def info(self):
return {
"text": str(self.e),
"latex": self.latex,
"reason": self.reason,
"_latex_reason": "Integrate by parts, \\(u = %s, v = %s\\)" %\
(latex.convert_expr(self.u), latex.convert_expr(self.v)),
"location": str(self.loc),
"params": {
"parts_u": str(self.u),
"parts_v": str(self.v)
}
}
def info(self):
return {
"text": str(self.e),
"reason": self.reason,
"_latex_reason": "Rewrite trigonometric \\(%s\\) to \\(%s\\)" %\
(latex.convert_expr(self.old_trig), latex.convert_expr(self.new_trig)),
"latex": self.latex,
"params": {
"rule": self.tr_rule
},
"old_trig": str(self.old_trig),
"new_trig": str(self.new_trig),
"location": str(self.loc),
}
def info(self):
return {
"text": str(self.e),
"latex": self.latex,
"location": str(self.loc),
"params": {
"f": str(self.f),
"g": str(self.var_subst),
"var_name": self.var_name
},
"_latex_reason": "Substitute \\(%s\\) for \\(%s\\)" %\
(latex.convert_expr(Var(self.var_name)), latex.convert_expr(self.var_subst)),
"reason": self.reason
}
def __init__(self, e, denom, rhs, loc=[]):
self.e = e
self.denom = denom
self.loc = Location(loc)
self.rhs = rhs
self.latex = latex.convert_expr(e)
self.reason = "Rewrite fraction"
def __init__(self, e, u, v, loc=[]):
self.e = e
self.u = u
self.v = v
self.loc = Location(loc)
self.latex = latex.convert_expr(e)
self.reason = "Integrate by parts"
def __init__(self, e, loc=[]):
"""comp is the integration method.
"""
self.e = e
self.reason = "Simplification"
self.latex = latex.convert_expr(e)
self.loc = Location(loc)
def __init__(self, e, loc, old_trig, new_trig, tr_rule):
self.e = e
self.old_trig = old_trig
self.new_trig = new_trig
self.loc = Location(loc)
self.latex = latex.convert_expr(e)
self.tr_rule = tr_rule
self.reason = "Rewrite trigonometric"
def __init__(self, e, var_name, var_subst, loc=[]):
self.e = e
self.reason = "Substitution inverse"
self.latex = latex.convert_expr(e)
self.var_name = var_name
self.var_subst = var_subst
self.comp = rules.Substitution2(var_name, var_subst).eval
self.loc = Location(loc)
def __init__(self, e, var_name, var_subst, f, loc=[]):
self.e = e
self.var_name = var_name
self.var_subst = var_subst
self.f = f
self.latex = latex.convert_expr(e)
self.loc = Location(loc)
self.reason = "Substitution"
def info(self):
return {
"reason":
self.reason,
'text':
str(self.e),
'latex':
latex.convert_expr(self.e),
"params": {
"rule": self.rule_name
},
'_latex_reason':
"Rewrite trigonometric \\(%s\\) to \\(%s\\)" % (latex.convert_expr(
self.before_trig), latex.convert_expr(self.after_trig)),
# If there is only one integral in the full expression, location begins from the body;
# Else from the integral
"location":
str(self.loc)
}
def info(self):
return {
"text": str(self.e),
"latex": latex.convert_expr(self.e),
"reason": self.reason,
"location": str(self.loc),
"params": {
"c": str(self.zero_point)
}
}
def info(self):
return {
"latex": latex.convert_expr(self.e),
"location": str(self.loc),
"params": {
"denom": str(self.denom),
"rhs": str(self.rhs)
},
"reason": self.reason,
"text": str(self.e)
}
def info(self):
logs = {
"text": str(self.e),
"latex": latex.convert_expr(self.e),
"location": str(self.loc),
"reason": self.reason,
}
if self.zero_point is not None:
logs["params"] = {"c": str(self.zero_point)}
return logs
def testConvertExpr(self):
test_data = [
("sqrt(2)", "\\sqrt{2}"), ("1/3", "\\frac{1}{3}"),
("x^-2", "\\frac{1}{x ^ 2}"), ("-t^2", "-t ^ 2"),
("exp(-1)", "e^{-1}"), ("-(x + y)", "-(x + y)"),
("[3 * x]_x=1,2", "\\left. 3 x \\right\\vert_{x=1}^{2}"),
("INT x:[2,3]. 2 * x + x ^ 2", "\int_{2}^{3} 2 x + x ^ 2 \,dx"),
("(3 * x + 1) ^ -2", "\\frac{1}{(3 x + 1) ^ 2}"),
("INT x:[0,pi / 4]. sin(x)", "\int_{0}^{\pi/4} \sin{(x)} \,dx"),
("x^(1/2)", "\sqrt{x}"), ("x * (1 + x)", "x (1 + x)"),
("INT x:[4,9]. x^(1/2) * (1 + x^(1/2))",
"\int_{4}^{9} \sqrt{x} (1 + \sqrt{x}) \,dx"),
("cos(x) ^ 2", "\cos^{2}(x)"),
("exp(-(t^2/2))", "e^{-\\frac{1}{2} \\times t ^ 2}"),
("2 * 2 ^ (1/2)", "2 \\sqrt{2}"), ("(-1) * exp((-1))", "-e^{-1}"),
("abs(u) ^ -1", "\\frac{1}{\left| u \\right|}"),
("(3 + x) ^ (3/2)", "(3 + x) ^ {\\frac{3}{2}}")
]
for e, res in test_data:
e = parse_expr(e)
self.assertEqual(latex.convert_expr(e), res)
def __init__(self, e, loc=[]):
self.e = e
self.reason = "CommonIntegral"
self.latex = latex.convert_expr(e)
self.loc = Location(loc)
def __init__(self, e, loc=[]):
self.e = e
self.reason = "Linearity"
self.latex = latex.convert_expr(e)
self.loc = Location(loc)
def __init__(self, e, loc=[]):
self.e = e
self.latex = latex.convert_expr(e)
self.reason = "Unfold power"
self.comp = rules.UnfoldPower.eval
self.loc = Location(loc)
def __init__(self, e, loc=[]):
self.e = e
self.latex = latex.convert_expr(e)
self.loc = Location(loc)
self.reason = "Solve equation"
def perform_steps(node):
"""
Perform the real solving steps.
"""
real_steps = []
current = node.root
for step in node.trace():
loc = step.loc
if step.reason == "Simplification":
rule = rules.FullSimplify()
current = rules.OnLocation(rule, loc).eval(current)
real_steps.append({
"text": str(current),
"latex": latex.convert_expr(current),
"reason": step.reason,
"location": str(loc)
})
elif step.reason == "Substitution":
rule = rules.Substitution1(step.var_name, step.var_subst)
current = rules.OnLocation(rule, loc).eval(current)
real_steps.append({
"text": str(current),
"latex": latex.convert_expr(current),
"location": str(loc),
"params": {
"f": str(step.f),
"g": str(step.var_subst),
"var_name": step.var_name
},
"_latex_reason": "Substitute \\(%s\\) for \\(%s\\)" %\
(latex.convert_expr(Var(step.var_name)), latex.convert_expr(step.var_subst)),
"reason": step.reason
})
elif step.reason == "Integrate by parts":
rule = rules.IntegrationByParts(step.u, step.v)
current = rules.OnLocation(rule, loc).eval(current)
real_steps.append({
"text": str(current),
"latex": latex.convert_expr(current),
"location": str(loc),
"reason": step.reason,
"_latex_reason": "Integrate by parts, \\(u = %s, v = %s\\)" %\
(latex.convert_expr(step.u), latex.convert_expr(step.v)),
"params": {
"parts_u": str(step.u),
"parts_v": str(step.v)
}
})
elif step.reason == "Rewrite trigonometric":
rule = rules.RewriteTrigonometric(step.rule_name)
current = rules.OnLocation(rule, loc).eval(current)
real_steps.append({
"reason":
step.reason,
"text":
str(current),
"latex":
latex.convert_expr(current),
"params": {
"rule": step.rule_name
},
"_latex_reason":
"Rewrite trigonometric \\(%s\\) to \\(%s\\)" %
(latex.convert_expr(
step.before_trig), latex.convert_expr(step.after_trig)),
# If there is only one integral in the full expression, location begins from the body;
# Else from the integral
"location":
str(step.loc)
})
elif step.reason == "Elim abs":
rule = rules.ElimAbs()
current = rules.OnLocation(rule, loc).eval(current)
info = {
"reason": step.reason,
"text": str(current),
"latex": latex.convert_expr(current),
"location": str(loc)
}
if step.zero_point is not None:
info["params"] = {"c": str(step.zero_point)}
real_steps.append(info)
elif step.reason == "Substitution inverse":
rule = rules.Substitution2(step.var_name, step.var_subst)
current = rules.OnLocation(rule, loc).eval(current)
real_steps.append({
"text": str(current),
"latex": latex.convert_expr(current),
"_latex_reason": "Substitute \\(%s\\) for \\(%s\\)" % \
(latex.convert_expr(Var(step.var_name)), latex.convert_expr(step.var_subst)),
"reason": step.reason,
"location": str(loc),
"params": {
"a": str(step.e.lower),
"b": str(step.e.upper),
"g": str(step.var_subst),
"var_name": str(step.var_name)
}
})
elif step.reason == "Unfold power":
rule = rules.UnfoldPower()
current = rules.OnLocation(rule, loc).eval(current)
real_steps.append({
"text": str(current),
"latex": latex.convert_expr(current),
"reason": "Unfold power",
"location": str(loc)
})
elif step.reason == "Rewrite fraction":
rule = rules.PolynomialDivision()
current = rules.OnLocation(rule, loc).eval(current)
real_steps.append({
"text": str(current),
"latex": latex.convert_expr(current),
"reason": step.reason,
"params": {
"rhs": str(step.rhs),
"denom": str(step.denom),
},
"location": str(step.loc)
})
elif step.reason == "Split region":
rule = rules.SplitRegion(step.zero_point)
current = rules.OnLocation(rule, loc).eval(current)
real_steps.append({
"text": str(current),
"latex": latex.convert_expr(current),
"reason": step.reason,
"location": str(step.loc),
"params": {
"c": str(step.zero_point)
}
})
else:
raise NotImplementedError(step.reason)
last_expr = parse_expr(real_steps[-1]["text"])
if last_expr.is_constant() and last_expr.normalize() == last_expr:
return real_steps
final_expr = rules.FullSimplify().eval(last_expr)
real_steps.append({
"text": str(final_expr),
"latex": latex.convert_expr(final_expr),
"reason": "Simplification",
"location": "."
})
return real_steps
def __init__(self, e):
self.e = e
self.latex = latex.convert_expr(e)
self.loc = Location()