def testSubstitution2(self):
e = parse_expr("INT x:[0,1]. exp(6*x)")
e = rules.Substitution1("u", parse_expr("6 * x")).eval(e)
e = rules.Linearity().eval(e)
e = rules.OnSubterm(rules.CommonIntegral()).eval(e)
e = rules.Simplify().eval(e)
self.assertEqual(str(e.normalize()), "-1/6 + 1/6 * exp(6)")
def testSubstitution(self):
e = parse_expr("INT x:[0,1]. (3 * x + 1) ^ (-2)")
e = rules.Substitution1("u", parse_expr("3 * x + 1")).eval(e)
e = rules.Linearity().eval(e)
e = rules.OnSubterm(rules.CommonIntegral()).eval(e)
e = rules.Simplify().eval(e)
self.assertEqual(e, Const(Fraction("1/4")))
def testSubstitution6(self):
e = parse_expr("INT x:[-2, 0]. (x + 2)/(x^2 + 2*x + 2)")
e.body = rules.Equation(
e.body, parse_expr("((x+1) + 1)/((x+1)*(x+1) + 1)")).eval(e.body)
e = rules.Substitution1("u", parse_expr("x+1")).eval(e)
self.assertEqual(
e,
parse_expr(
"INT u:[-1,1]. u * (2 * u + (-1 + u) ^ 2) ^ -1 + (2 * u + (-1 + u) ^ 2) ^ -1"
))
def substitution(integral, subst):
new_var = gen_rand_letter(integral.var)
rule = rules.Substitution1(new_var, subst)
new_e = rule.eval(integral)
steps = [
calc.SubstitutionStep(e=new_e,
var_name=new_var,
var_subst=subst,
f=rule.f,
loc=[])
]
return new_e, steps
def testSubstitution10(self):
e = parse_expr("INT x:[0, 441]. (pi * sin(pi*sqrt(x))) / sqrt(x)")
e = rules.Substitution1("u", parse_expr("pi * sqrt(x)")).eval(e)
self.assertEqual(e, parse_expr("INT u:[0,21 * pi]. 2 * sin(u)"))
def testSubstitution9(self):
e = parse_expr("INT x:[1, exp(2)]. 1/(x * sqrt(1 + log(x)))")
e = rules.Substitution1("u", parse_expr("1 + log(x)")).eval(e)
self.assertEqual(e, parse_expr("INT u:[1,3]. u ^ (-1/2)"))
def testSubstitution8(self):
e = parse_expr("INT x:[1, exp(1)]. sin(log(x))")
e = rules.Substitution1("u", parse_expr("log(x)")).eval(e)
self.assertEqual(e.normalize(),
parse_expr("INT u:[0,1]. exp(u) * sin(u)"))
def testSubstitution7(self):
e = parse_expr("INT x:[3/4, 1]. 1/(sqrt(1-x) - 1)")
e = rules.Substitution1("u", parse_expr("sqrt(1 - x)")).eval(e)
self.assertEqual(str(e), "INT u:[0,1/2]. 2 * u * (-1 + u) ^ -1")
def testSubstitution5(self):
e = parse_expr("INT t:[0, 1]. t * exp(-(t^2/2))")
e = rules.Substitution1("u", parse_expr("-t^2/2")).eval(e)
self.assertEqual(e, parse_expr("INT u:[-1/2,0]. exp(u)"))
def testSubstitution4(self):
e = parse_expr("INT x:[1, 4]. 1/(1+sqrt(x))")
e = rules.Substitution1("u", parse_expr("sqrt(x)")).eval(e)
self.assertEqual(str(e), "INT u:[1,2]. 2 * u * (1 + u) ^ -1")
def testSubstitution3(self):
e = parse_expr("INT x:[0, pi/2].sqrt(cos(x))*sin(x)")
e = rules.Substitution1("u", parse_expr("cos(x)")).eval(e)
self.assertEqual(e, parse_expr("INT u:[0,1]. sqrt(u)"))
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