WIP: [py] Make single interface for polynomials

Author: pavel-fokin

.gitignore

@@ -3,3 +3,4 @@ catch.hpp
 __pycache__
 tags
 *.bak
+*.pyc

symbsat-py/symbsat/poly.py

@@ -53,13 +53,13 @@ def __str__(self):
     def copy(self):
         return Poly(self)
 
-    @classmethod
-    def zero(cls):
-        return cls([])
+    def zero(self):
+        class_ = type(self)
+        return class_([])
 
-    @classmethod
-    def one(cls):
-        return cls([Monom.one()])
+    def one(self):
+        class_ = type(self)
+        return class_([Monom.one()])
 
     def is_zero(self):
         return self == []

symbsat-py/symbsat/poly_new/__init__.py

@@ -0,0 +1 @@
+from .list import PolyList  # noqa

symbsat-py/symbsat/poly_new/base.py

@@ -0,0 +1,71 @@
+import abc
+
+
+class Poly(metaclass=abc.ABCMeta):
+    """Base class for boolean polynomials."""
+
+    def __init__(self, *, monoms=None, var=None, monom=None):
+        is_monoms = monoms is not None
+        is_var = var is not None
+        is_monom = monom is not None
+
+        # We want zero or one parameter
+        if [is_monoms, is_var, is_monom].count(True) > 1:
+            raise RuntimeError("Only one initialization parameter is allowed")
+
+        if is_monoms:
+            self._init_monoms(monoms)
+        elif is_var:
+            self._init_var(var)
+        elif is_monom:
+            self._init_monom(monom)
+        else:
+            raise NotImplementedError
+
+    @abc.abstractclassmethod
+    def make_zero(cls):
+        raise NotImplementedError
+
+    @abc.abstractclassmethod
+    def make_one(cls):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def _init_monoms(self, monoms):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def _init_var(self, var):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def _init_monom(self, monom):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __add__(self, other):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __mul__(self, other):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __str__(self):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def copy(self):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def is_zero(self):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def is_one(self):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def lm(self):
+        raise NotImplementedError

symbsat-py/symbsat/poly_new/list.py

@@ -0,0 +1,68 @@
+import collections
+import itertools
+import operator
+
+from symbsat.monom import Monom
+
+from .base import Poly
+
+
+class PolyList(Poly):
+
+    def _init_monoms(self, monoms):
+        self._list = sorted(monoms, reverse=True)
+
+    def _init_var(self, var):
+        self._list = [Monom(vars=[var])]
+
+    def _init_monom(self, monom):
+        self._list = [monom]
+
+    @classmethod
+    def make_zero(cls):
+        raise NotImplementedError
+
+    @classmethod
+    def make_one(cls):
+        raise NotImplementedError
+
+    def __add__(self, other):
+        # symmetric difference
+        if isinstance(other, Monom):
+            return PolyList(monoms=list(set(self) ^ set([other])))
+        if isinstance(other, PolyList):
+            return PolyList(monoms=list(set(self) ^ set(other)))
+        return NotImplemented
+
+    def __mul__(self, other):
+        if isinstance(other, Monom):
+            if self.is_zero() or other.is_zero():
+                return PolyList.make_zero()
+            monoms = map(lambda m: m*other, self)
+        elif isinstance(other, PolyList):
+            if self.is_zero() or other.is_zero():
+                return PolyList.make_zero()
+            monoms = itertools.starmap(
+                operator.mul,
+                (itertools.product(self, other))
+            )
+        else:
+            return NotImplemented
+
+        counter = collections.Counter(monoms)
+        return PolyList(monoms={m for m, c in counter.items() if c % 2 != 0})
+
+    def __str__(self):
+        raise NotImplementedError
+
+    def copy(self):
+        raise NotImplementedError
+
+    def is_zero(self):
+        raise NotImplementedError
+
+    def is_one(self):
+        raise NotImplementedError
+
+    def lm(self):
+        raise NotImplementedError

symbsat-py/symbsat/poly_new/zdd.py

@@ -0,0 +1,42 @@
+from .base import Poly
+
+
+class PolyZDD(Poly):
+
+    @classmethod
+    def make_zero(cls):
+        raise NotImplementedError
+
+    @classmethod
+    def make_one(cls):
+        raise NotImplementedError
+
+    def _init_monoms(self, monoms):
+        raise NotImplementedError
+
+    def _init_var(self, var):
+        raise NotImplementedError
+
+    def _init_monom(self, monom):
+        raise NotImplementedError
+
+    def __add__(self, other):
+        raise NotImplementedError
+
+    def __mul__(self, other):
+        raise NotImplementedError
+
+    def __str__(self):
+        raise NotImplementedError
+
+    def copy(self):
+        raise NotImplementedError
+
+    def is_zero(self):
+        raise NotImplementedError
+
+    def is_one(self):
+        raise NotImplementedError
+
+    def lm(self):
+        raise NotImplementedError

symbsat-py/tests/poly/test_poly_list.py

@@ -0,0 +1,28 @@
+import unittest
+
+from symbsat.monom import Monom4 as Monom
+from symbsat.poly_new import PolyList
+
+
+class BaseTest(unittest.TestCase):
+
+    def test_init_not_implemented(self):
+        with self.assertRaises(NotImplementedError):
+            self.poly_type()
+
+    def test_init_from_monoms(self):
+        monom_a = Monom(vars=[1])
+        monom_b = Monom(vars=[2])
+        self.poly_type(monoms=[monom_a, monom_b])
+
+
+class TestPolyList(BaseTest):
+
+    def setUp(self):
+        self.poly_type = PolyList
+
+
+def load_tests(loader, tests, pattern):
+    suite = unittest.TestSuite()
+    suite.addTest(TestPolyList())
+    return suite