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)