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()