def test_gruntz_eval_special():
# Gruntz, p. 126
assert gruntz(
exp(x) * (sin(1 / x + exp(-x)) - sin(1 / x + exp(-x**2))), x) == 1
assert gruntz((erf(x - exp(-exp(x))) - erf(x)) * exp(exp(x)) * exp(x**2),
x) == -2 / sqrt(pi)
assert gruntz(
exp(exp(x)) * (exp(sin(1 / x + exp(-exp(x)))) - exp(sin(1 / x))),
x) == 1
assert gruntz(exp(x) * (gamma(x + exp(-x)) - gamma(x)), x) == oo
assert gruntz(exp(exp(digamma(digamma(x)))) / x, x) == exp(-Rational(1, 2))
assert gruntz(exp(exp(digamma(log(x)))) / x, x) == exp(-Rational(1, 2))
assert gruntz(digamma(digamma(digamma(x))), x) == oo
assert gruntz(loggamma(loggamma(x)), x) == oo
assert gruntz(
((gamma(x + 1 / gamma(x)) - gamma(x)) / log(x) - cos(1 / x)) * x *
log(x), x) == -Rational(1, 2)
assert gruntz(x * (gamma(x - 1/gamma(x)) - gamma(x) + log(x)), x) \
== Rational(1, 2)
assert gruntz((gamma(x + 1 / gamma(x)) - gamma(x)) / log(x), x) == 1
assert gruntz(
gamma(x + 1) / sqrt(2 * pi) - exp(-x) *
(x**(x + Rational(1, 2)) + x**(x - Rational(1, 2)) / 12), x) == oo
assert gruntz(exp(exp(exp(digamma(digamma(digamma(x)))))) / x, x) == 0
assert gruntz(exp(gamma(x - exp(-x)) * exp(1 / x)) - exp(gamma(x)),
x) == oo
assert gruntz((Ei(x - exp(-exp(x))) - Ei(x)) * exp(-x) * exp(exp(x)) * x,
x) == -1
assert gruntz(exp((log(2) + 1) * x) * (zeta(x + exp(-x)) - zeta(x)),
x) == -log(2)
def test_intractable():
assert limit(1/gamma(x), x, oo) == 0
assert limit(1/loggamma(x), x, oo) == 0
assert limit(gamma(x)/loggamma(x), x, oo) == oo
assert limit(exp(gamma(x))/gamma(x), x, oo) == oo
assert limit(gamma(3 + 1/x), x, oo) == 2
assert limit(gamma(Rational(1, 7) + 1/x), x, oo) == gamma(Rational(1, 7))
assert limit(log(x**x)/log(gamma(x)), x, oo) == 1
assert limit(log(gamma(gamma(x)))/exp(x), x, oo) == oo
assert limit(acosh(1 + 1/x)*sqrt(x), x, oo) == sqrt(2)
# issue sympy/sympy#10804
assert limit(2*airyai(x)*root(x, 4) *
exp(2*x**Rational(3, 2)/3), x, oo) == 1/sqrt(pi)
assert limit(airybi(x)*root(x, 4) *
exp(-2*x**Rational(3, 2)/3), x, oo) == 1/sqrt(pi)
assert limit(airyai(1/x), x, oo) == (3**Rational(5, 6) *
gamma(Rational(1, 3))/(6*pi))
assert limit(airybi(1/x), x, oo) == cbrt(3)*gamma(Rational(1, 3))/(2*pi)
assert limit(airyai(2 + 1/x), x, oo) == airyai(2)
assert limit(airybi(2 + 1/x), x, oo) == airybi(2)
# issue sympy/sympy#10976
assert limit(erf(m/x)/erf(1/x), x, oo) == m
assert limit(Max(x**2, x, exp(x))/x, x, oo) == oo
def test_factorial_rewrite():
n = Symbol('n', integer=True)
k = Symbol('k', integer=True, nonnegative=True)
assert factorial(n).rewrite(gamma) == gamma(n + 1)
assert str(factorial(k).rewrite(Product)) == 'Product(_i, (_i, 1, k))'
assert factorial(n).rewrite('tractable') == exp(loggamma(n + 1))
def test_specfun():
for f in [besselj, bessely, besseli, besselk]:
assert octave_code(f(n, x)) == f.__name__ + '(n, x)'
assert octave_code(hankel1(n, x)) == 'besselh(n, 1, x)'
assert octave_code(hankel2(n, x)) == 'besselh(n, 2, x)'
assert octave_code(airyai(x)) == 'airy(0, x)'
assert octave_code(airyaiprime(x)) == 'airy(1, x)'
assert octave_code(airybi(x)) == 'airy(2, x)'
assert octave_code(airybiprime(x)) == 'airy(3, x)'
assert octave_code(uppergamma(n, x)) == "gammainc(x, n, 'upper')"
assert octave_code(lowergamma(n, x)) == "gammainc(x, n, 'lower')"
assert octave_code(jn(
n, x)) == 'sqrt(2)*sqrt(pi)*sqrt(1./x).*besselj(n + 1/2, x)/2'
assert octave_code(yn(
n, x)) == 'sqrt(2)*sqrt(pi)*sqrt(1./x).*bessely(n + 1/2, x)/2'
assert octave_code(Chi(x)) == 'coshint(x)'
assert octave_code(Ci(x)) == 'cosint(x)'
assert octave_code(laguerre(n, x)) == 'laguerreL(n, x)'
assert octave_code(li(x)) == 'logint(x)'
assert octave_code(loggamma(x)) == 'gammaln(x)'
assert octave_code(polygamma(n, x)) == 'psi(n, x)'
assert octave_code(Shi(x)) == 'sinhint(x)'
assert octave_code(Si(x)) == 'sinint(x)'
assert octave_code(LambertW(x)) == 'lambertw(x)'
assert octave_code(LambertW(x, n)) == 'lambertw(n, x)'
assert octave_code(zeta(x)) == 'zeta(x)'
assert octave_code(zeta(
x, y)) == '% Not supported in Octave:\n% zeta\nzeta(x, y)'
def test_factorial_rewrite():
n = Symbol('n', integer=True)
k = Symbol('k', integer=True, nonnegative=True)
assert factorial(n).rewrite(gamma) == gamma(n + 1)
assert str(factorial(k).rewrite(Product)) == 'Product(_i, (_i, 1, k))'
assert isinstance(factorial(n).rewrite(Product), factorial)
assert factorial(n).rewrite('tractable') == exp(loggamma(n + 1))
def test_gruntz_eval_special():
# Gruntz, p. 126
assert gruntz(exp(x)*(sin(1/x + exp(-x)) - sin(1/x + exp(-x**2))), x) == 1
assert gruntz((erf(x - exp(-exp(x))) - erf(x)) * exp(exp(x)) * exp(x**2),
x) == -2/sqrt(pi)
assert gruntz(exp(exp(x)) * (exp(sin(1/x + exp(-exp(x)))) - exp(sin(1/x))),
x) == 1
assert gruntz(exp(x)*(gamma(x + exp(-x)) - gamma(x)), x) == oo
assert gruntz(exp(exp(digamma(digamma(x))))/x, x) == exp(-Rational(1, 2))
assert gruntz(exp(exp(digamma(log(x))))/x, x) == exp(-Rational(1, 2))
assert gruntz(digamma(digamma(digamma(x))), x) == oo
assert gruntz(loggamma(loggamma(x)), x) == oo
assert gruntz(((gamma(x + 1/gamma(x)) - gamma(x))/log(x) - cos(1/x))
* x*log(x), x) == -Rational(1, 2)
assert gruntz(x * (gamma(x - 1/gamma(x)) - gamma(x) + log(x)), x) \
== Rational(1, 2)
assert gruntz((gamma(x + 1/gamma(x)) - gamma(x)) / log(x), x) == 1
def test_gruntz_eval_special():
# Gruntz, p. 126
assert gruntz(exp(x)*(sin(1/x + exp(-x)) - sin(1/x + exp(-x**2))), x) == 1
assert gruntz((erf(x - exp(-exp(x))) - erf(x)) * exp(exp(x)) * exp(x**2),
x) == -2/sqrt(pi)
assert gruntz(exp(exp(x)) * (exp(sin(1/x + exp(-exp(x)))) - exp(sin(1/x))),
x) == 1
assert gruntz(exp(x)*(gamma(x + exp(-x)) - gamma(x)), x) == oo
assert gruntz(exp(exp(digamma(digamma(x))))/x, x) == exp(-Rational(1, 2))
assert gruntz(exp(exp(digamma(log(x))))/x, x) == exp(-Rational(1, 2))
assert gruntz(digamma(digamma(digamma(x))), x) == oo
assert gruntz(loggamma(loggamma(x)), x) == oo
assert gruntz(((gamma(x + 1/gamma(x)) - gamma(x))/log(x) - cos(1/x))
* x*log(x), x) == -Rational(1, 2)
assert gruntz(x * (gamma(x - 1/gamma(x)) - gamma(x) + log(x)), x) \
== Rational(1, 2)
assert gruntz((gamma(x + 1/gamma(x)) - gamma(x)) / log(x), x) == 1
def test_intractable():
assert gruntz(1/gamma(x), x) == 0
assert gruntz(1/loggamma(x), x) == 0
assert gruntz(gamma(x)/loggamma(x), x) == oo
assert gruntz(exp(gamma(x))/gamma(x), x) == oo
assert gruntz(gamma(3 + 1/x), x) == 2
assert gruntz(gamma(Rational(1, 7) + 1/x), x) == gamma(Rational(1, 7))
assert gruntz(log(x**x)/log(gamma(x)), x) == 1
assert gruntz(log(gamma(gamma(x)))/exp(x), x) == oo
# issue sympy/sympy#10804
assert gruntz(2*airyai(x)*root(x, 4) *
exp(2*x**Rational(3, 2)/3), x) == 1/sqrt(pi)
assert gruntz(airybi(x)*root(x, 4) *
exp(-2*x**Rational(3, 2)/3), x) == 1/sqrt(pi)
assert gruntz(airyai(1/x), x) == (3**Rational(5, 6) *
gamma(Rational(1, 3))/(6*pi))
assert gruntz(airybi(1/x), x) == cbrt(3)*gamma(Rational(1, 3))/(2*pi)
assert gruntz(airyai(2 + 1/x), x) == airyai(2)
assert gruntz(airybi(2 + 1/x), x) == airybi(2)
def test_intractable():
assert gruntz(1/gamma(x), x) == 0
assert gruntz(1/loggamma(x), x) == 0
assert gruntz(gamma(x)/loggamma(x), x) == oo
assert gruntz(exp(gamma(x))/gamma(x), x) == oo
assert gruntz(gamma(3 + 1/x), x) == 2
assert gruntz(gamma(Rational(1, 7) + 1/x), x) == gamma(Rational(1, 7))
assert gruntz(log(x**x)/log(gamma(x)), x) == 1
assert gruntz(log(gamma(gamma(x)))/exp(x), x) == oo
# issue sympy/sympy#10804
assert gruntz(2*airyai(x)*root(x, 4) *
exp(2*x**Rational(3, 2)/3), x) == 1/sqrt(pi)
assert gruntz(airybi(x)*root(x, 4) *
exp(-2*x**Rational(3, 2)/3), x) == 1/sqrt(pi)
assert gruntz(airyai(1/x), x) == (3**Rational(5, 6) *
gamma(Rational(1, 3))/(6*pi))
assert gruntz(airybi(1/x), x) == cbrt(3)*gamma(Rational(1, 3))/(2*pi)
assert gruntz(airyai(2 + 1/x), x) == airyai(2)
assert gruntz(airybi(2 + 1/x), x) == airybi(2)
def test_rf_eval_apply():
x, y = symbols('x,y')
assert rf(nan, y) == nan
assert rf(x, y) == rf(x, y)
assert rf(oo, 0) == 1
assert rf(-oo, 0) == 1
assert rf(oo, 6) == oo
assert rf(-oo, 7) == -oo
assert rf(oo, -6) == oo
assert rf(-oo, -7) == oo
assert rf(-oo, 2) == oo
assert rf(x, 0) == 1
assert rf(x, 1) == x
assert rf(x, 2) == x*(x + 1)
assert rf(x, 3) == x*(x + 1)*(x + 2)
assert rf(x, 5) == x*(x + 1)*(x + 2)*(x + 3)*(x + 4)
assert rf(x, -1) == 1/(x - 1)
assert rf(x, -2) == 1/((x - 1)*(x - 2))
assert rf(x, -3) == 1/((x - 1)*(x - 2)*(x - 3))
assert rf(1, 100) == factorial(100)
n = Symbol('n', integer=True)
k = Symbol('k', integer=True)
m = Symbol('m', integer=True, nonnegative=True)
assert rf(x, m).is_integer is None
assert rf(n, k).is_integer is None
assert rf(n, m).is_integer is True
assert rf(x, y).rewrite('tractable') == \
exp(-loggamma(x))*exp(loggamma(x + y))
def test_rf_eval_apply():
x, y = symbols('x,y')
assert rf(nan, y) == nan
assert rf(x, y) == rf(x, y)
assert rf(oo, 0) == 1
assert rf(-oo, 0) == 1
assert rf(oo, 6) == oo
assert rf(-oo, 7) == -oo
assert rf(oo, -6) == oo
assert rf(-oo, -7) == oo
assert rf(-oo, 2) == oo
assert rf(x, 0) == 1
assert rf(x, 1) == x
assert rf(x, 2) == x * (x + 1)
assert rf(x, 3) == x * (x + 1) * (x + 2)
assert rf(x, 5) == x * (x + 1) * (x + 2) * (x + 3) * (x + 4)
assert rf(x, -1) == 1 / (x - 1)
assert rf(x, -2) == 1 / ((x - 1) * (x - 2))
assert rf(x, -3) == 1 / ((x - 1) * (x - 2) * (x - 3))
assert rf(1, 100) == factorial(100)
n = Symbol('n', integer=True)
k = Symbol('k', integer=True)
m = Symbol('m', integer=True, nonnegative=True)
assert rf(x, m).is_integer is None
assert rf(n, k).is_integer is None
assert rf(n, m).is_integer is True
assert rf(x, y).rewrite('tractable') == \
exp(-loggamma(x))*exp(loggamma(x + y))
def test_function__eval_nseries():
n = Symbol('n')
assert sin(x)._eval_nseries(x, 2, None) == x + O(x**3)
assert sin(x + 1)._eval_nseries(x, 2, None) == x*cos(1) + sin(1) + O(x**2)
assert sin(pi*(1 - x))._eval_nseries(x, 2, None) == pi*x + O(x**3)
assert acos(1 - x**2)._eval_nseries(x, 2, None) == sqrt(2)*x + O(x**2)
assert polygamma(n, x + 1)._eval_nseries(x, 2, None) == \
polygamma(n, 1) + polygamma(n + 1, 1)*x + O(x**2)
pytest.raises(PoleError, lambda: sin(1/x)._eval_nseries(x, 2, None))
assert acos(1 - x)._eval_nseries(x, 4, None) == sqrt(2)*sqrt(x) + \
sqrt(2)*x**Rational(3, 2)/12 + O(x**2)
assert acos(1 + x)._eval_nseries(x, 4, None) == sqrt(2)*I*sqrt(x) - \
sqrt(2)*I*x**(3/2)/12 + O(x**2) # XXX: wrong, branch cuts
assert loggamma(1/x)._eval_nseries(x, 0, None) == \
log(x)/2 - log(x)/x - 1/x + O(1, x)
assert loggamma(log(1/x)).nseries(x, n=1, logx=y) == loggamma(-y)
# issue sympy/sympy#6725:
assert expint(Rational(3, 2), -x)._eval_nseries(x, 8, None) == \
2 - 2*I*sqrt(pi)*sqrt(x) - 2*x - x**2/3 - x**3/15 - x**4/84 + O(x**5)
assert sin(sqrt(x))._eval_nseries(x, 6, None) == \
sqrt(x) - x**Rational(3, 2)/6 + x**Rational(5, 2)/120 + O(x**Rational(7, 2))
def test_function__eval_nseries():
n = Symbol('n')
assert sin(x)._eval_nseries(x, 2, None) == x + O(x**3)
assert sin(x + 1)._eval_nseries(x, 2, None) == x*cos(1) + sin(1) + O(x**2)
assert sin(pi*(1 - x))._eval_nseries(x, 2, None) == pi*x + O(x**3)
assert acos(1 - x**2)._eval_nseries(x, 2, None) == sqrt(2)*x + O(x**2)
assert polygamma(n, x + 1)._eval_nseries(x, 2, None) == \
polygamma(n, 1) + polygamma(n + 1, 1)*x + O(x**2)
pytest.raises(PoleError, lambda: sin(1/x)._eval_nseries(x, 2, None))
assert acos(1 - x)._eval_nseries(x, 4, None) == sqrt(2)*sqrt(x) + \
sqrt(2)*x**Rational(3, 2)/12 + O(x**2)
assert acos(1 + x)._eval_nseries(x, 4, None) == sqrt(2)*I*sqrt(x) - \
sqrt(2)*I*x**(3/2)/12 + O(x**2) # XXX: wrong, branch cuts
assert loggamma(1/x)._eval_nseries(x, 0, None) == \
log(x)/2 - log(x)/x - 1/x + O(1, x)
assert loggamma(log(1/x)).nseries(x, n=1, logx=y) == loggamma(-y)
# issue sympy/sympy#6725:
assert expint(Rational(3, 2), -x)._eval_nseries(x, 8, None) == \
2 - 2*I*sqrt(pi)*sqrt(x) - 2*x - x**2/3 - x**3/15 - x**4/84 + O(x**5)
assert sin(sqrt(x))._eval_nseries(x, 6, None) == \
sqrt(x) - x**Rational(3, 2)/6 + x**Rational(5, 2)/120 + O(x**Rational(7, 2))
def _eval_rewrite_as_tractable(self, n):
from diofant import loggamma, exp
return exp(loggamma(n + 1))
def tN(N, M):
assert loggamma(1/x)._eval_nseries(x, n=N).getn() == M
def test_loggamma():
pytest.raises(TypeError, lambda: loggamma(2, 3))
pytest.raises(ArgumentIndexError, lambda: loggamma(x).fdiff(2))
assert loggamma(-1) == oo
assert loggamma(-2) == oo
assert loggamma(0) == oo
assert loggamma(1) == 0
assert loggamma(2) == 0
assert loggamma(3) == log(2)
assert loggamma(4) == log(6)
n = Symbol('n', integer=True, positive=True)
assert loggamma(n) == log(gamma(n))
assert loggamma(-n) == oo
assert loggamma(n/2) == log(2**(-n + 1)*sqrt(pi)*gamma(n)/gamma(n/2 + Rational(1, 2)))
assert loggamma(oo) == oo
assert loggamma(-oo) == zoo
assert loggamma(I*oo) == zoo
assert loggamma(-I*oo) == zoo
assert loggamma(zoo) == zoo
assert loggamma(nan) == nan
L = loggamma(Rational(16, 3))
E = -5*log(3) + loggamma(Rational(1, 3)) + log(4) + log(7) + log(10) + log(13)
assert expand_func(L).doit() == E
assert L.evalf() == E.evalf()
L = loggamma(Rational(19, 4))
E = -4*log(4) + loggamma(Rational(3, 4)) + log(3) + log(7) + log(11) + log(15)
assert expand_func(L).doit() == E
assert L.evalf() == E.evalf()
L = loggamma(Rational(23, 7))
E = -3*log(7) + log(2) + loggamma(Rational(2, 7)) + log(9) + log(16)
assert expand_func(L).doit() == E
assert L.evalf() == E.evalf()
L = loggamma(Rational(19, 4) - 7)
E = -log(9) - log(5) + loggamma(Rational(3, 4)) + 3*log(4) - 3*I*pi
assert expand_func(L).doit() == E
assert L.evalf() == E.evalf()
L = loggamma(Rational(23, 7) - 6)
E = -log(19) - log(12) - log(5) + loggamma(Rational(2, 7)) + 3*log(7) - 3*I*pi
assert expand_func(L).doit() == E
assert L.evalf() == E.evalf()
assert expand_func(loggamma(x)) == loggamma(x)
assert expand_func(loggamma(Rational(1, 3))) == loggamma(Rational(1, 3))
assert loggamma(x).diff(x) == polygamma(0, x)
s1 = loggamma(1/(x + sin(x)) + cos(x)).series(x, n=4)
s2 = (-log(2*x) - 1)/(2*x) - log(x/pi)/2 + (4 - log(2*x))*x/24 + O(x**2) + \
log(x)*x**2/2
assert (s1 - s2).expand(force=True).removeO() == 0
s1 = loggamma(1/x).series(x)
s2 = (1/x - Rational(1, 2))*log(1/x) - 1/x + log(2*pi)/2 + \
x/12 - x**3/360 + x**5/1260 + O(x**7)
assert ((s1 - s2).expand(force=True)).removeO() == 0
assert loggamma(x).rewrite('intractable') == log(gamma(x))
s1 = loggamma(x).series(x)
assert s1 == -log(x) - EulerGamma*x + pi**2*x**2/12 + x**3*polygamma(2, 1)/6 + \
pi**4*x**4/360 + x**5*polygamma(4, 1)/120 + O(x**6)
assert s1 == loggamma(x).rewrite('intractable').series(x)
assert conjugate(loggamma(x)) == conjugate(loggamma(x), evaluate=False)
p = Symbol('p', positive=True)
c = Symbol('c', complex=True, extended_real=False)
assert conjugate(loggamma(p)) == loggamma(p)
assert conjugate(loggamma(c)) == loggamma(conjugate(c))
assert conjugate(loggamma(0)) == conjugate(loggamma(0))
assert conjugate(loggamma(1)) == loggamma(conjugate(1))
assert conjugate(loggamma(-oo)) == conjugate(loggamma(-oo))
assert loggamma(x).is_extended_real is None
y = Symbol('y', nonnegative=True)
assert loggamma(y).is_extended_real
assert loggamma(w).is_extended_real is None
def tN(N, M):
assert loggamma(1/x)._eval_nseries(x, n=N).getn() == M
tN(0, 0)
tN(1, 1)
tN(2, 3)
tN(3, 3)
tN(4, 5)
tN(5, 5)
def test_polygamma():
assert polygamma(n, nan) == nan
assert polygamma(0, oo) == oo
assert polygamma(0, -oo) == oo
assert polygamma(0, I*oo) == oo
assert polygamma(0, -I*oo) == oo
assert polygamma(1, oo) == 0
assert polygamma(5, oo) == 0
assert polygamma(n, oo) == polygamma(n, oo, evaluate=False)
assert polygamma(0, -9) == zoo
assert polygamma(0, -9) == zoo
assert polygamma(0, -1) == zoo
assert polygamma(0, 0) == zoo
assert polygamma(0, 1) == -EulerGamma
assert polygamma(0, 7) == Rational(49, 20) - EulerGamma
assert polygamma(0, -Rational(3, 11)) == polygamma(0, -Rational(3, 11),
evaluate=False)
assert polygamma(1, 1) == pi**2/6
assert polygamma(1, 2) == pi**2/6 - 1
assert polygamma(1, 3) == pi**2/6 - Rational(5, 4)
assert polygamma(3, 1) == pi**4 / 15
assert polygamma(3, 5) == 6*(Rational(-22369, 20736) + pi**4/90)
assert polygamma(5, 1) == 8 * pi**6 / 63
assert trigamma(x) == polygamma(1, x)
def t(m, n):
x = Integer(m)/n
r = polygamma(0, x)
if r.has(polygamma):
return False
return abs(polygamma(0, x.evalf()).evalf(strict=False) - r.evalf()).evalf(strict=False) < 1e-10
assert t(1, 2)
assert t(3, 2)
assert t(-1, 2)
assert t(1, 4)
assert t(-3, 4)
assert t(1, 3)
assert t(4, 3)
assert t(3, 4)
assert t(2, 3)
assert polygamma(0, x).rewrite(zeta) == polygamma(0, x)
assert polygamma(1, x).rewrite(zeta) == zeta(2, x)
assert polygamma(2, x).rewrite(zeta) == -2*zeta(3, x)
assert polygamma(3, 7*x).diff(x) == 7*polygamma(4, 7*x)
pytest.raises(ArgumentIndexError, lambda: polygamma(3, 7*x).fdiff(3))
assert polygamma(0, x).rewrite(harmonic) == harmonic(x - 1) - EulerGamma
assert polygamma(2, x).rewrite(harmonic) == 2*harmonic(x - 1, 3) - 2*zeta(3)
ni = Symbol('n', integer=True)
assert polygamma(ni, x).rewrite(harmonic) == (-1)**(ni + 1)*(-harmonic(x - 1, ni + 1)
+ zeta(ni + 1))*factorial(ni)
assert polygamma(x, y).rewrite(harmonic) == polygamma(x, y)
# Polygamma of non-negative integer order is unbranched:
k = Symbol('n', integer=True, nonnegative=True)
assert polygamma(k, exp_polar(2*I*pi)*x) == polygamma(k, x)
# but negative integers are branched!
k = Symbol('n', integer=True)
assert polygamma(k, exp_polar(2*I*pi)*x).args == (k, exp_polar(2*I*pi)*x)
# Polygamma of order -1 is loggamma:
assert polygamma(-1, x) == loggamma(x)
# But smaller orders are iterated integrals and don't have a special name
assert isinstance(polygamma(-2, x), polygamma)
# Test a bug
assert polygamma(0, -x).expand(func=True) == polygamma(0, -x)
assert polygamma(1, x).as_leading_term(x) == polygamma(1, x)
def test_polygamma():
from diofant import I
assert polygamma(n, nan) == nan
assert polygamma(0, oo) == oo
assert polygamma(0, -oo) == oo
assert polygamma(0, I * oo) == oo
assert polygamma(0, -I * oo) == oo
assert polygamma(1, oo) == 0
assert polygamma(5, oo) == 0
assert polygamma(0, -9) == zoo
assert polygamma(0, -9) == zoo
assert polygamma(0, -1) == zoo
assert polygamma(0, 0) == zoo
assert polygamma(0, 1) == -EulerGamma
assert polygamma(0, 7) == Rational(49, 20) - EulerGamma
assert polygamma(1, 1) == pi**2 / 6
assert polygamma(1, 2) == pi**2 / 6 - 1
assert polygamma(1, 3) == pi**2 / 6 - Rational(5, 4)
assert polygamma(3, 1) == pi**4 / 15
assert polygamma(3, 5) == 6 * (Rational(-22369, 20736) + pi**4 / 90)
assert polygamma(5, 1) == 8 * pi**6 / 63
assert trigamma(x) == polygamma(1, x)
def t(m, n):
x = Integer(m) / n
r = polygamma(0, x)
if r.has(polygamma):
return False
return abs(polygamma(0, x.n()).n() - r.n()).n() < 1e-10
assert t(1, 2)
assert t(3, 2)
assert t(-1, 2)
assert t(1, 4)
assert t(-3, 4)
assert t(1, 3)
assert t(4, 3)
assert t(3, 4)
assert t(2, 3)
assert polygamma(0, x).rewrite(zeta) == polygamma(0, x)
assert polygamma(1, x).rewrite(zeta) == zeta(2, x)
assert polygamma(2, x).rewrite(zeta) == -2 * zeta(3, x)
assert polygamma(3, 7 * x).diff(x) == 7 * polygamma(4, 7 * x)
assert polygamma(0, x).rewrite(harmonic) == harmonic(x - 1) - EulerGamma
assert polygamma(
2, x).rewrite(harmonic) == 2 * harmonic(x - 1, 3) - 2 * zeta(3)
ni = Symbol("n", integer=True)
assert polygamma(
ni,
x).rewrite(harmonic) == (-1)**(ni + 1) * (-harmonic(x - 1, ni + 1) +
zeta(ni + 1)) * factorial(ni)
# Polygamma of non-negative integer order is unbranched:
from diofant import exp_polar
k = Symbol('n', integer=True, nonnegative=True)
assert polygamma(k, exp_polar(2 * I * pi) * x) == polygamma(k, x)
# but negative integers are branched!
k = Symbol('n', integer=True)
assert polygamma(k,
exp_polar(2 * I * pi) *
x).args == (k, exp_polar(2 * I * pi) * x)
# Polygamma of order -1 is loggamma:
assert polygamma(-1, x) == loggamma(x)
# But smaller orders are iterated integrals and don't have a special name
assert polygamma(-2, x).func is polygamma
# Test a bug
assert polygamma(0, -x).expand(func=True) == polygamma(0, -x)
assert polygamma(1, x).as_leading_term(x) == polygamma(1, x)
def test_Function():
assert mathematica_code(f(x, y, z)) == 'f[x, y, z]'
assert mathematica_code(sin(x)**cos(x)) == 'Sin[x]^Cos[x]'
assert mathematica_code(sign(x)) == 'Sign[x]'
assert mathematica_code(atanh(x),
user_functions={'atanh':
'ArcTanh'}) == 'ArcTanh[x]'
assert (mathematica_code(meijerg(
((1, 1), (3, 4)), ((1, ), ()),
x)) == 'MeijerG[{{1, 1}, {3, 4}}, {{1}, {}}, x]')
assert (mathematica_code(hyper(
(1, 2, 3), (3, 4), x)) == 'HypergeometricPFQ[{1, 2, 3}, {3, 4}, x]')
assert mathematica_code(Min(x, y)) == 'Min[x, y]'
assert mathematica_code(Max(x, y)) == 'Max[x, y]'
assert mathematica_code(Max(x,
2)) == 'Max[2, x]' # issue sympy/sympy#15344
assert mathematica_code(binomial(x, y)) == 'Binomial[x, y]'
assert mathematica_code(log(x)) == 'Log[x]'
assert mathematica_code(tan(x)) == 'Tan[x]'
assert mathematica_code(cot(x)) == 'Cot[x]'
assert mathematica_code(asin(x)) == 'ArcSin[x]'
assert mathematica_code(acos(x)) == 'ArcCos[x]'
assert mathematica_code(atan(x)) == 'ArcTan[x]'
assert mathematica_code(acot(x)) == 'ArcCot[x]'
assert mathematica_code(sinh(x)) == 'Sinh[x]'
assert mathematica_code(cosh(x)) == 'Cosh[x]'
assert mathematica_code(tanh(x)) == 'Tanh[x]'
assert mathematica_code(coth(x)) == 'Coth[x]'
assert mathematica_code(asinh(x)) == 'ArcSinh[x]'
assert mathematica_code(acosh(x)) == 'ArcCosh[x]'
assert mathematica_code(atanh(x)) == 'ArcTanh[x]'
assert mathematica_code(acoth(x)) == 'ArcCoth[x]'
assert mathematica_code(sech(x)) == 'Sech[x]'
assert mathematica_code(csch(x)) == 'Csch[x]'
assert mathematica_code(erf(x)) == 'Erf[x]'
assert mathematica_code(erfi(x)) == 'Erfi[x]'
assert mathematica_code(erfc(x)) == 'Erfc[x]'
assert mathematica_code(conjugate(x)) == 'Conjugate[x]'
assert mathematica_code(re(x)) == 'Re[x]'
assert mathematica_code(im(x)) == 'Im[x]'
assert mathematica_code(polygamma(x, y)) == 'PolyGamma[x, y]'
assert mathematica_code(factorial(x)) == 'Factorial[x]'
assert mathematica_code(factorial2(x)) == 'Factorial2[x]'
assert mathematica_code(rf(x, y)) == 'Pochhammer[x, y]'
assert mathematica_code(gamma(x)) == 'Gamma[x]'
assert mathematica_code(zeta(x)) == 'Zeta[x]'
assert mathematica_code(Heaviside(x)) == 'UnitStep[x]'
assert mathematica_code(fibonacci(x)) == 'Fibonacci[x]'
assert mathematica_code(polylog(x, y)) == 'PolyLog[x, y]'
assert mathematica_code(loggamma(x)) == 'LogGamma[x]'
assert mathematica_code(uppergamma(x, y)) == 'Gamma[x, y]'
class MyFunc1(Function):
@classmethod
def eval(cls, x):
pass
class MyFunc2(Function):
@classmethod
def eval(cls, x, y):
pass
pytest.raises(
ValueError,
lambda: mathematica_code(MyFunc1(x),
user_functions={'MyFunc1': ['Myfunc1']}))
assert mathematica_code(MyFunc1(x),
user_functions={'MyFunc1':
'Myfunc1'}) == 'Myfunc1[x]'
assert mathematica_code(
MyFunc2(x, y),
user_functions={'MyFunc2':
[(lambda *x: False, 'Myfunc2')]}) == 'MyFunc2[x, y]'
