scipy 1.15.3__cp312-cp312-musllinux_1_2_aarch64.whl → 1.16.0rc2__cp312-cp312-musllinux_1_2_aarch64.whl

scipy/fft/tests/test_fftlog.py

@@ -7,10 +7,8 @@ import pytest
 from scipy.fft._fftlog import fht, ifht, fhtoffset
 from scipy.special import poch
 
-from scipy.conftest import array_api_compatible
-from scipy._lib._array_api import xp_assert_close, xp_assert_less, array_namespace
+from scipy._lib._array_api import xp_assert_close, xp_assert_less
 
-pytestmark = [array_api_compatible, pytest.mark.usefixtures("skip_xp_backends"),]
 skip_xp_backends = pytest.mark.skip_xp_backends
 
 
@@ -25,7 +23,7 @@ def test_fht_agrees_with_fftlog(xp):
 
     r = np.logspace(-4, 4, 16)
 
-    dln = np.log(r[1]/r[0])
+    dln = math.log(r[1]/r[0])
     mu = 0.3
     offset = 0.0
     bias = 0.0
@@ -62,6 +60,10 @@ def test_fht_agrees_with_fftlog(xp):
     # test 3: positive bias
     bias = 0.8
     offset = fhtoffset(dln, mu, bias=bias)
+    # offset is a np.float64, which array-api-strict disallows
+    # even if it's technically a subclass of float
+    offset = float(offset)
+
     ours = fht(a, dln, mu, offset=offset, bias=bias)
     theirs = [-7.3436673558316850E+00, +0.1710271207817100E+00,
               +0.1065374386206564E+00, -0.5121739602708132E-01,
@@ -77,6 +79,8 @@ def test_fht_agrees_with_fftlog(xp):
     # test 4: negative bias
     bias = -0.8
     offset = fhtoffset(dln, mu, bias=bias)
+    offset = float(offset)
+
     ours = fht(a, dln, mu, offset=offset, bias=bias)
     theirs = [+0.8985777068568745E-05, +0.4074898209936099E-04,
               +0.2123969254700955E-03, +0.1009558244834628E-02,
@@ -103,6 +107,9 @@ def test_fht_identity(n, bias, offset, optimal, xp):
 
     if optimal:
         offset = fhtoffset(dln, mu, initial=offset, bias=bias)
+        # offset is a np.float64, which array-api-strict disallows
+        # even if it's technically a subclass of float
+        offset = float(offset)
 
     A = fht(a, dln, mu, offset=offset, bias=bias)
     a_ = ifht(A, dln, mu, offset=offset, bias=bias)
@@ -163,9 +170,12 @@ def test_fht_exact(n, xp):
     r = np.logspace(-2, 2, n)
     a = xp.asarray(r**gamma)
 
-    dln = np.log(r[1]/r[0])
+    dln = math.log(r[1]/r[0])
 
     offset = fhtoffset(dln, mu, initial=0.0, bias=gamma)
+    # offset is a np.float64, which array-api-strict disallows
+    # even if it's technically a subclass of float
+    offset = float(offset)
 
     A = fht(a, dln, mu, offset=offset, bias=gamma)
 
@@ -188,13 +198,12 @@ def test_array_like(xp, op):
 @pytest.mark.parametrize('n', [128, 129])
 def test_gh_21661(xp, n):
     one = xp.asarray(1.0)
-    xp_test = array_namespace(one)
     mu = 0.0
     r = np.logspace(-7, 1, n)
     dln = math.log(r[1] / r[0])
     offset = fhtoffset(dln, initial=-6 * np.log(10), mu=mu)
     r = xp.asarray(r, dtype=one.dtype)
-    k = math.exp(offset) / xp_test.flip(r, axis=-1)
+    k = math.exp(offset) / xp.flip(r, axis=-1)
 
     def f(x, mu):
         return x**(mu + 1)*xp.exp(-x**2/2)

scipy/fft/tests/test_helper.py

@@ -10,13 +10,9 @@ from pytest import raises as assert_raises
 import pytest
 import numpy as np
 import sys
-from scipy.conftest import array_api_compatible
-from scipy._lib._array_api import (
-    xp_assert_close, get_xp_devices, xp_device, array_namespace
-)
+from scipy._lib._array_api import xp_assert_close, xp_device
 from scipy import fft
 
-pytestmark = [array_api_compatible, pytest.mark.usefixtures("skip_xp_backends")]
 skip_xp_backends = pytest.mark.skip_xp_backends
 
 _5_smooth_numbers = [
@@ -26,7 +22,8 @@ _5_smooth_numbers = [
     2**3 * 3**3 * 5**2,
 ]
 
-def test_next_fast_len():
+@skip_xp_backends(np_only=True)
+def test_next_fast_len(xp):
     for n in _5_smooth_numbers:
         assert_equal(next_fast_len(n), n)
 
@@ -56,7 +53,7 @@ def _assert_n_smooth(x, n):
 @skip_xp_backends(np_only=True)
 class TestNextFastLen:
 
-    def test_next_fast_len(self):
+    def test_next_fast_len(self, xp):
         np.random.seed(1234)
 
         def nums():
@@ -71,14 +68,14 @@ class TestNextFastLen:
             m = next_fast_len(n, True)
             _assert_n_smooth(m, 5)
 
-    def test_np_integers(self):
+    def test_np_integers(self, xp):
         ITYPES = [np.int16, np.int32, np.int64, np.uint16, np.uint32, np.uint64]
         for ityp in ITYPES:
             x = ityp(12345)
             testN = next_fast_len(x)
             assert_equal(testN, next_fast_len(int(x)))
 
-    def testnext_fast_len_small(self):
+    def testnext_fast_len_small(self, xp):
         hams = {
             1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 8, 8: 8, 14: 15, 15: 15,
             16: 16, 17: 18, 1021: 1024, 1536: 1536, 51200000: 51200000
@@ -89,7 +86,7 @@ class TestNextFastLen:
     @pytest.mark.xfail(sys.maxsize < 2**32,
                        reason="Hamming Numbers too large for 32-bit",
                        raises=ValueError, strict=True)
-    def testnext_fast_len_big(self):
+    def testnext_fast_len_big(self, xp):
         hams = {
             510183360: 510183360, 510183360 + 1: 512000000,
             511000000: 512000000,
@@ -123,14 +120,14 @@ class TestNextFastLen:
         for x, y in hams.items():
             assert_equal(next_fast_len(x, True), y)
 
-    def test_keyword_args(self):
+    def test_keyword_args(self, xp):
         assert next_fast_len(11, real=True) == 12
         assert next_fast_len(target=7, real=False) == 7
 
 @skip_xp_backends(np_only=True)
 class TestPrevFastLen:
 
-    def test_prev_fast_len(self):
+    def test_prev_fast_len(self, xp):
         np.random.seed(1234)
 
         def nums():
@@ -145,7 +142,7 @@ class TestPrevFastLen:
             m = prev_fast_len(n, True)
             _assert_n_smooth(m, 5)
 
-    def test_np_integers(self):
+    def test_np_integers(self, xp):
         ITYPES = [np.int16, np.int32, np.int64, np.uint16, np.uint32, 
                     np.uint64]
         for ityp in ITYPES:
@@ -156,7 +153,7 @@ class TestPrevFastLen:
             testN = prev_fast_len(x, real=True)
             assert_equal(testN, prev_fast_len(int(x), real=True))
 
-    def testprev_fast_len_small(self):
+    def testprev_fast_len_small(self, xp):
         hams = {
             1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 6, 8: 8, 14: 12, 15: 15,
             16: 16, 17: 16, 1021: 1000, 1536: 1536, 51200000: 51200000
@@ -176,7 +173,7 @@ class TestPrevFastLen:
     @pytest.mark.xfail(sys.maxsize < 2**32,
                        reason="Hamming Numbers too large for 32-bit",
                        raises=ValueError, strict=True)
-    def testprev_fast_len_big(self):
+    def testprev_fast_len_big(self, xp):
         hams = {
             # 2**6 * 3**13 * 5**1
             510183360: 510183360,
@@ -238,7 +235,7 @@ class TestPrevFastLen:
         for x, y in hams.items():
             assert_equal(prev_fast_len(x, True), y)
 
-    def test_keyword_args(self):
+    def test_keyword_args(self, xp):
         assert prev_fast_len(11, real=True) == 10
         assert prev_fast_len(target=7, real=False) == 7
 
@@ -508,12 +505,7 @@ class TestFFTShift:
         xp_assert_close(fft.ifftshift(shift_dim_both), freqs)
 
 
-@skip_xp_backends("cupy",
-                  reason="CuPy has not implemented the `device` param")
-@skip_xp_backends("jax.numpy",
-                  reason="JAX has not implemented the `device` param")
 class TestFFTFreq:
-
     def test_definition(self, xp):
         x = xp.asarray([0, 1, 2, 3, 4, -4, -3, -2, -1], dtype=xp.float64)
         x2 = xp.asarray([0, 1, 2, 3, 4, -5, -4, -3, -2, -1], dtype=xp.float64)
@@ -532,19 +524,13 @@ class TestFFTFreq:
         y = 10 * xp.pi * fft.fftfreq(10, xp.pi, xp=xp)
         xp_assert_close(y, x2, check_dtype=False)
 
-    def test_device(self, xp):
-        xp_test = array_namespace(xp.empty(0))
-        devices = get_xp_devices(xp)
+    def test_device(self, xp, devices):
         for d in devices:
             y = fft.fftfreq(9, xp=xp, device=d)
-            x = xp_test.empty(0, device=d)
+            x = xp.empty(0, device=d)
             assert xp_device(y) == xp_device(x)
 
 
-@skip_xp_backends("cupy",
-                  reason="CuPy has not implemented the `device` param")
-@skip_xp_backends("jax.numpy",
-                  reason="JAX has not implemented the `device` param")
 class TestRFFTFreq:
 
     def test_definition(self, xp):
@@ -552,7 +538,7 @@ class TestRFFTFreq:
         x2 = xp.asarray([0, 1, 2, 3, 4, 5], dtype=xp.float64)
 
         # default dtype varies across backends
-        
+
         y = 9 * fft.rfftfreq(9, xp=xp)
         xp_assert_close(y, x, check_dtype=False, check_namespace=True)
 
@@ -565,10 +551,8 @@ class TestRFFTFreq:
         y = 10 * xp.pi * fft.rfftfreq(10, xp.pi, xp=xp)
         xp_assert_close(y, x2, check_dtype=False)
 
-    def test_device(self, xp):
-        xp_test = array_namespace(xp.empty(0))
-        devices = get_xp_devices(xp)
+    def test_device(self, xp, devices):
         for d in devices:
             y = fft.rfftfreq(9, xp=xp, device=d)
-            x = xp_test.empty(0, device=d)
+            x = xp.empty(0, device=d)
             assert xp_device(y) == xp_device(x)

scipy/fft/tests/test_real_transforms.py

@@ -6,10 +6,8 @@ import math
 from scipy.fft import dct, idct, dctn, idctn, dst, idst, dstn, idstn
 import scipy.fft as fft
 from scipy import fftpack
-from scipy.conftest import array_api_compatible
 from scipy._lib._array_api import xp_copy, xp_assert_close
 
-pytestmark = [array_api_compatible, pytest.mark.usefixtures("skip_xp_backends")]
 skip_xp_backends = pytest.mark.skip_xp_backends
 
 SQRT_2 = math.sqrt(2)
@@ -52,7 +50,7 @@ def test_identity_1d(forward, backward, type, n, axis, norm, orthogonalize, xp):
 @pytest.mark.parametrize("norm", [None, 'backward', 'ortho', 'forward'])
 @pytest.mark.parametrize("overwrite_x", [True, False])
 def test_identity_1d_overwrite(forward, backward, type, dtype, axis, norm,
-                               overwrite_x):
+                               overwrite_x, xp):
     # Test the identity f^-1(f(x)) == x
     x = np.random.rand(7, 8).astype(dtype)
     x_orig = x.copy()
@@ -130,7 +128,7 @@ def test_identity_nd(forward, backward, type, shape, axes, norm,
 @pytest.mark.parametrize("norm", [None, 'backward', 'ortho', 'forward'])
 @pytest.mark.parametrize("overwrite_x", [False, True])
 def test_identity_nd_overwrite(forward, backward, type, shape, axes, dtype,
-                               norm, overwrite_x):
+                               norm, overwrite_x, xp):
     # Test the identity f^-1(f(x)) == x
 
     x = np.random.random(shape).astype(dtype)
@@ -193,8 +191,8 @@ def test_orthogonalize_noop(func, type, norm, xp):
 
 
 @skip_xp_backends('jax.numpy',
-                  reason='jax arrays do not support item assignment',
-                  cpu_only=True)
+                  reason='jax arrays do not support item assignment')
+@skip_xp_backends(cpu_only=True)
 @pytest.mark.parametrize("norm", ["backward", "ortho", "forward"])
 def test_orthogonalize_dct1(norm, xp):
     x = xp.asarray(np.random.rand(100))
@@ -212,8 +210,8 @@ def test_orthogonalize_dct1(norm, xp):
 
 
 @skip_xp_backends('jax.numpy',
-                  reason='jax arrays do not support item assignment',
-                  cpu_only=True)
+                  reason='jax arrays do not support item assignment')
+@skip_xp_backends(cpu_only=True)
 @pytest.mark.parametrize("norm", ["backward", "ortho", "forward"])
 @pytest.mark.parametrize("func", [dct, dst])
 def test_orthogonalize_dcst2(func, norm, xp):
@@ -226,8 +224,8 @@ def test_orthogonalize_dcst2(func, norm, xp):
 
 
 @skip_xp_backends('jax.numpy',
-                  reason='jax arrays do not support item assignment',
-                  cpu_only=True)
+                  reason='jax arrays do not support item assignment')
+@skip_xp_backends(cpu_only=True)
 @pytest.mark.parametrize("norm", ["backward", "ortho", "forward"])
 @pytest.mark.parametrize("func", [dct, dst])
 def test_orthogonalize_dcst3(func, norm, xp):

scipy/fftpack/tests/test_basic.py

@@ -350,10 +350,8 @@ class _TestIRFFTBase:
             y2 = rfft(irfft(x))
             assert_equal(y1.dtype, self.rdt)
             assert_equal(y2.dtype, self.rdt)
-            assert_array_almost_equal(y1, x, decimal=self.ndec,
-                                       err_msg="size=%d" % size)
-            assert_array_almost_equal(y2, x, decimal=self.ndec,
-                                       err_msg="size=%d" % size)
+            assert_array_almost_equal(y1, x, decimal=self.ndec, err_msg=f"size={size}")
+            assert_array_almost_equal(y2, x, decimal=self.ndec, err_msg=f"size={size}")
 
     def test_size_accuracy(self):
         # Sanity check for the accuracy for prime and non-prime sized inputs

scipy/fftpack/tests/test_real_transforms.py

@@ -11,8 +11,8 @@ from scipy.fftpack._realtransforms import (
 
 # Matlab reference data
 MDATA = np.load(join(dirname(__file__), 'test.npz'))
-X = [MDATA['x%d' % i] for i in range(8)]
-Y = [MDATA['y%d' % i] for i in range(8)]
+X = [MDATA[f'x{i}'] for i in range(8)]
+Y = [MDATA[f'y{i}'] for i in range(8)]
 
 # FFTW reference data: the data are organized as follows:
 #    * SIZES is an array containing all available sizes
@@ -33,7 +33,7 @@ def fftw_dct_ref(type, size, dt):
         data = FFTWDATA_SINGLE
     else:
         raise ValueError()
-    y = (data['dct_%d_%d' % (type, size)]).astype(dt)
+    y = (data[f'dct_{type}_{size}']).astype(dt)
     return x, y, dt
 
 
@@ -46,7 +46,7 @@ def fftw_dst_ref(type, size, dt):
         data = FFTWDATA_SINGLE
     else:
         raise ValueError()
-    y = (data['dst_%d_%d' % (type, size)]).astype(dt)
+    y = (data[f'dst_{type}_{size}']).astype(dt)
     return x, y, dt
 
 
@@ -208,7 +208,7 @@ class _TestDCTBase:
             # difference is due to fftw using a better algorithm w.r.t error
             # propagation compared to the ones from fftpack.
             assert_array_almost_equal(y / np.max(y), yr / np.max(y), decimal=self.dec,
-                    err_msg="Size %d failed" % i)
+                    err_msg=f"Size {i} failed")
 
     def test_axis(self):
         nt = 2
@@ -381,8 +381,7 @@ class _TestIDCTBase:
             # difference is due to fftw using a better algorithm w.r.t error
             # propagation compared to the ones from fftpack.
             assert_array_almost_equal(x / np.max(x), xr / np.max(x), decimal=self.dec,
-                    err_msg="Size %d failed" % i)
-
+                    err_msg=f"Size {i} failed")
 
 class TestIDCTIDouble(_TestIDCTBase):
     def setup_method(self):
@@ -487,7 +486,7 @@ class _TestDSTBase:
             # difference is due to fftw using a better algorithm w.r.t error
             # propagation compared to the ones from fftpack.
             assert_array_almost_equal(y / np.max(y), yr / np.max(y), decimal=self.dec,
-                    err_msg="Size %d failed" % i)
+                    err_msg=f"Size {i} failed")
 
 
 class _TestDSTIBase(_TestDSTBase):
@@ -621,7 +620,7 @@ class _TestIDSTBase:
             # difference is due to fftw using a better algorithm w.r.t error
             # propagation compared to the ones from fftpack.
             assert_array_almost_equal(x / np.max(x), xr / np.max(x), decimal=self.dec,
-                    err_msg="Size %d failed" % i)
+                    err_msg=f"Size {i} failed")
 
 
 class TestIDSTIDouble(_TestIDSTBase):

scipy/integrate/_bvp.py

@@ -402,7 +402,9 @@ def solve_newton(n, m, h, col_fun, bc, jac, y, p, B, bvp_tol, bc_tol):
     References
     ----------
     .. [1]  U. Ascher, R. Mattheij and R. Russell "Numerical Solution of
-       Boundary Value Problems for Ordinary Differential Equations"
+       Boundary Value Problems for Ordinary Differential Equations",
+       Philidelphia, PA: Society for Industrial and Applied Mathematics,
+       1995.
     """
     # We know that the solution residuals at the middle points of the mesh
     # are connected with collocation residuals  r_middle = 1.5 * col_res / h.
@@ -872,9 +874,13 @@ def solve_bvp(fun, bc, x, y, p=None, S=None, fun_jac=None, bc_jac=None,
            Control and the Maltab PSE", ACM Trans. Math. Softw., Vol. 27,
            Number 3, pp. 299-316, 2001.
     .. [2] L.F. Shampine, P. H. Muir and H. Xu, "A User-Friendly Fortran BVP
-           Solver".
+           Solver", J. Numer. Anal., Ind. Appl. Math. (JNAIAM), Vol. 1, 
+           Number 2, pp. 201-217, 2006.
     .. [3] U. Ascher, R. Mattheij and R. Russell "Numerical Solution of
-           Boundary Value Problems for Ordinary Differential Equations".
+           Boundary Value Problems for Ordinary Differential Equations",
+           Philidelphia, PA: Society for Industrial and Applied Mathematics,
+           1995.
+           :doi:`10.1137/1.9781611971231`
     .. [4] `Cauchy-Riemann equations
             <https://en.wikipedia.org/wiki/Cauchy-Riemann_equations>`_ on
             Wikipedia.

scipy/integrate/_cubature.py

@@ -10,7 +10,7 @@ from scipy._lib._array_api import (
     array_namespace,
     xp_size,
     xp_copy,
-    xp_broadcast_promote
+    xp_promote
 )
 from scipy._lib._util import MapWrapper
 
@@ -323,7 +323,8 @@ def cubature(f, a, b, *, rule="gk21", rtol=1e-8, atol=0, max_subdivisions=10000,
 
     # Convert a and b to arrays and convert each point in points to an array, promoting
     # each to a common floating dtype.
-    a, b, *points = xp_broadcast_promote(a, b, *points, force_floating=True)
+    a, b, *points = xp_promote(a, b, *points, broadcast=True, force_floating=True,
+                               xp=xp)
     result_dtype = a.dtype
 
     if xp_size(a) == 0 or xp_size(b) == 0:

scipy/integrate/_ode.py

@@ -826,7 +826,7 @@ class IntegratorBase:
     # XXX: __str__ method for getting visual state of the integrator
 
 
-def _vode_banded_jac_wrapper(jacfunc, ml, jac_params):
+def _banded_jac_wrapper(jacfunc, ml, jac_params):
     """
     Wrap a banded Jacobian function with a function that pads
     the Jacobian with `ml` rows of zeros.
@@ -1007,7 +1007,7 @@ class vode(IntegratorBase):
             # Banded Jacobian. Wrap the user-provided function with one
             # that pads the Jacobian array with the extra `self.ml` rows
             # required by the f2py-generated wrapper.
-            jac = _vode_banded_jac_wrapper(jac, self.ml, jac_params)
+            jac = _banded_jac_wrapper(jac, self.ml, jac_params)
 
         args = ((f, jac, y0, t0, t1) + tuple(self.call_args) +
                 (f_params, jac_params))
@@ -1351,6 +1351,13 @@ class lsoda(IntegratorBase):
         else:
             self.initialized = True
             self.acquire_new_handle()
+
+        if jac is not None and self.ml is not None and self.ml > 0:
+            # Banded Jacobian. Wrap the user-provided function with one
+            # that pads the Jacobian array with the extra `self.ml` rows
+            # required by the f2py-generated wrapper.
+            jac = _banded_jac_wrapper(jac, self.ml, jac_params)
+
         args = [f, y0, t0, t1] + self.call_args[:-1] + \
                [jac, self.call_args[-1], f_params, 0, jac_params]
 

scipy/integrate/_quad_vec.py

@@ -3,7 +3,6 @@ import copy
 import heapq
 import collections
 import functools
-import warnings
 
 import numpy as np
 
@@ -144,9 +143,9 @@ def quad_vec(f, a, b, epsabs=1e-200, epsrel=1e-8, norm='2', cache_size=100e6,
         Options: 'gk21' (Gauss-Kronrod 21-point rule),
         'gk15' (Gauss-Kronrod 15-point rule),
         'trapezoid' (composite trapezoid rule).
-        Default: 'gk21' for finite intervals and 'gk15' for (semi-)infinite
+        Default: 'gk21' for finite intervals and 'gk15' for (semi-)infinite.
     full_output : bool, optional
-        Return an additional ``info`` dictionary.
+        Return an additional ``info`` object.
     args : tuple, optional
         Extra arguments to pass to function, if any.
 
@@ -158,25 +157,25 @@ def quad_vec(f, a, b, epsabs=1e-200, epsrel=1e-8, norm='2', cache_size=100e6,
         Estimate for the result
     err : float
         Error estimate for the result in the given norm
-    info : dict
+    info : object
         Returned only when ``full_output=True``.
-        Info dictionary. Is an object with the attributes:
-
-            success : bool
-                Whether integration reached target precision.
-            status : int
-                Indicator for convergence, success (0),
-                failure (1), and failure due to rounding error (2).
-            neval : int
-                Number of function evaluations.
-            intervals : ndarray, shape (num_intervals, 2)
-                Start and end points of subdivision intervals.
-            integrals : ndarray, shape (num_intervals, ...)
-                Integral for each interval.
-                Note that at most ``cache_size`` values are recorded,
-                and the array may contains *nan* for missing items.
-            errors : ndarray, shape (num_intervals,)
-                Estimated integration error for each interval.
+        Result object with the attributes:
+
+        success : bool
+            Whether integration reached target precision.
+        status : int
+            Indicator for convergence, success (0),
+            failure (1), and failure due to rounding error (2).
+        neval : int
+            Number of function evaluations.
+        intervals : ndarray, shape (num_intervals, 2)
+            Start and end points of subdivision intervals.
+        integrals : ndarray, shape (num_intervals, ...)
+            Integral for each interval.
+            Note that at most ``cache_size`` values are recorded,
+            and the array may contains *nan* for missing items.
+        errors : ndarray, shape (num_intervals,)
+            Estimated integration error for each interval.
 
     Notes
     -----
@@ -310,17 +309,10 @@ def quad_vec(f, a, b, epsabs=1e-200, epsrel=1e-8, norm='2', cache_size=100e6,
         _quadrature = {None: _quadrature_gk21,
                        'gk21': _quadrature_gk21,
                        'gk15': _quadrature_gk15,
-                       'trapz': _quadrature_trapezoid,  # alias for backcompat
                        'trapezoid': _quadrature_trapezoid}[quadrature]
     except KeyError as e:
         raise ValueError(f"unknown quadrature {quadrature!r}") from e
 
-    if quadrature == "trapz":
-        msg = ("`quadrature='trapz'` is deprecated in favour of "
-               "`quadrature='trapezoid' and will raise an error from SciPy 1.16.0 "
-               "onwards.")
-        warnings.warn(msg, DeprecationWarning, stacklevel=2)
-
     # Initial interval set
     if points is None:
         initial_intervals = [(a, b)]
@@ -347,7 +339,7 @@ def quad_vec(f, a, b, epsabs=1e-200, epsrel=1e-8, norm='2', cache_size=100e6,
         neval += _quadrature.num_eval
 
         if global_integral is None:
-            if isinstance(ig, (float, complex)):
+            if isinstance(ig, float | complex):
                 # Specialize for scalars
                 if norm_func in (_max_norm, np.linalg.norm):
                     norm_func = abs

scipy/integrate/_quadpack_py.py

@@ -211,9 +211,9 @@ def quad(func, a, b, args=(), full_output=0, epsabs=1.49e-8, epsrel=1.49e-8,
     For the 'cos' and 'sin' weighting, additional inputs and outputs are
     available.
 
-    For finite integration limits, the integration is performed using a
-    Clenshaw-Curtis method which uses Chebyshev moments. For repeated
-    calculations, these moments are saved in the output dictionary:
+    For weighted integrals with finite integration limits, the integration
+    is performed using a Clenshaw-Curtis method, which uses Chebyshev moments.
+    For repeated calculations, these moments are saved in the output dictionary:
 
     'momcom'
         The maximum level of Chebyshev moments that have been computed,
@@ -284,7 +284,8 @@ def quad(func, a, b, args=(), full_output=0, epsabs=1.49e-8, epsrel=1.49e-8,
         is an integrator based on globally adaptive interval
         subdivision in connection with extrapolation, which will
         eliminate the effects of integrand singularities of
-        several types.
+        several types. The integration is performed using a 21-point Gauss-Kronrod 
+        quadrature within each subinterval.
     qagie
         handles integration over infinite intervals. The infinite range is
         mapped onto a finite interval and subsequently the same strategy as
@@ -745,7 +746,8 @@ def dblquad(func, a, b, gfun, hfun, args=(), epsabs=1.49e-8, epsrel=1.49e-8):
         is an integrator based on globally adaptive interval
         subdivision in connection with extrapolation, which will
         eliminate the effects of integrand singularities of
-        several types.
+        several types. The integration is is performed using a 21-point Gauss-Kronrod 
+        quadrature within each subinterval.
     qagie
         handles integration over infinite intervals. The infinite range is
         mapped onto a finite interval and subsequently the same strategy as
@@ -877,7 +879,8 @@ def tplquad(func, a, b, gfun, hfun, qfun, rfun, args=(), epsabs=1.49e-8,
         is an integrator based on globally adaptive interval
         subdivision in connection with extrapolation, which will
         eliminate the effects of integrand singularities of
-        several types.
+        several types. The integration is is performed using a 21-point Gauss-Kronrod 
+        quadrature within each subinterval.
     qagie
         handles integration over infinite intervals. The infinite range is
         mapped onto a finite interval and subsequently the same strategy as
@@ -1066,7 +1069,8 @@ def nquad(func, ranges, args=None, opts=None, full_output=False):
         is an integrator based on globally adaptive interval
         subdivision in connection with extrapolation, which will
         eliminate the effects of integrand singularities of
-        several types.
+        several types. The integration is is performed using a 21-point Gauss-Kronrod 
+        quadrature within each subinterval.
     qagie
         handles integration over infinite intervals. The infinite range is
         mapped onto a finite interval and subsequently the same strategy as

scipy/integrate/_quadrature.py

@@ -8,7 +8,7 @@ from collections.abc import Callable
 from scipy.special import roots_legendre
 from scipy.special import gammaln, logsumexp
 from scipy._lib._util import _rng_spawn
-from scipy._lib._array_api import _asarray, array_namespace, xp_broadcast_promote
+from scipy._lib._array_api import _asarray, array_namespace, xp_result_type
 
 
 __all__ = ['fixed_quad', 'romb',
@@ -124,7 +124,7 @@ def trapezoid(y, x=None, dx=1.0, axis=-1):
     # Cannot just use the broadcasted arrays that are returned
     # because trapezoid does not follow normal broadcasting rules
     # cf. https://github.com/scipy/scipy/pull/21524#issuecomment-2354105942
-    result_dtype = xp_broadcast_promote(y, force_floating=True, xp=xp)[0].dtype
+    result_dtype = xp_result_type(y, force_floating=True, xp=xp)
     nd = y.ndim
     slice1 = [slice(None)]*nd
     slice2 = [slice(None)]*nd
@@ -894,7 +894,7 @@ def romb(y, dx=1.0, axis=-1, show=False):
                 width = show[1]
             except (TypeError, IndexError):
                 width = 8
-            formstr = "%%%d.%df" % (width, precis)
+            formstr = f"%{width}.{precis}f"
 
             title = "Richardson Extrapolation Table for Romberg Integration"
             print(title, "=" * len(title), sep="\n", end="\n")

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)