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

scipy/fft/tests/test_basic.py

@@ -7,12 +7,10 @@ from numpy.random import random
 from numpy.testing import assert_array_almost_equal, assert_allclose
 from pytest import raises as assert_raises
 import scipy.fft as fft
-from scipy.conftest import array_api_compatible
 from scipy._lib._array_api import (
-    array_namespace, xp_size, xp_assert_close, xp_assert_equal
+    is_numpy, xp_size, xp_assert_close, xp_assert_equal
 )
 
-pytestmark = [array_api_compatible, pytest.mark.usefixtures("skip_xp_backends")]
 skip_xp_backends = pytest.mark.skip_xp_backends
 
 
@@ -230,10 +228,10 @@ class TestFFT:
         dtype = get_expected_input_dtype(op, xp)
         x = xp.asarray(random((30, 20, 10)), dtype=dtype)
         axes = [(0, 1, 2), (0, 2, 1), (1, 0, 2), (1, 2, 0), (2, 0, 1), (2, 1, 0)]
-        xp_test = array_namespace(x)
+
         for a in axes:
-            op_tr = op(xp_test.permute_dims(x, axes=a))
-            tr_op = xp_test.permute_dims(op(x, axes=a), axes=a)
+            op_tr = op(xp.permute_dims(x, axes=a))
+            tr_op = xp.permute_dims(op(x, axes=a), axes=a)
             xp_assert_close(op_tr, tr_op)
 
     @pytest.mark.parametrize("op", [fft.fftn, fft.ifftn, fft.rfftn, fft.irfftn])
@@ -250,15 +248,15 @@ class TestFFT:
         dtype = get_expected_input_dtype(op, xp)
         x = xp.asarray(random((16, 8, 4)), dtype=dtype)
         axes = [(0, 1, 2), (0, 2, 1), (1, 2, 0)]
-        xp_test = array_namespace(x)
+
         for a in axes:
             # different shape on the first two axes
             shape = tuple([2*x.shape[ax] if ax in a[:2] else x.shape[ax]
                            for ax in range(x.ndim)])
             # transform only the first two axes
-            op_tr = op(xp_test.permute_dims(x, axes=a),
+            op_tr = op(xp.permute_dims(x, axes=a),
                        s=shape[:2], axes=(0, 1))
-            tr_op = xp_test.permute_dims(op(x, s=shape[:2], axes=a[:2]),
+            tr_op = xp.permute_dims(op(x, s=shape[:2], axes=a[:2]),
                                          axes=a)
             xp_assert_close(op_tr, tr_op)
 
@@ -270,21 +268,21 @@ class TestFFT:
         dtype = get_expected_input_dtype(op, xp)
         x = xp.asarray(random((16, 8, 4)), dtype=dtype)
         axes = [(0, 1, 2), (0, 2, 1), (1, 2, 0)]
-        xp_test = array_namespace(x)
+
         for a in axes:
             # different shape on the first two axes
             shape = tuple([2*x.shape[ax] if ax in a[:2] else x.shape[ax]
                            for ax in range(x.ndim)])
             # transform only the first two axes
-            op_tr = op(xp_test.permute_dims(x, axes=a), s=shape[:2], axes=(0, 1))
-            tr_op = xp_test.permute_dims(op(x, s=shape[:2], axes=a[:2]), axes=a)
+            op_tr = op(xp.permute_dims(x, axes=a), s=shape[:2], axes=(0, 1))
+            tr_op = xp.permute_dims(op(x, s=shape[:2], axes=a[:2]), axes=a)
             xp_assert_close(op_tr, tr_op)
 
     def test_all_1d_norm_preserving(self, xp):
         # verify that round-trip transforms are norm-preserving
         x = xp.asarray(random(30), dtype=xp.float64)
-        xp_test = array_namespace(x)
-        x_norm = xp_test.linalg.vector_norm(x)
+
+        x_norm = xp.linalg.vector_norm(x)
         n = xp_size(x) * 2
         func_pairs = [(fft.rfft, fft.irfft),
                       # hfft: order so the first function takes x.size samples
@@ -296,16 +294,16 @@ class TestFFT:
         for forw, back in func_pairs:
             if forw == fft.fft:
                 x = xp.asarray(x, dtype=xp.complex128)
-                x_norm = xp_test.linalg.vector_norm(x)
+                x_norm = xp.linalg.vector_norm(x)
             for n in [xp_size(x), 2*xp_size(x)]:
                 for norm in ['backward', 'ortho', 'forward']:
                     tmp = forw(x, n=n, norm=norm)
                     tmp = back(tmp, n=n, norm=norm)
-                    xp_assert_close(xp_test.linalg.vector_norm(tmp), x_norm)
+                    xp_assert_close(xp.linalg.vector_norm(tmp), x_norm)
 
     @skip_xp_backends(np_only=True)
     @pytest.mark.parametrize("dtype", [np.float16, np.longdouble])
-    def test_dtypes_nonstandard(self, dtype):
+    def test_dtypes_nonstandard(self, dtype, xp):
         x = random(30).astype(dtype)
         out_dtypes = {np.float16: np.complex64, np.longdouble: np.clongdouble}
         x_complex = x.astype(out_dtypes[dtype])
@@ -368,7 +366,7 @@ class TestFFT:
         "fft",
         [fft.fft, fft.fft2, fft.fftn,
          fft.ifft, fft.ifft2, fft.ifftn])
-def test_fft_with_order(dtype, order, fft):
+def test_fft_with_order(dtype, order, fft, xp):
     # Check that FFT/IFFT produces identical results for C, Fortran and
     # non contiguous arrays
     rng = np.random.RandomState(42)
@@ -450,7 +448,7 @@ class TestFFTThreadSafe:
 
 @skip_xp_backends(np_only=True)
 @pytest.mark.parametrize("func", [fft.fft, fft.ifft, fft.rfft, fft.irfft])
-def test_multiprocess(func):
+def test_multiprocess(func, xp):
     # Test that fft still works after fork (gh-10422)
 
     with multiprocessing.Pool(2) as p:
@@ -483,13 +481,17 @@ def test_non_standard_params(func, xp):
     else:
         dtype = xp.complex128
 
-    if xp.__name__ != 'numpy':
-        x = xp.asarray([1, 2, 3], dtype=dtype)
-        # func(x) should not raise an exception
-        func(x)
+    x = xp.asarray([1, 2, 3], dtype=dtype)
+    # func(x) should not raise an exception
+    func(x)
+
+    if is_numpy(xp):
+        func(x, workers=2)
+    else:
         assert_raises(ValueError, func, x, workers=2)
-        # `plan` param is not tested since SciPy does not use it currently
-        # but should be tested if it comes into use
+
+    # `plan` param is not tested since SciPy does not use it currently
+    # but should be tested if it comes into use
 
 
 @pytest.mark.parametrize("dtype", ['float32', 'float64'])

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]