def _simplify(self, expression):
exprs = list(expression.get_expressions())
add = next(e for e in exprs if isinstance(e, Add))
exprs.remove(add)
terms = []
for term in add.get_expressions():
if len(exprs) == 1:
terms.append(Multiply(exprs[0], term))
else:
terms.append(Multiply(Multiply(*exprs), term))
return Add(*terms)
def _simplify(self, expression):
multiplies, others = filter_split(lambda x: isinstance(x, Multiply), expression.get_expressions())
sets = [set(x.get_expressions()) for x in multiplies]
c = Counter()
for s in sets:
c.update(s)
term, count = c.most_common(1)[0]
if count < 2:
return expression
in_terms = []
for mult in multiplies:
if term in mult.get_expressions():
l = list(mult.get_expressions())
l.remove(term)
if len(l) == 1:
in_terms.append(l[0])
else:
in_terms.append(Multiply(*l))
else:
others.append(mult)
if len(others) == 0:
return term * Add(*in_terms)
return Add(term * Add(*in_terms), *others)
def _simplify(self, expression):
values, other = filter_split(lambda x: isinstance(x, Value), expression.get_expressions())
value = reduce(lambda x, y: x * y, map(lambda x: x.get_numeric_value(), values))
if value == 0:
return Value(0)
if value == 1:
if len(other) == 1:
return other[0]
return Multiply(*other)
if value == -1:
if len(other) == 1:
return -other[0]
return -Multiply(*other)
if len(other) == 0:
return Value(value)
return Multiply(value, *other)
def _simplify(self, expression):
expr = expression.get_expression()
var = expression.get_var()
exprs = expr.get_expressions()
terms = []
for i, e in enumerate(exprs):
rest = exprs[:i] + exprs[i + 1:]
terms.append(Multiply(Derivative(e, var), *rest))
return Add(*terms)
def _simplify(self, expression):
exprs = expression.get_expressions()
counts = Counter(exprs)
exprs = []
for term in counts:
freq = counts[term]
if freq == 1:
exprs.append(term)
else:
exprs.append(term ^ Value(freq))
if len(exprs) == 1:
return exprs[0]
return Multiply(*exprs)
def runTest(self):
self.assertSimplify(Multiply(3, 4, x), Multiply(12, x))
self.assertSimplify(Multiply(3, 4, x - 1), Multiply(12, x - 1))
def runTest(self):
self.assertSimplify(x * x, x ^ 2)
self.assertSimplify(Multiply(x, y, x), (x ^ 2) * y)
def runTest(self):
self.assertSimplify(x * (x + x), (x * x) + (x * x))
self.assertSimplify(x * (x + x + x), (x * x) + (x * x) + (x * x))
self.assertSimplify(Multiply(x, y, (x + 1)),
Multiply((x * y), x) + Multiply((x * y), 1))
def runTest(self):
self.assertSimplify((x * y) * z, Multiply(x, y, z))
def _simplify(self, expression):
mult, other = filter_split(lambda x: isinstance(x, Multiply), expression.get_expressions())
mult = list(chain(*map(lambda x: x.get_expressions(), mult)))
return Multiply(*mult, *other)