2074 lines
75 KiB
Python
2074 lines
75 KiB
Python
import math
|
|
from sympy.concrete.summations import (Sum, summation)
|
|
from sympy.core.add import Add
|
|
from sympy.core.containers import Tuple
|
|
from sympy.core.expr import Expr
|
|
from sympy.core.function import (Derivative, Function, Lambda, diff)
|
|
from sympy.core import EulerGamma
|
|
from sympy.core.numbers import (E, Float, I, Rational, nan, oo, pi, zoo)
|
|
from sympy.core.relational import (Eq, Ne)
|
|
from sympy.core.singleton import S
|
|
from sympy.core.symbol import (Symbol, symbols)
|
|
from sympy.core.sympify import sympify
|
|
from sympy.functions.elementary.complexes import (Abs, im, polar_lift, re, sign)
|
|
from sympy.functions.elementary.exponential import (LambertW, exp, exp_polar, log)
|
|
from sympy.functions.elementary.hyperbolic import (acosh, asinh, cosh, coth, csch, sinh, tanh, sech)
|
|
from sympy.functions.elementary.miscellaneous import (Max, Min, sqrt)
|
|
from sympy.functions.elementary.piecewise import Piecewise
|
|
from sympy.functions.elementary.trigonometric import (acos, asin, atan, cos, sin, sinc, tan, sec)
|
|
from sympy.functions.special.delta_functions import DiracDelta, Heaviside
|
|
from sympy.functions.special.error_functions import (Ci, Ei, Si, erf, erfc, erfi, fresnelc, li)
|
|
from sympy.functions.special.gamma_functions import (gamma, polygamma)
|
|
from sympy.functions.special.hyper import (hyper, meijerg)
|
|
from sympy.functions.special.singularity_functions import SingularityFunction
|
|
from sympy.functions.special.zeta_functions import lerchphi
|
|
from sympy.integrals.integrals import integrate
|
|
from sympy.logic.boolalg import And
|
|
from sympy.matrices.dense import Matrix
|
|
from sympy.polys.polytools import (Poly, factor)
|
|
from sympy.printing.str import sstr
|
|
from sympy.series.order import O
|
|
from sympy.sets.sets import Interval
|
|
from sympy.simplify.gammasimp import gammasimp
|
|
from sympy.simplify.simplify import simplify
|
|
from sympy.simplify.trigsimp import trigsimp
|
|
from sympy.tensor.indexed import (Idx, IndexedBase)
|
|
from sympy.core.expr import unchanged
|
|
from sympy.functions.elementary.integers import floor
|
|
from sympy.integrals.integrals import Integral
|
|
from sympy.integrals.risch import NonElementaryIntegral
|
|
from sympy.physics import units
|
|
from sympy.testing.pytest import (raises, slow, skip, ON_CI,
|
|
warns_deprecated_sympy, warns)
|
|
from sympy.utilities.exceptions import SymPyDeprecationWarning
|
|
from sympy.core.random import verify_numerically
|
|
|
|
|
|
x, y, z, a, b, c, d, e, s, t, x_1, x_2 = symbols('x y z a b c d e s t x_1 x_2')
|
|
n = Symbol('n', integer=True)
|
|
f = Function('f')
|
|
|
|
|
|
def NS(e, n=15, **options):
|
|
return sstr(sympify(e).evalf(n, **options), full_prec=True)
|
|
|
|
|
|
def test_poly_deprecated():
|
|
p = Poly(2*x, x)
|
|
assert p.integrate(x) == Poly(x**2, x, domain='QQ')
|
|
# The stacklevel is based on Integral(Poly)
|
|
with warns(SymPyDeprecationWarning, test_stacklevel=False):
|
|
integrate(p, x)
|
|
with warns(SymPyDeprecationWarning, test_stacklevel=False):
|
|
Integral(p, (x,))
|
|
|
|
|
|
@slow
|
|
def test_principal_value():
|
|
g = 1 / x
|
|
assert Integral(g, (x, -oo, oo)).principal_value() == 0
|
|
assert Integral(g, (y, -oo, oo)).principal_value() == oo * sign(1 / x)
|
|
raises(ValueError, lambda: Integral(g, (x)).principal_value())
|
|
raises(ValueError, lambda: Integral(g).principal_value())
|
|
|
|
l = 1 / ((x ** 3) - 1)
|
|
assert Integral(l, (x, -oo, oo)).principal_value().together() == -sqrt(3)*pi/3
|
|
raises(ValueError, lambda: Integral(l, (x, -oo, 1)).principal_value())
|
|
|
|
d = 1 / (x ** 2 - 1)
|
|
assert Integral(d, (x, -oo, oo)).principal_value() == 0
|
|
assert Integral(d, (x, -2, 2)).principal_value() == -log(3)
|
|
|
|
v = x / (x ** 2 - 1)
|
|
assert Integral(v, (x, -oo, oo)).principal_value() == 0
|
|
assert Integral(v, (x, -2, 2)).principal_value() == 0
|
|
|
|
s = x ** 2 / (x ** 2 - 1)
|
|
assert Integral(s, (x, -oo, oo)).principal_value() is oo
|
|
assert Integral(s, (x, -2, 2)).principal_value() == -log(3) + 4
|
|
|
|
f = 1 / ((x ** 2 - 1) * (1 + x ** 2))
|
|
assert Integral(f, (x, -oo, oo)).principal_value() == -pi / 2
|
|
assert Integral(f, (x, -2, 2)).principal_value() == -atan(2) - log(3) / 2
|
|
|
|
|
|
def diff_test(i):
|
|
"""Return the set of symbols, s, which were used in testing that
|
|
i.diff(s) agrees with i.doit().diff(s). If there is an error then
|
|
the assertion will fail, causing the test to fail."""
|
|
syms = i.free_symbols
|
|
for s in syms:
|
|
assert (i.diff(s).doit() - i.doit().diff(s)).expand() == 0
|
|
return syms
|
|
|
|
|
|
def test_improper_integral():
|
|
assert integrate(log(x), (x, 0, 1)) == -1
|
|
assert integrate(x**(-2), (x, 1, oo)) == 1
|
|
assert integrate(1/(1 + exp(x)), (x, 0, oo)) == log(2)
|
|
|
|
|
|
def test_constructor():
|
|
# this is shared by Sum, so testing Integral's constructor
|
|
# is equivalent to testing Sum's
|
|
s1 = Integral(n, n)
|
|
assert s1.limits == (Tuple(n),)
|
|
s2 = Integral(n, (n,))
|
|
assert s2.limits == (Tuple(n),)
|
|
s3 = Integral(Sum(x, (x, 1, y)))
|
|
assert s3.limits == (Tuple(y),)
|
|
s4 = Integral(n, Tuple(n,))
|
|
assert s4.limits == (Tuple(n),)
|
|
|
|
s5 = Integral(n, (n, Interval(1, 2)))
|
|
assert s5.limits == (Tuple(n, 1, 2),)
|
|
|
|
# Testing constructor with inequalities:
|
|
s6 = Integral(n, n > 10)
|
|
assert s6.limits == (Tuple(n, 10, oo),)
|
|
s7 = Integral(n, (n > 2) & (n < 5))
|
|
assert s7.limits == (Tuple(n, 2, 5),)
|
|
|
|
|
|
def test_basics():
|
|
|
|
assert Integral(0, x) != 0
|
|
assert Integral(x, (x, 1, 1)) != 0
|
|
assert Integral(oo, x) != oo
|
|
assert Integral(S.NaN, x) is S.NaN
|
|
|
|
assert diff(Integral(y, y), x) == 0
|
|
assert diff(Integral(x, (x, 0, 1)), x) == 0
|
|
assert diff(Integral(x, x), x) == x
|
|
assert diff(Integral(t, (t, 0, x)), x) == x
|
|
|
|
e = (t + 1)**2
|
|
assert diff(integrate(e, (t, 0, x)), x) == \
|
|
diff(Integral(e, (t, 0, x)), x).doit().expand() == \
|
|
((1 + x)**2).expand()
|
|
assert diff(integrate(e, (t, 0, x)), t) == \
|
|
diff(Integral(e, (t, 0, x)), t) == 0
|
|
assert diff(integrate(e, (t, 0, x)), a) == \
|
|
diff(Integral(e, (t, 0, x)), a) == 0
|
|
assert diff(integrate(e, t), a) == diff(Integral(e, t), a) == 0
|
|
|
|
assert integrate(e, (t, a, x)).diff(x) == \
|
|
Integral(e, (t, a, x)).diff(x).doit().expand()
|
|
assert Integral(e, (t, a, x)).diff(x).doit() == ((1 + x)**2)
|
|
assert integrate(e, (t, x, a)).diff(x).doit() == (-(1 + x)**2).expand()
|
|
|
|
assert integrate(t**2, (t, x, 2*x)).diff(x) == 7*x**2
|
|
|
|
assert Integral(x, x).atoms() == {x}
|
|
assert Integral(f(x), (x, 0, 1)).atoms() == {S.Zero, S.One, x}
|
|
|
|
assert diff_test(Integral(x, (x, 3*y))) == {y}
|
|
assert diff_test(Integral(x, (a, 3*y))) == {x, y}
|
|
|
|
assert integrate(x, (x, oo, oo)) == 0 #issue 8171
|
|
assert integrate(x, (x, -oo, -oo)) == 0
|
|
|
|
# sum integral of terms
|
|
assert integrate(y + x + exp(x), x) == x*y + x**2/2 + exp(x)
|
|
|
|
assert Integral(x).is_commutative
|
|
n = Symbol('n', commutative=False)
|
|
assert Integral(n + x, x).is_commutative is False
|
|
|
|
|
|
def test_diff_wrt():
|
|
class Test(Expr):
|
|
_diff_wrt = True
|
|
is_commutative = True
|
|
|
|
t = Test()
|
|
assert integrate(t + 1, t) == t**2/2 + t
|
|
assert integrate(t + 1, (t, 0, 1)) == Rational(3, 2)
|
|
|
|
raises(ValueError, lambda: integrate(x + 1, x + 1))
|
|
raises(ValueError, lambda: integrate(x + 1, (x + 1, 0, 1)))
|
|
|
|
|
|
def test_basics_multiple():
|
|
assert diff_test(Integral(x, (x, 3*x, 5*y), (y, x, 2*x))) == {x}
|
|
assert diff_test(Integral(x, (x, 5*y), (y, x, 2*x))) == {x}
|
|
assert diff_test(Integral(x, (x, 5*y), (y, y, 2*x))) == {x, y}
|
|
assert diff_test(Integral(y, y, x)) == {x, y}
|
|
assert diff_test(Integral(y*x, x, y)) == {x, y}
|
|
assert diff_test(Integral(x + y, y, (y, 1, x))) == {x}
|
|
assert diff_test(Integral(x + y, (x, x, y), (y, y, x))) == {x, y}
|
|
|
|
|
|
def test_conjugate_transpose():
|
|
A, B = symbols("A B", commutative=False)
|
|
|
|
x = Symbol("x", complex=True)
|
|
p = Integral(A*B, (x,))
|
|
assert p.adjoint().doit() == p.doit().adjoint()
|
|
assert p.conjugate().doit() == p.doit().conjugate()
|
|
assert p.transpose().doit() == p.doit().transpose()
|
|
|
|
x = Symbol("x", real=True)
|
|
p = Integral(A*B, (x,))
|
|
assert p.adjoint().doit() == p.doit().adjoint()
|
|
assert p.conjugate().doit() == p.doit().conjugate()
|
|
assert p.transpose().doit() == p.doit().transpose()
|
|
|
|
|
|
def test_integration():
|
|
assert integrate(0, (t, 0, x)) == 0
|
|
assert integrate(3, (t, 0, x)) == 3*x
|
|
assert integrate(t, (t, 0, x)) == x**2/2
|
|
assert integrate(3*t, (t, 0, x)) == 3*x**2/2
|
|
assert integrate(3*t**2, (t, 0, x)) == x**3
|
|
assert integrate(1/t, (t, 1, x)) == log(x)
|
|
assert integrate(-1/t**2, (t, 1, x)) == 1/x - 1
|
|
assert integrate(t**2 + 5*t - 8, (t, 0, x)) == x**3/3 + 5*x**2/2 - 8*x
|
|
assert integrate(x**2, x) == x**3/3
|
|
assert integrate((3*t*x)**5, x) == (3*t)**5 * x**6 / 6
|
|
|
|
b = Symbol("b")
|
|
c = Symbol("c")
|
|
assert integrate(a*t, (t, 0, x)) == a*x**2/2
|
|
assert integrate(a*t**4, (t, 0, x)) == a*x**5/5
|
|
assert integrate(a*t**2 + b*t + c, (t, 0, x)) == a*x**3/3 + b*x**2/2 + c*x
|
|
|
|
|
|
def test_multiple_integration():
|
|
assert integrate((x**2)*(y**2), (x, 0, 1), (y, -1, 2)) == Rational(1)
|
|
assert integrate((y**2)*(x**2), x, y) == Rational(1, 9)*(x**3)*(y**3)
|
|
assert integrate(1/(x + 3)/(1 + x)**3, x) == \
|
|
log(3 + x)*Rational(-1, 8) + log(1 + x)*Rational(1, 8) + x/(4 + 8*x + 4*x**2)
|
|
assert integrate(sin(x*y)*y, (x, 0, 1), (y, 0, 1)) == -sin(1) + 1
|
|
|
|
|
|
def test_issue_3532():
|
|
assert integrate(exp(-x), (x, 0, oo)) == 1
|
|
|
|
|
|
def test_issue_3560():
|
|
assert integrate(sqrt(x)**3, x) == 2*sqrt(x)**5/5
|
|
assert integrate(sqrt(x), x) == 2*sqrt(x)**3/3
|
|
assert integrate(1/sqrt(x)**3, x) == -2/sqrt(x)
|
|
|
|
|
|
def test_issue_18038():
|
|
raises(AttributeError, lambda: integrate((x, x)))
|
|
|
|
|
|
def test_integrate_poly():
|
|
p = Poly(x + x**2*y + y**3, x, y)
|
|
|
|
# The stacklevel is based on Integral(Poly)
|
|
with warns_deprecated_sympy():
|
|
qx = Integral(p, x)
|
|
with warns(SymPyDeprecationWarning, test_stacklevel=False):
|
|
qx = integrate(p, x)
|
|
with warns(SymPyDeprecationWarning, test_stacklevel=False):
|
|
qy = integrate(p, y)
|
|
|
|
assert isinstance(qx, Poly) is True
|
|
assert isinstance(qy, Poly) is True
|
|
|
|
assert qx.gens == (x, y)
|
|
assert qy.gens == (x, y)
|
|
|
|
assert qx.as_expr() == x**2/2 + x**3*y/3 + x*y**3
|
|
assert qy.as_expr() == x*y + x**2*y**2/2 + y**4/4
|
|
|
|
|
|
def test_integrate_poly_definite():
|
|
p = Poly(x + x**2*y + y**3, x, y)
|
|
|
|
with warns_deprecated_sympy():
|
|
Qx = Integral(p, (x, 0, 1))
|
|
with warns(SymPyDeprecationWarning, test_stacklevel=False):
|
|
Qx = integrate(p, (x, 0, 1))
|
|
with warns(SymPyDeprecationWarning, test_stacklevel=False):
|
|
Qy = integrate(p, (y, 0, pi))
|
|
|
|
assert isinstance(Qx, Poly) is True
|
|
assert isinstance(Qy, Poly) is True
|
|
|
|
assert Qx.gens == (y,)
|
|
assert Qy.gens == (x,)
|
|
|
|
assert Qx.as_expr() == S.Half + y/3 + y**3
|
|
assert Qy.as_expr() == pi**4/4 + pi*x + pi**2*x**2/2
|
|
|
|
|
|
def test_integrate_omit_var():
|
|
y = Symbol('y')
|
|
|
|
assert integrate(x) == x**2/2
|
|
|
|
raises(ValueError, lambda: integrate(2))
|
|
raises(ValueError, lambda: integrate(x*y))
|
|
|
|
|
|
def test_integrate_poly_accurately():
|
|
y = Symbol('y')
|
|
assert integrate(x*sin(y), x) == x**2*sin(y)/2
|
|
|
|
# when passed to risch_norman, this will be a CPU hog, so this really
|
|
# checks, that integrated function is recognized as polynomial
|
|
assert integrate(x**1000*sin(y), x) == x**1001*sin(y)/1001
|
|
|
|
|
|
def test_issue_3635():
|
|
y = Symbol('y')
|
|
assert integrate(x**2, y) == x**2*y
|
|
assert integrate(x**2, (y, -1, 1)) == 2*x**2
|
|
|
|
# works in SymPy and py.test but hangs in `setup.py test`
|
|
|
|
|
|
def test_integrate_linearterm_pow():
|
|
# check integrate((a*x+b)^c, x) -- issue 3499
|
|
y = Symbol('y', positive=True)
|
|
# TODO: Remove conds='none' below, let the assumption take care of it.
|
|
assert integrate(x**y, x, conds='none') == x**(y + 1)/(y + 1)
|
|
assert integrate((exp(y)*x + 1/y)**(1 + sin(y)), x, conds='none') == \
|
|
exp(-y)*(exp(y)*x + 1/y)**(2 + sin(y)) / (2 + sin(y))
|
|
|
|
|
|
def test_issue_3618():
|
|
assert integrate(pi*sqrt(x), x) == 2*pi*sqrt(x)**3/3
|
|
assert integrate(pi*sqrt(x) + E*sqrt(x)**3, x) == \
|
|
2*pi*sqrt(x)**3/3 + 2*E *sqrt(x)**5/5
|
|
|
|
|
|
def test_issue_3623():
|
|
assert integrate(cos((n + 1)*x), x) == Piecewise(
|
|
(sin(x*(n + 1))/(n + 1), Ne(n + 1, 0)), (x, True))
|
|
assert integrate(cos((n - 1)*x), x) == Piecewise(
|
|
(sin(x*(n - 1))/(n - 1), Ne(n - 1, 0)), (x, True))
|
|
assert integrate(cos((n + 1)*x) + cos((n - 1)*x), x) == \
|
|
Piecewise((sin(x*(n - 1))/(n - 1), Ne(n - 1, 0)), (x, True)) + \
|
|
Piecewise((sin(x*(n + 1))/(n + 1), Ne(n + 1, 0)), (x, True))
|
|
|
|
|
|
def test_issue_3664():
|
|
n = Symbol('n', integer=True, nonzero=True)
|
|
assert integrate(-1./2 * x * sin(n * pi * x/2), [x, -2, 0]) == \
|
|
2.0*cos(pi*n)/(pi*n)
|
|
assert integrate(x * sin(n * pi * x/2) * Rational(-1, 2), [x, -2, 0]) == \
|
|
2*cos(pi*n)/(pi*n)
|
|
|
|
|
|
def test_issue_3679():
|
|
# definite integration of rational functions gives wrong answers
|
|
assert NS(Integral(1/(x**2 - 8*x + 17), (x, 2, 4))) == '1.10714871779409'
|
|
|
|
|
|
def test_issue_3686(): # remove this when fresnel integrals are implemented
|
|
from sympy.core.function import expand_func
|
|
from sympy.functions.special.error_functions import fresnels
|
|
assert expand_func(integrate(sin(x**2), x)) == \
|
|
sqrt(2)*sqrt(pi)*fresnels(sqrt(2)*x/sqrt(pi))/2
|
|
|
|
|
|
def test_integrate_units():
|
|
m = units.m
|
|
s = units.s
|
|
assert integrate(x * m/s, (x, 1*s, 5*s)) == 12*m*s
|
|
|
|
|
|
def test_transcendental_functions():
|
|
assert integrate(LambertW(2*x), x) == \
|
|
-x + x*LambertW(2*x) + x/LambertW(2*x)
|
|
|
|
|
|
def test_log_polylog():
|
|
assert integrate(log(1 - x)/x, (x, 0, 1)) == -pi**2/6
|
|
assert integrate(log(x)*(1 - x)**(-1), (x, 0, 1)) == -pi**2/6
|
|
|
|
|
|
def test_issue_3740():
|
|
f = 4*log(x) - 2*log(x)**2
|
|
fid = diff(integrate(f, x), x)
|
|
assert abs(f.subs(x, 42).evalf() - fid.subs(x, 42).evalf()) < 1e-10
|
|
|
|
|
|
def test_issue_3788():
|
|
assert integrate(1/(1 + x**2), x) == atan(x)
|
|
|
|
|
|
def test_issue_3952():
|
|
f = sin(x)
|
|
assert integrate(f, x) == -cos(x)
|
|
raises(ValueError, lambda: integrate(f, 2*x))
|
|
|
|
|
|
def test_issue_4516():
|
|
assert integrate(2**x - 2*x, x) == 2**x/log(2) - x**2
|
|
|
|
|
|
def test_issue_7450():
|
|
ans = integrate(exp(-(1 + I)*x), (x, 0, oo))
|
|
assert re(ans) == S.Half and im(ans) == Rational(-1, 2)
|
|
|
|
|
|
def test_issue_8623():
|
|
assert integrate((1 + cos(2*x)) / (3 - 2*cos(2*x)), (x, 0, pi)) == -pi/2 + sqrt(5)*pi/2
|
|
assert integrate((1 + cos(2*x))/(3 - 2*cos(2*x))) == -x/2 + sqrt(5)*(atan(sqrt(5)*tan(x)) + \
|
|
pi*floor((x - pi/2)/pi))/2
|
|
|
|
|
|
def test_issue_9569():
|
|
assert integrate(1 / (2 - cos(x)), (x, 0, pi)) == pi/sqrt(3)
|
|
assert integrate(1/(2 - cos(x))) == 2*sqrt(3)*(atan(sqrt(3)*tan(x/2)) + pi*floor((x/2 - pi/2)/pi))/3
|
|
|
|
|
|
def test_issue_13733():
|
|
s = Symbol('s', positive=True)
|
|
pz = exp(-(z - y)**2/(2*s*s))/sqrt(2*pi*s*s)
|
|
pzgx = integrate(pz, (z, x, oo))
|
|
assert integrate(pzgx, (x, 0, oo)) == sqrt(2)*s*exp(-y**2/(2*s**2))/(2*sqrt(pi)) + \
|
|
y*erf(sqrt(2)*y/(2*s))/2 + y/2
|
|
|
|
|
|
def test_issue_13749():
|
|
assert integrate(1 / (2 + cos(x)), (x, 0, pi)) == pi/sqrt(3)
|
|
assert integrate(1/(2 + cos(x))) == 2*sqrt(3)*(atan(sqrt(3)*tan(x/2)/3) + pi*floor((x/2 - pi/2)/pi))/3
|
|
|
|
|
|
def test_issue_18133():
|
|
assert integrate(exp(x)/(1 + x)**2, x) == NonElementaryIntegral(exp(x)/(x + 1)**2, x)
|
|
|
|
|
|
def test_issue_21741():
|
|
a = Float('3999999.9999999995', precision=53)
|
|
b = Float('2.5000000000000004e-7', precision=53)
|
|
r = Piecewise((b*I*exp(-a*I*pi*t*y)*exp(-a*I*pi*x*z)/(pi*x),
|
|
Ne(1.0*pi*x*exp(a*I*pi*t*y), 0)),
|
|
(z*exp(-a*I*pi*t*y), True))
|
|
fun = E**((-2*I*pi*(z*x+t*y))/(500*10**(-9)))
|
|
assert integrate(fun, z) == r
|
|
|
|
|
|
def test_matrices():
|
|
M = Matrix(2, 2, lambda i, j: (i + j + 1)*sin((i + j + 1)*x))
|
|
|
|
assert integrate(M, x) == Matrix([
|
|
[-cos(x), -cos(2*x)],
|
|
[-cos(2*x), -cos(3*x)],
|
|
])
|
|
|
|
|
|
def test_integrate_functions():
|
|
# issue 4111
|
|
assert integrate(f(x), x) == Integral(f(x), x)
|
|
assert integrate(f(x), (x, 0, 1)) == Integral(f(x), (x, 0, 1))
|
|
assert integrate(f(x)*diff(f(x), x), x) == f(x)**2/2
|
|
assert integrate(diff(f(x), x) / f(x), x) == log(f(x))
|
|
|
|
|
|
def test_integrate_derivatives():
|
|
assert integrate(Derivative(f(x), x), x) == f(x)
|
|
assert integrate(Derivative(f(y), y), x) == x*Derivative(f(y), y)
|
|
assert integrate(Derivative(f(x), x)**2, x) == \
|
|
Integral(Derivative(f(x), x)**2, x)
|
|
|
|
|
|
def test_transform():
|
|
a = Integral(x**2 + 1, (x, -1, 2))
|
|
fx = x
|
|
fy = 3*y + 1
|
|
assert a.doit() == a.transform(fx, fy).doit()
|
|
assert a.transform(fx, fy).transform(fy, fx) == a
|
|
fx = 3*x + 1
|
|
fy = y
|
|
assert a.transform(fx, fy).transform(fy, fx) == a
|
|
a = Integral(sin(1/x), (x, 0, 1))
|
|
assert a.transform(x, 1/y) == Integral(sin(y)/y**2, (y, 1, oo))
|
|
assert a.transform(x, 1/y).transform(y, 1/x) == a
|
|
a = Integral(exp(-x**2), (x, -oo, oo))
|
|
assert a.transform(x, 2*y) == Integral(2*exp(-4*y**2), (y, -oo, oo))
|
|
# < 3 arg limit handled properly
|
|
assert Integral(x, x).transform(x, a*y).doit() == \
|
|
Integral(y*a**2, y).doit()
|
|
_3 = S(3)
|
|
assert Integral(x, (x, 0, -_3)).transform(x, 1/y).doit() == \
|
|
Integral(-1/x**3, (x, -oo, -1/_3)).doit()
|
|
assert Integral(x, (x, 0, _3)).transform(x, 1/y) == \
|
|
Integral(y**(-3), (y, 1/_3, oo))
|
|
# issue 8400
|
|
i = Integral(x + y, (x, 1, 2), (y, 1, 2))
|
|
assert i.transform(x, (x + 2*y, x)).doit() == \
|
|
i.transform(x, (x + 2*z, x)).doit() == 3
|
|
|
|
i = Integral(x, (x, a, b))
|
|
assert i.transform(x, 2*s) == Integral(4*s, (s, a/2, b/2))
|
|
raises(ValueError, lambda: i.transform(x, 1))
|
|
raises(ValueError, lambda: i.transform(x, s*t))
|
|
raises(ValueError, lambda: i.transform(x, -s))
|
|
raises(ValueError, lambda: i.transform(x, (s, t)))
|
|
raises(ValueError, lambda: i.transform(2*x, 2*s))
|
|
|
|
i = Integral(x**2, (x, 1, 2))
|
|
raises(ValueError, lambda: i.transform(x**2, s))
|
|
|
|
am = Symbol('a', negative=True)
|
|
bp = Symbol('b', positive=True)
|
|
i = Integral(x, (x, bp, am))
|
|
i.transform(x, 2*s)
|
|
assert i.transform(x, 2*s) == Integral(-4*s, (s, am/2, bp/2))
|
|
|
|
i = Integral(x, (x, a))
|
|
assert i.transform(x, 2*s) == Integral(4*s, (s, a/2))
|
|
|
|
|
|
def test_issue_4052():
|
|
f = S.Half*asin(x) + x*sqrt(1 - x**2)/2
|
|
|
|
assert integrate(cos(asin(x)), x) == f
|
|
assert integrate(sin(acos(x)), x) == f
|
|
|
|
|
|
@slow
|
|
def test_evalf_integrals():
|
|
assert NS(Integral(x, (x, 2, 5)), 15) == '10.5000000000000'
|
|
gauss = Integral(exp(-x**2), (x, -oo, oo))
|
|
assert NS(gauss, 15) == '1.77245385090552'
|
|
assert NS(gauss**2 - pi + E*Rational(
|
|
1, 10**20), 15) in ('2.71828182845904e-20', '2.71828182845905e-20')
|
|
# A monster of an integral from http://mathworld.wolfram.com/DefiniteIntegral.html
|
|
t = Symbol('t')
|
|
a = 8*sqrt(3)/(1 + 3*t**2)
|
|
b = 16*sqrt(2)*(3*t + 1)*sqrt(4*t**2 + t + 1)**3
|
|
c = (3*t**2 + 1)*(11*t**2 + 2*t + 3)**2
|
|
d = sqrt(2)*(249*t**2 + 54*t + 65)/(11*t**2 + 2*t + 3)**2
|
|
f = a - b/c - d
|
|
assert NS(Integral(f, (t, 0, 1)), 50) == \
|
|
NS((3*sqrt(2) - 49*pi + 162*atan(sqrt(2)))/12, 50)
|
|
# http://mathworld.wolfram.com/VardisIntegral.html
|
|
assert NS(Integral(log(log(1/x))/(1 + x + x**2), (x, 0, 1)), 15) == \
|
|
NS('pi/sqrt(3) * log(2*pi**(5/6) / gamma(1/6))', 15)
|
|
# http://mathworld.wolfram.com/AhmedsIntegral.html
|
|
assert NS(Integral(atan(sqrt(x**2 + 2))/(sqrt(x**2 + 2)*(x**2 + 1)), (x,
|
|
0, 1)), 15) == NS(5*pi**2/96, 15)
|
|
# http://mathworld.wolfram.com/AbelsIntegral.html
|
|
assert NS(Integral(x/((exp(pi*x) - exp(
|
|
-pi*x))*(x**2 + 1)), (x, 0, oo)), 15) == NS('log(2)/2-1/4', 15)
|
|
# Complex part trimming
|
|
# http://mathworld.wolfram.com/VardisIntegral.html
|
|
assert NS(Integral(log(log(sin(x)/cos(x))), (x, pi/4, pi/2)), 15, chop=True) == \
|
|
NS('pi/4*log(4*pi**3/gamma(1/4)**4)', 15)
|
|
#
|
|
# Endpoints causing trouble (rounding error in integration points -> complex log)
|
|
assert NS(
|
|
2 + Integral(log(2*cos(x/2)), (x, -pi, pi)), 17, chop=True) == NS(2, 17)
|
|
assert NS(
|
|
2 + Integral(log(2*cos(x/2)), (x, -pi, pi)), 20, chop=True) == NS(2, 20)
|
|
assert NS(
|
|
2 + Integral(log(2*cos(x/2)), (x, -pi, pi)), 22, chop=True) == NS(2, 22)
|
|
# Needs zero handling
|
|
assert NS(pi - 4*Integral(
|
|
'sqrt(1-x**2)', (x, 0, 1)), 15, maxn=30, chop=True) in ('0.0', '0')
|
|
# Oscillatory quadrature
|
|
a = Integral(sin(x)/x**2, (x, 1, oo)).evalf(maxn=15)
|
|
assert 0.49 < a < 0.51
|
|
assert NS(
|
|
Integral(sin(x)/x**2, (x, 1, oo)), quad='osc') == '0.504067061906928'
|
|
assert NS(Integral(
|
|
cos(pi*x + 1)/x, (x, -oo, -1)), quad='osc') == '0.276374705640365'
|
|
# indefinite integrals aren't evaluated
|
|
assert NS(Integral(x, x)) == 'Integral(x, x)'
|
|
assert NS(Integral(x, (x, y))) == 'Integral(x, (x, y))'
|
|
|
|
|
|
def test_evalf_issue_939():
|
|
# https://github.com/sympy/sympy/issues/4038
|
|
|
|
# The output form of an integral may differ by a step function between
|
|
# revisions, making this test a bit useless. This can't be said about
|
|
# other two tests. For now, all values of this evaluation are used here,
|
|
# but in future this should be reconsidered.
|
|
assert NS(integrate(1/(x**5 + 1), x).subs(x, 4), chop=True) in \
|
|
['-0.000976138910649103', '0.965906660135753', '1.93278945918216']
|
|
|
|
assert NS(Integral(1/(x**5 + 1), (x, 2, 4))) == '0.0144361088886740'
|
|
assert NS(
|
|
integrate(1/(x**5 + 1), (x, 2, 4)), chop=True) == '0.0144361088886740'
|
|
|
|
|
|
def test_double_previously_failing_integrals():
|
|
# Double integrals not implemented <- Sure it is!
|
|
res = integrate(sqrt(x) + x*y, (x, 1, 2), (y, -1, 1))
|
|
# Old numerical test
|
|
assert NS(res, 15) == '2.43790283299492'
|
|
# Symbolic test
|
|
assert res == Rational(-4, 3) + 8*sqrt(2)/3
|
|
# double integral + zero detection
|
|
assert integrate(sin(x + x*y), (x, -1, 1), (y, -1, 1)) is S.Zero
|
|
|
|
|
|
def test_integrate_SingularityFunction():
|
|
in_1 = SingularityFunction(x, a, 3) + SingularityFunction(x, 5, -1)
|
|
out_1 = SingularityFunction(x, a, 4)/4 + SingularityFunction(x, 5, 0)
|
|
assert integrate(in_1, x) == out_1
|
|
|
|
in_2 = 10*SingularityFunction(x, 4, 0) - 5*SingularityFunction(x, -6, -2)
|
|
out_2 = 10*SingularityFunction(x, 4, 1) - 5*SingularityFunction(x, -6, -1)
|
|
assert integrate(in_2, x) == out_2
|
|
|
|
in_3 = 2*x**2*y -10*SingularityFunction(x, -4, 7) - 2*SingularityFunction(y, 10, -2)
|
|
out_3_1 = 2*x**3*y/3 - 2*x*SingularityFunction(y, 10, -2) - 5*SingularityFunction(x, -4, 8)/4
|
|
out_3_2 = x**2*y**2 - 10*y*SingularityFunction(x, -4, 7) - 2*SingularityFunction(y, 10, -1)
|
|
assert integrate(in_3, x) == out_3_1
|
|
assert integrate(in_3, y) == out_3_2
|
|
|
|
assert unchanged(Integral, in_3, (x,))
|
|
assert Integral(in_3, x) == Integral(in_3, (x,))
|
|
assert Integral(in_3, x).doit() == out_3_1
|
|
|
|
in_4 = 10*SingularityFunction(x, -4, 7) - 2*SingularityFunction(x, 10, -2)
|
|
out_4 = 5*SingularityFunction(x, -4, 8)/4 - 2*SingularityFunction(x, 10, -1)
|
|
assert integrate(in_4, (x, -oo, x)) == out_4
|
|
|
|
assert integrate(SingularityFunction(x, 5, -1), x) == SingularityFunction(x, 5, 0)
|
|
assert integrate(SingularityFunction(x, 0, -1), (x, -oo, oo)) == 1
|
|
assert integrate(5*SingularityFunction(x, 5, -1), (x, -oo, oo)) == 5
|
|
assert integrate(SingularityFunction(x, 5, -1) * f(x), (x, -oo, oo)) == f(5)
|
|
|
|
|
|
def test_integrate_DiracDelta():
|
|
# This is here to check that deltaintegrate is being called, but also
|
|
# to test definite integrals. More tests are in test_deltafunctions.py
|
|
assert integrate(DiracDelta(x) * f(x), (x, -oo, oo)) == f(0)
|
|
assert integrate(DiracDelta(x)**2, (x, -oo, oo)) == DiracDelta(0)
|
|
# issue 4522
|
|
assert integrate(integrate((4 - 4*x + x*y - 4*y) * \
|
|
DiracDelta(x)*DiracDelta(y - 1), (x, 0, 1)), (y, 0, 1)) == 0
|
|
# issue 5729
|
|
p = exp(-(x**2 + y**2))/pi
|
|
assert integrate(p*DiracDelta(x - 10*y), (x, -oo, oo), (y, -oo, oo)) == \
|
|
integrate(p*DiracDelta(x - 10*y), (y, -oo, oo), (x, -oo, oo)) == \
|
|
integrate(p*DiracDelta(10*x - y), (x, -oo, oo), (y, -oo, oo)) == \
|
|
integrate(p*DiracDelta(10*x - y), (y, -oo, oo), (x, -oo, oo)) == \
|
|
1/sqrt(101*pi)
|
|
|
|
|
|
def test_integrate_returns_piecewise():
|
|
assert integrate(x**y, x) == Piecewise(
|
|
(x**(y + 1)/(y + 1), Ne(y, -1)), (log(x), True))
|
|
assert integrate(x**y, y) == Piecewise(
|
|
(x**y/log(x), Ne(log(x), 0)), (y, True))
|
|
assert integrate(exp(n*x), x) == Piecewise(
|
|
(exp(n*x)/n, Ne(n, 0)), (x, True))
|
|
assert integrate(x*exp(n*x), x) == Piecewise(
|
|
((n*x - 1)*exp(n*x)/n**2, Ne(n**2, 0)), (x**2/2, True))
|
|
assert integrate(x**(n*y), x) == Piecewise(
|
|
(x**(n*y + 1)/(n*y + 1), Ne(n*y, -1)), (log(x), True))
|
|
assert integrate(x**(n*y), y) == Piecewise(
|
|
(x**(n*y)/(n*log(x)), Ne(n*log(x), 0)), (y, True))
|
|
assert integrate(cos(n*x), x) == Piecewise(
|
|
(sin(n*x)/n, Ne(n, 0)), (x, True))
|
|
assert integrate(cos(n*x)**2, x) == Piecewise(
|
|
((n*x/2 + sin(n*x)*cos(n*x)/2)/n, Ne(n, 0)), (x, True))
|
|
assert integrate(x*cos(n*x), x) == Piecewise(
|
|
(x*sin(n*x)/n + cos(n*x)/n**2, Ne(n, 0)), (x**2/2, True))
|
|
assert integrate(sin(n*x), x) == Piecewise(
|
|
(-cos(n*x)/n, Ne(n, 0)), (0, True))
|
|
assert integrate(sin(n*x)**2, x) == Piecewise(
|
|
((n*x/2 - sin(n*x)*cos(n*x)/2)/n, Ne(n, 0)), (0, True))
|
|
assert integrate(x*sin(n*x), x) == Piecewise(
|
|
(-x*cos(n*x)/n + sin(n*x)/n**2, Ne(n, 0)), (0, True))
|
|
assert integrate(exp(x*y), (x, 0, z)) == Piecewise(
|
|
(exp(y*z)/y - 1/y, (y > -oo) & (y < oo) & Ne(y, 0)), (z, True))
|
|
# https://github.com/sympy/sympy/issues/23707
|
|
assert integrate(exp(t)*exp(-t*sqrt(x - y)), t) == Piecewise(
|
|
(-exp(t)/(sqrt(x - y)*exp(t*sqrt(x - y)) - exp(t*sqrt(x - y))),
|
|
Ne(x, y + 1)), (t, True))
|
|
|
|
|
|
def test_integrate_max_min():
|
|
x = symbols('x', real=True)
|
|
assert integrate(Min(x, 2), (x, 0, 3)) == 4
|
|
assert integrate(Max(x**2, x**3), (x, 0, 2)) == Rational(49, 12)
|
|
assert integrate(Min(exp(x), exp(-x))**2, x) == Piecewise( \
|
|
(exp(2*x)/2, x <= 0), (1 - exp(-2*x)/2, True))
|
|
# issue 7907
|
|
c = symbols('c', extended_real=True)
|
|
int1 = integrate(Max(c, x)*exp(-x**2), (x, -oo, oo))
|
|
int2 = integrate(c*exp(-x**2), (x, -oo, c))
|
|
int3 = integrate(x*exp(-x**2), (x, c, oo))
|
|
assert int1 == int2 + int3 == sqrt(pi)*c*erf(c)/2 + \
|
|
sqrt(pi)*c/2 + exp(-c**2)/2
|
|
|
|
|
|
def test_integrate_Abs_sign():
|
|
assert integrate(Abs(x), (x, -2, 1)) == Rational(5, 2)
|
|
assert integrate(Abs(x), (x, 0, 1)) == S.Half
|
|
assert integrate(Abs(x + 1), (x, 0, 1)) == Rational(3, 2)
|
|
assert integrate(Abs(x**2 - 1), (x, -2, 2)) == 4
|
|
assert integrate(Abs(x**2 - 3*x), (x, -15, 15)) == 2259
|
|
assert integrate(sign(x), (x, -1, 2)) == 1
|
|
assert integrate(sign(x)*sin(x), (x, -pi, pi)) == 4
|
|
assert integrate(sign(x - 2) * x**2, (x, 0, 3)) == Rational(11, 3)
|
|
|
|
t, s = symbols('t s', real=True)
|
|
assert integrate(Abs(t), t) == Piecewise(
|
|
(-t**2/2, t <= 0), (t**2/2, True))
|
|
assert integrate(Abs(2*t - 6), t) == Piecewise(
|
|
(-t**2 + 6*t, t <= 3), (t**2 - 6*t + 18, True))
|
|
assert (integrate(abs(t - s**2), (t, 0, 2)) ==
|
|
2*s**2*Min(2, s**2) - 2*s**2 - Min(2, s**2)**2 + 2)
|
|
assert integrate(exp(-Abs(t)), t) == Piecewise(
|
|
(exp(t), t <= 0), (2 - exp(-t), True))
|
|
assert integrate(sign(2*t - 6), t) == Piecewise(
|
|
(-t, t < 3), (t - 6, True))
|
|
assert integrate(2*t*sign(t**2 - 1), t) == Piecewise(
|
|
(t**2, t < -1), (-t**2 + 2, t < 1), (t**2, True))
|
|
assert integrate(sign(t), (t, s + 1)) == Piecewise(
|
|
(s + 1, s + 1 > 0), (-s - 1, s + 1 < 0), (0, True))
|
|
|
|
|
|
def test_subs1():
|
|
e = Integral(exp(x - y), x)
|
|
assert e.subs(y, 3) == Integral(exp(x - 3), x)
|
|
e = Integral(exp(x - y), (x, 0, 1))
|
|
assert e.subs(y, 3) == Integral(exp(x - 3), (x, 0, 1))
|
|
f = Lambda(x, exp(-x**2))
|
|
conv = Integral(f(x - y)*f(y), (y, -oo, oo))
|
|
assert conv.subs({x: 0}) == Integral(exp(-2*y**2), (y, -oo, oo))
|
|
|
|
|
|
def test_subs2():
|
|
e = Integral(exp(x - y), x, t)
|
|
assert e.subs(y, 3) == Integral(exp(x - 3), x, t)
|
|
e = Integral(exp(x - y), (x, 0, 1), (t, 0, 1))
|
|
assert e.subs(y, 3) == Integral(exp(x - 3), (x, 0, 1), (t, 0, 1))
|
|
f = Lambda(x, exp(-x**2))
|
|
conv = Integral(f(x - y)*f(y), (y, -oo, oo), (t, 0, 1))
|
|
assert conv.subs({x: 0}) == Integral(exp(-2*y**2), (y, -oo, oo), (t, 0, 1))
|
|
|
|
|
|
def test_subs3():
|
|
e = Integral(exp(x - y), (x, 0, y), (t, y, 1))
|
|
assert e.subs(y, 3) == Integral(exp(x - 3), (x, 0, 3), (t, 3, 1))
|
|
f = Lambda(x, exp(-x**2))
|
|
conv = Integral(f(x - y)*f(y), (y, -oo, oo), (t, x, 1))
|
|
assert conv.subs({x: 0}) == Integral(exp(-2*y**2), (y, -oo, oo), (t, 0, 1))
|
|
|
|
|
|
def test_subs4():
|
|
e = Integral(exp(x), (x, 0, y), (t, y, 1))
|
|
assert e.subs(y, 3) == Integral(exp(x), (x, 0, 3), (t, 3, 1))
|
|
f = Lambda(x, exp(-x**2))
|
|
conv = Integral(f(y)*f(y), (y, -oo, oo), (t, x, 1))
|
|
assert conv.subs({x: 0}) == Integral(exp(-2*y**2), (y, -oo, oo), (t, 0, 1))
|
|
|
|
|
|
def test_subs5():
|
|
e = Integral(exp(-x**2), (x, -oo, oo))
|
|
assert e.subs(x, 5) == e
|
|
e = Integral(exp(-x**2 + y), x)
|
|
assert e.subs(y, 5) == Integral(exp(-x**2 + 5), x)
|
|
e = Integral(exp(-x**2 + y), (x, x))
|
|
assert e.subs(x, 5) == Integral(exp(y - x**2), (x, 5))
|
|
assert e.subs(y, 5) == Integral(exp(-x**2 + 5), x)
|
|
e = Integral(exp(-x**2 + y), (y, -oo, oo), (x, -oo, oo))
|
|
assert e.subs(x, 5) == e
|
|
assert e.subs(y, 5) == e
|
|
# Test evaluation of antiderivatives
|
|
e = Integral(exp(-x**2), (x, x))
|
|
assert e.subs(x, 5) == Integral(exp(-x**2), (x, 5))
|
|
e = Integral(exp(x), x)
|
|
assert (e.subs(x,1) - e.subs(x,0) - Integral(exp(x), (x, 0, 1))
|
|
).doit().is_zero
|
|
|
|
|
|
def test_subs6():
|
|
a, b = symbols('a b')
|
|
e = Integral(x*y, (x, f(x), f(y)))
|
|
assert e.subs(x, 1) == Integral(x*y, (x, f(1), f(y)))
|
|
assert e.subs(y, 1) == Integral(x, (x, f(x), f(1)))
|
|
e = Integral(x*y, (x, f(x), f(y)), (y, f(x), f(y)))
|
|
assert e.subs(x, 1) == Integral(x*y, (x, f(1), f(y)), (y, f(1), f(y)))
|
|
assert e.subs(y, 1) == Integral(x*y, (x, f(x), f(y)), (y, f(x), f(1)))
|
|
e = Integral(x*y, (x, f(x), f(a)), (y, f(x), f(a)))
|
|
assert e.subs(a, 1) == Integral(x*y, (x, f(x), f(1)), (y, f(x), f(1)))
|
|
|
|
|
|
def test_subs7():
|
|
e = Integral(x, (x, 1, y), (y, 1, 2))
|
|
assert e.subs({x: 1, y: 2}) == e
|
|
e = Integral(sin(x) + sin(y), (x, sin(x), sin(y)),
|
|
(y, 1, 2))
|
|
assert e.subs(sin(y), 1) == e
|
|
assert e.subs(sin(x), 1) == Integral(sin(x) + sin(y), (x, 1, sin(y)),
|
|
(y, 1, 2))
|
|
|
|
def test_expand():
|
|
e = Integral(f(x)+f(x**2), (x, 1, y))
|
|
assert e.expand() == Integral(f(x), (x, 1, y)) + Integral(f(x**2), (x, 1, y))
|
|
e = Integral(f(x)+f(x**2), (x, 1, oo))
|
|
assert e.expand() == e
|
|
assert e.expand(force=True) == Integral(f(x), (x, 1, oo)) + \
|
|
Integral(f(x**2), (x, 1, oo))
|
|
|
|
|
|
def test_integration_variable():
|
|
raises(ValueError, lambda: Integral(exp(-x**2), 3))
|
|
raises(ValueError, lambda: Integral(exp(-x**2), (3, -oo, oo)))
|
|
|
|
|
|
def test_expand_integral():
|
|
assert Integral(cos(x**2)*(sin(x**2) + 1), (x, 0, 1)).expand() == \
|
|
Integral(cos(x**2)*sin(x**2), (x, 0, 1)) + \
|
|
Integral(cos(x**2), (x, 0, 1))
|
|
assert Integral(cos(x**2)*(sin(x**2) + 1), x).expand() == \
|
|
Integral(cos(x**2)*sin(x**2), x) + \
|
|
Integral(cos(x**2), x)
|
|
|
|
|
|
def test_as_sum_midpoint1():
|
|
e = Integral(sqrt(x**3 + 1), (x, 2, 10))
|
|
assert e.as_sum(1, method="midpoint") == 8*sqrt(217)
|
|
assert e.as_sum(2, method="midpoint") == 4*sqrt(65) + 12*sqrt(57)
|
|
assert e.as_sum(3, method="midpoint") == 8*sqrt(217)/3 + \
|
|
8*sqrt(3081)/27 + 8*sqrt(52809)/27
|
|
assert e.as_sum(4, method="midpoint") == 2*sqrt(730) + \
|
|
4*sqrt(7) + 4*sqrt(86) + 6*sqrt(14)
|
|
assert abs(e.as_sum(4, method="midpoint").n() - e.n()) < 0.5
|
|
|
|
e = Integral(sqrt(x**3 + y**3), (x, 2, 10), (y, 0, 10))
|
|
raises(NotImplementedError, lambda: e.as_sum(4))
|
|
|
|
|
|
def test_as_sum_midpoint2():
|
|
e = Integral((x + y)**2, (x, 0, 1))
|
|
n = Symbol('n', positive=True, integer=True)
|
|
assert e.as_sum(1, method="midpoint").expand() == Rational(1, 4) + y + y**2
|
|
assert e.as_sum(2, method="midpoint").expand() == Rational(5, 16) + y + y**2
|
|
assert e.as_sum(3, method="midpoint").expand() == Rational(35, 108) + y + y**2
|
|
assert e.as_sum(4, method="midpoint").expand() == Rational(21, 64) + y + y**2
|
|
assert e.as_sum(n, method="midpoint").expand() == \
|
|
y**2 + y + Rational(1, 3) - 1/(12*n**2)
|
|
|
|
|
|
def test_as_sum_left():
|
|
e = Integral((x + y)**2, (x, 0, 1))
|
|
assert e.as_sum(1, method="left").expand() == y**2
|
|
assert e.as_sum(2, method="left").expand() == Rational(1, 8) + y/2 + y**2
|
|
assert e.as_sum(3, method="left").expand() == Rational(5, 27) + y*Rational(2, 3) + y**2
|
|
assert e.as_sum(4, method="left").expand() == Rational(7, 32) + y*Rational(3, 4) + y**2
|
|
assert e.as_sum(n, method="left").expand() == \
|
|
y**2 + y + Rational(1, 3) - y/n - 1/(2*n) + 1/(6*n**2)
|
|
assert e.as_sum(10, method="left", evaluate=False).has(Sum)
|
|
|
|
|
|
def test_as_sum_right():
|
|
e = Integral((x + y)**2, (x, 0, 1))
|
|
assert e.as_sum(1, method="right").expand() == 1 + 2*y + y**2
|
|
assert e.as_sum(2, method="right").expand() == Rational(5, 8) + y*Rational(3, 2) + y**2
|
|
assert e.as_sum(3, method="right").expand() == Rational(14, 27) + y*Rational(4, 3) + y**2
|
|
assert e.as_sum(4, method="right").expand() == Rational(15, 32) + y*Rational(5, 4) + y**2
|
|
assert e.as_sum(n, method="right").expand() == \
|
|
y**2 + y + Rational(1, 3) + y/n + 1/(2*n) + 1/(6*n**2)
|
|
|
|
|
|
def test_as_sum_trapezoid():
|
|
e = Integral((x + y)**2, (x, 0, 1))
|
|
assert e.as_sum(1, method="trapezoid").expand() == y**2 + y + S.Half
|
|
assert e.as_sum(2, method="trapezoid").expand() == y**2 + y + Rational(3, 8)
|
|
assert e.as_sum(3, method="trapezoid").expand() == y**2 + y + Rational(19, 54)
|
|
assert e.as_sum(4, method="trapezoid").expand() == y**2 + y + Rational(11, 32)
|
|
assert e.as_sum(n, method="trapezoid").expand() == \
|
|
y**2 + y + Rational(1, 3) + 1/(6*n**2)
|
|
assert Integral(sign(x), (x, 0, 1)).as_sum(1, 'trapezoid') == S.Half
|
|
|
|
|
|
def test_as_sum_raises():
|
|
e = Integral((x + y)**2, (x, 0, 1))
|
|
raises(ValueError, lambda: e.as_sum(-1))
|
|
raises(ValueError, lambda: e.as_sum(0))
|
|
raises(ValueError, lambda: Integral(x).as_sum(3))
|
|
raises(ValueError, lambda: e.as_sum(oo))
|
|
raises(ValueError, lambda: e.as_sum(3, method='xxxx2'))
|
|
|
|
|
|
def test_nested_doit():
|
|
e = Integral(Integral(x, x), x)
|
|
f = Integral(x, x, x)
|
|
assert e.doit() == f.doit()
|
|
|
|
|
|
def test_issue_4665():
|
|
# Allow only upper or lower limit evaluation
|
|
e = Integral(x**2, (x, None, 1))
|
|
f = Integral(x**2, (x, 1, None))
|
|
assert e.doit() == Rational(1, 3)
|
|
assert f.doit() == Rational(-1, 3)
|
|
assert Integral(x*y, (x, None, y)).subs(y, t) == Integral(x*t, (x, None, t))
|
|
assert Integral(x*y, (x, y, None)).subs(y, t) == Integral(x*t, (x, t, None))
|
|
assert integrate(x**2, (x, None, 1)) == Rational(1, 3)
|
|
assert integrate(x**2, (x, 1, None)) == Rational(-1, 3)
|
|
assert integrate("x**2", ("x", "1", None)) == Rational(-1, 3)
|
|
|
|
|
|
def test_integral_reconstruct():
|
|
e = Integral(x**2, (x, -1, 1))
|
|
assert e == Integral(*e.args)
|
|
|
|
|
|
def test_doit_integrals():
|
|
e = Integral(Integral(2*x), (x, 0, 1))
|
|
assert e.doit() == Rational(1, 3)
|
|
assert e.doit(deep=False) == Rational(1, 3)
|
|
f = Function('f')
|
|
# doesn't matter if the integral can't be performed
|
|
assert Integral(f(x), (x, 1, 1)).doit() == 0
|
|
# doesn't matter if the limits can't be evaluated
|
|
assert Integral(0, (x, 1, Integral(f(x), x))).doit() == 0
|
|
assert Integral(x, (a, 0)).doit() == 0
|
|
limits = ((a, 1, exp(x)), (x, 0))
|
|
assert Integral(a, *limits).doit() == Rational(1, 4)
|
|
assert Integral(a, *list(reversed(limits))).doit() == 0
|
|
|
|
|
|
def test_issue_4884():
|
|
assert integrate(sqrt(x)*(1 + x)) == \
|
|
Piecewise(
|
|
(2*sqrt(x)*(x + 1)**2/5 - 2*sqrt(x)*(x + 1)/15 - 4*sqrt(x)/15,
|
|
Abs(x + 1) > 1),
|
|
(2*I*sqrt(-x)*(x + 1)**2/5 - 2*I*sqrt(-x)*(x + 1)/15 -
|
|
4*I*sqrt(-x)/15, True))
|
|
assert integrate(x**x*(1 + log(x))) == x**x
|
|
|
|
def test_issue_18153():
|
|
assert integrate(x**n*log(x),x) == \
|
|
Piecewise(
|
|
(n*x*x**n*log(x)/(n**2 + 2*n + 1) +
|
|
x*x**n*log(x)/(n**2 + 2*n + 1) - x*x**n/(n**2 + 2*n + 1)
|
|
, Ne(n, -1)), (log(x)**2/2, True)
|
|
)
|
|
|
|
|
|
def test_is_number():
|
|
from sympy.abc import x, y, z
|
|
assert Integral(x).is_number is False
|
|
assert Integral(1, x).is_number is False
|
|
assert Integral(1, (x, 1)).is_number is True
|
|
assert Integral(1, (x, 1, 2)).is_number is True
|
|
assert Integral(1, (x, 1, y)).is_number is False
|
|
assert Integral(1, (x, y)).is_number is False
|
|
assert Integral(x, y).is_number is False
|
|
assert Integral(x, (y, 1, x)).is_number is False
|
|
assert Integral(x, (y, 1, 2)).is_number is False
|
|
assert Integral(x, (x, 1, 2)).is_number is True
|
|
# `foo.is_number` should always be equivalent to `not foo.free_symbols`
|
|
# in each of these cases, there are pseudo-free symbols
|
|
i = Integral(x, (y, 1, 1))
|
|
assert i.is_number is False and i.n() == 0
|
|
i = Integral(x, (y, z, z))
|
|
assert i.is_number is False and i.n() == 0
|
|
i = Integral(1, (y, z, z + 2))
|
|
assert i.is_number is False and i.n() == 2.0
|
|
|
|
assert Integral(x*y, (x, 1, 2), (y, 1, 3)).is_number is True
|
|
assert Integral(x*y, (x, 1, 2), (y, 1, z)).is_number is False
|
|
assert Integral(x, (x, 1)).is_number is True
|
|
assert Integral(x, (x, 1, Integral(y, (y, 1, 2)))).is_number is True
|
|
assert Integral(Sum(z, (z, 1, 2)), (x, 1, 2)).is_number is True
|
|
# it is possible to get a false negative if the integrand is
|
|
# actually an unsimplified zero, but this is true of is_number in general.
|
|
assert Integral(sin(x)**2 + cos(x)**2 - 1, x).is_number is False
|
|
assert Integral(f(x), (x, 0, 1)).is_number is True
|
|
|
|
|
|
def test_free_symbols():
|
|
from sympy.abc import x, y, z
|
|
assert Integral(0, x).free_symbols == {x}
|
|
assert Integral(x).free_symbols == {x}
|
|
assert Integral(x, (x, None, y)).free_symbols == {y}
|
|
assert Integral(x, (x, y, None)).free_symbols == {y}
|
|
assert Integral(x, (x, 1, y)).free_symbols == {y}
|
|
assert Integral(x, (x, y, 1)).free_symbols == {y}
|
|
assert Integral(x, (x, x, y)).free_symbols == {x, y}
|
|
assert Integral(x, x, y).free_symbols == {x, y}
|
|
assert Integral(x, (x, 1, 2)).free_symbols == set()
|
|
assert Integral(x, (y, 1, 2)).free_symbols == {x}
|
|
# pseudo-free in this case
|
|
assert Integral(x, (y, z, z)).free_symbols == {x, z}
|
|
assert Integral(x, (y, 1, 2), (y, None, None)
|
|
).free_symbols == {x, y}
|
|
assert Integral(x, (y, 1, 2), (x, 1, y)
|
|
).free_symbols == {y}
|
|
assert Integral(2, (y, 1, 2), (y, 1, x), (x, 1, 2)
|
|
).free_symbols == set()
|
|
assert Integral(2, (y, x, 2), (y, 1, x), (x, 1, 2)
|
|
).free_symbols == set()
|
|
assert Integral(2, (x, 1, 2), (y, x, 2), (y, 1, 2)
|
|
).free_symbols == {x}
|
|
assert Integral(f(x), (f(x), 1, y)).free_symbols == {y}
|
|
assert Integral(f(x), (f(x), 1, x)).free_symbols == {x}
|
|
|
|
|
|
def test_is_zero():
|
|
from sympy.abc import x, m
|
|
assert Integral(0, (x, 1, x)).is_zero
|
|
assert Integral(1, (x, 1, 1)).is_zero
|
|
assert Integral(1, (x, 1, 2), (y, 2)).is_zero is False
|
|
assert Integral(x, (m, 0)).is_zero
|
|
assert Integral(x + m, (m, 0)).is_zero is None
|
|
i = Integral(m, (m, 1, exp(x)), (x, 0))
|
|
assert i.is_zero is None
|
|
assert Integral(m, (x, 0), (m, 1, exp(x))).is_zero is True
|
|
|
|
assert Integral(x, (x, oo, oo)).is_zero # issue 8171
|
|
assert Integral(x, (x, -oo, -oo)).is_zero
|
|
|
|
# this is zero but is beyond the scope of what is_zero
|
|
# should be doing
|
|
assert Integral(sin(x), (x, 0, 2*pi)).is_zero is None
|
|
|
|
|
|
def test_series():
|
|
from sympy.abc import x
|
|
i = Integral(cos(x), (x, x))
|
|
e = i.lseries(x)
|
|
assert i.nseries(x, n=8).removeO() == Add(*[next(e) for j in range(4)])
|
|
|
|
|
|
def test_trig_nonelementary_integrals():
|
|
x = Symbol('x')
|
|
assert integrate((1 + sin(x))/x, x) == log(x) + Si(x)
|
|
# next one comes out as log(x) + log(x**2)/2 + Ci(x)
|
|
# so not hardcoding this log ugliness
|
|
assert integrate((cos(x) + 2)/x, x).has(Ci)
|
|
|
|
|
|
def test_issue_4403():
|
|
x = Symbol('x')
|
|
y = Symbol('y')
|
|
z = Symbol('z', positive=True)
|
|
assert integrate(sqrt(x**2 + z**2), x) == \
|
|
z**2*asinh(x/z)/2 + x*sqrt(x**2 + z**2)/2
|
|
assert integrate(sqrt(x**2 - z**2), x) == \
|
|
x*sqrt(x**2 - z**2)/2 - z**2*log(x + sqrt(x**2 - z**2))/2
|
|
|
|
x = Symbol('x', real=True)
|
|
y = Symbol('y', positive=True)
|
|
assert integrate(1/(x**2 + y**2)**S('3/2'), x) == \
|
|
x/(y**2*sqrt(x**2 + y**2))
|
|
# If y is real and nonzero, we get x*Abs(y)/(y**3*sqrt(x**2 + y**2)),
|
|
# which results from sqrt(1 + x**2/y**2) = sqrt(x**2 + y**2)/|y|.
|
|
|
|
|
|
def test_issue_4403_2():
|
|
assert integrate(sqrt(-x**2 - 4), x) == \
|
|
-2*atan(x/sqrt(-4 - x**2)) + x*sqrt(-4 - x**2)/2
|
|
|
|
|
|
def test_issue_4100():
|
|
R = Symbol('R', positive=True)
|
|
assert integrate(sqrt(R**2 - x**2), (x, 0, R)) == pi*R**2/4
|
|
|
|
|
|
def test_issue_5167():
|
|
from sympy.abc import w, x, y, z
|
|
f = Function('f')
|
|
assert Integral(Integral(f(x), x), x) == Integral(f(x), x, x)
|
|
assert Integral(f(x)).args == (f(x), Tuple(x))
|
|
assert Integral(Integral(f(x))).args == (f(x), Tuple(x), Tuple(x))
|
|
assert Integral(Integral(f(x)), y).args == (f(x), Tuple(x), Tuple(y))
|
|
assert Integral(Integral(f(x), z), y).args == (f(x), Tuple(z), Tuple(y))
|
|
assert Integral(Integral(Integral(f(x), x), y), z).args == \
|
|
(f(x), Tuple(x), Tuple(y), Tuple(z))
|
|
assert integrate(Integral(f(x), x), x) == Integral(f(x), x, x)
|
|
assert integrate(Integral(f(x), y), x) == y*Integral(f(x), x)
|
|
assert integrate(Integral(f(x), x), y) in [Integral(y*f(x), x), y*Integral(f(x), x)]
|
|
assert integrate(Integral(2, x), x) == x**2
|
|
assert integrate(Integral(2, x), y) == 2*x*y
|
|
# don't re-order given limits
|
|
assert Integral(1, x, y).args != Integral(1, y, x).args
|
|
# do as many as possible
|
|
assert Integral(f(x), y, x, y, x).doit() == y**2*Integral(f(x), x, x)/2
|
|
assert Integral(f(x), (x, 1, 2), (w, 1, x), (z, 1, y)).doit() == \
|
|
y*(x - 1)*Integral(f(x), (x, 1, 2)) - (x - 1)*Integral(f(x), (x, 1, 2))
|
|
|
|
|
|
def test_issue_4890():
|
|
z = Symbol('z', positive=True)
|
|
assert integrate(exp(-log(x)**2), x) == \
|
|
sqrt(pi)*exp(Rational(1, 4))*erf(log(x) - S.Half)/2
|
|
assert integrate(exp(log(x)**2), x) == \
|
|
sqrt(pi)*exp(Rational(-1, 4))*erfi(log(x)+S.Half)/2
|
|
assert integrate(exp(-z*log(x)**2), x) == \
|
|
sqrt(pi)*exp(1/(4*z))*erf(sqrt(z)*log(x) - 1/(2*sqrt(z)))/(2*sqrt(z))
|
|
|
|
|
|
def test_issue_4551():
|
|
assert not integrate(1/(x*sqrt(1 - x**2)), x).has(Integral)
|
|
|
|
|
|
def test_issue_4376():
|
|
n = Symbol('n', integer=True, positive=True)
|
|
assert simplify(integrate(n*(x**(1/n) - 1), (x, 0, S.Half)) -
|
|
(n**2 - 2**(1/n)*n**2 - n*2**(1/n))/(2**(1 + 1/n) + n*2**(1 + 1/n))) == 0
|
|
|
|
|
|
def test_issue_4517():
|
|
assert integrate((sqrt(x) - x**3)/x**Rational(1, 3), x) == \
|
|
6*x**Rational(7, 6)/7 - 3*x**Rational(11, 3)/11
|
|
|
|
|
|
def test_issue_4527():
|
|
k, m = symbols('k m', integer=True)
|
|
assert integrate(sin(k*x)*sin(m*x), (x, 0, pi)).simplify() == \
|
|
Piecewise((0, Eq(k, 0) | Eq(m, 0)),
|
|
(-pi/2, Eq(k, -m) | (Eq(k, 0) & Eq(m, 0))),
|
|
(pi/2, Eq(k, m) | (Eq(k, 0) & Eq(m, 0))),
|
|
(0, True))
|
|
# Should be possible to further simplify to:
|
|
# Piecewise(
|
|
# (0, Eq(k, 0) | Eq(m, 0)),
|
|
# (-pi/2, Eq(k, -m)),
|
|
# (pi/2, Eq(k, m)),
|
|
# (0, True))
|
|
assert integrate(sin(k*x)*sin(m*x), (x,)) == Piecewise(
|
|
(0, And(Eq(k, 0), Eq(m, 0))),
|
|
(-x*sin(m*x)**2/2 - x*cos(m*x)**2/2 + sin(m*x)*cos(m*x)/(2*m), Eq(k, -m)),
|
|
(x*sin(m*x)**2/2 + x*cos(m*x)**2/2 - sin(m*x)*cos(m*x)/(2*m), Eq(k, m)),
|
|
(m*sin(k*x)*cos(m*x)/(k**2 - m**2) -
|
|
k*sin(m*x)*cos(k*x)/(k**2 - m**2), True))
|
|
|
|
|
|
def test_issue_4199():
|
|
ypos = Symbol('y', positive=True)
|
|
# TODO: Remove conds='none' below, let the assumption take care of it.
|
|
assert integrate(exp(-I*2*pi*ypos*x)*x, (x, -oo, oo), conds='none') == \
|
|
Integral(exp(-I*2*pi*ypos*x)*x, (x, -oo, oo))
|
|
|
|
|
|
def test_issue_3940():
|
|
a, b, c, d = symbols('a:d', positive=True)
|
|
assert integrate(exp(-x**2 + I*c*x), x) == \
|
|
-sqrt(pi)*exp(-c**2/4)*erf(I*c/2 - x)/2
|
|
assert integrate(exp(a*x**2 + b*x + c), x) == \
|
|
sqrt(pi)*exp(c)*exp(-b**2/(4*a))*erfi(sqrt(a)*x + b/(2*sqrt(a)))/(2*sqrt(a))
|
|
|
|
from sympy.core.function import expand_mul
|
|
from sympy.abc import k
|
|
assert expand_mul(integrate(exp(-x**2)*exp(I*k*x), (x, -oo, oo))) == \
|
|
sqrt(pi)*exp(-k**2/4)
|
|
a, d = symbols('a d', positive=True)
|
|
assert expand_mul(integrate(exp(-a*x**2 + 2*d*x), (x, -oo, oo))) == \
|
|
sqrt(pi)*exp(d**2/a)/sqrt(a)
|
|
|
|
|
|
def test_issue_5413():
|
|
# Note that this is not the same as testing ratint() because integrate()
|
|
# pulls out the coefficient.
|
|
assert integrate(-a/(a**2 + x**2), x) == I*log(-I*a + x)/2 - I*log(I*a + x)/2
|
|
|
|
|
|
def test_issue_4892a():
|
|
A, z = symbols('A z')
|
|
c = Symbol('c', nonzero=True)
|
|
P1 = -A*exp(-z)
|
|
P2 = -A/(c*t)*(sin(x)**2 + cos(y)**2)
|
|
|
|
h1 = -sin(x)**2 - cos(y)**2
|
|
h2 = -sin(x)**2 + sin(y)**2 - 1
|
|
|
|
# there is still some non-deterministic behavior in integrate
|
|
# or trigsimp which permits one of the following
|
|
assert integrate(c*(P2 - P1), t) in [
|
|
c*(-A*(-h1)*log(c*t)/c + A*t*exp(-z)),
|
|
c*(-A*(-h2)*log(c*t)/c + A*t*exp(-z)),
|
|
c*( A* h1 *log(c*t)/c + A*t*exp(-z)),
|
|
c*( A* h2 *log(c*t)/c + A*t*exp(-z)),
|
|
(A*c*t - A*(-h1)*log(t)*exp(z))*exp(-z),
|
|
(A*c*t - A*(-h2)*log(t)*exp(z))*exp(-z),
|
|
]
|
|
|
|
|
|
def test_issue_4892b():
|
|
# Issues relating to issue 4596 are making the actual result of this hard
|
|
# to test. The answer should be something like
|
|
#
|
|
# (-sin(y) + sqrt(-72 + 48*cos(y) - 8*cos(y)**2)/2)*log(x + sqrt(-72 +
|
|
# 48*cos(y) - 8*cos(y)**2)/(2*(3 - cos(y)))) + (-sin(y) - sqrt(-72 +
|
|
# 48*cos(y) - 8*cos(y)**2)/2)*log(x - sqrt(-72 + 48*cos(y) -
|
|
# 8*cos(y)**2)/(2*(3 - cos(y)))) + x**2*sin(y)/2 + 2*x*cos(y)
|
|
|
|
expr = (sin(y)*x**3 + 2*cos(y)*x**2 + 12)/(x**2 + 2)
|
|
assert trigsimp(factor(integrate(expr, x).diff(x) - expr)) == 0
|
|
|
|
|
|
def test_issue_5178():
|
|
assert integrate(sin(x)*f(y, z), (x, 0, pi), (y, 0, pi), (z, 0, pi)) == \
|
|
2*Integral(f(y, z), (y, 0, pi), (z, 0, pi))
|
|
|
|
|
|
def test_integrate_series():
|
|
f = sin(x).series(x, 0, 10)
|
|
g = x**2/2 - x**4/24 + x**6/720 - x**8/40320 + x**10/3628800 + O(x**11)
|
|
|
|
assert integrate(f, x) == g
|
|
assert diff(integrate(f, x), x) == f
|
|
|
|
assert integrate(O(x**5), x) == O(x**6)
|
|
|
|
|
|
def test_atom_bug():
|
|
from sympy.integrals.heurisch import heurisch
|
|
assert heurisch(meijerg([], [], [1], [], x), x) is None
|
|
|
|
|
|
def test_limit_bug():
|
|
z = Symbol('z', zero=False)
|
|
assert integrate(sin(x*y*z), (x, 0, pi), (y, 0, pi)).together() == \
|
|
(log(z) - Ci(pi**2*z) + EulerGamma + 2*log(pi))/z
|
|
|
|
|
|
def test_issue_4703():
|
|
g = Function('g')
|
|
assert integrate(exp(x)*g(x), x).has(Integral)
|
|
|
|
|
|
def test_issue_1888():
|
|
f = Function('f')
|
|
assert integrate(f(x).diff(x)**2, x).has(Integral)
|
|
|
|
# The following tests work using meijerint.
|
|
|
|
|
|
def test_issue_3558():
|
|
assert integrate(cos(x*y), (x, -pi/2, pi/2), (y, 0, pi)) == 2*Si(pi**2/2)
|
|
|
|
|
|
def test_issue_4422():
|
|
assert integrate(1/sqrt(16 + 4*x**2), x) == asinh(x/2) / 2
|
|
|
|
|
|
def test_issue_4493():
|
|
assert simplify(integrate(x*sqrt(1 + 2*x), x)) == \
|
|
sqrt(2*x + 1)*(6*x**2 + x - 1)/15
|
|
|
|
|
|
def test_issue_4737():
|
|
assert integrate(sin(x)/x, (x, -oo, oo)) == pi
|
|
assert integrate(sin(x)/x, (x, 0, oo)) == pi/2
|
|
assert integrate(sin(x)/x, x) == Si(x)
|
|
|
|
|
|
def test_issue_4992():
|
|
# Note: psi in _check_antecedents becomes NaN.
|
|
from sympy.core.function import expand_func
|
|
a = Symbol('a', positive=True)
|
|
assert simplify(expand_func(integrate(exp(-x)*log(x)*x**a, (x, 0, oo)))) == \
|
|
(a*polygamma(0, a) + 1)*gamma(a)
|
|
|
|
|
|
def test_issue_4487():
|
|
from sympy.functions.special.gamma_functions import lowergamma
|
|
assert simplify(integrate(exp(-x)*x**y, x)) == lowergamma(y + 1, x)
|
|
|
|
|
|
def test_issue_4215():
|
|
x = Symbol("x")
|
|
assert integrate(1/(x**2), (x, -1, 1)) is oo
|
|
|
|
|
|
def test_issue_4400():
|
|
n = Symbol('n', integer=True, positive=True)
|
|
assert integrate((x**n)*log(x), x) == \
|
|
n*x*x**n*log(x)/(n**2 + 2*n + 1) + x*x**n*log(x)/(n**2 + 2*n + 1) - \
|
|
x*x**n/(n**2 + 2*n + 1)
|
|
|
|
|
|
def test_issue_6253():
|
|
# Note: this used to raise NotImplementedError
|
|
# Note: psi in _check_antecedents becomes NaN.
|
|
assert integrate((sqrt(1 - x) + sqrt(1 + x))**2/x, x, meijerg=True) == \
|
|
Integral((sqrt(-x + 1) + sqrt(x + 1))**2/x, x)
|
|
|
|
|
|
def test_issue_4153():
|
|
assert integrate(1/(1 + x + y + z), (x, 0, 1), (y, 0, 1), (z, 0, 1)) in [
|
|
-12*log(3) - 3*log(6)/2 + 3*log(8)/2 + 5*log(2) + 7*log(4),
|
|
6*log(2) + 8*log(4) - 27*log(3)/2, 22*log(2) - 27*log(3)/2,
|
|
-12*log(3) - 3*log(6)/2 + 47*log(2)/2]
|
|
|
|
|
|
def test_issue_4326():
|
|
R, b, h = symbols('R b h')
|
|
# It doesn't matter if we can do the integral. Just make sure the result
|
|
# doesn't contain nan. This is really a test against _eval_interval.
|
|
e = integrate(((h*(x - R + b))/b)*sqrt(R**2 - x**2), (x, R - b, R))
|
|
assert not e.has(nan)
|
|
# See that it evaluates
|
|
assert not e.has(Integral)
|
|
|
|
|
|
def test_powers():
|
|
assert integrate(2**x + 3**x, x) == 2**x/log(2) + 3**x/log(3)
|
|
|
|
|
|
def test_manual_option():
|
|
raises(ValueError, lambda: integrate(1/x, x, manual=True, meijerg=True))
|
|
# an example of a function that manual integration cannot handle
|
|
assert integrate(log(1+x)/x, (x, 0, 1), manual=True).has(Integral)
|
|
|
|
|
|
def test_meijerg_option():
|
|
raises(ValueError, lambda: integrate(1/x, x, meijerg=True, risch=True))
|
|
# an example of a function that meijerg integration cannot handle
|
|
assert integrate(tan(x), x, meijerg=True) == Integral(tan(x), x)
|
|
|
|
|
|
def test_risch_option():
|
|
# risch=True only allowed on indefinite integrals
|
|
raises(ValueError, lambda: integrate(1/log(x), (x, 0, oo), risch=True))
|
|
assert integrate(exp(-x**2), x, risch=True) == NonElementaryIntegral(exp(-x**2), x)
|
|
assert integrate(log(1/x)*y, x, y, risch=True) == y**2*(x*log(1/x)/2 + x/2)
|
|
assert integrate(erf(x), x, risch=True) == Integral(erf(x), x)
|
|
# TODO: How to test risch=False?
|
|
|
|
|
|
@slow
|
|
def test_heurisch_option():
|
|
raises(ValueError, lambda: integrate(1/x, x, risch=True, heurisch=True))
|
|
# an integral that heurisch can handle
|
|
assert integrate(exp(x**2), x, heurisch=True) == sqrt(pi)*erfi(x)/2
|
|
# an integral that heurisch currently cannot handle
|
|
assert integrate(exp(x)/x, x, heurisch=True) == Integral(exp(x)/x, x)
|
|
# an integral where heurisch currently hangs, issue 15471
|
|
assert integrate(log(x)*cos(log(x))/x**Rational(3, 4), x, heurisch=False) == (
|
|
-128*x**Rational(1, 4)*sin(log(x))/289 + 240*x**Rational(1, 4)*cos(log(x))/289 +
|
|
(16*x**Rational(1, 4)*sin(log(x))/17 + 4*x**Rational(1, 4)*cos(log(x))/17)*log(x))
|
|
|
|
|
|
def test_issue_6828():
|
|
f = 1/(1.08*x**2 - 4.3)
|
|
g = integrate(f, x).diff(x)
|
|
assert verify_numerically(f, g, tol=1e-12)
|
|
|
|
|
|
def test_issue_4803():
|
|
x_max = Symbol("x_max")
|
|
assert integrate(y/pi*exp(-(x_max - x)/cos(a)), x) == \
|
|
y*exp((x - x_max)/cos(a))*cos(a)/pi
|
|
|
|
|
|
def test_issue_4234():
|
|
assert integrate(1/sqrt(1 + tan(x)**2)) == tan(x)/sqrt(1 + tan(x)**2)
|
|
|
|
|
|
def test_issue_4492():
|
|
assert simplify(integrate(x**2 * sqrt(5 - x**2), x)).factor(
|
|
deep=True) == Piecewise(
|
|
(I*(2*x**5 - 15*x**3 + 25*x - 25*sqrt(x**2 - 5)*acosh(sqrt(5)*x/5)) /
|
|
(8*sqrt(x**2 - 5)), (x > sqrt(5)) | (x < -sqrt(5))),
|
|
((2*x**5 - 15*x**3 + 25*x - 25*sqrt(5 - x**2)*asin(sqrt(5)*x/5)) /
|
|
(-8*sqrt(-x**2 + 5)), True))
|
|
|
|
|
|
def test_issue_2708():
|
|
# This test needs to use an integration function that can
|
|
# not be evaluated in closed form. Update as needed.
|
|
f = 1/(a + z + log(z))
|
|
integral_f = NonElementaryIntegral(f, (z, 2, 3))
|
|
assert Integral(f, (z, 2, 3)).doit() == integral_f
|
|
assert integrate(f + exp(z), (z, 2, 3)) == integral_f - exp(2) + exp(3)
|
|
assert integrate(2*f + exp(z), (z, 2, 3)) == \
|
|
2*integral_f - exp(2) + exp(3)
|
|
assert integrate(exp(1.2*n*s*z*(-t + z)/t), (z, 0, x)) == \
|
|
NonElementaryIntegral(exp(-1.2*n*s*z)*exp(1.2*n*s*z**2/t),
|
|
(z, 0, x))
|
|
|
|
|
|
def test_issue_2884():
|
|
f = (4.000002016020*x + 4.000002016020*y + 4.000006024032)*exp(10.0*x)
|
|
e = integrate(f, (x, 0.1, 0.2))
|
|
assert str(e) == '1.86831064982608*y + 2.16387491480008'
|
|
|
|
|
|
def test_issue_8368i():
|
|
from sympy.functions.elementary.complexes import arg, Abs
|
|
assert integrate(exp(-s*x)*cosh(x), (x, 0, oo)) == \
|
|
Piecewise(
|
|
( pi*Piecewise(
|
|
( -s/(pi*(-s**2 + 1)),
|
|
Abs(s**2) < 1),
|
|
( 1/(pi*s*(1 - 1/s**2)),
|
|
Abs(s**(-2)) < 1),
|
|
( meijerg(
|
|
((S.Half,), (0, 0)),
|
|
((0, S.Half), (0,)),
|
|
polar_lift(s)**2),
|
|
True)
|
|
),
|
|
s**2 > 1
|
|
),
|
|
(
|
|
Integral(exp(-s*x)*cosh(x), (x, 0, oo)),
|
|
True))
|
|
assert integrate(exp(-s*x)*sinh(x), (x, 0, oo)) == \
|
|
Piecewise(
|
|
( -1/(s + 1)/2 - 1/(-s + 1)/2,
|
|
And(
|
|
Abs(s) > 1,
|
|
Abs(arg(s)) < pi/2,
|
|
Abs(arg(s)) <= pi/2
|
|
)),
|
|
( Integral(exp(-s*x)*sinh(x), (x, 0, oo)),
|
|
True))
|
|
|
|
|
|
def test_issue_8901():
|
|
assert integrate(sinh(1.0*x)) == 1.0*cosh(1.0*x)
|
|
assert integrate(tanh(1.0*x)) == 1.0*x - 1.0*log(tanh(1.0*x) + 1)
|
|
assert integrate(tanh(x)) == x - log(tanh(x) + 1)
|
|
|
|
|
|
@slow
|
|
def test_issue_8945():
|
|
assert integrate(sin(x)**3/x, (x, 0, 1)) == -Si(3)/4 + 3*Si(1)/4
|
|
assert integrate(sin(x)**3/x, (x, 0, oo)) == pi/4
|
|
assert integrate(cos(x)**2/x**2, x) == -Si(2*x) - cos(2*x)/(2*x) - 1/(2*x)
|
|
|
|
|
|
@slow
|
|
def test_issue_7130():
|
|
if ON_CI:
|
|
skip("Too slow for CI.")
|
|
i, L, a, b = symbols('i L a b')
|
|
integrand = (cos(pi*i*x/L)**2 / (a + b*x)).rewrite(exp)
|
|
assert x not in integrate(integrand, (x, 0, L)).free_symbols
|
|
|
|
|
|
def test_issue_10567():
|
|
a, b, c, t = symbols('a b c t')
|
|
vt = Matrix([a*t, b, c])
|
|
assert integrate(vt, t) == Integral(vt, t).doit()
|
|
assert integrate(vt, t) == Matrix([[a*t**2/2], [b*t], [c*t]])
|
|
|
|
|
|
def test_issue_11742():
|
|
assert integrate(sqrt(-x**2 + 8*x + 48), (x, 4, 12)) == 16*pi
|
|
|
|
|
|
def test_issue_11856():
|
|
t = symbols('t')
|
|
assert integrate(sinc(pi*t), t) == Si(pi*t)/pi
|
|
|
|
|
|
@slow
|
|
def test_issue_11876():
|
|
assert integrate(sqrt(log(1/x)), (x, 0, 1)) == sqrt(pi)/2
|
|
|
|
|
|
def test_issue_4950():
|
|
assert integrate((-60*exp(x) - 19.2*exp(4*x))*exp(4*x), x) ==\
|
|
-2.4*exp(8*x) - 12.0*exp(5*x)
|
|
|
|
|
|
def test_issue_4968():
|
|
assert integrate(sin(log(x**2))) == x*sin(log(x**2))/5 - 2*x*cos(log(x**2))/5
|
|
|
|
|
|
def test_singularities():
|
|
assert integrate(1/x**2, (x, -oo, oo)) is oo
|
|
assert integrate(1/x**2, (x, -1, 1)) is oo
|
|
assert integrate(1/(x - 1)**2, (x, -2, 2)) is oo
|
|
|
|
assert integrate(1/x**2, (x, 1, -1)) is -oo
|
|
assert integrate(1/(x - 1)**2, (x, 2, -2)) is -oo
|
|
|
|
|
|
def test_issue_12645():
|
|
x, y = symbols('x y', real=True)
|
|
assert (integrate(sin(x*x*x + y*y),
|
|
(x, -sqrt(pi - y*y), sqrt(pi - y*y)),
|
|
(y, -sqrt(pi), sqrt(pi)))
|
|
== Integral(sin(x**3 + y**2),
|
|
(x, -sqrt(-y**2 + pi), sqrt(-y**2 + pi)),
|
|
(y, -sqrt(pi), sqrt(pi))))
|
|
|
|
|
|
def test_issue_12677():
|
|
assert integrate(sin(x) / (cos(x)**3), (x, 0, pi/6)) == Rational(1, 6)
|
|
|
|
|
|
def test_issue_14078():
|
|
assert integrate((cos(3*x)-cos(x))/x, (x, 0, oo)) == -log(3)
|
|
|
|
|
|
def test_issue_14064():
|
|
assert integrate(1/cosh(x), (x, 0, oo)) == pi/2
|
|
|
|
|
|
def test_issue_14027():
|
|
assert integrate(1/(1 + exp(x - S.Half)/(1 + exp(x))), x) == \
|
|
x - exp(S.Half)*log(exp(x) + exp(S.Half)/(1 + exp(S.Half)))/(exp(S.Half) + E)
|
|
|
|
|
|
def test_issue_8170():
|
|
assert integrate(tan(x), (x, 0, pi/2)) is S.Infinity
|
|
|
|
|
|
def test_issue_8440_14040():
|
|
assert integrate(1/x, (x, -1, 1)) is S.NaN
|
|
assert integrate(1/(x + 1), (x, -2, 3)) is S.NaN
|
|
|
|
|
|
def test_issue_14096():
|
|
assert integrate(1/(x + y)**2, (x, 0, 1)) == -1/(y + 1) + 1/y
|
|
assert integrate(1/(1 + x + y + z)**2, (x, 0, 1), (y, 0, 1), (z, 0, 1)) == \
|
|
-4*log(4) - 6*log(2) + 9*log(3)
|
|
|
|
|
|
def test_issue_14144():
|
|
assert Abs(integrate(1/sqrt(1 - x**3), (x, 0, 1)).n() - 1.402182) < 1e-6
|
|
assert Abs(integrate(sqrt(1 - x**3), (x, 0, 1)).n() - 0.841309) < 1e-6
|
|
|
|
|
|
def test_issue_14375():
|
|
# This raised a TypeError. The antiderivative has exp_polar, which
|
|
# may be possible to unpolarify, so the exact output is not asserted here.
|
|
assert integrate(exp(I*x)*log(x), x).has(Ei)
|
|
|
|
|
|
def test_issue_14437():
|
|
f = Function('f')(x, y, z)
|
|
assert integrate(f, (x, 0, 1), (y, 0, 2), (z, 0, 3)) == \
|
|
Integral(f, (x, 0, 1), (y, 0, 2), (z, 0, 3))
|
|
|
|
|
|
def test_issue_14470():
|
|
assert integrate(1/sqrt(exp(x) + 1), x) == log(sqrt(exp(x) + 1) - 1) - log(sqrt(exp(x) + 1) + 1)
|
|
|
|
|
|
def test_issue_14877():
|
|
f = exp(1 - exp(x**2)*x + 2*x**2)*(2*x**3 + x)/(1 - exp(x**2)*x)**2
|
|
assert integrate(f, x) == \
|
|
-exp(2*x**2 - x*exp(x**2) + 1)/(x*exp(3*x**2) - exp(2*x**2))
|
|
|
|
|
|
def test_issue_14782():
|
|
f = sqrt(-x**2 + 1)*(-x**2 + x)
|
|
assert integrate(f, [x, -1, 1]) == - pi / 8
|
|
|
|
|
|
@slow
|
|
def test_issue_14782_slow():
|
|
f = sqrt(-x**2 + 1)*(-x**2 + x)
|
|
assert integrate(f, [x, 0, 1]) == S.One / 3 - pi / 16
|
|
|
|
|
|
def test_issue_12081():
|
|
f = x**(Rational(-3, 2))*exp(-x)
|
|
assert integrate(f, [x, 0, oo]) is oo
|
|
|
|
|
|
def test_issue_15285():
|
|
y = 1/x - 1
|
|
f = 4*y*exp(-2*y)/x**2
|
|
assert integrate(f, [x, 0, 1]) == 1
|
|
|
|
|
|
def test_issue_15432():
|
|
assert integrate(x**n * exp(-x) * log(x), (x, 0, oo)).gammasimp() == Piecewise(
|
|
(gamma(n + 1)*polygamma(0, n) + gamma(n + 1)/n, re(n) + 1 > 0),
|
|
(Integral(x**n*exp(-x)*log(x), (x, 0, oo)), True))
|
|
|
|
|
|
def test_issue_15124():
|
|
omega = IndexedBase('omega')
|
|
m, p = symbols('m p', cls=Idx)
|
|
assert integrate(exp(x*I*(omega[m] + omega[p])), x, conds='none') == \
|
|
-I*exp(I*x*omega[m])*exp(I*x*omega[p])/(omega[m] + omega[p])
|
|
|
|
|
|
def test_issue_15218():
|
|
with warns_deprecated_sympy():
|
|
Integral(Eq(x, y))
|
|
with warns_deprecated_sympy():
|
|
assert Integral(Eq(x, y), x) == Eq(Integral(x, x), Integral(y, x))
|
|
with warns_deprecated_sympy():
|
|
assert Integral(Eq(x, y), x).doit() == Eq(x**2/2, x*y)
|
|
with warns(SymPyDeprecationWarning, test_stacklevel=False):
|
|
# The warning is made in the ExprWithLimits superclass. The stacklevel
|
|
# is correct for integrate(Eq) but not Eq.integrate
|
|
assert Eq(x, y).integrate(x) == Eq(x**2/2, x*y)
|
|
|
|
# These are not deprecated because they are definite integrals
|
|
assert integrate(Eq(x, y), (x, 0, 1)) == Eq(S.Half, y)
|
|
assert Eq(x, y).integrate((x, 0, 1)) == Eq(S.Half, y)
|
|
|
|
|
|
def test_issue_15292():
|
|
res = integrate(exp(-x**2*cos(2*t)) * cos(x**2*sin(2*t)), (x, 0, oo))
|
|
assert isinstance(res, Piecewise)
|
|
assert gammasimp((res - sqrt(pi)/2 * cos(t)).subs(t, pi/6)) == 0
|
|
|
|
|
|
def test_issue_4514():
|
|
assert integrate(sin(2*x)/sin(x), x) == 2*sin(x)
|
|
|
|
|
|
def test_issue_15457():
|
|
x, a, b = symbols('x a b', real=True)
|
|
definite = integrate(exp(Abs(x-2)), (x, a, b))
|
|
indefinite = integrate(exp(Abs(x-2)), x)
|
|
assert definite.subs({a: 1, b: 3}) == -2 + 2*E
|
|
assert indefinite.subs(x, 3) - indefinite.subs(x, 1) == -2 + 2*E
|
|
assert definite.subs({a: -3, b: -1}) == -exp(3) + exp(5)
|
|
assert indefinite.subs(x, -1) - indefinite.subs(x, -3) == -exp(3) + exp(5)
|
|
|
|
|
|
def test_issue_15431():
|
|
assert integrate(x*exp(x)*log(x), x) == \
|
|
(x*exp(x) - exp(x))*log(x) - exp(x) + Ei(x)
|
|
|
|
|
|
def test_issue_15640_log_substitutions():
|
|
f = x/log(x)
|
|
F = Ei(2*log(x))
|
|
assert integrate(f, x) == F and F.diff(x) == f
|
|
f = x**3/log(x)**2
|
|
F = -x**4/log(x) + 4*Ei(4*log(x))
|
|
assert integrate(f, x) == F and F.diff(x) == f
|
|
f = sqrt(log(x))/x**2
|
|
F = -sqrt(pi)*erfc(sqrt(log(x)))/2 - sqrt(log(x))/x
|
|
assert integrate(f, x) == F and F.diff(x) == f
|
|
|
|
|
|
def test_issue_15509():
|
|
from sympy.vector import CoordSys3D
|
|
N = CoordSys3D('N')
|
|
x = N.x
|
|
assert integrate(cos(a*x + b), (x, x_1, x_2), heurisch=True) == Piecewise(
|
|
(-sin(a*x_1 + b)/a + sin(a*x_2 + b)/a, (a > -oo) & (a < oo) & Ne(a, 0)), \
|
|
(-x_1*cos(b) + x_2*cos(b), True))
|
|
|
|
|
|
def test_issue_4311_fast():
|
|
x = symbols('x', real=True)
|
|
assert integrate(x*abs(9-x**2), x) == Piecewise(
|
|
(x**4/4 - 9*x**2/2, x <= -3),
|
|
(-x**4/4 + 9*x**2/2 - Rational(81, 2), x <= 3),
|
|
(x**4/4 - 9*x**2/2, True))
|
|
|
|
|
|
def test_integrate_with_complex_constants():
|
|
K = Symbol('K', positive=True)
|
|
x = Symbol('x', real=True)
|
|
m = Symbol('m', real=True)
|
|
t = Symbol('t', real=True)
|
|
assert integrate(exp(-I*K*x**2+m*x), x) == sqrt(I)*sqrt(pi)*exp(-I*m**2
|
|
/(4*K))*erfi((-2*I*K*x + m)/(2*sqrt(K)*sqrt(-I)))/(2*sqrt(K))
|
|
assert integrate(1/(1 + I*x**2), x) == (-I*(sqrt(-I)*log(x - I*sqrt(-I))/2
|
|
- sqrt(-I)*log(x + I*sqrt(-I))/2))
|
|
assert integrate(exp(-I*x**2), x) == sqrt(pi)*erf(sqrt(I)*x)/(2*sqrt(I))
|
|
|
|
assert integrate((1/(exp(I*t)-2)), t) == -t/2 - I*log(exp(I*t) - 2)/2
|
|
assert integrate((1/(exp(I*t)-2)), (t, 0, 2*pi)) == -pi
|
|
|
|
|
|
def test_issue_14241():
|
|
x = Symbol('x')
|
|
n = Symbol('n', positive=True, integer=True)
|
|
assert integrate(n * x ** (n - 1) / (x + 1), x) == \
|
|
n**2*x**n*lerchphi(x*exp_polar(I*pi), 1, n)*gamma(n)/gamma(n + 1)
|
|
|
|
|
|
def test_issue_13112():
|
|
assert integrate(sin(t)**2 / (5 - 4*cos(t)), [t, 0, 2*pi]) == pi / 4
|
|
|
|
|
|
def test_issue_14709b():
|
|
h = Symbol('h', positive=True)
|
|
i = integrate(x*acos(1 - 2*x/h), (x, 0, h))
|
|
assert i == 5*h**2*pi/16
|
|
|
|
|
|
def test_issue_8614():
|
|
x = Symbol('x')
|
|
t = Symbol('t')
|
|
assert integrate(exp(t)/t, (t, -oo, x)) == Ei(x)
|
|
assert integrate((exp(-x) - exp(-2*x))/x, (x, 0, oo)) == log(2)
|
|
|
|
|
|
@slow
|
|
def test_issue_15494():
|
|
s = symbols('s', positive=True)
|
|
|
|
integrand = (exp(s/2) - 2*exp(1.6*s) + exp(s))*exp(s)
|
|
solution = integrate(integrand, s)
|
|
assert solution != S.NaN
|
|
# Not sure how to test this properly as it is a symbolic expression with floats
|
|
# assert str(solution) == '0.666666666666667*exp(1.5*s) + 0.5*exp(2.0*s) - 0.769230769230769*exp(2.6*s)'
|
|
# Maybe
|
|
assert abs(solution.subs(s, 1) - (-3.67440080236188)) <= 1e-8
|
|
|
|
integrand = (exp(s/2) - 2*exp(S(8)/5*s) + exp(s))*exp(s)
|
|
assert integrate(integrand, s) == -10*exp(13*s/5)/13 + 2*exp(3*s/2)/3 + exp(2*s)/2
|
|
|
|
|
|
def test_li_integral():
|
|
y = Symbol('y')
|
|
assert Integral(li(y*x**2), x).doit() == Piecewise((x*li(x**2*y) - \
|
|
x*Ei(3*log(x**2*y)/2)/sqrt(x**2*y),
|
|
Ne(y, 0)), (0, True))
|
|
|
|
|
|
def test_issue_17473():
|
|
x = Symbol('x')
|
|
n = Symbol('n')
|
|
h = S.Half
|
|
ans = x**(n + 1)*gamma(h + h/n)*hyper((h + h/n,),
|
|
(3*h, 3*h + h/n), -x**(2*n)/4)/(2*n*gamma(3*h + h/n))
|
|
got = integrate(sin(x**n), x)
|
|
assert got == ans
|
|
_x = Symbol('x', zero=False)
|
|
reps = {x: _x}
|
|
assert integrate(sin(_x**n), _x) == ans.xreplace(reps).expand()
|
|
|
|
|
|
def test_issue_17671():
|
|
assert integrate(log(log(x)) / x**2, [x, 1, oo]) == -EulerGamma
|
|
assert integrate(log(log(x)) / x**3, [x, 1, oo]) == -log(2)/2 - EulerGamma/2
|
|
assert integrate(log(log(x)) / x**10, [x, 1, oo]) == -log(9)/9 - EulerGamma/9
|
|
|
|
|
|
def test_issue_2975():
|
|
w = Symbol('w')
|
|
C = Symbol('C')
|
|
y = Symbol('y')
|
|
assert integrate(1/(y**2+C)**(S(3)/2), (y, -w/2, w/2)) == w/(C**(S(3)/2)*sqrt(1 + w**2/(4*C)))
|
|
|
|
|
|
def test_issue_7827():
|
|
x, n, M = symbols('x n M')
|
|
N = Symbol('N', integer=True)
|
|
assert integrate(summation(x*n, (n, 1, N)), x) == x**2*(N**2/4 + N/4)
|
|
assert integrate(summation(x*sin(n), (n,1,N)), x) == \
|
|
Sum(x**2*sin(n)/2, (n, 1, N))
|
|
assert integrate(summation(sin(n*x), (n,1,N)), x) == \
|
|
Sum(Piecewise((-cos(n*x)/n, Ne(n, 0)), (0, True)), (n, 1, N))
|
|
assert integrate(integrate(summation(sin(n*x), (n,1,N)), x), x) == \
|
|
Piecewise((Sum(Piecewise((-sin(n*x)/n**2, Ne(n, 0)), (-x/n, True)),
|
|
(n, 1, N)), (n > -oo) & (n < oo) & Ne(n, 0)), (0, True))
|
|
assert integrate(Sum(x, (n, 1, M)), x) == M*x**2/2
|
|
raises(ValueError, lambda: integrate(Sum(x, (x, y, n)), y))
|
|
raises(ValueError, lambda: integrate(Sum(x, (x, 1, n)), n))
|
|
raises(ValueError, lambda: integrate(Sum(x, (x, 1, y)), x))
|
|
|
|
|
|
def test_issue_4231():
|
|
f = (1 + 2*x + sqrt(x + log(x))*(1 + 3*x) + x**2)/(x*(x + sqrt(x + log(x)))*sqrt(x + log(x)))
|
|
assert integrate(f, x) == 2*sqrt(x + log(x)) + 2*log(x + sqrt(x + log(x)))
|
|
|
|
|
|
def test_issue_17841():
|
|
f = diff(1/(x**2+x+I), x)
|
|
assert integrate(f, x) == 1/(x**2 + x + I)
|
|
|
|
|
|
def test_issue_21034():
|
|
x = Symbol('x', real=True, nonzero=True)
|
|
f1 = x*(-x**4/asin(5)**4 - x*sinh(x + log(asin(5))) + 5)
|
|
f2 = (x + cosh(cos(4)))/(x*(x + 1/(12*x)))
|
|
|
|
assert integrate(f1, x) == \
|
|
-x**6/(6*asin(5)**4) - x**2*cosh(x + log(asin(5))) + 5*x**2/2 + 2*x*sinh(x + log(asin(5))) - 2*cosh(x + log(asin(5)))
|
|
|
|
assert integrate(f2, x) == \
|
|
log(x**2 + S(1)/12)/2 + 2*sqrt(3)*cosh(cos(4))*atan(2*sqrt(3)*x)
|
|
|
|
|
|
def test_issue_4187():
|
|
assert integrate(log(x)*exp(-x), x) == Ei(-x) - exp(-x)*log(x)
|
|
assert integrate(log(x)*exp(-x), (x, 0, oo)) == -EulerGamma
|
|
|
|
|
|
def test_issue_5547():
|
|
L = Symbol('L')
|
|
z = Symbol('z')
|
|
r0 = Symbol('r0')
|
|
R0 = Symbol('R0')
|
|
|
|
assert integrate(r0**2*cos(z)**2, (z, -L/2, L/2)) == -r0**2*(-L/4 -
|
|
sin(L/2)*cos(L/2)/2) + r0**2*(L/4 + sin(L/2)*cos(L/2)/2)
|
|
|
|
assert integrate(r0**2*cos(R0*z)**2, (z, -L/2, L/2)) == Piecewise(
|
|
(-r0**2*(-L*R0/4 - sin(L*R0/2)*cos(L*R0/2)/2)/R0 +
|
|
r0**2*(L*R0/4 + sin(L*R0/2)*cos(L*R0/2)/2)/R0, (R0 > -oo) & (R0 < oo) & Ne(R0, 0)),
|
|
(L*r0**2, True))
|
|
|
|
w = 2*pi*z/L
|
|
|
|
sol = sqrt(2)*sqrt(L)*r0**2*fresnelc(sqrt(2)*sqrt(L))*gamma(S.One/4)/(16*gamma(S(5)/4)) + L*r0**2/2
|
|
|
|
assert integrate(r0**2*cos(w*z)**2, (z, -L/2, L/2)) == sol
|
|
|
|
|
|
def test_issue_15810():
|
|
assert integrate(1/(2**(2*x/3) + 1), (x, 0, oo)) == Rational(3, 2)
|
|
|
|
|
|
def test_issue_21024():
|
|
x = Symbol('x', real=True, nonzero=True)
|
|
f = log(x)*log(4*x) + log(3*x + exp(2))
|
|
F = x*log(x)**2 + x*(1 - 2*log(2)) + (-2*x + 2*x*log(2))*log(x) + \
|
|
(x + exp(2)/6)*log(3*x + exp(2)) + exp(2)*log(3*x + exp(2))/6
|
|
assert F == integrate(f, x)
|
|
|
|
f = (x + exp(3))/x**2
|
|
F = log(x) - exp(3)/x
|
|
assert F == integrate(f, x)
|
|
|
|
f = (x**2 + exp(5))/x
|
|
F = x**2/2 + exp(5)*log(x)
|
|
assert F == integrate(f, x)
|
|
|
|
f = x/(2*x + tanh(1))
|
|
F = x/2 - log(2*x + tanh(1))*tanh(1)/4
|
|
assert F == integrate(f, x)
|
|
|
|
f = x - sinh(4)/x
|
|
F = x**2/2 - log(x)*sinh(4)
|
|
assert F == integrate(f, x)
|
|
|
|
f = log(x + exp(5)/x)
|
|
F = x*log(x + exp(5)/x) - x + 2*exp(Rational(5, 2))*atan(x*exp(Rational(-5, 2)))
|
|
assert F == integrate(f, x)
|
|
|
|
f = x**5/(x + E)
|
|
F = x**5/5 - E*x**4/4 + x**3*exp(2)/3 - x**2*exp(3)/2 + x*exp(4) - exp(5)*log(x + E)
|
|
assert F == integrate(f, x)
|
|
|
|
f = 4*x/(x + sinh(5))
|
|
F = 4*x - 4*log(x + sinh(5))*sinh(5)
|
|
assert F == integrate(f, x)
|
|
|
|
f = x**2/(2*x + sinh(2))
|
|
F = x**2/4 - x*sinh(2)/4 + log(2*x + sinh(2))*sinh(2)**2/8
|
|
assert F == integrate(f, x)
|
|
|
|
f = -x**2/(x + E)
|
|
F = -x**2/2 + E*x - exp(2)*log(x + E)
|
|
assert F == integrate(f, x)
|
|
|
|
f = (2*x + 3)*exp(5)/x
|
|
F = 2*x*exp(5) + 3*exp(5)*log(x)
|
|
assert F == integrate(f, x)
|
|
|
|
f = x + 2 + cosh(3)/x
|
|
F = x**2/2 + 2*x + log(x)*cosh(3)
|
|
assert F == integrate(f, x)
|
|
|
|
f = x - tanh(1)/x**3
|
|
F = x**2/2 + tanh(1)/(2*x**2)
|
|
assert F == integrate(f, x)
|
|
|
|
f = (3*x - exp(6))/x
|
|
F = 3*x - exp(6)*log(x)
|
|
assert F == integrate(f, x)
|
|
|
|
f = x**4/(x + exp(5))**2 + x
|
|
F = x**3/3 + x**2*(Rational(1, 2) - exp(5)) + 3*x*exp(10) - 4*exp(15)*log(x + exp(5)) - exp(20)/(x + exp(5))
|
|
assert F == integrate(f, x)
|
|
|
|
f = x*(x + exp(10)/x**2) + x
|
|
F = x**3/3 + x**2/2 + exp(10)*log(x)
|
|
assert F == integrate(f, x)
|
|
|
|
f = x + x/(5*x + sinh(3))
|
|
F = x**2/2 + x/5 - log(5*x + sinh(3))*sinh(3)/25
|
|
assert F == integrate(f, x)
|
|
|
|
f = (x + exp(3))/(2*x**2 + 2*x)
|
|
F = exp(3)*log(x)/2 - exp(3)*log(x + 1)/2 + log(x + 1)/2
|
|
assert F == integrate(f, x).expand()
|
|
|
|
f = log(x + 4*sinh(4))
|
|
F = x*log(x + 4*sinh(4)) - x + 4*log(x + 4*sinh(4))*sinh(4)
|
|
assert F == integrate(f, x)
|
|
|
|
f = -x + 20*(exp(-5) - atan(4)/x)**3*sin(4)/x
|
|
F = (-x**2*exp(15)/2 + 20*log(x)*sin(4) - (-180*x**2*exp(5)*sin(4)*atan(4) + 90*x*exp(10)*sin(4)*atan(4)**2 - \
|
|
20*exp(15)*sin(4)*atan(4)**3)/(3*x**3))*exp(-15)
|
|
assert F == integrate(f, x)
|
|
|
|
f = 2*x**2*exp(-4) + 6/x
|
|
F_true = (2*x**3/3 + 6*exp(4)*log(x))*exp(-4)
|
|
assert F_true == integrate(f, x)
|
|
|
|
|
|
def test_issue_21721():
|
|
a = Symbol('a')
|
|
assert integrate(1/(pi*(1+(x-a)**2)),(x,-oo,oo)).expand() == \
|
|
-Heaviside(im(a) - 1, 0) + Heaviside(im(a) + 1, 0)
|
|
|
|
|
|
def test_issue_21831():
|
|
theta = symbols('theta')
|
|
assert integrate(cos(3*theta)/(5-4*cos(theta)), (theta, 0, 2*pi)) == pi/12
|
|
integrand = cos(2*theta)/(5 - 4*cos(theta))
|
|
assert integrate(integrand, (theta, 0, 2*pi)) == pi/6
|
|
|
|
|
|
@slow
|
|
def test_issue_22033_integral():
|
|
assert integrate((x**2 - Rational(1, 4))**2 * sqrt(1 - x**2), (x, -1, 1)) == pi/32
|
|
|
|
|
|
@slow
|
|
def test_issue_21671():
|
|
assert integrate(1,(z,x**2+y**2,2-x**2-y**2),(y,-sqrt(1-x**2),sqrt(1-x**2)),(x,-1,1)) == pi
|
|
assert integrate(-4*(1 - x**2)**(S(3)/2)/3 + 2*sqrt(1 - x**2)*(2 - 2*x**2), (x, -1, 1)) == pi
|
|
|
|
|
|
def test_issue_18527():
|
|
# The manual integrator can not currently solve this. Assert that it does
|
|
# not give an incorrect result involving Abs when x has real assumptions.
|
|
xr = symbols('xr', real=True)
|
|
expr = (cos(x)/(4+(sin(x))**2))
|
|
res_real = integrate(expr.subs(x, xr), xr, manual=True).subs(xr, x)
|
|
assert integrate(expr, x, manual=True) == res_real == Integral(expr, x)
|
|
|
|
|
|
def test_issue_23718():
|
|
f = 1/(b*cos(x) + a*sin(x))
|
|
Fpos = (-log(-a/b + tan(x/2) - sqrt(a**2 + b**2)/b)/sqrt(a**2 + b**2)
|
|
+log(-a/b + tan(x/2) + sqrt(a**2 + b**2)/b)/sqrt(a**2 + b**2))
|
|
F = Piecewise(
|
|
# XXX: The zoo case here is for a=b=0 so it should just be zoo or maybe
|
|
# it doesn't really need to be included at all given that the original
|
|
# integrand is really undefined in that case anyway.
|
|
(zoo*(-log(tan(x/2) - 1) + log(tan(x/2) + 1)), Eq(a, 0) & Eq(b, 0)),
|
|
(log(tan(x/2))/a, Eq(b, 0)),
|
|
(-I/(-I*b*sin(x) + b*cos(x)), Eq(a, -I*b)),
|
|
(I/(I*b*sin(x) + b*cos(x)), Eq(a, I*b)),
|
|
(Fpos, True),
|
|
)
|
|
assert integrate(f, x) == F
|
|
|
|
ap, bp = symbols('a, b', positive=True)
|
|
rep = {a: ap, b: bp}
|
|
assert integrate(f.subs(rep), x) == Fpos.subs(rep)
|
|
|
|
|
|
def test_issue_23566():
|
|
i = integrate(1/sqrt(x**2-1), (x, -2, -1))
|
|
assert i == -log(2 - sqrt(3))
|
|
assert math.isclose(i.n(), 1.31695789692482)
|
|
|
|
|
|
def test_pr_23583():
|
|
# This result from meijerg is wrong. Check whether new result is correct when this test fail.
|
|
assert integrate(1/sqrt((x - I)**2-1)) == Piecewise((acosh(x - I), Abs((x - I)**2) > 1), (-I*asin(x - I), True))
|
|
|
|
|
|
def test_issue_7264():
|
|
assert integrate(exp(x)*sqrt(1 + exp(2*x))) == sqrt(exp(2*x) + 1)*exp(x)/2 + asinh(exp(x))/2
|
|
|
|
|
|
def test_issue_11254a():
|
|
assert integrate(sech(x), (x, 0, 1)) == 2*atan(tanh(S.Half))
|
|
|
|
|
|
def test_issue_11254b():
|
|
assert integrate(csch(x), x) == log(tanh(x/2))
|
|
assert integrate(csch(x), (x, 0, 1)) == oo
|
|
|
|
|
|
def test_issue_11254d():
|
|
assert integrate((sech(x)**2).rewrite(sinh), x) == 2*tanh(x/2)/(tanh(x/2)**2 + 1)
|
|
|
|
|
|
def test_issue_22863():
|
|
i = integrate((3*x**3-x**2+2*x-4)/sqrt(x**2-3*x+2), (x, 0, 1))
|
|
assert i == -101*sqrt(2)/8 - 135*log(3 - 2*sqrt(2))/16
|
|
assert math.isclose(i.n(), -2.98126694400554)
|
|
|
|
|
|
def test_issue_9723():
|
|
assert integrate(sqrt(x + sqrt(x))) == \
|
|
2*sqrt(sqrt(x) + x)*(sqrt(x)/12 + x/3 - S(1)/8) + log(2*sqrt(x) + 2*sqrt(sqrt(x) + x) + 1)/8
|
|
assert integrate(sqrt(2*x+3+sqrt(4*x+5))**3) == \
|
|
sqrt(2*x + sqrt(4*x + 5) + 3) * \
|
|
(9*x/10 + 11*(4*x + 5)**(S(3)/2)/40 + sqrt(4*x + 5)/40 + (4*x + 5)**2/10 + S(11)/10)/2
|
|
|
|
|
|
def test_issue_23704():
|
|
# XXX: This is testing that an exception is not raised in risch Ideally
|
|
# manualintegrate (manual=True) would be able to compute this but
|
|
# manualintegrate is very slow for this example so we don't test that here.
|
|
assert (integrate(log(x)/x**2/(c*x**2+b*x+a),x, risch=True)
|
|
== NonElementaryIntegral(log(x)/(a*x**2 + b*x**3 + c*x**4), x))
|
|
|
|
|
|
def test_exp_substitution():
|
|
assert integrate(1/sqrt(1-exp(2*x))) == log(sqrt(1 - exp(2*x)) - 1)/2 - log(sqrt(1 - exp(2*x)) + 1)/2
|
|
|
|
|
|
def test_hyperbolic():
|
|
assert integrate(coth(x)) == x - log(tanh(x) + 1) + log(tanh(x))
|
|
assert integrate(sech(x)) == 2*atan(tanh(x/2))
|
|
assert integrate(csch(x)) == log(tanh(x/2))
|
|
|
|
|
|
def test_nested_pow():
|
|
assert integrate(sqrt(x**2)) == x*sqrt(x**2)/2
|
|
assert integrate(sqrt(x**(S(5)/3))) == 6*x*sqrt(x**(S(5)/3))/11
|
|
assert integrate(1/sqrt(x**2)) == x*log(x)/sqrt(x**2)
|
|
assert integrate(x*sqrt(x**(-4))) == x**2*sqrt(x**-4)*log(x)
|
|
|
|
|
|
def test_sqrt_quadratic():
|
|
assert integrate(1/sqrt(3*x**2+4*x+5)) == sqrt(3)*asinh(3*sqrt(11)*(x + S(2)/3)/11)/3
|
|
assert integrate(1/sqrt(-3*x**2+4*x+5)) == sqrt(3)*asin(3*sqrt(19)*(x - S(2)/3)/19)/3
|
|
assert integrate(1/sqrt(3*x**2+4*x-5)) == sqrt(3)*log(6*x + 2*sqrt(3)*sqrt(3*x**2 + 4*x - 5) + 4)/3
|
|
assert integrate(1/sqrt(4*x**2-4*x+1)) == (x - S.Half)*log(x - S.Half)/(2*sqrt((x - S.Half)**2))
|
|
assert integrate(1/sqrt(a+b*x+c*x**2), x) == \
|
|
Piecewise((log(b + 2*sqrt(c)*sqrt(a + b*x + c*x**2) + 2*c*x)/sqrt(c), Ne(c, 0) & Ne(a - b**2/(4*c), 0)),
|
|
((b/(2*c) + x)*log(b/(2*c) + x)/sqrt(c*(b/(2*c) + x)**2), Ne(c, 0)),
|
|
(2*sqrt(a + b*x)/b, Ne(b, 0)), (x/sqrt(a), True))
|
|
|
|
assert integrate((7*x+6)/sqrt(3*x**2+4*x+5)) == \
|
|
7*sqrt(3*x**2 + 4*x + 5)/3 + 4*sqrt(3)*asinh(3*sqrt(11)*(x + S(2)/3)/11)/9
|
|
assert integrate((7*x+6)/sqrt(-3*x**2+4*x+5)) == \
|
|
-7*sqrt(-3*x**2 + 4*x + 5)/3 + 32*sqrt(3)*asin(3*sqrt(19)*(x - S(2)/3)/19)/9
|
|
assert integrate((7*x+6)/sqrt(3*x**2+4*x-5)) == \
|
|
7*sqrt(3*x**2 + 4*x - 5)/3 + 4*sqrt(3)*log(6*x + 2*sqrt(3)*sqrt(3*x**2 + 4*x - 5) + 4)/9
|
|
assert integrate((d+e*x)/sqrt(a+b*x+c*x**2), x) == \
|
|
Piecewise(((-b*e/(2*c) + d) *
|
|
Piecewise((log(b + 2*sqrt(c)*sqrt(a + b*x + c*x**2) + 2*c*x)/sqrt(c), Ne(a - b**2/(4*c), 0)),
|
|
((b/(2*c) + x)*log(b/(2*c) + x)/sqrt(c*(b/(2*c) + x)**2), True)) +
|
|
e*sqrt(a + b*x + c*x**2)/c, Ne(c, 0)),
|
|
((2*d*sqrt(a + b*x) + 2*e*(-a*sqrt(a + b*x) + (a + b*x)**(S(3)/2)/3)/b)/b, Ne(b, 0)),
|
|
((d*x + e*x**2/2)/sqrt(a), True))
|
|
|
|
assert integrate((3*x**3-x**2+2*x-4)/sqrt(x**2-3*x+2)) == \
|
|
sqrt(x**2 - 3*x + 2)*(x**2 + 13*x/4 + S(101)/8) + 135*log(2*x + 2*sqrt(x**2 - 3*x + 2) - 3)/16
|
|
|
|
assert integrate(sqrt(53225*x**2-66732*x+23013)) == \
|
|
(x/2 - S(16683)/53225)*sqrt(53225*x**2 - 66732*x + 23013) + \
|
|
111576969*sqrt(2129)*asinh(53225*x/10563 - S(11122)/3521)/1133160250
|
|
assert integrate(sqrt(a+b*x+c*x**2), x) == \
|
|
Piecewise(((a/2 - b**2/(8*c)) *
|
|
Piecewise((log(b + 2*sqrt(c)*sqrt(a + b*x + c*x**2) + 2*c*x)/sqrt(c), Ne(a - b**2/(4*c), 0)),
|
|
((b/(2*c) + x)*log(b/(2*c) + x)/sqrt(c*(b/(2*c) + x)**2), True)) +
|
|
(b/(4*c) + x/2)*sqrt(a + b*x + c*x**2), Ne(c, 0)),
|
|
(2*(a + b*x)**(S(3)/2)/(3*b), Ne(b, 0)),
|
|
(sqrt(a)*x, True))
|
|
|
|
assert integrate(x*sqrt(x**2+2*x+4)) == \
|
|
(x**2/3 + x/6 + S(5)/6)*sqrt(x**2 + 2*x + 4) - 3*asinh(sqrt(3)*(x + 1)/3)/2
|
|
|
|
|
|
def test_mul_pow_derivative():
|
|
assert integrate(x*sec(x)*tan(x)) == x*sec(x) - log(tan(x) + sec(x))
|
|
assert integrate(x*sec(x)**2, x) == x*tan(x) + log(cos(x))
|
|
assert integrate(x**3*Derivative(f(x), (x, 4))) == \
|
|
x**3*Derivative(f(x), (x, 3)) - 3*x**2*Derivative(f(x), (x, 2)) + 6*x*Derivative(f(x), x) - 6*f(x)
|