scipy 1.16.2__cp313-cp313t-win_arm64.whl

scipy/special/tests/test_orthogonal_eval.py

@@ -0,0 +1,275 @@
+import numpy as np
+from numpy.testing import assert_, assert_allclose
+import pytest
+
+from scipy.special import _ufuncs
+import scipy.special._orthogonal as orth
+from scipy.special._testutils import FuncData
+
+
+def test_eval_chebyt():
+    n = np.arange(0, 10000, 7, dtype=np.dtype("long"))
+    x = 2*np.random.rand() - 1
+    v1 = np.cos(n*np.arccos(x))
+    v2 = _ufuncs.eval_chebyt(n, x)
+    assert_(np.allclose(v1, v2, rtol=1e-15))
+
+
+def test_eval_chebyt_gh20129():
+    # https://github.com/scipy/scipy/issues/20129
+    assert _ufuncs.eval_chebyt(7, 2 + 0j) == 5042.0
+
+
+def test_eval_genlaguerre_restriction():
+    # check it returns nan for alpha <= -1
+    assert_(np.isnan(_ufuncs.eval_genlaguerre(0, -1, 0)))
+    assert_(np.isnan(_ufuncs.eval_genlaguerre(0.1, -1, 0)))
+
+
+def test_warnings():
+    # ticket 1334
+    with np.errstate(all='raise'):
+        # these should raise no fp warnings
+        _ufuncs.eval_legendre(1, 0)
+        _ufuncs.eval_laguerre(1, 1)
+        _ufuncs.eval_gegenbauer(1, 1, 0)
+
+
+class TestPolys:
+    """
+    Check that the eval_* functions agree with the constructed polynomials
+
+    """
+
+    def check_poly(self, func, cls, param_ranges=(), x_range=(), nn=10,
+                   nparam=10, nx=10, rtol=1e-8):
+        rng = np.random.RandomState(1234)
+
+        dataset = []
+        for n in np.arange(nn):
+            params = [a + (b-a)*rng.rand(nparam) for a,b in param_ranges]
+            params = np.asarray(params).T
+            if not param_ranges:
+                params = [0]
+            for p in params:
+                if param_ranges:
+                    p = (n,) + tuple(p)
+                else:
+                    p = (n,)
+                x = x_range[0] + (x_range[1] - x_range[0])*rng.rand(nx)
+                x[0] = x_range[0]  # always include domain start point
+                x[1] = x_range[1]  # always include domain end point
+                poly = np.poly1d(cls(*p).coef)
+                z = np.c_[np.tile(p, (nx,1)), x, poly(x)]
+                dataset.append(z)
+
+        dataset = np.concatenate(dataset, axis=0)
+
+        def polyfunc(*p):
+            p = (p[0].astype(np.dtype("long")),) + p[1:]
+            return func(*p)
+
+        with np.errstate(all='raise'):
+            ds = FuncData(polyfunc, dataset, list(range(len(param_ranges)+2)), -1,
+                          rtol=rtol)
+            ds.check()
+
+    def test_jacobi(self):
+        self.check_poly(_ufuncs.eval_jacobi, orth.jacobi,
+                        param_ranges=[(-0.99, 10), (-0.99, 10)],
+                        x_range=[-1, 1], rtol=1e-5)
+
+    def test_sh_jacobi(self):
+        self.check_poly(_ufuncs.eval_sh_jacobi, orth.sh_jacobi,
+                        param_ranges=[(1, 10), (0, 1)], x_range=[0, 1],
+                        rtol=1e-5)
+
+    def test_gegenbauer(self):
+        self.check_poly(_ufuncs.eval_gegenbauer, orth.gegenbauer,
+                        param_ranges=[(-0.499, 10)], x_range=[-1, 1],
+                        rtol=1e-7)
+
+    def test_chebyt(self):
+        self.check_poly(_ufuncs.eval_chebyt, orth.chebyt,
+                        param_ranges=[], x_range=[-1, 1])
+
+    def test_chebyu(self):
+        self.check_poly(_ufuncs.eval_chebyu, orth.chebyu,
+                        param_ranges=[], x_range=[-1, 1])
+
+    def test_chebys(self):
+        self.check_poly(_ufuncs.eval_chebys, orth.chebys,
+                        param_ranges=[], x_range=[-2, 2])
+
+    def test_chebyc(self):
+        self.check_poly(_ufuncs.eval_chebyc, orth.chebyc,
+                        param_ranges=[], x_range=[-2, 2])
+
+    def test_sh_chebyt(self):
+        with np.errstate(all='ignore'):
+            self.check_poly(_ufuncs.eval_sh_chebyt, orth.sh_chebyt,
+                            param_ranges=[], x_range=[0, 1])
+
+    def test_sh_chebyu(self):
+        self.check_poly(_ufuncs.eval_sh_chebyu, orth.sh_chebyu,
+                        param_ranges=[], x_range=[0, 1])
+
+    def test_legendre(self):
+        self.check_poly(_ufuncs.eval_legendre, orth.legendre,
+                        param_ranges=[], x_range=[-1, 1])
+
+    def test_sh_legendre(self):
+        with np.errstate(all='ignore'):
+            self.check_poly(_ufuncs.eval_sh_legendre, orth.sh_legendre,
+                            param_ranges=[], x_range=[0, 1])
+
+    def test_genlaguerre(self):
+        self.check_poly(_ufuncs.eval_genlaguerre, orth.genlaguerre,
+                        param_ranges=[(-0.99, 10)], x_range=[0, 100])
+
+    def test_laguerre(self):
+        self.check_poly(_ufuncs.eval_laguerre, orth.laguerre,
+                        param_ranges=[], x_range=[0, 100])
+
+    def test_hermite(self):
+        self.check_poly(_ufuncs.eval_hermite, orth.hermite,
+                        param_ranges=[], x_range=[-100, 100])
+
+    def test_hermitenorm(self):
+        self.check_poly(_ufuncs.eval_hermitenorm, orth.hermitenorm,
+                        param_ranges=[], x_range=[-100, 100])
+
+
+class TestRecurrence:
+    """
+    Check that the eval_* functions sig='ld->d' and 'dd->d' agree.
+
+    """
+
+    def check_poly(self, func, param_ranges=(), x_range=(), nn=10,
+                   nparam=10, nx=10, rtol=1e-8):
+        np.random.seed(1234)
+
+        dataset = []
+        for n in np.arange(nn):
+            params = [a + (b-a)*np.random.rand(nparam) for a,b in param_ranges]
+            params = np.asarray(params).T
+            if not param_ranges:
+                params = [0]
+            for p in params:
+                if param_ranges:
+                    p = (n,) + tuple(p)
+                else:
+                    p = (n,)
+                x = x_range[0] + (x_range[1] - x_range[0])*np.random.rand(nx)
+                x[0] = x_range[0]  # always include domain start point
+                x[1] = x_range[1]  # always include domain end point
+                kw = dict(sig=(len(p)+1)*'d'+'->d')
+                z = np.c_[np.tile(p, (nx,1)), x, func(*(p + (x,)), **kw)]
+                dataset.append(z)
+
+        dataset = np.concatenate(dataset, axis=0)
+
+        def polyfunc(*p):
+            p0 = p[0].astype(np.intp)
+            p = (p0,) + p[1:]
+            p0_type_char = p0.dtype.char
+            kw = dict(sig=p0_type_char + (len(p)-1)*'d' + '->d')
+            return func(*p, **kw)
+
+        with np.errstate(all='raise'):
+            ds = FuncData(polyfunc, dataset, list(range(len(param_ranges)+2)), -1,
+                          rtol=rtol)
+            ds.check()
+
+    def test_jacobi(self):
+        self.check_poly(_ufuncs.eval_jacobi,
+                        param_ranges=[(-0.99, 10), (-0.99, 10)],
+                        x_range=[-1, 1])
+
+    def test_sh_jacobi(self):
+        self.check_poly(_ufuncs.eval_sh_jacobi,
+                        param_ranges=[(1, 10), (0, 1)], x_range=[0, 1])
+
+    def test_gegenbauer(self):
+        self.check_poly(_ufuncs.eval_gegenbauer,
+                        param_ranges=[(-0.499, 10)], x_range=[-1, 1])
+
+    def test_chebyt(self):
+        self.check_poly(_ufuncs.eval_chebyt,
+                        param_ranges=[], x_range=[-1, 1])
+
+    def test_chebyu(self):
+        self.check_poly(_ufuncs.eval_chebyu,
+                        param_ranges=[], x_range=[-1, 1])
+
+    def test_chebys(self):
+        self.check_poly(_ufuncs.eval_chebys,
+                        param_ranges=[], x_range=[-2, 2])
+
+    def test_chebyc(self):
+        self.check_poly(_ufuncs.eval_chebyc,
+                        param_ranges=[], x_range=[-2, 2])
+
+    def test_sh_chebyt(self):
+        self.check_poly(_ufuncs.eval_sh_chebyt,
+                        param_ranges=[], x_range=[0, 1])
+
+    def test_sh_chebyu(self):
+        self.check_poly(_ufuncs.eval_sh_chebyu,
+                        param_ranges=[], x_range=[0, 1])
+
+    def test_legendre(self):
+        self.check_poly(_ufuncs.eval_legendre,
+                        param_ranges=[], x_range=[-1, 1])
+
+    def test_sh_legendre(self):
+        self.check_poly(_ufuncs.eval_sh_legendre,
+                        param_ranges=[], x_range=[0, 1])
+
+    def test_genlaguerre(self):
+        self.check_poly(_ufuncs.eval_genlaguerre,
+                        param_ranges=[(-0.99, 10)], x_range=[0, 100])
+
+    def test_laguerre(self):
+        self.check_poly(_ufuncs.eval_laguerre,
+                        param_ranges=[], x_range=[0, 100])
+
+    def test_hermite(self):
+        v = _ufuncs.eval_hermite(70, 1.0)
+        a = -1.457076485701412e60
+        assert_allclose(v, a)
+
+
+def test_hermite_domain():
+    # Regression test for gh-11091.
+    assert np.isnan(_ufuncs.eval_hermite(-1, 1.0))
+    assert np.isnan(_ufuncs.eval_hermitenorm(-1, 1.0))
+
+
+@pytest.mark.parametrize("n", [0, 1, 2])
+@pytest.mark.parametrize("x", [0, 1, np.nan])
+def test_hermite_nan(n, x):
+    # Regression test for gh-11369.
+    assert np.isnan(_ufuncs.eval_hermite(n, x)) == np.any(np.isnan([n, x]))
+    assert np.isnan(_ufuncs.eval_hermitenorm(n, x)) == np.any(np.isnan([n, x]))
+
+
+@pytest.mark.parametrize('n', [0, 1, 2, 3.2])
+@pytest.mark.parametrize('alpha', [1, np.nan])
+@pytest.mark.parametrize('x', [2, np.nan])
+def test_genlaguerre_nan(n, alpha, x):
+    # Regression test for gh-11361.
+    nan_laguerre = np.isnan(_ufuncs.eval_genlaguerre(n, alpha, x))
+    nan_arg = np.any(np.isnan([n, alpha, x]))
+    assert nan_laguerre == nan_arg
+
+
+@pytest.mark.parametrize('n', [0, 1, 2, 3.2])
+@pytest.mark.parametrize('alpha', [0.0, 1, np.nan])
+@pytest.mark.parametrize('x', [1e-6, 2, np.nan])
+def test_gegenbauer_nan(n, alpha, x):
+    # Regression test for gh-11370.
+    nan_gegenbauer = np.isnan(_ufuncs.eval_gegenbauer(n, alpha, x))
+    nan_arg = np.any(np.isnan([n, alpha, x]))
+    assert nan_gegenbauer == nan_arg

scipy/special/tests/test_owens_t.py

@@ -0,0 +1,53 @@
+import numpy as np
+from numpy.testing import assert_equal, assert_allclose
+
+import scipy.special as sc
+
+
+def test_symmetries():
+    np.random.seed(1234)
+    a, h = np.random.rand(100), np.random.rand(100)
+    assert_equal(sc.owens_t(h, a), sc.owens_t(-h, a))
+    assert_equal(sc.owens_t(h, a), -sc.owens_t(h, -a))
+
+
+def test_special_cases():
+    assert_equal(sc.owens_t(5, 0), 0)
+    assert_allclose(sc.owens_t(0, 5), 0.5*np.arctan(5)/np.pi,
+                    rtol=5e-14)
+    # Target value is 0.5*Phi(5)*(1 - Phi(5)) for Phi the CDF of the
+    # standard normal distribution
+    assert_allclose(sc.owens_t(5, 1), 1.4332574485503512543e-07,
+                    rtol=5e-14)
+
+
+def test_nans():
+    assert_equal(sc.owens_t(20, np.nan), np.nan)
+    assert_equal(sc.owens_t(np.nan, 20), np.nan)
+    assert_equal(sc.owens_t(np.nan, np.nan), np.nan)
+
+
+def test_infs():
+    h, a = 0, np.inf
+    # T(0, a) = 1/2π * arctan(a)
+    res = 1/(2*np.pi) * np.arctan(a)
+    assert_allclose(sc.owens_t(h, a), res, rtol=5e-14)
+    assert_allclose(sc.owens_t(h, -a), -res, rtol=5e-14)
+
+    h = 1
+    # Refer Owens T function definition in Wikipedia
+    # https://en.wikipedia.org/wiki/Owen%27s_T_function
+    # Value approximated through Numerical Integration
+    # using scipy.integrate.quad
+    # quad(lambda x: 1/(2*pi)*(exp(-0.5*(1*1)*(1+x*x))/(1+x*x)), 0, inf)
+    res = 0.07932762696572854
+    assert_allclose(sc.owens_t(h, np.inf), res, rtol=5e-14)
+    assert_allclose(sc.owens_t(h, -np.inf), -res, rtol=5e-14)
+
+    assert_equal(sc.owens_t(np.inf, 1), 0)
+    assert_equal(sc.owens_t(-np.inf, 1), 0)
+
+    assert_equal(sc.owens_t(np.inf, np.inf), 0)
+    assert_equal(sc.owens_t(-np.inf, np.inf), 0)
+    assert_equal(sc.owens_t(np.inf, -np.inf), -0.0)
+    assert_equal(sc.owens_t(-np.inf, -np.inf), -0.0)

scipy/special/tests/test_pcf.py

@@ -0,0 +1,24 @@
+"""Tests for parabolic cylinder functions.
+
+"""
+import numpy as np
+from numpy.testing import assert_allclose, assert_equal
+import scipy.special as sc
+
+
+def test_pbwa_segfault():
+    # Regression test for https://github.com/scipy/scipy/issues/6208.
+    #
+    # Data generated by mpmath.
+    #
+    w = 1.02276567211316867161
+    wp = -0.48887053372346189882
+    assert_allclose(sc.pbwa(0, 0), (w, wp), rtol=1e-13, atol=0)
+
+
+def test_pbwa_nan():
+    # Check that NaN's are returned outside of the range in which the
+    # implementation is accurate.
+    pts = [(-6, -6), (-6, 6), (6, -6), (6, 6)]
+    for p in pts:
+        assert_equal(sc.pbwa(*p), (np.nan, np.nan))

scipy/special/tests/test_pdtr.py

@@ -0,0 +1,48 @@
+import numpy as np
+import scipy.special as sc
+from numpy.testing import assert_almost_equal, assert_array_equal
+
+
+class TestPdtr:
+    def test(self):
+        val = sc.pdtr(0, 1)
+        assert_almost_equal(val, np.exp(-1))
+
+    def test_m_zero(self):
+        val = sc.pdtr([0, 1, 2], 0)
+        assert_array_equal(val, [1, 1, 1])
+
+    def test_rounding(self):
+        double_val = sc.pdtr([0.1, 1.1, 2.1], 1.0)
+        int_val = sc.pdtr([0, 1, 2], 1.0)
+        assert_array_equal(double_val, int_val)
+
+    def test_inf(self):
+        val = sc.pdtr(np.inf, 1.0)
+        assert_almost_equal(val, 1.0)
+
+    def test_domain(self):
+        val = sc.pdtr(-1.1, 1.0)
+        assert np.isnan(val)
+
+class TestPdtrc:
+    def test_value(self):
+        val = sc.pdtrc(0, 1)
+        assert_almost_equal(val, 1 - np.exp(-1))
+
+    def test_m_zero(self):
+        val = sc.pdtrc([0, 1, 2], 0.0)
+        assert_array_equal(val, [0, 0, 0])
+
+    def test_rounding(self):
+        double_val = sc.pdtrc([0.1, 1.1, 2.1], 1.0)
+        int_val = sc.pdtrc([0, 1, 2], 1.0)
+        assert_array_equal(double_val, int_val)
+
+    def test_inf(self):
+        val = sc.pdtrc(np.inf, 1.0)
+        assert_almost_equal(val, 0.0)
+
+    def test_domain(self):
+        val = sc.pdtrc(-1.1, 1.0)
+        assert np.isnan(val)

scipy/special/tests/test_powm1.py

@@ -0,0 +1,65 @@
+import pytest
+import numpy as np
+from numpy.testing import assert_allclose
+from scipy.special import powm1
+
+
+# Expected values were computed with mpmath, e.g.
+#
+#   >>> import mpmath
+#   >>> mpmath.np.dps = 200
+#   >>> print(float(mpmath.powm1(2.0, 1e-7))
+#   6.931472045825965e-08
+#
+powm1_test_cases = [
+    (1.25, 0.75, 0.18217701125396976, 1e-15),
+    (2.0, 1e-7, 6.931472045825965e-08, 1e-15),
+    (25.0, 5e-11, 1.6094379125636148e-10, 1e-15),
+    (0.99996, 0.75, -3.0000150002530058e-05, 1e-15),
+    (0.9999999999990905, 20, -1.81898940353014e-11, 1e-15),
+    (-1.25, 751.0, -6.017550852453444e+72, 2e-15)
+]
+
+
+@pytest.mark.parametrize('x, y, expected, rtol', powm1_test_cases)
+def test_powm1(x, y, expected, rtol):
+    p = powm1(x, y)
+    assert_allclose(p, expected, rtol=rtol)
+
+
+@pytest.mark.parametrize('x, y, expected',
+                         [(0.0, 0.0, 0.0),
+                          (0.0, -1.5, np.inf),
+                          (0.0, 1.75, -1.0),
+                          (-1.5, 2.0, 1.25),
+                          (-1.5, 3.0, -4.375),
+                          (np.nan, 0.0, 0.0),
+                          (1.0, np.nan, 0.0),
+                          (1.0, np.inf, 0.0),
+                          (1.0, -np.inf, 0.0),
+                          (np.inf, 7.5, np.inf),
+                          (np.inf, -7.5, -1.0),
+                          (3.25, np.inf, np.inf),
+                          (np.inf, np.inf, np.inf),
+                          (np.inf, -np.inf, -1.0),
+                          (np.inf, 0.0, 0.0),
+                          (-np.inf, 0.0, 0.0),
+                          (-np.inf, 2.0, np.inf),
+                          (-np.inf, 3.0, -np.inf),
+                          (-1.0, float(2**53 - 1), -2.0)])
+def test_powm1_exact_cases(x, y, expected):
+    # Test cases where we have an exact expected value.
+    p = powm1(x, y)
+    assert p == expected
+
+
+@pytest.mark.parametrize('x, y',
+                         [(-1.25, 751.03),
+                          (-1.25, np.inf),
+                          (np.nan, np.nan),
+                          (-np.inf, -np.inf),
+                          (-np.inf, 2.5)])
+def test_powm1_return_nan(x, y):
+    # Test cases where the expected return value is nan.
+    p = powm1(x, y)
+    assert np.isnan(p)

scipy/special/tests/test_precompute_expn_asy.py

@@ -0,0 +1,24 @@
+from numpy.testing import assert_equal
+
+from scipy.special._testutils import check_version, MissingModule
+from scipy.special._precompute.expn_asy import generate_A
+
+try:
+    import sympy
+    from sympy import Poly
+except ImportError:
+    sympy = MissingModule("sympy")
+
+
+@check_version(sympy, "1.0")
+def test_generate_A():
+    # Data from DLMF 8.20.5
+    x = sympy.symbols('x')
+    Astd = [Poly(1, x),
+            Poly(1, x),
+            Poly(1 - 2*x),
+            Poly(1 - 8*x + 6*x**2)]
+    Ares = generate_A(len(Astd))
+
+    for p, q in zip(Astd, Ares):
+        assert_equal(p, q)

scipy/special/tests/test_precompute_gammainc.py

@@ -0,0 +1,108 @@
+import pytest
+
+from scipy.special._testutils import MissingModule, check_version
+from scipy.special._mptestutils import (
+    Arg, IntArg, mp_assert_allclose, assert_mpmath_equal)
+from scipy.special._precompute.gammainc_asy import (
+    compute_g, compute_alpha, compute_d)
+from scipy.special._precompute.gammainc_data import gammainc, gammaincc
+
+try:
+    import sympy
+except ImportError:
+    sympy = MissingModule('sympy')
+
+try:
+    import mpmath as mp
+except ImportError:
+    mp = MissingModule('mpmath')
+
+
+@check_version(mp, '0.19')
+def test_g():
+    # Test data for the g_k. See DLMF 5.11.4.
+    with mp.workdps(30):
+        g = [mp.mpf(1), mp.mpf(1)/12, mp.mpf(1)/288,
+             -mp.mpf(139)/51840, -mp.mpf(571)/2488320,
+             mp.mpf(163879)/209018880, mp.mpf(5246819)/75246796800]
+        mp_assert_allclose(compute_g(7), g)
+
+
+@pytest.mark.slow
+@check_version(mp, '0.19')
+@check_version(sympy, '0.7')
+@pytest.mark.xfail_on_32bit("rtol only 2e-11, see gh-6938")
+def test_alpha():
+    # Test data for the alpha_k. See DLMF 8.12.14.
+    with mp.workdps(30):
+        alpha = [mp.mpf(0), mp.mpf(1), mp.mpf(1)/3, mp.mpf(1)/36,
+                 -mp.mpf(1)/270, mp.mpf(1)/4320, mp.mpf(1)/17010,
+                 -mp.mpf(139)/5443200, mp.mpf(1)/204120]
+        mp_assert_allclose(compute_alpha(9), alpha)
+
+
+@pytest.mark.xslow
+@check_version(mp, '0.19')
+@check_version(sympy, '0.7')
+def test_d():
+    # Compare the d_{k, n} to the results in appendix F of [1].
+    #
+    # Sources
+    # -------
+    # [1] DiDonato and Morris, Computation of the Incomplete Gamma
+    #     Function Ratios and their Inverse, ACM Transactions on
+    #     Mathematical Software, 1986.
+
+    with mp.workdps(50):
+        dataset = [(0, 0, -mp.mpf('0.333333333333333333333333333333')),
+                   (0, 12, mp.mpf('0.102618097842403080425739573227e-7')),
+                   (1, 0, -mp.mpf('0.185185185185185185185185185185e-2')),
+                   (1, 12, mp.mpf('0.119516285997781473243076536700e-7')),
+                   (2, 0, mp.mpf('0.413359788359788359788359788360e-2')),
+                   (2, 12, -mp.mpf('0.140925299108675210532930244154e-7')),
+                   (3, 0, mp.mpf('0.649434156378600823045267489712e-3')),
+                   (3, 12, -mp.mpf('0.191111684859736540606728140873e-7')),
+                   (4, 0, -mp.mpf('0.861888290916711698604702719929e-3')),
+                   (4, 12, mp.mpf('0.288658297427087836297341274604e-7')),
+                   (5, 0, -mp.mpf('0.336798553366358150308767592718e-3')),
+                   (5, 12, mp.mpf('0.482409670378941807563762631739e-7')),
+                   (6, 0, mp.mpf('0.531307936463992223165748542978e-3')),
+                   (6, 12, -mp.mpf('0.882860074633048352505085243179e-7')),
+                   (7, 0, mp.mpf('0.344367606892377671254279625109e-3')),
+                   (7, 12, -mp.mpf('0.175629733590604619378669693914e-6')),
+                   (8, 0, -mp.mpf('0.652623918595309418922034919727e-3')),
+                   (8, 12, mp.mpf('0.377358774161109793380344937299e-6')),
+                   (9, 0, -mp.mpf('0.596761290192746250124390067179e-3')),
+                   (9, 12, mp.mpf('0.870823417786464116761231237189e-6'))]
+        d = compute_d(10, 13)
+        res = [d[k][n] for k, n, std in dataset]
+        std = [x[2] for x in dataset]
+        mp_assert_allclose(res, std)
+
+
+@check_version(mp, '0.19')
+def test_gammainc():
+    # Quick check that the gammainc in
+    # special._precompute.gammainc_data agrees with mpmath's
+    # gammainc.
+    assert_mpmath_equal(gammainc,
+                        lambda a, x: mp.gammainc(a, b=x, regularized=True),
+                        [Arg(0, 100, inclusive_a=False), Arg(0, 100)],
+                        nan_ok=False, rtol=1e-17, n=50, dps=50)
+
+
+@pytest.mark.xslow
+@check_version(mp, '0.19')
+def test_gammaincc():
+    # Check that the gammaincc in special._precompute.gammainc_data
+    # agrees with mpmath's gammainc.
+    assert_mpmath_equal(lambda a, x: gammaincc(a, x, dps=1000),
+                        lambda a, x: mp.gammainc(a, a=x, regularized=True),
+                        [Arg(20, 100), Arg(20, 100)],
+                        nan_ok=False, rtol=1e-17, n=50, dps=1000)
+
+    # Test the fast integer path
+    assert_mpmath_equal(gammaincc,
+                        lambda a, x: mp.gammainc(a, a=x, regularized=True),
+                        [IntArg(1, 100), Arg(0, 100)],
+                        nan_ok=False, rtol=1e-17, n=50, dps=50)

scipy/special/tests/test_precompute_utils.py

@@ -0,0 +1,36 @@
+import pytest
+
+from scipy.special._testutils import MissingModule, check_version
+from scipy.special._mptestutils import mp_assert_allclose
+from scipy.special._precompute.utils import lagrange_inversion
+
+try:
+    import sympy
+except ImportError:
+    sympy = MissingModule('sympy')
+
+try:
+    import mpmath as mp
+except ImportError:
+    mp = MissingModule('mpmath')
+
+
+@pytest.mark.slow
+@check_version(sympy, '0.7')
+@check_version(mp, '0.19')
+class TestInversion:
+    @pytest.mark.xfail_on_32bit("rtol only 2e-9, see gh-6938")
+    def test_log(self):
+        with mp.workdps(30):
+            logcoeffs = mp.taylor(lambda x: mp.log(1 + x), 0, 10)
+            expcoeffs = mp.taylor(lambda x: mp.exp(x) - 1, 0, 10)
+            invlogcoeffs = lagrange_inversion(logcoeffs)
+            mp_assert_allclose(invlogcoeffs, expcoeffs)
+
+    @pytest.mark.xfail_on_32bit("rtol only 1e-15, see gh-6938")
+    def test_sin(self):
+        with mp.workdps(30):
+            sincoeffs = mp.taylor(mp.sin, 0, 10)
+            asincoeffs = mp.taylor(mp.asin, 0, 10)
+            invsincoeffs = lagrange_inversion(sincoeffs)
+            mp_assert_allclose(invsincoeffs, asincoeffs, atol=1e-30)

scipy/special/tests/test_round.py

@@ -0,0 +1,18 @@
+import numpy as np
+import pytest
+
+from scipy.special import _test_internal
+
+
+@pytest.mark.fail_slow(20)
+@pytest.mark.skipif(not _test_internal.have_fenv(), reason="no fenv()")
+def test_add_round_up():
+    rng = np.random.RandomState(1234)
+    _test_internal.test_add_round(10**5, 'up', rng)
+
+
+@pytest.mark.fail_slow(20)
+@pytest.mark.skipif(not _test_internal.have_fenv(), reason="no fenv()")
+def test_add_round_down():
+    rng = np.random.RandomState(1234)
+    _test_internal.test_add_round(10**5, 'down', rng)