def doIntegration(f, lower, upper):
logMessage("Integrating")
# Parse and error check the input.
parsed = parseIntegrateInput(f, lower, upper)
if (None in parsed): # If there was an error parsing the input
print("400 error")
abort(400)
# Unpack the parsed tuple.
f, lower, upper = parsed
# Create the functions.
try:
sympyFunction = convertInput(f)
stupidFunction, removedVariables = stupidifyFunction(sympyFunction)
except Exception:
print("501 error")
abort(501)
# Calculate the integrals.
indefiniteIntegral = sp.integrate(sympyFunction, x)
definiteIntegral = sp.integrate(sympyFunction, (x, lower, upper))
# Format the results into a dictionary which later is converted to JSON.
results = {}
results["function"] = sp.latex(sympyFunction)
results["integral"] = sp.latex(indefiniteIntegral)
results["definiteIntegral"] = sp.latex(definiteIntegral)
results["approxDefiniteIntegral"] = sp.latex(definiteIntegral.evalf())
results["steps"] = getStepTree(integral_steps(sympyFunction, x))
return json.JSONEncoder().encode(results) # Return the results.
def test():
f_x = atan(x)
out_f = '$' + latex(Integral(f_x, x)) + '$'
steps = integral_steps(f_x, x)
analysis_steps(steps)
f_x_result = '$' + latex(simplify(integrate(f_x, x))) + '$'
print('结果为：' + out_f + '=' + f_x_result)
def test_issue_9462():
assert manualintegrate(
sin(2 * x) * exp(x),
x) == exp(x) * sin(2 * x) / 5 - 2 * exp(x) * cos(2 * x) / 5
assert not contains_dont_know(integral_steps(sin(2 * x) * exp(x), x))
assert manualintegrate((x - 3) / (x**2 - 2*x + 2)**2, x) == \
Integral(x/(x**4 - 4*x**3 + 8*x**2 - 8*x + 4), x) \
- 3*Integral(1/(x**4 - 4*x**3 + 8*x**2 - 8*x + 4), x)
def test_issue_9462():
assert manualintegrate(sin(2*x)*exp(x), x) == exp(x)*sin(2*x)/5 - 2*exp(x)*cos(2*x)/5
assert not contains_dont_know(integral_steps(sin(2*x)*exp(x), x))
assert manualintegrate((x - 3) / (x**2 - 2*x + 2)**2, x) == \
Integral(x/(x**4 - 4*x**3 + 8*x**2 - 8*x + 4), x) \
- 3*Integral(1/(x**4 - 4*x**3 + 8*x**2 - 8*x + 4), x)
def print_html_steps(function, symbol):
rule = integral_steps(function, symbol)
if isinstance(rule, DontKnowRule):
raise ValueError("Cannot evaluate integral")
a = HTMLPrinter(rule)
return a.finalize()
def print_html_steps(function, symbol):
rule = integral_steps(function, symbol)
if isinstance(rule, DontKnowRule):
raise ValueError("Cannot evaluate integral")
a = HTMLPrinter(rule)
return a.finalize()
from sympy.parsing.sympy_parser import parse_expr
from mathlearning.model.expression import Expression
from sympy.integrals.manualintegrate import (
manualintegrate, _manualintegrate, integral_steps, evaluates, ConstantRule,
ConstantTimesRule, PowerRule, AddRule, URule, PartsRule, CyclicPartsRule,
TrigRule, ExpRule, ArctanRule, AlternativeRule, DontKnowRule, RewriteRule,
integral_steps, parts_rule, IntegralInfo, substitution_rule)
steps = integral_steps(parse_expr('(exp(x) / (1 + exp(2 * x))+ x**2 ) - x'),
parse_expr('x'))
steps_other = integral_steps(parse_expr('exp(x) / (1 + exp(2 * x))'),
parse_expr('x'))
print(steps)
# this returns None if not apply
parts_rule_application = parts_rule(
IntegralInfo(parse_expr('x**2*cos(x)'), parse_expr('x')))
parts_rule_application_invalid = parts_rule(
IntegralInfo(parse_expr('x'), parse_expr('x')))
parts_rule_application_invalida = parts_rule(
IntegralInfo(parse_expr('Derivative(x**2)* cos(x)'), parse_expr('x')))
a = parts_rule_application
# int u * v dx = u. int v - int u' (int v dx) dx
u = str(a.u)
v = str(a.v_step.context)
x = str(a.symbol)
res_step = parse_expr(
def analysis_indefinite_integral(f):
'''不定积分的计算'''
# 寻找原函数
steps = integral_steps(f, x)
analysis_steps(steps)
def test_issue_23348():
steps = integral_steps(tan(x), x)
constant_times_step = steps.substep.substep
assert constant_times_step.context == constant_times_step.constant * constant_times_step.other
def __init__(self):
self.runners = {
"integral_steps": lambda args: srepr(integral_steps(args[0], args[1])),
"equiv": lambda args: self.equivJson(args[0],args[1]),
"mirror": lambda args: srepr(args[0]),
}
