X-Git-Url: https://scm.cri.ensmp.fr/git/linpy.git/blobdiff_plain/3b1b3560c8880ef25995a18b6e365e0d730a2df2..288355579f9b2160e341e1d48910a66a0124ab04:/pypol/linear.py diff --git a/pypol/linear.py b/pypol/linear.py index 8e96f35..8f73fd3 100644 --- a/pypol/linear.py +++ b/pypol/linear.py @@ -9,8 +9,7 @@ from .isl import libisl __all__ = [ - 'Expression', - 'constant', 'symbol', 'symbols', + 'Expression', 'Constant', 'Symbol', 'symbols', 'eq', 'le', 'lt', 'ge', 'gt', 'Polyhedron', 'empty', 'universe' @@ -23,7 +22,7 @@ def _polymorphic_method(func): if isinstance(b, Expression): return func(a, b) if isinstance(b, numbers.Rational): - b = constant(b) + b = Constant(b) return func(a, b) return NotImplemented return wrapper @@ -34,7 +33,7 @@ def _polymorphic_operator(func): @functools.wraps(func) def wrapper(a, b): if isinstance(a, numbers.Rational): - a = constant(a) + a = Constant(a) return func(a, b) elif isinstance(a, Expression): return func(a, b) @@ -55,38 +54,56 @@ class Expression: if constant: raise TypeError('too many arguments') return cls.fromstring(coefficients) - self = super().__new__(cls) - self._coefficients = {} if isinstance(coefficients, dict): coefficients = coefficients.items() - if coefficients is not None: - for symbol, coefficient in coefficients: - if isinstance(symbol, Expression) and symbol.issymbol(): - symbol = str(symbol) - elif not isinstance(symbol, str): - raise TypeError('symbols must be strings') - if not isinstance(coefficient, numbers.Rational): - raise TypeError('coefficients must be rational numbers') - if coefficient != 0: - self._coefficients[symbol] = coefficient + if coefficients is None: + return Constant(constant) + coefficients = [(symbol, coefficient) + for symbol, coefficient in coefficients if coefficient != 0] + if len(coefficients) == 0: + return Constant(constant) + elif len(coefficients) == 1 and constant == 0: + symbol, coefficient = coefficients[0] + if coefficient == 1: + return Symbol(symbol) + self = object().__new__(cls) + self._coefficients = {} + for symbol, coefficient in coefficients: + if isinstance(symbol, Symbol): + symbol = str(symbol) + elif not isinstance(symbol, str): + raise TypeError('symbols must be strings or Symbol instances') + if isinstance(coefficient, Constant): + coefficient = coefficient.constant + if not isinstance(coefficient, numbers.Rational): + raise TypeError('coefficients must be rational numbers or Constant instances') + self._coefficients[symbol] = coefficient + if isinstance(constant, Constant): + constant = constant.constant if not isinstance(constant, numbers.Rational): - raise TypeError('constant must be a rational number') + raise TypeError('constant must be a rational number or a Constant instance') self._constant = constant + self._symbols = tuple(sorted(self._coefficients)) + self._dimension = len(self._symbols) return self + @classmethod + def fromstring(cls, string): + raise NotImplementedError + @property def symbols(self): - yield from sorted(self._coefficients) + return self._symbols @property def dimension(self): - return len(list(self.symbols())) + return self._dimension def coefficient(self, symbol): - if isinstance(symbol, Expression) and symbol.issymbol(): + if isinstance(symbol, Symbol): symbol = str(symbol) elif not isinstance(symbol, str): - raise TypeError('symbol must be a string') + raise TypeError('symbol must be a string or a Symbol instance') try: return self._coefficients[symbol] except KeyError: @@ -94,9 +111,8 @@ class Expression: __getitem__ = coefficient - @property def coefficients(self): - for symbol in self.symbols(): + for symbol in self.symbols: yield symbol, self.coefficient(symbol) @property @@ -104,29 +120,22 @@ class Expression: return self._constant def isconstant(self): - return len(self._coefficients) == 0 + return False def values(self): - for symbol in self.symbols(): + for symbol in self.symbols: yield self.coefficient(symbol) yield self.constant - def values_int(self): - for symbol in self.symbols(): - return self.coefficient(symbol) - return int(self.constant) - + @property def symbol(self): - if not self.issymbol(): - raise ValueError('not a symbol: {}'.format(self)) - for symbol in self.symbols(): - return symbol + raise ValueError('not a symbol: {}'.format(self)) def issymbol(self): - return len(self._coefficients) == 1 and self._constant == 0 + return False def __bool__(self): - return (not self.isconstant()) or bool(self.constant) + True def __pos__(self): return self @@ -136,8 +145,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 +158,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 +173,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 @@ -202,10 +211,9 @@ class Expression: def __str__(self): string = '' - symbols = sorted(self.symbols()) i = 0 - for symbol in symbols: - coefficient = self[symbol] + for symbol in self.symbols: + coefficient = self.coefficient(symbol) if coefficient == 1: if i == 0: string += symbol @@ -247,17 +255,13 @@ 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) string += '}}, {!r})'.format(self.constant) return string - @classmethod - def fromstring(cls, string): - raise NotImplementedError - @_polymorphic_method def __eq__(self, other): # "normal" equality @@ -269,42 +273,84 @@ class Expression: def __hash__(self): return hash((self._coefficients, self._constant)) - def _canonify(self): + def _toint(self): lcm = functools.reduce(lambda a, b: a*b // gcd(a, b), [value.denominator for value in self.values()]) return self * lcm @_polymorphic_method def _eq(self, other): - return Polyhedron(equalities=[(self - other)._canonify()]) + return Polyhedron(equalities=[(self - other)._toint()]) @_polymorphic_method def __le__(self, other): - return Polyhedron(inequalities=[(other - self)._canonify()]) + return Polyhedron(inequalities=[(other - self)._toint()]) @_polymorphic_method def __lt__(self, other): - return Polyhedron(inequalities=[(other - self)._canonify() - 1]) + return Polyhedron(inequalities=[(other - self)._toint() - 1]) @_polymorphic_method def __ge__(self, other): - return Polyhedron(inequalities=[(self - other)._canonify()]) + return Polyhedron(inequalities=[(self - other)._toint()]) @_polymorphic_method def __gt__(self, other): - return Polyhedron(inequalities=[(self - other)._canonify() - 1]) + return Polyhedron(inequalities=[(self - other)._toint() - 1]) + + +class Constant(Expression): + + def __new__(cls, numerator=0, denominator=None): + self = object().__new__(cls) + if denominator is None: + if isinstance(numerator, numbers.Rational): + self._constant = numerator + elif isinstance(numerator, Constant): + self._constant = numerator.constant + else: + raise TypeError('constant must be a rational number or a Constant instance') + else: + self._constant = Fraction(numerator, denominator) + self._coefficients = {} + self._symbols = () + self._dimension = 0 + return self + def isconstant(self): + return True -def constant(numerator=0, denominator=None): - if denominator is None and isinstance(numerator, numbers.Rational): - return Expression(constant=numerator) - else: - return Expression(constant=Fraction(numerator, denominator)) + def __bool__(self): + return bool(self.constant) -def symbol(name): - if not isinstance(name, str): - raise TypeError('name must be a string') - return Expression(coefficients={name: 1}) + def __repr__(self): + return '{}({!r})'.format(self.__class__.__name__, self._constant) + + +class Symbol(Expression): + + def __new__(cls, name): + if isinstance(name, Symbol): + name = name.symbol + 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._dimension = 1 + return self + + @property + def symbol(self): + return self._symbol + + def issymbol(self): + return True + + def __repr__(self): + return '{}({!r})'.format(self.__class__.__name__, self._symbol) def symbols(names): if isinstance(names, str): @@ -352,6 +398,7 @@ class Polyhedron: raise TypeError('non-integer constraint: ' '{} == 0'.format(constraint)) self._equalities.append(constraint) + self._equalities = tuple(self._equalities) self._inequalities = [] if inequalities is not None: for constraint in inequalities: @@ -360,46 +407,40 @@ class Polyhedron: raise TypeError('non-integer constraint: ' '{} <= 0'.format(constraint)) self._inequalities.append(constraint) + self._inequalities = tuple(self._inequalities) + self._constraints = self._equalities + self._inequalities + self._symbols = set() + for constraint in self._constraints: + self.symbols.update(constraint.symbols) + self._symbols = tuple(sorted(self._symbols)) return self + @classmethod + def fromstring(cls, string): + raise NotImplementedError + @property def equalities(self): - yield from self._equalities + return self._equalities @property def inequalities(self): - yield from self._inequalities + return 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 + return self._constraints + @property def symbols(self): - s = set() - for constraint in self.constraints(): - s.update(constraint.symbols()) - return sorted(s) + return self._symbols @property def dimension(self): - return len(self.symbols()) + return len(self.symbols) def __bool__(self): - # return false if the polyhedron is empty, true otherwise - if self._equalities or self._inequalities: - return False - else: - return True + return not self.is_empty() def __contains__(self, value): # is the value in the polyhedron? @@ -408,11 +449,12 @@ class Polyhedron: def __eq__(self, other): raise NotImplementedError - def is_empty(self): - return + def isempty(self): + bset = self._toisl() + return bool(libisl.isl_basic_set_is_empty(bset)) def isuniverse(self): - return self == universe + raise NotImplementedError def isdisjoint(self, other): # return true if the polyhedron has no elements in common with other @@ -429,11 +471,6 @@ 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): @@ -487,19 +524,15 @@ class Polyhedron: return '{}(equalities={!r}, inequalities={!r})' \ ''.format(self.__class__.__name__, equalities, inequalities) - @classmethod - def fromstring(cls, string): - raise NotImplementedError - def _symbolunion(self, *others): - symbols = set(self.symbols()) + symbols = set(self.symbols) for other in others: - symbols.update(other.symbols()) + symbols.update(other.symbols) return sorted(symbols) - def _to_isl(self, symbols=None): + def _toisl(self, symbols=None): if symbols is None: - symbols = self.symbols() + 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)) @@ -509,7 +542,7 @@ class Polyhedron: '''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) + coeff_eq = dict(eq.coefficients()) if eq.constant: value = eq.constant ceq = libisl.isl_constraint_set_constant_si(ceq, value) @@ -520,7 +553,7 @@ class Polyhedron: 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) + coeff_in = dict(ineq.coefficients()) if ineq.constant: value = ineq.constant cin = libisl.isl_constraint_set_constant_si(cin, value) @@ -532,26 +565,34 @@ class Polyhedron: bset = isl.BasicSet(bset) return bset - def from_isl(self, bset): - '''takes basic set in isl form and puts back into python version of polyhedron + @classmethod + def _fromisl(cls, bset): + raise NotImplementedError + equalities = ... + inequalities = ... + return cls(equalities, inequalities) + '''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 + # 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() + bs = p._toisl() print(bs) + print('empty ?', p.isempty()) + print('empty ?', eq(0, 1).isempty())