X-Git-Url: https://svn.cri.ensmp.fr/git/linpy.git/blobdiff_plain/156db05a9a4c4e6d71a431fcc6343b973ca1d5ab..66e41ccd173874b3309e4c24be64c7b6b2ac6298:/pypol/linear.py diff --git a/pypol/linear.py b/pypol/linear.py index 8fdece9..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): @@ -355,7 +374,21 @@ class Constant(Expression): return bool(self.constant) def __repr__(self): - return '{}({!r})'.format(self.__class__.__name__, self._constant) + if self.constant.denominator == 1: + return '{}({!r})'.format(self.__class__.__name__, self.constant) + else: + 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): @@ -387,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() @@ -625,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(): @@ -633,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) @@ -696,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())