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
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:
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):
+ if libisl.isl_basic_set_is_empty(islbset):
+ return Empty
+ if libisl.isl_basic_set_is_universe(islbset):
+ return Universe
islconstraints = islhelper.isl_basic_set_constraints(islbset)
equalities = []
inequalities = []
return domain
def __repr__(self):
- if self.isempty():
- return 'Empty'
- elif self.isuniverse():
- return 'Universe'
+ strings = []
+ for equality in self.equalities:
+ strings.append('Eq({}, 0)'.format(equality))
+ for inequality in self.inequalities:
+ strings.append('Ge({}, 0)'.format(inequality))
+ if len(strings) == 1:
+ return strings[0]
else:
- strings = []
- for equality in self.equalities:
- strings.append('Eq({}, 0)'.format(equality))
- for inequality in self.inequalities:
- strings.append('Ge({}, 0)'.format(inequality))
- if len(strings) == 1:
- return strings[0]
- else:
- return 'And({})'.format(', '.join(strings))
+ 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)
- 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
+ def _repr_latex_(self):
+ 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
return sympy.And(*constraints)
+class EmptyType(Polyhedron):
+
+ __slots__ = Polyhedron.__slots__
+
+ def __new__(cls):
+ self = object().__new__(cls)
+ self._equalities = (Rational(1),)
+ self._inequalities = ()
+ self._constraints = self._equalities
+ self._symbols = ()
+ self._dimension = 0
+ return self
+
+ def __repr__(self):
+ return 'Empty'
+
+ def _repr_latex_(self):
+ return '$$\\emptyset$$'
+
+Empty = EmptyType()
+
+
+class UniverseType(Polyhedron):
+
+ __slots__ = Polyhedron.__slots__
+
+ def __new__(cls):
+ self = object().__new__(cls)
+ self._equalities = ()
+ self._inequalities = ()
+ self._constraints = ()
+ self._symbols = ()
+ self._dimension = ()
+ return self
+
+ def __repr__(self):
+ return 'Universe'
+
+ def _repr_latex_(self):
+ return '$$\\Omega$$'
+
+Universe = UniverseType()
+
+
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])
-
-
-Empty = Eq(1, 0)
-
-Universe = Polyhedron([])
projects / linpy.git / blobdiff