scipy 1.15.2__cp312-cp312-macosx_14_0_arm64.whl → 1.16.0__cp312-cp312-macosx_14_0_arm64.whl

scipy/integrate/tests/test_cubature.py

@@ -11,10 +11,8 @@ from scipy._lib._array_api import (
     np_compat,
     is_array_api_strict,
 )
-from scipy.conftest import array_api_compatible
-
 from scipy.integrate import cubature
-
+from scipy.integrate._cubature import _InfiniteLimitsTransform
 from scipy.integrate._rules import (
     Rule, FixedRule,
     NestedFixedRule,
@@ -22,10 +20,8 @@ from scipy.integrate._rules import (
     GenzMalikCubature,
 )
 
-from scipy.integrate._cubature import _InfiniteLimitsTransform
-
-pytestmark = [pytest.mark.usefixtures("skip_xp_backends"),]
 skip_xp_backends = pytest.mark.skip_xp_backends
+boolean_index_skip_reason = 'JAX/Dask arrays do not support boolean assignment.'
 
 # The integrands ``genz_malik_1980_*`` come from the paper:
 #   A.C. Genz, A.A. Malik, Remarks on algorithm 006: An adaptive algorithm for
@@ -120,13 +116,10 @@ def genz_malik_1980_f_2_exact(a, b, alphas, betas, xp):
     a = xp.reshape(a, (*([1]*(len(alphas.shape) - 1)), ndim))
     b = xp.reshape(b, (*([1]*(len(alphas.shape) - 1)), ndim))
 
-    # `xp` is the unwrapped namespace, so `.atan` won't work for `xp = np` and np<2.
-    xp_test = array_namespace(a)
-
     return (
         (-1)**ndim * 1/xp.prod(alphas, axis=-1)
         * xp.prod(
-            xp_test.atan((a - betas)/alphas) - xp_test.atan((b - betas)/alphas),
+            xp.atan((a - betas)/alphas) - xp.atan((b - betas)/alphas),
             axis=-1,
         )
     )
@@ -229,7 +222,9 @@ def _eval_indefinite_integral(F, a, b, xp):
 
     out = 0
     for ind in itertools.product(range(2), repeat=ndim):
-        selected_points = xp.asarray([points[i, j] for i, j in zip(ind, range(ndim))])
+        selected_points = xp.asarray(
+            [float(points[i, j]) for i, j in zip(ind, range(ndim))]
+        )
         out += pow(-1, sum(ind) + ndim) * F(selected_points)
 
     return out
@@ -377,7 +372,6 @@ def f_with_problematic_points(x_arr, points, xp):
     return xp.ones(x_arr.shape[0])
 
 
-@array_api_compatible
 class TestCubature:
     """
     Tests related to the interface of `cubature`.
@@ -534,12 +528,13 @@ class TestCubature:
     "gk21",
     "genz-malik",
 ])
-@array_api_compatible
 class TestCubatureProblems:
     """
     Tests that `cubature` gives the correct answer.
     """
 
+    @skip_xp_backends("dask.array",
+                      reason="Dask hangs/takes a long time for some test cases")
     @pytest.mark.parametrize("problem", [
         # -- f1 --
         (
@@ -786,6 +781,8 @@ class TestCubatureProblems:
             err_msg=f"estimate_error={res.error}, subdivisions={res.subdivisions}",
         )
 
+    @skip_xp_backends("dask.array",
+                      reason="Dask hangs/takes a long time for some test cases")
     @pytest.mark.parametrize("problem", [
         (
             # Function to integrate, like `f(x, *args)`
@@ -973,10 +970,8 @@ class TestCubatureProblems:
                    f"true_error={xp.abs(res.estimate - exact)}")
         assert res.status == "converged", err_msg
 
-    @skip_xp_backends(
-        "jax.numpy",
-        reasons=["transforms make use of indexing assignment"],
-    )
+    @pytest.mark.skip_xp_backends('jax.numpy', reason=boolean_index_skip_reason)
+    @pytest.mark.skip_xp_backends('dask.array', reason=boolean_index_skip_reason)
     @pytest.mark.parametrize("problem", [
         (
             # Function to integrate
@@ -1123,10 +1118,8 @@ class TestCubatureProblems:
             check_0d=False,
         )
 
-    @skip_xp_backends(
-        "jax.numpy",
-        reasons=["transforms make use of indexing assignment"],
-    )
+    @pytest.mark.skip_xp_backends('jax.numpy', reason=boolean_index_skip_reason)
+    @pytest.mark.skip_xp_backends('dask.array', reason=boolean_index_skip_reason)
     @pytest.mark.parametrize("problem", [
         (
             # Function to integrate
@@ -1197,7 +1190,6 @@ class TestCubatureProblems:
         )
 
 
-@array_api_compatible
 class TestRules:
     """
     Tests related to the general Rule interface (currently private).
@@ -1238,7 +1230,6 @@ class TestRules:
                 base_class.estimate(basic_1d_integrand, a, b, args=(xp,))
 
 
-@array_api_compatible
 class TestRulesQuadrature:
     """
     Tests underlying quadrature rules (ndim == 1).
@@ -1311,7 +1302,6 @@ class TestRulesQuadrature:
             quadrature(1, xp=xp)
 
 
-@array_api_compatible
 class TestRulesCubature:
     """
     Tests underlying cubature rules (ndim >= 2).
@@ -1333,11 +1323,8 @@ class TestRulesCubature:
             GenzMalikCubature(1, xp=xp)
 
 
-@array_api_compatible
-@skip_xp_backends(
-    "jax.numpy",
-    reasons=["transforms make use of indexing assignment"],
-)
+@pytest.mark.skip_xp_backends('jax.numpy', reason=boolean_index_skip_reason)
+@pytest.mark.skip_xp_backends('dask.array', reason=boolean_index_skip_reason)
 class TestTransformations:
     @pytest.mark.parametrize(("a", "b", "points"), [
         (
@@ -1355,19 +1342,18 @@ class TestTransformations:
         transformation.
         """
 
-        xp_compat = array_namespace(xp.empty(0))
         points = [xp.asarray(p, dtype=xp.float64) for p in points]
 
         f_transformed = _InfiniteLimitsTransform(
             # Bind `points` and `xp` argument in f
-            lambda x: f_with_problematic_points(x, points, xp_compat),
-            xp.asarray(a, dtype=xp_compat.float64),
-            xp.asarray(b, dtype=xp_compat.float64),
-            xp=xp_compat,
+            lambda x: f_with_problematic_points(x, points, xp),
+            xp.asarray(a, dtype=xp.float64),
+            xp.asarray(b, dtype=xp.float64),
+            xp=xp,
         )
 
         for point in points:
-            transformed_point = f_transformed.inv(xp_compat.reshape(point, (1, -1)))
+            transformed_point = f_transformed.inv(xp.reshape(point, (1, -1)))
 
             with pytest.raises(Exception, match="called with a problematic point"):
                 f_transformed(transformed_point)

scipy/integrate/tests/test_quadrature.py

@@ -13,7 +13,7 @@ from scipy.integrate import (romb, newton_cotes,
 from scipy.integrate._quadrature import _cumulative_simpson_unequal_intervals
 
 from scipy import stats, special, integrate
-from scipy.conftest import array_api_compatible, skip_xp_invalid_arg
+from scipy.conftest import skip_xp_invalid_arg
 from scipy._lib._array_api_no_0d import xp_assert_close
 
 skip_xp_backends = pytest.mark.skip_xp_backends
@@ -269,7 +269,6 @@ class TestCumulative_trapezoid:
             cumulative_trapezoid(y=[])
 
 
-@array_api_compatible
 class TestTrapezoid:
     def test_simple(self, xp):
         x = xp.arange(-10, 10, .1)
@@ -278,8 +277,7 @@ class TestTrapezoid:
         xp_assert_close(r, xp.asarray(1.0))
 
     @skip_xp_backends('jax.numpy',
-                      reasons=["JAX arrays do not support item assignment"])
-    @pytest.mark.usefixtures("skip_xp_backends")
+                      reason="JAX arrays do not support item assignment")
     def test_ndim(self, xp):
         x = xp.linspace(0, 1, 3)
         y = xp.linspace(0, 2, 8)
@@ -318,8 +316,7 @@ class TestTrapezoid:
         xp_assert_close(r, qz)
 
     @skip_xp_backends('jax.numpy',
-                      reasons=["JAX arrays do not support item assignment"])
-    @pytest.mark.usefixtures("skip_xp_backends")
+                      reason="JAX arrays do not support item assignment")
     def test_gh21908(self, xp):
         # extended testing for n-dim arrays
         x = xp.reshape(xp.linspace(0, 29, 30), (3, 10))
@@ -362,8 +359,7 @@ class TestTrapezoid:
         assert_allclose(trapezoid(y, xm), r)
 
     @skip_xp_backends(np_only=True,
-                      reasons=['array-likes only supported for NumPy backend'])
-    @pytest.mark.usefixtures("skip_xp_backends")
+                      reason='array-likes only supported for NumPy backend')
     def test_array_like(self, xp):
         x = list(range(5))
         y = [t * t for t in x]
@@ -635,6 +631,7 @@ class TestCumulativeSimpson:
         # `simpson` uses the trapezoidal rule
         return theoretical_difference
 
+    @pytest.mark.fail_slow(10)
     @pytest.mark.thread_unsafe
     @pytest.mark.slow
     @given(
@@ -666,6 +663,7 @@ class TestCumulativeSimpson:
             res[..., 1:], ref[..., 1:] + theoretical_difference[..., 1:], atol=1e-16
         )
 
+    @pytest.mark.fail_slow(10)
     @pytest.mark.thread_unsafe
     @pytest.mark.slow
     @given(

scipy/integrate/tests/test_tanhsinh.py

@@ -6,7 +6,6 @@ import math
 import numpy as np
 from numpy.testing import assert_allclose
 
-from scipy.conftest import array_api_compatible
 import scipy._lib._elementwise_iterative_method as eim
 from scipy._lib._array_api_no_0d import xp_assert_close, xp_assert_equal
 from scipy._lib._array_api import array_namespace, xp_size, xp_ravel, xp_copy, is_numpy
@@ -20,6 +19,7 @@ def norm_pdf(x, xp=None):
     xp = array_namespace(x) if xp is None else xp
     return 1/(2*xp.pi)**0.5 * xp.exp(-x**2/2)
 
+
 def norm_logpdf(x, xp=None):
     xp = array_namespace(x) if xp is None else xp
     return -0.5*math.log(2*xp.pi) - x**2/2
@@ -43,11 +43,12 @@ def _vectorize(xp):
     return decorator
 
 
-@array_api_compatible
-@pytest.mark.usefixtures("skip_xp_backends")
 @pytest.mark.skip_xp_backends(
     'array_api_strict', reason='Currently uses fancy indexing assignment.'
 )
+@pytest.mark.skip_xp_backends(
+    'dask.array', reason='boolean indexing assignment'
+)
 @pytest.mark.skip_xp_backends(
     'jax.numpy', reason='JAX arrays do not support item assignment.'
 )
@@ -233,11 +234,11 @@ class TestTanhSinh:
         logres = _tanhsinh(norm_logpdf, *limits, log=True)
         xp_assert_close(xp.exp(logres.integral), ref, check_dtype=False)
         # Transformation should not make the result complex unnecessarily
-        xp_test = array_namespace(*limits)  # we need xp.isdtype
-        assert (xp_test.isdtype(logres.integral.dtype, "real floating") if ref > 0
-                else xp_test.isdtype(logres.integral.dtype, "complex floating"))
+        assert (xp.isdtype(logres.integral.dtype, "real floating") if ref > 0
+                else xp.isdtype(logres.integral.dtype, "complex floating"))
 
-        xp_assert_close(xp.exp(logres.error), res.error, atol=1e-16, check_dtype=False)
+        atol = 2 * xp.finfo(res.error.dtype).eps
+        xp_assert_close(xp.exp(logres.error), res.error, atol=atol, check_dtype=False)
 
     # 15 skipped intentionally; it's very difficult numerically
     @pytest.mark.skip_xp_backends(np_only=True,
@@ -248,7 +249,7 @@ class TestTanhSinh:
         rtol = 2e-8
         res = _tanhsinh(f, 0, f.b, rtol=rtol)
         assert_allclose(res.integral, f.ref, rtol=rtol)
-        if f_number not in {14}:  # mildly underestimates error here
+        if f_number not in {7, 12, 14}:  # mildly underestimates error here
             true_error = abs(self.error(res.integral, f.ref)/res.integral)
             assert true_error < res.error
 
@@ -299,18 +300,17 @@ class TestTanhSinh:
         res = _tanhsinh(f, a, b, args=(p,))
         refs = _tanhsinh_single(a, b, p)
 
-        xp_test = array_namespace(a)  # need xp.stack, isdtype
         attrs = ['integral', 'error', 'success', 'status', 'nfev', 'maxlevel']
         for attr in attrs:
-            ref_attr = xp_test.stack([getattr(ref, attr) for ref in refs])
+            ref_attr = xp.stack([getattr(ref, attr) for ref in refs])
             res_attr = xp_ravel(getattr(res, attr))
             xp_assert_close(res_attr, ref_attr, rtol=1e-15)
             assert getattr(res, attr).shape == shape
 
-        assert xp_test.isdtype(res.success.dtype, 'bool')
-        assert xp_test.isdtype(res.status.dtype, 'integral')
-        assert xp_test.isdtype(res.nfev.dtype, 'integral')
-        assert xp_test.isdtype(res.maxlevel.dtype, 'integral')
+        assert xp.isdtype(res.success.dtype, 'bool')
+        assert xp.isdtype(res.status.dtype, 'integral')
+        assert xp.isdtype(res.nfev.dtype, 'integral')
+        assert xp.isdtype(res.maxlevel.dtype, 'integral')
         assert xp.max(res.nfev) == f.feval
         # maxlevel = 2 -> 3 function calls (2 initialization, 1 work)
         assert xp.max(res.maxlevel) >= 2
@@ -383,12 +383,10 @@ class TestTanhSinh:
     def test_options_and_result_attributes(self, xp):
         # demonstrate that options are behaving as advertised and status
         # messages are as intended
-        xp_test = array_namespace(xp.asarray(1.))  # need xp.atan
-
         def f(x):
             f.calls += 1
             f.feval += xp_size(xp.asarray(x))
-            return x**2 * xp_test.atan(x)
+            return x**2 * xp.atan(x)
 
         f.ref = xp.asarray((math.pi - 2 + 2 * math.log(2)) / 12, dtype=xp.float64)
 
@@ -560,21 +558,18 @@ class TestTanhSinh:
         # integrand is evaluated or the integral/error estimates, only the
         # number of function calls
 
-        # need `xp.concat`, `xp.atan`, and `xp.sort`
-        xp_test = array_namespace(xp.asarray(1.))
-
         def f(x):
             f.calls += 1
             f.feval += xp_size(xp.asarray(x))
-            f.x = xp_test.concat((f.x, xp_ravel(x)))
-            return x**2 * xp_test.atan(x)
+            f.x = xp.concat((f.x, xp_ravel(x)))
+            return x**2 * xp.atan(x)
 
         f.feval, f.calls, f.x = 0, 0, xp.asarray([])
 
         a = xp.asarray(0, dtype=xp.float64)
         b = xp.asarray(1, dtype=xp.float64)
         ref = _tanhsinh(f, a, b, minlevel=0, maxlevel=maxlevel)
-        ref_x = xp_test.sort(f.x)
+        ref_x = xp.sort(f.x)
 
         for minlevel in range(0, maxlevel + 1):
             f.feval, f.calls, f.x = 0, 0, xp.asarray([])
@@ -587,7 +582,7 @@ class TestTanhSinh:
             assert res.nfev == f.feval == f.x.shape[0]
             assert f.calls == maxlevel - minlevel + 1 + 1  # 1 validation call
             assert res.status == ref.status
-            xp_assert_equal(ref_x, xp_test.sort(f.x))
+            xp_assert_equal(ref_x, xp.sort(f.x))
 
     def test_improper_integrals(self, xp):
         # Test handling of infinite limits of integration (mixed with finite limits)
@@ -679,10 +674,9 @@ class TestTanhSinh:
     def test_special_cases(self, xp):
         # Test edge cases and other special cases
         a, b = xp.asarray(0), xp.asarray(1)
-        xp_test = array_namespace(a, b)  # need `xp.isdtype`
 
         def f(x):
-            assert xp_test.isdtype(x.dtype, "real floating")
+            assert xp.isdtype(x.dtype, "real floating")
             return x
 
         res = _tanhsinh(f, a, b)
@@ -753,11 +747,30 @@ class TestTanhSinh:
         x[-1] = 1000
         _tanhsinh(np.sin, 1, x)
 
+    def test_gh_22681_finite_error(self, xp):
+        # gh-22681 noted a case in which the error was NaN on some platforms;
+        # check that this does in fact fail in CI.
+        c1 = complex(12, -10)
+        c2 = complex(12, 39)
+        def f(t):
+            return xp.sin(c1 * (1 - t) + c2 * t)
+        a, b = xp.asarray(0., dtype=xp.float64), xp.asarray(1., dtype=xp.float64)
+        ref = _tanhsinh(f, a, b, atol=0, rtol=0, maxlevel=10)
+        assert xp.isfinite(ref.error)
+        # Previously, tanhsinh would not detect convergence
+        res = _tanhsinh(f, a, b, rtol=1e-14)
+        assert res.success
+        assert res.maxlevel < 5
+        xp_assert_close(res.integral, ref.integral, rtol=1e-15)
+
 
-@array_api_compatible
-@pytest.mark.usefixtures("skip_xp_backends")
+@pytest.mark.skip_xp_backends('torch', reason='data-apis/array-api-compat#271')
 @pytest.mark.skip_xp_backends('array_api_strict', reason='No fancy indexing.')
 @pytest.mark.skip_xp_backends('jax.numpy', reason='No mutation.')
+@pytest.mark.skip_xp_backends(
+    'dask.array',
+    reason='Data-dependent shapes in boolean index assignment'
+)
 class TestNSum:
     rng = np.random.default_rng(5895448232066142650)
     p = rng.uniform(1, 10, size=10).tolist()
@@ -812,13 +825,21 @@ class TestNSum:
         with pytest.raises(ValueError, match=message):
             nsum(f, a, b, tolerances=dict(rtol=pytest))
 
-        with np.errstate(all='ignore'):
+        with (np.errstate(all='ignore')):
             res = nsum(f, xp.asarray([np.nan, np.inf]), xp.asarray(1.))
-            assert xp.all((res.status == -1) & xp.isnan(res.sum)
-                          & xp.isnan(res.error) & ~res.success & res.nfev == 1)
+            assert (res.status[0] == -1) and not res.success[0]
+            assert xp.isnan(res.sum[0]) and xp.isnan(res.error[0])
+            assert (res.status[1] == 0) and res.success[1]
+            assert res.sum[1] == res.error[1]
+            assert xp.all(res.nfev[0] == 1)
+
             res = nsum(f, xp.asarray(10.), xp.asarray([np.nan, 1]))
-            assert xp.all((res.status == -1) & xp.isnan(res.sum)
-                          & xp.isnan(res.error) & ~res.success & res.nfev == 1)
+            assert (res.status[0] == -1) and not res.success[0]
+            assert xp.isnan(res.sum[0]) and xp.isnan(res.error[0])
+            assert (res.status[1] == 0) and res.success[1]
+            assert res.sum[1] == res.error[1]
+            assert xp.all(res.nfev[0] == 1)
+
             res = nsum(f, xp.asarray(1.), xp.asarray(10.),
                        step=xp.asarray([xp.nan, -xp.inf, xp.inf, -1, 0]))
             assert xp.all((res.status == -1) & xp.isnan(res.sum)
@@ -852,8 +873,7 @@ class TestNSum:
         res = nsum(f, a, b, args=args)
         xp_assert_close(res.sum, ref)
         xp_assert_equal(res.status, xp.zeros(ref.shape, dtype=xp.int32))
-        xp_test = array_namespace(a)  # CuPy doesn't have `bool`
-        xp_assert_equal(res.success, xp.ones(ref.shape, dtype=xp_test.bool))
+        xp_assert_equal(res.success, xp.ones(ref.shape, dtype=xp.bool))
 
         with np.errstate(divide='ignore'):
             logres = nsum(lambda *args: xp.log(f(*args)),
@@ -891,8 +911,7 @@ class TestNSum:
         ref_err = (high - low)/2  # error (assuming perfect quadrature)
 
         # correct reference values where number of terms < maxterms
-        xp_test = array_namespace(a)  # torch needs broadcast_arrays
-        a, b, step = xp_test.broadcast_arrays(a, b, step)
+        a, b, step = xp.broadcast_arrays(a, b, step)
         for i in np.ndindex(a.shape):
             ai, bi, stepi = float(a[i]), float(b[i]), float(step[i])
             if (bi - ai)/stepi + 1 <= maxterms:
@@ -949,10 +968,9 @@ class TestNSum:
             xp_assert_close(xp_ravel(res_attr), xp.asarray(ref_attr), rtol=1e-15)
             assert res_attr.shape == shape
 
-        xp_test = array_namespace(xp.asarray(1.))
-        assert xp_test.isdtype(res.success.dtype, 'bool')
-        assert xp_test.isdtype(res.status.dtype, 'integral')
-        assert xp_test.isdtype(res.nfev.dtype, 'integral')
+        assert xp.isdtype(res.success.dtype, 'bool')
+        assert xp.isdtype(res.status.dtype, 'integral')
+        assert xp.isdtype(res.nfev.dtype, 'integral')
         if is_numpy(xp):  # other libraries might have different number
             assert int(xp.max(res.nfev)) == f.feval
 
@@ -1074,8 +1092,8 @@ class TestNSum:
                 return 1 / x
 
         res = nsum(f, xp.asarray(0), xp.asarray(10), maxterms=0)
-        assert xp.isnan(res.sum)
-        assert xp.isnan(res.error)
+        assert xp.isinf(res.sum)
+        assert xp.isinf(res.error)
         assert res.status == -2
 
         res = nsum(f, xp.asarray(0), xp.asarray(10), maxterms=1)