import numbers
import re
-from collections import OrderedDict
+from collections import OrderedDict, defaultdict
from fractions import Fraction, gcd
__all__ = [
'Expression',
- 'Symbol', 'symbols',
- 'Constant',
+ 'Symbol', 'symbols', 'Dummy',
+ 'Rational',
]
if isinstance(right, Expression):
return func(left, right)
elif isinstance(right, numbers.Rational):
- right = Constant(right)
+ right = Rational(right)
return func(left, right)
return NotImplemented
return wrapper
if isinstance(coefficients, str):
if constant:
raise TypeError('too many arguments')
- return cls.fromstring(coefficients)
+ return Expression.fromstring(coefficients)
+ if coefficients is None:
+ return Rational(constant)
if isinstance(coefficients, dict):
coefficients = coefficients.items()
- if coefficients is None:
- return Constant(constant)
+ 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 len(coefficients) == 0:
- return Constant(constant)
- elif len(coefficients) == 1 and constant == 0:
+ return Rational(constant)
+ if len(coefficients) == 1 and constant == 0:
symbol, coefficient = coefficients[0]
if coefficient == 1:
- return Symbol(symbol)
+ return symbol
self = object().__new__(cls)
- self._coefficients = {}
- for symbol, coefficient in coefficients:
- if isinstance(symbol, Symbol):
- symbol = symbol.name
- elif not isinstance(symbol, str):
- raise TypeError('symbols must be strings or Symbol instances')
- if isinstance(coefficient, Constant):
+ 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 Constant instances')
+ 'or Rational instances')
self._coefficients[symbol] = coefficient
- self._coefficients = OrderedDict(sorted(self._coefficients.items()))
- if isinstance(constant, Constant):
+ if isinstance(constant, Rational):
constant = constant.constant
if not isinstance(constant, numbers.Rational):
raise TypeError('constant must be a rational number '
- 'or a Constant instance')
+ 'or a Rational instance')
self._constant = constant
self._symbols = tuple(self._coefficients)
self._dimension = len(self._symbols)
return self
def coefficient(self, symbol):
- if isinstance(symbol, Symbol):
- symbol = str(symbol)
- elif not isinstance(symbol, str):
- raise TypeError('symbol must be a string or a Symbol instance')
+ if not isinstance(symbol, Symbol):
+ raise TypeError('symbol must be a Symbol instance')
try:
return self._coefficients[symbol]
except KeyError:
def dimension(self):
return self._dimension
+ def __hash__(self):
+ return hash((tuple(self._coefficients.items()), self._constant))
+
def isconstant(self):
return False
return False
def values(self):
- for symbol in self.symbols:
- yield self.coefficient(symbol)
+ yield from self._coefficients.values()
yield self.constant
def __bool__(self):
@_polymorphic
def __add__(self, other):
- coefficients = dict(self.coefficients())
+ coefficients = defaultdict(Rational, self.coefficients())
for symbol, coefficient in other.coefficients():
- if symbol in coefficients:
- coefficients[symbol] += coefficient
- else:
- coefficients[symbol] = coefficient
+ coefficients[symbol] += coefficient
constant = self.constant + other.constant
return Expression(coefficients, constant)
@_polymorphic
def __sub__(self, other):
- coefficients = dict(self.coefficients())
+ coefficients = defaultdict(Rational, self.coefficients())
for symbol, coefficient in other.coefficients():
- if symbol in coefficients:
- coefficients[symbol] -= coefficient
- else:
- coefficients[symbol] = -coefficient
+ coefficients[symbol] -= coefficient
constant = self.constant - other.constant
return Expression(coefficients, constant)
if other.isconstant():
coefficients = dict(self.coefficients())
for symbol in coefficients:
- coefficients[symbol] = \
- Fraction(coefficients[symbol], other.constant)
- constant = Fraction(self.constant, other.constant)
+ 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: '
def __rtruediv__(self, other):
if isinstance(other, self):
if self.isconstant():
- constant = Fraction(other, self.constant)
- return Expression(constant=constant)
+ return Rational(other, self.constant)
else:
raise ValueError('non-linear expression: '
'{} / {}'.format(other._parenstr(), self._parenstr()))
# "normal" equality
# 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._coefficients == other._coefficients and \
+ self.constant == other.constant
@_polymorphic
def __le__(self, other):
from .polyhedra import Gt
return Gt(self, other)
- def __hash__(self):
- return hash((tuple(self.coefficients()), self._constant))
-
- def _toint(self):
+ def scaleint(self):
lcm = functools.reduce(lambda a, b: a*b // gcd(a, b),
[value.denominator for value in self.values()])
return self * lcm
+ def subs(self, symbol, expression=None):
+ if expression is None:
+ if isinstance(symbol, dict):
+ symbol = symbol.items()
+ substitutions = symbol
+ else:
+ substitutions = [(symbol, expression)]
+ result = self
+ for symbol, expression in substitutions:
+ coefficients = [(othersymbol, coefficient)
+ for othersymbol, coefficient in result.coefficients()
+ if othersymbol != symbol]
+ coefficient = result.coefficient(symbol)
+ constant = result.constant
+ result = Expression(coefficients, constant) + coefficient*expression
+ return result
+
@classmethod
def _fromast(cls, node):
if isinstance(node, ast.Module) and len(node.body) == 1:
elif isinstance(node, ast.Name):
return Symbol(node.id)
elif isinstance(node, ast.Num):
- return Constant(node.n)
+ return Rational(node.n)
elif isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.USub):
return -cls._fromast(node.operand)
elif isinstance(node, ast.BinOp):
@classmethod
def fromstring(cls, string):
# add implicit multiplication operators, e.g. '5x' -> '5*x'
- string = cls._RE_NUM_VAR.sub(r'\1*\2', string)
+ string = Expression._RE_NUM_VAR.sub(r'\1*\2', string)
tree = ast.parse(string, 'eval')
return cls._fromast(tree)
- def __str__(self):
+ def __repr__(self):
string = ''
i = 0
for symbol in self.symbols:
coefficient = self.coefficient(symbol)
if coefficient == 1:
if i == 0:
- string += symbol
+ string += symbol.name
else:
string += ' + {}'.format(symbol)
elif coefficient == -1:
else:
return '({})'.format(string)
- def __repr__(self):
- return '{}({!r})'.format(self.__class__.__name__, str(self))
-
@classmethod
def fromsympy(cls, expr):
import sympy
- coefficients = {}
+ coefficients = []
constant = 0
for symbol, coefficient in expr.as_coefficients_dict().items():
coefficient = Fraction(coefficient.p, coefficient.q)
if symbol == sympy.S.One:
constant = coefficient
elif isinstance(symbol, sympy.Symbol):
- symbol = symbol.name
- coefficients[symbol] = coefficient
+ symbol = Symbol(symbol.name)
+ coefficients.append((symbol, coefficient))
else:
raise ValueError('non-linear expression: {!r}'.format(expr))
- return cls(coefficients, constant)
+ return Expression(coefficients, constant)
def tosympy(self):
import sympy
expr = 0
for symbol, coefficient in self.coefficients():
- term = coefficient * sympy.Symbol(symbol)
+ term = coefficient * sympy.Symbol(symbol.name)
expr += term
expr += self.constant
return expr
class Symbol(Expression):
- __slots__ = Expression.__slots__ + (
+ __slots__ = (
'_name',
)
def __new__(cls, name):
- if isinstance(name, Symbol):
- name = name.name
- elif not isinstance(name, str):
- raise TypeError('name must be a string or a Symbol instance')
- name = name.strip()
+ if not isinstance(name, str):
+ raise TypeError('name must be a string')
self = object().__new__(cls)
- self._coefficients = {name: 1}
- self._constant = 0
- self._symbols = tuple(name)
- self._name = name
- self._dimension = 1
+ self._name = name.strip()
return self
@property
def name(self):
return self._name
+ def __hash__(self):
+ return hash(self.sortkey())
+
+ 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
+
+ def sortkey(self):
+ return self.name,
+
def issymbol(self):
return True
+ def values(self):
+ yield 1
+
+ def __eq__(self, other):
+ 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):
if isinstance(node, ast.Module) and len(node.body) == 1:
return Symbol(node.id)
raise SyntaxError('invalid syntax')
- def __repr__(self):
- return '{}({!r})'.format(self.__class__.__name__, self._name)
-
@classmethod
def fromsympy(cls, expr):
import sympy
if isinstance(expr, sympy.Symbol):
- return cls(expr.name)
+ return Symbol(expr.name)
else:
raise TypeError('expr must be a sympy.Symbol instance')
def symbols(names):
if isinstance(names, str):
names = names.replace(',', ' ').split()
- return (Symbol(name) for name in names)
+ return tuple(Symbol(name) for name in names)
+
+
+class Dummy(Symbol):
+ __slots__ = (
+ '_name',
+ '_index',
+ )
-class Constant(Expression):
+ _count = 0
+
+ def __new__(cls, name=None):
+ if name is None:
+ name = 'Dummy_{}'.format(Dummy._count)
+ self = object().__new__(cls)
+ self._name = name.strip()
+ self._index = Dummy._count
+ 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
+
+
+class Rational(Expression):
+
+ __slots__ = (
+ '_constant',
+ )
def __new__(cls, numerator=0, denominator=None):
self = object().__new__(cls)
- if denominator is None and isinstance(numerator, Constant):
+ if denominator is None and isinstance(numerator, Rational):
self._constant = numerator.constant
else:
self._constant = Fraction(numerator, denominator)
- self._coefficients = {}
- 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 ()
+
+ @property
+ def symbols(self):
+ return ()
+
+ @property
+ def dimension(self):
+ return 0
+
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
@classmethod
def fromstring(cls, string):
- if isinstance(string, str):
- return Constant(Fraction(string))
- else:
+ if not isinstance(string, str):
raise TypeError('string must be a string instance')
-
- def __repr__(self):
- if self.constant.denominator == 1:
- return '{}({!r})'.format(self.__class__.__name__,
- self.constant.numerator)
- else:
- return '{}({!r}, {!r})'.format(self.__class__.__name__,
- self.constant.numerator, self.constant.denominator)
+ return Rational(Fraction(string))
@classmethod
def fromsympy(cls, expr):
import sympy
if isinstance(expr, sympy.Rational):
- return cls(expr.p, expr.q)
+ return Rational(expr.p, expr.q)
elif isinstance(expr, numbers.Rational):
- return cls(expr)
+ return Rational(expr)
else:
raise TypeError('expr must be a sympy.Rational instance')
projects / linpy.git / blobdiff