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

scipy/datasets/_download_all.py

@@ -31,6 +31,18 @@ def download_all(path=None):
     path : str, optional
         Directory path to download all the dataset files.
         If None, default to the system cache_dir detected by pooch.
+    
+    Examples
+    --------
+    Download the datasets to the default cache location:
+
+    >>> from scipy import datasets
+    >>> datasets.download_all()
+
+    Download the datasets to the current directory:
+
+    >>> datasets.download_all(".")
+    
     """
     if pooch is None:
         raise ImportError("Missing optional dependency 'pooch' required "
@@ -38,10 +50,12 @@ def download_all(path=None):
                           "conda to install 'pooch'.")
     if path is None:
         path = pooch.os_cache('scipy-data')
+    # https://github.com/scipy/scipy/issues/21879
+    downloader = pooch.HTTPDownloader(headers={"User-Agent": "SciPy"})
     for dataset_name, dataset_hash in _registry.registry.items():
         pooch.retrieve(url=_registry.registry_urls[dataset_name],
                        known_hash=dataset_hash,
-                       fname=dataset_name, path=path)
+                       fname=dataset_name, path=path, downloader=downloader)
 
 
 def main():

scipy/datasets/_fetchers.py

@@ -1,3 +1,5 @@
+import sys
+
 from numpy import array, frombuffer, load
 from ._registry import registry, registry_urls
 
@@ -27,8 +29,12 @@ def fetch_data(dataset_name, data_fetcher=data_fetcher):
         raise ImportError("Missing optional dependency 'pooch' required "
                           "for scipy.datasets module. Please use pip or "
                           "conda to install 'pooch'.")
+    # https://github.com/scipy/scipy/issues/21879
+    downloader = pooch.HTTPDownloader(
+        headers={"User-Agent": f"SciPy {sys.modules['scipy'].__version__}"}
+    )
     # The "fetch" method returns the full path to the downloaded data file.
-    return data_fetcher.fetch(dataset_name)
+    return data_fetcher.fetch(dataset_name, downloader=downloader)
 
 
 def ascent():

scipy/datasets/_utils.py

@@ -29,7 +29,7 @@ def _clear_cache(datasets, cache_dir=None, method_map=None):
         print(f"Cleaning the cache directory {cache_dir}!")
         shutil.rmtree(cache_dir)
     else:
-        if not isinstance(datasets, (list, tuple)):
+        if not isinstance(datasets, list | tuple):
             # single dataset method passed should be converted to list
             datasets = [datasets, ]
         for dataset in datasets:

scipy/differentiate/_differentiate.py

@@ -3,7 +3,8 @@ import warnings
 import numpy as np
 import scipy._lib._elementwise_iterative_method as eim
 from scipy._lib._util import _RichResult
-from scipy._lib._array_api import array_namespace, xp_sign, xp_copy, xp_take_along_axis
+from scipy._lib._array_api import array_namespace, xp_copy, xp_promote
+import scipy._lib.array_api_extra as xpx
 
 _EERRORINCREASE = -1  # used in derivative
 
@@ -400,11 +401,11 @@ def derivative(f, x, *, args=(), tolerances=None, maxiter=10,
     # that `hdir` can be broadcasted to the final shape. Same with `h0`.
     hdir = xp.broadcast_to(hdir, shape)
     hdir = xp.reshape(hdir, (-1,))
-    hdir = xp.astype(xp_sign(hdir), dtype)
+    hdir = xp.astype(xp.sign(hdir), dtype)
     h0 = xp.broadcast_to(h0, shape)
     h0 = xp.reshape(h0, (-1,))
     h0 = xp.astype(h0, dtype)
-    h0[h0 <= 0] = xp.asarray(xp.nan, dtype=dtype)
+    h0 = xpx.at(h0)[h0 <= 0].set(xp.nan)
 
     status = xp.full_like(x, eim._EINPROGRESS, dtype=xp.int32)  # in progress
     nit, nfev = 0, 1  # one function evaluations performed above
@@ -477,9 +478,9 @@ def derivative(f, x, *, args=(), tolerances=None, maxiter=10,
         n_new = 2*n if work.nit == 0 else 2  # number of new abscissae
         x_eval = xp.zeros((work.hdir.shape[0], n_new), dtype=work.dtype)
         il, ic, ir = work.il, work.ic, work.ir
-        x_eval[ir] = work.x[ir][:, xp.newaxis] + hr[ir]
-        x_eval[ic] = work.x[ic][:, xp.newaxis] + hc[ic]
-        x_eval[il] = work.x[il][:, xp.newaxis] - hr[il]
+        x_eval = xpx.at(x_eval)[ir].set(work.x[ir][:, xp.newaxis] + hr[ir])
+        x_eval = xpx.at(x_eval)[ic].set(work.x[ic][:, xp.newaxis] + hc[ic])
+        x_eval = xpx.at(x_eval)[il].set(work.x[il][:, xp.newaxis] - hr[il])
         return x_eval
 
     def post_func_eval(x, f, work):
@@ -529,14 +530,14 @@ def derivative(f, x, *, args=(), tolerances=None, maxiter=10,
             fo = xp.concat((work_fo[:, 0:1], work_fo[:, -2*n:]), axis=-1)
 
         work.fs = xp.zeros((ic.shape[0], work.fs.shape[-1] + 2*n_new), dtype=work.dtype)
-        work.fs[ic] = work_fc
-        work.fs[io] = work_fo
+        work.fs = xpx.at(work.fs)[ic].set(work_fc)
+        work.fs = xpx.at(work.fs)[io].set(work_fo)
 
         wc, wo = _derivative_weights(work, n, xp)
         work.df_last = xp.asarray(work.df, copy=True)
-        work.df[ic] = fc @ wc / work.h[ic]
-        work.df[io] = fo @ wo / work.h[io]
-        work.df[il] *= -1
+        work.df = xpx.at(work.df)[ic].set(fc @ wc / work.h[ic])
+        work.df = xpx.at(work.df)[io].set(fo @ wo / work.h[io])
+        work.df = xpx.at(work.df)[il].multiply(-1)
 
         work.h /= work.fac
         work.error_last = work.error
@@ -554,13 +555,14 @@ def derivative(f, x, *, args=(), tolerances=None, maxiter=10,
         stop = xp.astype(xp.zeros_like(work.df), xp.bool)
 
         i = work.error < work.atol + work.rtol*abs(work.df)
-        work.status[i] = eim._ECONVERGED
-        stop[i] = True
+        work.status = xpx.at(work.status)[i].set(eim._ECONVERGED)
+        stop = xpx.at(stop)[i].set(True)
 
         if work.nit > 0:
             i = ~((xp.isfinite(work.x) & xp.isfinite(work.df)) | stop)
-            work.df[i], work.status[i] = xp.nan, eim._EVALUEERR
-            stop[i] = True
+            work.df = xpx.at(work.df)[i].set(xp.nan)
+            work.status = xpx.at(work.status)[i].set(eim._EVALUEERR)
+            stop = xpx.at(stop)[i].set(True)
 
         # With infinite precision, there is a step size below which
         # all smaller step sizes will reduce the error. But in floating point
@@ -570,8 +572,8 @@ def derivative(f, x, *, args=(), tolerances=None, maxiter=10,
         # detecting a step size that minimizes the total error, but this
         # heuristic seems simple and effective.
         i = (work.error > work.error_last*10) & ~stop
-        work.status[i] = _EERRORINCREASE
-        stop[i] = True
+        work.status = xpx.at(work.status)[i].set(_EERRORINCREASE)
+        stop = xpx.at(stop)[i].set(True)
 
         return stop
 
@@ -906,9 +908,7 @@ def jacobian(f, x, *, tolerances=None, maxiter=10, order=8, initial_step=0.5,
 
     """
     xp = array_namespace(x)
-    x = xp.asarray(x)
-    int_dtype = xp.isdtype(x.dtype, 'integral')
-    x0 = xp.asarray(x, dtype=xp.asarray(1.0).dtype) if int_dtype else x
+    x0 = xp_promote(x, force_floating=True, xp=xp)
 
     if x0.ndim < 1:
         message = "Argument `x` must be at least 1-D."
@@ -925,7 +925,7 @@ def jacobian(f, x, *, tolerances=None, maxiter=10, order=8, initial_step=0.5,
         if x.ndim != x0.ndim:
             xph = xp.expand_dims(xph, axis=-1)
         xph = xp_copy(xp.broadcast_to(xph, new_shape), xp=xp)
-        xph[i, i] = x
+        xph = xpx.at(xph)[i, i].set(x)
         return f(xph)
 
     res = derivative(wrapped, x, tolerances=tolerances,
@@ -1097,9 +1097,9 @@ def hessian(f, x, *, tolerances=None, maxiter=10,
     rtol = tolerances.get('rtol', None)
 
     xp = array_namespace(x)
-    x = xp.asarray(x)
-    dtype = x.dtype if not xp.isdtype(x.dtype, 'integral') else xp.asarray(1.).dtype
-    finfo = xp.finfo(dtype)
+    x0 = xp_promote(x, force_floating=True, xp=xp)
+
+    finfo = xp.finfo(x0.dtype)
     rtol = finfo.eps**0.5 if rtol is None else rtol  # keep same as `derivative`
 
     # tighten the inner tolerance to make the inner error negligible
@@ -1121,7 +1121,7 @@ def hessian(f, x, *, tolerances=None, maxiter=10,
 
     nfev = xp.cumulative_sum(xp.stack(nfev), axis=0)
     res_nit = xp.astype(res.nit[xp.newaxis, ...], xp.int64)  # appease torch
-    res.nfev = xp_take_along_axis(nfev, res_nit, axis=0)[0]
+    res.nfev = xp.take_along_axis(nfev, res_nit, axis=0)[0]
     res.ddf = res.df
     del res.df  # this is renamed to ddf
     del res.nit  # this is only the outer-jacobian nit

scipy/differentiate/tests/test_differentiate.py

@@ -3,24 +3,20 @@ import pytest
 
 import numpy as np
 
-from scipy.conftest import array_api_compatible
 import scipy._lib._elementwise_iterative_method as eim
+import scipy._lib.array_api_extra as xpx
 from scipy._lib._array_api_no_0d import xp_assert_close, xp_assert_equal, xp_assert_less
-from scipy._lib._array_api import is_numpy, is_torch, array_namespace
+from scipy._lib._array_api import is_numpy, is_torch
 
 from scipy import stats, optimize, special
 from scipy.differentiate import derivative, jacobian, hessian
 from scipy.differentiate._differentiate import _EERRORINCREASE
 
-
-pytestmark = [array_api_compatible, pytest.mark.usefixtures("skip_xp_backends")]
-
 array_api_strict_skip_reason = 'Array API does not support fancy indexing assignment.'
-jax_skip_reason = 'JAX arrays do not support item assignment.'
 
 
 @pytest.mark.skip_xp_backends('array_api_strict', reason=array_api_strict_skip_reason)
-@pytest.mark.skip_xp_backends('jax.numpy',reason=jax_skip_reason)
+@pytest.mark.skip_xp_backends('dask.array', reason='boolean indexing assignment')
 class TestDerivative:
 
     def f(self, x):
@@ -40,7 +36,7 @@ class TestDerivative:
 
     @pytest.mark.skip_xp_backends(np_only=True)
     @pytest.mark.parametrize('case', stats._distr_params.distcont)
-    def test_accuracy(self, case):
+    def test_accuracy(self, case, xp):
         distname, params = case
         dist = getattr(stats, distname)(*params)
         x = dist.median() + 0.1
@@ -215,12 +211,13 @@ class TestDerivative:
         # test that `step_direction` works as expected
         def f(x):
             y = xp.exp(x)
-            y[(x < 0) + (x > 2)] = xp.nan
+            y = xpx.at(y)[(x < 0) + (x > 2)].set(xp.nan)
             return y
 
         x = xp.linspace(0, 2, 10)
         step_direction = xp.zeros_like(x)
-        step_direction[x < 0.6], step_direction[x > 1.4] = 1, -1
+        step_direction = xpx.at(step_direction)[x < 0.6].set(1)
+        step_direction = xpx.at(step_direction)[x > 1.4].set(-1)
         res = derivative(f, x, step_direction=step_direction)
         xp_assert_close(res.df, xp.exp(x))
         assert xp.all(res.success)
@@ -380,8 +377,7 @@ class TestDerivative:
         # Test that integers are not passed to `f`
         # (otherwise this would overflow)
         def f(x):
-            xp_test = array_namespace(x)  # needs `isdtype`
-            assert xp_test.isdtype(x.dtype, 'real floating')
+            assert xp.isdtype(x.dtype, 'real floating')
             return x ** 99 - 1
 
         if not is_torch(xp):  # torch defaults to float32
@@ -435,7 +431,7 @@ class TestDerivative:
         (lambda x: (x - 1) ** 3, 1),
         (lambda x: np.where(x > 1, (x - 1) ** 5, (x - 1) ** 3), 1)
     ))
-    def test_saddle_gh18811(self, case):
+    def test_saddle_gh18811(self, case, xp):
         # With default settings, `derivative` will not always converge when
         # the true derivative is exactly zero. This tests that specifying a
         # (tight) `atol` alleviates the problem. See discussion in gh-18811.
@@ -476,7 +472,7 @@ class JacobianHessianTest:
 
 
 @pytest.mark.skip_xp_backends('array_api_strict', reason=array_api_strict_skip_reason)
-@pytest.mark.skip_xp_backends('jax.numpy',reason=jax_skip_reason)
+@pytest.mark.skip_xp_backends('dask.array', reason='boolean indexing assignment')
 class TestJacobian(JacobianHessianTest):
     jh_func = jacobian
 
@@ -586,9 +582,10 @@ class TestJacobian(JacobianHessianTest):
             return xp.sin(2*x) * y**2
 
         res = jacobian(df1, z, initial_step=10)
-        if is_numpy(xp):
-            assert len(np.unique(res.nit)) == 4
-            assert len(np.unique(res.nfev)) == 4
+        # FIXME https://github.com/scipy/scipy/pull/22320#discussion_r1914898175
+        if not is_torch(xp):
+            assert xpx.nunique(res.nit) == 4
+            assert xpx.nunique(res.nfev) == 4
 
         res00 = jacobian(lambda x: df1_0xy(x, z[1]), z[0:1], initial_step=10)
         res01 = jacobian(lambda y: df1_0xy(z[0], y), z[1:2], initial_step=10)
@@ -598,7 +595,10 @@ class TestJacobian(JacobianHessianTest):
         for attr in ['success', 'status', 'df', 'nit', 'nfev']:
             ref_attr = xp.asarray([[getattr(res00, attr), getattr(res01, attr)],
                                    [getattr(res10, attr), getattr(res11, attr)]])
-            ref[attr] = xp.squeeze(ref_attr)
+            ref[attr] = xp.squeeze(
+                ref_attr,
+                axis=tuple(ax for ax, size in enumerate(ref_attr.shape) if size == 1)
+            )
             rtol = 1.5e-5 if res[attr].dtype == xp.float32 else 1.5e-14
             xp_assert_close(res[attr], ref[attr], rtol=rtol)
 
@@ -610,10 +610,10 @@ class TestJacobian(JacobianHessianTest):
         eps = 1e-7  # torch needs wiggle room?
 
         def f(x):
-            x[0, x[0] < b[0]] = xp.nan
-            x[0, x[0] > b[0] + 0.25] = xp.nan
-            x[1, x[1] > b[1]] = xp.nan
-            x[1, x[1] < b[1] - 0.1-eps] = xp.nan
+            x = xpx.at(x)[0, x[0] < b[0]].set(xp.nan)
+            x = xpx.at(x)[0, x[0] > b[0] + 0.25].set(xp.nan)
+            x = xpx.at(x)[1, x[1] > b[1]].set(xp.nan)
+            x = xpx.at(x)[1, x[1] < b[1] - 0.1-eps].set(xp.nan)
             return TestJacobian.f5(x, xp)
 
         dir = [1, -1, 0]
@@ -627,7 +627,7 @@ class TestJacobian(JacobianHessianTest):
 
 
 @pytest.mark.skip_xp_backends('array_api_strict', reason=array_api_strict_skip_reason)
-@pytest.mark.skip_xp_backends('jax.numpy',reason=jax_skip_reason)
+@pytest.mark.skip_xp_backends('dask.array', reason='boolean indexing assignment')
 class TestHessian(JacobianHessianTest):
     jh_func = hessian
 
@@ -663,10 +663,9 @@ class TestHessian(JacobianHessianTest):
 
     def test_nfev(self, xp):
         z = xp.asarray([0.5, 0.25])
-        xp_test = array_namespace(z)
 
         def f1(z):
-            x, y = xp_test.broadcast_arrays(*z)
+            x, y = xp.broadcast_arrays(*z)
             f1.nfev = f1.nfev + (math.prod(x.shape[2:]) if x.ndim > 2 else 1)
             return xp.sin(x) * y ** 3
         f1.nfev = 0

scipy/fft/_basic.py

@@ -1166,6 +1166,17 @@ def rfft2(x, s=None, axes=(-2, -1), norm=None, overwrite_x=False, workers=None,
     This is really just `rfftn` with different default behavior.
     For more details see `rfftn`.
 
+    Examples
+    --------
+    >>> import scipy.fft
+    >>> import numpy as np
+    >>> x = np.broadcast_to([1, 0, -1, 0], (4, 4))
+    >>> scipy.fft.rfft2(x)
+    array([[0.+0.j, 8.+0.j, 0.+0.j],
+           [0.+0.j, 0.+0.j, 0.+0.j],
+           [0.+0.j, 0.+0.j, 0.+0.j],
+           [0.+0.j, 0.+0.j, 0.+0.j]])
+
     """
     return (Dispatchable(x, np.ndarray),)
 
@@ -1484,6 +1495,15 @@ def hfft2(x, s=None, axes=(-2, -1), norm=None, overwrite_x=False, workers=None,
     This is really just `hfftn` with different default behavior.
     For more details see `hfftn`.
 
+    Examples
+    --------
+    >>> import scipy.fft
+    >>> import numpy as np
+    >>> x = np.array([[1+0j, 2+0j], [2+0j, 1+0j]])  # Hermitian-symmetric input
+    >>> scipy.fft.hfft2(x, s=(2, 2))
+    array([[ 6.,  0.],
+           [ 0., -2.]])
+
     """
     return (Dispatchable(x, np.ndarray),)
 

scipy/fft/_helper.py

@@ -7,6 +7,9 @@ import numpy as np
 from scipy._lib._array_api import array_namespace
 
 
+_init_nd_shape_and_axes = _helper._init_nd_shape_and_axes
+
+
 def next_fast_len(target, real=False):
     """Find the next fast size of input data to ``fft``, for zero-padding, etc.
 
@@ -140,40 +143,6 @@ prev_fast_len.__wrapped__ = _helper.prev_good_size
 prev_fast_len.__signature__ = _sig_prev_fast_len
 
 
-def _init_nd_shape_and_axes(x, shape, axes):
-    """Handle shape and axes arguments for N-D transforms.
-
-    Returns the shape and axes in a standard form, taking into account negative
-    values and checking for various potential errors.
-
-    Parameters
-    ----------
-    x : array_like
-        The input array.
-    shape : int or array_like of ints or None
-        The shape of the result. If both `shape` and `axes` (see below) are
-        None, `shape` is ``x.shape``; if `shape` is None but `axes` is
-        not None, then `shape` is ``numpy.take(x.shape, axes, axis=0)``.
-        If `shape` is -1, the size of the corresponding dimension of `x` is
-        used.
-    axes : int or array_like of ints or None
-        Axes along which the calculation is computed.
-        The default is over all axes.
-        Negative indices are automatically converted to their positive
-        counterparts.
-
-    Returns
-    -------
-    shape : tuple
-        The shape of the result as a tuple of integers.
-    axes : list
-        Axes along which the calculation is computed, as a list of integers.
-
-    """
-    x = np.asarray(x)
-    return _helper._init_nd_shape_and_axes(x, shape, axes)
-
-
 def fftfreq(n, d=1.0, *, xp=None, device=None):
     """Return the Discrete Fourier Transform sample frequencies.
 

scipy/fft/_pocketfft/helper.py

@@ -44,7 +44,35 @@ def _iterable_of_int(x, name=None):
 
 
 def _init_nd_shape_and_axes(x, shape, axes):
-    """Handles shape and axes arguments for nd transforms"""
+    """
+    Handle shape and axes arguments for N-D transforms.
+
+    Returns the shape and axes in a standard form, taking into account negative
+    values and checking for various potential errors.
+
+    Parameters
+    ----------
+    x : ndarray
+        The input array.
+    shape : int or array_like of ints or None
+        The shape of the result. If both `shape` and `axes` (see below) are
+        None, `shape` is ``x.shape``; if `shape` is None but `axes` is
+        not None, then `shape` is ``numpy.take(x.shape, axes, axis=0)``.
+        If `shape` is -1, the size of the corresponding dimension of `x` is
+        used.
+    axes : int or array_like of ints or None
+        Axes along which the calculation is computed.
+        The default is over all axes.
+        Negative indices are automatically converted to their positive
+        counterparts.
+
+    Returns
+    -------
+    shape : tuple
+        The shape of the result as a tuple of integers.
+    axes : list
+        Axes along which the calculation is computed, as a list of integers.
+    """
     noshape = shape is None
     noaxes = axes is None
 

scipy/fft/_pocketfft/tests/test_basic.py

@@ -406,10 +406,8 @@ class _TestIRFFTBase:
             y2 = rfft(irfft(x, n=(size*2-1)))
             assert_equal(y1.dtype, self.rdt)
             assert_equal(y2.dtype, self.cdt)
-            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/fft/_pocketfft/tests/test_real_transforms.py

@@ -30,8 +30,8 @@ def is_longdouble_binary_compatible():
 def reference_data():
     # Matlab reference data
     MDATA = np.load(join(fftpack_test_dir, 'test.npz'))
-    X = [MDATA['x%d' % i] for i in range(MDATA_COUNT)]
-    Y = [MDATA['y%d' % i] for i in range(MDATA_COUNT)]
+    X = [MDATA[f'x{i}'] for i in range(MDATA_COUNT)]
+    Y = [MDATA[f'y{i}'] for i in range(MDATA_COUNT)]
 
     # FFTW reference data: the data are organized as follows:
     #    * SIZES is an array containing all available sizes
@@ -100,7 +100,7 @@ def fftw_dct_ref(type, size, dt, reference_data):
         data = reference_data['FFTWDATA_LONGDOUBLE']
     else:
         raise ValueError()
-    y = (data['dct_%d_%d' % (type, size)]).astype(dt)
+    y = (data[f'dct_{type}_{size}']).astype(dt)
     return x, y, dt
 
 
@@ -115,7 +115,7 @@ def fftw_dst_ref(type, size, dt, reference_data):
         data = reference_data['FFTWDATA_LONGDOUBLE']
     else:
         raise ValueError()
-    y = (data['dst_%d_%d' % (type, size)]).astype(dt)
+    y = (data[f'dst_{type}_{size}']).astype(dt)
     return x, y, dt
 
 

scipy/fft/_realtransforms.py

@@ -621,6 +621,19 @@ def dst(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False, workers=None,
     The (unnormalized) DST-IV is its own inverse, up to a factor :math:`2N`. The
     orthonormalized DST-IV is exactly its own inverse.
 
+    Examples
+    --------
+    Compute the DST of a simple 1D array:
+
+    >>> import numpy as np
+    >>> from scipy.fft import dst
+    >>> x = np.array([1, -1, 1, -1])
+    >>> dst(x, type=2)
+    array([0., 0., 0., 8.])
+
+    This computes the Discrete Sine Transform (DST) of type-II for the input array. 
+    The output contains the transformed values corresponding to the given input sequence
+
     References
     ----------
     .. [1] Wikipedia, "Discrete sine transform",

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'])