return Rational(constant)
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')
if not isinstance(coefficient, numbers.Rational):
raise TypeError('coefficients must be rational numbers')
- coefficients = [(symbol, Fraction(coefficient))
- for symbol, coefficient in coefficients if coefficient != 0]
if not isinstance(constant, numbers.Rational):
raise TypeError('constant must be a rational number')
- constant = Fraction(constant)
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(sorted(coefficients,
- key=lambda item: item[0].sortkey()))
- self._constant = constant
+ self._coefficients = OrderedDict(coefficients)
+ self._constant = Fraction(constant)
self._symbols = tuple(self._coefficients)
self._dimension = len(self._symbols)
return self
def coefficient(self, symbol):
if not isinstance(symbol, Symbol):
raise TypeError('symbol must be a Symbol instance')
- try:
- return Rational(self._coefficients[symbol])
- except KeyError:
- return Rational(0)
+ return Rational(self._coefficients.get(symbol, 0))
__getitem__ = coefficient
constant = self._constant - other._constant
return Expression(coefficients, constant)
+ @_polymorphic
def __rsub__(self, other):
- return -(self - other)
+ return other - self
def __mul__(self, other):
if isinstance(other, numbers.Rational):
- coefficients = dict(self._coefficients)
- for symbol in coefficients:
- coefficients[symbol] *= other
+ coefficients = ((symbol, coefficient * other)
+ for symbol, coefficient in self._coefficients.items())
constant = self._constant * other
return Expression(coefficients, constant)
return NotImplemented
def __truediv__(self, other):
if isinstance(other, numbers.Rational):
- coefficients = dict(self._coefficients)
- for symbol in coefficients:
- coefficients[symbol] /= other
+ coefficients = ((symbol, coefficient / other)
+ for symbol, coefficient in self._coefficients.items())
constant = self._constant / other
- # import pdb; pdb.set_trace()
return Expression(coefficients, constant)
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
- @_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)
string += ' + {}'.format(constant._repr_latex_().strip('$'))
elif constant < 0:
string += ' - {}'.format((-constant)._repr_latex_().strip('$'))
- return '${}$'.format(string)
+ return '$${}$$'.format(string)
def _parenstr(self, always=False):
string = str(self)
return True
def __eq__(self, other):
- return not isinstance(other, Dummy) and isinstance(other, Symbol) \
- and self.name == other.name
+ return self.sortkey() == other.sortkey()
def asdummy(self):
return Dummy(self.name)
return self.name
def _repr_latex_(self):
- return '${}$'.format(self.name)
+ return '$${}$$'.format(self.name)
@classmethod
def fromsympy(cls, expr):
import sympy
- if isinstance(expr, sympy.Symbol):
- return cls(expr.name)
+ 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')
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()
def sortkey(self):
return self._name, self._index
- def __eq__(self, other):
- return isinstance(other, Dummy) and self._index == other._index
-
def __repr__(self):
return '_{}'.format(self.name)
def _repr_latex_(self):
- return '${}_{{{}}}$'.format(self.name, self._index)
+ return '$${}_{{{}}}$$'.format(self.name, self._index)
def symbols(names):
class Rational(Expression, Fraction):
def __new__(cls, numerator=0, denominator=None):
- self = Fraction.__new__(cls, numerator, denominator)
+ self = object().__new__(cls)
self._coefficients = {}
- self._constant = Fraction(self)
+ self._constant = Fraction(numerator, denominator)
self._symbols = ()
self._dimension = 0
+ self._numerator = self._constant.numerator
+ self._denominator = self._constant.denominator
return self
def __hash__(self):
def __bool__(self):
return Fraction.__bool__(self)
- @classmethod
- def fromstring(cls, string):
- if not isinstance(string, str):
- raise TypeError('string must be a string instance')
- return Rational(string)
-
def __repr__(self):
if self.denominator == 1:
return '{!r}'.format(self.numerator)
def _repr_latex_(self):
if self.denominator == 1:
- return '${}$'.format(self.numerator)
+ return '$${}$$'.format(self.numerator)
elif self.numerator < 0:
- return '$-\\frac{{{}}}{{{}}}$'.format(-self.numerator,
+ return '$$-\\frac{{{}}}{{{}}}$$'.format(-self.numerator,
self.denominator)
else:
- return '$\\frac{{{}}}{{{}}}$'.format(self.numerator,
+ return '$$\\frac{{{}}}{{{}}}$$'.format(self.numerator,
self.denominator)
@classmethod
projects / linpy.git / blobdiff