def parse_to_expression(s): """ Parse a given string expression into an Expression :param s: The string :return: The resulting Expression """ tokens = tokenize(s) tokens = clean_tokens(tokens) queue = shunting_yard(tokens) stack = Stack() while not queue.is_empty(): t = queue.pop() if is_numeric(t): stack.push(Value(parse_number(t))) elif is_function(t): arg_num = get_function_args(t) args = [stack.pop() for _ in range(arg_num)] args.reverse() stack.push(get_function(t)(*args)) elif is_operator(t): v2, v1 = stack.pop(), stack.pop() stack.push(get_operator(t)(v1, v2)) else: stack.push(Variable(t)) return stack.pop()
def evaluate(self, **kwargs): evaluated = list(map(lambda x: x.evaluate(**kwargs), self._expressions)) if all(expr.get_numeric_value() is not None for expr in evaluated): return Value( self._func(*map(lambda x: x.get_numeric_value(), evaluated))) else: return type(self)(*evaluated)
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): exprs = expression.get_expressions() counts = Counter(exprs) exprs = [] for term in counts: freq = counts[term] if freq == 1: exprs.append(term) else: exprs.append(Value(freq) * term) if len(exprs) == 1: return exprs[0] return Add(*exprs)
def _simplify(self, expression): return Value( expression.get_func()(*(e.get_numeric_value() for e in expression.get_expressions())))
def runTest(self): self.assertParsed("5 // x", Derivative(Value(5), Variable('x'))) self.assertParsed("sin(x) // x", Derivative(Sin('x'), Variable('x')))
def runTest(self): self.assertParsed("5 * sin(x)", Value(5) * Sin(Variable('x'))) self.assertParsed("5 * log(2, x)", Value(5) * Log(2, Variable('x')))
def runTest(self): self.assertParsed("5 * x", Value(5) * Variable('x'))
def can_simplify(self, expression): return isinstance( expression, Divide) and expression.get_expressions()[1] in (Value(1), Value(-1))
def _simplify(self, expression): return Value(1)
def _simplify(self, expression): expr = expression.get_expression() var = expression.get_var() exprs = expr.get_expressions() return Divide(Value(1), Log(exprs[1]) * exprs[0]) * (exprs[0] // var)
def can_simplify(self, expression): return isinstance(expression, Subtract) and any( x == Value(0) for x in expression.get_expressions())
def _simplify(self, expression): first, second = expression.get_expressions() if first == Value(0): return -second else: return first
def possibly_parse_literal(x): if isinstance(x, (int, float)): return Value(x) if isinstance(x, str): return Variable(x) return x
def can_simplify(self, expression): return isinstance( expression, Exponent) and expression.get_expressions()[1] == Value(1)
def runTest(self): self.assertParsed("5 * 3 + 3", (Value(5) * Value(3)) + Value(3)) self.assertParsed("5 * 3 ^ 5 + 3", (Value(5) * (Value(3) ^ Value(5))) + Value(3))
def runTest(self): self.assertSimplify(x ^ 0, Value(1)) self.assertSimplify((x + y) ^ 0, Value(1))
def _simplify(self, expression): numer, denom = expression.get_expressions() if denom == Value(1): return numer else: return -numer