X-Git-Url: https://svn.cri.ensmp.fr/git/linpy.git/blobdiff_plain/288355579f9b2160e341e1d48910a66a0124ab04..0efaf62e3354a0663031bc16b53d9d8b597f50d0:/pypol/linear.py?ds=inline diff --git a/pypol/linear.py b/pypol/linear.py index 8f73fd3..8a61744 100644 --- a/pypol/linear.py +++ b/pypol/linear.py @@ -1,18 +1,19 @@ -import ctypes, ctypes.util +import ast import functools import numbers +import re from fractions import Fraction, gcd -from . import isl -from .isl import libisl +from pypol import isl +from pypol.isl import libisl __all__ = [ 'Expression', 'Constant', 'Symbol', 'symbols', 'eq', 'le', 'lt', 'ge', 'gt', 'Polyhedron', - 'empty', 'universe' + 'Empty', 'Universe' ] @@ -70,7 +71,7 @@ class Expression: self._coefficients = {} for symbol, coefficient in coefficients: if isinstance(symbol, Symbol): - symbol = str(symbol) + symbol = symbol.name elif not isinstance(symbol, str): raise TypeError('symbols must be strings or Symbol instances') if isinstance(coefficient, Constant): @@ -87,9 +88,40 @@ class Expression: self._dimension = len(self._symbols) return self + @classmethod + def _fromast(cls, node): + if isinstance(node, ast.Module): + assert len(node.body) == 1 + return cls._fromast(node.body[0]) + elif isinstance(node, ast.Expr): + return cls._fromast(node.value) + elif isinstance(node, ast.Name): + return Symbol(node.id) + elif isinstance(node, ast.Num): + return Constant(node.n) + elif isinstance(node, ast.UnaryOp): + if isinstance(node.op, ast.USub): + return -cls._fromast(node.operand) + elif isinstance(node, ast.BinOp): + left = cls._fromast(node.left) + right = cls._fromast(node.right) + if isinstance(node.op, ast.Add): + return left + right + elif isinstance(node.op, ast.Sub): + return left - right + elif isinstance(node.op, ast.Mult): + return left * right + elif isinstance(node.op, ast.Div): + return left / right + raise SyntaxError('invalid syntax') + @classmethod def fromstring(cls, string): - raise NotImplementedError + string = re.sub(r'(\d+|\))\s*([^\W\d_]\w*|\()', + lambda m: '{}*{}'.format(m.group(1), m.group(2)), + string) + tree = ast.parse(string, 'eval') + return cls._fromast(tree) @property def symbols(self): @@ -127,15 +159,11 @@ class Expression: yield self.coefficient(symbol) yield self.constant - @property - def symbol(self): - raise ValueError('not a symbol: {}'.format(self)) - def issymbol(self): return False def __bool__(self): - True + return True def __pos__(self): return self @@ -271,7 +299,7 @@ class Expression: self.constant == other.constant def __hash__(self): - return hash((self._coefficients, self._constant)) + return hash((tuple(sorted(self._coefficients.items())), self._constant)) def _toint(self): lcm = functools.reduce(lambda a, b: a*b // gcd(a, b), @@ -331,52 +359,52 @@ class Symbol(Expression): def __new__(cls, name): if isinstance(name, Symbol): - name = name.symbol + name = name.name elif not isinstance(name, str): raise TypeError('name must be a string or a Symbol instance') self = object().__new__(cls) self._coefficients = {name: 1} self._constant = 0 self._symbols = tuple(name) - self._symbol = name + self._name = name self._dimension = 1 return self @property - def symbol(self): - return self._symbol + def name(self): + return self._name def issymbol(self): return True def __repr__(self): - return '{}({!r})'.format(self.__class__.__name__, self._symbol) + return '{}({!r})'.format(self.__class__.__name__, self._name) def symbols(names): if isinstance(names, str): names = names.replace(',', ' ').split() - return (symbol(name) for name in names) + return (Symbol(name) for name in names) @_polymorphic_operator def eq(a, b): - return a._eq(b) + return a.__eq__(b) @_polymorphic_operator def le(a, b): - return a <= b + return a.__le__(b) @_polymorphic_operator def lt(a, b): - return a < b + return a.__lt__(b) @_polymorphic_operator def ge(a, b): - return a >= b + return a.__ge__(b) @_polymorphic_operator def gt(a, b): - return a > b + return a.__gt__(b) class Polyhedron: @@ -447,27 +475,42 @@ class Polyhedron: raise NotImplementedError def __eq__(self, other): - raise NotImplementedError + # works correctly when symbols is not passed + # should be equal if values are the same even if symbols are different + bset = self._toisl() + other = other._toisl() + return bool(libisl.isl_basic_set_plain_is_equal(bset, other)) def isempty(self): bset = self._toisl() return bool(libisl.isl_basic_set_is_empty(bset)) def isuniverse(self): - raise NotImplementedError + bset = self._toisl() + return bool(libisl.isl_basic_set_is_universe(bset)) def isdisjoint(self, other): # return true if the polyhedron has no elements in common with other - raise NotImplementedError + #symbols = self._symbolunion(other) + bset = self._toisl() + other = other._toisl() + return bool(libisl.isl_set_is_disjoint(bset, other)) def issubset(self, other): - raise NotImplementedError + # check if self(bset) is a subset of other + symbols = self._symbolunion(other) + bset = self._toisl(symbols) + other = other._toisl(symbols) + return bool(libisl.isl_set_is_strict_subset(other, bset)) def __le__(self, other): return self.issubset(other) def __lt__(self, other): - raise NotImplementedError + symbols = self._symbolunion(other) + bset = self._toisl(symbols) + other = other._toisl(symbols) + return bool(libisl.isl_set_is_strict_subset(other, bset)) def issuperset(self, other): # test whether every element in other is in the polyhedron @@ -477,6 +520,10 @@ class Polyhedron: return self.issuperset(other) def __gt__(self, other): + symbols = self._symbolunion(other) + bset = self._toisl(symbols) + other = other._toisl(symbols) + bool(libisl.isl_set_is_strict_subset(other, bset)) raise NotImplementedError def union(self, *others): @@ -502,10 +549,13 @@ class Polyhedron: def __and__(self, other): return self.intersection(other) - def difference(self, *others): - # return a new polyhedron with elements in the polyhedron that are not - # in the others - raise NotImplementedError + def difference(self, other): + # return a new polyhedron with elements in the polyhedron that are not in the other + symbols = self._symbolunion(other) + bset = self._toisl(symbols) + other = other._toisl(symbols) + difference = libisl.isl_set_subtract(bset, other) + return difference def __sub__(self, other): return self.difference(other) @@ -519,10 +569,15 @@ class Polyhedron: return '{{{}}}'.format(', '.join(constraints)) def __repr__(self): - equalities = list(self.equalities) - inequalities = list(self.inequalities) - return '{}(equalities={!r}, inequalities={!r})' \ - ''.format(self.__class__.__name__, equalities, inequalities) + if self.isempty(): + return 'Empty' + elif self.isuniverse(): + return 'Universe' + else: + equalities = list(self.equalities) + inequalities = list(self.inequalities) + return '{}(equalities={!r}, inequalities={!r})' \ + ''.format(self.__class__.__name__, equalities, inequalities) def _symbolunion(self, *others): symbols = set(self.symbols) @@ -533,40 +588,39 @@ class Polyhedron: def _toisl(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) + dimension = len(symbols) + space = libisl.isl_space_set_alloc(_main_ctx, 0, dimension) 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)) - '''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 + for equality in self.equalities: + ceq = libisl.isl_equality_alloc(libisl.isl_local_space_copy(ls)) + for symbol, coefficient in equality.coefficients(): + val = str(coefficient).encode() + val = libisl.isl_val_read_from_str(_main_ctx, val) + dim = symbols.index(symbol) + ceq = libisl.isl_constraint_set_coefficient_val(ceq, libisl.isl_dim_set, dim, val) + if equality.constant != 0: + val = str(equality.constant).encode() + val = libisl.isl_val_read_from_str(_main_ctx, val) + ceq = libisl.isl_constraint_set_constant_val(ceq, val) 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 + for inequality in self.inequalities: + cin = libisl.isl_inequality_alloc(libisl.isl_local_space_copy(ls)) + for symbol, coefficient in inequality.coefficients(): + val = str(coefficient).encode() + val = libisl.isl_val_read_from_str(_main_ctx, val) + dim = symbols.index(symbol) + cin = libisl.isl_constraint_set_coefficient_val(cin, libisl.isl_dim_set, dim, val) + if inequality.constant != 0: + val = str(ineq.constant).encode() + val = libisl.isl_val_read_from_str(_main_ctx, val) + cin = libisl.isl_constraint_set_constant_val(cin, val) bset = libisl.isl_basic_set_add_constraint(bset, cin) bset = isl.BasicSet(bset) return bset @classmethod - def _fromisl(cls, bset): + def _fromisl(cls, bset, symbols): raise NotImplementedError equalities = ... inequalities = ... @@ -575,24 +629,15 @@ class 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() + { [i0, i1] : 2i1 >= -2 - i0 } ''' +Empty = eq(0,1) +Universe = 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._toisl() - print(bs) - print('empty ?', p.isempty()) - print('empty ?', eq(0, 1).isempty()) + e1 = Expression('2a + 2b + 1') + p1 = Polyhedron(equalities=[e1]) # empty + e2 = Expression('3x + 2y + 3') + p2 = Polyhedron(equalities=[e2]) # not empty + print(p1._toisl()) + print(p2._toisl())