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

scipy/integrate/_rules/_base.py

@@ -463,8 +463,8 @@ def _split_subregion(a, b, xp, split_at=None):
     if split_at is None:
         split_at = (a + b) / 2
 
-    left = [xp.asarray([a[i], split_at[i]]) for i in range(a.shape[0])]
-    right = [xp.asarray([split_at[i], b[i]]) for i in range(b.shape[0])]
+    left = [xp.stack((a[i], split_at[i])) for i in range(a.shape[0])]
+    right = [xp.stack((split_at[i], b[i])) for i in range(b.shape[0])]
 
     a_sub = _cartesian_product(left)
     b_sub = _cartesian_product(right)

scipy/integrate/_tanhsinh.py

@@ -5,7 +5,7 @@ from scipy import special
 import scipy._lib._elementwise_iterative_method as eim
 from scipy._lib._util import _RichResult
 from scipy._lib._array_api import (array_namespace, xp_copy, xp_ravel,
-                                   xp_real, xp_take_along_axis)
+                                   xp_promote)
 
 
 __all__ = ['nsum']
@@ -97,13 +97,10 @@ def tanhsinh(f, a, b, *, args=(), log=False, maxlevel=None, minlevel=2,
     atol, rtol : float, optional
         Absolute termination tolerance (default: 0) and relative termination
         tolerance (default: ``eps**0.75``, where ``eps`` is the precision of
-        the result dtype), respectively.  Iteration will stop when
-        ``res.error < atol`` or  ``res.error < res.integral * rtol``. The error
-        estimate is as described in [1]_ Section 5 but with a lower bound of
-        ``eps * res.integral``. While not theoretically rigorous or
-        conservative, it is said to work well in practice. Must be non-negative
-        and finite if `log` is False, and must be expressed as the log of a
-        non-negative and finite number if `log` is True.
+        the result dtype), respectively. Must be non-negative and finite if
+        `log` is False, and must be expressed as the log of a non-negative and
+        finite number if `log` is True. Iteration will stop when
+        ``res.error < atol`` or  ``res.error < res.integral * rtol``.
     preserve_shape : bool, default: False
         In the following, "arguments of `f`" refers to the array ``xi`` and
         any arrays within ``argsi``. Let ``shape`` be the broadcasted shape
@@ -128,7 +125,7 @@ def tanhsinh(f, a, b, *, args=(), log=False, maxlevel=None, minlevel=2,
         An optional user-supplied function to be called before the first
         iteration and after each iteration.
         Called as ``callback(res)``, where ``res`` is a ``_RichResult``
-        similar to that returned by `_differentiate` (but containing the
+        similar to that returned by `tanhsinh` (but containing the
         current iterate's values of all variables). If `callback` raises a
         ``StopIteration``, the algorithm will terminate immediately and
         `tanhsinh` will return a result object. `callback` must not mutate
@@ -175,6 +172,12 @@ def tanhsinh(f, a, b, *, args=(), log=False, maxlevel=None, minlevel=2,
     finite-precision arithmetic, including some described by [2]_ and [3]_. The
     tanh-sinh scheme was originally introduced in [4]_.
 
+    Two error estimation schemes are described in [1]_ Section 5: one attempts to
+    detect and exploit quadratic convergence; the other simply compares the integral
+    estimates at successive levels. While neither is theoretically rigorous or
+    conservative, both work well in practice. Our error estimate uses the minimum of
+    these two schemes with a lower bound of ``eps * res.integral``.
+
     Due to floating-point error in the abscissae, the function may be evaluated
     at the endpoints of the interval during iterations, but the values returned by
     the function at the endpoints will be ignored.
@@ -364,7 +367,7 @@ def tanhsinh(f, a, b, *, args=(), log=False, maxlevel=None, minlevel=2,
     aerr = xp_ravel(xp.full(shape, xp.nan, dtype=dtype))  # absolute error
     status = xp_ravel(xp.full(shape, eim._EINPROGRESS, dtype=xp.int32))
     h0 = _get_base_step(dtype, xp)
-    h0 = xp_real(h0) # base step
+    h0 = xp.real(h0) # base step
 
     # For term `d4` of error estimate ([1] Section 5), we need to keep the
     # most extreme abscissae and corresponding `fj`s, `wj`s in Euler-Maclaurin
@@ -403,8 +406,7 @@ def tanhsinh(f, a, b, *, args=(), log=False, maxlevel=None, minlevel=2,
 
         # Perform abscissae substitutions for infinite limits of integration
         xj = xp_copy(work.xj)
-        # use xp_real here to avoid cupy/cupy#8434
-        xj[work.abinf] = xj[work.abinf] / (1 - xp_real(xj[work.abinf])**2)
+        xj[work.abinf] = xj[work.abinf] / (1 - xp.real(xj[work.abinf])**2)
         xj[work.binf] = 1/xj[work.binf] - 1 + work.a0[work.binf]
         xj[work.ainf] *= -1
         return xj
@@ -454,7 +456,7 @@ def tanhsinh(f, a, b, *, args=(), log=False, maxlevel=None, minlevel=2,
 
         # Terminate if integral estimate becomes invalid
         if log:
-            Sn_real = xp_real(work.Sn)
+            Sn_real = xp.real(work.Sn)
             Sn_pos_inf = xp.isinf(Sn_real) & (Sn_real > 0)
             i = (Sn_pos_inf | xp.isnan(work.Sn)) & ~stop
         else:
@@ -473,10 +475,7 @@ def tanhsinh(f, a, b, *, args=(), log=False, maxlevel=None, minlevel=2,
         # If the integration limits were such that b < a, we reversed them
         # to perform the calculation, and the final result needs to be negated.
         if log and xp.any(negative):
-            dtype = res['integral'].dtype
-            pi = xp.asarray(xp.pi, dtype=dtype)[()]
-            j = xp.asarray(1j, dtype=xp.complex64)[()]  # minimum complex type
-            res['integral'] = res['integral'] + negative*pi*j
+            res['integral'] = res['integral'] + negative * xp.pi * 1.0j
         else:
             res['integral'][negative] *= -1
 
@@ -615,7 +614,7 @@ def _transform_to_limits(xjc, wj, a, b, xp):
     # these points; however, we can't easily filter out points since this
     # function is vectorized. Instead, zero the weights.
     # Note: values may have complex dtype, but have zero imaginary part
-    xj_real, a_real, b_real = xp_real(xj), xp_real(a), xp_real(b)
+    xj_real, a_real, b_real = xp.real(xj), xp.real(a), xp.real(b)
     invalid = (xj_real <= a_real) | (xj_real >= b_real)
     wj[invalid] = 0
     return xj, wj
@@ -646,16 +645,16 @@ def _euler_maclaurin_sum(fj, work, xp):
 
     # integer index of the maximum abscissa at this level
     xr[invalid_r] = -xp.inf
-    ir = xp.argmax(xp_real(xr), axis=0, keepdims=True)
+    ir = xp.argmax(xp.real(xr), axis=0, keepdims=True)
     # abscissa, function value, and weight at this index
     ### Not Array API Compatible... yet ###
-    xr_max = xp_take_along_axis(xr, ir, axis=0)[0]
-    fr_max = xp_take_along_axis(fr, ir, axis=0)[0]
-    wr_max = xp_take_along_axis(wr, ir, axis=0)[0]
+    xr_max = xp.take_along_axis(xr, ir, axis=0)[0]
+    fr_max = xp.take_along_axis(fr, ir, axis=0)[0]
+    wr_max = xp.take_along_axis(wr, ir, axis=0)[0]
     # boolean indices at which maximum abscissa at this level exceeds
     # the incumbent maximum abscissa (from all previous levels)
     # note: abscissa may have complex dtype, but will have zero imaginary part
-    j = xp_real(xr_max) > xp_real(xr0)
+    j = xp.real(xr_max) > xp.real(xr0)
     # Update record of the incumbent abscissa, function value, and weight
     xr0[j] = xr_max[j]
     fr0[j] = fr_max[j]
@@ -663,15 +662,15 @@ def _euler_maclaurin_sum(fj, work, xp):
 
     # integer index of the minimum abscissa at this level
     xl[invalid_l] = xp.inf
-    il = xp.argmin(xp_real(xl), axis=0, keepdims=True)
+    il = xp.argmin(xp.real(xl), axis=0, keepdims=True)
     # abscissa, function value, and weight at this index
-    xl_min = xp_take_along_axis(xl, il, axis=0)[0]
-    fl_min = xp_take_along_axis(fl, il, axis=0)[0]
-    wl_min = xp_take_along_axis(wl, il, axis=0)[0]
+    xl_min = xp.take_along_axis(xl, il, axis=0)[0]
+    fl_min = xp.take_along_axis(fl, il, axis=0)[0]
+    wl_min = xp.take_along_axis(wl, il, axis=0)[0]
     # boolean indices at which minimum abscissa at this level is less than
     # the incumbent minimum abscissa (from all previous levels)
     # note: abscissa may have complex dtype, but will have zero imaginary part
-    j = xp_real(xl_min) < xp_real(xl0)
+    j = xp.real(xl_min) < xp.real(xl0)
     # Update record of the incumbent abscissa, function value, and weight
     xl0[j] = xl_min[j]
     fl0[j] = fl_min[j]
@@ -682,7 +681,7 @@ def _euler_maclaurin_sum(fj, work, xp):
     # rightmost term, whichever is greater.
     flwl0 = fl0 + xp.log(wl0) if work.log else fl0 * wl0  # leftmost term
     frwr0 = fr0 + xp.log(wr0) if work.log else fr0 * wr0  # rightmost term
-    magnitude = xp_real if work.log else xp.abs
+    magnitude = xp.real if work.log else xp.abs
     work.d4 = xp.maximum(magnitude(flwl0), magnitude(frwr0))
 
     # There are two approaches to dealing with function values that are
@@ -769,14 +768,14 @@ def _estimate_error(work, xp):
         # complex values have imaginary part in increments of pi*j, which just
         # carries sign information of the original integral, so use of
         # `xp.real` here is equivalent to absolute value in real scale.
-        d1 = xp_real(special.logsumexp(xp.stack([work.Sn, Snm1 + work.pi*1j]), axis=0))
-        d2 = xp_real(special.logsumexp(xp.stack([work.Sn, Snm2 + work.pi*1j]), axis=0))
-        d3 = log_e1 + xp.max(xp_real(work.fjwj), axis=-1)
+        d1 = xp.real(special.logsumexp(xp.stack([work.Sn, Snm1 + work.pi*1j]), axis=0))
+        d2 = xp.real(special.logsumexp(xp.stack([work.Sn, Snm2 + work.pi*1j]), axis=0))
+        d3 = log_e1 + xp.max(xp.real(work.fjwj), axis=-1)
         d4 = work.d4
         d5 = log_e1 + xp.real(work.Sn)
         temp = xp.where(d1 > -xp.inf, d1 ** 2 / d2, -xp.inf)
-        ds = xp.stack([temp, 2 * d1, d3, d4, d5])
-        aerr = xp.max(ds, axis=0)
+        ds = xp.stack([temp, 2 * d1, d3, d4])
+        aerr = xp.clip(xp.max(ds, axis=0), d5, d1)
         rerr = aerr - xp.real(work.Sn)
     else:
         # Note: explicit computation of log10 of each of these is unnecessary.
@@ -786,8 +785,8 @@ def _estimate_error(work, xp):
         d4 = work.d4
         d5 = e1 * xp.abs(work.Sn)
         temp = xp.where(d1 > 0, d1**(xp.log(d1)/xp.log(d2)), 0)
-        ds = xp.stack([temp, d1**2, d3, d4, d5])
-        aerr = xp.max(ds, axis=0)
+        ds = xp.stack([temp, d1**2, d3, d4])
+        aerr = xp.clip(xp.max(ds, axis=0), d5, d1)
         rerr = aerr/xp.abs(work.Sn)
 
     return rerr, aerr
@@ -804,7 +803,7 @@ def _transform_integrals(a, b, xp):
     a[ab_same], b[ab_same] = 1, 1
 
     # `a, b` may have complex dtype but have zero imaginary part
-    negative = xp_real(b) < xp_real(a)
+    negative = xp.real(b) < xp.real(a)
     a[negative], b[negative] = b[negative], a[negative]
 
     abinf = xp.isinf(a) & xp.isinf(b)
@@ -825,14 +824,13 @@ def _tanhsinh_iv(f, a, b, log, maxfun, maxlevel, minlevel,
     # Input validation and standardization
 
     xp = array_namespace(a, b)
+    a, b = xp_promote(a, b, broadcast=True, force_floating=True, xp=xp)
 
     message = '`f` must be callable.'
     if not callable(f):
         raise ValueError(message)
 
     message = 'All elements of `a` and `b` must be real numbers.'
-    a, b = xp.asarray(a), xp.asarray(b)
-    a, b = xp.broadcast_arrays(a, b)
     if (xp.isdtype(a.dtype, 'complex floating')
             or xp.isdtype(b.dtype, 'complex floating')):
         raise ValueError(message)
@@ -901,16 +899,15 @@ def _tanhsinh_iv(f, a, b, log, maxfun, maxlevel, minlevel,
 def _nsum_iv(f, a, b, step, args, log, maxterms, tolerances):
     # Input validation and standardization
 
-    xp = array_namespace(a, b)
+    xp = array_namespace(a, b, step)
+    a, b, step = xp_promote(a, b, step, broadcast=True, force_floating=True, xp=xp)
 
     message = '`f` must be callable.'
     if not callable(f):
         raise ValueError(message)
 
     message = 'All elements of `a`, `b`, and `step` must be real numbers.'
-    a, b, step = xp.broadcast_arrays(xp.asarray(a), xp.asarray(b), xp.asarray(step))
-    dtype = xp.result_type(a.dtype, b.dtype, step.dtype)
-    if not xp.isdtype(dtype, 'numeric') or xp.isdtype(dtype, 'complex floating'):
+    if not xp.isdtype(a.dtype, ('integral', 'real floating')):
         raise ValueError(message)
 
     valid_b = b >= a  # NaNs will be False
@@ -1183,6 +1180,7 @@ def nsum(f, a, b, *, step=1, args=(), log=False, maxterms=int(2**20), tolerances
 
     # Branch for direct sum evaluation / integral approximation / invalid input
     i0 = ~valid_abstep                     # invalid
+    i0b = b < a                            # zero
     i1 = (nterms + 1 <= maxterms) & ~i0    # direct sum evaluation
     i2 = xp.isfinite(a) & ~i1 & ~i0        # infinite sum to the right
     i3 = xp.isfinite(b) & ~i2 & ~i1 & ~i0  # infinite sum to the left
@@ -1192,6 +1190,9 @@ def nsum(f, a, b, *, step=1, args=(), log=False, maxterms=int(2**20), tolerances
         S[i0], E[i0] = xp.nan, xp.nan
         status[i0] = -1
 
+        S[i0b], E[i0b] = zero, zero
+        status[i0b] = 0
+
     if xp.any(i1):
         args_direct = [arg[i1] for arg in args]
         tmp = _direct(f, a[i1], b[i1], step[i1], args_direct, constants, xp)
@@ -1294,7 +1295,7 @@ def _direct(f, a, b, step, args, constants, xp, inclusive=True):
     nfev = max_steps - i_nan.sum(axis=-1)
     S = special.logsumexp(fs, axis=-1) if log else xp.sum(fs, axis=-1)
     # Rough, non-conservative error estimate. See gh-19667 for improvement ideas.
-    E = xp_real(S) + math.log(eps) if log else eps * abs(S)
+    E = xp.real(S) + math.log(eps) if log else eps * abs(S)
     return S, E, nfev
 
 
@@ -1310,7 +1311,7 @@ def _integral_bound(f, a, b, step, args, constants, xp):
         tol = special.logsumexp(xp.stack((tol, rtol + lb.integral)), axis=0)
     else:
         tol = tol + rtol*lb.integral
-    i_skip = lb.status < 0  # avoid unnecessary f_evals if integral is divergent
+    i_skip = lb.status == -3  # avoid unnecessary f_evals if integral is divergent
     tol[i_skip] = xp.nan
     status = lb.status
 
@@ -1331,7 +1332,7 @@ def _integral_bound(f, a, b, step, args, constants, xp):
     fksp1 = f(ks + step2, *args2)  # check that the function is decreasing
     fk_insufficient = (fks > tol[:, xp.newaxis]) | (fksp1 > fks)
     n_fk_insufficient = xp.sum(fk_insufficient, axis=-1)
-    nt = xp.minimum(n_fk_insufficient, xp.asarray(n_steps.shape[-1]-1))
+    nt = xp.minimum(n_fk_insufficient, n_steps.shape[-1]-1)
     n_steps = n_steps[nt]
 
     # If `maxterms` is insufficient (i.e. either the magnitude of the last term of the
@@ -1374,7 +1375,7 @@ def _integral_bound(f, a, b, step, args, constants, xp):
         S_terms = (left, right.integral - log_step, fk - log2, fb - log2)
         S = special.logsumexp(xp.stack(S_terms), axis=0)
         E_terms = (left_error, right.error - log_step, fk-log2, fb-log2+xp.pi*1j)
-        E = xp_real(special.logsumexp(xp.stack(E_terms), axis=0))
+        E = xp.real(special.logsumexp(xp.stack(E_terms), axis=0))
     else:
         S = left + right.integral/step + fk/2 + fb/2
         E = left_error + right.error/step + fk/2 - fb/2

scipy/integrate/tests/test__quad_vec.py

@@ -209,9 +209,3 @@ def test_points(a, b):
     for p in interval_sets:
         j = np.searchsorted(sorted(points), tuple(p))
         assert np.all(j == j[0])
-
-
-@pytest.mark.thread_unsafe
-def test_trapz_deprecation():
-    with pytest.deprecated_call(match="`quadrature='trapz'`"):
-        quad_vec(lambda x: x, 0, 1, quadrature="trapz")

scipy/integrate/tests/test_banded_ode_solvers.py

@@ -130,6 +130,9 @@ def test_banded_ode_solvers():
     # Test the "lsoda", "vode" and "zvode" solvers of the `ode` class
     # with a system that has a banded Jacobian matrix.
 
+    # This test does not test the Jacobian evaluation (banded or not)
+    # of "lsoda" due to the nonstiff nature of the equations.
+
     t_exact = np.linspace(0, 1.0, 5)
 
     # --- Real arrays for testing the "lsoda" and "vode" solvers ---
@@ -218,3 +221,85 @@ def test_banded_ode_solvers():
              [False, True]]      # banded
         for meth, use_jac, with_jac, banded in itertools.product(*p):
             check_complex(idx, "zvode", meth, use_jac, with_jac, banded)
+
+# lsoda requires a stiffer problem to switch to stiff solver
+# Use the Robertson equation with surrounding trivial equations to make banded
+
+def stiff_f(t, y):
+    return np.array([
+        y[0],
+        -0.04 * y[1] + 1e4 * y[2] * y[3],
+        0.04 * y[1] - 1e4 * y[2] * y[3] - 3e7 * y[2]**2,
+        3e7 * y[2]**2,
+        y[4]
+    ])
+
+def stiff_jac(t, y):
+    return np.array([
+        [1,     0,                            0,         0, 0],
+        [0, -0.04,                     1e4*y[3],  1e4*y[2], 0],
+        [0,  0.04, -1e4 * y[3] - 3e7 * 2 * y[2], -1e4*y[2], 0],
+        [0,     0,                   3e7*2*y[2],         0, 0],
+        [0,     0,                            0,         0, 1]
+    ])
+
+def banded_stiff_jac(t, y):
+    return np.array([
+        [0,     0,                    0,  1e4*y[2], 0],
+        [0,     0,             1e4*y[3], -1e4*y[2], 0],
+        [1, -0.04, -1e4*y[3]-3e7*2*y[2],         0, 1],
+        [0,  0.04,           3e7*2*y[2],         0, 0]
+    ])
+
+@pytest.mark.thread_unsafe
+def test_banded_lsoda():
+    # expected solution is given by problem with full jacobian
+    tfull, yfull = _solve_robertson_lsoda(use_jac=True, banded=False)
+
+    for use_jac in [True, False]:
+        t, y = _solve_robertson_lsoda(use_jac, True)
+        assert_allclose(t, tfull)
+        assert_allclose(y, yfull)
+
+def _solve_robertson_lsoda(use_jac, banded):
+
+    if use_jac:
+        if banded:
+            jac = banded_stiff_jac
+        else:
+            jac = stiff_jac
+    else:
+        jac = None
+
+    if banded:
+        lband = 1
+        uband = 2
+    else:
+        lband = None
+        uband = None
+
+    r = ode(stiff_f, jac)
+    r.set_integrator('lsoda',
+                     lband=lband, uband=uband,
+                     rtol=1e-9, atol=1e-10,
+                     )
+    t0 = 0
+    dt = 1
+    tend = 10
+    y0 = np.array([1.0, 1.0, 0.0, 0.0, 1.0])
+    r.set_initial_value(y0, t0)
+
+    t = [t0]
+    y = [y0]
+    while r.successful() and r.t < tend:
+        r.integrate(r.t + dt)
+        t.append(r.t)
+        y.append(r.y)
+
+    # Ensure that the Jacobian was evaluated
+    # iwork[12] has the number of Jacobian evaluations.
+    assert r._integrator.iwork[12] > 0
+
+    t = np.array(t)
+    y = np.array(y)
+    return t, y

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(