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',
]
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()
for symbol, coefficient in coefficients:
if not isinstance(symbol, Symbol):
raise TypeError('symbols must be Symbol instances')
- coefficients = [(symbol, coefficient)
+ if not isinstance(coefficient, numbers.Rational):
+ raise TypeError('coefficients must be Rational instances')
+ 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 instance')
+ constant = Fraction(constant)
if len(coefficients) == 0:
return Rational(constant)
if len(coefficients) == 1 and constant == 0:
if coefficient == 1:
return symbol
self = object().__new__(cls)
- self._coefficients = OrderedDict()
- for symbol, coefficient in sorted(coefficients,
- key=lambda item: item[0].name):
- 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._coefficients = OrderedDict(sorted(coefficients,
+ key=lambda item: item[0].sortkey()))
self._constant = constant
self._symbols = tuple(self._coefficients)
self._dimension = len(self._symbols)
if not isinstance(symbol, Symbol):
raise TypeError('symbol must be a Symbol instance')
try:
- return self._coefficients[symbol]
+ return Rational(self._coefficients[symbol])
except KeyError:
- return 0
+ return Rational(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):
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
@_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)
def __rsub__(self, other):
@_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
- return Expression(coefficients, constant)
- if isinstance(other, Expression) and not self.isconstant():
- raise ValueError('non-linear expression: '
- '{} * {}'.format(self._parenstr(), other._parenstr()))
+ if isinstance(other, Rational):
+ return other.__rmul__(self)
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)
- return Expression(coefficients, constant)
- if isinstance(other, Expression):
- raise ValueError('non-linear expression: '
- '{} / {}'.format(self._parenstr(), other._parenstr()))
+ if isinstance(other, Rational):
+ return other.__rtruediv__(self)
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
+ __rtruediv__ = __truediv__
@_polymorphic
def __eq__(self, other):
# 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):
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
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)
+ string += '' if i == 0 else ' + '
+ string += '{!r}'.format(symbol)
elif coefficient == -1:
- if i == 0:
- string += '-{}'.format(symbol)
- else:
- string += ' - {}'.format(symbol)
+ string += '-' if i == 0 else ' - '
+ string += '{!r}'.format(symbol)
else:
if i == 0:
- string += '{}*{}'.format(coefficient, symbol)
+ string += '{}*{!r}'.format(coefficient, symbol)
elif coefficient > 0:
- string += ' + {}*{}'.format(coefficient, symbol)
+ string += ' + {}*{!r}'.format(coefficient, symbol)
else:
- assert coefficient < 0
- coefficient *= -1
- string += ' - {}*{}'.format(coefficient, symbol)
- i += 1
+ string += ' - {}*{!r}'.format(-coefficient, 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 _parenstr(self, always=False):
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: 1}
+ self._constant = 0
+ self._symbols = (self,)
+ self._dimension = 1
return self
@property
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
+ return hash(self.sortkey())
- @property
- def symbols(self):
- return self,
-
- @property
- def dimension(self):
- return 1
+ def sortkey(self):
+ return self.name,
def issymbol(self):
return True
- def values(self):
- yield 1
-
def __eq__(self, other):
- return isinstance(other, Symbol) and self.name == other.name
+ return not isinstance(other, Dummy) and isinstance(other, Symbol) \
+ and self.name == other.name
+
+ def asdummy(self):
+ return Dummy(self.name)
@classmethod
def _fromast(cls, node):
return Symbol(node.id)
raise SyntaxError('invalid syntax')
+ def __repr__(self):
+ return self.name
+
@classmethod
def fromsympy(cls, expr):
import sympy
if isinstance(expr, sympy.Symbol):
- return Symbol(expr.name)
+ return cls(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)
+ self = object().__new__(cls)
+ self._index = Dummy._count
+ self._name = name.strip()
+ self._coefficients = {self: 1}
+ self._constant = 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 __eq__(self, other):
+ return isinstance(other, Dummy) and self._index == other._index
+
+ def __repr__(self):
+ return '_{}'.format(self.name)
+
+
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
+ def __bool__(self):
+ return Fraction.__bool__(self)
@_polymorphic
- def __eq__(self, other):
- return isinstance(other, Rational) and self.constant == other.constant
+ def __mul__(self, other):
+ coefficients = dict(other._coefficients)
+ for symbol in coefficients:
+ coefficients[symbol] *= self._constant
+ constant = other._constant * self._constant
+ return Expression(coefficients, constant)
- def __bool__(self):
- return self.constant != 0
+ __rmul__ = __mul__
+
+ @_polymorphic
+ def __rtruediv__(self, other):
+ coefficients = dict(other._coefficients)
+ for symbol in coefficients:
+ coefficients[symbol] /= self._constant
+ constant = other._constant / self._constant
+ return Expression(coefficients, constant)
@classmethod
def fromstring(cls, string):
projects / linpy.git / blobdiff