X-Git-Url: https://svn.cri.ensmp.fr/git/linpy.git/blobdiff_plain/d06ab92943ec2e10a2bd798ca7c1b5cea395bf34..843dede1d98c459f9761abff5877e0b019fa0155:/pypol/polyhedra.py?ds=inline diff --git a/pypol/polyhedra.py b/pypol/polyhedra.py index fa2a5c6..a5d9495 100644 --- a/pypol/polyhedra.py +++ b/pypol/polyhedra.py @@ -1,9 +1,11 @@ import functools +import math import numbers from . import islhelper from .islhelper import mainctx, libisl +from .geometry import GeometricObject, Point from .linexprs import Expression, Rational from .domains import Domain @@ -30,14 +32,10 @@ class Polyhedron(Domain): if inequalities is not None: raise TypeError('too many arguments') return cls.fromstring(equalities) - elif isinstance(equalities, Polyhedron): + elif isinstance(equalities, GeometricObject): if inequalities is not None: raise TypeError('too many arguments') - return equalities - elif isinstance(equalities, Domain): - if inequalities is not None: - raise TypeError('too many arguments') - return equalities.polyhedral_hull() + return equalities.aspolyhedron() if equalities is None: equalities = [] else: @@ -73,18 +71,47 @@ class Polyhedron(Domain): return self, def disjoint(self): + """ + Return this set as disjoint. + """ return self def isuniverse(self): + """ + Return true if this set is the Universe set. + """ islbset = self._toislbasicset(self.equalities, self.inequalities, self.symbols) universe = bool(libisl.isl_basic_set_is_universe(islbset)) libisl.isl_basic_set_free(islbset) return universe - def polyhedral_hull(self): + def aspolyhedron(self): + """ + Return polyhedral hull of this set. + """ return self + def __contains__(self, point): + if not isinstance(point, Point): + raise TypeError('point must be a Point instance') + if self.symbols != point.symbols: + raise ValueError('arguments must belong to the same space') + for equality in self.equalities: + if equality.subs(point.coordinates()) != 0: + return False + for inequality in self.inequalities: + if inequality.subs(point.coordinates()) < 0: + return False + return True + + def subs(self, symbol, expression=None): + equalities = [equality.subs(symbol, expression) + for equality in self.equalities] + inequalities = [inequality.subs(symbol, expression) + for inequality in self.inequalities] + return Polyhedron(equalities, inequalities) + @classmethod def _fromislbasicset(cls, islbset, symbols): islconstraints = islhelper.isl_basic_set_constraints(islbset) @@ -172,38 +199,25 @@ class Polyhedron(Domain): else: return 'And({})'.format(', '.join(strings)) - @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) + def _repr_latex_(self): + if self.isempty(): + return '$\\emptyset$' + elif self.isuniverse(): + return '$\\Omega$' 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 + strings = [] + for equality in self.equalities: + strings.append('{} = 0'.format(equality._repr_latex_().strip('$'))) + for inequality in self.inequalities: + strings.append('{} \\ge 0'.format(inequality._repr_latex_().strip('$'))) + return '${}$'.format(' \\wedge '.join(strings)) @classmethod def fromsympy(cls, expr): - import sympy - equalities, inequalities = cls._fromsympy(expr) - return cls(equalities, inequalities) + domain = Domain.fromsympy(expr) + if not isinstance(domain, Polyhedron): + raise ValueError('non-polyhedral expression: {!r}'.format(expr)) + return domain def tosympy(self): import sympy @@ -214,45 +228,64 @@ class Polyhedron(Domain): constraints.append(sympy.Ge(inequality.tosympy(), 0)) return sympy.And(*constraints) - def _polymorphic(func): @functools.wraps(func) def wrapper(left, right): - if isinstance(left, numbers.Rational): - left = Rational(left) - elif not isinstance(left, Expression): - raise TypeError('left must be a a rational number ' - 'or a linear expression') - if isinstance(right, numbers.Rational): - right = Rational(right) - elif not isinstance(right, Expression): - raise TypeError('right must be a a rational number ' - 'or a linear expression') + if not isinstance(left, Expression): + if isinstance(left, numbers.Rational): + left = Rational(left) + else: + raise TypeError('left must be a a rational number ' + 'or a linear expression') + if not isinstance(right, Expression): + if isinstance(right, numbers.Rational): + right = Rational(right) + else: + raise TypeError('right must be a a rational number ' + 'or a linear expression') return func(left, right) return wrapper @_polymorphic def Lt(left, right): + """ + Return true if the first set is less than the second. + """ return Polyhedron([], [right - left - 1]) @_polymorphic def Le(left, right): + """ + Return true the first set is less than or equal to the second. + """ return Polyhedron([], [right - left]) @_polymorphic def Eq(left, right): + """ + Return true if the sets are equal. + """ return Polyhedron([left - right], []) @_polymorphic def Ne(left, right): + """ + Return true if the sets are NOT equal. + """ return ~Eq(left, right) @_polymorphic def Gt(left, right): + """ + Return true if the first set is greater than the second set. + """ return Polyhedron([], [left - right - 1]) @_polymorphic def Ge(left, right): + """ + Return true if the first set is greater than or equal the second set. + """ return Polyhedron([], [left - right])