def test_as_sum_raises():
e = Integral((x + y)**2, (x, 0, 1))
pytest.raises(ValueError, lambda: e.as_sum(-1))
pytest.raises(ValueError, lambda: e.as_sum(0))
pytest.raises(ValueError, lambda: Integral(x).as_sum(3))
pytest.raises(NotImplementedError, lambda: e.as_sum(oo))
pytest.raises(NotImplementedError, lambda: e.as_sum(3, method='xxxx2'))
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_sympyissue_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_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_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").evalf() - e.evalf()) < 0.5
e = Integral(sqrt(x**3 + y**3), (x, 2, 10), (y, 0, 10))
pytest.raises(NotImplementedError, lambda: e.as_sum(4))
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_subs6():
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_basics():
assert Integral(0, x) != 0
assert Integral(x, (x, 1, 1)) != 0
assert Integral(oo, x) != oo
assert Integral(nan, x) == 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 + Integral(0, (t, 0, 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() == {0, 1, 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 sympy/sympy#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_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_nested_doit():
e = Integral(Integral(x, x), x)
f = Integral(x, x, x)
assert e.doit() == f.doit()
def test_doit2():
f = Integral(2 * x, x)
l = Limit(f, x, oo)
# limit() breaks on the contained Integral.
assert l.doit(deep=False) == l
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))
def test_sym_integral():
f = Lambda(x, exp(-x**2))
l = lambdify(x, Integral(f(x), (x, -oo, oo)), modules="diofant")
assert l(y).doit() == sqrt(pi)
def test_sympyissue_4021():
e = Integral(x, x) + 1
assert str(e) == 'Integral(x, x) + 1'
def test_is_zero():
assert Integral(0, (x, 1, x)).is_zero
assert Integral(1, (x, 1, 1)).is_zero
assert Integral(1, (x, m)).is_zero is None
assert Integral(1, (x, 1, 2), (y, 2)).is_nonzero
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
assert Integral(x, (x, oo, oo)).is_zero # issue sympy/sympy#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_is_real():
assert Integral(x**3, (x, 1, 3)).is_real
assert Integral(1/(x - 1), (x, -1, 1)).is_real is not True
def test_is_number():
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 eqivalent 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.evalf() == 0
i = Integral(x, (y, z, z))
assert i.is_number is False and i.evalf() == 0
i = Integral(1, (y, z, z + 2))
assert i.is_number is False and i.evalf() == 2
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_symbols():
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}
def test_as_dummy():
assert Integral(x, x).as_dummy() == Integral(x, x)
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_integral_reconstruct():
e = Integral(x**2, (x, -1, 1))
assert e == Integral(*e.args)
def test_probability():
# various integrals from probability theory
mu1, mu2 = symbols('mu1 mu2', real=True, nonzero=True)
sigma1, sigma2 = symbols('sigma1 sigma2',
real=True,
nonzero=True,
positive=True)
rate = Symbol('lambda', real=True, positive=True)
def normal(x, mu, sigma):
return 1 / sqrt(2 * pi * sigma**2) * exp(-(x - mu)**2 / 2 / sigma**2)
def exponential(x, rate):
return rate * exp(-rate * x)
assert integrate(normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True) == 1
assert integrate(x*normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True) == \
mu1
assert integrate(x**2*normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True) \
== mu1**2 + sigma1**2
assert integrate(x**3*normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True) \
== mu1**3 + 3*mu1*sigma1**2
assert integrate(normal(x, mu1, sigma1) * normal(y, mu2, sigma2),
(x, -oo, oo), (y, -oo, oo),
meijerg=True) == 1
assert integrate(x * normal(x, mu1, sigma1) * normal(y, mu2, sigma2),
(x, -oo, oo), (y, -oo, oo),
meijerg=True) == mu1
assert integrate(y * normal(x, mu1, sigma1) * normal(y, mu2, sigma2),
(x, -oo, oo), (y, -oo, oo),
meijerg=True) == mu2
assert integrate(x * y * normal(x, mu1, sigma1) * normal(y, mu2, sigma2),
(x, -oo, oo), (y, -oo, oo),
meijerg=True) == mu1 * mu2
assert integrate(
(x + y + 1) * normal(x, mu1, sigma1) * normal(y, mu2, sigma2),
(x, -oo, oo), (y, -oo, oo),
meijerg=True) == 1 + mu1 + mu2
assert integrate((x + y - 1)*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),
(x, -oo, oo), (y, -oo, oo), meijerg=True) == \
-1 + mu1 + mu2
i = integrate(x**2 * normal(x, mu1, sigma1) * normal(y, mu2, sigma2),
(x, -oo, oo), (y, -oo, oo),
meijerg=True)
assert not i.has(Abs)
assert simplify(i) == mu1**2 + sigma1**2
assert integrate(y**2*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),
(x, -oo, oo), (y, -oo, oo), meijerg=True) == \
sigma2**2 + mu2**2
assert integrate(exponential(x, rate), (x, 0, oo), meijerg=True) == 1
assert integrate(x*exponential(x, rate), (x, 0, oo), meijerg=True) == \
1/rate
assert integrate(x**2*exponential(x, rate), (x, 0, oo), meijerg=True) == \
2/rate**2
def E(expr):
res1 = integrate(expr * exponential(x, rate) * normal(y, mu1, sigma1),
(x, 0, oo), (y, -oo, oo),
meijerg=True)
res2 = integrate(expr * exponential(x, rate) * normal(y, mu1, sigma1),
(y, -oo, oo), (x, 0, oo),
meijerg=True)
assert expand_mul(res1) == expand_mul(res2)
return res1
assert E(1) == 1
assert E(x * y) == mu1 / rate
assert E(x * y**2) == mu1**2 / rate + sigma1**2 / rate
ans = sigma1**2 + 1 / rate**2
assert simplify(E((x + y + 1)**2) - E(x + y + 1)**2) == ans
assert simplify(E((x + y - 1)**2) - E(x + y - 1)**2) == ans
assert simplify(E((x + y)**2) - E(x + y)**2) == ans
# Beta' distribution
alpha, beta = symbols('alpha beta', positive=True, real=True)
betadist = x**(alpha - 1)*(1 + x)**(-alpha - beta)*gamma(alpha + beta) \
/ gamma(alpha)/gamma(beta)
assert integrate(betadist, (x, 0, oo), meijerg=True) == 1
i = integrate(x * betadist, (x, 0, oo), meijerg=True, conds='separate')
assert (combsimp(i[0]), i[1]) == (alpha / (beta - 1), 1 < beta)
j = integrate(x**2 * betadist, (x, 0, oo), meijerg=True, conds='separate')
assert j[1] == (1 < beta - 1)
assert combsimp(j[0] - i[0]**2) == (alpha + beta - 1)*alpha \
/ (beta - 2)/(beta - 1)**2
# Beta distribution
# NOTE: this is evaluated using antiderivatives. It also tests that
# meijerint_indefinite returns the simplest possible answer.
a, b = symbols('a b', positive=True)
betadist = x**(a - 1) * (-x + 1)**(b - 1) * gamma(a + b) / (gamma(a) *
gamma(b))
assert simplify(integrate(betadist, (x, 0, 1), meijerg=True)) == 1
assert simplify(integrate(x*betadist, (x, 0, 1), meijerg=True)) == \
a/(a + b)
assert simplify(integrate(x**2*betadist, (x, 0, 1), meijerg=True)) == \
a*(a + 1)/(a + b)/(a + b + 1)
assert simplify(integrate(x**y*betadist, (x, 0, 1), meijerg=True)) == \
Piecewise((gamma(a + b)*gamma(a + y)/(gamma(a)*gamma(a + b + y)),
-a - re(y) + 1 < 1),
(Integral(x**(a + y - 1)*(-x + 1)**(b - 1)*gamma(a + b)/(gamma(a)*gamma(b)),
(x, 0, 1)), True))
# Chi distribution
k = Symbol('k', integer=True, positive=True)
chi = 2**(1 - k / 2) * x**(k - 1) * exp(-x**2 / 2) / gamma(k / 2)
assert powsimp(integrate(chi, (x, 0, oo), meijerg=True)) == 1
assert simplify(integrate(x*chi, (x, 0, oo), meijerg=True)) == \
sqrt(2)*gamma((k + 1)/2)/gamma(k/2)
assert simplify(integrate(x**2 * chi, (x, 0, oo), meijerg=True)) == k
# Chi^2 distribution
chisquared = 2**(-k / 2) / gamma(k / 2) * x**(k / 2 - 1) * exp(-x / 2)
assert powsimp(integrate(chisquared, (x, 0, oo), meijerg=True)) == 1
assert simplify(integrate(x * chisquared, (x, 0, oo), meijerg=True)) == k
assert simplify(integrate(x**2*chisquared, (x, 0, oo), meijerg=True)) == \
k*(k + 2)
assert combsimp(
integrate(((x - k) / sqrt(2 * k))**3 * chisquared, (x, 0, oo),
meijerg=True)) == 2 * sqrt(2) / sqrt(k)
# Dagum distribution
a, b, p = symbols('a b p', positive=True, real=True)
# XXX (x/b)**a does not work
dagum = a * p / x * (x / b)**(a * p) / (1 + x**a / b**a)**(p + 1)
assert simplify(integrate(dagum, (x, 0, oo), meijerg=True)) == 1
# XXX conditions are a mess
arg = x * dagum
assert simplify(integrate(
arg, (x, 0, oo), meijerg=True,
conds='none')) == a * b * gamma(1 - 1 / a) * gamma(p + 1 + 1 / a) / (
(a * p + 1) * gamma(p))
assert simplify(integrate(
x * arg, (x, 0, oo), meijerg=True,
conds='none')) == a * b**2 * gamma(1 -
2 / a) * gamma(p + 1 + 2 / a) / (
(a * p + 2) * gamma(p))
# F-distribution
d1, d2 = symbols('d1 d2', positive=True)
f = sqrt(((d1*x)**d1 * d2**d2)/(d1*x + d2)**(d1 + d2))/x \
/ gamma(d1/2)/gamma(d2/2)*gamma((d1 + d2)/2)
assert simplify(integrate(f, (x, 0, oo), meijerg=True)) == 1
# TODO conditions are a mess
assert simplify(integrate(x * f, (x, 0, oo), meijerg=True,
conds='none')) == d2 / (d2 - 2)
assert simplify(
integrate(x**2 * f, (x, 0, oo), meijerg=True,
conds='none')) == d2**2 * (d1 + 2) / d1 / (d2 - 4) / (d2 - 2)
# TODO gamma, rayleigh
# inverse gaussian
lamda, mu = symbols('lamda mu', positive=True)
dist = sqrt(lamda / 2 / pi) * x**(-Rational(3, 2)) * exp(
-lamda * (x - mu)**2 / x / 2 / mu**2)
def mysimp(expr):
return simplify(expr.rewrite(exp))
assert mysimp(integrate(dist, (x, 0, oo))) == 1
assert mysimp(integrate(x * dist, (x, 0, oo))) == mu
assert mysimp(integrate((x - mu)**2 * dist, (x, 0, oo))) == mu**3 / lamda
assert mysimp(integrate((x - mu)**3 * dist,
(x, 0, oo))) == 3 * mu**5 / lamda**2
# Levi
c = Symbol('c', positive=True)
assert integrate(
sqrt(c / 2 / pi) * exp(-c / 2 / (x - mu)) / (x - mu)**Rational(3, 2),
(x, mu, oo)) == 1
# higher moments oo
# log-logistic
distn = (beta/alpha)*x**(beta - 1)/alpha**(beta - 1) / \
(1 + x**beta/alpha**beta)**2
assert simplify(integrate(distn, (x, 0, oo))) == 1
# NOTE the conditions are a mess, but correctly state beta > 1
assert simplify(integrate(x*distn, (x, 0, oo), conds='none')) == \
pi*alpha/beta/sin(pi/beta)
# (similar comment for conditions applies)
assert simplify(integrate(x**y*distn, (x, 0, oo), conds='none')) == \
pi*alpha**y*y/beta/sin(pi*y/beta)
# weibull
k = Symbol('k', positive=True, real=True)
n = Symbol('n', positive=True)
distn = k / lamda * (x / lamda)**(k - 1) * exp(-(x / lamda)**k)
assert simplify(integrate(distn, (x, 0, oo))) == 1
assert simplify(integrate(x**n*distn, (x, 0, oo))) == \
lamda**n*gamma(1 + n/k)
# rice distribution
nu, sigma = symbols('nu sigma', positive=True)
rice = x / sigma**2 * exp(-(x**2 + nu**2) / 2 / sigma**2) * besseli(
0, x * nu / sigma**2)
assert integrate(rice, (x, 0, oo), meijerg=True) == 1
# can someone verify higher moments?
# Laplace distribution
mu = Symbol('mu', extended_real=True)
b = Symbol('b', positive=True)
laplace = exp(-abs(x - mu) / b) / 2 / b
assert integrate(laplace, (x, -oo, oo), meijerg=True) == 1
assert integrate(x * laplace, (x, -oo, oo), meijerg=True) == mu
assert integrate(x**2*laplace, (x, -oo, oo), meijerg=True) == \
2*b**2 + mu**2
# TODO are there other distributions supported on (-oo, oo) that we can do?
# misc tests
k = Symbol('k', positive=True)
assert combsimp(
expand_mul(
integrate(log(x) * x**(k - 1) * exp(-x) / gamma(k),
(x, 0, oo)))) == polygamma(0, k)
def test_series():
i = Integral(cos(x), (x, x))
e = i.lseries(x)
s1 = i.nseries(x, n=8).removeO().doit()
s2 = Add(*[next(e) for j in range(4)])
assert s1 == s2
def test_integral():
f = Lambda(x, exp(-x**2))
l = lambdify(x, Integral(f(x), (x, -oo, oo)), modules="diofant")
assert l(x) == Integral(exp(-x**2), (x, -oo, oo))
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) + 2*y/3 + y**2
assert e.as_sum(4, method='left').expand() == Rational(7, 32) + 3*y/4 + y**2
def test_Integral():
assert str(Integral(sin(x), y)) == 'Integral(sin(x), y)'
assert str(Integral(sin(x), (y, 0, 1))) == 'Integral(sin(x), (y, 0, 1))'
def test_as_sum_trapezoid():
e = Integral(sin(x), (x, 3, 7))
assert e.as_sum(2, 'trapezoid') == 2*sin(5) + sin(3) + sin(7)
def test_doit():
f = Integral(2 * x, x)
l = Limit(f, x, oo)
assert l.doit() == oo
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) + 2*y/3 + y**2
assert e.as_sum(4, method="left").expand() == Rational(7, 32) + 3*y/4 + y**2
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", extended_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_as_sum_midpoint2():
e = Integral((x + y)**2, (x, 0, 1))
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
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_integration_variable():
pytest.raises(ValueError, lambda: Integral(exp(-x**2), 3))
pytest.raises(ValueError, lambda: Integral(exp(-x**2), (3, -oo, oo)))
def test_sympyissue_5167():
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 possibble
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_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) + 3*y/2 + y**2
assert e.as_sum(3, method='right').expand() == Rational(14, 27) + 4*y/3 + y**2
assert e.as_sum(4, method='right').expand() == Rational(15, 32) + 5*y/4 + y**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))
def test_sympyissue_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_as_sum_midpoint2():
e = Integral((x + y)**2, (x, 0, 1))
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
# Some of the pretty forms shown denote how the expressions just
# above them should look with pretty printing.
N = CoordSysCartesian('N')
C = N.orient_new_axis('C', a, N.k)
v = []
d = []
v.append(Vector.zero)
v.append(N.i)
v.append(-N.i)
v.append(N.i + N.j)
v.append(a * N.i)
v.append(a * N.i - b * N.j)
v.append((a**2 + N.x) * N.i + N.k)
v.append((a**2 + b) * N.i + 3 * (C.y - c) * N.k)
f = Function('f')
v.append(N.j - (Integral(f(b)) - C.x**2) * N.k)
upretty_v_8 = \
"""\
N_j + ⎛ 2 ⌠ ⎞ N_k\n\
⎜C_x - ⎮ f(b) db⎟ \n\
⎝ ⌡ ⎠ \
"""
pretty_v_8 = \
"""\
N_j + / / \\\n\
| 2 | |\n\
|C_x - | f(b) db|\n\
| | |\n\
\\ / / \
"""
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) + 3*y/2 + y**2
assert e.as_sum(3, method="right").expand() == Rational(14, 27) + 4*y/3 + y**2
assert e.as_sum(4, method="right").expand() == Rational(15, 32) + 5*y/4 + y**2
def test_evalf_integral():
# test that workprec has to increase in order to get a result other than 0
eps = Rational(1, 1000000)
assert Integral(sin(x), (x, -pi, pi + eps)).evalf(2)._prec == 10
assert (Integral(sin(I * x), (x, -pi, pi + eps)).evalf(2) / I)._prec == 10
def test_nested_doit():
e = Integral(Integral(x, x), x)
f = Integral(x, x, x)
assert e.doit() == f.doit()
def test_order_symbols():
e = x * y * sin(x) * Integral(x, (x, 1, 2))
assert O(e) == O(x**2 * y)
assert O(e, x) == O(x**2)
def test_meijerint():
s, t, mu = symbols('s t mu', extended_real=True)
assert integrate(
meijerg([], [], [0], [], s * t) *
meijerg([], [], [mu / 2], [-mu / 2], t**2 / 4),
(t, 0, oo)).is_Piecewise
s = symbols('s', positive=True)
assert integrate(x**s*meijerg([[], []], [[0], []], x), (x, 0, oo)) == \
gamma(s + 1)
assert integrate(x**s * meijerg([[], []], [[0], []], x), (x, 0, oo),
meijerg=True) == gamma(s + 1)
assert isinstance(
integrate(x**s * meijerg([[], []], [[0], []], x), (x, 0, oo),
meijerg=False), Integral)
assert meijerint_indefinite(exp(x), x) == exp(x)
# issue sympy/sympy#8368
assert meijerint_indefinite(
cosh(x) * exp(-x * t),
x) == ((-t - 1) * exp(x) +
(-t + 1) * exp(-x)) * exp(-t * x) / 2 / (t**2 - 1)
# TODO what simplifications should be done automatically?
# This tests "extra case" for antecedents_1.
a, b = symbols('a b', positive=True)
assert simplify(meijerint_definite(x**a, x, 0, b)[0]) == \
b**(a + 1)/(a + 1)
# This tests various conditions and expansions:
meijerint_definite((x + 1)**3 * exp(-x), x, 0, oo) == (16, True)
# Again, how about simplifications?
sigma, mu = symbols('sigma mu', positive=True)
i, c = meijerint_definite(exp(-((x - mu) / (2 * sigma))**2), x, 0, oo)
assert simplify(i) == sqrt(pi) * sigma * (erf(mu / (2 * sigma)) + 1)
assert c
i, _ = meijerint_definite(exp(-mu * x) * exp(sigma * x), x, 0, oo)
# TODO it would be nice to test the condition
assert simplify(i) == 1 / (mu - sigma)
# Test substitutions to change limits
assert meijerint_definite(exp(x), x, -oo, 2) == (exp(2), True)
# Note: causes a NaN in _check_antecedents
assert expand(meijerint_definite(exp(x), x, 0, I)[0]) == exp(I) - 1
assert expand(meijerint_definite(exp(-x), x, 0, x)[0]) == \
1 - exp(-exp(I*arg(x))*abs(x))
# Test -oo to oo
assert meijerint_definite(exp(-x**2), x, -oo, oo) == (sqrt(pi), True)
assert meijerint_definite(exp(-abs(x)), x, -oo, oo) == (2, True)
assert meijerint_definite(exp(-(2*x - 3)**2), x, -oo, oo) == \
(sqrt(pi)/2, True)
assert meijerint_definite(exp(-abs(2 * x - 3)), x, -oo, oo) == (1, True)
assert meijerint_definite(
exp(-((x - mu) / sigma)**2 / 2) / sqrt(2 * pi * sigma**2), x, -oo,
oo) == (1, True)
# Test one of the extra conditions for 2 g-functinos
assert meijerint_definite(exp(-x) * sin(x), x, 0,
oo) == (Rational(1, 2), True)
# Test a bug
def res(n):
return (1 / (1 + x**2)).diff(x, n).subs({x: 1}) * (-1)**n
for n in range(6):
assert integrate(exp(-x)*sin(x)*x**n, (x, 0, oo), meijerg=True) == \
res(n)
# This used to test trigexpand... now it is done by linear substitution
assert simplify(integrate(exp(-x) * sin(x + a), (x, 0, oo),
meijerg=True)) == sqrt(2) * sin(a + pi / 4) / 2
# Test the condition 14 from prudnikov.
# (This is besselj*besselj in disguise, to stop the product from being
# recognised in the tables.)
a, b, s = symbols('a b s')
assert meijerint_definite(meijerg([], [], [a/2], [-a/2], x/4)
* meijerg([], [], [b/2], [-b/2], x/4)*x**(s - 1), x, 0, oo) == \
(4*2**(2*s - 2)*gamma(-2*s + 1)*gamma(a/2 + b/2 + s)
/ (gamma(-a/2 + b/2 - s + 1)*gamma(a/2 - b/2 - s + 1)
* gamma(a/2 + b/2 - s + 1)),
And(0 < -2*re(4*s) + 8, 0 < re(a/2 + b/2 + s), re(2*s) < 1))
# test a bug
assert integrate(sin(x**a)*sin(x**b), (x, 0, oo), meijerg=True) == \
Integral(sin(x**a)*sin(x**b), (x, 0, oo))
# test better hyperexpand
assert integrate(exp(-x**2)*log(x), (x, 0, oo), meijerg=True) == \
(sqrt(pi)*polygamma(0, Rational(1, 2))/4).expand()
# Test hyperexpand bug.
n = symbols('n', integer=True)
assert simplify(integrate(exp(-x)*x**n, x, meijerg=True)) == \
lowergamma(n + 1, x)
# Test a bug with argument 1/x
alpha = symbols('alpha', positive=True)
assert meijerint_definite((2 - x)**alpha*sin(alpha/x), x, 0, 2) == \
(sqrt(pi)*alpha*gamma(alpha + 1)*meijerg(((), (alpha/2 + Rational(1, 2),
alpha/2 + 1)), ((0, 0, Rational(1, 2)), (-Rational(1, 2),)), alpha**2/16)/4, True)
# test a bug related to 3016
a, s = symbols('a s', positive=True)
assert simplify(integrate(x**s*exp(-a*x**2), (x, -oo, oo))) == \
a**(-s/2 - Rational(1, 2))*((-1)**s + 1)*gamma(s/2 + Rational(1, 2))/2
# issue sympy/sympy#6348
assert integrate(exp(I * x) / (1 + x**2),
(x, -oo, oo)).simplify().rewrite(exp) == pi * exp(-1)
def test_subs6():
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)))