scipy 1.15.3__cp311-cp311-win_amd64.whl → 1.16.0__cp311-cp311-win_amd64.whl

scipy/signal/tests/_scipy_spectral_test_shim.py

@@ -24,11 +24,10 @@ import numpy as np
 from numpy.testing import assert_allclose
 
 from scipy.signal import ShortTimeFFT
-from scipy.signal import csd, get_window, stft, istft
+from scipy.signal import get_window, stft, istft
 from scipy.signal._arraytools import const_ext, even_ext, odd_ext, zero_ext
 from scipy.signal._short_time_fft import FFT_MODE_TYPE
-from scipy.signal._spectral_py import _spectral_helper, _triage_segments, \
-    _median_bias
+from scipy.signal._spectral_py import _triage_segments
 
 
 def _stft_wrapper(x, fs=1.0, window='hann', nperseg=256, noverlap=None,
@@ -226,156 +225,6 @@ def _istft_wrapper(Zxx, fs=1.0, window='hann', nperseg=None, noverlap=None,
     return t, x, (ST.lower_border_end[0], k_hi)
 
 
-def _csd_wrapper(x, y, fs=1.0, window='hann', nperseg=None, noverlap=None,
-                 nfft=None, detrend='constant', return_onesided=True,
-                 scaling='density', axis=-1, average='mean'):
-    """Wrapper for the `csd()` function based on `ShortTimeFFT` for
-        unit testing.
-    """
-    freqs, _, Pxy = _csd_test_shim(x, y, fs, window, nperseg, noverlap, nfft,
-                                   detrend, return_onesided, scaling, axis)
-
-    # The following code is taken from csd():
-    if len(Pxy.shape) >= 2 and Pxy.size > 0:
-        if Pxy.shape[-1] > 1:
-            if average == 'median':
-                # np.median must be passed real arrays for the desired result
-                bias = _median_bias(Pxy.shape[-1])
-                if np.iscomplexobj(Pxy):
-                    Pxy = (np.median(np.real(Pxy), axis=-1)
-                           + 1j * np.median(np.imag(Pxy), axis=-1))
-                else:
-                    Pxy = np.median(Pxy, axis=-1)
-                Pxy /= bias
-            elif average == 'mean':
-                Pxy = Pxy.mean(axis=-1)
-            else:
-                raise ValueError(f'average must be "median" or "mean", got {average}')
-        else:
-            Pxy = np.reshape(Pxy, Pxy.shape[:-1])
-
-    return freqs, Pxy
-
-
-def _csd_test_shim(x, y, fs=1.0, window='hann', nperseg=None, noverlap=None,
-                   nfft=None, detrend='constant', return_onesided=True,
-                   scaling='density', axis=-1):
-    """Compare output of  _spectral_helper() and ShortTimeFFT, more
-    precisely _spect_helper_csd() for used in csd_wrapper().
-
-   The motivation of this function is to test if the ShortTimeFFT-based
-   wrapper `_spect_helper_csd()` returns the same values as `_spectral_helper`.
-   This function should only be usd by csd() in (unit) testing.
-   """
-    freqs, t, Pxy = _spectral_helper(x, y, fs, window, nperseg, noverlap, nfft,
-                                     detrend, return_onesided, scaling, axis,
-                                     mode='psd')
-    freqs1, Pxy1 = _spect_helper_csd(x, y, fs, window, nperseg, noverlap, nfft,
-                                     detrend, return_onesided, scaling, axis)
-
-    np.testing.assert_allclose(freqs1, freqs)
-    amax_Pxy = max(np.abs(Pxy).max(), 1) if Pxy.size else 1
-    atol = np.finfo(Pxy.dtype).resolution * amax_Pxy  # needed for large Pxy
-    # for c_ in range(Pxy.shape[-1]):
-    #    np.testing.assert_allclose(Pxy1[:, c_], Pxy[:, c_], atol=atol)
-    np.testing.assert_allclose(Pxy1, Pxy, atol=atol)
-    return freqs, t, Pxy
-
-
-def _spect_helper_csd(x, y, fs=1.0, window='hann', nperseg=None, noverlap=None,
-                      nfft=None, detrend='constant', return_onesided=True,
-                      scaling='density', axis=-1):
-    """Wrapper for replacing _spectral_helper() by using the ShortTimeFFT
-      for use by csd().
-
-    This function should be only used by _csd_test_shim() and is only useful
-    for testing the ShortTimeFFT implementation.
-    """
-
-    # The following lines are taken from the original _spectral_helper():
-    same_data = y is x
-    axis = int(axis)
-
-    # Ensure we have np.arrays, get outdtype
-    x = np.asarray(x)
-    if not same_data:
-        y = np.asarray(y)
-    #     outdtype = np.result_type(x, y, np.complex64)
-    # else:
-    #     outdtype = np.result_type(x, np.complex64)
-
-    if not same_data:
-        # Check if we can broadcast the outer axes together
-        xouter = list(x.shape)
-        youter = list(y.shape)
-        xouter.pop(axis)
-        youter.pop(axis)
-        try:
-            outershape = np.broadcast(np.empty(xouter), np.empty(youter)).shape
-        except ValueError as e:
-            raise ValueError('x and y cannot be broadcast together.') from e
-
-    if same_data:
-        if x.size == 0:
-            return np.empty(x.shape), np.empty(x.shape)
-    else:
-        if x.size == 0 or y.size == 0:
-            outshape = outershape + (min([x.shape[axis], y.shape[axis]]),)
-            emptyout = np.moveaxis(np.empty(outshape), -1, axis)
-            return emptyout, emptyout
-
-    if nperseg is not None:  # if specified by user
-        nperseg = int(nperseg)
-        if nperseg < 1:
-            raise ValueError('nperseg must be a positive integer')
-
-    # parse window; if array like, then set nperseg = win.shape
-    n = x.shape[axis] if same_data else max(x.shape[axis], y.shape[axis])
-    win, nperseg = _triage_segments(window, nperseg, input_length=n)
-
-    if nfft is None:
-        nfft = nperseg
-    elif nfft < nperseg:
-        raise ValueError('nfft must be greater than or equal to nperseg.')
-    else:
-        nfft = int(nfft)
-
-    if noverlap is None:
-        noverlap = nperseg // 2
-    else:
-        noverlap = int(noverlap)
-    if noverlap >= nperseg:
-        raise ValueError('noverlap must be less than nperseg.')
-    nstep = nperseg - noverlap
-
-    if np.iscomplexobj(x) and return_onesided:
-        return_onesided = False
-
-    # using cast() to make mypy happy:
-    fft_mode = cast(FFT_MODE_TYPE, 'onesided' if return_onesided
-                    else 'twosided')
-    scale = {'spectrum': 'magnitude', 'density': 'psd'}[scaling]
-    SFT = ShortTimeFFT(win, nstep, fs, fft_mode=fft_mode, mfft=nfft,
-                       scale_to=scale, phase_shift=None)
-
-    # _spectral_helper() calculates X.conj()*Y instead of X*Y.conj():
-    Pxy = SFT.spectrogram(y, x, detr=None if detrend is False else detrend,
-                          p0=0, p1=(n-noverlap)//SFT.hop, k_offset=nperseg//2,
-                          axis=axis).conj()
-    # Note:
-    # 'onesided2X' scaling of ShortTimeFFT conflicts with the
-    # scaling='spectrum' parameter, since it doubles the squared magnitude,
-    # which in the view of the ShortTimeFFT implementation does not make sense.
-    # Hence, the doubling of the square is implemented here:
-    if return_onesided:
-        f_axis = Pxy.ndim - 1 + axis if axis < 0 else axis
-        Pxy = np.moveaxis(Pxy, f_axis, -1)
-        Pxy[..., 1:-1 if SFT.mfft % 2 == 0 else None] *= 2
-        Pxy = np.moveaxis(Pxy, -1, f_axis)
-
-    return SFT.f, Pxy
-
-
 def stft_compare(x, fs=1.0, window='hann', nperseg=256, noverlap=None,
                  nfft=None, detrend=False, return_onesided=True,
                  boundary='zeros', padded=True, axis=-1, scaling='spectrum'):
@@ -460,21 +309,3 @@ def istft_compare(Zxx, fs=1.0, window='hann', nperseg=None, noverlap=None,
     assert_allclose(x_wrapper[k_lo:k_hi], x[k_lo:k_hi], atol=atol, rtol=rtol,
                     err_msg=f"Signal values {e_msg_part}")
     return t, x
-
-
-def csd_compare(x, y, fs=1.0, window='hann', nperseg=None, noverlap=None,
-                nfft=None, detrend='constant', return_onesided=True,
-                scaling='density', axis=-1, average='mean'):
-    """Assert that the results from the existing `csd()` and `_csd_wrapper()`
-    are close to each other. """
-    kw = dict(x=x, y=y, fs=fs, window=window, nperseg=nperseg,
-              noverlap=noverlap, nfft=nfft, detrend=detrend,
-              return_onesided=return_onesided, scaling=scaling, axis=axis,
-              average=average)
-    freqs0, Pxy0 = csd(**kw)
-    freqs1, Pxy1 = _csd_wrapper(**kw)
-
-    assert_allclose(freqs1, freqs0)
-    assert_allclose(Pxy1, Pxy0)
-    assert_allclose(freqs1, freqs0)
-    return freqs0, Pxy0

scipy/signal/tests/test_bsplines.py

@@ -1,4 +1,5 @@
 # pylint: disable=missing-docstring
+import math
 import numpy as np
 
 from scipy._lib._array_api import (
@@ -7,9 +8,11 @@ from scipy._lib._array_api import (
 import pytest
 from pytest import raises
 
-import scipy.signal._spline_filters as bsp
 from scipy import signal
 
+skip_xp_backends = pytest.mark.skip_xp_backends
+xfail_xp_backends = pytest.mark.xfail_xp_backends
+
 
 class TestBSplines:
     """Test behaviors of B-splines. Some of the values tested against were
@@ -17,15 +20,17 @@ class TestBSplines:
     purposes. Others (at integer points) are compared to theoretical
     expressions (cf. Unser, Aldroubi, Eden, IEEE TSP 1993, Table 1)."""
 
-    def test_spline_filter(self):
+    @skip_xp_backends(cpu_only=True, exceptions=["cupy"])
+    def test_spline_filter(self, xp):
         rng = np.random.RandomState(12457)
         # Test the type-error branch
-        raises(TypeError, bsp.spline_filter, np.asarray([0]), 0)
+        raises(TypeError, signal.spline_filter, xp.asarray([0]), 0)
         # Test the real branch
         data_array_real = rng.rand(12, 12)
         # make the magnitude exceed 1, and make some negative
         data_array_real = 10*(1-2*data_array_real)
-        result_array_real = np.asarray(
+        data_array_real = xp.asarray(data_array_real)
+        result_array_real = xp.asarray(
             [[-.463312621, 8.33391222, .697290949, 5.28390836,
               5.92066474, 6.59452137, 9.84406950, -8.78324188,
               7.20675750, -8.17222994, -4.38633345, 9.89917069],
@@ -61,16 +66,19 @@ class TestBSplines:
               -3.77114594, -1.11903194, -5.39151466, 3.06620093],
              [9.86326886, 1.05134482, -7.75950607, -3.64429655,
               7.81848957, -9.02270373, 3.73399754, -4.71962549,
-              -7.71144306, 3.78263161, 6.46034818, -4.43444731]])
-        xp_assert_close(bsp.spline_filter(data_array_real, 0),
+              -7.71144306, 3.78263161, 6.46034818, -4.43444731]], dtype=xp.float64)
+        xp_assert_close(signal.spline_filter(data_array_real, 0),
                         result_array_real)
 
-    def test_spline_filter_complex(self):
+    @skip_xp_backends(cpu_only=True, exceptions=["cupy"])
+    def test_spline_filter_complex(self, xp):
         rng = np.random.RandomState(12457)
         data_array_complex = rng.rand(7, 7) + rng.rand(7, 7)*1j
         # make the magnitude exceed 1, and make some negative
         data_array_complex = 10*(1+1j-2*data_array_complex)
-        result_array_complex = np.asarray(
+        data_array_complex = xp.asarray(data_array_complex)
+
+        result_array_complex = xp.asarray(
             [[-4.61489230e-01-1.92994022j, 8.33332443+6.25519943j,
               6.96300745e-01-9.05576038j, 5.28294849+3.97541356j,
               5.92165565+7.68240595j, 6.59493160-1.04542804j,
@@ -98,99 +106,120 @@ class TestBSplines:
              [7.13875294+2.91851187j, -5.35737514+9.64132309j,
               -9.66586399+0.70250005j, -9.87717438-2.0262239j,
               9.93160629+1.5630846j, 4.71948051-2.22050714j,
-              9.49550819+7.8995142j]])
+              9.49550819+7.8995142j]], dtype=xp.complex128)
         # FIXME: for complex types, the computations are done in
         # single precision (reason unclear). When this is changed,
         # this test needs updating.
-        xp_assert_close(bsp.spline_filter(data_array_complex, 0),
+        xp_assert_close(signal.spline_filter(data_array_complex, 0),
                         result_array_complex, rtol=1e-6)
 
-    def test_gauss_spline(self):
-        np.random.seed(12459)
-        assert_almost_equal(bsp.gauss_spline(0, 0), 1.381976597885342)
-        xp_assert_close(bsp.gauss_spline(np.asarray([1.]), 1),
-                        np.asarray([0.04865217]), atol=1e-9
+    def test_gauss_spline(self, xp):
+        assert math.isclose(signal.gauss_spline(0, 0), 1.381976597885342)
+
+        xp_assert_close(signal.gauss_spline(xp.asarray([1.]), 1),
+                        xp.asarray([0.04865217]), atol=1e-9
         )
 
-    def test_gauss_spline_list(self):
+    @skip_xp_backends(np_only=True, reason="deliberate: array-likes are accepted")
+    def test_gauss_spline_list(self, xp):
         # regression test for gh-12152 (accept array_like)
         knots = [-1.0, 0.0, -1.0]
-        assert_almost_equal(bsp.gauss_spline(knots, 3),
+        assert_almost_equal(signal.gauss_spline(knots, 3),
                             np.asarray([0.15418033, 0.6909883, 0.15418033])
         )
 
-    def test_cspline1d(self):
-        np.random.seed(12462)
-        xp_assert_equal(bsp.cspline1d(np.asarray([0])), [0.])
-        c1d = np.asarray([1.21037185, 1.86293902, 2.98834059, 4.11660378,
-                          4.78893826])
+    @skip_xp_backends(cpu_only=True)
+    def test_cspline1d(self, xp):
+        xp_assert_equal(signal.cspline1d(xp.asarray([0])),
+                        xp.asarray([0.], dtype=xp.float64))
+        c1d = xp.asarray([1.21037185, 1.86293902, 2.98834059, 4.11660378,
+                          4.78893826], dtype=xp.float64)
         # test lamda != 0
-        xp_assert_close(bsp.cspline1d(np.asarray([1., 2, 3, 4, 5]), 1), c1d)
-        c1d0 = np.asarray([0.78683946, 2.05333735, 2.99981113, 3.94741812,
-                           5.21051638])
-        xp_assert_close(bsp.cspline1d(np.asarray([1., 2, 3, 4, 5])), c1d0)
-
-    def test_qspline1d(self):
-        np.random.seed(12463)
-        xp_assert_equal(bsp.qspline1d(np.asarray([0])), [0.])
+        xp_assert_close(signal.cspline1d(xp.asarray([1., 2, 3, 4, 5]), 1), c1d)
+        c1d0 = xp.asarray([0.78683946, 2.05333735, 2.99981113, 3.94741812,
+                           5.21051638], dtype=xp.float64)
+        xp_assert_close(signal.cspline1d(xp.asarray([1., 2, 3, 4, 5])), c1d0)
+
+    @skip_xp_backends(cpu_only=True)
+    def test_qspline1d(self, xp):
+        xp_assert_equal(signal.qspline1d(xp.asarray([0])),
+                        xp.asarray([0.], dtype=xp.float64))
         # test lamda != 0
-        raises(ValueError, bsp.qspline1d, np.asarray([1., 2, 3, 4, 5]), 1.)
-        raises(ValueError, bsp.qspline1d, np.asarray([1., 2, 3, 4, 5]), -1.)
-        q1d0 = np.asarray([0.85350007, 2.02441743, 2.99999534, 3.97561055,
-                           5.14634135])
-        xp_assert_close(bsp.qspline1d(np.asarray([1., 2, 3, 4, 5])), q1d0)
-
-    def test_cspline1d_eval(self):
-        np.random.seed(12464)
-        xp_assert_close(bsp.cspline1d_eval(np.asarray([0., 0]), [0.]),
-                        np.asarray([0.])
-        )
-        xp_assert_equal(bsp.cspline1d_eval(np.asarray([1., 0, 1]), []),
-                        np.asarray([])
+        raises(ValueError, signal.qspline1d, xp.asarray([1., 2, 3, 4, 5]), 1.)
+        raises(ValueError, signal.qspline1d, xp.asarray([1., 2, 3, 4, 5]), -1.)
+        q1d0 = xp.asarray([0.85350007, 2.02441743, 2.99999534, 3.97561055,
+                           5.14634135], dtype=xp.float64)
+        xp_assert_close(
+            signal.qspline1d(xp.asarray([1., 2, 3, 4, 5], dtype=xp.float64)), q1d0
         )
+
+    @skip_xp_backends(cpu_only=True)
+    def test_cspline1d_eval(self, xp):
+        r = signal.cspline1d_eval(xp.asarray([0., 0], dtype=xp.float64),
+                               xp.asarray([0.], dtype=xp.float64))
+        xp_assert_close(r, xp.asarray([0.], dtype=xp.float64))
+
+        r = signal.cspline1d_eval(xp.asarray([1., 0, 1], dtype=xp.float64),
+                               xp.asarray([], dtype=xp.float64))
+        xp_assert_equal(r, xp.asarray([], dtype=xp.float64))
         x = [-3, -2, -1, 0, 1, 2, 3, 4, 5, 6]
         dx = x[1] - x[0]
         newx = [-6., -5.5, -5., -4.5, -4., -3.5, -3., -2.5, -2., -1.5, -1.,
                 -0.5, 0., 0.5, 1., 1.5, 2., 2.5, 3., 3.5, 4., 4.5, 5., 5.5, 6.,
                 6.5, 7., 7.5, 8., 8.5, 9., 9.5, 10., 10.5, 11., 11.5, 12.,
                 12.5]
-        y = np.asarray([4.216, 6.864, 3.514, 6.203, 6.759, 7.433, 7.874, 5.879,
+        y = xp.asarray([4.216, 6.864, 3.514, 6.203, 6.759, 7.433, 7.874, 5.879,
                         1.396, 4.094])
-        cj = bsp.cspline1d(y)
-        newy = np.asarray([6.203, 4.41570658, 3.514, 5.16924703, 6.864, 6.04643068,
+        cj = signal.cspline1d(y)
+        newy = xp.asarray([6.203, 4.41570658, 3.514, 5.16924703, 6.864, 6.04643068,
                            4.21600281, 6.04643068, 6.864, 5.16924703, 3.514,
                            4.41570658, 6.203, 6.80717667, 6.759, 6.98971173, 7.433,
                            7.79560142, 7.874, 7.41525761, 5.879, 3.18686814, 1.396,
                            2.24889482, 4.094, 2.24889482, 1.396, 3.18686814, 5.879,
                            7.41525761, 7.874, 7.79560142, 7.433, 6.98971173, 6.759,
-                           6.80717667, 6.203, 4.41570658])
-        xp_assert_close(bsp.cspline1d_eval(cj, newx, dx=dx, x0=x[0]), newy)
+                           6.80717667, 6.203, 4.41570658], dtype=xp.float64)
+        xp_assert_close(
+            signal.cspline1d_eval(cj, xp.asarray(newx), dx=dx, x0=x[0]), newy
+        )
+
+        with pytest.raises(ValueError,
+                            match="Spline coefficients 'cj' must not be empty."):
+            signal.cspline1d_eval(xp.asarray([], dtype=xp.float64), 
+                                  xp.asarray([0.0], dtype=xp.float64))
 
-    def test_qspline1d_eval(self):
-        np.random.seed(12465)
-        xp_assert_close(bsp.qspline1d_eval(np.asarray([0., 0]), [0.]),
-                        np.asarray([0.])
+    @skip_xp_backends(cpu_only=True)
+    def test_qspline1d_eval(self, xp):
+        xp_assert_close(signal.qspline1d_eval(xp.asarray([0., 0]), xp.asarray([0.])),
+                        xp.asarray([0.])
         )
-        xp_assert_equal(bsp.qspline1d_eval(np.asarray([1., 0, 1]), []),
-                        np.asarray([])
+        xp_assert_equal(signal.qspline1d_eval(xp.asarray([1., 0, 1]), xp.asarray([])),
+                        xp.asarray([])
         )
         x = [-3, -2, -1, 0, 1, 2, 3, 4, 5, 6]
-        dx = x[1]-x[0]
+        dx = x[1] - x[0]
         newx = [-6., -5.5, -5., -4.5, -4., -3.5, -3., -2.5, -2., -1.5, -1.,
                 -0.5, 0., 0.5, 1., 1.5, 2., 2.5, 3., 3.5, 4., 4.5, 5., 5.5, 6.,
                 6.5, 7., 7.5, 8., 8.5, 9., 9.5, 10., 10.5, 11., 11.5, 12.,
                 12.5]
-        y = np.asarray([4.216, 6.864, 3.514, 6.203, 6.759, 7.433, 7.874, 5.879,
+        y = xp.asarray([4.216, 6.864, 3.514, 6.203, 6.759, 7.433, 7.874, 5.879,
                         1.396, 4.094])
-        cj = bsp.qspline1d(y)
-        newy = np.asarray([6.203, 4.49418159, 3.514, 5.18390821, 6.864, 5.91436915,
+        cj = signal.qspline1d(y)
+        newy = xp.asarray([6.203, 4.49418159, 3.514, 5.18390821, 6.864, 5.91436915,
                            4.21600002, 5.91436915, 6.864, 5.18390821, 3.514,
                            4.49418159, 6.203, 6.71900226, 6.759, 7.03980488, 7.433,
                            7.81016848, 7.874, 7.32718426, 5.879, 3.23872593, 1.396,
                            2.34046013, 4.094, 2.34046013, 1.396, 3.23872593, 5.879,
                            7.32718426, 7.874, 7.81016848, 7.433, 7.03980488, 6.759,
-                           6.71900226, 6.203, 4.49418159])
-        xp_assert_close(bsp.qspline1d_eval(cj, newx, dx=dx, x0=x[0]), newy)
+                           6.71900226, 6.203, 4.49418159], dtype=xp.float64)
+        r = signal.qspline1d_eval(
+            cj, xp.asarray(newx, dtype=xp.float64), dx=dx, x0=x[0]
+        )
+        xp_assert_close(r, newy)
+
+        with pytest.raises(ValueError, 
+                           match="Spline coefficients 'cj' must not be empty."):
+            signal.qspline1d_eval(xp.asarray([], dtype=xp.float64), 
+                                  xp.asarray([0.0], dtype=xp.float64))
 
 
 # i/o dtypes with scipy 1.9.1, likely fixed by backwards compat
@@ -198,10 +227,13 @@ sepfir_dtype_map = {np.uint8: np.float32, int: np.float64,
                     np.float32: np.float32, float: float,
                     np.complex64: np.complex64, complex: complex}
 
+
+@skip_xp_backends(np_only=True)
 class TestSepfir2d:
-    def test_sepfir2d_invalid_filter(self):
-        filt = np.array([1.0, 2.0, 4.0, 2.0, 1.0])
+    def test_sepfir2d_invalid_filter(self, xp):
+        filt = xp.asarray([1.0, 2.0, 4.0, 2.0, 1.0])
         image = np.random.rand(7, 9)
+        image = xp.asarray(image)
         # No error for odd lengths
         signal.sepfir2d(image, filt, filt[2:])
 
@@ -213,25 +245,26 @@ class TestSepfir2d:
 
         # Filters must be 1-dimensional
         with pytest.raises(ValueError, match="object too deep"):
-            signal.sepfir2d(image, filt.reshape(1, -1), filt)
+            signal.sepfir2d(image, xp.reshape(filt, (1, -1)), filt)
         with pytest.raises(ValueError, match="object too deep"):
-            signal.sepfir2d(image, filt, filt.reshape(1, -1))
+            signal.sepfir2d(image, filt, xp.reshape(filt, (1, -1)))
 
-    def test_sepfir2d_invalid_image(self):
-        filt = np.array([1.0, 2.0, 4.0, 2.0, 1.0])
+    def test_sepfir2d_invalid_image(self, xp):
+        filt = xp.asarray([1.0, 2.0, 4.0, 2.0, 1.0])
         image = np.random.rand(8, 8)
+        image = xp.asarray(image)
 
         # Image must be 2 dimensional
         with pytest.raises(ValueError, match="object too deep"):
-            signal.sepfir2d(image.reshape(4, 4, 4), filt, filt)
+            signal.sepfir2d(xp.reshape(image, (4, 4, 4)), filt, filt)
 
         with pytest.raises(ValueError, match="object of too small depth"):
-            signal.sepfir2d(image[0], filt, filt)
+            signal.sepfir2d(image[0, :], filt, filt)
 
     @pytest.mark.parametrize('dtyp',
         [np.uint8, int, np.float32, float, np.complex64, complex]
     )
-    def test_simple(self, dtyp):
+    def test_simple(self, dtyp, xp):
         # test values on a paper-and-pencil example
         a = np.array([[1, 2, 3, 3, 2, 1],
                       [1, 2, 3, 3, 2, 1],
@@ -254,10 +287,11 @@ class TestSepfir2d:
                                [2., 4., 6., 6., 4., 2.]], dtype=dt)
         xp_assert_close(result, expected, atol=1e-16)
 
+    @skip_xp_backends(np_only=True, reason="TODO: convert this test")
     @pytest.mark.parametrize('dtyp',
         [np.uint8, int, np.float32, float, np.complex64, complex]
     )
-    def test_strided(self, dtyp):
+    def test_strided(self, dtyp, xp):
         a = np.array([[1, 2, 3, 3, 2, 1, 1, 2, 3],
                      [1, 2, 3, 3, 2, 1, 1, 2, 3],
                      [1, 2, 3, 3, 2, 1, 1, 2, 3],
@@ -268,11 +302,11 @@ class TestSepfir2d:
         xp_assert_close(result_strided, result_contig, atol=1e-15)
         assert result_strided.dtype == result_contig.dtype
 
+    @skip_xp_backends(np_only=True, reason="TODO: convert this test")
     @pytest.mark.xfail(reason="XXX: filt.size > image.shape: flaky")
-    def test_sepfir2d_strided_2(self):
+    def test_sepfir2d_strided_2(self, xp):
         # XXX: this test is flaky: fails on some reruns, with
         # result[0, 1] and result[1, 1] being ~1e+224.
-        np.random.seed(1234)
         filt = np.array([1.0, 2.0, 4.0, 2.0, 1.0, 3.0, 2.0])
         image = np.random.rand(4, 4)
 
@@ -282,11 +316,12 @@ class TestSepfir2d:
                                 [49.120928, 39.681844, 43.596067, 45.085854]])
         xp_assert_close(signal.sepfir2d(image, filt, filt[::3]), expected)
 
+    @skip_xp_backends(np_only=True, reason="TODO: convert this test")
     @pytest.mark.xfail(reason="XXX: flaky. pointers OOB on some platforms")
     @pytest.mark.parametrize('dtyp',
         [np.uint8, int, np.float32, float, np.complex64, complex]
     )
-    def test_sepfir2d_strided_3(self, dtyp):
+    def test_sepfir2d_strided_3(self, dtyp, xp):
         # NB: 'image' and 'filt' dtypes match here. Otherwise we can run into
         # unsafe casting errors for many combinations. Historically, dtype handling
         # in `sepfir2d` is a tad baroque; fixing it is an enhancement.
@@ -318,13 +353,13 @@ class TestSepfir2d:
         assert result.dtype == sepfir_dtype_map[dtyp]
 
 
-def test_cspline2d():
-    np.random.seed(181819142)
-    image = np.random.rand(71, 73)
+def test_cspline2d(xp):
+    rng = np.random.RandomState(181819142)
+    image = rng.rand(71, 73)
     signal.cspline2d(image, 8.0)
 
 
-def test_qspline2d():
-    np.random.seed(181819143)
-    image = np.random.rand(71, 73)
+def test_qspline2d(xp):
+    rng = np.random.RandomState(181819143)
+    image = rng.rand(71, 73)
     signal.qspline2d(image)

scipy/signal/tests/test_cont2discrete.py

@@ -13,7 +13,6 @@ from scipy.signal import tf2ss, impulse, dimpulse, step, dstep
 
 
 class TestC2D:
-    @pytest.mark.thread_unsafe  # due to Cython fused types, see cython#6506
     def test_zoh(self):
         ac = np.eye(2, dtype=np.float64)
         bc = np.full((2, 1), 0.5, dtype=np.float64)
@@ -354,19 +353,27 @@ class TestC2dLti:
         B = np.array([[0], [1]])
         C = np.array([[1, 0]])
         D = 0
+        dt = 0.05
 
         A_res = np.array([[0.985136404135682, 0.004876671474795],
                           [0.009753342949590, 0.965629718236502]])
         B_res = np.array([[0.000122937599964], [0.049135527547844]])
 
         sys_ssc = lti(A, B, C, D)
-        sys_ssd = sys_ssc.to_discrete(0.05)
+        sys_ssd = sys_ssc.to_discrete(dt=dt)
 
         xp_assert_close(sys_ssd.A, A_res)
         xp_assert_close(sys_ssd.B, B_res)
         xp_assert_close(sys_ssd.C, C)
         xp_assert_close(sys_ssd.D, np.zeros_like(sys_ssd.D))
 
+        sys_ssd2 = c2d(sys_ssc, dt=dt)
+
+        xp_assert_close(sys_ssd2.A, A_res)
+        xp_assert_close(sys_ssd2.B, B_res)
+        xp_assert_close(sys_ssd2.C, C)
+        xp_assert_close(sys_ssd2.D, np.zeros_like(sys_ssd2.D))
+
     def test_c2d_tf(self):
 
         sys = lti([0.5, 0.3], [1.0, 0.4])