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