Add files using upload-large-folder tool

env-llmeval/lib/python3.10/site-packages/sympy/functions/special/tests/test_bessel.py

@@ -0,0 +1,759 @@
+from itertools import product
+
+from sympy.concrete.summations import Sum
+from sympy.core.function import (diff, expand_func)
+from sympy.core.numbers import (I, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import (conjugate, polar_lift)
+from sympy.functions.elementary.exponential import (exp, exp_polar, log)
+from sympy.functions.elementary.hyperbolic import (cosh, sinh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.bessel import (besseli, besselj, besselk, bessely, hankel1, hankel2, hn1, hn2, jn, jn_zeros, yn)
+from sympy.functions.special.gamma_functions import (gamma, uppergamma)
+from sympy.functions.special.hyper import hyper
+from sympy.integrals.integrals import Integral
+from sympy.series.order import O
+from sympy.series.series import series
+from sympy.functions.special.bessel import (airyai, airybi,
+                                            airyaiprime, airybiprime, marcumq)
+from sympy.core.random import (random_complex_number as randcplx,
+                                      verify_numerically as tn,
+                                      test_derivative_numerically as td,
+                                      _randint)
+from sympy.simplify import besselsimp
+from sympy.testing.pytest import raises, slow
+
+from sympy.abc import z, n, k, x
+
+randint = _randint()
+
+
+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_bessel_twoinputs():
+    for f in [besselj, bessely, besseli, besselk, hankel1, hankel2, jn, yn]:
+        raises(TypeError, lambda: f(1))
+        raises(TypeError, lambda: f(1, 2, 3))
+
+
+def test_besselj_leading_term():
+    assert besselj(0, x).as_leading_term(x) == 1
+    assert besselj(1, sin(x)).as_leading_term(x) == x/2
+    assert besselj(1, 2*sqrt(x)).as_leading_term(x) == sqrt(x)
+
+    # https://github.com/sympy/sympy/issues/21701
+    assert (besselj(z, x)/x**z).as_leading_term(x) == 1/(2**z*gamma(z + 1))
+
+
+def test_bessely_leading_term():
+    assert bessely(0, x).as_leading_term(x) == (2*log(x) - 2*log(2) + 2*S.EulerGamma)/pi
+    assert bessely(1, sin(x)).as_leading_term(x) == -2/(pi*x)
+    assert bessely(1, 2*sqrt(x)).as_leading_term(x) == -1/(pi*sqrt(x))
+
+
+def test_besseli_leading_term():
+    assert besseli(0, x).as_leading_term(x) == 1
+    assert besseli(1, sin(x)).as_leading_term(x) == x/2
+    assert besseli(1, 2*sqrt(x)).as_leading_term(x) == sqrt(x)
+
+
+def test_besselk_leading_term():
+    assert besselk(0, x).as_leading_term(x) == -log(x) - S.EulerGamma + log(2)
+    assert besselk(1, sin(x)).as_leading_term(x) == 1/x
+    assert besselk(1, 2*sqrt(x)).as_leading_term(x) == 1/(2*sqrt(x))
+
+
+def test_besselj_series():
+    assert besselj(0, x).series(x) == 1 - x**2/4 + x**4/64 + O(x**6)
+    assert besselj(0, x**(1.1)).series(x) == 1 + x**4.4/64 - x**2.2/4 + O(x**6)
+    assert besselj(0, x**2 + x).series(x) == 1 - x**2/4 - x**3/2\
+        - 15*x**4/64 + x**5/16 + O(x**6)
+    assert besselj(0, sqrt(x) + x).series(x, n=4) == 1 - x/4 - 15*x**2/64\
+        + 215*x**3/2304 - x**Rational(3, 2)/2 + x**Rational(5, 2)/16\
+        + 23*x**Rational(7, 2)/384 + O(x**4)
+    assert besselj(0, x/(1 - x)).series(x) == 1 - x**2/4 - x**3/2 - 47*x**4/64\
+        - 15*x**5/16 + O(x**6)
+    assert besselj(0, log(1 + x)).series(x) == 1 - x**2/4 + x**3/4\
+        - 41*x**4/192 + 17*x**5/96 + O(x**6)
+    assert besselj(1, sin(x)).series(x) == x/2 - 7*x**3/48 + 73*x**5/1920 + O(x**6)
+    assert besselj(1, 2*sqrt(x)).series(x) == sqrt(x) - x**Rational(3, 2)/2\
+        + x**Rational(5, 2)/12 - x**Rational(7, 2)/144 + x**Rational(9, 2)/2880\
+        - x**Rational(11, 2)/86400 + O(x**6)
+    assert besselj(-2, sin(x)).series(x, n=4) == besselj(2, sin(x)).series(x, n=4)
+
+
+def test_bessely_series():
+    const = 2*S.EulerGamma/pi - 2*log(2)/pi + 2*log(x)/pi
+    assert bessely(0, x).series(x, n=4) == const + x**2*(-log(x)/(2*pi)\
+        + (2 - 2*S.EulerGamma)/(4*pi) + log(2)/(2*pi)) + O(x**4*log(x))
+    assert bessely(1, x).series(x, n=4) == -2/(pi*x) + x*(log(x)/pi - log(2)/pi - \
+        (1 - 2*S.EulerGamma)/(2*pi)) + x**3*(-log(x)/(8*pi) + \
+        (S(5)/2 - 2*S.EulerGamma)/(16*pi) + log(2)/(8*pi)) + O(x**4*log(x))
+    assert bessely(2, x).series(x, n=4) == -4/(pi*x**2) - 1/pi + x**2*(log(x)/(4*pi) - \
+        log(2)/(4*pi) - (S(3)/2 - 2*S.EulerGamma)/(8*pi)) + O(x**4*log(x))
+    assert bessely(3, x).series(x, n=4) == -16/(pi*x**3) - 2/(pi*x) - \
+        x/(4*pi) + x**3*(log(x)/(24*pi) - log(2)/(24*pi) - \
+        (S(11)/6 - 2*S.EulerGamma)/(48*pi)) + O(x**4*log(x))
+    assert bessely(0, x**(1.1)).series(x, n=4) == 2*S.EulerGamma/pi\
+        - 2*log(2)/pi + 2.2*log(x)/pi + x**2.2*(-0.55*log(x)/pi\
+        + (2 - 2*S.EulerGamma)/(4*pi) + log(2)/(2*pi)) + O(x**4*log(x))
+    assert bessely(0, x**2 + x).series(x, n=4) == \
+        const - (2 - 2*S.EulerGamma)*(-x**3/(2*pi) - x**2/(4*pi)) + 2*x/pi\
+        + x**2*(-log(x)/(2*pi) - 1/pi + log(2)/(2*pi))\
+        + x**3*(-log(x)/pi + 1/(6*pi) + log(2)/pi) + O(x**4*log(x))
+    assert bessely(0, x/(1 - x)).series(x, n=3) == const\
+        + 2*x/pi + x**2*(-log(x)/(2*pi) + (2 - 2*S.EulerGamma)/(4*pi)\
+        + log(2)/(2*pi) + 1/pi) + O(x**3*log(x))
+    assert bessely(0, log(1 + x)).series(x, n=3) == const\
+        - x/pi + x**2*(-log(x)/(2*pi) + (2 - 2*S.EulerGamma)/(4*pi)\
+        + log(2)/(2*pi) + 5/(12*pi)) + O(x**3*log(x))
+    assert bessely(1, sin(x)).series(x, n=4) == -1/(pi*(-x**3/12 + x/2)) - \
+        (1 - 2*S.EulerGamma)*(-x**3/12 + x/2)/pi + x*(log(x)/pi - log(2)/pi) + \
+        x**3*(-7*log(x)/(24*pi) - 1/(6*pi) + (S(5)/2 - 2*S.EulerGamma)/(16*pi) +
+        7*log(2)/(24*pi)) + O(x**4*log(x))
+    assert bessely(1, 2*sqrt(x)).series(x, n=3) == -1/(pi*sqrt(x)) + \
+        sqrt(x)*(log(x)/pi - (1 - 2*S.EulerGamma)/pi) + x**(S(3)/2)*(-log(x)/(2*pi) + \
+        (S(5)/2 - 2*S.EulerGamma)/(2*pi)) + x**(S(5)/2)*(log(x)/(12*pi) - \
+        (S(10)/3 - 2*S.EulerGamma)/(12*pi)) + O(x**3*log(x))
+    assert bessely(-2, sin(x)).series(x, n=4) == bessely(2, sin(x)).series(x, n=4)
+
+
+def test_besseli_series():
+    assert besseli(0, x).series(x) == 1 + x**2/4 + x**4/64 + O(x**6)
+    assert besseli(0, x**(1.1)).series(x) == 1 + x**4.4/64 + x**2.2/4 + O(x**6)
+    assert besseli(0, x**2 + x).series(x) == 1 + x**2/4 + x**3/2 + 17*x**4/64 + \
+        x**5/16 + O(x**6)
+    assert besseli(0, sqrt(x) + x).series(x, n=4) == 1 + x/4 + 17*x**2/64 + \
+        217*x**3/2304 + x**(S(3)/2)/2 + x**(S(5)/2)/16 + 25*x**(S(7)/2)/384 + O(x**4)
+    assert besseli(0, x/(1 - x)).series(x) == 1 + x**2/4 + x**3/2 + 49*x**4/64 + \
+        17*x**5/16 + O(x**6)
+    assert besseli(0, log(1 + x)).series(x) == 1 + x**2/4 - x**3/4 + 47*x**4/192 - \
+        23*x**5/96 + O(x**6)
+    assert besseli(1, sin(x)).series(x) == x/2 - x**3/48 - 47*x**5/1920 + O(x**6)
+    assert besseli(1, 2*sqrt(x)).series(x) == sqrt(x) + x**(S(3)/2)/2 + x**(S(5)/2)/12 + \
+        x**(S(7)/2)/144 + x**(S(9)/2)/2880 + x**(S(11)/2)/86400 + O(x**6)
+    assert besseli(-2, sin(x)).series(x, n=4) == besseli(2, sin(x)).series(x, n=4)
+
+
+def test_besselk_series():
+    const = log(2) - S.EulerGamma - log(x)
+    assert besselk(0, x).series(x, n=4) == const + \
+        x**2*(-log(x)/4 - S.EulerGamma/4 + log(2)/4 + S(1)/4) + O(x**4*log(x))
+    assert besselk(1, x).series(x, n=4) == 1/x + x*(log(x)/2 - log(2)/2 - \
+        S(1)/4 + S.EulerGamma/2) + x**3*(log(x)/16 - S(5)/64 - log(2)/16 + \
+        S.EulerGamma/16) + O(x**4*log(x))
+    assert besselk(2, x).series(x, n=4) == 2/x**2 - S(1)/2 + x**2*(-log(x)/8 - \
+        S.EulerGamma/8 + log(2)/8 + S(3)/32) + O(x**4*log(x))
+    assert besselk(0, x**(1.1)).series(x, n=4) == log(2) - S.EulerGamma - \
+        1.1*log(x) + x**2.2*(-0.275*log(x) - S.EulerGamma/4 + \
+        log(2)/4 + S(1)/4) + O(x**4*log(x))
+    assert besselk(0, x**2 + x).series(x, n=4) == const + \
+        (2 - 2*S.EulerGamma)*(x**3/4 + x**2/8) - x + x**2*(-log(x)/4 + \
+        log(2)/4 + S(1)/2) + x**3*(-log(x)/2 - S(7)/12 + log(2)/2) + O(x**4*log(x))
+    assert besselk(0, x/(1 - x)).series(x, n=3) == const - x + x**2*(-log(x)/4 - \
+        S(1)/4 - S.EulerGamma/4 + log(2)/4) + O(x**3*log(x))
+    assert besselk(0, log(1 + x)).series(x, n=3) == const + x/2 + \
+        x**2*(-log(x)/4 - S.EulerGamma/4 + S(1)/24 + log(2)/4) + O(x**3*log(x))
+    assert besselk(1, 2*sqrt(x)).series(x, n=3) == 1/(2*sqrt(x)) + \
+        sqrt(x)*(log(x)/2 - S(1)/2 + S.EulerGamma) + x**(S(3)/2)*(log(x)/4 - S(5)/8 + \
+        S.EulerGamma/2) + x**(S(5)/2)*(log(x)/24 - S(5)/36 + S.EulerGamma/12) + O(x**3*log(x))
+    assert besselk(-2, sin(x)).series(x, n=4) == besselk(2, sin(x)).series(x, n=4)
+
+
+def test_diff():
+    assert besselj(n, z).diff(z) == besselj(n - 1, z)/2 - besselj(n + 1, z)/2
+    assert bessely(n, z).diff(z) == bessely(n - 1, z)/2 - bessely(n + 1, z)/2
+    assert besseli(n, z).diff(z) == besseli(n - 1, z)/2 + besseli(n + 1, z)/2
+    assert besselk(n, z).diff(z) == -besselk(n - 1, z)/2 - besselk(n + 1, z)/2
+    assert hankel1(n, z).diff(z) == hankel1(n - 1, z)/2 - hankel1(n + 1, z)/2
+    assert hankel2(n, z).diff(z) == hankel2(n - 1, z)/2 - hankel2(n + 1, z)/2
+
+
+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():
+    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))
+
+    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
+
+    for besselx in [besselj, bessely, besseli, besselk]:
+        assert expand_func(besselx(oo, x)) == besselx(oo, x, evaluate=False)
+        assert expand_func(besselx(-oo, x)) == besselx(-oo, x, evaluate=False)
+
+
+# Quite varying time, but often really slow
+@slow
+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 mjn(n, z):
+    return expand_func(jn(n, z))
+
+
+def myn(n, z):
+    return expand_func(yn(n, z))
+
+
+def test_jn():
+    z = symbols("z")
+    assert jn(0, 0) == 1
+    assert jn(1, 0) == 0
+    assert jn(-1, 0) == S.ComplexInfinity
+    assert jn(z, 0) == jn(z, 0, evaluate=False)
+    assert jn(0, oo) == 0
+    assert jn(0, -oo) == 0
+
+    assert mjn(0, z) == sin(z)/z
+    assert mjn(1, z) == sin(z)/z**2 - cos(z)/z
+    assert mjn(2, z) == (3/z**3 - 1/z)*sin(z) - (3/z**2) * cos(z)
+    assert mjn(3, z) == (15/z**4 - 6/z**2)*sin(z) + (1/z - 15/z**3)*cos(z)
+    assert mjn(4, z) == (1/z + 105/z**5 - 45/z**3)*sin(z) + \
+        (-105/z**4 + 10/z**2)*cos(z)
+    assert mjn(5, z) == (945/z**6 - 420/z**4 + 15/z**2)*sin(z) + \
+        (-1/z - 945/z**5 + 105/z**3)*cos(z)
+    assert mjn(6, z) == (-1/z + 10395/z**7 - 4725/z**5 + 210/z**3)*sin(z) + \
+        (-10395/z**6 + 1260/z**4 - 21/z**2)*cos(z)
+
+    assert expand_func(jn(n, z)) == jn(n, z)
+
+    # SBFs not defined for complex-valued orders
+    assert jn(2+3j, 5.2+0.3j).evalf() == jn(2+3j, 5.2+0.3j)
+
+    assert eq([jn(2, 5.2+0.3j).evalf(10)],
+              [0.09941975672 - 0.05452508024*I])
+
+
+def test_yn():
+    z = symbols("z")
+    assert myn(0, z) == -cos(z)/z
+    assert myn(1, z) == -cos(z)/z**2 - sin(z)/z
+    assert myn(2, z) == -((3/z**3 - 1/z)*cos(z) + (3/z**2)*sin(z))
+    assert expand_func(yn(n, z)) == yn(n, z)
+
+    # SBFs not defined for complex-valued orders
+    assert yn(2+3j, 5.2+0.3j).evalf() == yn(2+3j, 5.2+0.3j)
+
+    assert eq([yn(2, 5.2+0.3j).evalf(10)],
+              [0.185250342 + 0.01489557397*I])
+
+
+def test_sympify_yn():
+    assert S(15) in myn(3, pi).atoms()
+    assert myn(3, pi) == 15/pi**4 - 6/pi**2
+
+
+def eq(a, b, tol=1e-6):
+    for u, v in zip(a, b):
+        if not (abs(u - v) < tol):
+            return False
+    return True
+
+
+def test_jn_zeros():
+    assert eq(jn_zeros(0, 4), [3.141592, 6.283185, 9.424777, 12.566370])
+    assert eq(jn_zeros(1, 4), [4.493409, 7.725251, 10.904121, 14.066193])
+    assert eq(jn_zeros(2, 4), [5.763459, 9.095011, 12.322940, 15.514603])
+    assert eq(jn_zeros(3, 4), [6.987932, 10.417118, 13.698023, 16.923621])
+    assert eq(jn_zeros(4, 4), [8.182561, 11.704907, 15.039664, 18.301255])
+
+
+def test_bessel_eval():
+    n, m, k = Symbol('n', integer=True), Symbol('m'), Symbol('k', integer=True, zero=False)
+
+    for f in [besselj, besseli]:
+        assert f(0, 0) is S.One
+        assert f(2.1, 0) is S.Zero
+        assert f(-3, 0) is S.Zero
+        assert f(-10.2, 0) is S.ComplexInfinity
+        assert f(1 + 3*I, 0) is S.Zero
+        assert f(-3 + I, 0) is S.ComplexInfinity
+        assert f(-2*I, 0) is S.NaN
+        assert f(n, 0) != S.One and f(n, 0) != S.Zero
+        assert f(m, 0) != S.One and f(m, 0) != S.Zero
+        assert f(k, 0) is S.Zero
+
+    assert bessely(0, 0) is S.NegativeInfinity
+    assert besselk(0, 0) is S.Infinity
+    for f in [bessely, besselk]:
+        assert f(1 + I, 0) is S.ComplexInfinity
+        assert f(I, 0) is S.NaN
+
+    for f in [besselj, bessely]:
+        assert f(m, S.Infinity) is S.Zero
+        assert f(m, S.NegativeInfinity) is S.Zero
+
+    for f in [besseli, besselk]:
+        assert f(m, I*S.Infinity) is S.Zero
+        assert f(m, I*S.NegativeInfinity) is S.Zero
+
+    for f in [besseli, besselk]:
+        assert f(-4, z) == f(4, z)
+        assert f(-3, z) == f(3, z)
+        assert f(-n, z) == f(n, z)
+        assert f(-m, z) != f(m, z)
+
+    for f in [besselj, bessely]:
+        assert f(-4, z) == f(4, z)
+        assert f(-3, z) == -f(3, z)
+        assert f(-n, z) == (-1)**n*f(n, z)
+        assert f(-m, z) != (-1)**m*f(m, z)
+
+    for f in [besselj, besseli]:
+        assert f(m, -z) == (-z)**m*z**(-m)*f(m, z)
+
+    assert besseli(2, -z) == besseli(2, z)
+    assert besseli(3, -z) == -besseli(3, z)
+
+    assert besselj(0, -z) == besselj(0, z)
+    assert besselj(1, -z) == -besselj(1, z)
+
+    assert besseli(0, I*z) == besselj(0, z)
+    assert besseli(1, I*z) == I*besselj(1, z)
+    assert besselj(3, I*z) == -I*besseli(3, z)
+
+
+def test_bessel_nan():
+    # FIXME: could have these return NaN; for now just fix infinite recursion
+    for f in [besselj, bessely, besseli, besselk, hankel1, hankel2, yn, jn]:
+        assert f(1, S.NaN) == f(1, S.NaN, evaluate=False)
+
+
+def test_meromorphic():
+    assert besselj(2, x).is_meromorphic(x, 1) == True
+    assert besselj(2, x).is_meromorphic(x, 0) == True
+    assert besselj(2, x).is_meromorphic(x, oo) == False
+    assert besselj(S(2)/3, x).is_meromorphic(x, 1) == True
+    assert besselj(S(2)/3, x).is_meromorphic(x, 0) == False
+    assert besselj(S(2)/3, x).is_meromorphic(x, oo) == False
+    assert besselj(x, 2*x).is_meromorphic(x, 2) == False
+    assert besselk(0, x).is_meromorphic(x, 1) == True
+    assert besselk(2, x).is_meromorphic(x, 0) == True
+    assert besseli(0, x).is_meromorphic(x, 1) == True
+    assert besseli(2, x).is_meromorphic(x, 0) == True
+    assert bessely(0, x).is_meromorphic(x, 1) == True
+    assert bessely(0, x).is_meromorphic(x, 0) == False
+    assert bessely(2, x).is_meromorphic(x, 0) == True
+    assert hankel1(3, x**2 + 2*x).is_meromorphic(x, 1) == True
+    assert hankel1(0, x).is_meromorphic(x, 0) == False
+    assert hankel2(11, 4).is_meromorphic(x, 5) == True
+    assert hn1(6, 7*x**3 + 4).is_meromorphic(x, 7) == True
+    assert hn2(3, 2*x).is_meromorphic(x, 9) == True
+    assert jn(5, 2*x + 7).is_meromorphic(x, 4) == True
+    assert yn(8, x**2 + 11).is_meromorphic(x, 6) == True
+
+
+def test_conjugate():
+    n = Symbol('n')
+    z = Symbol('z', extended_real=False)
+    x = Symbol('x', extended_real=True)
+    y = Symbol('y', 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_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):
+        from sympy.core.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_airy_base():
+    z = Symbol('z')
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+
+    assert conjugate(airyai(z)) == airyai(conjugate(z))
+    assert airyai(x).is_extended_real
+
+    assert airyai(x+I*y).as_real_imag() == (
+            airyai(x - I*y)/2 + airyai(x + I*y)/2,
+            I*(airyai(x - I*y) - airyai(x + I*y))/2)
+
+
+def test_airyai():
+    z = Symbol('z', real=False)
+    t = Symbol('t', negative=True)
+    p = Symbol('p', positive=True)
+
+    assert isinstance(airyai(z), airyai)
+
+    assert airyai(0) == 3**Rational(1, 3)/(3*gamma(Rational(2, 3)))
+    assert airyai(oo) == 0
+    assert airyai(-oo) == 0
+
+    assert diff(airyai(z), z) == airyaiprime(z)
+
+    assert series(airyai(z), z, 0, 3) == (
+        3**Rational(5, 6)*gamma(Rational(1, 3))/(6*pi) - 3**Rational(1, 6)*z*gamma(Rational(2, 3))/(2*pi) + O(z**3))
+
+    assert airyai(z).rewrite(hyper) == (
+        -3**Rational(2, 3)*z*hyper((), (Rational(4, 3),), z**3/9)/(3*gamma(Rational(1, 3))) +
+         3**Rational(1, 3)*hyper((), (Rational(2, 3),), z**3/9)/(3*gamma(Rational(2, 3))))
+
+    assert isinstance(airyai(z).rewrite(besselj), airyai)
+    assert airyai(t).rewrite(besselj) == (
+        sqrt(-t)*(besselj(Rational(-1, 3), 2*(-t)**Rational(3, 2)/3) +
+                  besselj(Rational(1, 3), 2*(-t)**Rational(3, 2)/3))/3)
+    assert airyai(z).rewrite(besseli) == (
+        -z*besseli(Rational(1, 3), 2*z**Rational(3, 2)/3)/(3*(z**Rational(3, 2))**Rational(1, 3)) +
+         (z**Rational(3, 2))**Rational(1, 3)*besseli(Rational(-1, 3), 2*z**Rational(3, 2)/3)/3)
+    assert airyai(p).rewrite(besseli) == (
+        sqrt(p)*(besseli(Rational(-1, 3), 2*p**Rational(3, 2)/3) -
+                 besseli(Rational(1, 3), 2*p**Rational(3, 2)/3))/3)
+
+    assert expand_func(airyai(2*(3*z**5)**Rational(1, 3))) == (
+        -sqrt(3)*(-1 + (z**5)**Rational(1, 3)/z**Rational(5, 3))*airybi(2*3**Rational(1, 3)*z**Rational(5, 3))/6 +
+         (1 + (z**5)**Rational(1, 3)/z**Rational(5, 3))*airyai(2*3**Rational(1, 3)*z**Rational(5, 3))/2)
+
+
+def test_airybi():
+    z = Symbol('z', real=False)
+    t = Symbol('t', negative=True)
+    p = Symbol('p', positive=True)
+
+    assert isinstance(airybi(z), airybi)
+
+    assert airybi(0) == 3**Rational(5, 6)/(3*gamma(Rational(2, 3)))
+    assert airybi(oo) is oo
+    assert airybi(-oo) == 0
+
+    assert diff(airybi(z), z) == airybiprime(z)
+
+    assert series(airybi(z), z, 0, 3) == (
+        3**Rational(1, 3)*gamma(Rational(1, 3))/(2*pi) + 3**Rational(2, 3)*z*gamma(Rational(2, 3))/(2*pi) + O(z**3))
+
+    assert airybi(z).rewrite(hyper) == (
+        3**Rational(1, 6)*z*hyper((), (Rational(4, 3),), z**3/9)/gamma(Rational(1, 3)) +
+        3**Rational(5, 6)*hyper((), (Rational(2, 3),), z**3/9)/(3*gamma(Rational(2, 3))))
+
+    assert isinstance(airybi(z).rewrite(besselj), airybi)
+    assert airyai(t).rewrite(besselj) == (
+        sqrt(-t)*(besselj(Rational(-1, 3), 2*(-t)**Rational(3, 2)/3) +
+                  besselj(Rational(1, 3), 2*(-t)**Rational(3, 2)/3))/3)
+    assert airybi(z).rewrite(besseli) == (
+        sqrt(3)*(z*besseli(Rational(1, 3), 2*z**Rational(3, 2)/3)/(z**Rational(3, 2))**Rational(1, 3) +
+                 (z**Rational(3, 2))**Rational(1, 3)*besseli(Rational(-1, 3), 2*z**Rational(3, 2)/3))/3)
+    assert airybi(p).rewrite(besseli) == (
+        sqrt(3)*sqrt(p)*(besseli(Rational(-1, 3), 2*p**Rational(3, 2)/3) +
+                         besseli(Rational(1, 3), 2*p**Rational(3, 2)/3))/3)
+
+    assert expand_func(airybi(2*(3*z**5)**Rational(1, 3))) == (
+        sqrt(3)*(1 - (z**5)**Rational(1, 3)/z**Rational(5, 3))*airyai(2*3**Rational(1, 3)*z**Rational(5, 3))/2 +
+        (1 + (z**5)**Rational(1, 3)/z**Rational(5, 3))*airybi(2*3**Rational(1, 3)*z**Rational(5, 3))/2)
+
+
+def test_airyaiprime():
+    z = Symbol('z', real=False)
+    t = Symbol('t', negative=True)
+    p = Symbol('p', positive=True)
+
+    assert isinstance(airyaiprime(z), airyaiprime)
+
+    assert airyaiprime(0) == -3**Rational(2, 3)/(3*gamma(Rational(1, 3)))
+    assert airyaiprime(oo) == 0
+
+    assert diff(airyaiprime(z), z) == z*airyai(z)
+
+    assert series(airyaiprime(z), z, 0, 3) == (
+        -3**Rational(2, 3)/(3*gamma(Rational(1, 3))) + 3**Rational(1, 3)*z**2/(6*gamma(Rational(2, 3))) + O(z**3))
+
+    assert airyaiprime(z).rewrite(hyper) == (
+        3**Rational(1, 3)*z**2*hyper((), (Rational(5, 3),), z**3/9)/(6*gamma(Rational(2, 3))) -
+        3**Rational(2, 3)*hyper((), (Rational(1, 3),), z**3/9)/(3*gamma(Rational(1, 3))))
+
+    assert isinstance(airyaiprime(z).rewrite(besselj), airyaiprime)
+    assert airyai(t).rewrite(besselj) == (
+        sqrt(-t)*(besselj(Rational(-1, 3), 2*(-t)**Rational(3, 2)/3) +
+                  besselj(Rational(1, 3), 2*(-t)**Rational(3, 2)/3))/3)
+    assert airyaiprime(z).rewrite(besseli) == (
+        z**2*besseli(Rational(2, 3), 2*z**Rational(3, 2)/3)/(3*(z**Rational(3, 2))**Rational(2, 3)) -
+        (z**Rational(3, 2))**Rational(2, 3)*besseli(Rational(-1, 3), 2*z**Rational(3, 2)/3)/3)
+    assert airyaiprime(p).rewrite(besseli) == (
+        p*(-besseli(Rational(-2, 3), 2*p**Rational(3, 2)/3) + besseli(Rational(2, 3), 2*p**Rational(3, 2)/3))/3)
+
+    assert expand_func(airyaiprime(2*(3*z**5)**Rational(1, 3))) == (
+        sqrt(3)*(z**Rational(5, 3)/(z**5)**Rational(1, 3) - 1)*airybiprime(2*3**Rational(1, 3)*z**Rational(5, 3))/6 +
+        (z**Rational(5, 3)/(z**5)**Rational(1, 3) + 1)*airyaiprime(2*3**Rational(1, 3)*z**Rational(5, 3))/2)
+
+
+def test_airybiprime():
+    z = Symbol('z', real=False)
+    t = Symbol('t', negative=True)
+    p = Symbol('p', positive=True)
+
+    assert isinstance(airybiprime(z), airybiprime)
+
+    assert airybiprime(0) == 3**Rational(1, 6)/gamma(Rational(1, 3))
+    assert airybiprime(oo) is oo
+    assert airybiprime(-oo) == 0
+
+    assert diff(airybiprime(z), z) == z*airybi(z)
+
+    assert series(airybiprime(z), z, 0, 3) == (
+        3**Rational(1, 6)/gamma(Rational(1, 3)) + 3**Rational(5, 6)*z**2/(6*gamma(Rational(2, 3))) + O(z**3))
+
+    assert airybiprime(z).rewrite(hyper) == (
+        3**Rational(5, 6)*z**2*hyper((), (Rational(5, 3),), z**3/9)/(6*gamma(Rational(2, 3))) +
+        3**Rational(1, 6)*hyper((), (Rational(1, 3),), z**3/9)/gamma(Rational(1, 3)))
+
+    assert isinstance(airybiprime(z).rewrite(besselj), airybiprime)
+    assert airyai(t).rewrite(besselj) == (
+        sqrt(-t)*(besselj(Rational(-1, 3), 2*(-t)**Rational(3, 2)/3) +
+                  besselj(Rational(1, 3), 2*(-t)**Rational(3, 2)/3))/3)
+    assert airybiprime(z).rewrite(besseli) == (
+        sqrt(3)*(z**2*besseli(Rational(2, 3), 2*z**Rational(3, 2)/3)/(z**Rational(3, 2))**Rational(2, 3) +
+                 (z**Rational(3, 2))**Rational(2, 3)*besseli(Rational(-2, 3), 2*z**Rational(3, 2)/3))/3)
+    assert airybiprime(p).rewrite(besseli) == (
+        sqrt(3)*p*(besseli(Rational(-2, 3), 2*p**Rational(3, 2)/3) + besseli(Rational(2, 3), 2*p**Rational(3, 2)/3))/3)
+
+    assert expand_func(airybiprime(2*(3*z**5)**Rational(1, 3))) == (
+        sqrt(3)*(z**Rational(5, 3)/(z**5)**Rational(1, 3) - 1)*airyaiprime(2*3**Rational(1, 3)*z**Rational(5, 3))/2 +
+        (z**Rational(5, 3)/(z**5)**Rational(1, 3) + 1)*airybiprime(2*3**Rational(1, 3)*z**Rational(5, 3))/2)
+
+
+def test_marcumq():
+    m = Symbol('m')
+    a = Symbol('a')
+    b = Symbol('b')
+
+    assert marcumq(0, 0, 0) == 0
+    assert marcumq(m, 0, b) == uppergamma(m, b**2/2)/gamma(m)
+    assert marcumq(2, 0, 5) == 27*exp(Rational(-25, 2))/2
+    assert marcumq(0, a, 0) == 1 - exp(-a**2/2)
+    assert marcumq(0, pi, 0) == 1 - exp(-pi**2/2)
+    assert marcumq(1, a, a) == S.Half + exp(-a**2)*besseli(0, a**2)/2
+    assert marcumq(2, a, a) == S.Half + exp(-a**2)*besseli(0, a**2)/2 + exp(-a**2)*besseli(1, a**2)
+
+    assert diff(marcumq(1, a, 3), a) == a*(-marcumq(1, a, 3) + marcumq(2, a, 3))
+    assert diff(marcumq(2, 3, b), b) == -b**2*exp(-b**2/2 - Rational(9, 2))*besseli(1, 3*b)/3
+
+    x = Symbol('x')
+    assert marcumq(2, 3, 4).rewrite(Integral, x=x) == \
+           Integral(x**2*exp(-x**2/2 - Rational(9, 2))*besseli(1, 3*x), (x, 4, oo))/3
+    assert eq([marcumq(5, -2, 3).rewrite(Integral).evalf(10)],
+              [0.7905769565])
+
+    k = Symbol('k')
+    assert marcumq(-3, -5, -7).rewrite(Sum, k=k) == \
+           exp(-37)*Sum((Rational(5, 7))**k*besseli(k, 35), (k, 4, oo))
+    assert eq([marcumq(1, 3, 1).rewrite(Sum).evalf(10)],
+              [0.9891705502])
+
+    assert marcumq(1, a, a, evaluate=False).rewrite(besseli) == S.Half + exp(-a**2)*besseli(0, a**2)/2
+    assert marcumq(2, a, a, evaluate=False).rewrite(besseli) == S.Half + exp(-a**2)*besseli(0, a**2)/2 + \
+           exp(-a**2)*besseli(1, a**2)
+    assert marcumq(3, a, a).rewrite(besseli) == (besseli(1, a**2) + besseli(2, a**2))*exp(-a**2) + \
+           S.Half + exp(-a**2)*besseli(0, a**2)/2
+    assert marcumq(5, 8, 8).rewrite(besseli) == exp(-64)*besseli(0, 64)/2 + \
+           (besseli(4, 64) + besseli(3, 64) + besseli(2, 64) + besseli(1, 64))*exp(-64) + S.Half
+    assert marcumq(m, a, a).rewrite(besseli) == marcumq(m, a, a)
+
+    x = Symbol('x', integer=True)
+    assert marcumq(x, a, a).rewrite(besseli) == marcumq(x, a, a)

env-llmeval/lib/python3.10/site-packages/sympy/functions/special/tests/test_bsplines.py

@@ -0,0 +1,167 @@
+from sympy.functions import bspline_basis_set, interpolating_spline
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.logic.boolalg import And
+from sympy.sets.sets import Interval
+from sympy.testing.pytest import slow
+
+x, y = symbols('x,y')
+
+
+def test_basic_degree_0():
+    d = 0
+    knots = range(5)
+    splines = bspline_basis_set(d, knots, x)
+    for i in range(len(splines)):
+        assert splines[i] == Piecewise((1, Interval(i, i + 1).contains(x)),
+                                       (0, True))
+
+
+def test_basic_degree_1():
+    d = 1
+    knots = range(5)
+    splines = bspline_basis_set(d, knots, x)
+    assert splines[0] == Piecewise((x, Interval(0, 1).contains(x)),
+                                   (2 - x, Interval(1, 2).contains(x)),
+                                   (0, True))
+    assert splines[1] == Piecewise((-1 + x, Interval(1, 2).contains(x)),
+                                   (3 - x, Interval(2, 3).contains(x)),
+                                   (0, True))
+    assert splines[2] == Piecewise((-2 + x, Interval(2, 3).contains(x)),
+                                   (4 - x, Interval(3, 4).contains(x)),
+                                   (0, True))
+
+
+def test_basic_degree_2():
+    d = 2
+    knots = range(5)
+    splines = bspline_basis_set(d, knots, x)
+    b0 = Piecewise((x**2/2, Interval(0, 1).contains(x)),
+                   (Rational(-3, 2) + 3*x - x**2, Interval(1, 2).contains(x)),
+                   (Rational(9, 2) - 3*x + x**2/2, Interval(2, 3).contains(x)),
+                   (0, True))
+    b1 = Piecewise((S.Half - x + x**2/2, Interval(1, 2).contains(x)),
+                   (Rational(-11, 2) + 5*x - x**2, Interval(2, 3).contains(x)),
+                   (8 - 4*x + x**2/2, Interval(3, 4).contains(x)),
+                   (0, True))
+    assert splines[0] == b0
+    assert splines[1] == b1
+
+
+def test_basic_degree_3():
+    d = 3
+    knots = range(5)
+    splines = bspline_basis_set(d, knots, x)
+    b0 = Piecewise(
+        (x**3/6, Interval(0, 1).contains(x)),
+        (Rational(2, 3) - 2*x + 2*x**2 - x**3/2, Interval(1, 2).contains(x)),
+        (Rational(-22, 3) + 10*x - 4*x**2 + x**3/2, Interval(2, 3).contains(x)),
+        (Rational(32, 3) - 8*x + 2*x**2 - x**3/6, Interval(3, 4).contains(x)),
+        (0, True)
+    )
+    assert splines[0] == b0
+
+
+def test_repeated_degree_1():
+    d = 1
+    knots = [0, 0, 1, 2, 2, 3, 4, 4]
+    splines = bspline_basis_set(d, knots, x)
+    assert splines[0] == Piecewise((1 - x, Interval(0, 1).contains(x)),
+                                   (0, True))
+    assert splines[1] == Piecewise((x, Interval(0, 1).contains(x)),
+                                   (2 - x, Interval(1, 2).contains(x)),
+                                   (0, True))
+    assert splines[2] == Piecewise((-1 + x, Interval(1, 2).contains(x)),
+                                   (0, True))
+    assert splines[3] == Piecewise((3 - x, Interval(2, 3).contains(x)),
+                                   (0, True))
+    assert splines[4] == Piecewise((-2 + x, Interval(2, 3).contains(x)),
+                                   (4 - x, Interval(3, 4).contains(x)),
+                                   (0, True))
+    assert splines[5] == Piecewise((-3 + x, Interval(3, 4).contains(x)),
+                                   (0, True))
+
+
+def test_repeated_degree_2():
+    d = 2
+    knots = [0, 0, 1, 2, 2, 3, 4, 4]
+    splines = bspline_basis_set(d, knots, x)
+
+    assert splines[0] == Piecewise(((-3*x**2/2 + 2*x), And(x <= 1, x >= 0)),
+                                   (x**2/2 - 2*x + 2, And(x <= 2, x >= 1)),
+                                   (0, True))
+    assert splines[1] == Piecewise((x**2/2, And(x <= 1, x >= 0)),
+                                   (-3*x**2/2 + 4*x - 2, And(x <= 2, x >= 1)),
+                                   (0, True))
+    assert splines[2] == Piecewise((x**2 - 2*x + 1, And(x <= 2, x >= 1)),
+                                   (x**2 - 6*x + 9, And(x <= 3, x >= 2)),
+                                   (0, True))
+    assert splines[3] == Piecewise((-3*x**2/2 + 8*x - 10, And(x <= 3, x >= 2)),
+                                   (x**2/2 - 4*x + 8, And(x <= 4, x >= 3)),
+                                   (0, True))
+    assert splines[4] == Piecewise((x**2/2 - 2*x + 2, And(x <= 3, x >= 2)),
+                                   (-3*x**2/2 + 10*x - 16, And(x <= 4, x >= 3)),
+                                   (0, True))
+
+# Tests for interpolating_spline
+
+
+def test_10_points_degree_1():
+    d = 1
+    X = [-5, 2, 3, 4, 7, 9, 10, 30, 31, 34]
+    Y = [-10, -2, 2, 4, 7, 6, 20, 45, 19, 25]
+    spline = interpolating_spline(d, x, X, Y)
+
+    assert spline == Piecewise((x*Rational(8, 7) - Rational(30, 7), (x >= -5) & (x <= 2)), (4*x - 10, (x >= 2) & (x <= 3)),
+                               (2*x - 4, (x >= 3) & (x <= 4)), (x, (x >= 4) & (x <= 7)),
+                               (-x/2 + Rational(21, 2), (x >= 7) & (x <= 9)), (14*x - 120, (x >= 9) & (x <= 10)),
+                               (x*Rational(5, 4) + Rational(15, 2), (x >= 10) & (x <= 30)), (-26*x + 825, (x >= 30) & (x <= 31)),
+                               (2*x - 43, (x >= 31) & (x <= 34)))
+
+
+def test_3_points_degree_2():
+    d = 2
+    X = [-3, 10, 19]
+    Y = [3, -4, 30]
+    spline = interpolating_spline(d, x, X, Y)
+
+    assert spline == Piecewise((505*x**2/2574 - x*Rational(4921, 2574) - Rational(1931, 429), (x >= -3) & (x <= 19)))
+
+
+def test_5_points_degree_2():
+    d = 2
+    X = [-3, 2, 4, 5, 10]
+    Y = [-1, 2, 5, 10, 14]
+    spline = interpolating_spline(d, x, X, Y)
+
+    assert spline == Piecewise((4*x**2/329 + x*Rational(1007, 1645) + Rational(1196, 1645), (x >= -3) & (x <= 3)),
+                               (2701*x**2/1645 - x*Rational(15079, 1645) + Rational(5065, 329), (x >= 3) & (x <= Rational(9, 2))),
+                               (-1319*x**2/1645 + x*Rational(21101, 1645) - Rational(11216, 329), (x >= Rational(9, 2)) & (x <= 10)))
+
+
+@slow
+def test_6_points_degree_3():
+    d = 3
+    X = [-1, 0, 2, 3, 9, 12]
+    Y = [-4, 3, 3, 7, 9, 20]
+    spline = interpolating_spline(d, x, X, Y)
+
+    assert spline == Piecewise((6058*x**3/5301 - 18427*x**2/5301 + x*Rational(12622, 5301) + 3, (x >= -1) & (x <= 2)),
+                               (-8327*x**3/5301 + 67883*x**2/5301 - x*Rational(159998, 5301) + Rational(43661, 1767), (x >= 2) & (x <= 3)),
+                               (5414*x**3/47709 - 1386*x**2/589 + x*Rational(4267, 279) - Rational(12232, 589), (x >= 3) & (x <= 12)))
+
+
+def test_issue_19262():
+    Delta = symbols('Delta', positive=True)
+    knots = [i*Delta for i in range(4)]
+    basis = bspline_basis_set(1, knots, x)
+    y = symbols('y', nonnegative=True)
+    basis2 = bspline_basis_set(1, knots, y)
+    assert basis[0].subs(x, y) == basis2[0]
+    assert interpolating_spline(1, x,
+        [Delta*i for i in [1, 2, 4, 7]], [3, 6, 5, 7]
+        )  == Piecewise((3*x/Delta, (Delta <= x) & (x <= 2*Delta)),
+        (7 - x/(2*Delta), (x >= 2*Delta) & (x <= 4*Delta)),
+        (Rational(7, 3) + 2*x/(3*Delta), (x >= 4*Delta) & (x <= 7*Delta)))

env-llmeval/lib/python3.10/site-packages/sympy/functions/special/tests/test_delta_functions.py

@@ -0,0 +1,165 @@
+from sympy.core.numbers import (I, nan, oo, pi)
+from sympy.core.relational import (Eq, Ne)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import (adjoint, conjugate, sign, transpose)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.delta_functions import (DiracDelta, Heaviside)
+from sympy.functions.special.singularity_functions import SingularityFunction
+from sympy.simplify.simplify import signsimp
+
+
+from sympy.testing.pytest import raises
+
+from sympy.core.expr import unchanged
+
+from sympy.core.function import ArgumentIndexError
+
+
+x, y = symbols('x y')
+i = symbols('t', nonzero=True)
+j = symbols('j', positive=True)
+k = symbols('k', negative=True)
+
+def test_DiracDelta():
+    assert DiracDelta(1) == 0
+    assert DiracDelta(5.1) == 0
+    assert DiracDelta(-pi) == 0
+    assert DiracDelta(5, 7) == 0
+    assert DiracDelta(x, 0) == DiracDelta(x)
+    assert DiracDelta(i) == 0
+    assert DiracDelta(j) == 0
+    assert DiracDelta(k) == 0
+    assert DiracDelta(nan) is nan
+    assert DiracDelta(0).func is DiracDelta
+    assert DiracDelta(x).func is DiracDelta
+    # FIXME: this is generally undefined @ x=0
+    #         But then limit(Delta(c)*Heaviside(x),x,-oo)
+    #         need's to be implemented.
+    # assert 0*DiracDelta(x) == 0
+
+    assert adjoint(DiracDelta(x)) == DiracDelta(x)
+    assert adjoint(DiracDelta(x - y)) == DiracDelta(x - y)
+    assert conjugate(DiracDelta(x)) == DiracDelta(x)
+    assert conjugate(DiracDelta(x - y)) == DiracDelta(x - y)
+    assert transpose(DiracDelta(x)) == DiracDelta(x)
+    assert transpose(DiracDelta(x - y)) == DiracDelta(x - y)
+
+    assert DiracDelta(x).diff(x) == DiracDelta(x, 1)
+    assert DiracDelta(x, 1).diff(x) == DiracDelta(x, 2)
+
+    assert DiracDelta(x).is_simple(x) is True
+    assert DiracDelta(3*x).is_simple(x) is True
+    assert DiracDelta(x**2).is_simple(x) is False
+    assert DiracDelta(sqrt(x)).is_simple(x) is False
+    assert DiracDelta(x).is_simple(y) is False
+
+    assert DiracDelta(x*y).expand(diracdelta=True, wrt=x) == DiracDelta(x)/abs(y)
+    assert DiracDelta(x*y).expand(diracdelta=True, wrt=y) == DiracDelta(y)/abs(x)
+    assert DiracDelta(x**2*y).expand(diracdelta=True, wrt=x) == DiracDelta(x**2*y)
+    assert DiracDelta(y).expand(diracdelta=True, wrt=x) == DiracDelta(y)
+    assert DiracDelta((x - 1)*(x - 2)*(x - 3)).expand(diracdelta=True, wrt=x) == (
+        DiracDelta(x - 3)/2 + DiracDelta(x - 2) + DiracDelta(x - 1)/2)
+
+    assert DiracDelta(2*x) != DiracDelta(x)  # scaling property
+    assert DiracDelta(x) == DiracDelta(-x)  # even function
+    assert DiracDelta(-x, 2) == DiracDelta(x, 2)
+    assert DiracDelta(-x, 1) == -DiracDelta(x, 1)  # odd deriv is odd
+    assert DiracDelta(-oo*x) == DiracDelta(oo*x)
+    assert DiracDelta(x - y) != DiracDelta(y - x)
+    assert signsimp(DiracDelta(x - y) - DiracDelta(y - x)) == 0
+
+    assert DiracDelta(x*y).expand(diracdelta=True, wrt=x) == DiracDelta(x)/abs(y)
+    assert DiracDelta(x*y).expand(diracdelta=True, wrt=y) == DiracDelta(y)/abs(x)
+    assert DiracDelta(x**2*y).expand(diracdelta=True, wrt=x) == DiracDelta(x**2*y)
+    assert DiracDelta(y).expand(diracdelta=True, wrt=x) == DiracDelta(y)
+    assert DiracDelta((x - 1)*(x - 2)*(x - 3)).expand(diracdelta=True) == (
+            DiracDelta(x - 3)/2 + DiracDelta(x - 2) + DiracDelta(x - 1)/2)
+
+    raises(ArgumentIndexError, lambda: DiracDelta(x).fdiff(2))
+    raises(ValueError, lambda: DiracDelta(x, -1))
+    raises(ValueError, lambda: DiracDelta(I))
+    raises(ValueError, lambda: DiracDelta(2 + 3*I))
+
+
+def test_heaviside():
+    assert Heaviside(-5) == 0
+    assert Heaviside(1) == 1
+    assert Heaviside(0) == S.Half
+
+    assert Heaviside(0, x) == x
+    assert unchanged(Heaviside,x, nan)
+    assert Heaviside(0, nan) == nan
+
+    h0  = Heaviside(x, 0)
+    h12 = Heaviside(x, S.Half)
+    h1  = Heaviside(x, 1)
+
+    assert h0.args == h0.pargs == (x, 0)
+    assert h1.args == h1.pargs == (x, 1)
+    assert h12.args == (x, S.Half)
+    assert h12.pargs == (x,) # default 1/2 suppressed
+
+    assert adjoint(Heaviside(x)) == Heaviside(x)
+    assert adjoint(Heaviside(x - y)) == Heaviside(x - y)
+    assert conjugate(Heaviside(x)) == Heaviside(x)
+    assert conjugate(Heaviside(x - y)) == Heaviside(x - y)
+    assert transpose(Heaviside(x)) == Heaviside(x)
+    assert transpose(Heaviside(x - y)) == Heaviside(x - y)
+
+    assert Heaviside(x).diff(x) == DiracDelta(x)
+    assert Heaviside(x + I).is_Function is True
+    assert Heaviside(I*x).is_Function is True
+
+    raises(ArgumentIndexError, lambda: Heaviside(x).fdiff(2))
+    raises(ValueError, lambda: Heaviside(I))
+    raises(ValueError, lambda: Heaviside(2 + 3*I))
+
+
+def test_rewrite():
+    x, y = Symbol('x', real=True), Symbol('y')
+    assert Heaviside(x).rewrite(Piecewise) == (
+        Piecewise((0, x < 0), (Heaviside(0), Eq(x, 0)), (1, True)))
+    assert Heaviside(y).rewrite(Piecewise) == (
+        Piecewise((0, y < 0), (Heaviside(0), Eq(y, 0)), (1, True)))
+    assert Heaviside(x, y).rewrite(Piecewise) == (
+        Piecewise((0, x < 0), (y, Eq(x, 0)), (1, True)))
+    assert Heaviside(x, 0).rewrite(Piecewise) == (
+        Piecewise((0, x <= 0), (1, True)))
+    assert Heaviside(x, 1).rewrite(Piecewise) == (
+        Piecewise((0, x < 0), (1, True)))
+    assert Heaviside(x, nan).rewrite(Piecewise) == (
+        Piecewise((0, x < 0), (nan, Eq(x, 0)), (1, True)))
+
+    assert Heaviside(x).rewrite(sign) == \
+        Heaviside(x, H0=Heaviside(0)).rewrite(sign) == \
+        Piecewise(
+            (sign(x)/2 + S(1)/2, Eq(Heaviside(0), S(1)/2)),
+            (Piecewise(
+                (sign(x)/2 + S(1)/2, Ne(x, 0)), (Heaviside(0), True)), True)
+        )
+
+    assert Heaviside(y).rewrite(sign) == Heaviside(y)
+    assert Heaviside(x, S.Half).rewrite(sign) == (sign(x)+1)/2
+    assert Heaviside(x, y).rewrite(sign) == \
+        Piecewise(
+            (sign(x)/2 + S(1)/2, Eq(y, S(1)/2)),
+            (Piecewise(
+                (sign(x)/2 + S(1)/2, Ne(x, 0)), (y, True)), True)
+        )
+
+    assert DiracDelta(y).rewrite(Piecewise) == Piecewise((DiracDelta(0), Eq(y, 0)), (0, True))
+    assert DiracDelta(y, 1).rewrite(Piecewise) == DiracDelta(y, 1)
+    assert DiracDelta(x - 5).rewrite(Piecewise) == (
+        Piecewise((DiracDelta(0), Eq(x - 5, 0)), (0, True)))
+
+    assert (x*DiracDelta(x - 10)).rewrite(SingularityFunction) == x*SingularityFunction(x, 10, -1)
+    assert 5*x*y*DiracDelta(y, 1).rewrite(SingularityFunction) == 5*x*y*SingularityFunction(y, 0, -2)
+    assert DiracDelta(0).rewrite(SingularityFunction) == SingularityFunction(0, 0, -1)
+    assert DiracDelta(0, 1).rewrite(SingularityFunction) == SingularityFunction(0, 0, -2)
+
+    assert Heaviside(x).rewrite(SingularityFunction) == SingularityFunction(x, 0, 0)
+    assert 5*x*y*Heaviside(y + 1).rewrite(SingularityFunction) == 5*x*y*SingularityFunction(y, -1, 0)
+    assert ((x - 3)**3*Heaviside(x - 3)).rewrite(SingularityFunction) == (x - 3)**3*SingularityFunction(x, 3, 0)
+    assert Heaviside(0).rewrite(SingularityFunction) == S.Half

env-llmeval/lib/python3.10/site-packages/sympy/functions/special/tests/test_error_functions.py

@@ -0,0 +1,816 @@
+from sympy.core.function import (diff, expand, expand_func)
+from sympy.core import EulerGamma
+from sympy.core.numbers import (E, Float, I, Rational, nan, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import (conjugate, im, polar_lift, re)
+from sympy.functions.elementary.exponential import (exp, exp_polar, log)
+from sympy.functions.elementary.hyperbolic import (cosh, sinh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin, sinc)
+from sympy.functions.special.error_functions import (Chi, Ci, E1, Ei, Li, Shi, Si, erf, erf2, erf2inv, erfc, erfcinv, erfi, erfinv, expint, fresnelc, fresnels, li)
+from sympy.functions.special.gamma_functions import (gamma, uppergamma)
+from sympy.functions.special.hyper import (hyper, meijerg)
+from sympy.integrals.integrals import (Integral, integrate)
+from sympy.series.gruntz import gruntz
+from sympy.series.limits import limit
+from sympy.series.order import O
+from sympy.core.expr import unchanged
+from sympy.core.function import ArgumentIndexError
+from sympy.functions.special.error_functions import _erfs, _eis
+from sympy.testing.pytest import raises
+
+x, y, z = symbols('x,y,z')
+w = Symbol("w", real=True)
+n = Symbol("n", integer=True)
+
+
+def test_erf():
+    assert erf(nan) is nan
+
+    assert erf(oo) == 1
+    assert erf(-oo) == -1
+
+    assert erf(0) is S.Zero
+
+    assert erf(I*oo) == oo*I
+    assert erf(-I*oo) == -oo*I
+
+    assert erf(-2) == -erf(2)
+    assert erf(-x*y) == -erf(x*y)
+    assert erf(-x - y) == -erf(x + y)
+
+    assert erf(erfinv(x)) == x
+    assert erf(erfcinv(x)) == 1 - x
+    assert erf(erf2inv(0, x)) == x
+    assert erf(erf2inv(0, x, evaluate=False)) == x # To cover code in erf
+    assert erf(erf2inv(0, erf(erfcinv(1 - erf(erfinv(x)))))) == x
+
+    assert erf(I).is_real is False
+    assert erf(0, evaluate=False).is_real
+    assert erf(0, evaluate=False).is_zero
+
+    assert conjugate(erf(z)) == erf(conjugate(z))
+
+    assert erf(x).as_leading_term(x) == 2*x/sqrt(pi)
+    assert erf(x*y).as_leading_term(y) == 2*x*y/sqrt(pi)
+    assert (erf(x*y)/erf(y)).as_leading_term(y) == x
+    assert erf(1/x).as_leading_term(x) == S.One
+
+    assert erf(z).rewrite('uppergamma') == sqrt(z**2)*(1 - erfc(sqrt(z**2)))/z
+    assert erf(z).rewrite('erfc') == S.One - erfc(z)
+    assert erf(z).rewrite('erfi') == -I*erfi(I*z)
+    assert erf(z).rewrite('fresnels') == (1 + I)*(fresnelc(z*(1 - I)/sqrt(pi)) -
+        I*fresnels(z*(1 - I)/sqrt(pi)))
+    assert erf(z).rewrite('fresnelc') == (1 + I)*(fresnelc(z*(1 - I)/sqrt(pi)) -
+        I*fresnels(z*(1 - I)/sqrt(pi)))
+    assert erf(z).rewrite('hyper') == 2*z*hyper([S.Half], [3*S.Half], -z**2)/sqrt(pi)
+    assert erf(z).rewrite('meijerg') == z*meijerg([S.Half], [], [0], [Rational(-1, 2)], z**2)/sqrt(pi)
+    assert erf(z).rewrite('expint') == sqrt(z**2)/z - z*expint(S.Half, z**2)/sqrt(S.Pi)
+
+    assert limit(exp(x)*exp(x**2)*(erf(x + 1/exp(x)) - erf(x)), x, oo) == \
+        2/sqrt(pi)
+    assert limit((1 - erf(z))*exp(z**2)*z, z, oo) == 1/sqrt(pi)
+    assert limit((1 - erf(x))*exp(x**2)*sqrt(pi)*x, x, oo) == 1
+    assert limit(((1 - erf(x))*exp(x**2)*sqrt(pi)*x - 1)*2*x**2, x, oo) == -1
+    assert limit(erf(x)/x, x, 0) == 2/sqrt(pi)
+    assert limit(x**(-4) - sqrt(pi)*erf(x**2) / (2*x**6), x, 0) == S(1)/3
+
+    assert erf(x).as_real_imag() == \
+        (erf(re(x) - I*im(x))/2 + erf(re(x) + I*im(x))/2,
+         -I*(-erf(re(x) - I*im(x)) + erf(re(x) + I*im(x)))/2)
+
+    assert erf(x).as_real_imag(deep=False) == \
+        (erf(re(x) - I*im(x))/2 + erf(re(x) + I*im(x))/2,
+         -I*(-erf(re(x) - I*im(x)) + erf(re(x) + I*im(x)))/2)
+
+    assert erf(w).as_real_imag() == (erf(w), 0)
+    assert erf(w).as_real_imag(deep=False) == (erf(w), 0)
+    # issue 13575
+    assert erf(I).as_real_imag() == (0, -I*erf(I))
+
+    raises(ArgumentIndexError, lambda: erf(x).fdiff(2))
+
+    assert erf(x).inverse() == erfinv
+
+
+def test_erf_series():
+    assert erf(x).series(x, 0, 7) == 2*x/sqrt(pi) - \
+        2*x**3/3/sqrt(pi) + x**5/5/sqrt(pi) + O(x**7)
+
+    assert erf(x).series(x, oo) == \
+        -exp(-x**2)*(3/(4*x**5) - 1/(2*x**3) + 1/x + O(x**(-6), (x, oo)))/sqrt(pi) + 1
+    assert erf(x**2).series(x, oo, n=8) == \
+        (-1/(2*x**6) + x**(-2) + O(x**(-8), (x, oo)))*exp(-x**4)/sqrt(pi)*-1 + 1
+    assert erf(sqrt(x)).series(x, oo, n=3) == (sqrt(1/x) - (1/x)**(S(3)/2)/2\
+        + 3*(1/x)**(S(5)/2)/4 + O(x**(-3), (x, oo)))*exp(-x)/sqrt(pi)*-1 + 1
+
+
+def test_erf_evalf():
+    assert abs( erf(Float(2.0)) - 0.995322265 ) < 1E-8 # XXX
+
+
+def test__erfs():
+    assert _erfs(z).diff(z) == -2/sqrt(S.Pi) + 2*z*_erfs(z)
+
+    assert _erfs(1/z).series(z) == \
+        z/sqrt(pi) - z**3/(2*sqrt(pi)) + 3*z**5/(4*sqrt(pi)) + O(z**6)
+
+    assert expand(erf(z).rewrite('tractable').diff(z).rewrite('intractable')) \
+        == erf(z).diff(z)
+    assert _erfs(z).rewrite("intractable") == (-erf(z) + 1)*exp(z**2)
+    raises(ArgumentIndexError, lambda: _erfs(z).fdiff(2))
+
+
+def test_erfc():
+    assert erfc(nan) is nan
+
+    assert erfc(oo) is S.Zero
+    assert erfc(-oo) == 2
+
+    assert erfc(0) == 1
+
+    assert erfc(I*oo) == -oo*I
+    assert erfc(-I*oo) == oo*I
+
+    assert erfc(-x) == S(2) - erfc(x)
+    assert erfc(erfcinv(x)) == x
+
+    assert erfc(I).is_real is False
+    assert erfc(0, evaluate=False).is_real
+    assert erfc(0, evaluate=False).is_zero is False
+
+    assert erfc(erfinv(x)) == 1 - x
+
+    assert conjugate(erfc(z)) == erfc(conjugate(z))
+
+    assert erfc(x).as_leading_term(x) is S.One
+    assert erfc(1/x).as_leading_term(x) == S.Zero
+
+    assert erfc(z).rewrite('erf') == 1 - erf(z)
+    assert erfc(z).rewrite('erfi') == 1 + I*erfi(I*z)
+    assert erfc(z).rewrite('fresnels') == 1 - (1 + I)*(fresnelc(z*(1 - I)/sqrt(pi)) -
+        I*fresnels(z*(1 - I)/sqrt(pi)))
+    assert erfc(z).rewrite('fresnelc') == 1 - (1 + I)*(fresnelc(z*(1 - I)/sqrt(pi)) -
+        I*fresnels(z*(1 - I)/sqrt(pi)))
+    assert erfc(z).rewrite('hyper') == 1 - 2*z*hyper([S.Half], [3*S.Half], -z**2)/sqrt(pi)
+    assert erfc(z).rewrite('meijerg') == 1 - z*meijerg([S.Half], [], [0], [Rational(-1, 2)], z**2)/sqrt(pi)
+    assert erfc(z).rewrite('uppergamma') == 1 - sqrt(z**2)*(1 - erfc(sqrt(z**2)))/z
+    assert erfc(z).rewrite('expint') == S.One - sqrt(z**2)/z + z*expint(S.Half, z**2)/sqrt(S.Pi)
+    assert erfc(z).rewrite('tractable') == _erfs(z)*exp(-z**2)
+    assert expand_func(erf(x) + erfc(x)) is S.One
+
+    assert erfc(x).as_real_imag() == \
+        (erfc(re(x) - I*im(x))/2 + erfc(re(x) + I*im(x))/2,
+         -I*(-erfc(re(x) - I*im(x)) + erfc(re(x) + I*im(x)))/2)
+
+    assert erfc(x).as_real_imag(deep=False) == \
+        (erfc(re(x) - I*im(x))/2 + erfc(re(x) + I*im(x))/2,
+         -I*(-erfc(re(x) - I*im(x)) + erfc(re(x) + I*im(x)))/2)
+
+    assert erfc(w).as_real_imag() == (erfc(w), 0)
+    assert erfc(w).as_real_imag(deep=False) == (erfc(w), 0)
+    raises(ArgumentIndexError, lambda: erfc(x).fdiff(2))
+
+    assert erfc(x).inverse() == erfcinv
+
+
+def test_erfc_series():
+    assert erfc(x).series(x, 0, 7) == 1 - 2*x/sqrt(pi) + \
+        2*x**3/3/sqrt(pi) - x**5/5/sqrt(pi) + O(x**7)
+
+    assert erfc(x).series(x, oo) == \
+            (3/(4*x**5) - 1/(2*x**3) + 1/x + O(x**(-6), (x, oo)))*exp(-x**2)/sqrt(pi)
+
+
+def test_erfc_evalf():
+    assert abs( erfc(Float(2.0)) - 0.00467773 ) < 1E-8 # XXX
+
+
+def test_erfi():
+    assert erfi(nan) is nan
+
+    assert erfi(oo) is S.Infinity
+    assert erfi(-oo) is S.NegativeInfinity
+
+    assert erfi(0) is S.Zero
+
+    assert erfi(I*oo) == I
+    assert erfi(-I*oo) == -I
+
+    assert erfi(-x) == -erfi(x)
+
+    assert erfi(I*erfinv(x)) == I*x
+    assert erfi(I*erfcinv(x)) == I*(1 - x)
+    assert erfi(I*erf2inv(0, x)) == I*x
+    assert erfi(I*erf2inv(0, x, evaluate=False)) == I*x # To cover code in erfi
+
+    assert erfi(I).is_real is False
+    assert erfi(0, evaluate=False).is_real
+    assert erfi(0, evaluate=False).is_zero
+
+    assert conjugate(erfi(z)) == erfi(conjugate(z))
+
+    assert erfi(x).as_leading_term(x) == 2*x/sqrt(pi)
+    assert erfi(x*y).as_leading_term(y) == 2*x*y/sqrt(pi)
+    assert (erfi(x*y)/erfi(y)).as_leading_term(y) == x
+    assert erfi(1/x).as_leading_term(x) == erfi(1/x)
+
+    assert erfi(z).rewrite('erf') == -I*erf(I*z)
+    assert erfi(z).rewrite('erfc') == I*erfc(I*z) - I
+    assert erfi(z).rewrite('fresnels') == (1 - I)*(fresnelc(z*(1 + I)/sqrt(pi)) -
+        I*fresnels(z*(1 + I)/sqrt(pi)))
+    assert erfi(z).rewrite('fresnelc') == (1 - I)*(fresnelc(z*(1 + I)/sqrt(pi)) -
+        I*fresnels(z*(1 + I)/sqrt(pi)))
+    assert erfi(z).rewrite('hyper') == 2*z*hyper([S.Half], [3*S.Half], z**2)/sqrt(pi)
+    assert erfi(z).rewrite('meijerg') == z*meijerg([S.Half], [], [0], [Rational(-1, 2)], -z**2)/sqrt(pi)
+    assert erfi(z).rewrite('uppergamma') == (sqrt(-z**2)/z*(uppergamma(S.Half,
+        -z**2)/sqrt(S.Pi) - S.One))
+    assert erfi(z).rewrite('expint') == sqrt(-z**2)/z - z*expint(S.Half, -z**2)/sqrt(S.Pi)
+    assert erfi(z).rewrite('tractable') == -I*(-_erfs(I*z)*exp(z**2) + 1)
+    assert expand_func(erfi(I*z)) == I*erf(z)
+
+    assert erfi(x).as_real_imag() == \
+        (erfi(re(x) - I*im(x))/2 + erfi(re(x) + I*im(x))/2,
+         -I*(-erfi(re(x) - I*im(x)) + erfi(re(x) + I*im(x)))/2)
+    assert erfi(x).as_real_imag(deep=False) == \
+        (erfi(re(x) - I*im(x))/2 + erfi(re(x) + I*im(x))/2,
+         -I*(-erfi(re(x) - I*im(x)) + erfi(re(x) + I*im(x)))/2)
+
+    assert erfi(w).as_real_imag() == (erfi(w), 0)
+    assert erfi(w).as_real_imag(deep=False) == (erfi(w), 0)
+
+    raises(ArgumentIndexError, lambda: erfi(x).fdiff(2))
+
+
+def test_erfi_series():
+    assert erfi(x).series(x, 0, 7) == 2*x/sqrt(pi) + \
+        2*x**3/3/sqrt(pi) + x**5/5/sqrt(pi) + O(x**7)
+
+    assert erfi(x).series(x, oo) == \
+        (3/(4*x**5) + 1/(2*x**3) + 1/x + O(x**(-6), (x, oo)))*exp(x**2)/sqrt(pi) - I
+
+
+def test_erfi_evalf():
+    assert abs( erfi(Float(2.0)) - 18.5648024145756 ) < 1E-13  # XXX
+
+
+def test_erf2():
+
+    assert erf2(0, 0) is S.Zero
+    assert erf2(x, x) is S.Zero
+    assert erf2(nan, 0) is nan
+
+    assert erf2(-oo,  y) ==  erf(y) + 1
+    assert erf2( oo,  y) ==  erf(y) - 1
+    assert erf2(  x, oo) ==  1 - erf(x)
+    assert erf2(  x,-oo) == -1 - erf(x)
+    assert erf2(x, erf2inv(x, y)) == y
+
+    assert erf2(-x, -y) == -erf2(x,y)
+    assert erf2(-x,  y) == erf(y) + erf(x)
+    assert erf2( x, -y) == -erf(y) - erf(x)
+    assert erf2(x, y).rewrite('fresnels') == erf(y).rewrite(fresnels)-erf(x).rewrite(fresnels)
+    assert erf2(x, y).rewrite('fresnelc') == erf(y).rewrite(fresnelc)-erf(x).rewrite(fresnelc)
+    assert erf2(x, y).rewrite('hyper') == erf(y).rewrite(hyper)-erf(x).rewrite(hyper)
+    assert erf2(x, y).rewrite('meijerg') == erf(y).rewrite(meijerg)-erf(x).rewrite(meijerg)
+    assert erf2(x, y).rewrite('uppergamma') == erf(y).rewrite(uppergamma) - erf(x).rewrite(uppergamma)
+    assert erf2(x, y).rewrite('expint') == erf(y).rewrite(expint)-erf(x).rewrite(expint)
+
+    assert erf2(I, 0).is_real is False
+    assert erf2(0, 0, evaluate=False).is_real
+    assert erf2(0, 0, evaluate=False).is_zero
+    assert erf2(x, x, evaluate=False).is_zero
+    assert erf2(x, y).is_zero is None
+
+    assert expand_func(erf(x) + erf2(x, y)) == erf(y)
+
+    assert conjugate(erf2(x, y)) == erf2(conjugate(x), conjugate(y))
+
+    assert erf2(x, y).rewrite('erf')  == erf(y) - erf(x)
+    assert erf2(x, y).rewrite('erfc') == erfc(x) - erfc(y)
+    assert erf2(x, y).rewrite('erfi') == I*(erfi(I*x) - erfi(I*y))
+
+    assert erf2(x, y).diff(x) == erf2(x, y).fdiff(1)
+    assert erf2(x, y).diff(y) == erf2(x, y).fdiff(2)
+    assert erf2(x, y).diff(x) == -2*exp(-x**2)/sqrt(pi)
+    assert erf2(x, y).diff(y) == 2*exp(-y**2)/sqrt(pi)
+    raises(ArgumentIndexError, lambda: erf2(x, y).fdiff(3))
+
+    assert erf2(x, y).is_extended_real is None
+    xr, yr = symbols('xr yr', extended_real=True)
+    assert erf2(xr, yr).is_extended_real is True
+
+
+def test_erfinv():
+    assert erfinv(0) is S.Zero
+    assert erfinv(1) is S.Infinity
+    assert erfinv(nan) is S.NaN
+    assert erfinv(-1) is S.NegativeInfinity
+
+    assert erfinv(erf(w)) == w
+    assert erfinv(erf(-w)) == -w
+
+    assert erfinv(x).diff() == sqrt(pi)*exp(erfinv(x)**2)/2
+    raises(ArgumentIndexError, lambda: erfinv(x).fdiff(2))
+
+    assert erfinv(z).rewrite('erfcinv') == erfcinv(1-z)
+    assert erfinv(z).inverse() == erf
+
+
+def test_erfinv_evalf():
+    assert abs( erfinv(Float(0.2)) - 0.179143454621292 ) < 1E-13
+
+
+def test_erfcinv():
+    assert erfcinv(1) is S.Zero
+    assert erfcinv(0) is S.Infinity
+    assert erfcinv(nan) is S.NaN
+
+    assert erfcinv(x).diff() == -sqrt(pi)*exp(erfcinv(x)**2)/2
+    raises(ArgumentIndexError, lambda: erfcinv(x).fdiff(2))
+
+    assert erfcinv(z).rewrite('erfinv') == erfinv(1-z)
+    assert erfcinv(z).inverse() == erfc
+
+
+def test_erf2inv():
+    assert erf2inv(0, 0) is S.Zero
+    assert erf2inv(0, 1) is S.Infinity
+    assert erf2inv(1, 0) is S.One
+    assert erf2inv(0, y) == erfinv(y)
+    assert erf2inv(oo, y) == erfcinv(-y)
+    assert erf2inv(x, 0) == x
+    assert erf2inv(x, oo) == erfinv(x)
+    assert erf2inv(nan, 0) is nan
+    assert erf2inv(0, nan) is nan
+
+    assert erf2inv(x, y).diff(x) == exp(-x**2 + erf2inv(x, y)**2)
+    assert erf2inv(x, y).diff(y) == sqrt(pi)*exp(erf2inv(x, y)**2)/2
+    raises(ArgumentIndexError, lambda: erf2inv(x, y).fdiff(3))
+
+
+# NOTE we multiply by exp_polar(I*pi) and need this to be on the principal
+# branch, hence take x in the lower half plane (d=0).
+
+
+def mytn(expr1, expr2, expr3, x, d=0):
+    from sympy.core.random import verify_numerically, random_complex_number
+    subs = {}
+    for a in expr1.free_symbols:
+        if a != x:
+            subs[a] = random_complex_number()
+    return expr2 == expr3 and verify_numerically(expr1.subs(subs),
+                                               expr2.subs(subs), x, d=d)
+
+
+def mytd(expr1, expr2, x):
+    from sympy.core.random import test_derivative_numerically, \
+        random_complex_number
+    subs = {}
+    for a in expr1.free_symbols:
+        if a != x:
+            subs[a] = random_complex_number()
+    return expr1.diff(x) == expr2 and test_derivative_numerically(expr1.subs(subs), x)
+
+
+def tn_branch(func, s=None):
+    from sympy.core.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_ei():
+    assert Ei(0) is S.NegativeInfinity
+    assert Ei(oo) is S.Infinity
+    assert Ei(-oo) is S.Zero
+
+    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 gruntz(Ei(x+exp(-x))*exp(-x)*x, x, oo) == 1
+
+    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(x).series(x, 1, 3) == Ei(1) + E*(x - 1) + O((x - 1)**3, (x, 1))
+    assert Ei(x).series(x, oo) == \
+        (120/x**5 + 24/x**4 + 6/x**3 + 2/x**2 + 1/x + 1 + O(x**(-6), (x, oo)))*exp(x)/x
+
+    assert str(Ei(cos(2)).evalf(n=10)) == '-0.6760647401'
+    raises(ArgumentIndexError, lambda: Ei(x).fdiff(2))
+
+
+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)*erfc(sqrt(x))/(4*x**S('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 expint(x, y).rewrite(Ei) == expint(x, y)
+    assert expint(x, y).rewrite(Ci) == expint(x, y)
+
+    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) == \
+        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 - I*pi/6) - z**4/24 + \
+        z**5/240 + O(z**6)
+
+    assert expint(n, x).series(x, oo, n=3) == \
+        (n*(n + 1)/x**2 - n/x + 1 + O(x**(-3), (x, oo)))*exp(-x)/x
+
+    assert expint(z, y).series(z, 0, 2) == exp(-y)/y - z*meijerg(((), (1, 1)),
+                                  ((0, 0, 1), ()), y)/y + O(z**2)
+    raises(ArgumentIndexError, lambda: expint(x, y).fdiff(3))
+
+    neg = Symbol('neg', negative=True)
+    assert Ei(neg).rewrite(Si) == Shi(neg) + Chi(neg) - I*pi
+
+
+def test__eis():
+    assert _eis(z).diff(z) == -_eis(z) + 1/z
+
+    assert _eis(1/z).series(z) == \
+        z + z**2 + 2*z**3 + 6*z**4 + 24*z**5 + O(z**6)
+
+    assert Ei(z).rewrite('tractable') == exp(z)*_eis(z)
+    assert li(z).rewrite('tractable') == z*_eis(log(z))
+
+    assert _eis(z).rewrite('intractable') == exp(-z)*Ei(z)
+
+    assert expand(li(z).rewrite('tractable').diff(z).rewrite('intractable')) \
+        == li(z).diff(z)
+
+    assert expand(Ei(z).rewrite('tractable').diff(z).rewrite('intractable')) \
+        == Ei(z).diff(z)
+
+    assert _eis(z).series(z, n=3) == EulerGamma + log(z) + z*(-log(z) - \
+        EulerGamma + 1) + z**2*(log(z)/2 - Rational(3, 4) + EulerGamma/2)\
+        + O(z**3*log(z))
+    raises(ArgumentIndexError, lambda: _eis(z).fdiff(2))
+
+
+def tn_arg(func):
+    def test(arg, e1, e2):
+        from sympy.core.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 test_li():
+    z = Symbol("z")
+    zr = Symbol("z", real=True)
+    zp = Symbol("z", positive=True)
+    zn = Symbol("z", negative=True)
+
+    assert li(0) is S.Zero
+    assert li(1) is -oo
+    assert li(oo) is oo
+
+    assert isinstance(li(z), li)
+    assert unchanged(li, -zp)
+    assert unchanged(li, zn)
+
+    assert diff(li(z), z) == 1/log(z)
+
+    assert conjugate(li(z)) == li(conjugate(z))
+    assert conjugate(li(-zr)) == li(-zr)
+    assert unchanged(conjugate, li(-zp))
+    assert unchanged(conjugate, li(zn))
+
+    assert li(z).rewrite(Li) == Li(z) + li(2)
+    assert li(z).rewrite(Ei) == Ei(log(z))
+    assert li(z).rewrite(uppergamma) == (-log(1/log(z))/2 - log(-log(z)) +
+                                         log(log(z))/2 - expint(1, -log(z)))
+    assert li(z).rewrite(Si) == (-log(I*log(z)) - log(1/log(z))/2 +
+                                 log(log(z))/2 + Ci(I*log(z)) + Shi(log(z)))
+    assert li(z).rewrite(Ci) == (-log(I*log(z)) - log(1/log(z))/2 +
+                                 log(log(z))/2 + Ci(I*log(z)) + Shi(log(z)))
+    assert li(z).rewrite(Shi) == (-log(1/log(z))/2 + log(log(z))/2 +
+                                  Chi(log(z)) - Shi(log(z)))
+    assert li(z).rewrite(Chi) == (-log(1/log(z))/2 + log(log(z))/2 +
+                                  Chi(log(z)) - Shi(log(z)))
+    assert li(z).rewrite(hyper) ==(log(z)*hyper((1, 1), (2, 2), log(z)) -
+                                   log(1/log(z))/2 + log(log(z))/2 + EulerGamma)
+    assert li(z).rewrite(meijerg) == (-log(1/log(z))/2 - log(-log(z)) + log(log(z))/2 -
+                                      meijerg(((), (1,)), ((0, 0), ()), -log(z)))
+
+    assert gruntz(1/li(z), z, oo) is S.Zero
+    assert li(z).series(z) == log(z)**5/600 + log(z)**4/96 + log(z)**3/18 + log(z)**2/4 + \
+            log(z) + log(log(z)) + EulerGamma
+    raises(ArgumentIndexError, lambda: li(z).fdiff(2))
+
+
+def test_Li():
+    assert Li(2) is S.Zero
+    assert Li(oo) is oo
+
+    assert isinstance(Li(z), Li)
+
+    assert diff(Li(z), z) == 1/log(z)
+
+    assert gruntz(1/Li(z), z, oo) is S.Zero
+    assert Li(z).rewrite(li) == li(z) - li(2)
+    assert Li(z).series(z) == \
+        log(z)**5/600 + log(z)**4/96 + log(z)**3/18 + log(z)**2/4 + log(z) + log(log(z)) - li(2) + EulerGamma
+    raises(ArgumentIndexError, lambda: Li(z).fdiff(2))
+
+
+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) is oo
+    assert Shi(-oo) is -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**6)
+    assert Si(x).nseries(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))
+
+    assert Si(x).series(x, oo) == pi/2 - (- 6/x**3 + 1/x \
+        + O(x**(-7), (x, oo)))*sin(x)/x - (24/x**4 - 2/x**2 + 1 \
+        + O(x**(-7), (x, oo)))*cos(x)/x
+
+    t = Symbol('t', Dummy=True)
+    assert Si(x).rewrite(sinc) == Integral(sinc(t), (t, 0, x))
+
+    assert limit(Shi(x), x, S.Infinity) == S.Infinity
+    assert limit(Shi(x), x, S.NegativeInfinity) == S.NegativeInfinity
+
+
+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) is S.Zero
+    assert Ci(-oo) == I*pi
+    assert Chi(oo) is oo
+    assert Chi(-oo) is 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**5)
+    assert Chi(x).nseries(x, n=4) == \
+        EulerGamma + log(x) + x**2/4 + x**4/96 + O(x**5)
+
+    assert Ci(x).series(x, oo) == -cos(x)*(-6/x**3 + 1/x \
+        + O(x**(-7), (x, oo)))/x + (24/x**4 - 2/x**2 + 1 \
+        + O(x**(-7), (x, oo)))*sin(x)/x
+    assert limit(log(x) - Ci(2*x), x, 0) == -log(2) - EulerGamma
+    assert Ci(x).rewrite(uppergamma) == -expint(1, x*exp_polar(-I*pi/2))/2 -\
+                                        expint(1, x*exp_polar(I*pi/2))/2
+    assert Ci(x).rewrite(expint) == -expint(1, x*exp_polar(-I*pi/2))/2 -\
+                                        expint(1, x*exp_polar(I*pi/2))/2
+    raises(ArgumentIndexError, lambda: Ci(x).fdiff(2))
+
+
+def test_fresnel():
+    assert fresnels(0) is S.Zero
+    assert fresnels(oo) is S.Half
+    assert fresnels(-oo) == Rational(-1, 2)
+    assert fresnels(I*oo) == -I*S.Half
+
+    assert unchanged(fresnels, z)
+    assert fresnels(-z) == -fresnels(z)
+    assert fresnels(I*z) == -I*fresnels(z)
+    assert fresnels(-I*z) == I*fresnels(z)
+
+    assert conjugate(fresnels(z)) == fresnels(conjugate(z))
+
+    assert fresnels(z).diff(z) == sin(pi*z**2/2)
+
+    assert fresnels(z).rewrite(erf) == (S.One + I)/4 * (
+        erf((S.One + I)/2*sqrt(pi)*z) - I*erf((S.One - I)/2*sqrt(pi)*z))
+
+    assert fresnels(z).rewrite(hyper) == \
+        pi*z**3/6 * hyper([Rational(3, 4)], [Rational(3, 2), Rational(7, 4)], -pi**2*z**4/16)
+
+    assert fresnels(z).series(z, n=15) == \
+        pi*z**3/6 - pi**3*z**7/336 + pi**5*z**11/42240 + O(z**15)
+
+    assert fresnels(w).is_extended_real is True
+    assert fresnels(w).is_finite is True
+
+    assert fresnels(z).is_extended_real is None
+    assert fresnels(z).is_finite is None
+
+    assert fresnels(z).as_real_imag() == (fresnels(re(z) - I*im(z))/2 +
+                    fresnels(re(z) + I*im(z))/2,
+                    -I*(-fresnels(re(z) - I*im(z)) + fresnels(re(z) + I*im(z)))/2)
+
+    assert fresnels(z).as_real_imag(deep=False) == (fresnels(re(z) - I*im(z))/2 +
+                    fresnels(re(z) + I*im(z))/2,
+                    -I*(-fresnels(re(z) - I*im(z)) + fresnels(re(z) + I*im(z)))/2)
+
+    assert fresnels(w).as_real_imag() == (fresnels(w), 0)
+    assert fresnels(w).as_real_imag(deep=True) == (fresnels(w), 0)
+
+    assert fresnels(2 + 3*I).as_real_imag() == (
+            fresnels(2 + 3*I)/2 + fresnels(2 - 3*I)/2,
+            -I*(fresnels(2 + 3*I) - fresnels(2 - 3*I))/2
+            )
+
+    assert expand_func(integrate(fresnels(z), z)) == \
+        z*fresnels(z) + cos(pi*z**2/2)/pi
+
+    assert fresnels(z).rewrite(meijerg) == sqrt(2)*pi*z**Rational(9, 4) * \
+        meijerg(((), (1,)), ((Rational(3, 4),),
+        (Rational(1, 4), 0)), -pi**2*z**4/16)/(2*(-z)**Rational(3, 4)*(z**2)**Rational(3, 4))
+
+    assert fresnelc(0) is S.Zero
+    assert fresnelc(oo) == S.Half
+    assert fresnelc(-oo) == Rational(-1, 2)
+    assert fresnelc(I*oo) == I*S.Half
+
+    assert unchanged(fresnelc, z)
+    assert fresnelc(-z) == -fresnelc(z)
+    assert fresnelc(I*z) == I*fresnelc(z)
+    assert fresnelc(-I*z) == -I*fresnelc(z)
+
+    assert conjugate(fresnelc(z)) == fresnelc(conjugate(z))
+
+    assert fresnelc(z).diff(z) == cos(pi*z**2/2)
+
+    assert fresnelc(z).rewrite(erf) == (S.One - I)/4 * (
+        erf((S.One + I)/2*sqrt(pi)*z) + I*erf((S.One - I)/2*sqrt(pi)*z))
+
+    assert fresnelc(z).rewrite(hyper) == \
+        z * hyper([Rational(1, 4)], [S.Half, Rational(5, 4)], -pi**2*z**4/16)
+
+    assert fresnelc(w).is_extended_real is True
+
+    assert fresnelc(z).as_real_imag() == \
+        (fresnelc(re(z) - I*im(z))/2 + fresnelc(re(z) + I*im(z))/2,
+         -I*(-fresnelc(re(z) - I*im(z)) + fresnelc(re(z) + I*im(z)))/2)
+
+    assert fresnelc(z).as_real_imag(deep=False) == \
+        (fresnelc(re(z) - I*im(z))/2 + fresnelc(re(z) + I*im(z))/2,
+         -I*(-fresnelc(re(z) - I*im(z)) + fresnelc(re(z) + I*im(z)))/2)
+
+    assert fresnelc(2 + 3*I).as_real_imag() == (
+        fresnelc(2 - 3*I)/2 + fresnelc(2 + 3*I)/2,
+         -I*(fresnelc(2 + 3*I) - fresnelc(2 - 3*I))/2
+    )
+
+    assert expand_func(integrate(fresnelc(z), z)) == \
+        z*fresnelc(z) - sin(pi*z**2/2)/pi
+
+    assert fresnelc(z).rewrite(meijerg) == sqrt(2)*pi*z**Rational(3, 4) * \
+        meijerg(((), (1,)), ((Rational(1, 4),),
+        (Rational(3, 4), 0)), -pi**2*z**4/16)/(2*(-z)**Rational(1, 4)*(z**2)**Rational(1, 4))
+
+    from sympy.core.random import verify_numerically
+
+    verify_numerically(re(fresnels(z)), fresnels(z).as_real_imag()[0], z)
+    verify_numerically(im(fresnels(z)), fresnels(z).as_real_imag()[1], z)
+    verify_numerically(fresnels(z), fresnels(z).rewrite(hyper), z)
+    verify_numerically(fresnels(z), fresnels(z).rewrite(meijerg), z)
+
+    verify_numerically(re(fresnelc(z)), fresnelc(z).as_real_imag()[0], z)
+    verify_numerically(im(fresnelc(z)), fresnelc(z).as_real_imag()[1], z)
+    verify_numerically(fresnelc(z), fresnelc(z).rewrite(hyper), z)
+    verify_numerically(fresnelc(z), fresnelc(z).rewrite(meijerg), z)
+
+    raises(ArgumentIndexError, lambda: fresnels(z).fdiff(2))
+    raises(ArgumentIndexError, lambda: fresnelc(z).fdiff(2))
+
+    assert fresnels(x).taylor_term(-1, x) is S.Zero
+    assert fresnelc(x).taylor_term(-1, x) is S.Zero
+    assert fresnelc(x).taylor_term(1, x) == -pi**2*x**5/40
+
+
+def test_fresnel_series():
+    assert fresnelc(z).series(z, n=15) == \
+        z - pi**2*z**5/40 + pi**4*z**9/3456 - pi**6*z**13/599040 + O(z**15)
+
+    # issues 6510, 10102
+    fs = (S.Half - sin(pi*z**2/2)/(pi**2*z**3)
+        + (-1/(pi*z) + 3/(pi**3*z**5))*cos(pi*z**2/2))
+    fc = (S.Half - cos(pi*z**2/2)/(pi**2*z**3)
+        + (1/(pi*z) - 3/(pi**3*z**5))*sin(pi*z**2/2))
+    assert fresnels(z).series(z, oo) == fs + O(z**(-6), (z, oo))
+    assert fresnelc(z).series(z, oo) == fc + O(z**(-6), (z, oo))
+    assert (fresnels(z).series(z, -oo) + fs.subs(z, -z)).expand().is_Order
+    assert (fresnelc(z).series(z, -oo) + fc.subs(z, -z)).expand().is_Order
+    assert (fresnels(1/z).series(z) - fs.subs(z, 1/z)).expand().is_Order
+    assert (fresnelc(1/z).series(z) - fc.subs(z, 1/z)).expand().is_Order
+    assert ((2*fresnels(3*z)).series(z, oo) - 2*fs.subs(z, 3*z)).expand().is_Order
+    assert ((3*fresnelc(2*z)).series(z, oo) - 3*fc.subs(z, 2*z)).expand().is_Order

env-llmeval/lib/python3.10/site-packages/sympy/functions/special/tests/test_gamma_functions.py

@@ -0,0 +1,741 @@
+from sympy.core.function import expand_func, Subs
+from sympy.core import EulerGamma
+from sympy.core.numbers import (I, Rational, nan, oo, pi, zoo)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol)
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.combinatorial.numbers import harmonic
+from sympy.functions.elementary.complexes import (Abs, conjugate, im, re)
+from sympy.functions.elementary.exponential import (exp, exp_polar, log)
+from sympy.functions.elementary.hyperbolic import tanh
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin, atan)
+from sympy.functions.special.error_functions import (Ei, erf, erfc)
+from sympy.functions.special.gamma_functions import (digamma, gamma, loggamma, lowergamma, multigamma, polygamma, trigamma, uppergamma)
+from sympy.functions.special.zeta_functions import zeta
+from sympy.series.order import O
+
+from sympy.core.expr import unchanged
+from sympy.core.function import ArgumentIndexError
+from sympy.testing.pytest import raises
+from sympy.core.random import (test_derivative_numerically as td,
+                                      random_complex_number as randcplx,
+                                      verify_numerically as tn)
+
+x = Symbol('x')
+y = Symbol('y')
+n = Symbol('n', integer=True)
+w = Symbol('w', real=True)
+
+def test_gamma():
+    assert gamma(nan) is nan
+    assert gamma(oo) is oo
+
+    assert gamma(-100) is zoo
+    assert gamma(0) is zoo
+    assert gamma(-100.0) is zoo
+
+    assert gamma(1) == 1
+    assert gamma(2) == 1
+    assert gamma(3) == 2
+
+    assert gamma(102) == factorial(101)
+
+    assert gamma(S.Half) == sqrt(pi)
+
+    assert gamma(Rational(3, 2)) == sqrt(pi)*S.Half
+    assert gamma(Rational(5, 2)) == sqrt(pi)*Rational(3, 4)
+    assert gamma(Rational(7, 2)) == sqrt(pi)*Rational(15, 8)
+
+    assert gamma(Rational(-1, 2)) == -2*sqrt(pi)
+    assert gamma(Rational(-3, 2)) == sqrt(pi)*Rational(4, 3)
+    assert gamma(Rational(-5, 2)) == sqrt(pi)*Rational(-8, 15)
+
+    assert gamma(Rational(-15, 2)) == sqrt(pi)*Rational(256, 2027025)
+
+    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)
+
+    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 + S.Half)*gamma(x + S.Half)
+
+    assert expand_func(gamma(x - S.Half)) == \
+        gamma(S.Half + x)/(x - S.Half)
+
+    # Test a bug:
+    assert expand_func(gamma(x + Rational(3, 4))) == gamma(x + Rational(3, 4))
+
+    # XXX: Not sure about these tests. I can fix them by defining e.g.
+    # exp_polar.is_integer but I'm not sure if that makes sense.
+    assert gamma(3*exp_polar(I*pi)/4).is_nonnegative is False
+    assert gamma(3*exp_polar(I*pi)/4).is_extended_nonpositive is True
+
+    y = Symbol('y', nonpositive=True, integer=True)
+    assert gamma(y).is_real == False
+    y = Symbol('y', positive=True, noninteger=True)
+    assert gamma(y).is_real == True
+
+    assert gamma(-1.0, evaluate=False).is_real == False
+    assert gamma(0, evaluate=False).is_real == False
+    assert gamma(-2, evaluate=False).is_real == False
+
+
+def test_gamma_rewrite():
+    assert gamma(n).rewrite(factorial) == factorial(n - 1)
+
+
+def test_gamma_series():
+    assert gamma(x + 1).series(x, 0, 3) == \
+        1 - EulerGamma*x + x**2*(EulerGamma**2/2 + pi**2/12) + O(x**3)
+    assert gamma(x).series(x, -1, 3) == \
+        -1/(x + 1) + EulerGamma - 1 + (x + 1)*(-1 - pi**2/12 - EulerGamma**2/2 + \
+       EulerGamma) + (x + 1)**2*(-1 - pi**2/12 - EulerGamma**2/2 + EulerGamma**3/6 - \
+       polygamma(2, 1)/6 + EulerGamma*pi**2/12 + EulerGamma) + O((x + 1)**3, (x, -1))
+
+
+def tn_branch(s, func):
+    from sympy.core.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_lowergamma():
+    from sympy.functions.special.error_functions import expint
+    from sympy.functions.special.hyper import meijerg
+    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(0, x)._eval_is_meromorphic(x, 0) == False
+    assert lowergamma(S(1)/3, x)._eval_is_meromorphic(x, 0) == False
+    assert lowergamma(1, x, evaluate=False)._eval_is_meromorphic(x, 0) == True
+    assert lowergamma(x, x)._eval_is_meromorphic(x, 0) == False
+    assert lowergamma(x + 1, x)._eval_is_meromorphic(x, 0) == False
+    assert lowergamma(1/x, x)._eval_is_meromorphic(x, 0) == False
+    assert lowergamma(0, x + 1)._eval_is_meromorphic(x, 0) == False
+    assert lowergamma(S(1)/3, x + 1)._eval_is_meromorphic(x, 0) == True
+    assert lowergamma(1, x + 1, evaluate=False)._eval_is_meromorphic(x, 0) == True
+    assert lowergamma(x, x + 1)._eval_is_meromorphic(x, 0) == True
+    assert lowergamma(x + 1, x + 1)._eval_is_meromorphic(x, 0) == True
+    assert lowergamma(1/x, x + 1)._eval_is_meromorphic(x, 0) == False
+    assert lowergamma(0, 1/x)._eval_is_meromorphic(x, 0) == False
+    assert lowergamma(S(1)/3, 1/x)._eval_is_meromorphic(x, 0) == False
+    assert lowergamma(1, 1/x, evaluate=False)._eval_is_meromorphic(x, 0) == False
+    assert lowergamma(x, 1/x)._eval_is_meromorphic(x, 0) == False
+    assert lowergamma(x + 1, 1/x)._eval_is_meromorphic(x, 0) == False
+    assert lowergamma(1/x, 1/x)._eval_is_meromorphic(x, 0) == False
+
+    assert lowergamma(x, 2).series(x, oo, 3) == \
+        2**x*(1 + 2/(x + 1))*exp(-2)/x + O(exp(x*log(2))/x**3, (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_uppergamma():
+    from sympy.functions.special.error_functions import expint
+    from sympy.functions.special.hyper import meijerg
+    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_polygamma():
+    assert polygamma(n, nan) is nan
+
+    assert polygamma(0, oo) is oo
+    assert polygamma(0, -oo) is oo
+    assert polygamma(0, I*oo) is oo
+    assert polygamma(0, -I*oo) is oo
+    assert polygamma(1, oo) == 0
+    assert polygamma(5, oo) == 0
+
+    assert polygamma(0, -9) is zoo
+
+    assert polygamma(0, -9) is zoo
+    assert polygamma(0, -1) is zoo
+    assert polygamma(Rational(3, 2), -1) is zoo
+
+    assert polygamma(0, 0) is 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 polygamma(1, S.Half) == pi**2 / 2
+    assert polygamma(2, S.Half) == -14*zeta(3)
+    assert polygamma(11, S.Half) == 176896*pi**12
+
+    def t(m, n):
+        x = S(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 t(123, 5)
+
+    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(I, 2).rewrite(zeta) == polygamma(I, 2)
+    n1 = Symbol('n1')
+    n2 = Symbol('n2', real=True)
+    n3 = Symbol('n3', integer=True)
+    n4 = Symbol('n4', positive=True)
+    n5 = Symbol('n5', positive=True, integer=True)
+    assert polygamma(n1, x).rewrite(zeta) == polygamma(n1, x)
+    assert polygamma(n2, x).rewrite(zeta) == polygamma(n2, x)
+    assert polygamma(n3, x).rewrite(zeta) == polygamma(n3, x)
+    assert polygamma(n4, x).rewrite(zeta) == polygamma(n4, x)
+    assert polygamma(n5, x).rewrite(zeta) == (-1)**(n5 + 1) * factorial(n5) * zeta(n5 + 1, 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:
+    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) - log(2*pi) / 2
+
+    # 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(2, 2.5).is_positive == False
+    assert polygamma(2, -2.5).is_positive == False
+    assert polygamma(3, 2.5).is_positive == True
+    assert polygamma(3, -2.5).is_positive is True
+    assert polygamma(-2, -2.5).is_positive is None
+    assert polygamma(-3, -2.5).is_positive is None
+
+    assert polygamma(2, 2.5).is_negative == True
+    assert polygamma(3, 2.5).is_negative == False
+    assert polygamma(3, -2.5).is_negative == False
+    assert polygamma(2, -2.5).is_negative is True
+    assert polygamma(-2, -2.5).is_negative is None
+    assert polygamma(-3, -2.5).is_negative is None
+
+    assert polygamma(I, 2).is_positive is None
+    assert polygamma(I, 3).is_negative is None
+
+    # issue 17350
+    assert (I*polygamma(I, pi)).as_real_imag() == \
+           (-im(polygamma(I, pi)), re(polygamma(I, pi)))
+    assert (tanh(polygamma(I, 1))).rewrite(exp) == \
+           (exp(polygamma(I, 1)) - exp(-polygamma(I, 1)))/(exp(polygamma(I, 1)) + exp(-polygamma(I, 1)))
+    assert (I / polygamma(I, 4)).rewrite(exp) == \
+           I*exp(-I*atan(im(polygamma(I, 4))/re(polygamma(I, 4))))/Abs(polygamma(I, 4))
+
+    # issue 12569
+    assert unchanged(im, polygamma(0, I))
+    assert polygamma(Symbol('a', positive=True), Symbol('b', positive=True)).is_real is True
+    assert polygamma(0, I).is_real is None
+
+    assert str(polygamma(pi, 3).evalf(n=10)) == "0.1169314564"
+    assert str(polygamma(2.3, 1.0).evalf(n=10)) == "-3.003302909"
+    assert str(polygamma(-1, 1).evalf(n=10)) == "-0.9189385332" # not zero
+    assert str(polygamma(I, 1).evalf(n=10)) == "-3.109856569 + 1.89089016*I"
+    assert str(polygamma(1, I).evalf(n=10)) == "-0.5369999034 - 0.7942335428*I"
+    assert str(polygamma(I, I).evalf(n=10)) == "6.332362889 + 45.92828268*I"
+
+
+def test_polygamma_expand_func():
+    assert polygamma(0, x).expand(func=True) == polygamma(0, x)
+    assert polygamma(0, 2*x).expand(func=True) == \
+        polygamma(0, x)/2 + polygamma(0, S.Half + x)/2 + log(2)
+    assert polygamma(1, 2*x).expand(func=True) == \
+        polygamma(1, x)/4 + polygamma(1, S.Half + x)/4
+    assert polygamma(2, x).expand(func=True) == \
+        polygamma(2, x)
+    assert polygamma(0, -1 + x).expand(func=True) == \
+        polygamma(0, x) - 1/(x - 1)
+    assert polygamma(0, 1 + x).expand(func=True) == \
+        1/x + polygamma(0, x )
+    assert polygamma(0, 2 + x).expand(func=True) == \
+        1/x + 1/(1 + x) + polygamma(0, x)
+    assert polygamma(0, 3 + x).expand(func=True) == \
+        polygamma(0, x) + 1/x + 1/(1 + x) + 1/(2 + x)
+    assert polygamma(0, 4 + x).expand(func=True) == \
+        polygamma(0, x) + 1/x + 1/(1 + x) + 1/(2 + x) + 1/(3 + x)
+    assert polygamma(1, 1 + x).expand(func=True) == \
+        polygamma(1, x) - 1/x**2
+    assert polygamma(1, 2 + x).expand(func=True, multinomial=False) == \
+        polygamma(1, x) - 1/x**2 - 1/(1 + x)**2
+    assert polygamma(1, 3 + x).expand(func=True, multinomial=False) == \
+        polygamma(1, x) - 1/x**2 - 1/(1 + x)**2 - 1/(2 + x)**2
+    assert polygamma(1, 4 + x).expand(func=True, multinomial=False) == \
+        polygamma(1, x) - 1/x**2 - 1/(1 + x)**2 - \
+        1/(2 + x)**2 - 1/(3 + x)**2
+    assert polygamma(0, x + y).expand(func=True) == \
+        polygamma(0, x + y)
+    assert polygamma(1, x + y).expand(func=True) == \
+        polygamma(1, x + y)
+    assert polygamma(1, 3 + 4*x + y).expand(func=True, multinomial=False) == \
+        polygamma(1, y + 4*x) - 1/(y + 4*x)**2 - \
+        1/(1 + y + 4*x)**2 - 1/(2 + y + 4*x)**2
+    assert polygamma(3, 3 + 4*x + y).expand(func=True, multinomial=False) == \
+        polygamma(3, y + 4*x) - 6/(y + 4*x)**4 - \
+        6/(1 + y + 4*x)**4 - 6/(2 + y + 4*x)**4
+    assert polygamma(3, 4*x + y + 1).expand(func=True, multinomial=False) == \
+        polygamma(3, y + 4*x) - 6/(y + 4*x)**4
+    e = polygamma(3, 4*x + y + Rational(3, 2))
+    assert e.expand(func=True) == e
+    e = polygamma(3, x + y + Rational(3, 4))
+    assert e.expand(func=True, basic=False) == e
+
+    assert polygamma(-1, x, evaluate=False).expand(func=True) == \
+        loggamma(x) - log(pi)/2 - log(2)/2
+    p2 = polygamma(-2, x).expand(func=True) + x**2/2 - x/2 + S(1)/12
+    assert isinstance(p2, Subs)
+    assert p2.point == (-1,)
+
+
+def test_digamma():
+    assert digamma(nan) == nan
+
+    assert digamma(oo) == oo
+    assert digamma(-oo) == oo
+    assert digamma(I*oo) == oo
+    assert digamma(-I*oo) == oo
+
+    assert digamma(-9) == zoo
+
+    assert digamma(-9) == zoo
+    assert digamma(-1) == zoo
+
+    assert digamma(0) == zoo
+
+    assert digamma(1) == -EulerGamma
+    assert digamma(7) == Rational(49, 20) - EulerGamma
+
+    def t(m, n):
+        x = S(m)/n
+        r = digamma(x)
+        if r.has(digamma):
+            return False
+        return abs(digamma(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 t(123, 5)
+
+    assert digamma(x).rewrite(zeta) == polygamma(0, x)
+
+    assert digamma(x).rewrite(harmonic) == harmonic(x - 1) - EulerGamma
+
+    assert digamma(I).is_real is None
+
+    assert digamma(x,evaluate=False).fdiff() == polygamma(1, x)
+
+    assert digamma(x,evaluate=False).is_real is None
+
+    assert digamma(x,evaluate=False).is_positive is None
+
+    assert digamma(x,evaluate=False).is_negative is None
+
+    assert digamma(x,evaluate=False).rewrite(polygamma) == polygamma(0, x)
+
+
+def test_digamma_expand_func():
+    assert digamma(x).expand(func=True) == polygamma(0, x)
+    assert digamma(2*x).expand(func=True) == \
+        polygamma(0, x)/2 + polygamma(0, Rational(1, 2) + x)/2 + log(2)
+    assert digamma(-1 + x).expand(func=True) == \
+        polygamma(0, x) - 1/(x - 1)
+    assert digamma(1 + x).expand(func=True) == \
+        1/x + polygamma(0, x )
+    assert digamma(2 + x).expand(func=True) == \
+        1/x + 1/(1 + x) + polygamma(0, x)
+    assert digamma(3 + x).expand(func=True) == \
+        polygamma(0, x) + 1/x + 1/(1 + x) + 1/(2 + x)
+    assert digamma(4 + x).expand(func=True) == \
+        polygamma(0, x) + 1/x + 1/(1 + x) + 1/(2 + x) + 1/(3 + x)
+    assert digamma(x + y).expand(func=True) == \
+        polygamma(0, x + y)
+
+def test_trigamma():
+    assert trigamma(nan) == nan
+
+    assert trigamma(oo) == 0
+
+    assert trigamma(1) == pi**2/6
+    assert trigamma(2) == pi**2/6 - 1
+    assert trigamma(3) == pi**2/6 - Rational(5, 4)
+
+    assert trigamma(x, evaluate=False).rewrite(zeta) == zeta(2, x)
+    assert trigamma(x, evaluate=False).rewrite(harmonic) == \
+        trigamma(x).rewrite(polygamma).rewrite(harmonic)
+
+    assert trigamma(x,evaluate=False).fdiff() == polygamma(2, x)
+
+    assert trigamma(x,evaluate=False).is_real is None
+
+    assert trigamma(x,evaluate=False).is_positive is None
+
+    assert trigamma(x,evaluate=False).is_negative is None
+
+    assert trigamma(x,evaluate=False).rewrite(polygamma) == polygamma(1, x)
+
+def test_trigamma_expand_func():
+    assert trigamma(2*x).expand(func=True) == \
+        polygamma(1, x)/4 + polygamma(1, Rational(1, 2) + x)/4
+    assert trigamma(1 + x).expand(func=True) == \
+        polygamma(1, x) - 1/x**2
+    assert trigamma(2 + x).expand(func=True, multinomial=False) == \
+        polygamma(1, x) - 1/x**2 - 1/(1 + x)**2
+    assert trigamma(3 + x).expand(func=True, multinomial=False) == \
+        polygamma(1, x) - 1/x**2 - 1/(1 + x)**2 - 1/(2 + x)**2
+    assert trigamma(4 + x).expand(func=True, multinomial=False) == \
+        polygamma(1, x) - 1/x**2 - 1/(1 + x)**2 - \
+        1/(2 + x)**2 - 1/(3 + x)**2
+    assert trigamma(x + y).expand(func=True) == \
+        polygamma(1, x + y)
+    assert trigamma(3 + 4*x + y).expand(func=True, multinomial=False) == \
+        polygamma(1, y + 4*x) - 1/(y + 4*x)**2 - \
+        1/(1 + y + 4*x)**2 - 1/(2 + y + 4*x)**2
+
+def test_loggamma():
+    raises(TypeError, lambda: loggamma(2, 3))
+    raises(ArgumentIndexError, lambda: loggamma(x).fdiff(2))
+
+    assert loggamma(-1) is oo
+    assert loggamma(-2) is oo
+    assert loggamma(0) is 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) is oo
+    assert loggamma(n/2) == log(2**(-n + 1)*sqrt(pi)*gamma(n)/gamma(n/2 + S.Half))
+
+    assert loggamma(oo) is oo
+    assert loggamma(-oo) is zoo
+    assert loggamma(I*oo) is zoo
+    assert loggamma(-I*oo) is zoo
+    assert loggamma(zoo) is zoo
+    assert loggamma(nan) is 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.n() == E.n()
+
+    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.n() == E.n()
+
+    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.n() == E.n()
+
+    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.n() == E.n()
+
+    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.n() == E.n()
+
+    assert loggamma(x).diff(x) == polygamma(0, x)
+    s1 = loggamma(1/(x + sin(x)) + cos(x)).nseries(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 - S.Half)*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).cancel()
+    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).cancel()
+
+    assert conjugate(loggamma(x)) == loggamma(conjugate(x))
+    assert conjugate(loggamma(0)) is oo
+    assert conjugate(loggamma(1)) == loggamma(conjugate(1))
+    assert conjugate(loggamma(-oo)) == conjugate(zoo)
+
+    assert loggamma(Symbol('v', positive=True)).is_real is True
+    assert loggamma(Symbol('v', zero=True)).is_real is False
+    assert loggamma(Symbol('v', negative=True)).is_real is False
+    assert loggamma(Symbol('v', nonpositive=True)).is_real is False
+    assert loggamma(Symbol('v', nonnegative=True)).is_real is None
+    assert loggamma(Symbol('v', imaginary=True)).is_real is None
+    assert loggamma(Symbol('v', real=True)).is_real is None
+    assert loggamma(Symbol('v')).is_real is None
+
+    assert loggamma(S.Half).is_real is True
+    assert loggamma(0).is_real is False
+    assert loggamma(Rational(-1, 2)).is_real is False
+    assert loggamma(I).is_real is None
+    assert loggamma(2 + 3*I).is_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, 2)
+    tN(3, 3)
+    tN(4, 4)
+    tN(5, 5)
+
+
+def test_polygamma_expansion():
+    # A. & S., pa. 259 and 260
+    assert polygamma(0, 1/x).nseries(x, n=3) == \
+        -log(x) - x/2 - x**2/12 + O(x**3)
+    assert polygamma(1, 1/x).series(x, n=5) == \
+        x + x**2/2 + x**3/6 + O(x**5)
+    assert polygamma(3, 1/x).nseries(x, n=11) == \
+        2*x**3 + 3*x**4 + 2*x**5 - x**7 + 4*x**9/3 + O(x**11)
+
+
+def test_polygamma_leading_term():
+     expr = -log(1/x) + polygamma(0, 1 + 1/x) + S.EulerGamma
+     assert expr.as_leading_term(x, logx=-y) == S.EulerGamma
+
+
+def test_issue_8657():
+    n = Symbol('n', negative=True, integer=True)
+    m = Symbol('m', integer=True)
+    o = Symbol('o', positive=True)
+    p = Symbol('p', negative=True, integer=False)
+    assert gamma(n).is_real is False
+    assert gamma(m).is_real is None
+    assert gamma(o).is_real is True
+    assert gamma(p).is_real is True
+    assert gamma(w).is_real is None
+
+
+def test_issue_8524():
+    x = Symbol('x', positive=True)
+    y = Symbol('y', negative=True)
+    z = Symbol('z', positive=False)
+    p = Symbol('p', negative=False)
+    q = Symbol('q', integer=True)
+    r = Symbol('r', integer=False)
+    e = Symbol('e', even=True, negative=True)
+    assert gamma(x).is_positive is True
+    assert gamma(y).is_positive is None
+    assert gamma(z).is_positive is None
+    assert gamma(p).is_positive is None
+    assert gamma(q).is_positive is None
+    assert gamma(r).is_positive is None
+    assert gamma(e + S.Half).is_positive is True
+    assert gamma(e - S.Half).is_positive is False
+
+def test_issue_14450():
+    assert uppergamma(Rational(3, 8), x).evalf() == uppergamma(Rational(3, 8), x)
+    assert lowergamma(x, Rational(3, 8)).evalf() == lowergamma(x, Rational(3, 8))
+    # some values from Wolfram Alpha for comparison
+    assert abs(uppergamma(Rational(3, 8), 2).evalf() - 0.07105675881) < 1e-9
+    assert abs(lowergamma(Rational(3, 8), 2).evalf() - 2.2993794256) < 1e-9
+
+def test_issue_14528():
+    k = Symbol('k', integer=True, nonpositive=True)
+    assert isinstance(gamma(k), gamma)
+
+def test_multigamma():
+    from sympy.concrete.products import Product
+    p = Symbol('p')
+    _k = Dummy('_k')
+
+    assert multigamma(x, p).dummy_eq(pi**(p*(p - 1)/4)*\
+        Product(gamma(x + (1 - _k)/2), (_k, 1, p)))
+
+    assert conjugate(multigamma(x, p)).dummy_eq(pi**((conjugate(p) - 1)*\
+        conjugate(p)/4)*Product(gamma(conjugate(x) + (1-conjugate(_k))/2), (_k, 1, p)))
+    assert conjugate(multigamma(x, 1)) == gamma(conjugate(x))
+
+    p = Symbol('p', positive=True)
+    assert conjugate(multigamma(x, p)).dummy_eq(pi**((p - 1)*p/4)*\
+        Product(gamma(conjugate(x) + (1-conjugate(_k))/2), (_k, 1, p)))
+
+    assert multigamma(nan, 1) is nan
+    assert multigamma(oo, 1).doit() is oo
+
+    assert multigamma(1, 1) == 1
+    assert multigamma(2, 1) == 1
+    assert multigamma(3, 1) == 2
+
+    assert multigamma(102, 1) == factorial(101)
+    assert multigamma(S.Half, 1) == sqrt(pi)
+
+    assert multigamma(1, 2) == pi
+    assert multigamma(2, 2) == pi/2
+
+    assert multigamma(1, 3) is zoo
+    assert multigamma(2, 3) == pi**2/2
+    assert multigamma(3, 3) == 3*pi**2/2
+
+    assert multigamma(x, 1).diff(x) == gamma(x)*polygamma(0, x)
+    assert multigamma(x, 2).diff(x) == sqrt(pi)*gamma(x)*gamma(x - S.Half)*\
+        polygamma(0, x) + sqrt(pi)*gamma(x)*gamma(x - S.Half)*polygamma(0, x - S.Half)
+
+    assert multigamma(x - 1, 1).expand(func=True) == gamma(x)/(x - 1)
+    assert multigamma(x + 2, 1).expand(func=True, mul=False) == x*(x + 1)*\
+        gamma(x)
+    assert multigamma(x - 1, 2).expand(func=True) == sqrt(pi)*gamma(x)*\
+        gamma(x + S.Half)/(x**3 - 3*x**2 + x*Rational(11, 4) - Rational(3, 4))
+    assert multigamma(x - 1, 3).expand(func=True) == pi**Rational(3, 2)*gamma(x)**2*\
+        gamma(x + S.Half)/(x**5 - 6*x**4 + 55*x**3/4 - 15*x**2 + x*Rational(31, 4) - Rational(3, 2))
+
+    assert multigamma(n, 1).rewrite(factorial) == factorial(n - 1)
+    assert multigamma(n, 2).rewrite(factorial) == sqrt(pi)*\
+        factorial(n - Rational(3, 2))*factorial(n - 1)
+    assert multigamma(n, 3).rewrite(factorial) == pi**Rational(3, 2)*\
+        factorial(n - 2)*factorial(n - Rational(3, 2))*factorial(n - 1)
+
+    assert multigamma(Rational(-1, 2), 3, evaluate=False).is_real == False
+    assert multigamma(S.Half, 3, evaluate=False).is_real == False
+    assert multigamma(0, 1, evaluate=False).is_real == False
+    assert multigamma(1, 3, evaluate=False).is_real == False
+    assert multigamma(-1.0, 3, evaluate=False).is_real == False
+    assert multigamma(0.7, 3, evaluate=False).is_real == True
+    assert multigamma(3, 3, evaluate=False).is_real == True
+
+def test_gamma_as_leading_term():
+    assert gamma(x).as_leading_term(x) == 1/x
+    assert gamma(2 + x).as_leading_term(x) == S(1)
+    assert gamma(cos(x)).as_leading_term(x) == S(1)
+    assert gamma(sin(x)).as_leading_term(x) == 1/x

env-llmeval/lib/python3.10/site-packages/sympy/functions/special/tests/test_hyper.py

@@ -0,0 +1,387 @@
+from sympy.core.containers import Tuple
+from sympy.core.function import Derivative
+from sympy.core.numbers import (I, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import cos
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.hyper import (appellf1, hyper, meijerg)
+from sympy.series.order import O
+from sympy.abc import x, z, k
+from sympy.series.limits import limit
+from sympy.testing.pytest import raises, slow
+from sympy.core.random import (
+    random_complex_number as randcplx,
+    verify_numerically as tn,
+    test_derivative_numerically as td)
+
+
+def test_TupleParametersBase():
+    # test that our implementation of the chain rule works
+    p = hyper((), (), z**2)
+    assert p.diff(z) == p*2*z
+
+
+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.functions.elementary.complexes 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_expand_func():
+    # evaluation at 1 of Gauss' hypergeometric function:
+    from sympy.abc import a, b, c
+    from sympy.core.function 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 replace_dummy(expr, sym):
+    from sympy.core.symbol import Dummy
+    dum = expr.atoms(Dummy)
+    if not dum:
+        return expr
+    assert len(dum) == 1
+    return expr.xreplace({dum.pop(): sym})
+
+
+def test_hyper_rewrite_sum():
+    from sympy.concrete.summations import Sum
+    from sympy.core.symbol import Dummy
+    from sympy.functions.combinatorial.factorials import (RisingFactorial, factorial)
+    _k = Dummy("k")
+    assert replace_dummy(hyper((1, 2), (1, 3), x).rewrite(Sum), _k) == \
+        Sum(x**_k / factorial(_k) * RisingFactorial(2, _k) /
+            RisingFactorial(3, _k), (_k, 0, oo))
+
+    assert hyper((1, 2, 3), (-1, 3), z).rewrite(Sum) == \
+        hyper((1, 2, 3), (-1, 3), z)
+
+
+def test_radius_of_convergence():
+    assert hyper((1, 2), [3], z).radius_of_convergence == 1
+    assert hyper((1, 2), [3, 4], z).radius_of_convergence is oo
+    assert hyper((1, 2, 3), [4], z).radius_of_convergence == 0
+    assert hyper((0, 1, 2), [4], z).radius_of_convergence is oo
+    assert hyper((-1, 1, 2), [-4], z).radius_of_convergence == 0
+    assert hyper((-1, -2, 2), [-1], z).radius_of_convergence is oo
+    assert hyper((-1, 2), [-1, -2], z).radius_of_convergence == 0
+    assert hyper([-1, 1, 3], [-2, 2], z).radius_of_convergence == 1
+    assert hyper([-1, 1], [-2, 2], z).radius_of_convergence is oo
+    assert hyper([-1, 1, 3], [-2], z).radius_of_convergence == 0
+    assert hyper((-1, 2, 3, 4), [], z).radius_of_convergence is oo
+
+    assert hyper([1, 1], [3], 1).convergence_statement == True
+    assert hyper([1, 1], [2], 1).convergence_statement == False
+    assert hyper([1, 1], [2], -1).convergence_statement == True
+    assert hyper([1, 1], [1], -1).convergence_statement == False
+
+
+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.functions.elementary.complexes 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))
+
+
+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_meijerg_period():
+    assert meijerg([], [1], [0], [], x).get_period() == 2*pi
+    assert meijerg([1], [], [], [0], x).get_period() == 2*pi
+    assert meijerg([], [], [0], [], x).get_period() == 2*pi  # exp(x)
+    assert meijerg(
+        [], [], [0], [S.Half], x).get_period() == 2*pi  # cos(sqrt(x))
+    assert meijerg(
+        [], [], [S.Half], [0], x).get_period() == 4*pi  # sin(sqrt(x))
+    assert meijerg([1, 1], [], [1], [0], x).get_period() is oo  # log(1 + x)
+
+
+def test_hyper_unpolarify():
+    from sympy.functions.elementary.exponential 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
+    assert hyper([0, 1], [0], exp_polar(2*pi*I)).argument == 1
+
+
+@slow
+def test_hyperrep():
+    from sympy.functions.special.hyper import (HyperRep, HyperRep_atanh,
+        HyperRep_power1, HyperRep_power2, HyperRep_log1, HyperRep_asin1,
+        HyperRep_asin2, HyperRep_sqrts1, HyperRep_sqrts2, HyperRep_log2,
+        HyperRep_cosasin, HyperRep_sinasin)
+    # First test the base class works.
+    from sympy.functions.elementary.exponential import exp_polar
+    from sympy.functions.elementary.piecewise import Piecewise
+    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=S.Half, d=S.Half):
+            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=S.Half, d=S.Half):
+            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).n() - expr.subs(z, 1 - 1e-15).n()) > 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([S.Half, 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 - S.Half], [2*a], z), z)
+    assert t(HyperRep_log1(z), -z*hyper([1, 1], [2], z), z)
+    assert t(HyperRep_asin1(z), hyper([S.Half, S.Half], [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, S.Half - a], [S.Half], z), z)
+    assert t(HyperRep_sqrts2(a, z),
+             -2*z/(2*a + 1)*hyper([-a - S.Half, -a], [S.Half], 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], [S.Half], z), z)
+    assert t(HyperRep_sinasin(a, z), 2*a*z*hyper([1 - a, 1 + a], [Rational(3, 2)], z), z)
+
+
+@slow
+def test_meijerg_eval():
+    from sympy.functions.elementary.exponential import exp_polar
+    from sympy.functions.special.bessel import besseli
+    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_limits():
+    k, x = symbols('k, x')
+    assert hyper((1,), (Rational(4, 3), Rational(5, 3)), k**2).series(k) == \
+           1 + 9*k**2/20 + 81*k**4/1120 + O(k**6) # issue 6350
+
+    # https://github.com/sympy/sympy/issues/11465
+    assert limit(1/hyper((1, ), (1, ), x), x, 0) == 1
+
+
+def test_appellf1():
+    a, b1, b2, c, x, y = symbols('a b1 b2 c x y')
+    assert appellf1(a, b2, b1, c, y, x) == appellf1(a, b1, b2, c, x, y)
+    assert appellf1(a, b1, b1, c, y, x) == appellf1(a, b1, b1, c, x, y)
+    assert appellf1(a, b1, b2, c, S.Zero, S.Zero) is S.One
+
+    f = appellf1(a, b1, b2, c, S.Zero, S.Zero, evaluate=False)
+    assert f.func is appellf1
+    assert f.doit() is S.One
+
+
+def test_derivative_appellf1():
+    from sympy.core.function import diff
+    a, b1, b2, c, x, y, z = symbols('a b1 b2 c x y z')
+    assert diff(appellf1(a, b1, b2, c, x, y), x) == a*b1*appellf1(a + 1, b2, b1 + 1, c + 1, y, x)/c
+    assert diff(appellf1(a, b1, b2, c, x, y), y) == a*b2*appellf1(a + 1, b1, b2 + 1, c + 1, x, y)/c
+    assert diff(appellf1(a, b1, b2, c, x, y), z) == 0
+    assert diff(appellf1(a, b1, b2, c, x, y), a) ==  Derivative(appellf1(a, b1, b2, c, x, y), a)
+
+
+def test_eval_nseries():
+    a1, b1, a2, b2 = symbols('a1 b1 a2 b2')
+    assert hyper((1,2), (1,2,3), x**2)._eval_nseries(x, 7, None) == 1 + x**2/3 + x**4/24 + x**6/360 + O(x**7)
+    assert exp(x)._eval_nseries(x,7,None) == hyper((a1, b1), (a1, b1), x)._eval_nseries(x, 7, None)
+    assert hyper((a1, a2), (b1, b2), x)._eval_nseries(z, 7, None) == hyper((a1, a2), (b1, b2), x) + O(z**7)

env-llmeval/lib/python3.10/site-packages/sympy/functions/special/tests/test_mathieu.py

@@ -0,0 +1,29 @@
+from sympy.core.function import diff
+from sympy.functions.elementary.complexes import conjugate
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.mathieu_functions import (mathieuc, mathieucprime, mathieus, mathieusprime)
+
+from sympy.abc import a, q, z
+
+
+def test_mathieus():
+    assert isinstance(mathieus(a, q, z), mathieus)
+    assert mathieus(a, 0, z) == sin(sqrt(a)*z)
+    assert conjugate(mathieus(a, q, z)) == mathieus(conjugate(a), conjugate(q), conjugate(z))
+    assert diff(mathieus(a, q, z), z) == mathieusprime(a, q, z)
+
+def test_mathieuc():
+    assert isinstance(mathieuc(a, q, z), mathieuc)
+    assert mathieuc(a, 0, z) == cos(sqrt(a)*z)
+    assert diff(mathieuc(a, q, z), z) == mathieucprime(a, q, z)
+
+def test_mathieusprime():
+    assert isinstance(mathieusprime(a, q, z), mathieusprime)
+    assert mathieusprime(a, 0, z) == sqrt(a)*cos(sqrt(a)*z)
+    assert diff(mathieusprime(a, q, z), z) == (-a + 2*q*cos(2*z))*mathieus(a, q, z)
+
+def test_mathieucprime():
+    assert isinstance(mathieucprime(a, q, z), mathieucprime)
+    assert mathieucprime(a, 0, z) == -sqrt(a)*sin(sqrt(a)*z)
+    assert diff(mathieucprime(a, q, z), z) == (-a + 2*q*cos(2*z))*mathieuc(a, q, z)

env-llmeval/lib/python3.10/site-packages/sympy/functions/special/tests/test_singularity_functions.py

@@ -0,0 +1,115 @@
+from sympy.core.function import (Derivative, diff)
+from sympy.core.numbers import (Float, I, nan, oo, pi)
+from sympy.core.relational import Eq
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.delta_functions import (DiracDelta, Heaviside)
+from sympy.functions.special.singularity_functions import SingularityFunction
+from sympy.series.order import O
+
+
+from sympy.core.expr import unchanged
+from sympy.core.function import ArgumentIndexError
+from sympy.testing.pytest import raises
+
+x, y, a, n = symbols('x y a n')
+
+
+def test_fdiff():
+    assert SingularityFunction(x, 4, 5).fdiff() == 5*SingularityFunction(x, 4, 4)
+    assert SingularityFunction(x, 4, -1).fdiff() == SingularityFunction(x, 4, -2)
+    assert SingularityFunction(x, 4, 0).fdiff() == SingularityFunction(x, 4, -1)
+
+    assert SingularityFunction(y, 6, 2).diff(y) == 2*SingularityFunction(y, 6, 1)
+    assert SingularityFunction(y, -4, -1).diff(y) == SingularityFunction(y, -4, -2)
+    assert SingularityFunction(y, 4, 0).diff(y) == SingularityFunction(y, 4, -1)
+    assert SingularityFunction(y, 4, 0).diff(y, 2) == SingularityFunction(y, 4, -2)
+
+    n = Symbol('n', positive=True)
+    assert SingularityFunction(x, a, n).fdiff() == n*SingularityFunction(x, a, n - 1)
+    assert SingularityFunction(y, a, n).diff(y) == n*SingularityFunction(y, a, n - 1)
+
+    expr_in = 4*SingularityFunction(x, a, n) + 3*SingularityFunction(x, a, -1) + -10*SingularityFunction(x, a, 0)
+    expr_out = n*4*SingularityFunction(x, a, n - 1) + 3*SingularityFunction(x, a, -2) - 10*SingularityFunction(x, a, -1)
+    assert diff(expr_in, x) == expr_out
+
+    assert SingularityFunction(x, -10, 5).diff(evaluate=False) == (
+        Derivative(SingularityFunction(x, -10, 5), x))
+
+    raises(ArgumentIndexError, lambda: SingularityFunction(x, 4, 5).fdiff(2))
+
+
+def test_eval():
+    assert SingularityFunction(x, a, n).func == SingularityFunction
+    assert unchanged(SingularityFunction, x, 5, n)
+    assert SingularityFunction(5, 3, 2) == 4
+    assert SingularityFunction(3, 5, 1) == 0
+    assert SingularityFunction(3, 3, 0) == 1
+    assert SingularityFunction(4, 4, -1) is oo
+    assert SingularityFunction(4, 2, -1) == 0
+    assert SingularityFunction(4, 7, -1) == 0
+    assert SingularityFunction(5, 6, -2) == 0
+    assert SingularityFunction(4, 2, -2) == 0
+    assert SingularityFunction(4, 4, -2) is oo
+    assert (SingularityFunction(6.1, 4, 5)).evalf(5) == Float('40.841', '5')
+    assert SingularityFunction(6.1, pi, 2) == (-pi + 6.1)**2
+    assert SingularityFunction(x, a, nan) is nan
+    assert SingularityFunction(x, nan, 1) is nan
+    assert SingularityFunction(nan, a, n) is nan
+
+    raises(ValueError, lambda: SingularityFunction(x, a, I))
+    raises(ValueError, lambda: SingularityFunction(2*I, I, n))
+    raises(ValueError, lambda: SingularityFunction(x, a, -3))
+
+
+def test_leading_term():
+    l = Symbol('l', positive=True)
+    assert SingularityFunction(x, 3, 2).as_leading_term(x) == 0
+    assert SingularityFunction(x, -2, 1).as_leading_term(x) == 2
+    assert SingularityFunction(x, 0, 0).as_leading_term(x) == 1
+    assert SingularityFunction(x, 0, 0).as_leading_term(x, cdir=-1) == 0
+    assert SingularityFunction(x, 0, -1).as_leading_term(x) == 0
+    assert SingularityFunction(x, 0, -2).as_leading_term(x) == 0
+    assert (SingularityFunction(x + l, 0, 1)/2\
+        - SingularityFunction(x + l, l/2, 1)\
+        + SingularityFunction(x + l, l, 1)/2).as_leading_term(x) == -x/2
+
+
+def test_series():
+    l = Symbol('l', positive=True)
+    assert SingularityFunction(x, -3, 2).series(x) == x**2 + 6*x + 9
+    assert SingularityFunction(x, -2, 1).series(x) == x + 2
+    assert SingularityFunction(x, 0, 0).series(x) == 1
+    assert SingularityFunction(x, 0, 0).series(x, dir='-') == 0
+    assert SingularityFunction(x, 0, -1).series(x) == 0
+    assert SingularityFunction(x, 0, -2).series(x) == 0
+    assert (SingularityFunction(x + l, 0, 1)/2\
+        - SingularityFunction(x + l, l/2, 1)\
+        + SingularityFunction(x + l, l, 1)/2).nseries(x) == -x/2 + O(x**6)
+
+
+def test_rewrite():
+    assert SingularityFunction(x, 4, 5).rewrite(Piecewise) == (
+        Piecewise(((x - 4)**5, x - 4 > 0), (0, True)))
+    assert SingularityFunction(x, -10, 0).rewrite(Piecewise) == (
+        Piecewise((1, x + 10 > 0), (0, True)))
+    assert SingularityFunction(x, 2, -1).rewrite(Piecewise) == (
+        Piecewise((oo, Eq(x - 2, 0)), (0, True)))
+    assert SingularityFunction(x, 0, -2).rewrite(Piecewise) == (
+        Piecewise((oo, Eq(x, 0)), (0, True)))
+
+    n = Symbol('n', nonnegative=True)
+    assert SingularityFunction(x, a, n).rewrite(Piecewise) == (
+        Piecewise(((x - a)**n, x - a > 0), (0, True)))
+
+    expr_in = SingularityFunction(x, 4, 5) + SingularityFunction(x, -3, -1) - SingularityFunction(x, 0, -2)
+    expr_out = (x - 4)**5*Heaviside(x - 4) + DiracDelta(x + 3) - DiracDelta(x, 1)
+    assert expr_in.rewrite(Heaviside) == expr_out
+    assert expr_in.rewrite(DiracDelta) == expr_out
+    assert expr_in.rewrite('HeavisideDiracDelta') == expr_out
+
+    expr_in = SingularityFunction(x, a, n) + SingularityFunction(x, a, -1) - SingularityFunction(x, a, -2)
+    expr_out = (x - a)**n*Heaviside(x - a) + DiracDelta(x - a) + DiracDelta(a - x, 1)
+    assert expr_in.rewrite(Heaviside) == expr_out
+    assert expr_in.rewrite(DiracDelta) == expr_out
+    assert expr_in.rewrite('HeavisideDiracDelta') == expr_out

env-llmeval/lib/python3.10/site-packages/sympy/functions/special/tests/test_spec_polynomials.py

@@ -0,0 +1,475 @@
+from sympy.concrete.summations import Sum
+from sympy.core.function import (Derivative, diff)
+from sympy.core.numbers import (Rational, oo, pi, zoo)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol)
+from sympy.functions.combinatorial.factorials import (RisingFactorial, binomial, factorial)
+from sympy.functions.elementary.complexes import conjugate
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import cos
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.hyper import hyper
+from sympy.functions.special.polynomials import (assoc_laguerre, assoc_legendre, chebyshevt, chebyshevt_root, chebyshevu, chebyshevu_root, gegenbauer, hermite, hermite_prob, jacobi, jacobi_normalized, laguerre, legendre)
+from sympy.polys.orthopolys import laguerre_poly
+from sympy.polys.polyroots import roots
+
+from sympy.core.expr import unchanged
+from sympy.core.function import ArgumentIndexError
+from sympy.testing.pytest import raises
+
+
+x = Symbol('x')
+
+
+def test_jacobi():
+    n = Symbol("n")
+    a = Symbol("a")
+    b = Symbol("b")
+
+    assert jacobi(0, a, b, x) == 1
+    assert jacobi(1, a, b, x) == a/2 - b/2 + x*(a/2 + b/2 + 1)
+
+    assert jacobi(n, a, a, x) == RisingFactorial(
+        a + 1, n)*gegenbauer(n, a + S.Half, x)/RisingFactorial(2*a + 1, n)
+    assert jacobi(n, a, -a, x) == ((-1)**a*(-x + 1)**(-a/2)*(x + 1)**(a/2)*assoc_legendre(n, a, x)*
+                                   factorial(-a + n)*gamma(a + n + 1)/(factorial(a + n)*gamma(n + 1)))
+    assert jacobi(n, -b, b, x) == ((-x + 1)**(b/2)*(x + 1)**(-b/2)*assoc_legendre(n, b, x)*
+                                   gamma(-b + n + 1)/gamma(n + 1))
+    assert jacobi(n, 0, 0, x) == legendre(n, x)
+    assert jacobi(n, S.Half, S.Half, x) == RisingFactorial(
+        Rational(3, 2), n)*chebyshevu(n, x)/factorial(n + 1)
+    assert jacobi(n, Rational(-1, 2), Rational(-1, 2), x) == RisingFactorial(
+        S.Half, n)*chebyshevt(n, x)/factorial(n)
+
+    X = jacobi(n, a, b, x)
+    assert isinstance(X, jacobi)
+
+    assert jacobi(n, a, b, -x) == (-1)**n*jacobi(n, b, a, x)
+    assert jacobi(n, a, b, 0) == 2**(-n)*gamma(a + n + 1)*hyper(
+        (-b - n, -n), (a + 1,), -1)/(factorial(n)*gamma(a + 1))
+    assert jacobi(n, a, b, 1) == RisingFactorial(a + 1, n)/factorial(n)
+
+    m = Symbol("m", positive=True)
+    assert jacobi(m, a, b, oo) == oo*RisingFactorial(a + b + m + 1, m)
+    assert unchanged(jacobi, n, a, b, oo)
+
+    assert conjugate(jacobi(m, a, b, x)) == \
+        jacobi(m, conjugate(a), conjugate(b), conjugate(x))
+
+    _k = Dummy('k')
+    assert diff(jacobi(n, a, b, x), n) == Derivative(jacobi(n, a, b, x), n)
+    assert diff(jacobi(n, a, b, x), a).dummy_eq(Sum((jacobi(n, a, b, x) +
+        (2*_k + a + b + 1)*RisingFactorial(_k + b + 1, -_k + n)*jacobi(_k, a,
+        b, x)/((-_k + n)*RisingFactorial(_k + a + b + 1, -_k + n)))/(_k + a
+        + b + n + 1), (_k, 0, n - 1)))
+    assert diff(jacobi(n, a, b, x), b).dummy_eq(Sum(((-1)**(-_k + n)*(2*_k +
+        a + b + 1)*RisingFactorial(_k + a + 1, -_k + n)*jacobi(_k, a, b, x)/
+        ((-_k + n)*RisingFactorial(_k + a + b + 1, -_k + n)) + jacobi(n, a,
+        b, x))/(_k + a + b + n + 1), (_k, 0, n - 1)))
+    assert diff(jacobi(n, a, b, x), x) == \
+        (a/2 + b/2 + n/2 + S.Half)*jacobi(n - 1, a + 1, b + 1, x)
+
+    assert jacobi_normalized(n, a, b, x) == \
+           (jacobi(n, a, b, x)/sqrt(2**(a + b + 1)*gamma(a + n + 1)*gamma(b + n + 1)
+                                    /((a + b + 2*n + 1)*factorial(n)*gamma(a + b + n + 1))))
+
+    raises(ValueError, lambda: jacobi(-2.1, a, b, x))
+    raises(ValueError, lambda: jacobi(Dummy(positive=True, integer=True), 1, 2, oo))
+
+    assert jacobi(n, a, b, x).rewrite(Sum).dummy_eq(Sum((S.Half - x/2)
+        **_k*RisingFactorial(-n, _k)*RisingFactorial(_k + a + 1, -_k + n)*
+        RisingFactorial(a + b + n + 1, _k)/factorial(_k), (_k, 0, n))/factorial(n))
+    assert jacobi(n, a, b, x).rewrite("polynomial").dummy_eq(Sum((S.Half - x/2)
+        **_k*RisingFactorial(-n, _k)*RisingFactorial(_k + a + 1, -_k + n)*
+        RisingFactorial(a + b + n + 1, _k)/factorial(_k), (_k, 0, n))/factorial(n))
+    raises(ArgumentIndexError, lambda: jacobi(n, a, b, x).fdiff(5))
+
+
+def test_gegenbauer():
+    n = Symbol("n")
+    a = Symbol("a")
+
+    assert gegenbauer(0, a, x) == 1
+    assert gegenbauer(1, a, x) == 2*a*x
+    assert gegenbauer(2, a, x) == -a + x**2*(2*a**2 + 2*a)
+    assert gegenbauer(3, a, x) == \
+        x**3*(4*a**3/3 + 4*a**2 + a*Rational(8, 3)) + x*(-2*a**2 - 2*a)
+
+    assert gegenbauer(-1, a, x) == 0
+    assert gegenbauer(n, S.Half, x) == legendre(n, x)
+    assert gegenbauer(n, 1, x) == chebyshevu(n, x)
+    assert gegenbauer(n, -1, x) == 0
+
+    X = gegenbauer(n, a, x)
+    assert isinstance(X, gegenbauer)
+
+    assert gegenbauer(n, a, -x) == (-1)**n*gegenbauer(n, a, x)
+    assert gegenbauer(n, a, 0) == 2**n*sqrt(pi) * \
+        gamma(a + n/2)/(gamma(a)*gamma(-n/2 + S.Half)*gamma(n + 1))
+    assert gegenbauer(n, a, 1) == gamma(2*a + n)/(gamma(2*a)*gamma(n + 1))
+
+    assert gegenbauer(n, Rational(3, 4), -1) is zoo
+    assert gegenbauer(n, Rational(1, 4), -1) == (sqrt(2)*cos(pi*(n + S.One/4))*
+                      gamma(n + S.Half)/(sqrt(pi)*gamma(n + 1)))
+
+    m = Symbol("m", positive=True)
+    assert gegenbauer(m, a, oo) == oo*RisingFactorial(a, m)
+    assert unchanged(gegenbauer, n, a, oo)
+
+    assert conjugate(gegenbauer(n, a, x)) == gegenbauer(n, conjugate(a), conjugate(x))
+
+    _k = Dummy('k')
+
+    assert diff(gegenbauer(n, a, x), n) == Derivative(gegenbauer(n, a, x), n)
+    assert diff(gegenbauer(n, a, x), a).dummy_eq(Sum((2*(-1)**(-_k + n) + 2)*
+        (_k + a)*gegenbauer(_k, a, x)/((-_k + n)*(_k + 2*a + n)) + ((2*_k +
+        2)/((_k + 2*a)*(2*_k + 2*a + 1)) + 2/(_k + 2*a + n))*gegenbauer(n, a
+        , x), (_k, 0, n - 1)))
+    assert diff(gegenbauer(n, a, x), x) == 2*a*gegenbauer(n - 1, a + 1, x)
+
+    assert gegenbauer(n, a, x).rewrite(Sum).dummy_eq(
+        Sum((-1)**_k*(2*x)**(-2*_k + n)*RisingFactorial(a, -_k + n)
+        /(factorial(_k)*factorial(-2*_k + n)), (_k, 0, floor(n/2))))
+    assert gegenbauer(n, a, x).rewrite("polynomial").dummy_eq(
+        Sum((-1)**_k*(2*x)**(-2*_k + n)*RisingFactorial(a, -_k + n)
+        /(factorial(_k)*factorial(-2*_k + n)), (_k, 0, floor(n/2))))
+
+    raises(ArgumentIndexError, lambda: gegenbauer(n, a, x).fdiff(4))
+
+
+def test_legendre():
+    assert legendre(0, x) == 1
+    assert legendre(1, x) == x
+    assert legendre(2, x) == ((3*x**2 - 1)/2).expand()
+    assert legendre(3, x) == ((5*x**3 - 3*x)/2).expand()
+    assert legendre(4, x) == ((35*x**4 - 30*x**2 + 3)/8).expand()
+    assert legendre(5, x) == ((63*x**5 - 70*x**3 + 15*x)/8).expand()
+    assert legendre(6, x) == ((231*x**6 - 315*x**4 + 105*x**2 - 5)/16).expand()
+
+    assert legendre(10, -1) == 1
+    assert legendre(11, -1) == -1
+    assert legendre(10, 1) == 1
+    assert legendre(11, 1) == 1
+    assert legendre(10, 0) != 0
+    assert legendre(11, 0) == 0
+
+    assert legendre(-1, x) == 1
+    k = Symbol('k')
+    assert legendre(5 - k, x).subs(k, 2) == ((5*x**3 - 3*x)/2).expand()
+
+    assert roots(legendre(4, x), x) == {
+        sqrt(Rational(3, 7) - Rational(2, 35)*sqrt(30)): 1,
+        -sqrt(Rational(3, 7) - Rational(2, 35)*sqrt(30)): 1,
+        sqrt(Rational(3, 7) + Rational(2, 35)*sqrt(30)): 1,
+        -sqrt(Rational(3, 7) + Rational(2, 35)*sqrt(30)): 1,
+    }
+
+    n = Symbol("n")
+
+    X = legendre(n, x)
+    assert isinstance(X, legendre)
+    assert unchanged(legendre, n, x)
+
+    assert legendre(n, 0) == sqrt(pi)/(gamma(S.Half - n/2)*gamma(n/2 + 1))
+    assert legendre(n, 1) == 1
+    assert legendre(n, oo) is oo
+    assert legendre(-n, x) == legendre(n - 1, x)
+    assert legendre(n, -x) == (-1)**n*legendre(n, x)
+    assert unchanged(legendre, -n + k, x)
+
+    assert conjugate(legendre(n, x)) == legendre(n, conjugate(x))
+
+    assert diff(legendre(n, x), x) == \
+        n*(x*legendre(n, x) - legendre(n - 1, x))/(x**2 - 1)
+    assert diff(legendre(n, x), n) == Derivative(legendre(n, x), n)
+
+    _k = Dummy('k')
+    assert legendre(n, x).rewrite(Sum).dummy_eq(Sum((-1)**_k*(S.Half -
+            x/2)**_k*(x/2 + S.Half)**(-_k + n)*binomial(n, _k)**2, (_k, 0, n)))
+    assert legendre(n, x).rewrite("polynomial").dummy_eq(Sum((-1)**_k*(S.Half -
+            x/2)**_k*(x/2 + S.Half)**(-_k + n)*binomial(n, _k)**2, (_k, 0, n)))
+    raises(ArgumentIndexError, lambda: legendre(n, x).fdiff(1))
+    raises(ArgumentIndexError, lambda: legendre(n, x).fdiff(3))
+
+
+def test_assoc_legendre():
+    Plm = assoc_legendre
+    Q = sqrt(1 - x**2)
+
+    assert Plm(0, 0, x) == 1
+    assert Plm(1, 0, x) == x
+    assert Plm(1, 1, x) == -Q
+    assert Plm(2, 0, x) == (3*x**2 - 1)/2
+    assert Plm(2, 1, x) == -3*x*Q
+    assert Plm(2, 2, x) == 3*Q**2
+    assert Plm(3, 0, x) == (5*x**3 - 3*x)/2
+    assert Plm(3, 1, x).expand() == (( 3*(1 - 5*x**2)/2 ).expand() * Q).expand()
+    assert Plm(3, 2, x) == 15*x * Q**2
+    assert Plm(3, 3, x) == -15 * Q**3
+
+    # negative m
+    assert Plm(1, -1, x) == -Plm(1, 1, x)/2
+    assert Plm(2, -2, x) == Plm(2, 2, x)/24
+    assert Plm(2, -1, x) == -Plm(2, 1, x)/6
+    assert Plm(3, -3, x) == -Plm(3, 3, x)/720
+    assert Plm(3, -2, x) == Plm(3, 2, x)/120
+    assert Plm(3, -1, x) == -Plm(3, 1, x)/12
+
+    n = Symbol("n")
+    m = Symbol("m")
+    X = Plm(n, m, x)
+    assert isinstance(X, assoc_legendre)
+
+    assert Plm(n, 0, x) == legendre(n, x)
+    assert Plm(n, m, 0) == 2**m*sqrt(pi)/(gamma(-m/2 - n/2 +
+                           S.Half)*gamma(-m/2 + n/2 + 1))
+
+    assert diff(Plm(m, n, x), x) == (m*x*assoc_legendre(m, n, x) -
+                (m + n)*assoc_legendre(m - 1, n, x))/(x**2 - 1)
+
+    _k = Dummy('k')
+    assert Plm(m, n, x).rewrite(Sum).dummy_eq(
+            (1 - x**2)**(n/2)*Sum((-1)**_k*2**(-m)*x**(-2*_k + m - n)*factorial
+             (-2*_k + 2*m)/(factorial(_k)*factorial(-_k + m)*factorial(-2*_k + m
+              - n)), (_k, 0, floor(m/2 - n/2))))
+    assert Plm(m, n, x).rewrite("polynomial").dummy_eq(
+            (1 - x**2)**(n/2)*Sum((-1)**_k*2**(-m)*x**(-2*_k + m - n)*factorial
+             (-2*_k + 2*m)/(factorial(_k)*factorial(-_k + m)*factorial(-2*_k + m
+              - n)), (_k, 0, floor(m/2 - n/2))))
+    assert conjugate(assoc_legendre(n, m, x)) == \
+        assoc_legendre(n, conjugate(m), conjugate(x))
+    raises(ValueError, lambda: Plm(0, 1, x))
+    raises(ValueError, lambda: Plm(-1, 1, x))
+    raises(ArgumentIndexError, lambda: Plm(n, m, x).fdiff(1))
+    raises(ArgumentIndexError, lambda: Plm(n, m, x).fdiff(2))
+    raises(ArgumentIndexError, lambda: Plm(n, m, x).fdiff(4))
+
+
+def test_chebyshev():
+    assert chebyshevt(0, x) == 1
+    assert chebyshevt(1, x) == x
+    assert chebyshevt(2, x) == 2*x**2 - 1
+    assert chebyshevt(3, x) == 4*x**3 - 3*x
+
+    for n in range(1, 4):
+        for k in range(n):
+            z = chebyshevt_root(n, k)
+            assert chebyshevt(n, z) == 0
+        raises(ValueError, lambda: chebyshevt_root(n, n))
+
+    for n in range(1, 4):
+        for k in range(n):
+            z = chebyshevu_root(n, k)
+            assert chebyshevu(n, z) == 0
+        raises(ValueError, lambda: chebyshevu_root(n, n))
+
+    n = Symbol("n")
+    X = chebyshevt(n, x)
+    assert isinstance(X, chebyshevt)
+    assert unchanged(chebyshevt, n, x)
+    assert chebyshevt(n, -x) == (-1)**n*chebyshevt(n, x)
+    assert chebyshevt(-n, x) == chebyshevt(n, x)
+
+    assert chebyshevt(n, 0) == cos(pi*n/2)
+    assert chebyshevt(n, 1) == 1
+    assert chebyshevt(n, oo) is oo
+
+    assert conjugate(chebyshevt(n, x)) == chebyshevt(n, conjugate(x))
+
+    assert diff(chebyshevt(n, x), x) == n*chebyshevu(n - 1, x)
+
+    X = chebyshevu(n, x)
+    assert isinstance(X, chebyshevu)
+
+    y = Symbol('y')
+    assert chebyshevu(n, -x) == (-1)**n*chebyshevu(n, x)
+    assert chebyshevu(-n, x) == -chebyshevu(n - 2, x)
+    assert unchanged(chebyshevu, -n + y, x)
+
+    assert chebyshevu(n, 0) == cos(pi*n/2)
+    assert chebyshevu(n, 1) == n + 1
+    assert chebyshevu(n, oo) is oo
+
+    assert conjugate(chebyshevu(n, x)) == chebyshevu(n, conjugate(x))
+
+    assert diff(chebyshevu(n, x), x) == \
+        (-x*chebyshevu(n, x) + (n + 1)*chebyshevt(n + 1, x))/(x**2 - 1)
+
+    _k = Dummy('k')
+    assert chebyshevt(n, x).rewrite(Sum).dummy_eq(Sum(x**(-2*_k + n)
+                    *(x**2 - 1)**_k*binomial(n, 2*_k), (_k, 0, floor(n/2))))
+    assert chebyshevt(n, x).rewrite("polynomial").dummy_eq(Sum(x**(-2*_k + n)
+                    *(x**2 - 1)**_k*binomial(n, 2*_k), (_k, 0, floor(n/2))))
+    assert chebyshevu(n, x).rewrite(Sum).dummy_eq(Sum((-1)**_k*(2*x)
+                    **(-2*_k + n)*factorial(-_k + n)/(factorial(_k)*
+                       factorial(-2*_k + n)), (_k, 0, floor(n/2))))
+    assert chebyshevu(n, x).rewrite("polynomial").dummy_eq(Sum((-1)**_k*(2*x)
+                    **(-2*_k + n)*factorial(-_k + n)/(factorial(_k)*
+                       factorial(-2*_k + n)), (_k, 0, floor(n/2))))
+    raises(ArgumentIndexError, lambda: chebyshevt(n, x).fdiff(1))
+    raises(ArgumentIndexError, lambda: chebyshevt(n, x).fdiff(3))
+    raises(ArgumentIndexError, lambda: chebyshevu(n, x).fdiff(1))
+    raises(ArgumentIndexError, lambda: chebyshevu(n, x).fdiff(3))
+
+
+def test_hermite():
+    assert hermite(0, x) == 1
+    assert hermite(1, x) == 2*x
+    assert hermite(2, x) == 4*x**2 - 2
+    assert hermite(3, x) == 8*x**3 - 12*x
+    assert hermite(4, x) == 16*x**4 - 48*x**2 + 12
+    assert hermite(6, x) == 64*x**6 - 480*x**4 + 720*x**2 - 120
+
+    n = Symbol("n")
+    assert unchanged(hermite, n, x)
+    assert hermite(n, -x) == (-1)**n*hermite(n, x)
+    assert unchanged(hermite, -n, x)
+
+    assert hermite(n, 0) == 2**n*sqrt(pi)/gamma(S.Half - n/2)
+    assert hermite(n, oo) is oo
+
+    assert conjugate(hermite(n, x)) == hermite(n, conjugate(x))
+
+    _k = Dummy('k')
+    assert hermite(n, x).rewrite(Sum).dummy_eq(factorial(n)*Sum((-1)
+        **_k*(2*x)**(-2*_k + n)/(factorial(_k)*factorial(-2*_k + n)), (_k,
+        0, floor(n/2))))
+    assert hermite(n, x).rewrite("polynomial").dummy_eq(factorial(n)*Sum((-1)
+        **_k*(2*x)**(-2*_k + n)/(factorial(_k)*factorial(-2*_k + n)), (_k,
+        0, floor(n/2))))
+
+    assert diff(hermite(n, x), x) == 2*n*hermite(n - 1, x)
+    assert diff(hermite(n, x), n) == Derivative(hermite(n, x), n)
+    raises(ArgumentIndexError, lambda: hermite(n, x).fdiff(3))
+
+    assert hermite(n, x).rewrite(hermite_prob) == \
+            sqrt(2)**n * hermite_prob(n, x*sqrt(2))
+
+
+def test_hermite_prob():
+    assert hermite_prob(0, x) == 1
+    assert hermite_prob(1, x) == x
+    assert hermite_prob(2, x) == x**2 - 1
+    assert hermite_prob(3, x) == x**3 - 3*x
+    assert hermite_prob(4, x) == x**4 - 6*x**2 + 3
+    assert hermite_prob(6, x) == x**6 - 15*x**4 + 45*x**2 - 15
+
+    n = Symbol("n")
+    assert unchanged(hermite_prob, n, x)
+    assert hermite_prob(n, -x) == (-1)**n*hermite_prob(n, x)
+    assert unchanged(hermite_prob, -n, x)
+
+    assert hermite_prob(n, 0) == sqrt(pi)/gamma(S.Half - n/2)
+    assert hermite_prob(n, oo) is oo
+
+    assert conjugate(hermite_prob(n, x)) == hermite_prob(n, conjugate(x))
+
+    _k = Dummy('k')
+    assert hermite_prob(n, x).rewrite(Sum).dummy_eq(factorial(n) *
+        Sum((-S.Half)**_k * x**(n-2*_k) / (factorial(_k) * factorial(n-2*_k)),
+        (_k, 0, floor(n/2))))
+    assert hermite_prob(n, x).rewrite("polynomial").dummy_eq(factorial(n) *
+        Sum((-S.Half)**_k * x**(n-2*_k) / (factorial(_k) * factorial(n-2*_k)),
+        (_k, 0, floor(n/2))))
+
+    assert diff(hermite_prob(n, x), x) == n*hermite_prob(n-1, x)
+    assert diff(hermite_prob(n, x), n) == Derivative(hermite_prob(n, x), n)
+    raises(ArgumentIndexError, lambda: hermite_prob(n, x).fdiff(3))
+
+    assert hermite_prob(n, x).rewrite(hermite) == \
+            sqrt(2)**(-n) * hermite(n, x/sqrt(2))
+
+
+def test_laguerre():
+    n = Symbol("n")
+    m = Symbol("m", negative=True)
+
+    # Laguerre polynomials:
+    assert laguerre(0, x) == 1
+    assert laguerre(1, x) == -x + 1
+    assert laguerre(2, x) == x**2/2 - 2*x + 1
+    assert laguerre(3, x) == -x**3/6 + 3*x**2/2 - 3*x + 1
+    assert laguerre(-2, x) == (x + 1)*exp(x)
+
+    X = laguerre(n, x)
+    assert isinstance(X, laguerre)
+
+    assert laguerre(n, 0) == 1
+    assert laguerre(n, oo) == (-1)**n*oo
+    assert laguerre(n, -oo) is oo
+
+    assert conjugate(laguerre(n, x)) == laguerre(n, conjugate(x))
+
+    _k = Dummy('k')
+
+    assert laguerre(n, x).rewrite(Sum).dummy_eq(
+        Sum(x**_k*RisingFactorial(-n, _k)/factorial(_k)**2, (_k, 0, n)))
+    assert laguerre(n, x).rewrite("polynomial").dummy_eq(
+        Sum(x**_k*RisingFactorial(-n, _k)/factorial(_k)**2, (_k, 0, n)))
+    assert laguerre(m, x).rewrite(Sum).dummy_eq(
+        exp(x)*Sum((-x)**_k*RisingFactorial(m + 1, _k)/factorial(_k)**2,
+            (_k, 0, -m - 1)))
+    assert laguerre(m, x).rewrite("polynomial").dummy_eq(
+        exp(x)*Sum((-x)**_k*RisingFactorial(m + 1, _k)/factorial(_k)**2,
+            (_k, 0, -m - 1)))
+
+    assert diff(laguerre(n, x), x) == -assoc_laguerre(n - 1, 1, x)
+
+    k = Symbol('k')
+    assert laguerre(-n, x) == exp(x)*laguerre(n - 1, -x)
+    assert laguerre(-3, x) == exp(x)*laguerre(2, -x)
+    assert unchanged(laguerre, -n + k, x)
+
+    raises(ValueError, lambda: laguerre(-2.1, x))
+    raises(ValueError, lambda: laguerre(Rational(5, 2), x))
+    raises(ArgumentIndexError, lambda: laguerre(n, x).fdiff(1))
+    raises(ArgumentIndexError, lambda: laguerre(n, x).fdiff(3))
+
+
+def test_assoc_laguerre():
+    n = Symbol("n")
+    m = Symbol("m")
+    alpha = Symbol("alpha")
+
+    # generalized Laguerre polynomials:
+    assert assoc_laguerre(0, alpha, x) == 1
+    assert assoc_laguerre(1, alpha, x) == -x + alpha + 1
+    assert assoc_laguerre(2, alpha, x).expand() == \
+        (x**2/2 - (alpha + 2)*x + (alpha + 2)*(alpha + 1)/2).expand()
+    assert assoc_laguerre(3, alpha, x).expand() == \
+        (-x**3/6 + (alpha + 3)*x**2/2 - (alpha + 2)*(alpha + 3)*x/2 +
+        (alpha + 1)*(alpha + 2)*(alpha + 3)/6).expand()
+
+    # Test the lowest 10 polynomials with laguerre_poly, to make sure it works:
+    for i in range(10):
+        assert assoc_laguerre(i, 0, x).expand() == laguerre_poly(i, x)
+
+    X = assoc_laguerre(n, m, x)
+    assert isinstance(X, assoc_laguerre)
+
+    assert assoc_laguerre(n, 0, x) == laguerre(n, x)
+    assert assoc_laguerre(n, alpha, 0) == binomial(alpha + n, alpha)
+    p = Symbol("p", positive=True)
+    assert assoc_laguerre(p, alpha, oo) == (-1)**p*oo
+    assert assoc_laguerre(p, alpha, -oo) is oo
+
+    assert diff(assoc_laguerre(n, alpha, x), x) == \
+        -assoc_laguerre(n - 1, alpha + 1, x)
+    _k = Dummy('k')
+    assert diff(assoc_laguerre(n, alpha, x), alpha).dummy_eq(
+        Sum(assoc_laguerre(_k, alpha, x)/(-alpha + n), (_k, 0, n - 1)))
+
+    assert conjugate(assoc_laguerre(n, alpha, x)) == \
+        assoc_laguerre(n, conjugate(alpha), conjugate(x))
+
+    assert assoc_laguerre(n, alpha, x).rewrite(Sum).dummy_eq(
+            gamma(alpha + n + 1)*Sum(x**_k*RisingFactorial(-n, _k)/
+            (factorial(_k)*gamma(_k + alpha + 1)), (_k, 0, n))/factorial(n))
+    assert assoc_laguerre(n, alpha, x).rewrite("polynomial").dummy_eq(
+            gamma(alpha + n + 1)*Sum(x**_k*RisingFactorial(-n, _k)/
+            (factorial(_k)*gamma(_k + alpha + 1)), (_k, 0, n))/factorial(n))
+    raises(ValueError, lambda: assoc_laguerre(-2.1, alpha, x))
+    raises(ArgumentIndexError, lambda: assoc_laguerre(n, alpha, x).fdiff(1))
+    raises(ArgumentIndexError, lambda: assoc_laguerre(n, alpha, x).fdiff(4))