scipy 1.15.3__cp313-cp313-win_amd64.whl → 1.16.0rc2__cp313-cp313-win_amd64.whl

scipy/special/tests/test_gammainc.py

@@ -38,6 +38,14 @@ class TestGammainc:
         else:
             assert result == desired
 
+    @pytest.mark.parametrize("x", [-np.inf, -1.0, -0.0, 0.0, np.inf, np.nan])
+    def test_a_nan(self, x):
+        assert np.isnan(sc.gammainc(np.nan, x))
+
+    @pytest.mark.parametrize("a", [-np.inf, -1.0, -0.0, 0.0, np.inf, np.nan])
+    def test_x_nan(self, a):
+        assert np.isnan(sc.gammainc(a, np.nan))
+
     def test_infinite_limits(self):
         # Test that large arguments converge to the hard-coded limits
         # at infinity.
@@ -108,6 +116,14 @@ class TestGammaincc:
         else:
             assert result == desired
 
+    @pytest.mark.parametrize("x", [-np.inf, -1.0, -0.0, 0.0, np.inf, np.nan])
+    def test_a_nan(self, x):
+        assert np.isnan(sc.gammaincc(np.nan, x))
+
+    @pytest.mark.parametrize("a", [-np.inf, -1.0, -0.0, 0.0, np.inf, np.nan])
+    def test_x_nan(self, a):
+        assert np.isnan(sc.gammaincc(a, np.nan))
+
     def test_infinite_limits(self):
         # Test that large arguments converge to the hard-coded limits
         # at infinity.

scipy/special/tests/test_hyp2f1.py

@@ -1135,7 +1135,7 @@ class TestHyp2f1:
                     c=8.5,
                     z=(0.7368421052631575+0.5263157894736841j),
                     expected=(6.468457061368628+24.190040684917374j),
-                    rtol=5e-16,
+                    rtol=6e-16,
                 ),
             ),
             pytest.param(
@@ -1662,7 +1662,7 @@ class TestHyp2f1:
                     c=4.0013768449590685,
                     z=(0.3413793103448277-0.8724137931034484j),
                     expected=(0.2722302180888523-0.21790187837266162j),
-                    rtol=1e-12,
+                    rtol=1.2e-12,
                 ),
             ),
             pytest.param(

scipy/special/tests/test_log1mexp.py

@@ -0,0 +1,85 @@
+import numpy as np
+import pytest
+
+from numpy.testing import assert_allclose, assert_equal
+
+from scipy.special._ufuncs import _log1mexp
+
+# # Test cases generated with the script
+#
+# import numpy as np
+
+# from mpmath import mp
+
+
+# def mp_log1mexp(x):
+#     with mp.workdps(324):
+#         return float(mp.log(mp.one - mp.exp(x)))
+
+# X = np.concat([-np.logspace(-1, -300, 20), np.linspace(-745, -1, 20)])
+
+# cases = [(float(x), mp_log1mexp(x)) for x in X]
+
+@pytest.mark.parametrize(
+    "x,expected",
+    [
+        (-0.1, -2.3521684610440907),
+        (-1.8329807108324374e-17, -38.538003135374026),
+        (-3.359818286283788e-33, -74.773421177754),
+        (-6.1584821106602796e-49, -111.00883922013399),
+        (-1.1288378916846929e-64, -147.24425726251397),
+        (-2.0691380811148324e-80, -183.47967530489393),
+        (-3.792690190732269e-96, -219.71509334727392),
+        (-6.951927961775534e-112, -255.95051138965394),
+        (-1.2742749857031425e-127, -292.1859294320339),
+        (-2.3357214690901785e-143, -328.42134747441384),
+        (-4.281332398719571e-159, -364.6567655167938),
+        (-7.847599703514559e-175, -400.8921835591739),
+        (-1.4384498882876776e-190, -437.1276016015538),
+        (-2.6366508987304307e-206, -473.3630196439338),
+        (-4.832930238571653e-222, -509.59843768631384),
+        (-8.858667904100796e-238, -545.8338557286938),
+        (-1.623776739188744e-253, -582.0692737710738),
+        (-2.9763514416312156e-269, -618.3046918134538),
+        (-5.455594781168782e-285, -654.5401098558336),
+        (-1e-300, -690.7755278982137),
+        (-745.0, -5e-324),
+        (-705.8421052631579, -2.8619931451743316e-307),
+        (-666.6842105263158, -2.9021923726875757e-290),
+        (-627.5263157894738, -2.9429562339405562e-273),
+        (-588.3684210526316, -2.9842926597143714e-256),
+        (-549.2105263157895, -3.0262096921839423e-239),
+        (-510.0526315789474, -3.0687154864846747e-222),
+        (-470.89473684210526, -3.1118183122979086e-205),
+        (-431.7368421052632, -3.155526555459449e-188),
+        (-392.5789473684211, -3.1998487195921207e-171),
+        (-353.42105263157896, -3.2447934277596653e-154),
+        (-314.2631578947369, -3.2903694241438367e-137),
+        (-275.1052631578948, -3.3365855757467166e-120),
+        (-235.94736842105266, -3.3834508741152875e-103),
+        (-196.78947368421052, -3.4309744370903894e-86),
+        (-157.63157894736844, -3.4791655105810003e-69),
+        (-118.47368421052636, -3.528033470363468e-52),
+        (-79.31578947368428, -3.577587823905024e-35),
+        (-40.157894736842195, -3.627838212213697e-18),
+        (-1.0, -0.4586751453870819),
+    ]
+)
+def test_log1mexp(x, expected):
+    observed = _log1mexp(x)
+    assert_allclose(observed, expected, rtol=1e-15)
+
+
+@pytest.mark.parametrize("x", [1.1, 1e10, np.inf])
+def test_log1mexp_out_of_domain(x):
+    observed = _log1mexp(x)
+    assert np.isnan(observed)
+
+
+@pytest.mark.parametrize(
+    "x,expected",
+    [(-np.inf, -0.0), (0.0, -np.inf), (-0.0, -np.inf), (np.nan, np.nan)]
+)
+def test_log1mexp_extreme(x, expected):
+    observed = _log1mexp(x)
+    assert_equal(expected, observed)

scipy/special/tests/test_logsumexp.py

@@ -1,15 +1,15 @@
+import itertools as it
 import math
 import pytest
 
 import numpy as np
-from numpy.testing import assert_allclose
 
-from scipy.conftest import array_api_compatible
-from scipy._lib._array_api import array_namespace, is_array_api_strict
+from scipy._lib._array_api import (is_array_api_strict, make_xp_test_case,
+                                   xp_default_dtype, xp_device)
 from scipy._lib._array_api_no_0d import (xp_assert_equal, xp_assert_close,
                                          xp_assert_less)
 
-from scipy.special import logsumexp, softmax
+from scipy.special import log_softmax, logsumexp, softmax
 from scipy.special._logsumexp import _wrap_radians
 
 
@@ -17,23 +17,22 @@ dtypes = ['float32', 'float64', 'int32', 'int64', 'complex64', 'complex128']
 integral_dtypes = ['int32', 'int64']
 
 
-@array_api_compatible
-@pytest.mark.usefixtures("skip_xp_backends")
-@pytest.mark.skip_xp_backends('jax.numpy',
-                              reason="JAX arrays do not support item assignment")
 def test_wrap_radians(xp):
     x = xp.asarray([-math.pi-1, -math.pi, -1, -1e-300,
                     0, 1e-300, 1, math.pi, math.pi+1])
     ref = xp.asarray([math.pi-1, math.pi, -1, -1e-300,
                     0, 1e-300, 1, math.pi, -math.pi+1])
-    res = _wrap_radians(x, xp)
+    res = _wrap_radians(x, xp=xp)
     xp_assert_close(res, ref, atol=0)
 
 
-@array_api_compatible
-@pytest.mark.usefixtures("skip_xp_backends")
-@pytest.mark.skip_xp_backends('jax.numpy',
-                              reason="JAX arrays do not support item assignment")
+# numpy warning filters don't work for dask (dask/dask#3245)
+# (also we should not expect the numpy warning filter to work for any Array API
+# library)
+@pytest.mark.filterwarnings("ignore:invalid value encountered:RuntimeWarning")
+@pytest.mark.filterwarnings("ignore:divide by zero encountered:RuntimeWarning")
+@pytest.mark.filterwarnings("ignore:overflow encountered:RuntimeWarning")
+@make_xp_test_case(logsumexp)
 class TestLogSumExp:
     def test_logsumexp(self, xp):
         # Test with zero-size array
@@ -79,8 +78,7 @@ class TestLogSumExp:
         xp_assert_close(logsumexp(a, axis=-1), ref)
 
         # Test keeping dimensions
-        xp_test = array_namespace(a) # `torch` needs `expand_dims`
-        ref = xp_test.expand_dims(ref, axis=-1)
+        ref = xp.expand_dims(ref, axis=-1)
         xp_assert_close(logsumexp(a, axis=-1, keepdims=True), ref)
 
         # Test multiple axes
@@ -170,23 +168,19 @@ class TestLogSumExp:
         logsumexp(a, b=b)
 
     @pytest.mark.parametrize('arg', (1, [1, 2, 3]))
-    @pytest.mark.skip_xp_backends(np_only=True)
-    def test_xp_invalid_input(self, arg, xp):
+    def test_xp_invalid_input(self, arg):
         assert logsumexp(arg) == logsumexp(np.asarray(np.atleast_1d(arg)))
 
-    @pytest.mark.skip_xp_backends(np_only=True,
-                                  reason="Lists correspond with NumPy backend")
-    def test_list(self, xp):
+    def test_array_like(self):
         a = [1000, 1000]
-        desired = xp.asarray(1000.0 + math.log(2.0), dtype=np.float64)
+        desired = np.asarray(1000.0 + math.log(2.0))
         xp_assert_close(logsumexp(a), desired)
 
     @pytest.mark.parametrize('dtype', dtypes)
     def test_dtypes_a(self, dtype, xp):
         dtype = getattr(xp, dtype)
         a = xp.asarray([1000., 1000.], dtype=dtype)
-        xp_test = array_namespace(a)  # torch needs compatible `isdtype`
-        desired_dtype = (xp.asarray(1.).dtype if xp_test.isdtype(dtype, 'integral')
+        desired_dtype = (xp.asarray(1.).dtype if xp.isdtype(dtype, 'integral')
                          else dtype)  # true for all libraries tested
         desired = xp.asarray(1000.0 + math.log(2.0), dtype=desired_dtype)
         xp_assert_close(logsumexp(a), desired)
@@ -198,16 +192,18 @@ class TestLogSumExp:
         xp_dtype_b = getattr(xp, dtype_b)
         a = xp.asarray([2, 1], dtype=xp_dtype_a)
         b = xp.asarray([1, -1], dtype=xp_dtype_b)
-        xp_test = array_namespace(a, b)  # torch needs compatible result_type
         if is_array_api_strict(xp):
+            # special-case for `TypeError: array_api_strict.float32 and
+            # and array_api_strict.int64 cannot be type promoted together`
             xp_float_dtypes = [dtype for dtype in [xp_dtype_a, xp_dtype_b]
-                               if not xp_test.isdtype(dtype, 'integral')]
+                               if not xp.isdtype(dtype, 'integral')]
             if len(xp_float_dtypes) < 2:  # at least one is integral
                 xp_float_dtypes.append(xp.asarray(1.).dtype)
-            desired_dtype = xp_test.result_type(*xp_float_dtypes)
+            desired_dtype = xp.result_type(*xp_float_dtypes)
         else:
-            # True for all libraries tested
-            desired_dtype = xp_test.result_type(xp_dtype_a, xp_dtype_b, xp.float32)
+            desired_dtype = xp.result_type(xp_dtype_a, xp_dtype_b)
+            if xp.isdtype(desired_dtype, 'integral'):
+               desired_dtype = xp_default_dtype(xp)
         desired = xp.asarray(math.log(math.exp(2) - math.exp(1)), dtype=desired_dtype)
         xp_assert_close(logsumexp(a, b=b), desired)
 
@@ -234,7 +230,7 @@ class TestLogSumExp:
 
         res = logsumexp(x, axis=1)
         ref = xp.log(xp.sum(xp.exp(x), axis=1))
-        max = xp.full_like(xp.imag(res), xp.asarray(xp.pi))
+        max = xp.full_like(xp.imag(res), xp.pi)
         xp_assert_less(xp.abs(xp.imag(res)), max)
         xp_assert_close(res, ref)
 
@@ -257,6 +253,54 @@ class TestLogSumExp:
         xp_assert_close(xp.real(res), xp.real(ref))
         xp_assert_close(xp.imag(res), xp.imag(ref), atol=0, rtol=1e-15)
 
+
+    @pytest.mark.parametrize('x,y', it.product(
+        [
+            -np.inf,
+            np.inf,
+            complex(-np.inf, 0.),
+            complex(-np.inf, -0.),
+            complex(-np.inf, np.inf),
+            complex(-np.inf, -np.inf),
+            complex(np.inf, 0.),
+            complex(np.inf, -0.),
+            complex(np.inf, np.inf),
+            complex(np.inf, -np.inf),
+            # Phase in each quadrant.
+            complex(-np.inf, 0.7533),
+            complex(-np.inf, 2.3562),
+            complex(-np.inf, 3.9270),
+            complex(-np.inf, 5.4978),
+            complex(np.inf, 0.7533),
+            complex(np.inf, 2.3562),
+            complex(np.inf, 3.9270),
+            complex(np.inf, 5.4978),
+        ], repeat=2)
+    )
+    def test_gh22601_infinite_elements(self, x, y, xp):
+        # Test that `logsumexp` does reasonable things in the presence of
+        # real and complex infinities.
+        res = logsumexp(xp.asarray([x, y]))
+        ref = xp.log(xp.sum(xp.exp(xp.asarray([x, y]))))
+        xp_assert_equal(res, ref)
+
+    def test_no_writeback(self, xp):
+        """Test that logsumexp doesn't accidentally write back to its parameters."""
+        a = xp.asarray([5., 4.])
+        b = xp.asarray([3., 2.])
+        logsumexp(a)
+        logsumexp(a, b=b)
+        xp_assert_equal(a, xp.asarray([5., 4.]))
+        xp_assert_equal(b, xp.asarray([3., 2.]))
+
+    @pytest.mark.parametrize("x_raw", [1.0, 1.0j, []])
+    def test_device(self, x_raw, xp, devices):
+        """Test input device propagation to output."""
+        for d in devices:
+            x = xp.asarray(x_raw, device=d)
+            assert xp_device(logsumexp(x)) == xp_device(x)
+            assert xp_device(logsumexp(x, b=x)) == xp_device(x)
+
     def test_gh22903(self, xp):
         # gh-22903 reported that `logsumexp` produced NaN where the weight associated
         # with the max magnitude element was negative and `return_sign=False`, even if
@@ -272,56 +316,154 @@ class TestLogSumExp:
         xp_assert_close(logsumexp(a, b=b), xp.asarray(xp.nan))
 
 
+@make_xp_test_case(softmax)
 class TestSoftmax:
-    def test_softmax_fixtures(self):
-        assert_allclose(softmax([1000, 0, 0, 0]), np.array([1, 0, 0, 0]),
-                        rtol=1e-13)
-        assert_allclose(softmax([1, 1]), np.array([.5, .5]), rtol=1e-13)
-        assert_allclose(softmax([0, 1]), np.array([1, np.e])/(1 + np.e),
+    def test_softmax_fixtures(self, xp):
+        xp_assert_close(softmax(xp.asarray([1000., 0., 0., 0.])),
+                        xp.asarray([1., 0., 0., 0.]), rtol=1e-13)
+        xp_assert_close(softmax(xp.asarray([1., 1.])),
+                        xp.asarray([.5, .5]), rtol=1e-13)
+        xp_assert_close(softmax(xp.asarray([0., 1.])),
+                        xp.asarray([1., np.e])/(1 + np.e),
                         rtol=1e-13)
 
         # Expected value computed using mpmath (with mpmath.mp.dps = 200) and then
         # converted to float.
-        x = np.arange(4)
-        expected = np.array([0.03205860328008499,
-                            0.08714431874203256,
-                            0.23688281808991013,
-                            0.6439142598879722])
+        x = xp.arange(4, dtype=xp.float64)
+        expected = xp.asarray([0.03205860328008499,
+                               0.08714431874203256,
+                               0.23688281808991013,
+                               0.6439142598879722], dtype=xp.float64)
 
-        assert_allclose(softmax(x), expected, rtol=1e-13)
+        xp_assert_close(softmax(x), expected, rtol=1e-13)
 
         # Translation property.  If all the values are changed by the same amount,
         # the softmax result does not change.
-        assert_allclose(softmax(x + 100), expected, rtol=1e-13)
+        xp_assert_close(softmax(x + 100), expected, rtol=1e-13)
 
         # When axis=None, softmax operates on the entire array, and preserves
         # the shape.
-        assert_allclose(softmax(x.reshape(2, 2)), expected.reshape(2, 2),
-                        rtol=1e-13)
-
+        xp_assert_close(softmax(xp.reshape(x, (2, 2))),
+                        xp.reshape(expected, (2, 2)), rtol=1e-13)
 
-    def test_softmax_multi_axes(self):
-        assert_allclose(softmax([[1000, 0], [1000, 0]], axis=0),
-                        np.array([[.5, .5], [.5, .5]]), rtol=1e-13)
-        assert_allclose(softmax([[1000, 0], [1000, 0]], axis=1),
-                        np.array([[1, 0], [1, 0]]), rtol=1e-13)
+    def test_softmax_multi_axes(self, xp):
+        xp_assert_close(softmax(xp.asarray([[1000., 0.], [1000., 0.]]), axis=0),
+                        xp.asarray([[.5, .5], [.5, .5]]), rtol=1e-13)
+        xp_assert_close(softmax(xp.asarray([[1000., 0.], [1000., 0.]]), axis=1),
+                        xp.asarray([[1., 0.], [1., 0.]]), rtol=1e-13)
 
         # Expected value computed using mpmath (with mpmath.mp.dps = 200) and then
         # converted to float.
-        x = np.array([[-25, 0, 25, 50],
-                    [1, 325, 749, 750]])
-        expected = np.array([[2.678636961770877e-33,
-                            1.9287498479371314e-22,
-                            1.3887943864771144e-11,
-                            0.999999999986112],
-                            [0.0,
-                            1.9444526359919372e-185,
-                            0.2689414213699951,
-                            0.7310585786300048]])
-        assert_allclose(softmax(x, axis=1), expected, rtol=1e-13)
-        assert_allclose(softmax(x.T, axis=0), expected.T, rtol=1e-13)
+        x = xp.asarray([[-25.,   0.,  25.,  50.],
+                        [  1., 325., 749., 750.]])
+        expected = xp.asarray([[2.678636961770877e-33,
+                                1.9287498479371314e-22,
+                                1.3887943864771144e-11,
+                                0.999999999986112],
+                               [0.0,
+                                1.9444526359919372e-185,
+                                0.2689414213699951,
+                                0.7310585786300048]])
+        xp_assert_close(softmax(x, axis=1), expected, rtol=1e-13)
+        xp_assert_close(softmax(x.T, axis=0), expected.T, rtol=1e-13)
 
         # 3-d input, with a tuple for the axis.
-        x3d = x.reshape(2, 2, 2)
-        assert_allclose(softmax(x3d, axis=(1, 2)), expected.reshape(2, 2, 2),
-                        rtol=1e-13)
+        x3d = xp.reshape(x, (2, 2, 2))
+        xp_assert_close(softmax(x3d, axis=(1, 2)),
+                        xp.reshape(expected, (2, 2, 2)), rtol=1e-13)
+
+    @pytest.mark.xfail_xp_backends("array_api_strict", reason="int->float promotion")
+    def test_softmax_int_array(self, xp):
+        xp_assert_close(softmax(xp.asarray([1000, 0, 0, 0])),
+                        xp.asarray([1., 0., 0., 0.]), rtol=1e-13)
+
+    def test_softmax_scalar(self):
+        xp_assert_close(softmax(1000), np.asarray(1.), rtol=1e-13)
+
+    def test_softmax_array_like(self):
+        xp_assert_close(softmax([1000, 0, 0, 0]),
+                        np.asarray([1., 0., 0., 0.]), rtol=1e-13)
+
+
+@make_xp_test_case(log_softmax)
+class TestLogSoftmax:
+    def test_log_softmax_basic(self, xp):
+        xp_assert_close(log_softmax(xp.asarray([1000., 1.])),
+                        xp.asarray([0., -999.]), rtol=1e-13)
+
+    @pytest.mark.xfail_xp_backends("array_api_strict", reason="int->float promotion")
+    def test_log_softmax_int_array(self, xp):
+        xp_assert_close(log_softmax(xp.asarray([1000, 1])),
+                        xp.asarray([0., -999.]), rtol=1e-13)
+
+    def test_log_softmax_scalar(self):
+        xp_assert_close(log_softmax(1.0), 0.0, rtol=1e-13)
+
+    def test_log_softmax_array_like(self):
+        xp_assert_close(log_softmax([1000, 1]),
+                        np.asarray([0., -999.]), rtol=1e-13)
+
+    @staticmethod
+    def data_1d(xp):
+        x = xp.arange(4, dtype=xp.float64)
+        # Expected value computed using mpmath (with mpmath.mp.dps = 200)
+        expect = [-3.4401896985611953,
+                  -2.4401896985611953,
+                  -1.4401896985611953,
+                  -0.44018969856119533]
+        return x, xp.asarray(expect, dtype=xp.float64)
+
+    @staticmethod
+    def data_2d(xp):
+        x = xp.reshape(xp.arange(8, dtype=xp.float64), (2, 4))
+
+        # Expected value computed using mpmath (with mpmath.mp.dps = 200)
+        expect = [[-3.4401896985611953,
+                   -2.4401896985611953,
+                   -1.4401896985611953,
+                   -0.44018969856119533],
+                  [-3.4401896985611953,
+                   -2.4401896985611953,
+                   -1.4401896985611953,
+                   -0.44018969856119533]]
+        return x, xp.asarray(expect, dtype=xp.float64)
+
+    @pytest.mark.parametrize("offset", [0, 100])
+    def test_log_softmax_translation(self, offset, xp):
+        # Translation property.  If all the values are changed by the same amount,
+        # the softmax result does not change.
+        x, expect = self.data_1d(xp)
+        x += offset
+        xp_assert_close(log_softmax(x), expect, rtol=1e-13)
+
+    def test_log_softmax_noneaxis(self, xp):
+        # When axis=None, softmax operates on the entire array, and preserves
+        # the shape.
+        x, expect = self.data_1d(xp)
+        x = xp.reshape(x, (2, 2))
+        expect = xp.reshape(expect, (2, 2))
+        xp_assert_close(log_softmax(x), expect, rtol=1e-13)
+
+    @pytest.mark.parametrize('axis_2d, expected_2d', [
+        (0, np.log(0.5) * np.ones((2, 2))),
+        (1, [[0., -999.], [0., -999.]]),
+    ])
+    def test_axes(self, axis_2d, expected_2d, xp):
+        x = xp.asarray([[1000., 1.], [1000., 1.]])
+        xp_assert_close(log_softmax(x, axis=axis_2d),
+                        xp.asarray(expected_2d, dtype=x.dtype), rtol=1e-13)
+
+    def test_log_softmax_2d_axis1(self, xp):
+        x, expect = self.data_2d(xp)
+        xp_assert_close(log_softmax(x, axis=1), expect, rtol=1e-13)
+
+    def test_log_softmax_2d_axis0(self, xp):
+        x, expect = self.data_2d(xp)
+        xp_assert_close(log_softmax(x.T, axis=0), expect.T, rtol=1e-13)
+
+    def test_log_softmax_3d(self, xp):
+        # 3D input, with a tuple for the axis.
+        x, expect = self.data_2d(xp)
+        x = xp.reshape(x, (2, 2, 2))
+        expect = xp.reshape(expect, (2, 2, 2))
+        xp_assert_close(log_softmax(x, axis=(1, 2)), expect, rtol=1e-13)

scipy/special/tests/test_mpmath.py

@@ -321,6 +321,7 @@ def test_lpmv():
 # beta
 # ------------------------------------------------------------------------------
 
+@pytest.mark.slow
 @check_version(mpmath, '0.15')
 def test_beta():
     np.random.seed(1234)

scipy/special/tests/test_nan_inputs.py

@@ -1,7 +1,7 @@
 """Test how the ufuncs in special handle nan inputs.
 
 """
-from typing import Callable
+from collections.abc import Callable
 
 import numpy as np
 from numpy.testing import assert_array_equal, assert_, suppress_warnings

scipy/special/tests/test_orthogonal.py

@@ -258,24 +258,23 @@ class TestCall:
         poly = []
         for n in range(5):
             poly.extend([x.strip() for x in
-                ("""
-                orth.jacobi(%(n)d,0.3,0.9)
-                orth.sh_jacobi(%(n)d,0.3,0.9)
-                orth.genlaguerre(%(n)d,0.3)
-                orth.laguerre(%(n)d)
-                orth.hermite(%(n)d)
-                orth.hermitenorm(%(n)d)
-                orth.gegenbauer(%(n)d,0.3)
-                orth.chebyt(%(n)d)
-                orth.chebyu(%(n)d)
-                orth.chebyc(%(n)d)
-                orth.chebys(%(n)d)
-                orth.sh_chebyt(%(n)d)
-                orth.sh_chebyu(%(n)d)
-                orth.legendre(%(n)d)
-                orth.sh_legendre(%(n)d)
-                """ % dict(n=n)).split()
-            ])
+                (f"""
+                orth.jacobi({n},0.3,0.9)
+                orth.sh_jacobi({n},0.3,0.9)
+                orth.genlaguerre({n},0.3)
+                orth.laguerre({n})
+                orth.hermite({n})
+                orth.hermitenorm({n})
+                orth.gegenbauer({n},0.3)
+                orth.chebyt({n})
+                orth.chebyu({n})
+                orth.chebyc({n})
+                orth.chebys({n})
+                orth.sh_chebyt({n})
+                orth.sh_chebyu({n})
+                orth.legendre({n})
+                orth.sh_legendre({n})
+                """).split()])
         with np.errstate(all='ignore'):
             for pstr in poly:
                 p = eval(pstr)

scipy/special/tests/test_sf_error.py

@@ -2,7 +2,7 @@ import sys
 import warnings
 
 import numpy as np
-from numpy.testing import assert_, assert_equal, IS_PYPY
+from numpy.testing import assert_, assert_equal, HAS_REFCOUNT
 import pytest
 from pytest import raises as assert_raises
 
@@ -73,7 +73,8 @@ def test_seterr():
         sc.seterr(**entry_err)
 
 
-@pytest.mark.skipif(IS_PYPY, reason="Test not meaningful on PyPy")
+@pytest.mark.thread_unsafe
+@pytest.mark.skipif(not HAS_REFCOUNT, reason="Python lacks refcounts")
 def test_sf_error_special_refcount():
     # Regression test for gh-16233.
     # Check that the reference count of scipy.special is not increased

scipy/special/tests/test_sph_harm.py

@@ -1,7 +1,7 @@
 import numpy as np
 import pytest
 
-from numpy.testing import assert_allclose, suppress_warnings
+from numpy.testing import assert_allclose
 import scipy.special as sc
 
 class TestSphHarm:
@@ -47,6 +47,7 @@ class TestSphHarm:
 
         np.testing.assert_allclose(y_actual, y_desired, rtol=1e-05)
 
+@pytest.mark.filterwarnings("ignore::DeprecationWarning")
 def test_first_harmonics():
     # Test against explicit representations of the first four
     # spherical harmonics which use `theta` as the azimuthal angle,
@@ -78,9 +79,7 @@ def test_first_harmonics():
     theta, phi = np.meshgrid(theta, phi)
 
     for harm, m, n in zip(harms, m, n):
-        with suppress_warnings() as sup:
-            sup.filter(category=DeprecationWarning)
-            assert_allclose(sc.sph_harm(m, n, theta, phi),
-                            harm(theta, phi),
-                            rtol=1e-15, atol=1e-15,
-                            err_msg=f"Y^{m}_{n} incorrect")
+        assert_allclose(sc.sph_harm(m, n, theta, phi),
+                        harm(theta, phi),
+                        rtol=1e-15, atol=1e-15,
+                        err_msg=f"Y^{m}_{n} incorrect")