X-Git-Url: https://scm.cri.ensmp.fr/git/linpy.git/blobdiff_plain/491b8f0501c7b3d8b7c33d85a430845d245da5c9..1d10c1b14b9544aba049dab42fff4b1224bb1640:/pypol/linear.py?ds=sidebyside diff --git a/pypol/linear.py b/pypol/linear.py index c169049..8e96f35 100644 --- a/pypol/linear.py +++ b/pypol/linear.py @@ -1,13 +1,12 @@ +import ctypes, ctypes.util 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')) +from . import isl +from .isl import libisl -libisl.isl_printer_get_str.restype = ctypes.c_char_p __all__ = [ 'Expression', @@ -18,8 +17,6 @@ __all__ = [ ] -_CONTEXT = isl.Context() - def _polymorphic_method(func): @functools.wraps(func) def wrapper(a, b): @@ -45,6 +42,9 @@ def _polymorphic_operator(func): return wrapper +_main_ctx = isl.Context() + + class Expression: """ This class implements linear expressions. @@ -94,6 +94,7 @@ class Expression: __getitem__ = coefficient + @property def coefficients(self): for symbol in self.symbols(): yield symbol, self.coefficient(symbol) @@ -115,7 +116,6 @@ class Expression: return self.coefficient(symbol) return int(self.constant) - def symbol(self): if not self.issymbol(): raise ValueError('not a symbol: {}'.format(self)) @@ -136,8 +136,8 @@ class Expression: @_polymorphic_method def __add__(self, other): - coefficients = dict(self.coefficients()) - for symbol, coefficient in other.coefficients(): + coefficients = dict(self.coefficients) + for symbol, coefficient in other.coefficients: if symbol in coefficients: coefficients[symbol] += coefficient else: @@ -149,8 +149,8 @@ class Expression: @_polymorphic_method def __sub__(self, other): - coefficients = dict(self.coefficients()) - for symbol, coefficient in other.coefficients(): + coefficients = dict(self.coefficients) + for symbol, coefficient in other.coefficients: if symbol in coefficients: coefficients[symbol] -= coefficient else: @@ -164,7 +164,7 @@ class Expression: @_polymorphic_method def __mul__(self, other): if other.isconstant(): - coefficients = dict(self.coefficients()) + coefficients = dict(self.coefficients) for symbol in coefficients: coefficients[symbol] *= other.constant constant = self.constant * other.constant @@ -247,7 +247,7 @@ class Expression: def __repr__(self): string = '{}({{'.format(self.__class__.__name__) - for i, (symbol, coefficient) in enumerate(self.coefficients()): + for i, (symbol, coefficient) in enumerate(self.coefficients): if i != 0: string += ', ' string += '{!r}: {!r}'.format(symbol, coefficient) @@ -280,19 +280,19 @@ class Expression: @_polymorphic_method def __le__(self, other): - return Polyhedron(inequalities=[(self - other)._canonify()]) + return Polyhedron(inequalities=[(other - self)._canonify()]) @_polymorphic_method def __lt__(self, other): - return Polyhedron(inequalities=[(self - other)._canonify() + 1]) + return Polyhedron(inequalities=[(other - self)._canonify() - 1]) @_polymorphic_method def __ge__(self, other): - return Polyhedron(inequalities=[(other - self)._canonify()]) + return Polyhedron(inequalities=[(self - other)._canonify()]) @_polymorphic_method def __gt__(self, other): - return Polyhedron(inequalities=[(other - self)._canonify() + 1]) + return Polyhedron(inequalities=[(self - other)._canonify() - 1]) def constant(numerator=0, denominator=None): @@ -359,11 +359,9 @@ class Polyhedron: if value.denominator != 1: raise TypeError('non-integer constraint: ' '{} <= 0'.format(constraint)) - self._inequalities.append(constraint) - self._bset = self.to_isl() - return self._bset - - + self._inequalities.append(constraint) + return self + @property def equalities(self): yield from self._equalities @@ -371,15 +369,14 @@ 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)) @@ -387,19 +384,12 @@ class Polyhedron: 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) - - def symbol_count(self): - s = [] - for constraint in self.constraints(): - s.append(constraint.symbols) - return s - + s.update(constraint.symbols()) + return sorted(s) + @property def dimension(self): return len(self.symbols()) @@ -410,7 +400,6 @@ class Polyhedron: return False else: return True - def __contains__(self, value): # is the value in the polyhedron? @@ -442,9 +431,9 @@ class Polyhedron: # test whether every element in other is in the polyhedron for value in other: if value == self.constraints(): - return True + return True else: - return False + return False raise NotImplementedError def __ge__(self, other): @@ -489,7 +478,7 @@ class Polyhedron: for constraint in self.equalities: constraints.append('{} == 0'.format(constraint)) for constraint in self.inequalities: - constraints.append('{} <= 0'.format(constraint)) + constraints.append('{} >= 0'.format(constraint)) return '{{{}}}'.format(', '.join(constraints)) def __repr__(self): @@ -501,56 +490,68 @@ 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) #self should be value - 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)) + + def _symbolunion(self, *others): + symbols = set(self.symbols()) + for other in others: + symbols.update(other.symbols()) + return sorted(symbols) + + def _to_isl(self, symbols=None): + if symbols is None: + symbols = self.symbols() + num_coefficients = len(symbols) + space = libisl.isl_space_set_alloc(_main_ctx, 0, num_coefficients) + bset = libisl.isl_basic_set_universe(libisl.isl_space_copy(space)) + ls = libisl.isl_local_space_from_space(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__ - print(dict_ex) - ''' - 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) - bset = libisl.isl_basic_set_project_out(bset, libisl.isl_set_dim, 1, 1); - 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 = libisl.isl_printer_print_basic_set(bset) - print('here') - print(bset) - print(self) - #print(string) + '''if there are equalities/inequalities, take each constant and coefficient and add as a constraint to the basic set''' + if list(self.equalities): #check if any equalities exist + for eq in self.equalities: + coeff_eq = dict(eq.coefficients) + if eq.constant: + value = eq.constant + ceq = libisl.isl_constraint_set_constant_si(ceq, value) + for eq in coeff_eq: + num = coeff_eq.get(eq) + iden = symbols.index(eq) + ceq = libisl.isl_constraint_set_coefficient_si(ceq, libisl.isl_dim_set, iden, num) #use 3 for type isl_dim_set + bset = libisl.isl_basic_set_add_constraint(bset, ceq) + if list(self.inequalities): #check if any inequalities exist + for ineq in self.inequalities: + coeff_in = dict(ineq.coefficients) + if ineq.constant: + value = ineq.constant + cin = libisl.isl_constraint_set_constant_si(cin, value) + for ineq in coeff_in: + num = coeff_in.get(ineq) + iden = symbols.index(ineq) + cin = libisl.isl_constraint_set_coefficient_si(cin, libisl.isl_dim_set, iden, num) #use 3 for type isl_dim_set + bset = libisl.isl_basic_set_add_constraint(bset, cin) + bset = isl.BasicSet(bset) return bset -empty = eq(1, 1) - - -universe = Polyhedron() + def from_isl(self, bset): + '''takes basic set in isl form and puts back into python version of polyhedron + isl example code gives isl form as: + "{[i] : exists (a : i = 2a and i >= 10 and i <= 42)}") + our printer is giving form as: + b'{ [i0] : 1 = 0 }' ''' + #bset = self + if self._equalities: + constraints = libisl.isl_basic_set_equalities_matrix(bset, 3) + elif self._inequalities: + constraints = libisl.isl_basic_set_inequalities_matrix(bset, 3) + print(constraints) + return constraints + +empty = None #eq(0,1) +universe = None #Polyhedron() + +if __name__ == '__main__': + ex1 = Expression(coefficients={'a': 1, 'x': 2}, constant=2) + ex2 = Expression(coefficients={'a': 3 , 'b': 2}, constant=3) + p = Polyhedron(inequalities=[ex1, ex2]) + bs = p._to_isl() + print(bs)