X-Git-Url: https://svn.cri.ensmp.fr/git/linpy.git/blobdiff_plain/9e103619134c8839d143951c5b814bab500fcdcf..66e41ccd173874b3309e4c24be64c7b6b2ac6298:/pypol/linear.py?ds=sidebyside

diff --git a/pypol/linear.py b/pypol/linear.py
index e6d442e..b40415f 100644
--- a/pypol/linear.py
+++ b/pypol/linear.py
@@ -5,8 +5,8 @@ import re
 
 from fractions import Fraction, gcd
 
-from pypol import isl
-from pypol.isl import libisl
+from . import isl
+from .isl import libisl
 
 
 __all__ = [
@@ -285,13 +285,7 @@ class Expression:
             return '({})'.format(string)
 
     def __repr__(self):
-        string = '{}({{'.format(self.__class__.__name__)
-        for i, (symbol, coefficient) in enumerate(self.coefficients()):
-            if i != 0:
-                string += ', '
-            string += '{!r}: {!r}'.format(symbol, coefficient)
-        string += '}}, {!r})'.format(self.constant)
-        return string
+        return '{}({!r})'.format(self.__class__.__name__, str(self))
 
     @_polymorphic_method
     def __eq__(self, other):
@@ -329,6 +323,31 @@ class Expression:
     def __gt__(self, other):
         return Polyhedron(inequalities=[(self - other)._toint() - 1])
 
+    @classmethod
+    def fromsympy(cls, expr):
+        import sympy
+        coefficients = {}
+        constant = 0
+        for symbol, coefficient in expr.as_coefficients_dict().items():
+            coefficient = Fraction(coefficient.p, coefficient.q)
+            if symbol == sympy.S.One:
+                constant = coefficient
+            elif isinstance(symbol, sympy.Symbol):
+                symbol = symbol.name
+                coefficients[symbol] = coefficient
+            else:
+                raise ValueError('non-linear expression: {!r}'.format(expr))
+        return cls(coefficients, constant)
+
+    def tosympy(self):
+        import sympy
+        expr = 0
+        for symbol, coefficient in self.coefficients():
+            term = coefficient * sympy.Symbol(symbol)
+            expr += term
+        expr += self.constant
+        return expr
+
 
 class Constant(Expression):
 
@@ -361,6 +380,17 @@ class Constant(Expression):
             return '{}({!r}, {!r})'.format(self.__class__.__name__,
                 self.constant.numerator, self.constant.denominator)
 
+    @classmethod
+    def fromsympy(cls, expr):
+        import sympy
+        if isinstance(expr, sympy.Rational):
+            return cls(expr.p, expr.q)
+        elif isinstance(expr, numbers.Rational):
+            return cls(expr)
+        else:
+            raise TypeError('expr must be a sympy.Rational instance')
+
+
 class Symbol(Expression):
 
     __slots__ = Expression.__slots__ + (
@@ -390,6 +420,15 @@ class Symbol(Expression):
     def __repr__(self):
         return '{}({!r})'.format(self.__class__.__name__, self._name)
 
+    @classmethod
+    def fromsympy(cls, expr):
+        import sympy
+        if isinstance(expr, sympy.Symbol):
+            return cls(expr.name)
+        else:
+            raise TypeError('expr must be a sympy.Symbol instance')
+
+
 def symbols(names):
     if isinstance(names, str):
         names = names.replace(',', ' ').split()
@@ -628,7 +667,7 @@ class Polyhedron:
             constraints.append('{} == 0'.format(constraint))
         for constraint in self.inequalities:
             constraints.append('{} >= 0'.format(constraint))
-        return '{{{}}}'.format(', '.join(constraints))
+        return '{}'.format(', '.join(constraints))
 
     def __repr__(self):
         if self.isempty():
@@ -636,10 +675,49 @@ class Polyhedron:
         elif self.isuniverse():
             return 'Universe'
         else:
-            equalities = list(self.equalities)
-            inequalities = list(self.inequalities)
-            return '{}(equalities={!r}, inequalities={!r})' \
-                    ''.format(self.__class__.__name__, equalities, inequalities)
+            return '{}({!r})'.format(self.__class__.__name__, str(self))
+
+    @classmethod
+    def _fromsympy(cls, expr):
+        import sympy
+        equalities = []
+        inequalities = []
+        if expr.func == sympy.And:
+            for arg in expr.args:
+                arg_eqs, arg_ins = cls._fromsympy(arg)
+                equalities.extend(arg_eqs)
+                inequalities.extend(arg_ins)
+        elif expr.func == sympy.Eq:
+            expr = Expression.fromsympy(expr.args[0] - expr.args[1])
+            equalities.append(expr)
+        else:
+            if expr.func == sympy.Lt:
+                expr = Expression.fromsympy(expr.args[1] - expr.args[0] - 1)
+            elif expr.func == sympy.Le:
+                expr = Expression.fromsympy(expr.args[1] - expr.args[0])
+            elif expr.func == sympy.Ge:
+                expr = Expression.fromsympy(expr.args[0] - expr.args[1])
+            elif expr.func == sympy.Gt:
+                expr = Expression.fromsympy(expr.args[0] - expr.args[1] - 1)
+            else:
+                raise ValueError('non-polyhedral expression: {!r}'.format(expr))
+            inequalities.append(expr)
+        return equalities, inequalities
+
+    @classmethod
+    def fromsympy(cls, expr):
+        import sympy
+        equalities, inequalities = cls._fromsympy(expr)
+        return cls(equalities, inequalities)
+
+    def tosympy(self):
+        import sympy
+        constraints = []
+        for equality in self.equalities:
+            constraints.append(sympy.Eq(equality.tosympy(), 0))
+        for inequality in self.inequalities:
+            constraints.append(sympy.Ge(inequality.tosympy(), 0))
+        return sympy.And(*constraints)
 
     def _symbolunion(self, *others):
         symbols = set(self.symbols)
@@ -699,7 +777,8 @@ Universe = Polyhedron()
 
 
 if __name__ == '__main__':
-    p1 = Polyhedron('2a + 2b + 1 == 0') # empty
-    print(p1._toisl())
-    p2 = Polyhedron('3x + 2y + 3 == 0') # not empty
-    print(p2._toisl())
+    #p = Polyhedron('2a + 2b + 1 == 0') # empty
+    p = Polyhedron('3x + 2y + 3 == 0, y == 0') # not empty
+    ip = p._toisl()
+    print(ip)
+    print(ip.constraints())