def jacobi_normalized(n, a, b, x):
r"""
Jacobi polynomial :math:`P_n^{\left(\alpha, \beta\right)}(x)`
jacobi_normalized(n, alpha, beta, x) gives the nth Jacobi polynomial
in x, :math:`P_n^{\left(\alpha, \beta\right)}(x)`.
The Jacobi polynomials are orthogonal on :math:`[-1, 1]` with respect
to the weight :math:`\left(1-x\right)^\alpha \left(1+x\right)^\beta`.
This functions returns the polynomials normilzed:
.. math::
\int_{-1}^{1}
P_m^{\left(\alpha, \beta\right)}(x)
P_n^{\left(\alpha, \beta\right)}(x)
(1-x)^{\alpha} (1+x)^{\beta} \mathrm{d}x
= \delta_{m,n}
Examples
========
>>> from sympy import jacobi_normalized
>>> from sympy.abc import n,a,b,x
>>> jacobi_normalized(n, a, b, x)
jacobi(n, a, b, x)/sqrt(2**(a + b + 1)*gamma(a + n + 1)*gamma(b + n + 1)/((a + b + 2*n + 1)*factorial(n)*gamma(a + b + n + 1)))
See Also
========
gegenbauer,
chebyshevt_root, chebyshevu, chebyshevu_root,
legendre, assoc_legendre,
hermite,
laguerre, assoc_laguerre,
sympy.polys.orthopolys.jacobi_poly,
sympy.polys.orthopolys.gegenbauer_poly
sympy.polys.orthopolys.chebyshevt_poly
sympy.polys.orthopolys.chebyshevu_poly
sympy.polys.orthopolys.hermite_poly
sympy.polys.orthopolys.legendre_poly
sympy.polys.orthopolys.laguerre_poly
References
==========
.. [1] http://en.wikipedia.org/wiki/Jacobi_polynomials
.. [2] http://mathworld.wolfram.com/JacobiPolynomial.html
.. [3] http://functions.wolfram.com/Polynomials/JacobiP/
"""
nfactor = (
S(2) ** (a + b + 1)
* (gamma(n + a + 1) * gamma(n + b + 1))
/ (2 * n + a + b + 1)
/ (factorial(n) * gamma(n + a + b + 1))
)
return jacobi(n, a, b, x) / sqrt(nfactor)
def taylor_term(n, x, *previous_terms):
if n < 0:
return S.Zero
else:
x = sympify(x)
if len(previous_terms) > 1:
p = previous_terms[-1]
return (
(3 ** (S(1) / 3) * x) ** (-n)
* (3 ** (S(1) / 3) * x) ** (n + 1)
* sin(pi * (2 * n / 3 + S(4) / 3))
* factorial(n)
* gamma(n / 3 + S(2) / 3)
/ (sin(pi * (2 * n / 3 + S(2) / 3)) * factorial(n + 1) * gamma(n / 3 + S(1) / 3))
* p
)
else:
return (
S.One
/ (3 ** (S(2) / 3) * pi)
* gamma((n + S.One) / S(3))
* sin(2 * pi * (n + S.One) / S(3))
/ factorial(n)
* (root(3, 3) * x) ** n
)
def _eval_rewrite_as_polynomial(self, n, x):
from sympy import Sum
# TODO: Should make sure n is in N_0
k = Dummy("k")
kern = RisingFactorial(
-n, k) / (gamma(k + alpha + 1) * factorial(k)) * x**k
return gamma(n + alpha + 1) / factorial(n) * Sum(kern, (k, 0, n))
def _eval_rewrite_as_polynomial(self, n, x):
from sympy import Sum
# Make sure n \in N_0
if n.is_negative or n.is_integer is False:
raise ValueError("Error: n should be a non-negative integer.")
k = Dummy("k")
kern = RisingFactorial(
-n, k) / (gamma(k + alpha + 1) * factorial(k)) * x**k
return gamma(n + alpha + 1) / factorial(n) * Sum(kern, (k, 0, n))
def pdf(self, *args):
from sympy.functions.special.gamma_functions import gamma
mu, sigma = self.mu, self.shape_mat
v = S(self.dof)
k = S(len(mu))
sigma_inv = sigma.inv()
args = ImmutableMatrix(args)
x = args - mu
return gamma((k + v)/2)/(gamma(v/2)*(v*pi)**(k/2)*sqrt(det(sigma)))\
*(1 + 1/v*(x.transpose()*sigma_inv*x)[0])**((-v - k)/2)
def eval(cls, z):
if z is S.Zero:
return pi / 2
elif z is S.Half:
return 8 * pi ** (S(3) / 2) / gamma(-S(1) / 4) ** 2
elif z is S.One:
return S.ComplexInfinity
elif z is S.NegativeOne:
return gamma(S(1) / 4) ** 2 / (4 * sqrt(2 * pi))
elif z in (S.Infinity, S.NegativeInfinity, I * S.Infinity, I * S.NegativeInfinity, S.ComplexInfinity):
return S.Zero
def marginal_distribution(self, indices, *sym):
from sympy.functions.special.gamma_functions import gamma
if len(indices) == 2:
return self.pdf(*sym)
if indices[0] == 0:
#For marginal over `x`, return non-standardized Student-T's
#distribution
x = sym[0]
v, mu, sigma = self.alpha - S(1)/2, self.mu, \
S(self.beta)/(self.lamda * self.alpha)
return Lambda(sym, gamma((v + 1)/2)/(gamma(v/2)*sqrt(pi*v)*sigma)*\
(1 + 1/v*((x - mu)/sigma)**2)**((-v -1)/2))
#For marginal over `tau`, return Gamma distribution as per construction
from sympy.stats.crv_types import GammaDistribution
return Lambda(sym, GammaDistribution(self.alpha, self.beta)(sym[0]))
def eval(cls, n, m, x):
if m.could_extract_minus_sign():
# P^{-m}_n ---> F * P^m_n
return S.NegativeOne**(-m) * (factorial(m + n)/factorial(n - m)) * assoc_legendre(n, -m, x)
if m == 0:
# P^0_n ---> L_n
return legendre(n, x)
if x == 0:
return 2**m*sqrt(S.Pi) / (gamma((1 - m - n)/2)*gamma(1 - (m - n)/2))
if n.is_Number and m.is_Number and n.is_integer and m.is_integer:
if n.is_negative:
raise ValueError("%s : 1st index must be nonnegative integer (got %r)" % (cls, n))
if abs(m) > n:
raise ValueError("%s : abs('2nd index') must be <= '1st index' (got %r, %r)" % (cls, n, m))
return cls._eval_at_order(int(n), abs(int(m))).subs(_x, x)
def pdf(self, x, tau):
from sympy.functions.special.gamma_functions import gamma
beta, alpha, lamda = self.beta, self.alpha, self.lamda
mu = self.mu
return beta**alpha*sqrt(lamda)/(gamma(alpha)*sqrt(2*pi))*\
tau**(alpha - S(1)/2)*exp(-1*beta*tau)*\
exp(-1*(lamda*tau*(x - mu)**2)/S(2))
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Infinity:
return S.Zero
elif arg is S.Zero:
return -S.One / (3 ** Rational(1, 3) * gamma(Rational(1, 3)))
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Infinity:
return S.Infinity
elif arg is S.NegativeInfinity:
return S.Zero
elif arg is S.Zero:
return 3 ** Rational(1, 6) / gamma(Rational(1, 3))
def taylor_term(n, x, *previous_terms):
if n < 0:
return S.Zero
else:
x = sympify(x)
if len(previous_terms) > 1:
p = previous_terms[-1]
return (3**(S(1)/3)*x * Abs(sin(2*pi*(n + S.One)/S(3))) * C.factorial((n - S.One)/S(3)) /
((n + S.One) * Abs(cos(2*pi*(n + S.Half)/S(3))) * C.factorial((n - 2)/S(3))) * p)
else:
return (S.One/(root(3, 6)*pi) * gamma((n + S.One)/S(3)) * Abs(sin(2*pi*(n + S.One)/S(3))) /
C.factorial(n) * (root(3, 3)*x)**n)
def eval(cls, n, x):
if not n.is_Number:
# Symbolic result L_n(x)
# L_n(-x) ---> (-1)**n * L_n(x)
if x.could_extract_minus_sign():
return S.NegativeOne**n * legendre(n, -x)
# L_{-n}(x) ---> L_{n-1}(x)
if n.could_extract_minus_sign():
return legendre(-n - S.One, x)
# We can evaluate for some special values of x
if x == S.Zero:
return sqrt(S.Pi)/(gamma(S.Half - n/2)*gamma(S.One + n/2))
elif x == S.One:
return S.One
elif x == S.Infinity:
return S.Infinity
else:
# n is a given fixed integer, evaluate into polynomial;
# L_{-n}(x) ---> L_{n-1}(x)
if n.is_negative:
n = -n - S.One
return cls._eval_at_order(n, x)
def eval(cls, n, a, b, x):
# Simplify to other polynomials
# P^{a, a}_n(x)
if a == b:
if a == -S.Half:
return RisingFactorial(S.Half, n) / factorial(n) * chebyshevt(n, x)
elif a == S.Zero:
return legendre(n, x)
elif a == S.Half:
return RisingFactorial(3*S.Half, n) / factorial(n + 1) * chebyshevu(n, x)
else:
return RisingFactorial(a + 1, n) / RisingFactorial(2*a + 1, n) * gegenbauer(n, a + S.Half, x)
elif b == -a:
# P^{a, -a}_n(x)
return gamma(n + a + 1) / gamma(n + 1) * (1 + x)**(a/2) / (1 - x)**(a/2) * assoc_legendre(n, -a, x)
if not n.is_Number:
# Symbolic result P^{a,b}_n(x)
# P^{a,b}_n(-x) ---> (-1)**n * P^{b,a}_n(-x)
if x.could_extract_minus_sign():
return S.NegativeOne**n * jacobi(n, b, a, -x)
# We can evaluate for some special values of x
if x == S.Zero:
return (2**(-n) * gamma(a + n + 1) / (gamma(a + 1) * factorial(n)) *
hyper([-b - n, -n], [a + 1], -1))
if x == S.One:
return RisingFactorial(a + 1, n) / factorial(n)
elif x == S.Infinity:
if n.is_positive:
# Make sure a+b+2*n \notin Z
if (a + b + 2*n).is_integer:
raise ValueError("Error. a + b + 2*n should not be an integer.")
return RisingFactorial(a + b + n + 1, n) * S.Infinity
else:
# n is a given fixed integer, evaluate into polynomial
return jacobi_poly(n, a, b, x)
def eval(cls, n, x):
if not n.is_Number:
# Symbolic result H_n(x)
# H_n(-x) ---> (-1)**n * H_n(x)
if x.could_extract_minus_sign():
return S.NegativeOne**n * hermite(n, -x)
# We can evaluate for some special values of x
if x == S.Zero:
return 2**n * sqrt(S.Pi) / gamma((S.One - n)/2)
elif x == S.Infinity:
return S.Infinity
else:
# n is a given fixed integer, evaluate into polynomial
if n.is_negative:
raise ValueError(
"The index n must be nonnegative integer (got %r)" % n)
else:
return cls._eval_at_order(n, x)
def eval(cls, n, a, x):
# For negative n the polynomials vanish
# See http://functions.wolfram.com/Polynomials/GegenbauerC3/03/01/03/0012/
if n.is_negative:
return S.Zero
# Some special values for fixed a
if a == S.Half:
return legendre(n, x)
elif a == S.One:
return chebyshevu(n, x)
elif a == S.NegativeOne:
return S.Zero
if not n.is_Number:
# Handle this before the general sign extraction rule
if x == S.NegativeOne:
if (re(a) > S.Half) == True:
return S.ComplexInfinity
else:
# No sec function available yet
#return (cos(S.Pi*(a+n)) * sec(S.Pi*a) * gamma(2*a+n) /
# (gamma(2*a) * gamma(n+1)))
return None
# Symbolic result C^a_n(x)
# C^a_n(-x) ---> (-1)**n * C^a_n(x)
if x.could_extract_minus_sign():
return S.NegativeOne**n * gegenbauer(n, a, -x)
# We can evaluate for some special values of x
if x == S.Zero:
return (2**n * sqrt(S.Pi) * gamma(a + S.Half*n) /
(gamma((1 - n)/2) * gamma(n + 1) * gamma(a)) )
if x == S.One:
return gamma(2*a + n) / (gamma(2*a) * gamma(n + 1))
elif x == S.Infinity:
if n.is_positive:
return RisingFactorial(a, n) * S.Infinity
else:
# n is a given fixed integer, evaluate into polynomial
return gegenbauer_poly(n, a, x)
def eval(cls, n, a, x):
# For negative n the polynomials vanish
# See http://functions.wolfram.com/Polynomials/GegenbauerC3/03/01/03/0012/
if n.is_negative:
return S.Zero
# Some special values for fixed a
if a == S.Half:
return legendre(n, x)
elif a == S.One:
return chebyshevu(n, x)
elif a == S.NegativeOne:
return S.Zero
if not n.is_Number:
# Handle this before the general sign extraction rule
if x == S.NegativeOne:
if (re(a) > S.Half) == True:
return S.ComplexInfinity
else:
# No sec function available yet
#return (cos(S.Pi*(a+n)) * sec(S.Pi*a) * gamma(2*a+n) /
# (gamma(2*a) * gamma(n+1)))
return None
# Symbolic result C^a_n(x)
# C^a_n(-x) ---> (-1)**n * C^a_n(x)
if x.could_extract_minus_sign():
return S.NegativeOne**n * gegenbauer(n, a, -x)
# We can evaluate for some special values of x
if x == S.Zero:
return (2**n * sqrt(S.Pi) * gamma(a + S.Half * n) / (gamma(
(1 - n) / 2) * gamma(n + 1) * gamma(a)))
if x == S.One:
return gamma(2 * a + n) / (gamma(2 * a) * gamma(n + 1))
elif x == S.Infinity:
if n.is_positive:
return RisingFactorial(a, n) * S.Infinity
else:
# n is a given fixed integer, evaluate into polynomial
return gegenbauer_poly(n, a, x)
def eval(cls, n, a, b, x):
# Simplify to other polynomials
# P^{a, a}_n(x)
if a == b:
if a == -S.Half:
return RisingFactorial(S.Half, n) / factorial(n) * chebyshevt(
n, x)
elif a == S.Zero:
return legendre(n, x)
elif a == S.Half:
return RisingFactorial(
3 * S.Half, n) / factorial(n + 1) * chebyshevu(n, x)
else:
return RisingFactorial(a + 1, n) / RisingFactorial(
2 * a + 1, n) * gegenbauer(n, a + S.Half, x)
elif b == -a:
# P^{a, -a}_n(x)
return gamma(n + a + 1) / gamma(n + 1) * (1 + x)**(a / 2) / (
1 - x)**(a / 2) * assoc_legendre(n, -a, x)
elif a == -b:
# P^{-b, b}_n(x)
return gamma(n - b + 1) / gamma(n + 1) * (1 - x)**(b / 2) / (
1 + x)**(b / 2) * assoc_legendre(n, b, x)
if not n.is_Number:
# Symbolic result P^{a,b}_n(x)
# P^{a,b}_n(-x) ---> (-1)**n * P^{b,a}_n(-x)
if x.could_extract_minus_sign():
return S.NegativeOne**n * jacobi(n, b, a, -x)
# We can evaluate for some special values of x
if x == S.Zero:
return (2**(-n) * gamma(a + n + 1) /
(gamma(a + 1) * factorial(n)) *
hyper([-b - n, -n], [a + 1], -1))
if x == S.One:
return RisingFactorial(a + 1, n) / factorial(n)
elif x == S.Infinity:
if n.is_positive:
# Make sure a+b+2*n \notin Z
if (a + b + 2 * n).is_integer:
raise ValueError(
"Error. a + b + 2*n should not be an integer.")
return RisingFactorial(a + b + n + 1, n) * S.Infinity
else:
# n is a given fixed integer, evaluate into polynomial
return jacobi_poly(n, a, b, x)
def test_binomial():
x = Symbol('x')
n = Symbol('n', integer=True)
nz = Symbol('nz', integer=True, nonzero=True)
k = Symbol('k', integer=True)
kp = Symbol('kp', integer=True, positive=True)
kn = Symbol('kn', integer=True, negative=True)
u = Symbol('u', negative=True)
v = Symbol('v', nonnegative=True)
p = Symbol('p', positive=True)
z = Symbol('z', zero=True)
nt = Symbol('nt', integer=False)
kt = Symbol('kt', integer=False)
a = Symbol('a', integer=True, nonnegative=True)
b = Symbol('b', integer=True, nonnegative=True)
assert binomial(0, 0) == 1
assert binomial(1, 1) == 1
assert binomial(10, 10) == 1
assert binomial(n, z) == 1
assert binomial(1, 2) == 0
assert binomial(-1, 2) == 1
assert binomial(1, -1) == 0
assert binomial(-1, 1) == -1
assert binomial(-1, -1) == 0
assert binomial(S.Half, S.Half) == 1
assert binomial(-10, 1) == -10
assert binomial(-10, 7) == -11440
assert binomial(
n, -1) == 0 # holds for all integers (negative, zero, positive)
assert binomial(kp, -1) == 0
assert binomial(nz, 0) == 1
assert expand_func(binomial(n, 1)) == n
assert expand_func(binomial(n, 2)) == n * (n - 1) / 2
assert expand_func(binomial(n, n - 2)) == n * (n - 1) / 2
assert expand_func(binomial(n, n - 1)) == n
assert binomial(n, 3).func == binomial
assert binomial(n, 3).expand(func=True) == n**3 / 6 - n**2 / 2 + n / 3
assert expand_func(binomial(n, 3)) == n * (n - 2) * (n - 1) / 6
assert binomial(n, n).func == binomial # e.g. (-1, -1) == 0, (2, 2) == 1
assert binomial(n, n + 1).func == binomial # e.g. (-1, 0) == 1
assert binomial(kp, kp + 1) == 0
assert binomial(kn, kn) == 0 # issue #14529
assert binomial(n, u).func == binomial
assert binomial(kp, u).func == binomial
assert binomial(n, p).func == binomial
assert binomial(n, k).func == binomial
assert binomial(n, n + p).func == binomial
assert binomial(kp, kp + p).func == binomial
assert expand_func(binomial(n, n - 3)) == n * (n - 2) * (n - 1) / 6
assert binomial(n, k).is_integer
assert binomial(nt, k).is_integer is None
assert binomial(x, nt).is_integer is False
assert binomial(
gamma(25), 6
) == 79232165267303928292058750056084441948572511312165380965440075720159859792344339983120618959044048198214221915637090855535036339620413440000
assert binomial(
1324, 47
) == 906266255662694632984994480774946083064699457235920708992926525848438478406790323869952
assert binomial(
1735, 43
) == 190910140420204130794758005450919715396159959034348676124678207874195064798202216379800
assert binomial(
2512, 53
) == 213894469313832631145798303740098720367984955243020898718979538096223399813295457822575338958939834177325304000
assert binomial(
3383, 52
) == 27922807788818096863529701501764372757272890613101645521813434902890007725667814813832027795881839396839287659777235
assert binomial(
4321, 51
) == 124595639629264868916081001263541480185227731958274383287107643816863897851139048158022599533438936036467601690983780576
assert binomial(a, b).is_nonnegative is True
assert binomial(-1, 2, evaluate=False).is_nonnegative is True
assert binomial(10, 5, evaluate=False).is_nonnegative is True
assert binomial(10, -3, evaluate=False).is_nonnegative is True
assert binomial(-10, -3, evaluate=False).is_nonnegative is True
assert binomial(-10, 2, evaluate=False).is_nonnegative is True
assert binomial(-10, 1, evaluate=False).is_nonnegative is False
assert binomial(-10, 7, evaluate=False).is_nonnegative is False
# issue #14625
for _ in (pi, -pi, nt, v, a):
assert binomial(_, _) == 1
assert binomial(_, _ - 1) == _
assert isinstance(binomial(u, u), binomial)
assert isinstance(binomial(u, u - 1), binomial)
assert isinstance(binomial(x, x), binomial)
assert isinstance(binomial(x, x - 1), binomial)
#issue #18802
assert expand_func(binomial(x + 1, x)) == x + 1
assert expand_func(binomial(x, x - 1)) == x
assert expand_func(binomial(x + 1, x - 1)) == x * (x + 1) / 2
assert expand_func(binomial(x**2 + 1, x**2)) == x**2 + 1
# issue #13980 and #13981
assert binomial(-7, -5) == 0
assert binomial(-23, -12) == 0
assert binomial(Rational(13, 2), -10) == 0
assert binomial(-49, -51) == 0
assert binomial(19,
Rational(-7,
2)) == S(-68719476736) / (911337863661225 * pi)
assert binomial(0, Rational(3, 2)) == S(-2) / (3 * pi)
assert binomial(-3, Rational(-7, 2)) is zoo
assert binomial(kn, kt) is zoo
assert binomial(nt, kt).func == binomial
assert binomial(nt, Rational(
15,
6)) == 8 * gamma(nt + 1) / (15 * sqrt(pi) * gamma(nt - Rational(3, 2)))
assert binomial(Rational(20, 3), Rational(-10, 8)) == gamma(Rational(
23, 3)) / (gamma(Rational(-1, 4)) * gamma(Rational(107, 12)))
assert binomial(Rational(19, 2), Rational(-7,
2)) == Rational(-1615, 8388608)
assert binomial(Rational(-13, 5), Rational(-7, 8)) == gamma(Rational(
-8, 5)) / (gamma(Rational(-29, 40)) * gamma(Rational(1, 8)))
assert binomial(Rational(-19, 8), Rational(-13, 5)) == gamma(
Rational(-11, 8)) / (gamma(Rational(-8, 5)) * gamma(Rational(49, 40)))
# binomial for complexes
assert binomial(I,
Rational(-89,
8)) == gamma(1 + I) / (gamma(Rational(-81, 8)) *
gamma(Rational(97, 8) + I))
assert binomial(I,
2 * I) == gamma(1 + I) / (gamma(1 - I) * gamma(1 + 2 * I))
assert binomial(-7, I) is zoo
assert binomial(Rational(-7, 6), I) == gamma(Rational(
-1, 6)) / (gamma(Rational(-1, 6) - I) * gamma(1 + I))
assert binomial(
(1 + 2 * I),
(1 + 3 * I)) == gamma(2 + 2 * I) / (gamma(1 - I) * gamma(2 + 3 * I))
assert binomial(I, 5) == Rational(1, 3) - I / S(12)
assert binomial((2 * I + 3), 7) == -13 * I / S(63)
assert isinstance(binomial(I, n), binomial)
assert expand_func(binomial(3, 2, evaluate=False)) == 3
assert expand_func(binomial(n, 0, evaluate=False)) == 1
assert expand_func(binomial(n, -2, evaluate=False)) == 0
assert expand_func(binomial(n, k)) == binomial(n, k)
def test_sympy__functions__special__gamma_functions__gamma():
from sympy.functions.special.gamma_functions import gamma
assert _test_args(gamma(x))
def pdf(self, *k):
k0, p = self.k0, self.p
term_1 = (gamma(k0 + sum(k))*(1 - sum(p))**k0)/gamma(k0)
term_2 = Mul.fromiter(pi**ki/factorial(ki) for pi, ki in zip(p, k))
return term_1 * term_2
def gauss_gen_laguerre(n, alpha, n_digits):
r"""
Computes the generalized Gauss-Laguerre quadrature [1]_ points and weights.
The generalized Gauss-Laguerre quadrature approximates the integral:
.. math::
\int_{0}^\infty x^{\alpha} e^{-x} f(x)\,dx \approx
\sum_{i=1}^n w_i f(x_i)
The nodes `x_i` of an order `n` quadrature rule are the roots of
`L^{\alpha}_n` and the weights `w_i` are given by:
.. math::
w_i = \frac{\Gamma(\alpha+n)}
{n \Gamma(n) L^{\alpha}_{n-1}(x_i) L^{\alpha+1}_{n-1}(x_i)}
Parameters
==========
n : the order of quadrature
alpha : the exponent of the singularity, `\alpha > -1`
n_digits : number of significant digits of the points and weights to return
Returns
=======
(x, w) : the ``x`` and ``w`` are lists of points and weights as Floats.
The points `x_i` and weights `w_i` are returned as ``(x, w)``
tuple of lists.
Examples
========
>>> from sympy import S
>>> from sympy.integrals.quadrature import gauss_gen_laguerre
>>> x, w = gauss_gen_laguerre(3, -S.Half, 5)
>>> x
[0.19016, 1.7845, 5.5253]
>>> w
[1.4493, 0.31413, 0.00906]
>>> x, w = gauss_gen_laguerre(4, 3*S.Half, 5)
>>> x
[0.97851, 2.9904, 6.3193, 11.712]
>>> w
[0.53087, 0.67721, 0.11895, 0.0023152]
See Also
========
gauss_legendre, gauss_laguerre, gauss_hermite, gauss_chebyshev_t, gauss_chebyshev_u, gauss_jacobi, gauss_lobatto
References
==========
.. [1] https://en.wikipedia.org/wiki/Gauss%E2%80%93Laguerre_quadrature
.. [2] http://people.sc.fsu.edu/~jburkardt/cpp_src/gen_laguerre_rule/gen_laguerre_rule.html
"""
x = Dummy("x")
p = laguerre_poly(n, x, alpha=alpha, polys=True)
p1 = laguerre_poly(n - 1, x, alpha=alpha, polys=True)
p2 = laguerre_poly(n - 1, x, alpha=alpha + 1, polys=True)
xi = []
w = []
for r in p.real_roots():
if isinstance(r, RootOf):
r = r.eval_rational(S(1) / 10**(n_digits + 2))
xi.append(r.n(n_digits))
w.append((gamma(alpha + n) /
(n * gamma(n) * p1.subs(x, r) * p2.subs(x, r))).n(n_digits))
return xi, w
def gauss_jacobi(n, alpha, beta, n_digits):
r"""
Computes the Gauss-Jacobi quadrature [1]_ points and weights.
The Gauss-Jacobi quadrature of the first kind approximates the integral:
.. math::
\int_{-1}^1 (1-x)^\alpha (1+x)^\beta f(x)\,dx \approx \sum_{i=1}^n w_i f(x_i)
The nodes `x_i` of an order `n` quadrature rule are the roots of `P^{(\alpha,\beta)}_n`
and the weights `w_i` are given by:
.. math::
w_i = -\frac{2n+\alpha+\beta+2}{n+\alpha+\beta+1}\frac{\Gamma(n+\alpha+1)\Gamma(n+\beta+1)}
{\Gamma(n+\alpha+\beta+1)(n+1)!} \frac{2^{\alpha+\beta}}{P'_n(x_i)
P^{(\alpha,\beta)}_{n+1}(x_i)}
Parameters
==========
n : the order of quadrature
alpha : the first parameter of the Jacobi Polynomial, `\alpha > -1`
beta : the second parameter of the Jacobi Polynomial, `\beta > -1`
n_digits : number of significant digits of the points and weights to return
Returns
=======
(x, w) : the ``x`` and ``w`` are lists of points and weights as Floats.
The points `x_i` and weights `w_i` are returned as ``(x, w)``
tuple of lists.
Examples
========
>>> from sympy import S
>>> from sympy.integrals.quadrature import gauss_jacobi
>>> x, w = gauss_jacobi(3, S.Half, -S.Half, 5)
>>> x
[-0.90097, -0.22252, 0.62349]
>>> w
[1.7063, 1.0973, 0.33795]
>>> x, w = gauss_jacobi(6, 1, 1, 5)
>>> x
[-0.87174, -0.5917, -0.2093, 0.2093, 0.5917, 0.87174]
>>> w
[0.050584, 0.22169, 0.39439, 0.39439, 0.22169, 0.050584]
See Also
========
gauss_legendre, gauss_laguerre, gauss_hermite, gauss_gen_laguerre, gauss_chebyshev_t, gauss_chebyshev_u
References
==========
.. [1] http://en.wikipedia.org/wiki/Gauss%E2%80%93Jacobi_quadrature
.. [2] http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_rule/jacobi_rule.html
.. [3] http://people.sc.fsu.edu/~jburkardt/cpp_src/gegenbauer_rule/gegenbauer_rule.html
"""
x = Dummy("x")
p = jacobi_poly(n, alpha, beta, x, polys=True)
pd = p.diff(x)
pn = jacobi_poly(n+1, alpha, beta, x, polys=True)
xi = []
w = []
for r in p.real_roots():
if isinstance(r, RootOf):
r = r.eval_rational(S(1)/10**(n_digits+2))
xi.append(r.n(n_digits))
w.append((
- (2*n+alpha+beta+2) / (n+alpha+beta+S.One)
* (gamma(n+alpha+1)*gamma(n+beta+1)) / (gamma(n+alpha+beta+S.One)*gamma(n+2))
* 2**(alpha+beta) / (pd.subs(x, r) * pn.subs(x, r))
).n(n_digits))
return xi, w
def fdiff(self, argindex=1):
from sympy.functions.special.gamma_functions import (gamma, polygamma)
if argindex == 1:
return gamma(self.args[0] + 1) * polygamma(0, self.args[0] + 1)
else:
raise ArgumentIndexError(self, argindex)
def test_issue_16722():
z = symbols('z', positive=True)
assert limit(binomial(n + z, n)*n**-z, n, oo) == 1/gamma(z + 1)
z = symbols('z', positive=True, integer=True)
assert limit(binomial(n + z, n)*n**-z, n, oo) == 1/gamma(z + 1)
def test_issue_13571():
assert limit(uppergamma(x, 1) / gamma(x), x, oo) == 1
def test_basic1():
assert limit(x, x, oo) is oo
assert limit(x, x, -oo) is -oo
assert limit(-x, x, oo) is -oo
assert limit(x**2, x, -oo) is oo
assert limit(-x**2, x, oo) is -oo
assert limit(x*log(x), x, 0, dir="+") == 0
assert limit(1/x, x, oo) == 0
assert limit(exp(x), x, oo) is oo
assert limit(-exp(x), x, oo) is -oo
assert limit(exp(x)/x, x, oo) is oo
assert limit(1/x - exp(-x), x, oo) == 0
assert limit(x + 1/x, x, oo) is oo
assert limit(x - x**2, x, oo) is -oo
assert limit((1 + x)**(1 + sqrt(2)), x, 0) == 1
assert limit((1 + x)**oo, x, 0) == Limit((x + 1)**oo, x, 0)
assert limit((1 + x)**oo, x, 0, dir='-') == Limit((x + 1)**oo, x, 0, dir='-')
assert limit((1 + x + y)**oo, x, 0, dir='-') == Limit((1 + x + y)**oo, x, 0, dir='-')
assert limit(y/x/log(x), x, 0) == -oo*sign(y)
assert limit(cos(x + y)/x, x, 0) == sign(cos(y))*oo
assert limit(gamma(1/x + 3), x, oo) == 2
assert limit(S.NaN, x, -oo) is S.NaN
assert limit(Order(2)*x, x, S.NaN) is S.NaN
assert limit(1/(x - 1), x, 1, dir="+") is oo
assert limit(1/(x - 1), x, 1, dir="-") is -oo
assert limit(1/(5 - x)**3, x, 5, dir="+") is -oo
assert limit(1/(5 - x)**3, x, 5, dir="-") is oo
assert limit(1/sin(x), x, pi, dir="+") is -oo
assert limit(1/sin(x), x, pi, dir="-") is oo
assert limit(1/cos(x), x, pi/2, dir="+") is -oo
assert limit(1/cos(x), x, pi/2, dir="-") is oo
assert limit(1/tan(x**3), x, (2*pi)**Rational(1, 3), dir="+") is oo
assert limit(1/tan(x**3), x, (2*pi)**Rational(1, 3), dir="-") is -oo
assert limit(1/cot(x)**3, x, (pi*Rational(3, 2)), dir="+") is -oo
assert limit(1/cot(x)**3, x, (pi*Rational(3, 2)), dir="-") is oo
assert limit(tan(x), x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity)
assert limit(cot(x), x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity)
assert limit(sec(x), x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity)
assert limit(csc(x), x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity)
# test bi-directional limits
assert limit(sin(x)/x, x, 0, dir="+-") == 1
assert limit(x**2, x, 0, dir="+-") == 0
assert limit(1/x**2, x, 0, dir="+-") is oo
# test failing bi-directional limits
assert limit(1/x, x, 0, dir="+-") is zoo
# approaching 0
# from dir="+"
assert limit(1 + 1/x, x, 0) is oo
# from dir='-'
# Add
assert limit(1 + 1/x, x, 0, dir='-') is -oo
# Pow
assert limit(x**(-2), x, 0, dir='-') is oo
assert limit(x**(-3), x, 0, dir='-') is -oo
assert limit(1/sqrt(x), x, 0, dir='-') == (-oo)*I
assert limit(x**2, x, 0, dir='-') == 0
assert limit(sqrt(x), x, 0, dir='-') == 0
assert limit(x**-pi, x, 0, dir='-') == oo/(-1)**pi
assert limit((1 + cos(x))**oo, x, 0) == Limit((cos(x) + 1)**oo, x, 0)
# test pull request 22491
assert limit(1/asin(x), x, 0, dir = '+') == oo
assert limit(1/asin(x), x, 0, dir = '-') == -oo
assert limit(1/sinh(x), x, 0, dir = '+') == oo
assert limit(1/sinh(x), x, 0, dir = '-') == -oo
assert limit(log(1/x) + 1/sin(x), x, 0, dir = '+') == oo
assert limit(log(1/x) + 1/x, x, 0, dir = '+') == oo
def test_jacobi():
n = Symbol("n")
a = Symbol("a")
b = Symbol("b")
assert jacobi(0, a, b, x) == 1
assert jacobi(1, a, b, x) == a / 2 - b / 2 + x * (a / 2 + b / 2 + 1)
assert jacobi(n, a, a, x) == RisingFactorial(a + 1, n) * gegenbauer(
n, a + S.Half, x) / RisingFactorial(2 * a + 1, n)
assert jacobi(n, a, -a,
x) == ((-1)**a * (-x + 1)**(-a / 2) * (x + 1)**(a / 2) *
assoc_legendre(n, a, x) * factorial(-a + n) *
gamma(a + n + 1) / (factorial(a + n) * gamma(n + 1)))
assert jacobi(n, -b, b, x) == ((-x + 1)**(b / 2) * (x + 1)**(-b / 2) *
assoc_legendre(n, b, x) *
gamma(-b + n + 1) / gamma(n + 1))
assert jacobi(n, 0, 0, x) == legendre(n, x)
assert jacobi(n, S.Half, S.Half, x) == RisingFactorial(Rational(
3, 2), n) * chebyshevu(n, x) / factorial(n + 1)
assert jacobi(
n, Rational(-1, 2), Rational(-1, 2),
x) == RisingFactorial(S.Half, n) * chebyshevt(n, x) / factorial(n)
X = jacobi(n, a, b, x)
assert isinstance(X, jacobi)
assert jacobi(n, a, b, -x) == (-1)**n * jacobi(n, b, a, x)
assert jacobi(n, a, b, 0) == 2**(-n) * gamma(a + n + 1) * hyper(
(-b - n, -n), (a + 1, ), -1) / (factorial(n) * gamma(a + 1))
assert jacobi(n, a, b, 1) == RisingFactorial(a + 1, n) / factorial(n)
m = Symbol("m", positive=True)
assert jacobi(m, a, b, oo) == oo * RisingFactorial(a + b + m + 1, m)
assert unchanged(jacobi, n, a, b, oo)
assert conjugate(jacobi(m, a, b, x)) == \
jacobi(m, conjugate(a), conjugate(b), conjugate(x))
_k = Dummy('k')
assert diff(jacobi(n, a, b, x), n) == Derivative(jacobi(n, a, b, x), n)
assert diff(jacobi(n, a, b, x), a).dummy_eq(
Sum((jacobi(n, a, b, x) + (2 * _k + a + b + 1) *
RisingFactorial(_k + b + 1, -_k + n) * jacobi(_k, a, b, x) /
((-_k + n) * RisingFactorial(_k + a + b + 1, -_k + n))) /
(_k + a + b + n + 1), (_k, 0, n - 1)))
assert diff(jacobi(n, a, b, x), b).dummy_eq(
Sum(((-1)**(-_k + n) * (2 * _k + a + b + 1) *
RisingFactorial(_k + a + 1, -_k + n) * jacobi(_k, a, b, x) /
((-_k + n) * RisingFactorial(_k + a + b + 1, -_k + n)) +
jacobi(n, a, b, x)) / (_k + a + b + n + 1), (_k, 0, n - 1)))
assert diff(jacobi(n, a, b, x), x) == \
(a/2 + b/2 + n/2 + S.Half)*jacobi(n - 1, a + 1, b + 1, x)
assert jacobi_normalized(n, a, b, x) == \
(jacobi(n, a, b, x)/sqrt(2**(a + b + 1)*gamma(a + n + 1)*gamma(b + n + 1)
/((a + b + 2*n + 1)*factorial(n)*gamma(a + b + n + 1))))
raises(ValueError, lambda: jacobi(-2.1, a, b, x))
raises(ValueError,
lambda: jacobi(Dummy(positive=True, integer=True), 1, 2, oo))
assert jacobi(n, a, b, x).rewrite("polynomial").dummy_eq(
Sum((S.Half - x / 2)**_k * RisingFactorial(-n, _k) *
RisingFactorial(_k + a + 1, -_k + n) *
RisingFactorial(a + b + n + 1, _k) / factorial(_k),
(_k, 0, n)) / factorial(n))
raises(ArgumentIndexError, lambda: jacobi(n, a, b, x).fdiff(5))
def _eval_rewrite_as_gamma(self, arg, piecewise=True, **kwargs):
from sympy.functions.elementary.exponential import exp
from sympy.functions.special.gamma_functions import (gamma, lowergamma)
return (S.NegativeOne**(arg + 1) * exp(-I * pi * arg) *
lowergamma(arg + 1, -1) + gamma(arg + 1)) * exp(-1)
def apply(n):
n = sympify(n)
x = Symbol.x(real=True)
return Equality(Integral[x:0:pi / 2](cos(x)**(n - 1)),
sqrt(pi) * gamma(n / 2) / (2 * gamma(n / 2 + S.One / 2)))
def _eval_expand_func(self, **hints):
x, y = self.args
return gamma(x)*gamma(y) / gamma(x + y)
def test_probability():
# various integrals from probability theory
from sympy.core.function import expand_mul
from sympy.core.symbol import (Symbol, symbols)
from sympy.functions.elementary.complexes import Abs
from sympy.simplify.gammasimp import gammasimp
from sympy.simplify.powsimp import powsimp
mu1, mu2 = symbols('mu1 mu2', nonzero=True)
sigma1, sigma2 = symbols('sigma1 sigma2', positive=True)
rate = Symbol('lambda', 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)
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 (gammasimp(i[0]), i[1]) == (alpha / (beta - 1), 1 < beta)
j = integrate(x**2 * betadist, (x, 0, oo), meijerg=True, conds='separate')
assert j[1] == (beta > 2)
assert gammasimp(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)) == \
gamma(a + b)*gamma(a + y)/gamma(a)/gamma(a + b + y)
# 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 gammasimp(
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)
# 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)
mysimp = lambda expr: 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)**S('3/2'),
(x, mu, oo)) == 1
# higher moments oo
# log-logistic
alpha, beta = symbols('alpha beta', positive=True)
distn = (beta/alpha)*x**(beta - 1)/alpha**(beta - 1)/ \
(1 + x**beta/alpha**beta)**2
# FIXME: If alpha, beta are not declared as finite the line below hangs
# after the changes in:
# https://github.com/sympy/sympy/pull/16603
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)
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
from sympy.functions.special.bessel import besseli
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', 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 gammasimp(
expand_mul(
integrate(log(x) * x**(k - 1) * exp(-x) / gamma(k),
(x, 0, oo)))) == polygamma(0, k)
def jacobi_normalized(n, a, b, x):
r"""
Jacobi polynomial $P_n^{\left(\alpha, \beta\right)}(x)$.
Explanation
===========
``jacobi_normalized(n, alpha, beta, x)`` gives the $n$th
Jacobi polynomial in $x$, $P_n^{\left(\alpha, \beta\right)}(x)$.
The Jacobi polynomials are orthogonal on $[-1, 1]$ with respect
to the weight $\left(1-x\right)^\alpha \left(1+x\right)^\beta$.
This functions returns the polynomials normilzed:
.. math::
\int_{-1}^{1}
P_m^{\left(\alpha, \beta\right)}(x)
P_n^{\left(\alpha, \beta\right)}(x)
(1-x)^{\alpha} (1+x)^{\beta} \mathrm{d}x
= \delta_{m,n}
Examples
========
>>> from sympy import jacobi_normalized
>>> from sympy.abc import n,a,b,x
>>> jacobi_normalized(n, a, b, x)
jacobi(n, a, b, x)/sqrt(2**(a + b + 1)*gamma(a + n + 1)*gamma(b + n + 1)/((a + b + 2*n + 1)*factorial(n)*gamma(a + b + n + 1)))
Parameters
==========
n : integer degree of polynomial
a : alpha value
b : beta value
x : symbol
See Also
========
gegenbauer,
chebyshevt_root, chebyshevu, chebyshevu_root,
legendre, assoc_legendre,
hermite,
laguerre, assoc_laguerre,
sympy.polys.orthopolys.jacobi_poly,
sympy.polys.orthopolys.gegenbauer_poly
sympy.polys.orthopolys.chebyshevt_poly
sympy.polys.orthopolys.chebyshevu_poly
sympy.polys.orthopolys.hermite_poly
sympy.polys.orthopolys.legendre_poly
sympy.polys.orthopolys.laguerre_poly
References
==========
.. [1] https://en.wikipedia.org/wiki/Jacobi_polynomials
.. [2] http://mathworld.wolfram.com/JacobiPolynomial.html
.. [3] http://functions.wolfram.com/Polynomials/JacobiP/
"""
nfactor = (S(2)**(a + b + 1) * (gamma(n + a + 1) * gamma(n + b + 1)) /
(2 * n + a + b + 1) / (factorial(n) * gamma(n + a + b + 1)))
return jacobi(n, a, b, x) / sqrt(nfactor)
def test_issue_19067():
x = Symbol('x')
assert limit(gamma(x)/(gamma(x - 1)*gamma(x + 2)), x, 0) == -1
def _eval_rewrite_as_hyper(self, z, **kwargs):
pf1 = z**2 / (2 * root(3, 6) * gamma(S(2) / 3))
pf2 = root(3, 6) / gamma(S(1) / 3)
return pf1 * hyper([], [S(5) / 3], z**3 / 9) + pf2 * hyper(
[], [S(1) / 3], z**3 / 9)
def _eval_rewrite_as_hyper(self, z):
pf1 = S.One / (root(3, 6) * gamma(S(2) / 3))
pf2 = z * root(3, 6) / gamma(S(1) / 3)
return pf1 * hyper([], [S(2) / 3], z ** 3 / 9) + pf2 * hyper([], [S(4) / 3], z ** 3 / 9)
def test_gammasimp():
R = Rational
# was part of test_combsimp_gamma() in test_combsimp.py
assert gammasimp(gamma(x)) == gamma(x)
assert gammasimp(gamma(x + 1) / x) == gamma(x)
assert gammasimp(gamma(x) / (x - 1)) == gamma(x - 1)
assert gammasimp(x * gamma(x)) == gamma(x + 1)
assert gammasimp((x + 1) * gamma(x + 1)) == gamma(x + 2)
assert gammasimp(gamma(x + y) * (x + y)) == gamma(x + y + 1)
assert gammasimp(x / gamma(x + 1)) == 1 / gamma(x)
assert gammasimp((x + 1)**2 / gamma(x + 2)) == (x + 1) / gamma(x + 1)
assert gammasimp(x*gamma(x) + gamma(x + 3)/(x + 2)) == \
(x + 2)*gamma(x + 1)
assert gammasimp(gamma(2 * x) * x) == gamma(2 * x + 1) / 2
assert gammasimp(gamma(2 * x) / (x - S.Half)) == 2 * gamma(2 * x - 1)
assert gammasimp(gamma(x) * gamma(1 - x)) == pi / sin(pi * x)
assert gammasimp(gamma(x) * gamma(-x)) == -pi / (x * sin(pi * x))
assert gammasimp(1/gamma(x + 3)/gamma(1 - x)) == \
sin(pi*x)/(pi*x*(x + 1)*(x + 2))
assert gammasimp(factorial(n + 2)) == gamma(n + 3)
assert gammasimp(binomial(n, k)) == \
gamma(n + 1)/(gamma(k + 1)*gamma(-k + n + 1))
assert powsimp(gammasimp(
gamma(x)*gamma(x + S.Half)*gamma(y)/gamma(x + y))) == \
2**(-2*x + 1)*sqrt(pi)*gamma(2*x)*gamma(y)/gamma(x + y)
assert gammasimp(1/gamma(x)/gamma(x - Rational(1, 3))/gamma(x + Rational(1, 3))) == \
3**(3*x - Rational(3, 2))/(2*pi*gamma(3*x - 1))
assert simplify(
gamma(S.Half + x / 2) * gamma(1 + x / 2) / gamma(1 + x) / sqrt(pi) *
2**x) == 1
assert gammasimp(gamma(Rational(-1, 4)) *
gamma(Rational(-3, 4))) == 16 * sqrt(2) * pi / 3
assert powsimp(gammasimp(gamma(2*x)/gamma(x))) == \
2**(2*x - 1)*gamma(x + S.Half)/sqrt(pi)
# issue 6792
e = (-gamma(k) * gamma(k + 2) + gamma(k + 1)**2) / gamma(k)**2
assert gammasimp(e) == -k
assert gammasimp(1 / e) == -1 / k
e = (gamma(x) + gamma(x + 1)) / gamma(x)
assert gammasimp(e) == x + 1
assert gammasimp(1 / e) == 1 / (x + 1)
e = (gamma(x) + gamma(x + 2)) * (gamma(x - 1) + gamma(x)) / gamma(x)
assert gammasimp(e) == (x**2 + x + 1) * gamma(x + 1) / (x - 1)
e = (-gamma(k) * gamma(k + 2) + gamma(k + 1)**2) / gamma(k)**2
assert gammasimp(e**2) == k**2
assert gammasimp(e**2 / gamma(k + 1)) == k / gamma(k)
a = R(1, 2) + R(1, 3)
b = a + R(1, 3)
assert gammasimp(gamma(2 * k) / gamma(k) * gamma(k + a) *
gamma(k + b)) == 3 * 2**(2 * k + 1) * 3**(
-3 * k - 2) * sqrt(pi) * gamma(3 * k + R(3, 2)) / 2
# issue 9699
assert gammasimp(
(x + 1) * factorial(x) / gamma(y)) == gamma(x + 2) / gamma(y)
assert gammasimp(rf(x + n, k) * binomial(n, k)).simplify() == Piecewise(
(gamma(n + 1) * gamma(k + n + x) /
(gamma(k + 1) * gamma(n + x) * gamma(-k + n + 1)), n > -x),
((-1)**k * gamma(n + 1) * gamma(-n - x + 1) /
(gamma(k + 1) * gamma(-k + n + 1) * gamma(-k - n - x + 1)), True))
A, B = symbols('A B', commutative=False)
assert gammasimp(e * B * A) == gammasimp(e) * B * A
# check iteration
assert gammasimp(gamma(2 * k) / gamma(k) *
gamma(-k - R(1, 2))) == (-2**(2 * k + 1) * sqrt(pi) /
(2 *
((2 * k + 1) * cos(pi * k))))
assert gammasimp(
gamma(k) * gamma(k + R(1, 3)) * gamma(k + R(2, 3)) /
gamma(k * R(3, 2))) == (3 * 2**(3 * k + 1) * 3**(-3 * k - S.Half) *
sqrt(pi) * gamma(k * R(3, 2) + S.Half) / 2)
# issue 6153
assert gammasimp(gamma(Rational(1, 4)) / gamma(Rational(5, 4))) == 4
# was part of test_combsimp() in test_combsimp.py
assert gammasimp(binomial(n + 2, k + S.Half)) == gamma(n + 3)/ \
(gamma(k + R(3, 2))*gamma(-k + n + R(5, 2)))
assert gammasimp(binomial(n + 2, k + 2.0)) == \
gamma(n + 3)/(gamma(k + 3.0)*gamma(-k + n + 1))
# issue 11548
assert gammasimp(binomial(0, x)) == sin(pi * x) / (pi * x)
e = gamma(n + Rational(1, 3)) * gamma(n + R(2, 3))
assert gammasimp(e) == e
assert gammasimp(gamma(4*n + S.Half)/gamma(2*n - R(3, 4))) == \
2**(4*n - R(5, 2))*(8*n - 3)*gamma(2*n + R(3, 4))/sqrt(pi)
i, m = symbols('i m', integer=True)
e = gamma(exp(i))
assert gammasimp(e) == e
e = gamma(m + 3)
assert gammasimp(e) == e
e = gamma(m + 1) / (gamma(i + 1) * gamma(-i + m + 1))
assert gammasimp(e) == e
p = symbols("p", integer=True, positive=True)
assert gammasimp(gamma(-p + 4)) == gamma(-p + 4)
def _eval_rewrite_as_hyper(self, z):
pf1 = z ** 2 / (2 * 3 ** (S(2) / 3) * gamma(S(2) / 3))
pf2 = 1 / (root(3, 3) * gamma(S(1) / 3))
return pf1 * hyper([], [S(5) / 3], z ** 3 / 9) - pf2 * hyper([], [S(1) / 3], z ** 3 / 9)
def test_sympy__functions__special__gamma_functions__gamma():
from sympy.functions.special.gamma_functions import gamma
assert _test_args(gamma(x))
def gauss_gen_laguerre(n, alpha, n_digits):
r"""
Computes the generalized Gauss-Laguerre quadrature [1]_ points and weights.
The generalized Gauss-Laguerre quadrature approximates the integral:
.. math::
\int_{0}^\infty x^{\alpha} e^{-x} f(x)\,dx \approx \sum_{i=1}^n w_i f(x_i)
The nodes `x_i` of an order `n` quadrature rule are the roots of `L^{\alpha}_n`
and the weights `w_i` are given by:
.. math::
w_i = \frac{\Gamma(\alpha+n)}{n \Gamma(n) L^{\alpha}_{n-1}(x_i) L^{\alpha+1}_{n-1}(x_i)}
Parameters
==========
n : the order of quadrature
alpha : the exponent of the singularity, `\alpha > -1`
n_digits : number of significant digits of the points and weights to return
Returns
=======
(x, w) : the ``x`` and ``w`` are lists of points and weights as Floats.
The points `x_i` and weights `w_i` are returned as ``(x, w)``
tuple of lists.
Examples
========
>>> from sympy import S
>>> from sympy.integrals.quadrature import gauss_gen_laguerre
>>> x, w = gauss_gen_laguerre(3, -S.Half, 5)
>>> x
[0.19016, 1.7845, 5.5253]
>>> w
[1.4493, 0.31413, 0.00906]
>>> x, w = gauss_gen_laguerre(4, 3*S.Half, 5)
>>> x
[0.97851, 2.9904, 6.3193, 11.712]
>>> w
[0.53087, 0.67721, 0.11895, 0.0023152]
See Also
========
gauss_legendre, gauss_laguerre, gauss_hermite, gauss_chebyshev_t, gauss_chebyshev_u, gauss_jacobi
References
==========
.. [1] http://en.wikipedia.org/wiki/Gauss%E2%80%93Laguerre_quadrature
.. [2] http://people.sc.fsu.edu/~jburkardt/cpp_src/gen_laguerre_rule/gen_laguerre_rule.html
"""
x = Dummy("x")
p = laguerre_poly(n, x, alpha=alpha, polys=True)
p1 = laguerre_poly(n-1, x, alpha=alpha, polys=True)
p2 = laguerre_poly(n-1, x, alpha=alpha+1, polys=True)
xi = []
w = []
for r in p.real_roots():
if isinstance(r, RootOf):
r = r.eval_rational(S(1)/10**(n_digits+2))
xi.append(r.n(n_digits))
w.append((gamma(alpha+n)/(n*gamma(n)*p1.subs(x, r)*p2.subs(x, r))).n(n_digits))
return xi, w
def gauss_jacobi(n, alpha, beta, n_digits):
r"""
Computes the Gauss-Jacobi quadrature [1]_ points and weights.
The Gauss-Jacobi quadrature of the first kind approximates the integral:
.. math::
\int_{-1}^1 (1-x)^\alpha (1+x)^\beta f(x)\,dx \approx
\sum_{i=1}^n w_i f(x_i)
The nodes `x_i` of an order `n` quadrature rule are the roots of
`P^{(\alpha,\beta)}_n` and the weights `w_i` are given by:
.. math::
w_i = -\frac{2n+\alpha+\beta+2}{n+\alpha+\beta+1}
\frac{\Gamma(n+\alpha+1)\Gamma(n+\beta+1)}
{\Gamma(n+\alpha+\beta+1)(n+1)!}
\frac{2^{\alpha+\beta}}{P'_n(x_i)
P^{(\alpha,\beta)}_{n+1}(x_i)}
Parameters
==========
n : the order of quadrature
alpha : the first parameter of the Jacobi Polynomial, `\alpha > -1`
beta : the second parameter of the Jacobi Polynomial, `\beta > -1`
n_digits : number of significant digits of the points and weights to return
Returns
=======
(x, w) : the ``x`` and ``w`` are lists of points and weights as Floats.
The points `x_i` and weights `w_i` are returned as ``(x, w)``
tuple of lists.
Examples
========
>>> from sympy import S
>>> from sympy.integrals.quadrature import gauss_jacobi
>>> x, w = gauss_jacobi(3, S.Half, -S.Half, 5)
>>> x
[-0.90097, -0.22252, 0.62349]
>>> w
[1.7063, 1.0973, 0.33795]
>>> x, w = gauss_jacobi(6, 1, 1, 5)
>>> x
[-0.87174, -0.5917, -0.2093, 0.2093, 0.5917, 0.87174]
>>> w
[0.050584, 0.22169, 0.39439, 0.39439, 0.22169, 0.050584]
See Also
========
gauss_legendre, gauss_laguerre, gauss_hermite, gauss_gen_laguerre, gauss_chebyshev_t, gauss_chebyshev_u, gauss_lobatto
References
==========
.. [1] https://en.wikipedia.org/wiki/Gauss%E2%80%93Jacobi_quadrature
.. [2] http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_rule/jacobi_rule.html
.. [3] http://people.sc.fsu.edu/~jburkardt/cpp_src/gegenbauer_rule/gegenbauer_rule.html
"""
x = Dummy("x")
p = jacobi_poly(n, alpha, beta, x, polys=True)
pd = p.diff(x)
pn = jacobi_poly(n + 1, alpha, beta, x, polys=True)
xi = []
w = []
for r in p.real_roots():
if isinstance(r, RootOf):
r = r.eval_rational(S(1) / 10**(n_digits + 2))
xi.append(r.n(n_digits))
w.append(
(-(2 * n + alpha + beta + 2) / (n + alpha + beta + S.One) *
(gamma(n + alpha + 1) * gamma(n + beta + 1)) /
(gamma(n + alpha + beta + S.One) * gamma(n + 2)) *
2**(alpha + beta) / (pd.subs(x, r) * pn.subs(x, r))).n(n_digits))
return xi, w
def test_ff_eval_apply():
x, y = symbols('x,y')
n, k = symbols('n k', integer=True)
m = Symbol('m', integer=True, nonnegative=True)
assert ff(nan, y) is nan
assert ff(x, nan) is nan
assert unchanged(ff, x, y)
assert ff(oo, 0) == 1
assert ff(-oo, 0) == 1
assert ff(oo, 6) is oo
assert ff(-oo, 7) is -oo
assert ff(-oo, 6) is oo
assert ff(oo, -6) is oo
assert ff(-oo, -7) is oo
assert ff(x, 0) == 1
assert ff(x, 1) == x
assert ff(x, 2) == x * (x - 1)
assert ff(x, 3) == x * (x - 1) * (x - 2)
assert ff(x, 5) == x * (x - 1) * (x - 2) * (x - 3) * (x - 4)
assert ff(x, -1) == 1 / (x + 1)
assert ff(x, -2) == 1 / ((x + 1) * (x + 2))
assert ff(x, -3) == 1 / ((x + 1) * (x + 2) * (x + 3))
assert ff(100, 100) == factorial(100)
assert ff(2 * x**2 - 5 * x,
2) == (2 * x**2 - 5 * x) * (2 * x**2 - 5 * x - 1)
assert isinstance(ff(2 * x**2 - 5 * x, 2), Mul)
assert ff(x**2 + 3 * x,
-2) == 1 / ((x**2 + 3 * x + 1) * (x**2 + 3 * x + 2))
assert ff(Poly(2 * x**2 - 5 * x, x),
2) == Poly(4 * x**4 - 28 * x**3 + 59 * x**2 - 35 * x, x)
assert isinstance(ff(Poly(2 * x**2 - 5 * x, x), 2), Poly)
raises(ValueError, lambda: ff(Poly(2 * x**2 - 5 * x, x, y), 2))
assert ff(Poly(x**2 + 3 * x, x),
-2) == 1 / (x**4 + 12 * x**3 + 49 * x**2 + 78 * x + 40)
raises(ValueError, lambda: ff(Poly(x**2 + 3 * x, x, y), -2))
assert ff(x, m).is_integer is None
assert ff(n, k).is_integer is None
assert ff(n, m).is_integer is True
assert ff(n, k + pi).is_integer is False
assert ff(n, m + pi).is_integer is False
assert ff(pi, m).is_integer is False
assert isinstance(ff(x, x), ff)
assert ff(n, n) == factorial(n)
def check(x, k, o, n):
a, b = Dummy(), Dummy()
r = lambda x, k: o(a, b).rewrite(n).subs({a: x, b: k})
for i in range(-5, 5):
for j in range(-5, 5):
assert o(i, j) == r(i, j), (o, n)
check(x, k, ff, rf)
check(x, k, ff, gamma)
check(n, k, ff, factorial)
check(x, k, ff, binomial)
check(x, y, ff, factorial)
check(x, y, ff, binomial)
assert ff(x, k).rewrite(rf) == rf(x - k + 1, k)
assert ff(x, k).rewrite(gamma) == Piecewise(
(gamma(x + 1) / gamma(-k + x + 1), x >= 0),
((-1)**k * gamma(k - x) / gamma(-x), True))
assert ff(5, k).rewrite(gamma) == 120 / gamma(6 - k)
assert ff(n, k).rewrite(factorial) == Piecewise(
(factorial(n) / factorial(-k + n), n >= 0),
((-1)**k * factorial(k - n - 1) / factorial(-n - 1), True))
assert ff(5, k).rewrite(factorial) == 120 / factorial(5 - k)
assert ff(x, k).rewrite(binomial) == factorial(k) * binomial(x, k)
assert ff(x, y).rewrite(factorial) == ff(x, y)
assert ff(x, y).rewrite(binomial) == ff(x, y)
import random
from mpmath import ff as mpmath_ff
for i in range(100):
x = -500 + 500 * random.random()
k = -500 + 500 * random.random()
a = mpmath_ff(x, k)
b = ff(x, k)
assert (abs(a - b) < abs(a) * 10**(-15))
def _eval_rewrite_as_gamma(self, n, piecewise=True, **kwargs):
from sympy.functions.special.gamma_functions import gamma
return gamma(n + 1)
def _eval_expand_func(self, **hints):
x, y = self.args
return gamma(x) * gamma(y) / gamma(x + y)
def _eval_rewrite_as_hyper(self, z):
pf1 = S.One / (root(3, 6) * gamma(S(2) / 3))
pf2 = z * root(3, 6) / gamma(S(1) / 3)
return pf1 * hyper([], [S(2) / 3], z**3 / 9) + pf2 * hyper(
[], [S(4) / 3], z**3 / 9)
def _eval_rewrite_as_zeta(self, s, **kwargs):
from sympy.functions.special.gamma_functions import gamma
return s*(s - 1)*gamma(s/2)*zeta(s)/(2*pi**(s/2))
def test_rf_eval_apply():
x, y = symbols('x,y')
n, k = symbols('n k', integer=True)
m = Symbol('m', integer=True, nonnegative=True)
assert rf(nan, y) is nan
assert rf(x, nan) is nan
assert unchanged(rf, x, y)
assert rf(oo, 0) == 1
assert rf(-oo, 0) == 1
assert rf(oo, 6) is oo
assert rf(-oo, 7) is -oo
assert rf(-oo, 6) is oo
assert rf(oo, -6) is oo
assert rf(-oo, -7) is oo
assert rf(-1, pi) == 0
assert rf(-5, 1 + I) == 0
assert unchanged(rf, -3, k)
assert unchanged(rf, x, Symbol('k', integer=False))
assert rf(-3, Symbol('k', integer=False)) == 0
assert rf(Symbol('x', negative=True, integer=True),
Symbol('k', integer=False)) == 0
assert rf(x, 0) == 1
assert rf(x, 1) == x
assert rf(x, 2) == x * (x + 1)
assert rf(x, 3) == x * (x + 1) * (x + 2)
assert rf(x, 5) == x * (x + 1) * (x + 2) * (x + 3) * (x + 4)
assert rf(x, -1) == 1 / (x - 1)
assert rf(x, -2) == 1 / ((x - 1) * (x - 2))
assert rf(x, -3) == 1 / ((x - 1) * (x - 2) * (x - 3))
assert rf(1, 100) == factorial(100)
assert rf(x**2 + 3 * x, 2) == (x**2 + 3 * x) * (x**2 + 3 * x + 1)
assert isinstance(rf(x**2 + 3 * x, 2), Mul)
assert rf(x**3 + x, -2) == 1 / ((x**3 + x - 1) * (x**3 + x - 2))
assert rf(Poly(x**2 + 3 * x, x),
2) == Poly(x**4 + 8 * x**3 + 19 * x**2 + 12 * x, x)
assert isinstance(rf(Poly(x**2 + 3 * x, x), 2), Poly)
raises(ValueError, lambda: rf(Poly(x**2 + 3 * x, x, y), 2))
assert rf(Poly(x**3 + x, x),
-2) == 1 / (x**6 - 9 * x**5 + 35 * x**4 - 75 * x**3 + 94 * x**2 -
66 * x + 20)
raises(ValueError, lambda: rf(Poly(x**3 + x, x, y), -2))
assert rf(x, m).is_integer is None
assert rf(n, k).is_integer is None
assert rf(n, m).is_integer is True
assert rf(n, k + pi).is_integer is False
assert rf(n, m + pi).is_integer is False
assert rf(pi, m).is_integer is False
def check(x, k, o, n):
a, b = Dummy(), Dummy()
r = lambda x, k: o(a, b).rewrite(n).subs({a: x, b: k})
for i in range(-5, 5):
for j in range(-5, 5):
assert o(i, j) == r(i, j), (o, n, i, j)
check(x, k, rf, ff)
check(x, k, rf, binomial)
check(n, k, rf, factorial)
check(x, y, rf, factorial)
check(x, y, rf, binomial)
assert rf(x, k).rewrite(ff) == ff(x + k - 1, k)
assert rf(x, k).rewrite(gamma) == Piecewise(
(gamma(k + x) / gamma(x), x > 0),
((-1)**k * gamma(1 - x) / gamma(-k - x + 1), True))
assert rf(5, k).rewrite(gamma) == gamma(k + 5) / 24
assert rf(x, k).rewrite(binomial) == factorial(k) * binomial(x + k - 1, k)
assert rf(n, k).rewrite(factorial) == Piecewise(
(factorial(k + n - 1) / factorial(n - 1), n > 0),
((-1)**k * factorial(-n) / factorial(-k - n), True))
assert rf(5, k).rewrite(factorial) == factorial(k + 4) / 24
assert rf(x, y).rewrite(factorial) == rf(x, y)
assert rf(x, y).rewrite(binomial) == rf(x, y)
import random
from mpmath import rf as mpmath_rf
for i in range(100):
x = -500 + 500 * random.random()
k = -500 + 500 * random.random()
assert (abs(mpmath_rf(x, k) - rf(x, k)) < 10**(-15))
def _eval_rewrite_as_hyper(self, z):
pf1 = S.One / (3 ** (S(2) / 3) * gamma(S(2) / 3))
pf2 = z / (root(3, 3) * gamma(S(1) / 3))
return pf1 * hyper([], [S(2) / 3], z ** 3 / 9) - pf2 * hyper([], [S(4) / 3], z ** 3 / 9)
def test_meijerint():
from sympy.core.function import expand
from sympy.core.symbol import symbols
from sympy.functions.elementary.complexes import arg
s, t, mu = symbols('s t mu', 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)
# 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:
assert 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 * (2 - erfc(mu / (2 * sigma)))
assert c == True
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)
assert meijerint_definite(sinc(x)**2, x, -oo, oo) == (pi, True)
# Test one of the extra conditions for 2 g-functinos
assert meijerint_definite(exp(-x) * sin(x), x, 0, oo) == (S.Half, 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')
from sympy.functions.elementary.complexes import re
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)),
(re(s) < 1) & (re(s) < S(1) / 2) &
(re(a) / 2 + re(b) / 2 + re(s) > 0)))
# 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, S.Half)/4).expand()
# Test hyperexpand bug.
from sympy.functions.special.gamma_functions import lowergamma
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 + S.Half,
alpha/2 + 1)), ((0, 0, S.Half), (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 - S.Half)*((-1)**s + 1)*gamma(s/2 + S.Half)/2
def _eval_rewrite_as_hyper(self, z, **kwargs):
pf1 = S.One / (3**(S(2) / 3) * gamma(S(2) / 3))
pf2 = z / (root(3, 3) * gamma(S(1) / 3))
return pf1 * hyper([], [S(2) / 3], z**3 / 9) - pf2 * hyper(
[], [S(4) / 3], z**3 / 9)
def pdf(self, *syms):
alpha = self.alpha
B = Mul.fromiter(map(gamma, alpha))/gamma(Add(*alpha))
return Mul.fromiter(sym**(a_k - 1) for a_k, sym in zip(alpha, syms))/B
def _eval_rewrite_as_hyper(self, z, **kwargs):
pf1 = z**2 / (2 * 3**(S(2) / 3) * gamma(S(2) / 3))
pf2 = 1 / (root(3, 3) * gamma(S(1) / 3))
return pf1 * hyper([], [S(5) / 3], z**3 / 9) - pf2 * hyper(
[], [S(1) / 3], z**3 / 9)
def _eval_rewrite_as_hyper(self, z):
pf1 = z ** 2 / (2 * root(3, 6) * gamma(S(2) / 3))
pf2 = root(3, 6) / gamma(S(1) / 3)
return pf1 * hyper([], [S(5) / 3], z ** 3 / 9) + pf2 * hyper([], [S(1) / 3], z ** 3 / 9)
def _eval_rewrite_as_gamma(self, n, piecewise=True, **kwargs):
from sympy.functions.elementary.miscellaneous import sqrt
from sympy.functions.elementary.piecewise import Piecewise
from sympy.functions.special.gamma_functions import gamma
return 2**(n / 2) * gamma(n / 2 + 1) * Piecewise(
(1, Eq(Mod(n, 2), 0)), (sqrt(2 / pi), Eq(Mod(n, 2), 1)))
