X-Git-Url: https://scm.cri.ensmp.fr/git/linpy.git/blobdiff_plain/ce545ffab9494e0c8250a8880859b6b097ed544d..ba567519bac2c8a170defbc2275088f31cf8ccdd:/pypol/linexprs.py?ds=inline diff --git a/pypol/linexprs.py b/pypol/linexprs.py index 73c6b0e..c5f4336 100644 --- a/pypol/linexprs.py +++ b/pypol/linexprs.py @@ -3,13 +3,13 @@ import functools import numbers import re -from collections import OrderedDict, defaultdict +from collections import OrderedDict, defaultdict, Mapping from fractions import Fraction, gcd __all__ = [ 'Expression', - 'Symbol', 'symbols', + 'Symbol', 'Dummy', 'symbols', 'Rational', ] @@ -31,49 +31,35 @@ class Expression: This class implements linear expressions. """ - __slots__ = ( - '_coefficients', - '_constant', - '_symbols', - '_dimension', - ) - def __new__(cls, coefficients=None, constant=0): if isinstance(coefficients, str): - if constant: + if constant != 0: raise TypeError('too many arguments') return Expression.fromstring(coefficients) if coefficients is None: return Rational(constant) - if isinstance(coefficients, dict): + if isinstance(coefficients, Mapping): coefficients = coefficients.items() + coefficients = list(coefficients) for symbol, coefficient in coefficients: if not isinstance(symbol, Symbol): raise TypeError('symbols must be Symbol instances') - coefficients = [(symbol, coefficient) - for symbol, coefficient in coefficients if coefficient != 0] + if not isinstance(coefficient, numbers.Rational): + raise TypeError('coefficients must be rational numbers') + if not isinstance(constant, numbers.Rational): + raise TypeError('constant must be a rational number') if len(coefficients) == 0: return Rational(constant) if len(coefficients) == 1 and constant == 0: symbol, coefficient = coefficients[0] if coefficient == 1: return symbol + coefficients = [(symbol, Fraction(coefficient)) + for symbol, coefficient in coefficients if coefficient != 0] + coefficients.sort(key=lambda item: item[0].sortkey()) self = object().__new__(cls) - self._coefficients = OrderedDict() - for symbol, coefficient in sorted(coefficients, - key=lambda item: item[0].sortkey()): - if isinstance(coefficient, Rational): - coefficient = coefficient.constant - if not isinstance(coefficient, numbers.Rational): - raise TypeError('coefficients must be rational numbers ' - 'or Rational instances') - self._coefficients[symbol] = coefficient - if isinstance(constant, Rational): - constant = constant.constant - if not isinstance(constant, numbers.Rational): - raise TypeError('constant must be a rational number ' - 'or a Rational instance') - self._constant = constant + self._coefficients = OrderedDict(coefficients) + self._constant = Fraction(constant) self._symbols = tuple(self._coefficients) self._dimension = len(self._symbols) return self @@ -81,19 +67,17 @@ class Expression: def coefficient(self, symbol): if not isinstance(symbol, Symbol): raise TypeError('symbol must be a Symbol instance') - try: - return self._coefficients[symbol] - except KeyError: - return 0 + return Rational(self._coefficients.get(symbol, 0)) __getitem__ = coefficient def coefficients(self): - yield from self._coefficients.items() + for symbol, coefficient in self._coefficients.items(): + yield symbol, Rational(coefficient) @property def constant(self): - return self._constant + return Rational(self._constant) @property def symbols(self): @@ -113,8 +97,9 @@ class Expression: return False def values(self): - yield from self._coefficients.values() - yield self.constant + for coefficient in self._coefficients.values(): + yield Rational(coefficient) + yield Rational(self._constant) def __bool__(self): return True @@ -127,86 +112,64 @@ class Expression: @_polymorphic def __add__(self, other): - coefficients = defaultdict(Rational, self.coefficients()) - for symbol, coefficient in other.coefficients(): + coefficients = defaultdict(Fraction, self._coefficients) + for symbol, coefficient in other._coefficients.items(): coefficients[symbol] += coefficient - constant = self.constant + other.constant + constant = self._constant + other._constant return Expression(coefficients, constant) __radd__ = __add__ @_polymorphic def __sub__(self, other): - coefficients = defaultdict(Rational, self.coefficients()) - for symbol, coefficient in other.coefficients(): + coefficients = defaultdict(Fraction, self._coefficients) + for symbol, coefficient in other._coefficients.items(): coefficients[symbol] -= coefficient - constant = self.constant - other.constant + constant = self._constant - other._constant return Expression(coefficients, constant) + @_polymorphic def __rsub__(self, other): - return -(self - other) + return other - self - @_polymorphic def __mul__(self, other): - if other.isconstant(): - coefficients = dict(self.coefficients()) - for symbol in coefficients: - coefficients[symbol] *= other.constant - constant = self.constant * other.constant + if isinstance(other, numbers.Rational): + coefficients = ((symbol, coefficient * other) + for symbol, coefficient in self._coefficients.items()) + constant = self._constant * other return Expression(coefficients, constant) - if isinstance(other, Expression) and not self.isconstant(): - raise ValueError('non-linear expression: ' - '{} * {}'.format(self._parenstr(), other._parenstr())) return NotImplemented __rmul__ = __mul__ - @_polymorphic def __truediv__(self, other): - if other.isconstant(): - coefficients = dict(self.coefficients()) - for symbol in coefficients: - coefficients[symbol] = Rational(coefficients[symbol], other.constant) - constant = Rational(self.constant, other.constant) + if isinstance(other, numbers.Rational): + coefficients = ((symbol, coefficient / other) + for symbol, coefficient in self._coefficients.items()) + constant = self._constant / other return Expression(coefficients, constant) - if isinstance(other, Expression): - raise ValueError('non-linear expression: ' - '{} / {}'.format(self._parenstr(), other._parenstr())) - return NotImplemented - - def __rtruediv__(self, other): - if isinstance(other, self): - if self.isconstant(): - return Rational(other, self.constant) - else: - raise ValueError('non-linear expression: ' - '{} / {}'.format(other._parenstr(), self._parenstr())) return NotImplemented @_polymorphic def __eq__(self, other): - # "normal" equality + # returns a boolean, not a constraint # see http://docs.sympy.org/dev/tutorial/gotchas.html#equals-signs return isinstance(other, Expression) and \ self._coefficients == other._coefficients and \ - self.constant == other.constant + self._constant == other._constant - @_polymorphic def __le__(self, other): from .polyhedra import Le return Le(self, other) - @_polymorphic def __lt__(self, other): from .polyhedra import Lt return Lt(self, other) - @_polymorphic def __ge__(self, other): from .polyhedra import Ge return Ge(self, other) - @_polymorphic def __gt__(self, other): from .polyhedra import Gt return Gt(self, other) @@ -218,18 +181,20 @@ class Expression: def subs(self, symbol, expression=None): if expression is None: - if isinstance(symbol, dict): + if isinstance(symbol, Mapping): symbol = symbol.items() substitutions = symbol else: substitutions = [(symbol, expression)] result = self for symbol, expression in substitutions: + if not isinstance(symbol, Symbol): + raise TypeError('symbols must be Symbol instances') coefficients = [(othersymbol, coefficient) - for othersymbol, coefficient in result.coefficients() + for othersymbol, coefficient in result._coefficients.items() if othersymbol != symbol] - coefficient = result.coefficient(symbol) - constant = result.constant + coefficient = result._coefficients.get(symbol, 0) + constant = result._constant result = Expression(coefficients, constant) + coefficient*expression return result @@ -269,41 +234,52 @@ class Expression: def __repr__(self): string = '' - i = 0 - for symbol in self.symbols: - coefficient = self.coefficient(symbol) + for i, (symbol, coefficient) in enumerate(self.coefficients()): if coefficient == 1: - if i == 0: - string += symbol.name - else: - string += ' + {}'.format(symbol) + if i != 0: + string += ' + ' elif coefficient == -1: - if i == 0: - string += '-{}'.format(symbol) - else: - string += ' - {}'.format(symbol) + string += '-' if i == 0 else ' - ' + elif i == 0: + string += '{}*'.format(coefficient) + elif coefficient > 0: + string += ' + {}*'.format(coefficient) else: - if i == 0: - string += '{}*{}'.format(coefficient, symbol) - elif coefficient > 0: - string += ' + {}*{}'.format(coefficient, symbol) - else: - assert coefficient < 0 - coefficient *= -1 - string += ' - {}*{}'.format(coefficient, symbol) - i += 1 + string += ' - {}*'.format(-coefficient) + string += '{}'.format(symbol) constant = self.constant - if constant != 0 and i == 0: + if len(string) == 0: string += '{}'.format(constant) elif constant > 0: string += ' + {}'.format(constant) elif constant < 0: - constant *= -1 - string += ' - {}'.format(constant) - if string == '': - string = '0' + string += ' - {}'.format(-constant) return string + def _repr_latex_(self): + string = '' + for i, (symbol, coefficient) in enumerate(self.coefficients()): + if coefficient == 1: + if i != 0: + string += ' + ' + elif coefficient == -1: + string += '-' if i == 0 else ' - ' + elif i == 0: + string += '{}'.format(coefficient._repr_latex_().strip('$')) + elif coefficient > 0: + string += ' + {}'.format(coefficient._repr_latex_().strip('$')) + elif coefficient < 0: + string += ' - {}'.format((-coefficient)._repr_latex_().strip('$')) + string += '{}'.format(symbol._repr_latex_().strip('$')) + constant = self.constant + if len(string) == 0: + string += '{}'.format(constant._repr_latex_().strip('$')) + elif constant > 0: + string += ' + {}'.format(constant._repr_latex_().strip('$')) + elif constant < 0: + string += ' - {}'.format((-constant)._repr_latex_().strip('$')) + return '${}$'.format(string) + def _parenstr(self, always=False): string = str(self) if not always and (self.isconstant() or self.issymbol()): @@ -339,15 +315,15 @@ class Expression: class Symbol(Expression): - __slots__ = ( - '_name', - ) - def __new__(cls, name): if not isinstance(name, str): raise TypeError('name must be a string') self = object().__new__(cls) self._name = name.strip() + self._coefficients = {self: Fraction(1)} + self._constant = Fraction(0) + self._symbols = (self,) + self._dimension = 1 return self @property @@ -355,30 +331,7 @@ class Symbol(Expression): return self._name def __hash__(self): - return hash(self._name) - - def coefficient(self, symbol): - if not isinstance(symbol, Symbol): - raise TypeError('symbol must be a Symbol instance') - if symbol == self: - return 1 - else: - return 0 - - def coefficients(self): - yield self, 1 - - @property - def constant(self): - return 0 - - @property - def symbols(self): - return self, - - @property - def dimension(self): - return 1 + return hash(self.sortkey()) def sortkey(self): return self.name, @@ -386,11 +339,11 @@ class Symbol(Expression): def issymbol(self): return True - def values(self): - yield 1 - def __eq__(self, other): - return isinstance(other, Symbol) and self.name == other.name + return self.sortkey() == other.sortkey() + + def asdummy(self): + return Dummy(self.name) @classmethod def _fromast(cls, node): @@ -402,72 +355,99 @@ class Symbol(Expression): return Symbol(node.id) raise SyntaxError('invalid syntax') + def __repr__(self): + return self.name + + def _repr_latex_(self): + return '${}$'.format(self.name) + @classmethod def fromsympy(cls, expr): import sympy - if isinstance(expr, sympy.Symbol): + if isinstance(expr, sympy.Dummy): + return Dummy(expr.name) + elif isinstance(expr, sympy.Symbol): return Symbol(expr.name) else: raise TypeError('expr must be a sympy.Symbol instance') +class Dummy(Symbol): + + _count = 0 + + def __new__(cls, name=None): + if name is None: + name = 'Dummy_{}'.format(Dummy._count) + elif not isinstance(name, str): + raise TypeError('name must be a string') + self = object().__new__(cls) + self._index = Dummy._count + self._name = name.strip() + self._coefficients = {self: Fraction(1)} + self._constant = Fraction(0) + self._symbols = (self,) + self._dimension = 1 + Dummy._count += 1 + return self + + def __hash__(self): + return hash(self.sortkey()) + + def sortkey(self): + return self._name, self._index + + def __repr__(self): + return '_{}'.format(self.name) + + def _repr_latex_(self): + return '${}_{{{}}}$'.format(self.name, self._index) + + def symbols(names): if isinstance(names, str): names = names.replace(',', ' ').split() return tuple(Symbol(name) for name in names) -class Rational(Expression): - - __slots__ = ( - '_constant', - ) +class Rational(Expression, Fraction): def __new__(cls, numerator=0, denominator=None): - self = object().__new__(cls) - if denominator is None and isinstance(numerator, Rational): - self._constant = numerator.constant - else: - self._constant = Fraction(numerator, denominator) + self = Fraction.__new__(cls, numerator, denominator) + self._coefficients = {} + self._constant = Fraction(self) + self._symbols = () + self._dimension = 0 return self def __hash__(self): - return hash(self.constant) - - def coefficient(self, symbol): - if not isinstance(symbol, Symbol): - raise TypeError('symbol must be a Symbol instance') - return 0 - - def coefficients(self): - yield from () + return Fraction.__hash__(self) @property - def symbols(self): - return () - - @property - def dimension(self): - return 0 + def constant(self): + return self def isconstant(self): return True - def values(self): - yield self._constant - - @_polymorphic - def __eq__(self, other): - return isinstance(other, Rational) and self.constant == other.constant - def __bool__(self): - return self.constant != 0 + return Fraction.__bool__(self) - @classmethod - def fromstring(cls, string): - if not isinstance(string, str): - raise TypeError('string must be a string instance') - return Rational(Fraction(string)) + def __repr__(self): + if self.denominator == 1: + return '{!r}'.format(self.numerator) + else: + return '{!r}/{!r}'.format(self.numerator, self.denominator) + + def _repr_latex_(self): + if self.denominator == 1: + return '${}$'.format(self.numerator) + elif self.numerator < 0: + return '$-\\frac{{{}}}{{{}}}$'.format(-self.numerator, + self.denominator) + else: + return '$\\frac{{{}}}{{{}}}$'.format(self.numerator, + self.denominator) @classmethod def fromsympy(cls, expr):