def test_issue_7173():
assert laplace_transform(sinh(a*x)*cosh(a*x), x, s) == \
(a/(s**2 - 4*a**2), 0,
And(Or(Abs(periodic_argument(exp_polar(I*pi)*polar_lift(a), oo)) <
pi/2, Abs(periodic_argument(exp_polar(I*pi)*polar_lift(a), oo)) <=
pi/2), Or(Abs(periodic_argument(a, oo)) < pi/2,
Abs(periodic_argument(a, oo)) <= pi/2)))
def test_meijerg_eval():
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).evalf(subs={x: x_, k: k_}, strict=False)) < 1e-10
assert abs((expr1 - expr2).evalf(subs={x: x_, k: -k_}, strict=False)) < 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).evalf(
subs={x: x_, k: k_ + eps, l: k_ - eps})) < 1e-10
assert abs((expr1 - expr2).evalf(
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)).evalf(chop=True) == 0
def t(func, hyp, z):
""" Test that func is a valid representation of hyp. """
# First test that func agrees with hyp for small z
if not tn(func.rewrite('nonrepsmall'), hyp, z,
a=Rational(-1, 2), b=Rational(-1, 2), c=Rational(1, 2), d=Rational(1, 2)):
return False
# Next check that the two small representations agree.
if not tn(
func.rewrite('nonrepsmall').subs({z: exp_polar(I*pi)*z}).replace(exp_polar, exp),
func.subs({z: exp_polar(I*pi)*z}).rewrite('nonrepsmall'),
z, a=Rational(-1, 2), b=Rational(-1, 2), c=Rational(1, 2), d=Rational(1, 2)):
return False
# Next check continuity along exp_polar(I*pi)*t
expr = func.subs({z: exp_polar(I*pi)*z}).rewrite('nonrep')
if abs(expr.subs({z: 1 + 1e-15}) - expr.subs({z: 1 - 1e-15})).evalf(strict=False) > 1e-10:
return False
# Finally check continuity of the big reps.
def dosubs(func, a, b):
rv = func.subs({z: exp_polar(a)*z}).rewrite('nonrep')
return rv.subs({z: exp_polar(b)*z}).replace(exp_polar, exp)
for n in [0, 1, 2, 3, 4, -1, -2, -3, -4]:
expr1 = dosubs(func, 2*I*pi*n, I*pi/2)
expr2 = dosubs(func, 2*I*pi*n + I*pi, -I*pi/2)
if not tn(expr1, expr2, z):
return False
expr1 = dosubs(func, 2*I*pi*(n + 1), -I*pi/2)
expr2 = dosubs(func, 2*I*pi*n + I*pi, I*pi/2)
if not tn(expr1, expr2, z):
return False
return True
def test_ei():
pos = Symbol('p', positive=True)
neg = Symbol('n', negative=True)
assert Ei(-pos) == Ei(polar_lift(-1) * pos) - I * pi
assert Ei(neg) == Ei(polar_lift(neg)) - I * pi
assert tn_branch(Ei)
assert mytd(Ei(x), exp(x) / x, x)
assert mytn(Ei(x),
Ei(x).rewrite(uppergamma),
-uppergamma(0, x * polar_lift(-1)) - I * pi, x)
assert mytn(Ei(x),
Ei(x).rewrite(expint), -expint(1, x * polar_lift(-1)) - I * pi,
x)
assert Ei(x).rewrite(expint).rewrite(Ei) == Ei(x)
assert Ei(x * exp_polar(2 * I * pi)) == Ei(x) + 2 * I * pi
assert Ei(x * exp_polar(-2 * I * pi)) == Ei(x) - 2 * I * pi
assert mytn(Ei(x), Ei(x).rewrite(Shi), Chi(x) + Shi(x), x)
assert mytn(Ei(x * polar_lift(I)),
Ei(x * polar_lift(I)).rewrite(Si),
Ci(x) + I * Si(x) + I * pi / 2, x)
assert Ei(log(x)).rewrite(li) == li(x)
assert Ei(2 * log(x)).rewrite(li) == li(x**2)
assert Ei(x).series(x) == EulerGamma + log(x) + x + x**2/4 + \
x**3/18 + x**4/96 + x**5/600 + O(x**6)
def t(func, hyp, z):
"""Test that func is a valid representation of hyp."""
# First test that func agrees with hyp for small z
if not tn(func.rewrite('nonrepsmall'), hyp, z,
a=Rational(-1, 2), b=Rational(-1, 2), c=Rational(1, 2), d=Rational(1, 2)):
return False
# Next check that the two small representations agree.
if not tn(
func.rewrite('nonrepsmall').subs({z: exp_polar(I*pi)*z}).replace(exp_polar, exp),
func.subs({z: exp_polar(I*pi)*z}).rewrite('nonrepsmall'),
z, a=Rational(-1, 2), b=Rational(-1, 2), c=Rational(1, 2), d=Rational(1, 2)):
return False
# Next check continuity along exp_polar(I*pi)*t
expr = func.subs({z: exp_polar(I*pi)*z}).rewrite('nonrep')
if abs(expr.subs({z: 1 + 1e-15}) - expr.subs({z: 1 - 1e-15})).evalf(strict=False) > 1e-10:
return False
# Finally check continuity of the big reps.
def dosubs(func, a, b):
rv = func.subs({z: exp_polar(a)*z}).rewrite('nonrep')
return rv.subs({z: exp_polar(b)*z}).replace(exp_polar, exp)
for n in [0, 1, 2, 3, 4, -1, -2, -3, -4]:
expr1 = dosubs(func, 2*I*pi*n, I*pi/2)
expr2 = dosubs(func, 2*I*pi*n + I*pi, -I*pi/2)
if not tn(expr1, expr2, z):
return False
expr1 = dosubs(func, 2*I*pi*(n + 1), -I*pi/2)
expr2 = dosubs(func, 2*I*pi*n + I*pi, I*pi/2)
if not tn(expr1, expr2, z):
return False
return True
def test_ei():
pos = Symbol('p', positive=True)
neg = Symbol('n', negative=True)
assert Ei(0) == -oo
assert Ei(+oo) == oo
assert Ei(-oo) == 0
assert Ei(-pos) == Ei(polar_lift(-1) * pos) - I * pi
assert Ei(neg) == Ei(polar_lift(neg)) - I * pi
assert tn_branch(Ei)
assert mytd(Ei(x), exp(x) / x, x)
assert mytn(Ei(x),
Ei(x).rewrite(uppergamma),
-uppergamma(0, x * polar_lift(-1)) - I * pi, x)
assert mytn(Ei(x),
Ei(x).rewrite(expint), -expint(1, x * polar_lift(-1)) - I * pi,
x)
assert Ei(x).rewrite(expint).rewrite(Ei) == Ei(x)
assert Ei(x * exp_polar(2 * I * pi)) == Ei(x) + 2 * I * pi
assert Ei(x * exp_polar(-2 * I * pi)) == Ei(x) - 2 * I * pi
assert mytn(Ei(x), Ei(x).rewrite(Shi), Chi(x) + Shi(x), x)
assert mytn(Ei(x * polar_lift(I)),
Ei(x * polar_lift(I)).rewrite(Si),
Ci(x) + I * Si(x) + I * pi / 2, x)
assert Ei(log(x)).rewrite(li) == li(x)
assert Ei(2 * log(x)).rewrite(li) == li(x**2)
assert Ei(x).series(x) == (EulerGamma + log(x) + x + x**2 / 4 + x**3 / 18 +
x**4 / 96 + x**5 / 600 + O(x**6))
assert Ei(1 + x).series(x) == (Ei(1) + E * x + E * x**3 / 6 -
E * x**4 / 12 + 3 * E * x**5 / 40 + O(x**6))
pytest.raises(ArgumentIndexError, lambda: Ei(x).fdiff(2))
def test_polylog_eval():
assert polylog(s, 0) == 0
assert polylog(s, 1) == zeta(s)
assert polylog(s, -1) == -dirichlet_eta(s)
assert polylog(s, exp_polar(I * pi)) == polylog(s, -1)
assert polylog(s, 2 * exp_polar(2 * I * pi)) == polylog(
s, 2 * exp_polar(2 * I * pi), evaluate=False)
def test_branching():
assert besselj(polar_lift(k), x) == besselj(k, x)
assert besseli(polar_lift(k), x) == besseli(k, x)
n = Symbol('n', integer=True)
assert besselj(n, exp_polar(2*pi*I)*x) == besselj(n, x)
assert besselj(n, polar_lift(x)) == besselj(n, x)
assert besseli(n, exp_polar(2*pi*I)*x) == besseli(n, x)
assert besseli(n, polar_lift(x)) == besseli(n, x)
def tn(func, s):
c = uniform(1, 5)
expr = func(s, c*exp_polar(I*pi)) - func(s, c*exp_polar(-I*pi))
eps = 1e-15
expr2 = func(s + eps, -c + eps*I) - func(s + eps, -c - eps*I)
return abs(expr - expr2).evalf(strict=False) < 1e-10
nu = Symbol('nu')
assert besselj(nu, exp_polar(2*pi*I)*x) == exp(2*pi*I*nu)*besselj(nu, x)
assert besseli(nu, exp_polar(2*pi*I)*x) == exp(2*pi*I*nu)*besseli(nu, x)
assert tn(besselj, 2)
assert tn(besselj, pi)
assert tn(besselj, I)
assert tn(besseli, 2)
assert tn(besseli, pi)
assert tn(besseli, I)
def test_branching():
from diofant import exp_polar, polar_lift, Symbol, I, exp
assert besselj(polar_lift(k), x) == besselj(k, x)
assert besseli(polar_lift(k), x) == besseli(k, x)
n = Symbol('n', integer=True)
assert besselj(n, exp_polar(2 * pi * I) * x) == besselj(n, x)
assert besselj(n, polar_lift(x)) == besselj(n, x)
assert besseli(n, exp_polar(2 * pi * I) * x) == besseli(n, x)
assert besseli(n, polar_lift(x)) == besseli(n, x)
def tn(func, s):
from random import uniform
c = uniform(1, 5)
expr = func(s, c * exp_polar(I * pi)) - func(s, c * exp_polar(-I * pi))
eps = 1e-15
expr2 = func(s + eps, -c + eps * I) - func(s + eps, -c - eps * I)
return abs(expr.n() - expr2.n()).n() < 1e-10
nu = Symbol('nu')
assert besselj(nu,
exp_polar(2 * pi * I) *
x) == exp(2 * pi * I * nu) * besselj(nu, x)
assert besseli(nu,
exp_polar(2 * pi * I) *
x) == exp(2 * pi * I * nu) * besseli(nu, x)
assert tn(besselj, 2)
assert tn(besselj, pi)
assert tn(besselj, I)
assert tn(besseli, 2)
assert tn(besseli, pi)
assert tn(besseli, I)
def test_matplotlib_advanced():
"""Examples from the 'advanced' notebook."""
try:
name = 'test'
tmp_file = TmpFileManager.tmp_file
s = summation(1 / x**y, (x, 1, oo))
p = plot(s, (y, 2, 10))
p.save(tmp_file('%s_advanced_inf_sum' % name))
p = plot(summation(1 / x, (x, 1, y)), (y, 2, 10), show=False)
p[0].only_integers = True
p[0].steps = True
p.save(tmp_file('%s_advanced_fin_sum' % name))
###
# Test expressions that can not be translated to np and
# generate complex results.
###
plot(sin(x) + I * cos(x)).save(tmp_file())
plot(sqrt(sqrt(-x))).save(tmp_file())
plot(LambertW(x)).save(tmp_file())
plot(sqrt(LambertW(x))).save(tmp_file())
# Characteristic function of a StudentT distribution with nu=10
plot((meijerg(
((1 / 2, ), ()),
((5, 0, 1 / 2), ()), 5 * x**2 * exp_polar(-I * pi) / 2) + meijerg(
((1 / 2, ), ()),
((5, 0, 1 / 2),
()), 5 * x**2 * exp_polar(I * pi) / 2)) / (48 * pi),
(x, 1e-6, 1e-2)).save(tmp_file())
finally:
TmpFileManager.cleanup()
def test_ei():
pos = Symbol('p', positive=True)
neg = Symbol('n', negative=True)
assert Ei(0) == -oo
assert Ei(+oo) == oo
assert Ei(-oo) == 0
assert Ei(-pos) == Ei(polar_lift(-1)*pos) - I*pi
assert Ei(neg) == Ei(polar_lift(neg)) - I*pi
assert tn_branch(Ei)
assert mytd(Ei(x), exp(x)/x, x)
assert mytn(Ei(x), Ei(x).rewrite(uppergamma),
-uppergamma(0, x*polar_lift(-1)) - I*pi, x)
assert mytn(Ei(x), Ei(x).rewrite(expint),
-expint(1, x*polar_lift(-1)) - I*pi, x)
assert Ei(x).rewrite(expint).rewrite(Ei) == Ei(x)
assert Ei(x*exp_polar(2*I*pi)) == Ei(x) + 2*I*pi
assert Ei(x*exp_polar(-2*I*pi)) == Ei(x) - 2*I*pi
assert mytn(Ei(x), Ei(x).rewrite(Shi), Chi(x) + Shi(x), x)
assert mytn(Ei(x*polar_lift(I)), Ei(x*polar_lift(I)).rewrite(Si),
Ci(x) + I*Si(x) + I*pi/2, x)
assert Ei(log(x)).rewrite(li) == li(x)
assert Ei(2*log(x)).rewrite(li) == li(x**2)
assert Ei(x).series(x) == (EulerGamma + log(x) + x + x**2/4 +
x**3/18 + x**4/96 + x**5/600 + O(x**6))
assert Ei(1 + x).series(x) == (Ei(1) + E*x + E*x**3/6 - E*x**4/12 +
3*E*x**5/40 + O(x**6))
pytest.raises(ArgumentIndexError, lambda: Ei(x).fdiff(2))
def test_meijerg_eval():
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).evalf(subs={x: x_, k: k_}, strict=False)) < 1e-10
assert abs((expr1 - expr2).evalf(subs={x: x_, k: -k_}, strict=False)) < 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).evalf(
subs={x: x_, k: k_ + eps, l: k_ - eps})) < 1e-10
assert abs((expr1 - expr2).evalf(
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)).evalf(chop=True) == 0
def test_matplotlib_advanced():
"""Examples from the 'advanced' notebook."""
try:
name = 'test'
tmp_file = TmpFileManager.tmp_file
s = summation(1/x**y, (x, 1, oo))
p = plot(s, (y, 2, 10))
p.save(tmp_file('%s_advanced_inf_sum' % name))
p = plot(summation(1/x, (x, 1, y)), (y, 2, 10), show=False)
p[0].only_integers = True
p[0].steps = True
p.save(tmp_file('%s_advanced_fin_sum' % name))
###
# Test expressions that can not be translated to np and
# generate complex results.
###
plot(sin(x) + I*cos(x)).save(tmp_file())
plot(sqrt(sqrt(-x))).save(tmp_file())
plot(LambertW(x)).save(tmp_file())
plot(sqrt(LambertW(x))).save(tmp_file())
# Characteristic function of a StudentT distribution with nu=10
plot((meijerg(((1 / 2,), ()), ((5, 0, 1 / 2), ()),
5 * x**2 * exp_polar(-I*pi)/2)
+ meijerg(((1/2,), ()), ((5, 0, 1/2), ()),
5*x**2 * exp_polar(I*pi)/2)) / (48 * pi), (x, 1e-6, 1e-2)).save(tmp_file())
finally:
TmpFileManager.cleanup()
def tn(func, s):
from random import uniform
c = uniform(1, 5)
expr = func(s, c * exp_polar(I * pi)) - func(s, c * exp_polar(-I * pi))
eps = 1e-15
expr2 = func(s + eps, -c + eps * I) - func(s + eps, -c - eps * I)
return abs(expr.n() - expr2.n()).n() < 1e-10
def test_branching():
assert besselj(polar_lift(k), x) == besselj(k, x)
assert besseli(polar_lift(k), x) == besseli(k, x)
n = Symbol('n', integer=True)
assert besselj(n, exp_polar(2 * pi * I) * x) == besselj(n, x)
assert besselj(n, polar_lift(x)) == besselj(n, x)
assert besseli(n, exp_polar(2 * pi * I) * x) == besseli(n, x)
assert besseli(n, polar_lift(x)) == besseli(n, x)
def tn(func, s):
c = uniform(1, 5)
expr = func(s, c * exp_polar(I * pi)) - func(s, c * exp_polar(-I * pi))
eps = 1e-15
expr2 = func(s + eps, -c + eps * I) - func(s + eps, -c - eps * I)
return abs(expr - expr2).evalf(strict=False) < 1e-10
nu = Symbol('nu')
assert besselj(nu,
exp_polar(2 * pi * I) *
x) == exp(2 * pi * I * nu) * besselj(nu, x)
assert besseli(nu,
exp_polar(2 * pi * I) *
x) == exp(2 * pi * I * nu) * besseli(nu, x)
assert tn(besselj, 2)
assert tn(besselj, pi)
assert tn(besselj, I)
assert tn(besseli, 2)
assert tn(besseli, pi)
assert tn(besseli, I)
def test_sympyissue_7173():
assert laplace_transform(sinh(a*x)*cosh(a*x), x, s) == \
(a/(s**2 - 4*a**2), 0,
And(Or(Abs(periodic_argument(exp_polar(I*pi)*polar_lift(a), oo)) <
pi/2, Abs(periodic_argument(exp_polar(I*pi)*polar_lift(a), oo)) <=
pi/2), Or(Abs(periodic_argument(a, oo)) < pi/2,
Abs(periodic_argument(a, oo)) <= pi/2)))
def test_gamma():
assert gamma(nan) == nan
assert gamma(oo) == oo
assert gamma(-100) == zoo
assert gamma(0) == zoo
assert gamma(1) == 1
assert gamma(2) == 1
assert gamma(3) == 2
assert gamma(102) == factorial(101)
assert gamma(Rational(1, 2)) == sqrt(pi)
assert gamma(Rational(3, 2)) == Rational(1, 2)*sqrt(pi)
assert gamma(Rational(5, 2)) == Rational(3, 4)*sqrt(pi)
assert gamma(Rational(7, 2)) == Rational(15, 8)*sqrt(pi)
assert gamma(Rational(-1, 2)) == -2*sqrt(pi)
assert gamma(Rational(-3, 2)) == Rational(4, 3)*sqrt(pi)
assert gamma(Rational(-5, 2)) == -Rational(8, 15)*sqrt(pi)
assert gamma(Rational(-15, 2)) == Rational(256, 2027025)*sqrt(pi)
assert gamma(Rational(
-11, 8)).expand(func=True) == Rational(64, 33)*gamma(Rational(5, 8))
assert gamma(Rational(
-10, 3)).expand(func=True) == Rational(81, 280)*gamma(Rational(2, 3))
assert gamma(Rational(
14, 3)).expand(func=True) == Rational(880, 81)*gamma(Rational(2, 3))
assert gamma(Rational(
17, 7)).expand(func=True) == Rational(30, 49)*gamma(Rational(3, 7))
assert gamma(Rational(
19, 8)).expand(func=True) == Rational(33, 64)*gamma(Rational(3, 8))
assert gamma(x).diff(x) == gamma(x)*polygamma(0, x)
pytest.raises(ArgumentIndexError, lambda: gamma(x).fdiff(2))
assert gamma(x - 1).expand(func=True) == gamma(x)/(x - 1)
assert gamma(x + 2).expand(func=True, mul=False) == x*(x + 1)*gamma(x)
assert conjugate(gamma(x)) == gamma(conjugate(x))
assert expand_func(gamma(x + Rational(3, 2))) == \
(x + Rational(1, 2))*gamma(x + Rational(1, 2))
assert expand_func(gamma(x - Rational(1, 2))) == \
gamma(Rational(1, 2) + x)/(x - Rational(1, 2))
# Test a bug:
assert expand_func(gamma(x + Rational(3, 4))) == gamma(x + Rational(3, 4))
assert gamma(3*exp_polar(I*pi)/4).is_nonnegative is False
assert gamma(3*exp_polar(I*pi)/4).is_nonpositive is True
# Issue sympy/sympy#8526
k = Symbol('k', integer=True, nonnegative=True)
assert isinstance(gamma(k), gamma)
assert gamma(-k) == zoo
def tn_branch(s, func):
from diofant import I, pi, exp_polar
from random import uniform
c = uniform(1, 5)
expr = func(s, c * exp_polar(I * pi)) - func(s, c * exp_polar(-I * pi))
eps = 1e-15
expr2 = func(s + eps, -c + eps * I) - func(s + eps, -c - eps * I)
return abs(expr.n() - expr2.n()).n() < 1e-10
def tn_arg(func):
def test(arg, e1, e2):
v = uniform(1, 5)
v1 = func(arg * x).subs({x: v}).evalf(strict=False)
v2 = func(e1 * v + e2 * 1e-15).evalf(strict=False)
return abs(v1 - v2).evalf(strict=False) < 1e-10
return test(exp_polar(I*pi/2), I, 1) and \
test(exp_polar(-I*pi/2), -I, 1) and \
test(exp_polar(I*pi), -1, I) and \
test(exp_polar(-I*pi), -1, -I)
def tn_branch(func, s=None):
def fn(x):
if s is None:
return func(x)
return func(s, x)
c = uniform(1, 5)
expr = fn(c*exp_polar(I*pi)) - fn(c*exp_polar(-I*pi))
eps = 1e-15
expr2 = fn(-c + eps*I) - fn(-c - eps*I)
return abs(expr - expr2).evalf(strict=False) < 1e-10
def tn_arg(func):
def test(arg, e1, e2):
v = uniform(1, 5)
v1 = func(arg*x).subs({x: v}).evalf(strict=False)
v2 = func(e1*v + e2*1e-15).evalf(strict=False)
return abs(v1 - v2).evalf(strict=False) < 1e-10
return test(exp_polar(I*pi/2), I, 1) and \
test(exp_polar(-I*pi/2), -I, 1) and \
test(exp_polar(I*pi), -1, I) and \
test(exp_polar(-I*pi), -1, -I)
def test_principal_branch():
p = Symbol('p', positive=True)
neg = Symbol('x', negative=True)
assert principal_branch(polar_lift(x), p) == principal_branch(x, p)
assert principal_branch(polar_lift(2 + I), p) == principal_branch(2 + I, p)
assert principal_branch(2 * x, p) == 2 * principal_branch(x, p)
assert principal_branch(1, pi) == exp_polar(0)
assert principal_branch(-1, 2 * pi) == exp_polar(I * pi)
assert principal_branch(-1, pi) == exp_polar(0)
assert principal_branch(exp_polar(3*pi*I)*x, 2*pi) == \
principal_branch(exp_polar(I*pi)*x, 2*pi)
assert principal_branch(neg * exp_polar(pi * I),
2 * pi) == neg * exp_polar(-I * pi)
assert N_equals(principal_branch((1 + I)**2, 2 * pi), 2 * I)
assert N_equals(principal_branch((1 + I)**2, 3 * pi), 2 * I)
assert N_equals(principal_branch((1 + I)**2, 1 * pi), 2 * I)
# test argument sanitization
assert isinstance(principal_branch(x, I), principal_branch)
assert isinstance(principal_branch(x, -4), principal_branch)
assert isinstance(principal_branch(x, -oo), principal_branch)
assert isinstance(principal_branch(x, zoo), principal_branch)
assert (principal_branch((4 + I)**2, 2 * pi).evalf() == principal_branch(
(4 + I)**2, 2 * pi))
assert principal_branch(exp_polar(-I * pi) * polar_lift(-1 - I),
2 * pi) == sqrt(2) * exp_polar(I * pi / 4)
def test_expint():
assert mytn(expint(x, y),
expint(x, y).rewrite(uppergamma),
y**(x - 1) * uppergamma(1 - x, y), x)
assert mytd(expint(x, y),
-y**(x - 1) * meijerg([], [1, 1], [0, 0, 1 - x], [], y), x)
assert mytd(expint(x, y), -expint(x - 1, y), y)
assert mytn(expint(1, x),
expint(1, x).rewrite(Ei), -Ei(x * polar_lift(-1)) + I * pi, x)
assert expint(-4, x) == exp(-x)/x + 4*exp(-x)/x**2 + 12*exp(-x)/x**3 \
+ 24*exp(-x)/x**4 + 24*exp(-x)/x**5
assert expint(-Rational(3, 2), x) == \
exp(-x)/x + 3*exp(-x)/(2*x**2) - 3*sqrt(pi)*erf(sqrt(x))/(4*x**Rational(5, 2)) \
+ 3*sqrt(pi)/(4*x**Rational(5, 2))
assert tn_branch(expint, 1)
assert tn_branch(expint, 2)
assert tn_branch(expint, 3)
assert tn_branch(expint, 1.7)
assert tn_branch(expint, pi)
assert expint(y, x*exp_polar(2*I*pi)) == \
x**(y - 1)*(exp(2*I*pi*y) - 1)*gamma(-y + 1) + expint(y, x)
assert expint(y, x*exp_polar(-2*I*pi)) == \
x**(y - 1)*(exp(-2*I*pi*y) - 1)*gamma(-y + 1) + expint(y, x)
assert expint(2,
x * exp_polar(2 * I * pi)) == 2 * I * pi * x + expint(2, x)
assert expint(2, x *
exp_polar(-2 * I * pi)) == -2 * I * pi * x + expint(2, x)
assert expint(1, x).rewrite(Ei).rewrite(expint) == expint(1, x)
assert mytn(E1(x), E1(x).rewrite(Shi), Shi(x) - Chi(x), x)
assert mytn(E1(polar_lift(I) * x),
E1(polar_lift(I) * x).rewrite(Si),
-Ci(x) + I * Si(x) - I * pi / 2, x)
assert mytn(expint(2, x),
expint(2, x).rewrite(Ei).rewrite(expint), -x * E1(x) + exp(-x),
x)
assert mytn(expint(3, x),
expint(3, x).rewrite(Ei).rewrite(expint),
x**2 * E1(x) / 2 + (1 - x) * exp(-x) / 2, x)
assert expint(Rational(3, 2), z).nseries(z, n=10) == \
2 + 2*z - z**2/3 + z**3/15 - z**4/84 + z**5/540 - \
2*sqrt(pi)*sqrt(z) + O(z**6)
assert E1(z).series(z) == -EulerGamma - log(z) + z - \
z**2/4 + z**3/18 - z**4/96 + z**5/600 + O(z**6)
assert expint(4, z).series(z) == Rational(1, 3) - z/2 + z**2/2 + \
z**3*(log(z)/6 - Rational(11, 36) + EulerGamma/6) - z**4/24 + \
z**5/240 + O(z**6)
def tn_arg(func):
def test(arg, e1, e2):
from random import uniform
v = uniform(1, 5)
v1 = func(arg*x).subs(x, v).n()
v2 = func(e1*v + e2*1e-15).n()
return abs(v1 - v2).n() < 1e-10
return test(exp_polar(I*pi/2), I, 1) and \
test(exp_polar(-I*pi/2), -I, 1) and \
test(exp_polar(I*pi), -1, I) and \
test(exp_polar(-I*pi), -1, -I)
def tn_branch(func, s=None):
def fn(x):
if s is None:
return func(x)
return func(s, x)
c = uniform(1, 5)
expr = fn(c * exp_polar(I * pi)) - fn(c * exp_polar(-I * pi))
eps = 1e-15
expr2 = fn(-c + eps * I) - fn(-c - eps * I)
return abs(expr - expr2).evalf(strict=False) < 1e-10
def test_laplace_transform_2():
LT = laplace_transform
# issue sympy/sympy#7173
assert LT(sinh(a*x)*cosh(a*x), x, s) == \
(a/(s**2 - 4*a**2), 0,
And(Or(abs(periodic_argument(exp_polar(I*pi)*polar_lift(a), oo)) <
pi/2, abs(periodic_argument(exp_polar(I*pi)*polar_lift(a), oo)) <=
pi/2), Or(abs(periodic_argument(a, oo)) < pi/2,
abs(periodic_argument(a, oo)) <= pi/2)))
# issues sympy/sympy#8368 and sympy/sympy#7173
assert LT(sinh(x) * cosh(x), x, s) == (1 / (s**2 - 4), 2, Ne(s / 2, 1))
def test_si():
assert Si(I * x) == I * Shi(x)
assert Shi(I * x) == I * Si(x)
assert Si(-I * x) == -I * Shi(x)
assert Shi(-I * x) == -I * Si(x)
assert Si(-x) == -Si(x)
assert Shi(-x) == -Shi(x)
assert Si(exp_polar(2 * pi * I) * x) == Si(x)
assert Si(exp_polar(-2 * pi * I) * x) == Si(x)
assert Shi(exp_polar(2 * pi * I) * x) == Shi(x)
assert Shi(exp_polar(-2 * pi * I) * x) == Shi(x)
assert Si(oo) == pi / 2
assert Si(-oo) == -pi / 2
assert Shi(oo) == oo
assert Shi(-oo) == -oo
assert mytd(Si(x), sin(x) / x, x)
assert mytd(Shi(x), sinh(x) / x, x)
assert mytn(
Si(x),
Si(x).rewrite(Ei),
-I * (-Ei(x * exp_polar(-I * pi / 2)) / 2 +
Ei(x * exp_polar(I * pi / 2)) / 2 - I * pi) + pi / 2, x)
assert mytn(
Si(x),
Si(x).rewrite(expint),
-I * (-expint(1, x * exp_polar(-I * pi / 2)) / 2 +
expint(1, x * exp_polar(I * pi / 2)) / 2) + pi / 2, x)
assert mytn(Shi(x),
Shi(x).rewrite(Ei),
Ei(x) / 2 - Ei(x * exp_polar(I * pi)) / 2 + I * pi / 2, x)
assert mytn(
Shi(x),
Shi(x).rewrite(expint),
expint(1, x) / 2 - expint(1, x * exp_polar(I * pi)) / 2 - I * pi / 2,
x)
assert tn_arg(Si)
assert tn_arg(Shi)
assert Si(x).nseries(x, n=8) == \
x - x**3/18 + x**5/600 - x**7/35280 + O(x**9)
assert Shi(x).nseries(x, n=8) == \
x + x**3/18 + x**5/600 + x**7/35280 + O(x**9)
assert Si(sin(x)).nseries(
x, n=5) == x - 2 * x**3 / 9 + 17 * x**5 / 450 + O(x**7)
assert Si(x).series(x, 1, n=3) == \
Si(1) + (x - 1)*sin(1) + (x - 1)**2*(-sin(1)/2 + cos(1)/2) + O((x - 1)**3, (x, 1))
pytest.raises(ArgumentIndexError, lambda: Si(z).fdiff(2))
def tn_branch(func, s=None):
from diofant import I, pi, exp_polar
from random import uniform
def fn(x):
if s is None:
return func(x)
return func(s, x)
c = uniform(1, 5)
expr = fn(c*exp_polar(I*pi)) - fn(c*exp_polar(-I*pi))
eps = 1e-15
expr2 = fn(-c + eps*I) - fn(-c - eps*I)
return abs(expr.n() - expr2.n()).n() < 1e-10
def test_besselsimp():
assert besselsimp(exp(-I*pi*y/2)*besseli(y, z*exp_polar(I*pi/2))) == \
besselj(y, z)
assert besselsimp(exp(-I*pi*a/2)*besseli(a, 2*sqrt(x)*exp_polar(I*pi/2))) == \
besselj(a, 2*sqrt(x))
assert besselsimp(sqrt(2)*sqrt(pi)*root(x, 4)*exp(I*pi/4)*exp(-I*pi*a/2) *
besseli(-Rational(1, 2), sqrt(x)*exp_polar(I*pi/2)) *
besseli(a, sqrt(x)*exp_polar(I*pi/2))/2) == \
besselj(a, sqrt(x)) * cos(sqrt(x))
assert besselsimp(besseli(Rational(-1, 2), z)) == \
sqrt(2)*cosh(z)/(sqrt(pi)*sqrt(z))
assert besselsimp(besseli(a, z*exp_polar(-I*pi/2))) == \
exp(-I*pi*a/2)*besselj(a, z)
assert cosine_transform(1/t*sin(a/t), t, y) == \
sqrt(2)*sqrt(pi)*besselj(0, 2*sqrt(a)*sqrt(y))/2
def test_lerchphi():
from diofant import combsimp, exp_polar, polylog, log, lerchphi
assert hyperexpand(hyper([1, a], [a + 1], z) / a) == lerchphi(z, 1, a)
assert hyperexpand(hyper([1, a, a], [a + 1, a + 1], z) / a**2) == lerchphi(
z, 2, a)
assert hyperexpand(hyper([1, a, a, a], [a + 1, a + 1, a + 1], z)/a**3) == \
lerchphi(z, 3, a)
assert hyperexpand(hyper([1] + [a]*10, [a + 1]*10, z)/a**10) == \
lerchphi(z, 10, a)
assert combsimp(
hyperexpand(meijerg([0, 1 - a], [], [0], [-a],
exp_polar(-I * pi) * z))) == lerchphi(z, 1, a)
assert combsimp(
hyperexpand(
meijerg([0, 1 - a, 1 - a], [], [0], [-a, -a],
exp_polar(-I * pi) * z))) == lerchphi(z, 2, a)
assert combsimp(
hyperexpand(
meijerg([0, 1 - a, 1 - a, 1 - a], [], [0], [-a, -a, -a],
exp_polar(-I * pi) * z))) == lerchphi(z, 3, a)
assert hyperexpand(z * hyper([1, 1], [2], z)) == -log(1 + -z)
assert hyperexpand(z * hyper([1, 1, 1], [2, 2], z)) == polylog(2, z)
assert hyperexpand(z * hyper([1, 1, 1, 1], [2, 2, 2], z)) == polylog(3, z)
assert hyperexpand(hyper([1, a, 1 + Rational(1, 2)], [a + 1, Rational(1, 2)], z)) == \
-2*a/(z - 1) + (-2*a**2 + a)*lerchphi(z, 1, a)
# Now numerical tests. These make sure reductions etc are carried out
# correctly
# a rational function (polylog at negative integer order)
assert can_do([2, 2, 2], [1, 1])
# NOTE these contain log(1-x) etc ... better make sure we have |z| < 1
# reduction of order for polylog
assert can_do([1, 1, 1, b + 5], [2, 2, b], div=10)
# reduction of order for lerchphi
# XXX lerchphi in mpmath is flaky
assert can_do([1, a, a, a, b + 5], [a + 1, a + 1, a + 1, b],
numerical=False)
# test a bug
from diofant import Abs
assert hyperexpand(hyper([Rational(1, 2), Rational(1, 2), Rational(1, 2), 1],
[Rational(3, 2), Rational(3, 2), Rational(3, 2)], Rational(1, 4))) == \
Abs(-polylog(3, exp_polar(I*pi)/2) + polylog(3, Rational(1, 2)))
def test_branch_bug():
assert hyperexpand(hyper((-Rational(1, 3), Rational(1, 2)), (Rational(2, 3), Rational(3, 2)), -z)) == \
-z**Rational(1, 3)*lowergamma(exp_polar(I*pi)/3, z)/5 \
+ sqrt(pi)*erf(sqrt(z))/(5*sqrt(z))
assert hyperexpand(meijerg([Rational(7, 6), 1], [], [Rational(2, 3)], [Rational(1, 6), 0], z)) == \
2*z**Rational(2, 3)*(2*sqrt(pi)*erf(sqrt(z))/sqrt(z) -
2*lowergamma(Rational(2, 3), z)/z**Rational(2, 3))*gamma(Rational(2, 3))/gamma(Rational(5, 3))
def test_hyper_unpolarify():
a = exp_polar(2 * pi * I) * x
b = x
assert hyper([], [], a).argument == b
assert hyper([0], [], a).argument == a
assert hyper([0], [0], a).argument == b
assert hyper([0, 1], [0], a).argument == a
def test_meijerg_with_Floats():
# see sympy/sympy#10681
f = meijerg(((3.0, 1), ()), ((Rational(3, 2),), (0,)), z)
a = -2.3632718012073
g = a*z**Rational(3, 2)*hyper((-0.5, Rational(3, 2)),
(Rational(5, 2),), z*exp_polar(I*pi))
assert RR.almosteq((hyperexpand(f)/g).n(), 1.0, 1e-12)
def test_branch_bug():
assert hyperexpand(hyper((-Rational(1, 3), Rational(1, 2)), (Rational(2, 3), Rational(3, 2)), -z)) == \
-cbrt(z)*lowergamma(exp_polar(I*pi)/3, z)/5 \
+ sqrt(pi)*erf(sqrt(z))/(5*sqrt(z))
assert hyperexpand(meijerg([Rational(7, 6), 1], [], [Rational(2, 3)], [Rational(1, 6), 0], z)) == \
2*z**Rational(2, 3)*(2*sqrt(pi)*erf(sqrt(z))/sqrt(z) -
2*lowergamma(Rational(2, 3), z)/z**Rational(2, 3))*gamma(Rational(2, 3))/gamma(Rational(5, 3))
def test_hyper_unpolarify():
a = exp_polar(2*pi*I)*x
b = x
assert hyper([], [], a).argument == b
assert hyper([0], [], a).argument == a
assert hyper([0], [0], a).argument == b
assert hyper([0, 1], [0], a).argument == a
def test_meijerg_expand():
from diofant import combsimp, simplify
# from mpmath docs
assert hyperexpand(meijerg([[], []], [[0], []], -z)) == exp(z)
assert hyperexpand(meijerg([[1, 1], []], [[1], [0]], z)) == \
log(z + 1)
assert hyperexpand(meijerg([[1, 1], []], [[1], [1]], z)) == \
z/(z + 1)
assert hyperexpand(meijerg([[], []], [[Rational(1, 2)], [0]], (z/2)**2)) \
== sin(z)/sqrt(pi)
assert hyperexpand(meijerg([[], []], [[0], [Rational(1, 2)]], (z/2)**2)) \
== cos(z)/sqrt(pi)
assert can_do_meijer([], [a], [a - 1, a - S.Half], [])
assert can_do_meijer([], [], [a / 2], [-a / 2], False) # branches...
assert can_do_meijer([a], [b], [a], [b, a - 1])
# wikipedia
assert hyperexpand(meijerg([1], [], [], [0], z)) == \
Piecewise((0, abs(z) < 1), (1, abs(1/z) < 1),
(meijerg([1], [], [], [0], z), True))
assert hyperexpand(meijerg([], [1], [0], [], z)) == \
Piecewise((1, abs(z) < 1), (0, abs(1/z) < 1),
(meijerg([], [1], [0], [], z), True))
# The Special Functions and their Approximations
assert can_do_meijer([], [], [a + b / 2], [a, a - b / 2, a + S.Half])
assert can_do_meijer([], [], [a], [b],
False) # branches only agree for small z
assert can_do_meijer([], [S.Half], [a], [-a])
assert can_do_meijer([], [], [a, b], [])
assert can_do_meijer([], [], [a, b], [])
assert can_do_meijer([], [], [a, a + S.Half], [b, b + S.Half])
assert can_do_meijer([], [], [a, -a], [0, S.Half], False) # dito
assert can_do_meijer([], [], [a, a + S.Half, b, b + S.Half], [])
assert can_do_meijer([S.Half], [], [0], [a, -a])
assert can_do_meijer([S.Half], [], [a], [0, -a], False) # dito
assert can_do_meijer([], [a - S.Half], [a, b], [a - S.Half], False)
assert can_do_meijer([], [a + S.Half], [a + b, a - b, a], [], False)
assert can_do_meijer([a + S.Half], [], [b, 2 * a - b, a], [], False)
# This for example is actually zero.
assert can_do_meijer([], [], [], [a, b])
# Testing a bug:
assert hyperexpand(meijerg([0, 2], [], [], [-1, 1], z)) == \
Piecewise((0, abs(z) < 1),
(z/2 - 1/(2*z), abs(1/z) < 1),
(meijerg([0, 2], [], [], [-1, 1], z), True))
# Test that the simplest possible answer is returned:
assert combsimp(simplify(hyperexpand(
meijerg([1], [1 - a], [-a/2, -a/2 + Rational(1, 2)], [], 1/z)))) == \
-2*sqrt(pi)*(sqrt(z + 1) + 1)**a/a
# Test that hyper is returned
assert hyperexpand(meijerg([1], [], [a], [0, 0], z)) == hyper(
(a, ), (a + 1, a + 1),
z * exp_polar(I * pi)) * z**a * gamma(a) / gamma(a + 1)**2
def test_hyper_unpolarify():
from diofant import exp_polar
a = exp_polar(2 * pi * I) * x
b = x
assert hyper([], [], a).argument == b
assert hyper([0], [], a).argument == a
assert hyper([0], [0], a).argument == b
assert hyper([0, 1], [0], a).argument == a
def test_polarify():
z = Symbol('z', polar=True)
f = Function('f')
ES = {}
assert polarify(-1) == (polar_lift(-1), ES)
assert polarify(1 + I) == (polar_lift(1 + I), ES)
assert polarify(exp(x), subs=False) == exp(x)
assert polarify(1 + x, subs=False) == 1 + x
assert polarify(f(I) + x, subs=False) == f(polar_lift(I)) + x
assert polarify(x, lift=True) == polar_lift(x)
assert polarify(z, lift=True) == z
assert polarify(f(x), lift=True) == f(polar_lift(x))
assert polarify(1 + x, lift=True) == polar_lift(1 + x)
assert polarify(1 + f(x), lift=True) == polar_lift(1 + f(polar_lift(x)))
newex, subs = polarify(f(x) + z)
assert newex.subs(subs) == f(x) + z
mu = Symbol('mu')
sigma = Symbol('sigma', positive=True)
# Make sure polarify(lift=True) doesn't try to lift the integration
# variable
assert polarify(
Integral(
sqrt(2) * x * exp(-(-mu + x)**2 / (2 * sigma**2)) /
(2 * sqrt(pi) * sigma), (x, -oo, oo)),
lift=True) == Integral(
sqrt(2) * (sigma * exp_polar(0))**exp_polar(I * pi) * exp(
(sigma * exp_polar(0))**(2 * exp_polar(I * pi)) * exp_polar(
I * pi) * polar_lift(-mu + x)**(2 * exp_polar(0)) / 2) *
exp_polar(0) * polar_lift(x) / (2 * sqrt(pi)), (x, -oo, oo))
def test_principal_branch():
p = Symbol('p', positive=True)
neg = Symbol('x', negative=True)
assert principal_branch(polar_lift(x), p) == principal_branch(x, p)
assert principal_branch(polar_lift(2 + I), p) == principal_branch(2 + I, p)
assert principal_branch(2*x, p) == 2*principal_branch(x, p)
assert principal_branch(1, pi) == exp_polar(0)
assert principal_branch(-1, 2*pi) == exp_polar(I*pi)
assert principal_branch(-1, pi) == exp_polar(0)
assert principal_branch(exp_polar(3*pi*I)*x, 2*pi) == \
principal_branch(exp_polar(I*pi)*x, 2*pi)
assert principal_branch(neg*exp_polar(pi*I), 2*pi) == neg*exp_polar(-I*pi)
assert N_equals(principal_branch((1 + I)**2, 2*pi), 2*I)
assert N_equals(principal_branch((1 + I)**2, 3*pi), 2*I)
assert N_equals(principal_branch((1 + I)**2, 1*pi), 2*I)
# test argument sanitization
assert isinstance(principal_branch(x, I), principal_branch)
assert isinstance(principal_branch(x, -4), principal_branch)
assert isinstance(principal_branch(x, -oo), principal_branch)
assert isinstance(principal_branch(x, zoo), principal_branch)
assert (principal_branch((4 + I)**2, 2*pi).evalf() ==
principal_branch((4 + I)**2, 2*pi))
def test_exp_log():
x = Symbol("x", extended_real=True)
assert log(exp(x)) == x
assert exp(log(x)) == x
assert log(x).inverse() == exp
y = Symbol("y", polar=True)
assert log(exp_polar(z)) == z
assert exp(log(y)) == y
def test_exp_log():
x = Symbol("x", extended_real=True)
assert log(exp(x)) == x
assert exp(log(x)) == x
assert log(x).inverse() == exp
y = Symbol("y", polar=True)
assert log(exp_polar(z)) == z
assert exp(log(y)) == y
def test_lowergamma():
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)*polygamma(0, x) - uppergamma(x, y)*log(y) \
- meijerg([], [1, 1], [0, 0, x], [], y)
pytest.raises(ArgumentIndexError, lambda: lowergamma(x, y).fdiff(3))
assert lowergamma(Rational(1, 2), x) == sqrt(pi)*erf(sqrt(x))
assert not lowergamma(Rational(1, 2) - 3, x).has(lowergamma)
assert not lowergamma(Rational(1, 2) + 3, x).has(lowergamma)
assert lowergamma(Rational(1, 2), x, evaluate=False).has(lowergamma)
assert tn(lowergamma(Rational(1, 2) + 3, x, evaluate=False),
lowergamma(Rational(1, 2) + 3, x), x)
assert tn(lowergamma(Rational(1, 2) - 3, x, evaluate=False),
lowergamma(Rational(1, 2) - 3, x), x)
assert lowergamma(0, 1) == zoo
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)) == conjugate(lowergamma(x, 0))
assert conjugate(lowergamma(x, -oo)) == 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 (x*lowergamma(x, 1)/gamma(x + 1)).limit(x, 0) == 1
def test_si():
assert Si(I*x) == I*Shi(x)
assert Shi(I*x) == I*Si(x)
assert Si(-I*x) == -I*Shi(x)
assert Shi(-I*x) == -I*Si(x)
assert Si(-x) == -Si(x)
assert Shi(-x) == -Shi(x)
assert Si(exp_polar(2*pi*I)*x) == Si(x)
assert Si(exp_polar(-2*pi*I)*x) == Si(x)
assert Shi(exp_polar(2*pi*I)*x) == Shi(x)
assert Shi(exp_polar(-2*pi*I)*x) == Shi(x)
assert Si(oo) == pi/2
assert Si(-oo) == -pi/2
assert Shi(oo) == oo
assert Shi(-oo) == -oo
assert mytd(Si(x), sin(x)/x, x)
assert mytd(Shi(x), sinh(x)/x, x)
assert mytn(Si(x), Si(x).rewrite(Ei),
-I*(-Ei(x*exp_polar(-I*pi/2))/2
+ Ei(x*exp_polar(I*pi/2))/2 - I*pi) + pi/2, x)
assert mytn(Si(x), Si(x).rewrite(expint),
-I*(-expint(1, x*exp_polar(-I*pi/2))/2 +
expint(1, x*exp_polar(I*pi/2))/2) + pi/2, x)
assert mytn(Shi(x), Shi(x).rewrite(Ei),
Ei(x)/2 - Ei(x*exp_polar(I*pi))/2 + I*pi/2, x)
assert mytn(Shi(x), Shi(x).rewrite(expint),
expint(1, x)/2 - expint(1, x*exp_polar(I*pi))/2 - I*pi/2, x)
assert tn_arg(Si)
assert tn_arg(Shi)
assert Si(x).nseries(x, n=8) == \
x - x**3/18 + x**5/600 - x**7/35280 + O(x**9)
assert Shi(x).nseries(x, n=8) == \
x + x**3/18 + x**5/600 + x**7/35280 + O(x**9)
assert Si(sin(x)).nseries(x, n=5) == x - 2*x**3/9 + 17*x**5/450 + O(x**7)
assert Si(x).series(x, 1, n=3) == \
Si(1) + (x - 1)*sin(1) + (x - 1)**2*(-sin(1)/2 + cos(1)/2) + O((x - 1)**3, (x, 1))
pytest.raises(ArgumentIndexError, lambda: Si(z).fdiff(2))
def test_lerchphi():
assert hyperexpand(hyper([1, a], [a + 1], z)/a) == lerchphi(z, 1, a)
assert hyperexpand(
hyper([1, a, a], [a + 1, a + 1], z)/a**2) == lerchphi(z, 2, a)
assert hyperexpand(hyper([1, a, a, a], [a + 1, a + 1, a + 1], z)/a**3) == \
lerchphi(z, 3, a)
assert hyperexpand(hyper([1] + [a]*10, [a + 1]*10, z)/a**10) == \
lerchphi(z, 10, a)
assert combsimp(hyperexpand(meijerg([0, 1 - a], [], [0],
[-a], exp_polar(-I*pi)*z))) == lerchphi(z, 1, a)
assert combsimp(hyperexpand(meijerg([0, 1 - a, 1 - a], [], [0],
[-a, -a], exp_polar(-I*pi)*z))) == lerchphi(z, 2, a)
assert combsimp(hyperexpand(meijerg([0, 1 - a, 1 - a, 1 - a], [], [0],
[-a, -a, -a], exp_polar(-I*pi)*z))) == lerchphi(z, 3, a)
assert hyperexpand(z*hyper([1, 1], [2], z)) == -log(1 + -z)
assert hyperexpand(z*hyper([1, 1, 1], [2, 2], z)) == polylog(2, z)
assert hyperexpand(z*hyper([1, 1, 1, 1], [2, 2, 2], z)) == polylog(3, z)
assert hyperexpand(hyper([1, a, 1 + Rational(1, 2)], [a + 1, Rational(1, 2)], z)) == \
-2*a/(z - 1) + (-2*a**2 + a)*lerchphi(z, 1, a)
# Now numerical tests. These make sure reductions etc are carried out
# correctly
# a rational function (polylog at negative integer order)
assert can_do([2, 2, 2], [1, 1])
# NOTE these contain log(1-x) etc ... better make sure we have |z| < 1
# reduction of order for polylog
assert can_do([1, 1, 1, b + 5], [2, 2, b], div=10)
# reduction of order for lerchphi
# XXX lerchphi in mpmath is flaky
assert can_do(
[1, a, a, a, b + 5], [a + 1, a + 1, a + 1, b], numerical=False)
# test a bug
assert hyperexpand(hyper([Rational(1, 2), Rational(1, 2), Rational(1, 2), 1],
[Rational(3, 2), Rational(3, 2), Rational(3, 2)], Rational(1, 4))) == \
abs(-polylog(3, exp_polar(I*pi)/2) + polylog(3, Rational(1, 2)))
def test_polarify():
z = Symbol('z', polar=True)
f = Function('f')
ES = {}
assert polarify(-1) == (polar_lift(-1), ES)
assert polarify(1 + I) == (polar_lift(1 + I), ES)
assert polarify(exp(x), subs=False) == exp(x)
assert polarify(1 + x, subs=False) == 1 + x
assert polarify(f(I) + x, subs=False) == f(polar_lift(I)) + x
assert polarify(x, lift=True) == polar_lift(x)
assert polarify(z, lift=True) == z
assert polarify(f(x), lift=True) == f(polar_lift(x))
assert polarify(1 + x, lift=True) == polar_lift(1 + x)
assert polarify(1 + f(x), lift=True) == polar_lift(1 + f(polar_lift(x)))
newex, subs = polarify(f(x) + z)
assert newex.subs(subs) == f(x) + z
mu = Symbol("mu")
sigma = Symbol("sigma", positive=True)
# Make sure polarify(lift=True) doesn't try to lift the integration
# variable
assert polarify(
Integral(sqrt(2)*x*exp(-(-mu + x)**2/(2*sigma**2))/(2*sqrt(pi)*sigma),
(x, -oo, oo)), lift=True) == Integral(sqrt(2)*(sigma*exp_polar(0))**exp_polar(I*pi) *
exp((sigma*exp_polar(0))**(2*exp_polar(I*pi))*exp_polar(I*pi)*polar_lift(-mu + x) **
(2*exp_polar(0))/2)*exp_polar(0)*polar_lift(x)/(2*sqrt(pi)), (x, -oo, oo))
def test_unpolarify():
p = exp_polar(7*I) + 1
u = exp(7*I) + 1
assert unpolarify(1) == 1
assert unpolarify(p) == u
assert unpolarify(p**2) == u**2
assert unpolarify(p**x) == p**x
assert unpolarify(p*x) == u*x
assert unpolarify(p + x) == u + x
assert unpolarify(sqrt(sin(p))) == sqrt(sin(u))
# Test reduction to principal branch 2*pi.
t = principal_branch(x, 2*pi)
assert unpolarify(t) == x
assert unpolarify(sqrt(t)) == sqrt(t)
# Test exponents_only.
assert unpolarify(p**p, exponents_only=True) == p**u
assert unpolarify(uppergamma(x, p**p)) == uppergamma(x, p**u)
# Test functions.
assert unpolarify(sin(p)) == sin(u)
assert unpolarify(tanh(p)) == tanh(u)
assert unpolarify(gamma(p)) == gamma(u)
assert unpolarify(erf(p)) == erf(u)
assert unpolarify(uppergamma(x, p)) == uppergamma(x, p)
assert unpolarify(uppergamma(sin(p), sin(p + exp_polar(0)))) == \
uppergamma(sin(u), sin(u + 1))
assert unpolarify(uppergamma(polar_lift(0), 2*exp_polar(0))) == \
uppergamma(0, 2)
assert unpolarify(Eq(p, 0)) == Eq(u, 0)
assert unpolarify(Ne(p, 0)) == Ne(u, 0)
assert unpolarify(polar_lift(x) > 0) == (x > 0)
# Test bools
assert unpolarify(True) is True
def test_expint():
assert mytn(expint(x, y), expint(x, y).rewrite(uppergamma),
y**(x - 1)*uppergamma(1 - x, y), x)
assert mytd(
expint(x, y), -y**(x - 1)*meijerg([], [1, 1], [0, 0, 1 - x], [], y), x)
assert mytd(expint(x, y), -expint(x - 1, y), y)
assert mytn(expint(1, x), expint(1, x).rewrite(Ei),
-Ei(x*polar_lift(-1)) + I*pi, x)
assert expint(-4, x) == exp(-x)/x + 4*exp(-x)/x**2 + 12*exp(-x)/x**3 \
+ 24*exp(-x)/x**4 + 24*exp(-x)/x**5
assert expint(-Rational(3, 2), x) == \
exp(-x)/x + 3*exp(-x)/(2*x**2) - 3*sqrt(pi)*erf(sqrt(x))/(4*x**Rational(5, 2)) \
+ 3*sqrt(pi)/(4*x**Rational(5, 2))
assert tn_branch(expint, 1)
assert tn_branch(expint, 2)
assert tn_branch(expint, 3)
assert tn_branch(expint, 1.7)
assert tn_branch(expint, pi)
assert expint(y, x*exp_polar(2*I*pi)) == \
x**(y - 1)*(exp(2*I*pi*y) - 1)*gamma(-y + 1) + expint(y, x)
assert expint(y, x*exp_polar(-2*I*pi)) == \
x**(y - 1)*(exp(-2*I*pi*y) - 1)*gamma(-y + 1) + expint(y, x)
assert expint(2, x*exp_polar(2*I*pi)) == 2*I*pi*x + expint(2, x)
assert expint(2, x*exp_polar(-2*I*pi)) == -2*I*pi*x + expint(2, x)
assert (expint(n, x*exp_polar(2*I*pi)) ==
expint(n, x*exp_polar(2*I*pi), evaluate=False))
assert expint(1, x).rewrite(Ei).rewrite(expint) == expint(1, x)
assert (expint(2, x, evaluate=False).rewrite(Shi) ==
expint(2, x, evaluate=False))
assert mytn(E1(x), E1(x).rewrite(Shi), Shi(x) - Chi(x), x)
assert mytn(E1(polar_lift(I)*x), E1(polar_lift(I)*x).rewrite(Si),
-Ci(x) + I*Si(x) - I*pi/2, x)
assert mytn(expint(2, x), expint(2, x).rewrite(Ei).rewrite(expint),
-x*E1(x) + exp(-x), x)
assert mytn(expint(3, x), expint(3, x).rewrite(Ei).rewrite(expint),
x**2*E1(x)/2 + (1 - x)*exp(-x)/2, x)
assert expint(Rational(3, 2), z).nseries(z, n=10) == \
2 + 2*z - z**2/3 + z**3/15 - z**4/84 + z**5/540 - \
2*sqrt(pi)*sqrt(z) + O(z**6)
assert E1(z).series(z) == -EulerGamma - log(z) + z - \
z**2/4 + z**3/18 - z**4/96 + z**5/600 + O(z**6)
assert expint(4, z).series(z) == Rational(1, 3) - z/2 + z**2/2 + \
z**3*(log(z)/6 - Rational(11, 36) + EulerGamma/6) - z**4/24 + \
z**5/240 + O(z**6)
assert (expint(x, x).series(x, x0=1, n=2) ==
expint(1, 1) + (x - 1)*(-meijerg(((), (1, 1)),
((0, 0, 0), ()), 1) - 1/E) +
O((x - 1)**2, (x, 1)))
pytest.raises(ArgumentIndexError, lambda: expint(x, y).fdiff(3))
def test_rewrite_single():
def t(expr, c, m):
e = _rewrite_single(meijerg([a], [b], [c], [d], expr), x)
assert e is not None
assert isinstance(e[0][0][2], meijerg)
assert e[0][0][2].argument.as_coeff_mul(x) == (c, (m,))
def tn(expr):
assert _rewrite_single(meijerg([a], [b], [c], [d], expr), x) is None
t(x, 1, x)
t(x**2, 1, x**2)
t(x**2 + y*x**2, y + 1, x**2)
tn(x**2 + x)
tn(x**y)
def u(expr, x):
r = _rewrite_single(expr, x)
e = Add(*[res[0]*res[2] for res in r[0]]).replace(
exp_polar, exp) # XXX Hack?
assert verify_numerically(e, expr, x)
u(exp(-x)*sin(x), x)
# The following has stopped working because hyperexpand changed slightly.
# It is probably not worth fixing
# u(exp(-x)*sin(x)*cos(x), x)
# This one cannot be done numerically, since it comes out as a g-function
# of argument 4*pi
# NOTE This also tests a bug in inverse mellin transform (which used to
# turn exp(4*pi*I*t) into a factor of exp(4*pi*I)**t instead of
# exp_polar).
# u(exp(x)*sin(x), x)
assert _rewrite_single(exp(x)*sin(x), x) == \
([(-sqrt(2)/(2*sqrt(pi)), 0,
meijerg(((-Rational(1, 2), 0, Rational(1, 4), Rational(1, 2), Rational(3, 4)), (1,)),
((), (-Rational(1, 2), 0)), 64*exp_polar(-4*I*pi)/x**4))], True)
def test_ci():
m1 = exp_polar(I*pi)
m1_ = exp_polar(-I*pi)
pI = exp_polar(I*pi/2)
mI = exp_polar(-I*pi/2)
assert Ci(m1*x) == Ci(x) + I*pi
assert Ci(m1_*x) == Ci(x) - I*pi
assert Ci(pI*x) == Chi(x) + I*pi/2
assert Ci(mI*x) == Chi(x) - I*pi/2
assert Chi(m1*x) == Chi(x) + I*pi
assert Chi(m1_*x) == Chi(x) - I*pi
assert Chi(pI*x) == Ci(x) + I*pi/2
assert Chi(mI*x) == Ci(x) - I*pi/2
assert Ci(exp_polar(2*I*pi)*x) == Ci(x) + 2*I*pi
assert Chi(exp_polar(-2*I*pi)*x) == Chi(x) - 2*I*pi
assert Chi(exp_polar(2*I*pi)*x) == Chi(x) + 2*I*pi
assert Ci(exp_polar(-2*I*pi)*x) == Ci(x) - 2*I*pi
assert Ci(oo) == 0
assert Ci(-oo) == I*pi
assert Chi(oo) == oo
assert Chi(-oo) == oo
assert mytd(Ci(x), cos(x)/x, x)
assert mytd(Chi(x), cosh(x)/x, x)
assert mytn(Ci(x), Ci(x).rewrite(Ei),
Ei(x*exp_polar(-I*pi/2))/2 + Ei(x*exp_polar(I*pi/2))/2, x)
assert mytn(Chi(x), Chi(x).rewrite(Ei),
Ei(x)/2 + Ei(x*exp_polar(I*pi))/2 - I*pi/2, x)
assert tn_arg(Ci)
assert tn_arg(Chi)
assert Ci(x).nseries(x, n=4) == \
EulerGamma + log(x) - x**2/4 + x**4/96 + O(x**6)
assert Chi(x).nseries(x, n=4) == \
EulerGamma + log(x) + x**2/4 + x**4/96 + O(x**6)
assert limit(log(x) - Ci(2*x), x, 0) == -log(2) - EulerGamma
def dosubs(func, a, b):
rv = func.subs({z: exp_polar(a)*z}).rewrite('nonrep')
return rv.subs({z: exp_polar(b)*z}).replace(exp_polar, exp)
def test_powsimp_polar():
p, q, r = symbols('p q r', polar=True)
assert (polar_lift(-1))**(2*x) == exp_polar(2*pi*I*x)
assert powsimp(p**x * q**x) == (p*q)**x
assert p**x * (1/p)**x == 1
assert (1/p)**x == p**(-x)
assert exp_polar(x)*exp_polar(y) == exp_polar(x)*exp_polar(y)
assert powsimp(exp_polar(x)*exp_polar(y)) == exp_polar(x + y)
assert powsimp(exp_polar(x)*exp_polar(y)*p**x*p**y) == \
(p*exp_polar(1))**(x + y)
assert powsimp(exp_polar(x)*exp_polar(y)*p**x*p**y, combine='exp') == \
exp_polar(x + y)*p**(x + y)
assert powsimp(
exp_polar(x)*exp_polar(y)*exp_polar(2)*sin(x) + sin(y) + p**x*p**y) \
== p**(x + y) + sin(x)*exp_polar(2 + x + y) + sin(y)
assert powsimp(sin(exp_polar(x)*exp_polar(y))) == \
sin(exp_polar(x)*exp_polar(y))
assert powsimp(sin(exp_polar(x)*exp_polar(y)), deep=True) == \
sin(exp_polar(x + y))
def test_evalf():
assert hyper((-1, 1), (-1,), 1).evalf() == Float('2.0')
e = meijerg([], [], [], [], (exp_polar(-I*pi))*cos(exp_polar(-I*pi)))
assert e.evalf() == e
def tn(func, s):
c = uniform(1, 5)
expr = func(s, c*exp_polar(I*pi)) - func(s, c*exp_polar(-I*pi))
eps = 1e-15
expr2 = func(s + eps, -c + eps*I) - func(s + eps, -c - eps*I)
return abs(expr - expr2).evalf(strict=False) < 1e-10
def test_hyperrep():
# First test the base class works.
a, b, c, d, z = symbols('a b c d z')
class myrep(HyperRep):
@classmethod
def _expr_small(cls, x):
return a
@classmethod
def _expr_small_minus(cls, x):
return b
@classmethod
def _expr_big(cls, x, n):
return c*n
@classmethod
def _expr_big_minus(cls, x, n):
return d*n
assert myrep(z).rewrite('nonrep') == Piecewise((0, abs(z) > 1), (a, True))
assert myrep(exp_polar(I*pi)*z).rewrite('nonrep') == \
Piecewise((0, abs(z) > 1), (b, True))
assert myrep(exp_polar(2*I*pi)*z).rewrite('nonrep') == \
Piecewise((c, abs(z) > 1), (a, True))
assert myrep(exp_polar(3*I*pi)*z).rewrite('nonrep') == \
Piecewise((d, abs(z) > 1), (b, True))
assert myrep(exp_polar(4*I*pi)*z).rewrite('nonrep') == \
Piecewise((2*c, abs(z) > 1), (a, True))
assert myrep(exp_polar(5*I*pi)*z).rewrite('nonrep') == \
Piecewise((2*d, abs(z) > 1), (b, True))
assert myrep(z).rewrite('nonrepsmall') == a
assert myrep(exp_polar(I*pi)*z).rewrite('nonrepsmall') == b
def t(func, hyp, z):
""" Test that func is a valid representation of hyp. """
# First test that func agrees with hyp for small z
if not tn(func.rewrite('nonrepsmall'), hyp, z,
a=Rational(-1, 2), b=Rational(-1, 2), c=Rational(1, 2), d=Rational(1, 2)):
return False
# Next check that the two small representations agree.
if not tn(
func.rewrite('nonrepsmall').subs({z: exp_polar(I*pi)*z}).replace(exp_polar, exp),
func.subs({z: exp_polar(I*pi)*z}).rewrite('nonrepsmall'),
z, a=Rational(-1, 2), b=Rational(-1, 2), c=Rational(1, 2), d=Rational(1, 2)):
return False
# Next check continuity along exp_polar(I*pi)*t
expr = func.subs({z: exp_polar(I*pi)*z}).rewrite('nonrep')
if abs(expr.subs({z: 1 + 1e-15}) - expr.subs({z: 1 - 1e-15})).evalf(strict=False) > 1e-10:
return False
# Finally check continuity of the big reps.
def dosubs(func, a, b):
rv = func.subs({z: exp_polar(a)*z}).rewrite('nonrep')
return rv.subs({z: exp_polar(b)*z}).replace(exp_polar, exp)
for n in [0, 1, 2, 3, 4, -1, -2, -3, -4]:
expr1 = dosubs(func, 2*I*pi*n, I*pi/2)
expr2 = dosubs(func, 2*I*pi*n + I*pi, -I*pi/2)
if not tn(expr1, expr2, z):
return False
expr1 = dosubs(func, 2*I*pi*(n + 1), -I*pi/2)
expr2 = dosubs(func, 2*I*pi*n + I*pi, I*pi/2)
if not tn(expr1, expr2, z):
return False
return True
# Now test the various representatives.
a = Rational(1, 3)
assert t(HyperRep_atanh(z), hyper([Rational(1, 2), 1], [Rational(3, 2)], z), z)
assert t(HyperRep_power1(a, z), hyper([-a], [], z), z)
assert t(HyperRep_power2(a, z), hyper([a, a - Rational(1, 2)], [2*a], z), z)
assert t(HyperRep_log1(z), -z*hyper([1, 1], [2], z), z)
assert t(HyperRep_asin1(z), hyper([Rational(1, 2), Rational(1, 2)], [Rational(3, 2)], z), z)
assert t(HyperRep_asin2(z), hyper([1, 1], [Rational(3, 2)], z), z)
assert t(HyperRep_sqrts1(a, z), hyper([-a, Rational(1, 2) - a], [Rational(1, 2)], z), z)
assert t(HyperRep_sqrts2(a, z),
-2*z/(2*a + 1)*hyper([-a - Rational(1, 2), -a], [Rational(1, 2)], z).diff(z), z)
assert t(HyperRep_log2(z), -z/4*hyper([Rational(3, 2), 1, 1], [2, 2], z), z)
assert t(HyperRep_cosasin(a, z), hyper([-a, a], [Rational(1, 2)], z), z)
assert t(HyperRep_sinasin(a, z), 2*a*z*hyper([1 - a, 1 + a], [Rational(3, 2)], z), z)
def test_polar():
x, y = symbols('x y', polar=True)
assert abs(exp_polar(I*4)) == 1
assert exp_polar(I*10).evalf() == exp_polar(I*10)
assert log(exp_polar(z)) == z
assert log(x*y).expand() == log(x) + log(y)
assert log(x**z).expand() == z*log(x)
assert exp_polar(3).exp == 3
# Compare exp(1.0*pi*I).
assert (exp_polar(1.0*pi*I).evalf(5)).as_real_imag()[1] >= 0
assert exp_polar(0).is_rational is True # issue sympy/sympy#8008
nz = Symbol('nz', rational=True, nonzero=True)
assert exp_polar(nz).is_rational is False
assert exp_polar(oo).is_finite is False
assert exp_polar(-oo).is_finite
assert exp_polar(zoo).is_finite is None
assert exp_polar(-oo).is_zero
ninf = Symbol('ninf', infinite=True, negative=True)
assert exp_polar(ninf).is_zero
r = Symbol('r', extended_real=True)
assert exp_polar(r).is_extended_real
assert exp_polar(x).is_extended_real is None
def test_meijerg_expand():
# from mpmath docs
assert hyperexpand(meijerg([[], []], [[0], []], -z)) == exp(z)
assert hyperexpand(meijerg([[1, 1], []], [[1], [0]], z)) == \
log(z + 1)
assert hyperexpand(meijerg([[1, 1], []], [[1], [1]], z)) == \
z/(z + 1)
assert hyperexpand(meijerg([[], []], [[Rational(1, 2)], [0]], (z/2)**2)) \
== sin(z)/sqrt(pi)
assert hyperexpand(meijerg([[], []], [[0], [Rational(1, 2)]], (z/2)**2)) \
== cos(z)/sqrt(pi)
assert can_do_meijer([], [a], [a - 1, a - Rational(1, 2)], [])
assert can_do_meijer([], [], [a/2], [-a/2], False) # branches...
assert can_do_meijer([a], [b], [a], [b, a - 1])
# wikipedia
assert hyperexpand(meijerg([1], [], [], [0], z)) == \
Piecewise((0, abs(z) < 1), (1, abs(1/z) < 1),
(meijerg([1], [], [], [0], z), True))
assert hyperexpand(meijerg([], [1], [0], [], z)) == \
Piecewise((1, abs(z) < 1), (0, abs(1/z) < 1),
(meijerg([], [1], [0], [], z), True))
# The Special Functions and their Approximations
assert can_do_meijer([], [], [a + b/2], [a, a - b/2, a + Rational(1, 2)])
assert can_do_meijer(
[], [], [a], [b], False) # branches only agree for small z
assert can_do_meijer([], [Rational(1, 2)], [a], [-a])
assert can_do_meijer([], [], [a, b], [])
assert can_do_meijer([], [], [a, b], [])
assert can_do_meijer([], [], [a, a + Rational(1, 2)], [b, b + Rational(1, 2)])
assert can_do_meijer([], [], [a, -a], [0, Rational(1, 2)], False) # dito
assert can_do_meijer([], [], [a, a + Rational(1, 2), b, b + Rational(1, 2)], [])
assert can_do_meijer([Rational(1, 2)], [], [0], [a, -a])
assert can_do_meijer([Rational(1, 2)], [], [a], [0, -a], False) # dito
assert can_do_meijer([], [a - Rational(1, 2)], [a, b], [a - Rational(1, 2)], False)
assert can_do_meijer([], [a + Rational(1, 2)], [a + b, a - b, a], [], False)
assert can_do_meijer([a + Rational(1, 2)], [], [b, 2*a - b, a], [], False)
# This for example is actually zero.
assert can_do_meijer([], [], [], [a, b])
# Testing a bug:
assert hyperexpand(meijerg([0, 2], [], [], [-1, 1], z)) == \
Piecewise((0, abs(z) < 1),
(z/2 - 1/(2*z), abs(1/z) < 1),
(meijerg([0, 2], [], [], [-1, 1], z), True))
# Test that the simplest possible answer is returned:
assert combsimp(simplify(hyperexpand(
meijerg([1], [1 - a], [-a/2, -a/2 + Rational(1, 2)], [], 1/z)))) == \
-2*sqrt(pi)*(sqrt(z + 1) + 1)**a/a
# Test that hyper is returned
assert hyperexpand(meijerg([1], [], [a], [0, 0], z)) == hyper(
(a,), (a + 1, a + 1), z*exp_polar(I*pi))*z**a*gamma(a)/gamma(a + 1)**2
assert can_do_meijer([], [], [a + Rational(1, 2)], [a, a - b/2, a + b/2])
assert can_do_meijer([], [], [3*a - Rational(1, 2), a, -a - Rational(1, 2)], [a - Rational(1, 2)])
assert can_do_meijer([], [], [0, a - Rational(1, 2), -a - Rational(1, 2)], [Rational(1, 2)])
assert can_do_meijer([Rational(1, 2)], [], [-a, a], [0])
def test_sign():
assert sign(1.2) == 1
assert sign(-1.2) == -1
assert sign(3*I) == I
assert sign(-3*I) == -I
assert sign(0) == 0
assert sign(nan) == nan
assert sign(2 + 2*I).doit() == sqrt(2)*(2 + 2*I)/4
assert sign(2 + 3*I).simplify() == sign(2 + 3*I)
assert sign(2 + 2*I).simplify() == sign(1 + I)
assert sign(im(sqrt(1 - sqrt(3)))) == 1
assert sign(sqrt(1 - sqrt(3))) == I
x = Symbol('x')
assert sign(x).is_finite is True
assert sign(x).is_complex is True
assert sign(x).is_imaginary is None
assert sign(x).is_integer is None
assert sign(x).is_extended_real is None
assert sign(x).is_zero is None
assert sign(x).doit() == sign(x)
assert sign(1.2*x) == sign(x)
assert sign(2*x) == sign(x)
assert sign(I*x) == I*sign(x)
assert sign(-2*I*x) == -I*sign(x)
assert sign(conjugate(x)) == conjugate(sign(x))
p = Symbol('p', positive=True)
n = Symbol('n', negative=True)
m = Symbol('m', negative=True)
assert sign(2*p*x) == sign(x)
assert sign(n*x) == -sign(x)
assert sign(n*m*x) == sign(x)
x = Symbol('x', imaginary=True)
xn = Symbol('xn', imaginary=True, nonzero=True)
assert sign(x).is_imaginary is True
assert sign(x).is_integer is None
assert sign(x).is_extended_real is None
assert sign(x).is_zero is None
assert sign(x).diff(x) == 2*DiracDelta(-I*x)
assert sign(xn).doit() == xn / Abs(xn)
assert conjugate(sign(x)) == -sign(x)
x = Symbol('x', extended_real=True)
assert sign(x).is_imaginary is None
assert sign(x).is_integer is True
assert sign(x).is_extended_real is True
assert sign(x).is_zero is None
assert sign(x).diff(x) == 2*DiracDelta(x)
assert sign(x).doit() == sign(x)
assert conjugate(sign(x)) == sign(x)
assert sign(sin(x)).nseries(x) == 1
y = Symbol('y')
assert sign(x*y).nseries(x).removeO() == sign(y)
x = Symbol('x', nonzero=True)
assert sign(x).is_imaginary is None
assert sign(x).is_integer is None
assert sign(x).is_extended_real is None
assert sign(x).is_zero is False
assert sign(x).doit() == x / Abs(x)
assert sign(Abs(x)) == 1
assert Abs(sign(x)) == 1
x = Symbol('x', positive=True)
assert sign(x).is_imaginary is False
assert sign(x).is_integer is True
assert sign(x).is_extended_real is True
assert sign(x).is_zero is False
assert sign(x).doit() == x / Abs(x)
assert sign(Abs(x)) == 1
assert Abs(sign(x)) == 1
x = 0
assert sign(x).is_imaginary is True
assert sign(x).is_integer is True
assert sign(x).is_extended_real is True
assert sign(x).is_zero is True
assert sign(x).doit() == 0
assert sign(Abs(x)) == 0
assert Abs(sign(x)) == 0
nz = Symbol('nz', nonzero=True, integer=True)
assert sign(nz).is_imaginary is False
assert sign(nz).is_integer is True
assert sign(nz).is_extended_real is True
assert sign(nz).is_zero is False
assert sign(nz)**2 == 1
assert (sign(nz)**3).args == (sign(nz), 3)
assert sign(Symbol('x', nonnegative=True)).is_nonnegative
assert sign(Symbol('x', nonnegative=True)).is_nonpositive is None
assert sign(Symbol('x', nonpositive=True)).is_nonnegative is None
assert sign(Symbol('x', nonpositive=True)).is_nonpositive
assert sign(Symbol('x', extended_real=True)).is_nonnegative is None
assert sign(Symbol('x', extended_real=True)).is_nonpositive is None
assert sign(Symbol('x', extended_real=True, zero=False)).is_nonpositive is None
x, y = Symbol('x', extended_real=True), Symbol('y')
assert sign(x).rewrite(Piecewise) == \
Piecewise((1, x > 0), (-1, x < 0), (0, True))
assert sign(y).rewrite(Piecewise) == sign(y)
assert sign(x).rewrite(Heaviside) == 2*Heaviside(x)-1
assert sign(y).rewrite(Heaviside) == sign(y)
# evaluate what can be evaluated
assert sign(exp_polar(I*pi)*pi) is Integer(-1)
eq = -sqrt(10 + 6*sqrt(3)) + sqrt(1 + sqrt(3)) + sqrt(3 + 3*sqrt(3))
# if there is a fast way to know when and when you cannot prove an
# expression like this is zero then the equality to zero is ok
assert sign(eq) == 0
q = 1 + sqrt(2) - 2*sqrt(3) + 1331*sqrt(6)
p = cbrt(expand(q**3))
d = p - q
assert sign(d) == 0
assert abs(sign(z)) == Abs(sign(z), evaluate=False)
def test_polylog_eval():
assert polylog(s, 0) == 0
assert polylog(s, 1) == zeta(s)
assert polylog(s, -1) == -dirichlet_eta(s)
assert polylog(s, exp_polar(I*pi)) == polylog(s, -1)
assert polylog(s, 2*exp_polar(2*I*pi)) == polylog(s, 2*exp_polar(2*I*pi), evaluate=False)
def test_minimal_polynomial():
assert minimal_polynomial(-7)(x) == x + 7
assert minimal_polynomial(-1)(x) == x + 1
assert minimal_polynomial( 0)(x) == x
assert minimal_polynomial( 1)(x) == x - 1
assert minimal_polynomial( 7)(x) == x - 7
assert minimal_polynomial(Rational(1, 3), method='groebner')(x) == 3*x - 1
pytest.raises(NotAlgebraic,
lambda: minimal_polynomial(pi, method='groebner'))
pytest.raises(NotAlgebraic,
lambda: minimal_polynomial(sin(sqrt(2)), method='groebner'))
pytest.raises(NotAlgebraic,
lambda: minimal_polynomial(2**pi, method='groebner'))
pytest.raises(ValueError, lambda: minimal_polynomial(1, method='spam'))
assert minimal_polynomial(sqrt(2))(x) == x**2 - 2
assert minimal_polynomial(sqrt(5))(x) == x**2 - 5
assert minimal_polynomial(sqrt(6))(x) == x**2 - 6
assert minimal_polynomial(2*sqrt(2))(x) == x**2 - 8
assert minimal_polynomial(3*sqrt(5))(x) == x**2 - 45
assert minimal_polynomial(4*sqrt(6))(x) == x**2 - 96
assert minimal_polynomial(2*sqrt(2) + 3)(x) == x**2 - 6*x + 1
assert minimal_polynomial(3*sqrt(5) + 6)(x) == x**2 - 12*x - 9
assert minimal_polynomial(4*sqrt(6) + 7)(x) == x**2 - 14*x - 47
assert minimal_polynomial(2*sqrt(2) - 3)(x) == x**2 + 6*x + 1
assert minimal_polynomial(3*sqrt(5) - 6)(x) == x**2 + 12*x - 9
assert minimal_polynomial(4*sqrt(6) - 7)(x) == x**2 + 14*x - 47
assert minimal_polynomial(sqrt(1 + sqrt(6)))(x) == x**4 - 2*x**2 - 5
assert minimal_polynomial(sqrt(I + sqrt(6)))(x) == x**8 - 10*x**4 + 49
assert minimal_polynomial(2*I + sqrt(2 + I))(x) == x**4 + 4*x**2 + 8*x + 37
assert minimal_polynomial(sqrt(2) + sqrt(3))(x) == x**4 - 10*x**2 + 1
assert minimal_polynomial(sqrt(2) + sqrt(3) + sqrt(6))(x) == x**4 - 22*x**2 - 48*x - 23
e = 1/sqrt(sqrt(1 + sqrt(3)) - 4)
assert minimal_polynomial(e) == minimal_polynomial(e, method='groebner')
assert minimal_polynomial(e)(x) == (222*x**8 + 240*x**6 +
94*x**4 + 16*x**2 + 1)
a = 1 - 9*sqrt(2) + 7*sqrt(3)
assert minimal_polynomial(1/a)(x) == 392*x**4 - 1232*x**3 + 612*x**2 + 4*x - 1
assert minimal_polynomial(1/sqrt(a))(x) == 392*x**8 - 1232*x**6 + 612*x**4 + 4*x**2 - 1
pytest.raises(NotAlgebraic, lambda: minimal_polynomial(oo))
pytest.raises(NotAlgebraic, lambda: minimal_polynomial(2**y))
pytest.raises(NotAlgebraic, lambda: minimal_polynomial(sin(1)))
assert minimal_polynomial(sqrt(2))(x) == x**2 - 2
assert minimal_polynomial(sqrt(2)) == PurePoly(x**2 - 2)
assert minimal_polynomial(sqrt(2), method='groebner') == PurePoly(x**2 - 2)
a = sqrt(2)
b = sqrt(3)
assert minimal_polynomial(b)(x) == x**2 - 3
assert minimal_polynomial(a) == PurePoly(x**2 - 2)
assert minimal_polynomial(b) == PurePoly(x**2 - 3)
assert minimal_polynomial(sqrt(a)) == PurePoly(x**4 - 2)
assert minimal_polynomial(a + 1) == PurePoly(x**2 - 2*x - 1)
assert minimal_polynomial(sqrt(a/2 + 17))(x) == 2*x**4 - 68*x**2 + 577
assert minimal_polynomial(sqrt(b/2 + 17))(x) == 4*x**4 - 136*x**2 + 1153
# issue diofant/diofant#431
K = QQ.algebraic_field(sqrt(2))
theta = K.to_expr(K([Rational(1, 2), 17]))
assert minimal_polynomial(theta)(x) == 2*x**2 - 68*x + 577
K = QQ.algebraic_field(RootOf(x**7 + x - 1, 3))
theta = K.to_expr(K([1, 2, 0, 0, 1]))
ans = minimal_polynomial(theta)(x)
assert ans == (x**7 - 7*x**6 + 19*x**5 - 27*x**4 + 63*x**3 -
115*x**2 + 82*x - 147)
assert minimal_polynomial(theta, method='groebner')(x) == ans
K = QQ.algebraic_field(RootOf(x**5 + 5*x - 1, 2))
theta = K.to_expr(K([1, -1, 1]))
ans = (x**30 - 15*x**28 - 10*x**27 + 135*x**26 + 330*x**25 - 705*x**24 -
150*x**23 + 3165*x**22 - 6850*x**21 + 7182*x**20 + 3900*x**19 +
4435*x**18 + 11970*x**17 - 259725*x**16 - 18002*x**15 +
808215*x**14 - 200310*x**13 - 647115*x**12 + 299280*x**11 -
1999332*x**10 + 910120*x**9 + 2273040*x**8 - 5560320*x**7 +
5302000*x**6 - 2405376*x**5 + 1016640*x**4 - 804480*x**3 +
257280*x**2 - 53760*x + 1280)
assert minimal_polynomial(sqrt(theta) + root(theta, 3),
method='groebner')(x) == ans
K1 = QQ.algebraic_field(RootOf(x**3 + 4*x - 15, 1))
K2 = QQ.algebraic_field(RootOf(x**3 - x + 1, 0))
theta = sqrt(1 + 1/(K1.to_expr(K1([1, 0, 1])) +
1/(sqrt(3) + K2.to_expr(K2([1, 2, -1])))))
ans = (2262264837876687263*x**36 - 38939909597855051866*x**34 +
315720420314462950715*x**32 - 1601958657418182606114*x**30 +
5699493671077371036494*x**28 - 15096777696140985506150*x**26 +
30847690820556462893974*x**24 - 49706549068200640994022*x**22 +
64013601241426223813103*x**20 - 66358713088213594372990*x**18 +
55482571280904904971976*x**16 - 37309340229165533529076*x**14 +
20016999328983554519040*x**12 - 8446273798231518826782*x**10 +
2738866994867366499481*x**8 - 657825125060873756424*x**6 +
110036313740049140508*x**4 - 11416087328869938298*x**2 +
551322649782053543)
assert minimal_polynomial(theta)(x) == ans
a = sqrt(2)/3 + 7
f = 81*x**8 - 2268*x**6 - 4536*x**5 + 22644*x**4 + 63216*x**3 - \
31608*x**2 - 189648*x + 141358
assert minimal_polynomial(sqrt(a) + sqrt(sqrt(a)))(x) == f
assert minimal_polynomial(a**Rational(3, 2))(x) == 729*x**4 - 506898*x**2 + 84604519
K = QQ.algebraic_field(RootOf(x**3 + x - 1, 0))
a = K.to_expr(K([1, 0]))
assert minimal_polynomial(1/a**2)(x) == x**3 - x**2 - 2*x - 1
# issue sympy/sympy#5994
eq = (-1/(800*sqrt(Rational(-1, 240) + 1/(18000*cbrt(Rational(-1, 17280000) +
sqrt(15)*I/28800000)) + 2*cbrt(Rational(-1, 17280000) +
sqrt(15)*I/28800000))))
assert minimal_polynomial(eq)(x) == 8000*x**2 - 1
ex = 1 + sqrt(2) + sqrt(3)
mp = minimal_polynomial(ex)(x)
assert mp == x**4 - 4*x**3 - 4*x**2 + 16*x - 8
ex = 1/(1 + sqrt(2) + sqrt(3))
mp = minimal_polynomial(ex)(x)
assert mp == 8*x**4 - 16*x**3 + 4*x**2 + 4*x - 1
p = cbrt(expand((1 + sqrt(2) - 2*sqrt(3) + sqrt(7))**3))
mp = minimal_polynomial(p)(x)
assert mp == x**8 - 8*x**7 - 56*x**6 + 448*x**5 + 480*x**4 - 5056*x**3 + 1984*x**2 + 7424*x - 3008
p = expand((1 + sqrt(2) - 2*sqrt(3) + sqrt(7))**3)
mp = minimal_polynomial(p)(x)
assert mp == x**8 - 512*x**7 - 118208*x**6 + 31131136*x**5 + 647362560*x**4 - 56026611712*x**3 + 116994310144*x**2 + 404854931456*x - 27216576512
assert minimal_polynomial(-sqrt(5)/2 - Rational(1, 2) + (-sqrt(5)/2 - Rational(1, 2))**2)(x) == x - 1
a = 1 + sqrt(2)
assert minimal_polynomial((a*sqrt(2) + a)**3)(x) == x**2 - 198*x + 1
p = 1/(1 + sqrt(2) + sqrt(3))
assert minimal_polynomial(p, method='groebner')(x) == 8*x**4 - 16*x**3 + 4*x**2 + 4*x - 1
p = 2/(1 + sqrt(2) + sqrt(3))
assert minimal_polynomial(p, method='groebner')(x) == x**4 - 4*x**3 + 2*x**2 + 4*x - 2
assert minimal_polynomial(1 + sqrt(2)*I, method='groebner')(x) == x**2 - 2*x + 3
assert minimal_polynomial(1/(1 + sqrt(2)) + 1, method='groebner')(x) == x**2 - 2
assert minimal_polynomial(sqrt(2)*I + I*(1 + sqrt(2)),
method='groebner')(x) == x**4 + 18*x**2 + 49
assert minimal_polynomial(exp_polar(0))(x) == x - 1
def test_expand():
assert expand_func(besselj(Rational(1, 2), z).rewrite(jn)) == \
sqrt(2)*sin(z)/(sqrt(pi)*sqrt(z))
assert expand_func(bessely(Rational(1, 2), z).rewrite(yn)) == \
-sqrt(2)*cos(z)/(sqrt(pi)*sqrt(z))
assert expand_func(besselj(I, z)) == besselj(I, z)
# Test simplify helper
assert simplify(besselj(Rational(1, 2), z)) == sqrt(2)*sin(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(Rational(1, 2), 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(Rational(1, 2), 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(Rational(1, 2), 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(Rational(1, 2), 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 = Rational(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 + Rational(1, 2), z).rewrite(jn)) == \
(sqrt(2)*sqrt(z)*exp(-I*pi*(n + Rational(1, 2))/2) *
exp_polar(I*pi/4)*jn(n, z*exp_polar(I*pi/2))/sqrt(pi))
assert expand_func(besselj(n + Rational(1, 2), z).rewrite(jn)) == \
sqrt(2)*sqrt(z)*jn(n, z)/sqrt(pi)
r = Symbol('r', extended_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
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
for besselx in [bessely, besselk]:
assert besselx(i, r).is_extended_real is None
