X-Git-Url: https://svn.cri.ensmp.fr/git/linpy.git/blobdiff_plain/ba15f3f33f837b1291f74bc94081e99b860d3228..4e408d8113221ec6ecbaabdeb24ba0710c5a417c:/linpy/polyhedra.py?ds=sidebyside diff --git a/linpy/polyhedra.py b/linpy/polyhedra.py index b486be1..fb2b4a7 100644 --- a/linpy/polyhedra.py +++ b/linpy/polyhedra.py @@ -44,7 +44,6 @@ class Polyhedron(Domain): __slots__ = ( '_equalities', '_inequalities', - '_constraints', '_symbols', '_dimension', ) @@ -88,22 +87,20 @@ class Polyhedron(Domain): if inequalities is not None: raise TypeError('too many arguments') return equalities.aspolyhedron() - if equalities is None: - equalities = [] - else: - for i, equality in enumerate(equalities): + sc_equalities = [] + if equalities is not None: + for equality in equalities: if not isinstance(equality, LinExpr): raise TypeError('equalities must be linear expressions') - equalities[i] = equality.scaleint() - if inequalities is None: - inequalities = [] - else: - for i, inequality in enumerate(inequalities): + sc_equalities.append(equality.scaleint()) + sc_inequalities = [] + if inequalities is not None: + for inequality in inequalities: if not isinstance(inequality, LinExpr): raise TypeError('inequalities must be linear expressions') - inequalities[i] = inequality.scaleint() - symbols = cls._xsymbols(equalities + inequalities) - islbset = cls._toislbasicset(equalities, inequalities, symbols) + sc_inequalities.append(inequality.scaleint()) + symbols = cls._xsymbols(sc_equalities + sc_inequalities) + islbset = cls._toislbasicset(sc_equalities, sc_inequalities, symbols) return cls._fromislbasicset(islbset, symbols) @property @@ -128,7 +125,7 @@ class Polyhedron(Domain): The tuple of constraints, i.e., equalities and inequalities. This is semantically equivalent to: equalities + inequalities. """ - return self._constraints + return self._equalities + self._inequalities @property def polyhedra(self): @@ -176,6 +173,9 @@ class Polyhedron(Domain): def widen(self, other): """ Compute the standard widening of two polyhedra, à la Halbwachs. + + In its current implementation, this method is slow and should not be + used on large polyhedra. """ if not isinstance(other, Polyhedron): raise ValueError('argument must be a Polyhedron instance') @@ -219,8 +219,7 @@ class Polyhedron(Domain): self = object().__new__(Polyhedron) self._equalities = tuple(equalities) self._inequalities = tuple(inequalities) - self._constraints = tuple(equalities + inequalities) - self._symbols = cls._xsymbols(self._constraints) + self._symbols = cls._xsymbols(self.constraints) self._dimension = len(self._symbols) return self @@ -307,13 +306,10 @@ class EmptyType(Polyhedron): The empty polyhedron, whose set of constraints is not satisfiable. """ - __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 @@ -338,13 +334,10 @@ class UniverseType(Polyhedron): i.e. is empty. """ - __slots__ = Polyhedron.__slots__ - def __new__(cls): self = object().__new__(cls) self._equalities = () self._inequalities = () - self._constraints = () self._symbols = () self._dimension = () return self @@ -406,15 +399,15 @@ def Ne(left, right): return ~Eq(left, right) @_polymorphic -def Gt(left, right): +def Ge(left, right): """ - Create the polyhedron with constraints expr1 > expr2 > expr3 ... + Create the polyhedron with constraints expr1 >= expr2 >= expr3 ... """ - return Polyhedron([], [left - right - 1]) + return Polyhedron([], [left - right]) @_polymorphic -def Ge(left, right): +def Gt(left, right): """ - Create the polyhedron with constraints expr1 >= expr2 >= expr3 ... + Create the polyhedron with constraints expr1 > expr2 > expr3 ... """ - return Polyhedron([], [left - right]) + return Polyhedron([], [left - right - 1])