def t(fac, arg):
g = meijerg([a], [b], [c], [d], arg)*fac
subs = {a: randcplx()/10, b: randcplx()/10 + I,
c: randcplx(), d: randcplx()}
integral = meijerint_indefinite(g, x)
assert integral is not None
assert verify_numerically(g.subs(subs), integral.diff(x).subs(subs), x)
def test_hyper():
raises(TypeError, lambda: hyper(1, 2, z))
assert hyper((1, 2), (1, ), z) == hyper(Tuple(1, 2), Tuple(1), z)
h = hyper((1, 2), (3, 4, 5), z)
assert h.ap == Tuple(1, 2)
assert h.bq == Tuple(3, 4, 5)
assert h.argument == z
assert h.is_commutative is True
# just a few checks to make sure that all arguments go where they should
assert tn(hyper(Tuple(), Tuple(), z), exp(z), z)
assert tn(z * hyper((1, 1), Tuple(2), -z), log(1 + z), z)
# differentiation
h = hyper((randcplx(), randcplx(), randcplx()), (randcplx(), randcplx()),
z)
assert td(h, z)
a1, a2, b1, b2, b3 = symbols('a1:3, b1:4')
assert hyper((a1, a2), (b1, b2, b3), z).diff(z) == \
a1*a2/(b1*b2*b3) * hyper((a1 + 1, a2 + 1), (b1 + 1, b2 + 1, b3 + 1), z)
# differentiation wrt parameters is not supported
assert hyper([z], [], z).diff(z) == Derivative(hyper([z], [], z), z)
# hyper is unbranched wrt parameters
from sympy import polar_lift
assert hyper([polar_lift(z)], [polar_lift(k)], polar_lift(x)) == \
hyper([z], [k], polar_lift(x))
# hyper does not automatically evaluate anyway, but the test is to make
# sure that the evaluate keyword is accepted
assert hyper((1, 2), (1, ), z, evaluate=False).func is hyper
def test_P():
assert P(0, z, m) == F(z, m)
assert P(1, z, m) == F(z, m) + \
(sqrt(1 - m*sin(z)**2)*tan(z) - E(z, m))/(1 - m)
assert P(n, i * pi / 2, m) == i * P(n, m)
assert P(n, z, 0) == atanh(sqrt(n - 1) * tan(z)) / sqrt(n - 1)
assert P(n, z,
n) == F(z, n) - P(1, z, n) + tan(z) / sqrt(1 - n * sin(z)**2)
assert P(oo, z, m) == 0
assert P(-oo, z, m) == 0
assert P(n, z, oo) == 0
assert P(n, z, -oo) == 0
assert P(0, m) == K(m)
assert P(1, m) is zoo
assert P(n, 0) == pi / (2 * sqrt(1 - n))
assert P(2, 1) is -oo
assert P(-1, 1) is oo
assert P(n, n) == E(n) / (1 - n)
assert P(n, -z, m) == -P(n, z, m)
ni, mi = Symbol('n', real=False), Symbol('m', real=False)
assert P(ni, z, mi).conjugate() == \
P(ni.conjugate(), z.conjugate(), mi.conjugate())
nr, mr = Symbol('n', real=True, negative=True), \
Symbol('m', real=True, negative=True)
assert P(nr, z, mr).conjugate() == P(nr, z.conjugate(), mr)
assert P(n, m).conjugate() == P(n.conjugate(), m.conjugate())
assert P(n, z, m).diff(n) == (E(z, m) + (m - n) * F(z, m) / n +
(n**2 - m) * P(n, z, m) / n -
n * sqrt(1 - m * sin(z)**2) * sin(2 * z) /
(2 * (1 - n * sin(z)**2))) / (2 * (m - n) *
(n - 1))
assert P(n, z,
m).diff(z) == 1 / (sqrt(1 - m * sin(z)**2) * (1 - n * sin(z)**2))
assert P(
n, z,
m).diff(m) == (E(z, m) / (m - 1) + P(n, z, m) - m * sin(2 * z) /
(2 * (m - 1) * sqrt(1 - m * sin(z)**2))) / (2 * (n - m))
assert P(n,
m).diff(n) == (E(m) + (m - n) * K(m) / n +
(n**2 - m) * P(n, m) / n) / (2 * (m - n) * (n - 1))
assert P(n, m).diff(m) == (E(m) / (m - 1) + P(n, m)) / (2 * (n - m))
rx, ry = randcplx(), randcplx()
assert td(P(n, rx, ry), n)
assert td(P(rx, z, ry), z)
assert td(P(rx, ry, m), m)
assert P(n, z, m).series(z) == z + z**3*(m/6 + n/3) + \
z**5*(3*m**2/40 + m*n/10 - m/30 + n**2/5 - n/15) + O(z**6)
assert P(n, z, m).rewrite(Integral).dummy_eq(
Integral(1 / ((1 - n * sin(t)**2) * sqrt(1 - m * sin(t)**2)),
(t, 0, z)))
assert P(n, m).rewrite(Integral).dummy_eq(
Integral(1 / ((1 - n * sin(t)**2) * sqrt(1 - m * sin(t)**2)),
(t, 0, pi / 2)))
def test_uppergamma():
from sympy import meijerg, exp_polar, I, expint
assert uppergamma(4, 0) == 6
assert uppergamma(x, y).diff(y) == -(y ** (x - 1)) * exp(-y)
assert td(uppergamma(randcplx(), y), y)
assert uppergamma(x, y).diff(x) == uppergamma(x, y) * log(y) + meijerg(
[], [1, 1], [0, 0, x], [], y
)
assert td(uppergamma(x, randcplx()), x)
p = Symbol("p", positive=True)
assert uppergamma(0, p) == -Ei(-p)
assert uppergamma(p, 0) == gamma(p)
assert uppergamma(S.Half, x) == sqrt(pi) * erfc(sqrt(x))
assert not uppergamma(S.Half - 3, x).has(uppergamma)
assert not uppergamma(S.Half + 3, x).has(uppergamma)
assert uppergamma(S.Half, x, evaluate=False).has(uppergamma)
assert tn(uppergamma(S.Half + 3, x, evaluate=False), uppergamma(S.Half + 3, x), x)
assert tn(uppergamma(S.Half - 3, x, evaluate=False), uppergamma(S.Half - 3, x), x)
assert unchanged(uppergamma, x, -oo)
assert unchanged(uppergamma, x, 0)
assert tn_branch(-3, uppergamma)
assert tn_branch(-4, uppergamma)
assert tn_branch(Rational(1, 3), uppergamma)
assert tn_branch(pi, uppergamma)
assert uppergamma(3, exp_polar(4 * pi * I) * x) == uppergamma(3, x)
assert uppergamma(y, exp_polar(5 * pi * I) * x) == exp(4 * I * pi * y) * uppergamma(
y, x * exp_polar(pi * I)
) + gamma(y) * (1 - exp(4 * pi * I * y))
assert (
uppergamma(-2, exp_polar(5 * pi * I) * x)
== uppergamma(-2, x * exp_polar(I * pi)) - 2 * pi * I
)
assert uppergamma(-2, x) == expint(3, x) / x ** 2
assert conjugate(uppergamma(x, y)) == uppergamma(conjugate(x), conjugate(y))
assert unchanged(conjugate, uppergamma(x, -oo))
assert uppergamma(x, y).rewrite(expint) == y ** x * expint(-x + 1, y)
assert uppergamma(x, y).rewrite(lowergamma) == gamma(x) - lowergamma(x, y)
assert uppergamma(
70, 6
) == 69035724522603011058660187038367026272747334489677105069435923032634389419656200387949342530805432320 * exp(
-6
)
assert (
uppergamma(S(77) / 2, 6) - uppergamma(S(77) / 2, 6, evaluate=False)
).evalf() < 1e-16
assert (
uppergamma(-S(77) / 2, 6) - uppergamma(-S(77) / 2, 6, evaluate=False)
).evalf() < 1e-16
def test_lowergamma():
from sympy import meijerg, exp_polar, I, expint
assert lowergamma(x, 0) == 0
assert lowergamma(x, y).diff(y) == y ** (x - 1) * exp(-y)
assert td(lowergamma(randcplx(), y), y)
assert td(lowergamma(x, randcplx()), x)
assert lowergamma(x, y).diff(x) == gamma(x) * digamma(x) - uppergamma(x, y) * log(
y
) - meijerg([], [1, 1], [0, 0, x], [], y)
assert lowergamma(S.Half, x) == sqrt(pi) * erf(sqrt(x))
assert not lowergamma(S.Half - 3, x).has(lowergamma)
assert not lowergamma(S.Half + 3, x).has(lowergamma)
assert lowergamma(S.Half, x, evaluate=False).has(lowergamma)
assert tn(lowergamma(S.Half + 3, x, evaluate=False), lowergamma(S.Half + 3, x), x)
assert tn(lowergamma(S.Half - 3, x, evaluate=False), lowergamma(S.Half - 3, x), x)
assert tn_branch(-3, lowergamma)
assert tn_branch(-4, lowergamma)
assert tn_branch(Rational(1, 3), lowergamma)
assert tn_branch(pi, lowergamma)
assert lowergamma(3, exp_polar(4 * pi * I) * x) == lowergamma(3, x)
assert lowergamma(y, exp_polar(5 * pi * I) * x) == exp(4 * I * pi * y) * lowergamma(
y, x * exp_polar(pi * I)
)
assert (
lowergamma(-2, exp_polar(5 * pi * I) * x)
== lowergamma(-2, x * exp_polar(I * pi)) + 2 * pi * I
)
assert conjugate(lowergamma(x, y)) == lowergamma(conjugate(x), conjugate(y))
assert conjugate(lowergamma(x, 0)) == 0
assert unchanged(conjugate, lowergamma(x, -oo))
assert lowergamma(x, y).rewrite(expint) == -(y ** x) * expint(-x + 1, y) + gamma(x)
k = Symbol("k", integer=True)
assert lowergamma(k, y).rewrite(expint) == -(y ** k) * expint(-k + 1, y) + gamma(k)
k = Symbol("k", integer=True, positive=False)
assert lowergamma(k, y).rewrite(expint) == lowergamma(k, y)
assert lowergamma(x, y).rewrite(uppergamma) == gamma(x) - uppergamma(x, y)
assert lowergamma(70, 6) == factorial(
69
) - 69035724522603011058660187038367026272747334489677105069435923032634389419656200387949342530805432320 * exp(
-6
)
assert (
lowergamma(S(77) / 2, 6) - lowergamma(S(77) / 2, 6, evaluate=False)
).evalf() < 1e-16
assert (
lowergamma(-S(77) / 2, 6) - lowergamma(-S(77) / 2, 6, evaluate=False)
).evalf() < 1e-16
def test_inflate():
subs = {a: randcplx()/10, b: randcplx()/10 + I, c: randcplx(),
d: randcplx(), y: randcplx()/10}
def t(a, b, arg, n):
from sympy import Mul
m1 = meijerg(a, b, arg)
m2 = Mul(*_inflate_g(m1, n))
# NOTE: (the random number)**9 must still be on the principal sheet.
# Thus make b&d small to create random numbers of small imaginary part.
return verify_numerically(m1.subs(subs), m2.subs(subs), x, b=0.1, d=-0.1)
assert t([[a], [b]], [[c], [d]], x, 3)
assert t([[a, y], [b]], [[c], [d]], x, 3)
assert t([[a], [b]], [[c, y], [d]], 2*x**3, 3)
def test_meijerg_eval():
from sympy import besseli, exp_polar
from sympy.abc import l
a = randcplx()
arg = x * exp_polar(k * pi * I)
expr1 = pi * meijerg([[], [(a + 1) / 2]], [[a / 2], [-a / 2, (a + 1) / 2]],
arg**2 / 4)
expr2 = besseli(a, arg)
# Test that the two expressions agree for all arguments.
for x_ in [0.5, 1.5]:
for k_ in [0.0, 0.1, 0.3, 0.5, 0.8, 1, 5.751, 15.3]:
assert abs((expr1 - expr2).n(subs={x: x_, k: k_})) < 1e-10
assert abs((expr1 - expr2).n(subs={x: x_, k: -k_})) < 1e-10
# Test continuity independently
eps = 1e-13
expr2 = expr1.subs(k, l)
for x_ in [0.5, 1.5]:
for k_ in [0.5, Rational(1, 3), 0.25, 0.75, Rational(2, 3), 1.0, 1.5]:
assert abs((expr1 - expr2).n(subs={
x: x_,
k: k_ + eps,
l: k_ - eps
})) < 1e-10
assert abs((expr1 - expr2).n(subs={
x: x_,
k: -k_ + eps,
l: -k_ - eps
})) < 1e-10
expr = (meijerg(((0.5,), ()), ((0.5, 0, 0.5), ()), exp_polar(-I*pi)/4)
+ meijerg(((0.5,), ()), ((0.5, 0, 0.5), ()), exp_polar(I*pi)/4)) \
/(2*sqrt(pi))
assert (expr - pi / exp(1)).n(chop=True) == 0
def test_F():
assert F(z, 0) == z
assert F(0, m) == 0
assert F(pi*i/2, m) == i*K(m)
assert F(z, oo) == 0
assert F(z, -oo) == 0
assert F(-z, m) == -F(z, m)
assert F(z, m).diff(z) == 1/sqrt(1 - m*sin(z)**2)
assert F(z, m).diff(m) == E(z, m)/(2*m*(1 - m)) - F(z, m)/(2*m) - \
sin(2*z)/(4*(1 - m)*sqrt(1 - m*sin(z)**2))
r = randcplx()
assert td(F(z, r), z)
assert td(F(r, m), m)
mi = Symbol('m', real=False)
assert F(z, mi).conjugate() == F(z.conjugate(), mi.conjugate())
mr = Symbol('m', real=True, negative=True)
assert F(z, mr).conjugate() == F(z.conjugate(), mr)
assert F(z, m).series(z) == \
z + z**5*(3*m**2/40 - m/30) + m*z**3/6 + O(z**6)
assert F(z, m).rewrite(Integral).dummy_eq(
Integral(1/sqrt(1 - m*sin(t)**2), (t, 0, z)))
def test_E():
assert E(z, 0) == z
assert E(0, m) == 0
assert E(i * pi / 2, m) == i * E(m)
assert E(z, oo) is zoo
assert E(z, -oo) is zoo
assert E(0) == pi / 2
assert E(1) == 1
assert E(oo) == I * oo
assert E(-oo) is oo
assert E(zoo) is zoo
assert E(-z, m) == -E(z, m)
assert E(z, m).diff(z) == sqrt(1 - m * sin(z) ** 2)
assert E(z, m).diff(m) == (E(z, m) - F(z, m)) / (2 * m)
assert E(z).diff(z) == (E(z) - K(z)) / (2 * z)
r = randcplx()
assert td(E(r, m), m)
assert td(E(z, r), z)
assert td(E(z), z)
mi = Symbol("m", real=False)
assert E(z, mi).conjugate() == E(z.conjugate(), mi.conjugate())
assert E(mi).conjugate() == E(mi.conjugate())
mr = Symbol("m", real=True, negative=True)
assert E(z, mr).conjugate() == E(z.conjugate(), mr)
assert E(mr).conjugate() == E(mr)
assert E(z).rewrite(hyper) == (pi / 2) * hyper(
(Rational(-1, 2), S.Half), (S.One,), z
)
assert tn(E(z), (pi / 2) * hyper((Rational(-1, 2), S.Half), (S.One,), z))
assert (
E(z).rewrite(meijerg)
== -meijerg(((S.Half, Rational(3, 2)), []), ((S.Zero,), (S.Zero,)), -z) / 4
)
assert tn(
E(z), -meijerg(((S.Half, Rational(3, 2)), []), ((S.Zero,), (S.Zero,)), -z) / 4
)
assert E(z, m).series(z) == z + z ** 5 * (
-(m ** 2) / 40 + m / 30
) - m * z ** 3 / 6 + O(z ** 6)
assert E(z).series(
z
) == pi / 2 - pi * z / 8 - 3 * pi * z ** 2 / 128 - 5 * pi * z ** 3 / 512 - 175 * pi * z ** 4 / 32768 - 441 * pi * z ** 5 / 131072 + O(
z ** 6
)
assert (
E(z, m)
.rewrite(Integral)
.dummy_eq(Integral(sqrt(1 - m * sin(t) ** 2), (t, 0, z)))
)
assert (
E(m)
.rewrite(Integral)
.dummy_eq(Integral(sqrt(1 - m * sin(t) ** 2), (t, 0, pi / 2)))
)
def test_slow_expand():
def check(eq, ans):
return tn(eq, ans) and eq == ans
rn = randcplx(a=1, b=0, d=0, c=2)
for besselx in [besselj, bessely, besseli, besselk]:
ri = S(2 * randint(-11, 10) + 1) / 2 # half integer in [-21/2, 21/2]
assert tn(besselsimp(besselx(ri, z)), besselx(ri, z))
assert check(expand_func(besseli(rn, x)),
besseli(rn - 2, x) - 2 * (rn - 1) * besseli(rn - 1, x) / x)
assert check(expand_func(besseli(-rn, x)),
besseli(-rn + 2, x) + 2 * (-rn + 1) * besseli(-rn + 1, x) / x)
assert check(expand_func(besselj(rn, x)),
-besselj(rn - 2, x) + 2 * (rn - 1) * besselj(rn - 1, x) / x)
assert check(
expand_func(besselj(-rn, x)),
-besselj(-rn + 2, x) + 2 * (-rn + 1) * besselj(-rn + 1, x) / x)
assert check(expand_func(besselk(rn, x)),
besselk(rn - 2, x) + 2 * (rn - 1) * besselk(rn - 1, x) / x)
assert check(expand_func(besselk(-rn, x)),
besselk(-rn + 2, x) - 2 * (-rn + 1) * besselk(-rn + 1, x) / x)
assert check(expand_func(bessely(rn, x)),
-bessely(rn - 2, x) + 2 * (rn - 1) * bessely(rn - 1, x) / x)
assert check(
expand_func(bessely(-rn, x)),
-bessely(-rn + 2, x) + 2 * (-rn + 1) * bessely(-rn + 1, x) / x)
def test_conjugate():
n = Symbol('n')
z = Symbol('z', extended_real=False)
x = Symbol('x', extended_real=True)
y = Symbol('y', real=True, positive=True)
t = Symbol('t', negative=True)
for f in [besseli, besselj, besselk, bessely, hankel1, hankel2]:
assert f(n, -1).conjugate() != f(conjugate(n), -1)
assert f(n, x).conjugate() != f(conjugate(n), x)
assert f(n, t).conjugate() != f(conjugate(n), t)
rz = randcplx(b=0.5)
for f in [besseli, besselj, besselk, bessely]:
assert f(n, 1 + I).conjugate() == f(conjugate(n), 1 - I)
assert f(n, 0).conjugate() == f(conjugate(n), 0)
assert f(n, 1).conjugate() == f(conjugate(n), 1)
assert f(n, z).conjugate() == f(conjugate(n), conjugate(z))
assert f(n, y).conjugate() == f(conjugate(n), y)
assert tn(f(n, rz).conjugate(), f(conjugate(n), conjugate(rz)))
assert hankel1(n, 1 + I).conjugate() == hankel2(conjugate(n), 1 - I)
assert hankel1(n, 0).conjugate() == hankel2(conjugate(n), 0)
assert hankel1(n, 1).conjugate() == hankel2(conjugate(n), 1)
assert hankel1(n, y).conjugate() == hankel2(conjugate(n), y)
assert hankel1(n, z).conjugate() == hankel2(conjugate(n), conjugate(z))
assert tn(hankel1(n, rz).conjugate(), hankel2(conjugate(n), conjugate(rz)))
assert hankel2(n, 1 + I).conjugate() == hankel1(conjugate(n), 1 - I)
assert hankel2(n, 0).conjugate() == hankel1(conjugate(n), 0)
assert hankel2(n, 1).conjugate() == hankel1(conjugate(n), 1)
assert hankel2(n, y).conjugate() == hankel1(conjugate(n), y)
assert hankel2(n, z).conjugate() == hankel1(conjugate(n), conjugate(z))
assert tn(hankel2(n, rz).conjugate(), hankel1(conjugate(n), conjugate(rz)))
def test_rewrite():
assert besselj(n, z).rewrite(jn) == sqrt(2 * z / pi) * jn(n - S.Half, z)
assert bessely(n, z).rewrite(yn) == sqrt(2 * z / pi) * yn(n - S.Half, z)
assert besseli(n, z).rewrite(besselj) == \
exp(-I*n*pi/2)*besselj(n, polar_lift(I)*z)
assert besselj(n, z).rewrite(besseli) == \
exp(I*n*pi/2)*besseli(n, polar_lift(-I)*z)
nu = randcplx()
assert tn(besselj(nu, z), besselj(nu, z).rewrite(besseli), z)
assert tn(besselj(nu, z), besselj(nu, z).rewrite(bessely), z)
assert tn(besseli(nu, z), besseli(nu, z).rewrite(besselj), z)
assert tn(besseli(nu, z), besseli(nu, z).rewrite(bessely), z)
assert tn(bessely(nu, z), bessely(nu, z).rewrite(besselj), z)
assert tn(bessely(nu, z), bessely(nu, z).rewrite(besseli), z)
assert tn(besselk(nu, z), besselk(nu, z).rewrite(besselj), z)
assert tn(besselk(nu, z), besselk(nu, z).rewrite(besseli), z)
assert tn(besselk(nu, z), besselk(nu, z).rewrite(bessely), z)
# check that a rewrite was triggered, when the order is set to a generic
# symbol 'nu'
assert yn(nu, z) != yn(nu, z).rewrite(jn)
assert hn1(nu, z) != hn1(nu, z).rewrite(jn)
assert hn2(nu, z) != hn2(nu, z).rewrite(jn)
assert jn(nu, z) != jn(nu, z).rewrite(yn)
assert hn1(nu, z) != hn1(nu, z).rewrite(yn)
assert hn2(nu, z) != hn2(nu, z).rewrite(yn)
# rewriting spherical bessel functions (SBFs) w.r.t. besselj, bessely is
# not allowed if a generic symbol 'nu' is used as the order of the SBFs
# to avoid inconsistencies (the order of bessel[jy] is allowed to be
# complex-valued, whereas SBFs are defined only for integer orders)
order = nu
for f in (besselj, bessely):
assert hn1(order, z) == hn1(order, z).rewrite(f)
assert hn2(order, z) == hn2(order, z).rewrite(f)
assert jn(order, z).rewrite(besselj) == sqrt(2) * sqrt(pi) * sqrt(
1 / z) * besselj(order + S.Half, z) / 2
assert jn(order,
z).rewrite(bessely) == (-1)**nu * sqrt(2) * sqrt(pi) * sqrt(
1 / z) * bessely(-order - S.Half, z) / 2
# for integral orders rewriting SBFs w.r.t bessel[jy] is allowed
N = Symbol('n', integer=True)
ri = randint(-11, 10)
for order in (ri, N):
for f in (besselj, bessely):
assert yn(order, z) != yn(order, z).rewrite(f)
assert jn(order, z) != jn(order, z).rewrite(f)
assert hn1(order, z) != hn1(order, z).rewrite(f)
assert hn2(order, z) != hn2(order, z).rewrite(f)
for func, refunc in product((yn, jn, hn1, hn2),
(jn, yn, besselj, bessely)):
assert tn(func(ri, z), func(ri, z).rewrite(refunc), z)
def test_expand_func():
# evaluation at 1 of Gauss' hypergeometric function:
from sympy.abc import a, b, c
from sympy import expand_func
a1, b1, c1 = randcplx(), randcplx(), randcplx() + 5
assert expand_func(hyper([a, b], [c], 1)) == \
gamma(c)*gamma(-a - b + c)/(gamma(-a + c)*gamma(-b + c))
assert abs(
expand_func(hyper([a1, b1], [c1], 1)).n() -
hyper([a1, b1], [c1], 1).n()) < 1e-10
# hyperexpand wrapper for hyper:
assert expand_func(hyper([], [], z)) == exp(z)
assert expand_func(hyper([1, 2, 3], [], z)) == hyper([1, 2, 3], [], z)
assert expand_func(meijerg([[1, 1], []], [[1], [0]], z)) == log(z + 1)
assert expand_func(meijerg([[1, 1], []], [[], []], z)) == \
meijerg([[1, 1], []], [[], []], z)
def test_derivatives():
from sympy import Derivative
assert zeta(x, a).diff(x) == Derivative(zeta(x, a), x)
assert zeta(x, a).diff(a) == -x * zeta(x + 1, a)
assert lerchphi(
z, s, a).diff(z) == (lerchphi(z, s - 1, a) - a * lerchphi(z, s, a)) / z
assert lerchphi(z, s, a).diff(a) == -s * lerchphi(z, s + 1, a)
assert polylog(s, z).diff(z) == polylog(s - 1, z) / z
b = randcplx()
c = randcplx()
assert td(zeta(b, x), x)
assert td(polylog(b, z), z)
assert td(lerchphi(c, b, x), x)
assert td(lerchphi(x, b, c), x)
raises(ArgumentIndexError, lambda: lerchphi(c, b, x).fdiff(2))
raises(ArgumentIndexError, lambda: lerchphi(c, b, x).fdiff(4))
raises(ArgumentIndexError, lambda: polylog(b, z).fdiff(1))
raises(ArgumentIndexError, lambda: polylog(b, z).fdiff(3))
def myexpand(func, target):
expanded = expand_func(func)
if target is not None:
return expanded == target
if expanded == func: # it didn't expand
return False
# check to see that the expanded and original evaluate to the same value
subs = {}
for a in func.free_symbols:
subs[a] = randcplx()
return abs(func.subs(subs).n()
- expanded.replace(exp_polar, exp).subs(subs).n()) < 1e-10
def test_meijerg_derivative():
assert meijerg([], [1, 1], [0, 0, x], [], z).diff(x) == \
log(z)*meijerg([], [1, 1], [0, 0, x], [], z) \
+ 2*meijerg([], [1, 1, 1], [0, 0, x, 0], [], z)
y = randcplx()
a = 5 # mpmath chokes with non-real numbers, and Mod1 with floats
assert td(meijerg([x], [], [], [], y), x)
assert td(meijerg([x**2], [], [], [], y), x)
assert td(meijerg([], [x], [], [], y), x)
assert td(meijerg([], [], [x], [], y), x)
assert td(meijerg([], [], [], [x], y), x)
assert td(meijerg([x], [a], [a + 1], [], y), x)
assert td(meijerg([x], [a + 1], [a], [], y), x)
assert td(meijerg([x, a], [], [], [a + 1], y), x)
assert td(meijerg([x, a + 1], [], [], [a], y), x)
b = Rational(3, 2)
assert td(meijerg([a + 2], [b], [b - 3, x], [a], y), x)
def test_conjugate():
from sympy import conjugate, I, Symbol
n = Symbol("n")
z = Symbol("z", extended_real=False)
x = Symbol("x", extended_real=True)
y = Symbol("y", real=True, positive=True)
t = Symbol("t", negative=True)
for f in [besseli, besselj, besselk, bessely, hankel1, hankel2]:
assert f(n, -1).conjugate() != f(conjugate(n), -1)
assert f(n, x).conjugate() != f(conjugate(n), x)
assert f(n, t).conjugate() != f(conjugate(n), t)
rz = randcplx(b=0.5)
for f in [besseli, besselj, besselk, bessely]:
assert f(n, 1 + I).conjugate() == f(conjugate(n), 1 - I)
assert f(n, 0).conjugate() == f(conjugate(n), 0)
assert f(n, 1).conjugate() == f(conjugate(n), 1)
assert f(n, z).conjugate() == f(conjugate(n), conjugate(z))
assert f(n, y).conjugate() == f(conjugate(n), y)
assert tn(f(n, rz).conjugate(), f(conjugate(n), conjugate(rz)))
assert hankel1(n, 1 + I).conjugate() == hankel2(conjugate(n), 1 - I)
assert hankel1(n, 0).conjugate() == hankel2(conjugate(n), 0)
assert hankel1(n, 1).conjugate() == hankel2(conjugate(n), 1)
assert hankel1(n, y).conjugate() == hankel2(conjugate(n), y)
assert hankel1(n, z).conjugate() == hankel2(conjugate(n), conjugate(z))
assert tn(hankel1(n, rz).conjugate(), hankel2(conjugate(n), conjugate(rz)))
assert hankel2(n, 1 + I).conjugate() == hankel1(conjugate(n), 1 - I)
assert hankel2(n, 0).conjugate() == hankel1(conjugate(n), 0)
assert hankel2(n, 1).conjugate() == hankel1(conjugate(n), 1)
assert hankel2(n, y).conjugate() == hankel1(conjugate(n), y)
assert hankel2(n, z).conjugate() == hankel1(conjugate(n), conjugate(z))
assert tn(hankel2(n, rz).conjugate(), hankel1(conjugate(n), conjugate(rz)))
def test_bessel_rand():
for f in [besselj, bessely, besseli, besselk, hankel1, hankel2]:
assert td(f(randcplx(), z), z)
for f in [jn, yn, hn1, hn2]:
assert td(f(randint(-10, 10), z), z)
def test_expand():
from sympy import besselsimp, Symbol, exp, exp_polar, I
assert expand_func(besselj(
S.Half, z).rewrite(jn)) == sqrt(2) * sin(z) / (sqrt(pi) * sqrt(z))
assert expand_func(bessely(
S.Half, z).rewrite(yn)) == -sqrt(2) * cos(z) / (sqrt(pi) * sqrt(z))
# XXX: teach sin/cos to work around arguments like
# x*exp_polar(I*pi*n/2). Then change besselsimp -> expand_func
assert besselsimp(besselj(S.Half,
z)) == sqrt(2) * sin(z) / (sqrt(pi) * sqrt(z))
assert besselsimp(besselj(Rational(-1, 2),
z)) == sqrt(2) * cos(z) / (sqrt(pi) * sqrt(z))
assert besselsimp(besselj(Rational(
5, 2), z)) == -sqrt(2) * (z**2 * sin(z) + 3 * z * cos(z) -
3 * sin(z)) / (sqrt(pi) * z**Rational(5, 2))
assert besselsimp(besselj(Rational(
-5, 2), z)) == -sqrt(2) * (z**2 * cos(z) - 3 * z * sin(z) -
3 * cos(z)) / (sqrt(pi) * z**Rational(5, 2))
assert besselsimp(bessely(S.Half,
z)) == -(sqrt(2) * cos(z)) / (sqrt(pi) * sqrt(z))
assert besselsimp(bessely(Rational(-1, 2),
z)) == sqrt(2) * sin(z) / (sqrt(pi) * sqrt(z))
assert besselsimp(bessely(Rational(
5, 2), z)) == sqrt(2) * (z**2 * cos(z) - 3 * z * sin(z) -
3 * cos(z)) / (sqrt(pi) * z**Rational(5, 2))
assert besselsimp(bessely(Rational(
-5, 2), z)) == -sqrt(2) * (z**2 * sin(z) + 3 * z * cos(z) -
3 * sin(z)) / (sqrt(pi) * z**Rational(5, 2))
assert besselsimp(besseli(S.Half,
z)) == sqrt(2) * sinh(z) / (sqrt(pi) * sqrt(z))
assert besselsimp(besseli(Rational(-1, 2),
z)) == sqrt(2) * cosh(z) / (sqrt(pi) * sqrt(z))
assert besselsimp(besseli(Rational(
5, 2), z)) == sqrt(2) * (z**2 * sinh(z) - 3 * z * cosh(z) +
3 * sinh(z)) / (sqrt(pi) * z**Rational(5, 2))
assert besselsimp(besseli(Rational(
-5, 2), z)) == sqrt(2) * (z**2 * cosh(z) - 3 * z * sinh(z) +
3 * cosh(z)) / (sqrt(pi) * z**Rational(5, 2))
assert (besselsimp(besselk(S.Half, z)) == besselsimp(
besselk(Rational(-1, 2), z)) == sqrt(pi) * exp(-z) /
(sqrt(2) * sqrt(z)))
assert (besselsimp(besselk(Rational(5, 2), z)) == besselsimp(
besselk(Rational(-5, 2), z)) == sqrt(2) * sqrt(pi) *
(z**2 + 3 * z + 3) * exp(-z) / (2 * z**Rational(5, 2)))
def check(eq, ans):
return tn(eq, ans) and eq == ans
rn = randcplx(a=1, b=0, d=0, c=2)
for besselx in [besselj, bessely, besseli, besselk]:
ri = S(2 * randint(-11, 10) + 1) / 2 # half integer in [-21/2, 21/2]
assert tn(besselsimp(besselx(ri, z)), besselx(ri, z))
assert check(
expand_func(besseli(rn, x)),
besseli(rn - 2, x) - 2 * (rn - 1) * besseli(rn - 1, x) / x,
)
assert check(
expand_func(besseli(-rn, x)),
besseli(-rn + 2, x) + 2 * (-rn + 1) * besseli(-rn + 1, x) / x,
)
assert check(
expand_func(besselj(rn, x)),
-besselj(rn - 2, x) + 2 * (rn - 1) * besselj(rn - 1, x) / x,
)
assert check(
expand_func(besselj(-rn, x)),
-besselj(-rn + 2, x) + 2 * (-rn + 1) * besselj(-rn + 1, x) / x,
)
assert check(
expand_func(besselk(rn, x)),
besselk(rn - 2, x) + 2 * (rn - 1) * besselk(rn - 1, x) / x,
)
assert check(
expand_func(besselk(-rn, x)),
besselk(-rn + 2, x) - 2 * (-rn + 1) * besselk(-rn + 1, x) / x,
)
assert check(
expand_func(bessely(rn, x)),
-bessely(rn - 2, x) + 2 * (rn - 1) * bessely(rn - 1, x) / x,
)
assert check(
expand_func(bessely(-rn, x)),
-bessely(-rn + 2, x) + 2 * (-rn + 1) * bessely(-rn + 1, x) / x,
)
n = Symbol("n", integer=True, positive=True)
assert (expand_func(besseli(n + 2, z)) == besseli(n, z) + (-2 * n - 2) *
(-2 * n * besseli(n, z) / z + besseli(n - 1, z)) / z)
assert (expand_func(besselj(n + 2, z)) == -besselj(n, z) + (2 * n + 2) *
(2 * n * besselj(n, z) / z - besselj(n - 1, z)) / z)
assert (expand_func(besselk(n + 2, z)) == besselk(n, z) + (2 * n + 2) *
(2 * n * besselk(n, z) / z + besselk(n - 1, z)) / z)
assert (expand_func(bessely(n + 2, z)) == -bessely(n, z) + (2 * n + 2) *
(2 * n * bessely(n, z) / z - bessely(n - 1, z)) / z)
assert expand_func(besseli(
n + S.Half,
z).rewrite(jn)) == (sqrt(2) * sqrt(z) * exp(-I * pi *
(n + S.Half) / 2) *
exp_polar(I * pi / 4) *
jn(n, z * exp_polar(I * pi / 2)) / sqrt(pi))
assert expand_func(besselj(
n + S.Half, z).rewrite(jn)) == sqrt(2) * sqrt(z) * jn(n, z) / sqrt(pi)
r = Symbol("r", real=True)
p = Symbol("p", positive=True)
i = Symbol("i", integer=True)
for besselx in [besselj, bessely, besseli, besselk]:
assert besselx(i, p).is_extended_real is True
assert besselx(i, x).is_extended_real is None
assert besselx(x, z).is_extended_real is None
for besselx in [besselj, besseli]:
assert besselx(i, r).is_extended_real is True
for besselx in [bessely, besselk]:
assert besselx(i, r).is_extended_real is None
def test_meijer():
raises(TypeError, lambda: meijerg(1, z))
raises(TypeError, lambda: meijerg(((1, ), (2, )), (3, ), (4, ), z))
assert meijerg(((1, 2), (3,)), ((4,), (5,)), z) == \
meijerg(Tuple(1, 2), Tuple(3), Tuple(4), Tuple(5), z)
g = meijerg((1, 2), (3, 4, 5), (6, 7, 8, 9), (10, 11, 12, 13, 14), z)
assert g.an == Tuple(1, 2)
assert g.ap == Tuple(1, 2, 3, 4, 5)
assert g.aother == Tuple(3, 4, 5)
assert g.bm == Tuple(6, 7, 8, 9)
assert g.bq == Tuple(6, 7, 8, 9, 10, 11, 12, 13, 14)
assert g.bother == Tuple(10, 11, 12, 13, 14)
assert g.argument == z
assert g.nu == 75
assert g.delta == -1
assert g.is_commutative is True
assert g.is_number is False
#issue 13071
assert meijerg([[], []], [[S.Half], [0]], 1).is_number is True
assert meijerg([1, 2], [3], [4], [5], z).delta == S.Half
# just a few checks to make sure that all arguments go where they should
assert tn(meijerg(Tuple(), Tuple(), Tuple(0), Tuple(), -z), exp(z), z)
assert tn(
sqrt(pi) *
meijerg(Tuple(), Tuple(), Tuple(0), Tuple(S.Half), z**2 / 4), cos(z),
z)
assert tn(meijerg(Tuple(1, 1), Tuple(), Tuple(1), Tuple(0), z), log(1 + z),
z)
# test exceptions
raises(ValueError, lambda: meijerg(((3, 1), (2, )), ((oo, ), (2, 0)), x))
raises(ValueError, lambda: meijerg(((3, 1), (2, )), ((1, ), (2, 0)), x))
# differentiation
g = meijerg((randcplx(), ), (randcplx() + 2 * I, ), Tuple(),
(randcplx(), randcplx()), z)
assert td(g, z)
g = meijerg(Tuple(), (randcplx(), ), Tuple(), (randcplx(), randcplx()), z)
assert td(g, z)
g = meijerg(Tuple(), Tuple(), Tuple(randcplx()),
Tuple(randcplx(), randcplx()), z)
assert td(g, z)
a1, a2, b1, b2, c1, c2, d1, d2 = symbols('a1:3, b1:3, c1:3, d1:3')
assert meijerg((a1, a2), (b1, b2), (c1, c2), (d1, d2), z).diff(z) == \
(meijerg((a1 - 1, a2), (b1, b2), (c1, c2), (d1, d2), z)
+ (a1 - 1)*meijerg((a1, a2), (b1, b2), (c1, c2), (d1, d2), z))/z
assert meijerg([z, z], [], [], [], z).diff(z) == \
Derivative(meijerg([z, z], [], [], [], z), z)
# meijerg is unbranched wrt parameters
from sympy import polar_lift as pl
assert meijerg([pl(a1)], [pl(a2)], [pl(b1)], [pl(b2)], pl(z)) == \
meijerg([a1], [a2], [b1], [b2], pl(z))
# integrand
from sympy.abc import a, b, c, d, s
assert meijerg([a], [b], [c], [d], z).integrand(s) == \
z**s*gamma(c - s)*gamma(-a + s + 1)/(gamma(b - s)*gamma(-d + s + 1))