X-Git-Url: https://scm.cri.ensmp.fr/git/linpy.git/blobdiff_plain/844f76f670a227d335e9bc539e1a61be7161452a..2849330c65ff7bbc0bfefddf0f062fce51bde7b9:/pypol/linear.py diff --git a/pypol/linear.py b/pypol/linear.py index 6550e92..2b064d4 100644 --- a/pypol/linear.py +++ b/pypol/linear.py @@ -1,9 +1,13 @@ - import functools import numbers +import ctypes, ctypes.util +from pypol import isl from fractions import Fraction, gcd +libisl = ctypes.CDLL(ctypes.util.find_library('isl')) + +libisl.isl_printer_get_str.restype = ctypes.c_char_p __all__ = [ 'Expression', @@ -14,6 +18,33 @@ __all__ = [ ] +_CONTEXT = isl.Context() + +def _polymorphic_method(func): + @functools.wraps(func) + def wrapper(a, b): + if isinstance(b, Expression): + return func(a, b) + if isinstance(b, numbers.Rational): + b = constant(b) + return func(a, b) + return NotImplemented + return wrapper + +def _polymorphic_operator(func): + # A polymorphic operator should call a polymorphic method, hence we just + # have to test the left operand. + @functools.wraps(func) + def wrapper(a, b): + if isinstance(a, numbers.Rational): + a = constant(a) + return func(a, b) + elif isinstance(a, Expression): + return func(a, b) + raise TypeError('arguments must be linear expressions') + return wrapper + + class Expression: """ This class implements linear expressions. @@ -43,6 +74,7 @@ class Expression: self._constant = constant return self + def symbols(self): yield from sorted(self._coefficients) @@ -78,6 +110,12 @@ class Expression: yield self.coefficient(symbol) yield self.constant + def values_int(self): + for symbol in self.symbols(): + return self.coefficient(symbol) + return int(self.constant) + + def symbol(self): if not self.issymbol(): raise ValueError('not a symbol: {}'.format(self)) @@ -96,18 +134,7 @@ class Expression: def __neg__(self): return self * -1 - def _polymorphic(func): - @functools.wraps(func) - def wrapper(self, other): - if isinstance(other, Expression): - return func(self, other) - if isinstance(other, numbers.Rational): - other = Expression(constant=other) - return func(self, other) - return NotImplemented - return wrapper - - @_polymorphic + @_polymorphic_method def __add__(self, other): coefficients = dict(self.coefficients()) for symbol, coefficient in other.coefficients(): @@ -120,7 +147,7 @@ class Expression: __radd__ = __add__ - @_polymorphic + @_polymorphic_method def __sub__(self, other): coefficients = dict(self.coefficients()) for symbol, coefficient in other.coefficients(): @@ -133,7 +160,7 @@ class Expression: __rsub__ = __sub__ - @_polymorphic + @_polymorphic_method def __mul__(self, other): if other.isconstant(): coefficients = dict(self.coefficients()) @@ -148,7 +175,7 @@ class Expression: __rmul__ = __mul__ - @_polymorphic + @_polymorphic_method def __truediv__(self, other): if other.isconstant(): coefficients = dict(self.coefficients()) @@ -163,7 +190,7 @@ class Expression: return NotImplemented def __rtruediv__(self, other): - if isinstance(other, Rational): + if isinstance(other, self): if self.isconstant(): constant = Fraction(other, self.constant) return Expression(constant=constant) @@ -230,7 +257,7 @@ class Expression: def fromstring(cls, string): raise NotImplementedError - @_polymorphic + @_polymorphic_method def __eq__(self, other): # "normal" equality # see http://docs.sympy.org/dev/tutorial/gotchas.html#equals-signs @@ -246,29 +273,32 @@ class Expression: [value.denominator for value in self.values()]) return self * lcm - @_polymorphic + @_polymorphic_method def _eq(self, other): return Polyhedron(equalities=[(self - other)._canonify()]) - @_polymorphic + @_polymorphic_method def __le__(self, other): return Polyhedron(inequalities=[(self - other)._canonify()]) - @_polymorphic + @_polymorphic_method def __lt__(self, other): return Polyhedron(inequalities=[(self - other)._canonify() + 1]) - @_polymorphic + @_polymorphic_method def __ge__(self, other): return Polyhedron(inequalities=[(other - self)._canonify()]) - @_polymorphic + @_polymorphic_method def __gt__(self, other): return Polyhedron(inequalities=[(other - self)._canonify() + 1]) def constant(numerator=0, denominator=None): - return Expression(constant=Fraction(numerator, denominator)) + if denominator is None and isinstance(numerator, numbers.Rational): + return Expression(constant=numerator) + else: + return Expression(constant=Fraction(numerator, denominator)) def symbol(name): if not isinstance(name, str): @@ -281,35 +311,23 @@ def symbols(names): return (symbol(name) for name in names) -def _operator(func): - @functools.wraps(func) - def wrapper(a, b): - if isinstance(a, numbers.Rational): - a = constant(a) - if isinstance(b, numbers.Rational): - b = constant(b) - if isinstance(a, Expression) and isinstance(b, Expression): - return func(a, b) - raise TypeError('arguments must be linear expressions') - return wrapper - -@_operator +@_polymorphic_operator def eq(a, b): return a._eq(b) -@_operator +@_polymorphic_operator def le(a, b): return a <= b -@_operator +@_polymorphic_operator def lt(a, b): return a < b -@_operator +@_polymorphic_operator def ge(a, b): return a >= b -@_operator +@_polymorphic_operator def gt(a, b): return a > b @@ -340,9 +358,14 @@ class Polyhedron: if value.denominator != 1: raise TypeError('non-integer constraint: ' '{} <= 0'.format(constraint)) - self._inequalities.append(constraint) - return self - + self._inequalities.append(constraint) + print('in polyhedron') + #print(self.constraints()) + self._bset = self.to_isl() + #print(self._bset) + return self + + @property def equalities(self): yield from self._equalities @@ -350,24 +373,47 @@ class Polyhedron: @property def inequalities(self): yield from self._inequalities + + @property + def constant(self): + return self._constant + + def isconstant(self): + return len(self._coefficients) == 0 + + + def isempty(self): + return bool(libisl.isl_basic_set_is_empty(self._bset)) def constraints(self): yield from self.equalities yield from self.inequalities + def symbols(self): s = set() for constraint in self.constraints(): s.update(constraint.symbols) - yield from sorted(s) - + yield from sorted(s) + + def symbol_count(self): + s = [] + for constraint in self.constraints(): + s.append(constraint.symbols) + print(s) + return s + @property def dimension(self): return len(self.symbols()) def __bool__(self): # return false if the polyhedron is empty, true otherwise - raise NotImplementedError + if self._equalities or self._inequalities: + return False + else: + return True + def __contains__(self, value): # is the value in the polyhedron? @@ -376,8 +422,8 @@ class Polyhedron: def __eq__(self, other): raise NotImplementedError - def isempty(self): - return self == empty + def is_empty(self): + return def isuniverse(self): return self == universe @@ -397,6 +443,11 @@ class Polyhedron: def issuperset(self, other): # test whether every element in other is in the polyhedron + for value in other: + if value == self.constraints(): + return True + else: + return False raise NotImplementedError def __ge__(self, other): @@ -453,8 +504,54 @@ class Polyhedron: @classmethod def fromstring(cls, string): raise NotImplementedError + + def printer(self): + + ip = libisl.isl_printer_to_str(_CONTEXT) + ip = libisl.isl_printer_print_val(ip, self) + string = libisl.isl_printer_get_str(ip).decode() + print(string) + return string + + + def to_isl(self): + space = libisl.isl_space_set_alloc(_CONTEXT, 0, len(self.symbol_count())) + bset = libisl.isl_basic_set_empty(libisl.isl_space_copy(space)) + ls = libisl.isl_local_space_from_space(libisl.isl_space_copy(space)) + ceq = libisl.isl_equality_alloc(libisl.isl_local_space_copy(ls)) + cin = libisl.isl_inequality_alloc(libisl.isl_local_space_copy(ls)) + dict_ex = Expression().__dict__ + ''' + if there are equalities/inequalities, take each constant and coefficient and add as a constraint to the basic set + need to change the symbols method to a lookup table for the integer value for each letter that could be a symbol + ''' + if self.equalities: + for _constant in dict_ex: + value = dict_ex.get('_constant') + ceq = libisl.isl_constraint_set_constant_val(ceq, value) + for _coefficients in dict_ex: + value_co = dict_ex.get('_coefficients') + if value_co: + ceq = libisl.isl_constraint_set_coefficient_si(ceq, libisl.isl_set_dim, self.symbols(), value_co) + bset = libisl.isl_set_add_constraint(bset, ceq) + + elif self.inequalities: + for _constant in dict_ex: + value = dict_ex.get('_constant') + cin = libisl.isl_constraint_set_constant_val(cin, value) + for _coefficients in dict_ex: + value_co = dict_ex.get('_coefficients') + if value_co: + cin = libisl.isl_constraint_set_coefficient_si(cin, libisl.isl_set_dim, self.symbols(), value_co) + bset = libisl.isl_set_add_contraint(bset, cin) + string = self.printer() + #string = libisl.isl_printer_print_basic_set(bset) + print('here') + print(string) + print(self) + return string +empty = eq(1, 1) -empty = le(1, 0) universe = Polyhedron()