scipy 1.15.2__cp312-cp312-win_amd64.whl → 1.16.0rc1__cp312-cp312-win_amd64.whl

scipy/signal/tests/test_spectral.py

@@ -10,7 +10,7 @@ from pytest import raises as assert_raises
 from scipy import signal
 from scipy.fft import fftfreq, rfftfreq, fft, irfft
 from scipy.integrate import trapezoid
-from scipy.signal import (periodogram, welch, lombscargle, coherence,
+from scipy.signal import (periodogram, welch, lombscargle, coherence, csd,
                           spectrogram, check_COLA, check_NOLA)
 from scipy.signal.windows import hann
 from scipy.signal._spectral_py import _spectral_helper
@@ -18,7 +18,6 @@ from scipy.signal._spectral_py import _spectral_helper
 # Compare ShortTimeFFT.stft() / ShortTimeFFT.istft() with stft() / istft():
 from scipy.signal.tests._scipy_spectral_test_shim import stft_compare as stft
 from scipy.signal.tests._scipy_spectral_test_shim import istft_compare as istft
-from scipy.signal.tests._scipy_spectral_test_shim import csd_compare as csd
 
 
 class TestPeriodogram:
@@ -416,8 +415,7 @@ class TestWelch:
         #for string-like window, input signal length < nperseg value gives
         #UserWarning, sets nperseg to x.shape[-1]
         with suppress_warnings() as sup:
-            msg = "nperseg = 256 is greater than input length  = 8, using nperseg = 8"
-            sup.filter(UserWarning, msg)
+            sup.filter(UserWarning, "nperseg=256 is greater than signal.*")
             f, p = welch(x,window='hann')  # default nperseg
             f1, p1 = welch(x,window='hann', nperseg=256)  # user-specified nperseg
         f2, p2 = welch(x, nperseg=8)  # valid nperseg, doesn't give warning
@@ -560,6 +558,15 @@ class TestWelch:
         assert_raises(ValueError, welch, x, nperseg=8,
                       average='unrecognised-average')
 
+    def test_ratio_scale_to(self):
+        """Verify the factor of ``sum(abs(window)**2)*fs / abs(sum(window))**2``
+        used in the `welch`  and `csd` docstrs. """
+        x, win, fs = np.array([1., 0, 0, 0]), np.ones(4), 12
+        params = dict(fs=fs, window=win, return_onesided=False, detrend=None)
+        p_dens = welch(x, scaling='density', **params)[1]
+        p_spec = welch(x, scaling='spectrum', **params)[1]
+        p_fac = sum(win**2)*fs / abs(sum(win))**2
+        assert_allclose(p_spec / p_dens, p_fac)
 
 class TestCSD:
     def test_pad_shorter_x(self):
@@ -735,6 +742,8 @@ class TestCSD:
         win_err = signal.get_window('hann', 32)
         assert_raises(ValueError, csd, x, x,
               10, win_err, nperseg=None)  # because win longer than signal
+        with pytest.raises(ValueError, match="Parameter nperseg=0.*"):
+            csd(x, x, 0, nperseg=0)
 
     def test_empty_input(self):
         f, p = csd([],np.zeros(10))
@@ -779,8 +788,7 @@ class TestCSD:
         #for string-like window, input signal length < nperseg value gives
         #UserWarning, sets nperseg to x.shape[-1]
         with suppress_warnings() as sup:
-            msg = "nperseg = 256 is greater than input length  = 8, using nperseg = 8"
-            sup.filter(UserWarning, msg)
+            sup.filter(UserWarning, "nperseg=256 is greater than signal length.*")
             f, p = csd(x, x, window='hann')  # default nperseg
             f1, p1 = csd(x, x, window='hann', nperseg=256)  # user-specified nperseg
         f2, p2 = csd(x, x, nperseg=8)  # valid nperseg, doesn't give warning
@@ -811,6 +819,11 @@ class TestCSD:
         assert_raises(ValueError, csd, np.ones(12), np.zeros(12), nfft=3,
                       nperseg=4)
 
+    def test_incompatible_inputs(self):
+        with pytest.raises(ValueError, match='x and y cannot be broadcast.*'):
+            csd(np.ones((1, 8, 1)), np.ones((2, 8)), nperseg=4)
+
+
     def test_real_onesided_even_32(self):
         x = np.zeros(16, 'f')
         x[0] = 1

scipy/signal/tests/test_splines.py

@@ -1,12 +1,21 @@
 # pylint: disable=missing-docstring
+import math
 import numpy as np
 import pytest
-from scipy._lib._array_api import xp_assert_close
+import scipy._lib.array_api_extra as xpx
+from scipy._lib._array_api import is_cupy, xp_assert_close, xp_default_dtype
 
 from scipy.signal._spline import (
     symiirorder1_ic, symiirorder2_ic_fwd, symiirorder2_ic_bwd)
 from scipy.signal import symiirorder1, symiirorder2
 
+skip_xp_backends = pytest.mark.skip_xp_backends
+xfail_xp_backends = pytest.mark.xfail_xp_backends
+
+
+def npr(xp, *args):
+    return xp.concat(tuple(xpx.atleast_nd(x, ndim=1, xp=xp) for x in args))
+
 
 def _compute_symiirorder2_bwd_hs(k, cs, rsq, omega):
     cssq = cs * cs
@@ -20,13 +29,18 @@ def _compute_symiirorder2_bwd_hs(k, cs, rsq, omega):
 
 
 class TestSymIIR:
+
+    @skip_xp_backends(np_only=True, reason="_ic functions are private and numpy-only")
     @pytest.mark.parametrize(
-        'dtype', [np.float32, np.float64, np.complex64, np.complex128])
+        'dtype', ['float32', 'float64', 'complex64', 'complex128'])
     @pytest.mark.parametrize('precision', [-1.0, 0.7, 0.5, 0.25, 0.0075])
-    def test_symiir1_ic(self, dtype, precision):
+    def test_symiir1_ic(self, dtype, precision, xp):
+
+        dtype = getattr(xp, dtype)
+
         c_precision = precision
         if precision <= 0.0 or precision > 1.0:
-            if dtype in {np.float32, np.complex64}:
+            if dtype in {xp.float32, xp.complex64}:
                 c_precision = 1e-6
             else:
                 c_precision = 1e-11
@@ -45,33 +59,34 @@ class TestSymIIR:
         # using the partial sum formula: (1 - b**n) / (1 - b)
         # This holds due to the input being a step signal.
         b = 0.85
-        n_exp = int(np.ceil(np.log(c_precision) / np.log(b)))
-        expected = np.asarray([[(1 - b ** n_exp) / (1 - b)]], dtype=dtype)
+        n_exp = int(math.ceil(math.log(c_precision) / math.log(b)))
+        expected = xp.asarray([[(1 - b ** n_exp) / (1 - b)]], dtype=dtype)
         expected = 1 + b * expected
 
         # Create a step signal of size n + 1
-        x = np.ones(n_exp + 1, dtype=dtype)
+        x = xp.ones(n_exp + 1, dtype=dtype)
         xp_assert_close(symiirorder1_ic(x, b, precision), expected,
                         atol=2e-6, rtol=2e-7)
 
         # Check the conditions for a exponential decreasing signal with base 2.
         # Same conditions hold, as the product of 0.5^n * 0.85^n is
         # still a geometric series
-        b_d = np.asarray(b, dtype=dtype)
+        b_d = xp.asarray(b, dtype=dtype)
         expected = np.asarray(
             [[(1 - (0.5 * b_d) ** n_exp) / (1 - (0.5 * b_d))]], dtype=dtype)
         expected = 1 + b_d * expected
 
         # Create an exponential decreasing signal of size n + 1
-        x = 2 ** -np.arange(n_exp + 1, dtype=dtype)
+        x = 2 ** -xp.arange(n_exp + 1, dtype=dtype)
         xp_assert_close(symiirorder1_ic(x, b, precision), expected,
                         atol=2e-6, rtol=2e-7)
 
-    def test_symiir1_ic_fails(self):
+    @skip_xp_backends(np_only=True, reason="_ic functions are private and numpy-only")
+    def test_symiir1_ic_fails(self, xp):
         # Test that symiirorder1_ic fails whenever \sum_{n = 1}^{n} b^n > eps
         b = 0.85
         # Create a step signal of size 100
-        x = np.ones(100, dtype=np.float64)
+        x = xp.ones(100, dtype=xp.float64)
 
         # Compute the closed form for the geometrical series
         precision = 1 / (1 - b)
@@ -81,13 +96,20 @@ class TestSymIIR:
         pytest.raises(ValueError, symiirorder1_ic, x, 1.0, -1)
         pytest.raises(ValueError, symiirorder1_ic, x, 2.0, -1)
 
+    @skip_xp_backends(
+        cpu_only=True, exceptions=["cupy"], reason="internals are numpy-only"
+    )
+    @xfail_xp_backends("cupy", reason="sum did not converge")
+    @skip_xp_backends("jax.numpy", reason="item assignment in tests")
     @pytest.mark.parametrize(
-        'dtype', [np.float32, np.float64, np.complex64, np.complex128])
+        'dtype', ['float32', 'float64', 'complex64', 'complex128'])
     @pytest.mark.parametrize('precision', [-1.0, 0.7, 0.5, 0.25, 0.0075])
-    def test_symiir1(self, dtype, precision):
+    def test_symiir1(self, dtype, precision, xp):
+        dtype = getattr(xp, dtype)
+
         c_precision = precision
         if precision <= 0.0 or precision > 1.0:
-            if dtype in {np.float32, np.complex64}:
+            if dtype in {xp.float32, xp.complex64}:
                 c_precision = 1e-6
             else:
                 c_precision = 1e-11
@@ -97,12 +119,12 @@ class TestSymIIR:
         c0 = 0.15
         z1 = 0.85
         n = 200
-        signal = np.ones(n, dtype=dtype)
+        signal = xp.ones(n, dtype=dtype)
 
         # Find the initial condition. See test_symiir1_ic for a detailed
         # explanation
-        n_exp = int(np.ceil(np.log(c_precision) / np.log(z1)))
-        initial = np.asarray((1 - z1 ** n_exp) / (1 - z1), dtype=dtype)
+        n_exp = int(math.ceil(math.log(c_precision) / math.log(z1)))
+        initial = xp.asarray((1 - z1 ** n_exp) / (1 - z1), dtype=dtype)
         initial = 1 + z1 * initial
 
         # Forward pass
@@ -117,15 +139,15 @@ class TestSymIIR:
         # d is the Kronecker delta function, and u is the unit step
 
         # y0 * z1**n * u[n]
-        pos = np.arange(n, dtype=dtype)
+        pos = xp.astype(xp.arange(n), dtype)
         comp1 = initial * z1**pos
 
         # -z1 / (1 - z1) * z1**(k - 1) * u[k - 1]
-        comp2 = np.zeros(n, dtype=dtype)
+        comp2 = xp.zeros(n, dtype=dtype)
         comp2[1:] = -z1 / (1 - z1) * z1**pos[:-1]
 
         # 1 / (1 - z1) * u[k - 1]
-        comp3 = np.zeros(n, dtype=dtype)
+        comp3 = xp.zeros(n, dtype=dtype)
         comp3[1:] = 1 / (1 - z1)
 
         expected_fwd = comp1 + comp2 + comp3
@@ -139,63 +161,73 @@ class TestSymIIR:
 
         # Computing a closed form for the complete expression is difficult
         # The result will be computed iteratively from the difference equation
-        exp_out = np.zeros(n, dtype=dtype)
+        exp_out = xp.zeros(n, dtype=dtype)
         exp_out[0] = sym_cond
 
         for i in range(1, n):
             exp_out[i] = c0 * expected_fwd[n - 1 - i] + z1 * exp_out[i - 1]
 
-        exp_out = exp_out[::-1]
+        exp_out = xp.flip(exp_out)
 
         out = symiirorder1(signal, c0, z1, precision)
         xp_assert_close(out, exp_out, atol=4e-6, rtol=6e-7)
 
+    @xfail_xp_backends("cupy", reason="sum did not converge")
+    @skip_xp_backends(
+        cpu_only=True, exceptions=["cupy"], reason="internals are numpy-only"
+    )
     @pytest.mark.parametrize('dtype', ['float32', 'float64'])
-    def test_symiir1_values(self, dtype):
+    def test_symiir1_values(self, dtype, xp):
         rng = np.random.RandomState(1234)
-        dtype = getattr(np, dtype)
         s = rng.uniform(size=16).astype(dtype)
+        dtype = getattr(xp, dtype)
+        s = xp.asarray(s)
         res = symiirorder1(s, 0.5, 0.1)
 
         # values from scipy 1.9.1
-        exp_res = np.array([0.14387447, 0.35166047, 0.29735238, 0.46295986, 0.45174927,
-                            0.19982875, 0.20355805, 0.47378628, 0.57232247, 0.51597393,
-                           0.25935107, 0.31438554, 0.41096728, 0.4190693 , 0.25812255,
-                           0.33671467], dtype=res.dtype)
-        assert res.dtype == dtype
-        atol = {np.float64: 1e-15, np.float32: 1e-7}[dtype]
+        exp_res = xp.asarray([
+            0.14387447, 0.35166047, 0.29735238, 0.46295986, 0.45174927,
+            0.19982875, 0.20355805, 0.47378628, 0.57232247, 0.51597393,
+            0.25935107, 0.31438554, 0.41096728, 0.4190693 , 0.25812255,
+            0.33671467], dtype=res.dtype)
+        atol = {xp.float64: 1e-15, xp.float32: 1e-7}[dtype]
         xp_assert_close(res, exp_res, atol=atol)
 
-        s = s + 1j*s
+        I1 = xp.asarray(
+            1 + 1j, dtype=xp.result_type(s, xp.complex64)
+        )
+        s = s * I1
         res = symiirorder1(s, 0.5, 0.1)
-        assert res.dtype == np.complex64 if dtype == np.float32 else np.complex128
-        xp_assert_close(res, exp_res + 1j*exp_res, atol=atol)
+        assert res.dtype == xp.complex64 if dtype == xp.float32 else xp.complex128
+        xp_assert_close(res, I1 * exp_res, atol=atol)
 
+    @skip_xp_backends(np_only=True,
+                      reason="_initial_fwd functions are private and numpy-only")
     @pytest.mark.parametrize(
         'dtype', ['float32', 'float64'])
     @pytest.mark.parametrize('precision', [-1.0, 0.7, 0.5, 0.25, 0.0075])
-    def test_symiir2_initial_fwd(self, dtype, precision):
-        dtype = getattr(np, dtype)
+    def test_symiir2_initial_fwd(self, dtype, precision, xp):
+        dtype = getattr(xp, dtype)
         c_precision = precision
         if precision <= 0.0 or precision > 1.0:
-            if dtype in {np.float32, np.complex64}:
+            if dtype in {xp.float32, xp.complex64}:
                 c_precision = 1e-6
             else:
                 c_precision = 1e-11
 
         # Compute the initial conditions for a order-two symmetrical low-pass
         # filter with r = 0.5 and omega = pi / 3 for an unit step input.
-        r = np.asarray(0.5, dtype=dtype)
-        omega = np.asarray(np.pi / 3.0, dtype=dtype)
-        cs = 1 - 2 * r * np.cos(omega) + r**2
+        r = xp.asarray(0.5, dtype=dtype)
+        omega = xp.asarray(np.pi / 3.0, dtype=dtype)
+        cs = 1 - 2 * r * xp.cos(omega) + r**2
 
         # The index n for the initial condition is bound from 0 to the
         # first position where sin(omega * (n + 2)) = 0 => omega * (n + 2) = pi
         # For omega = pi / 3, the maximum initial condition occurs when
         # sqrt(3) / 2 * r**n < precision.
         # => n = log(2 * sqrt(3) / 3 * precision) / log(r)
-        ub = np.ceil(np.log(c_precision / np.sin(omega)) / np.log(c_precision))
-        lb = np.ceil(np.pi / omega) - 2
+        ub = xp.ceil(xp.log(c_precision / xp.sin(omega)) / math.log(c_precision))
+        lb = xp.ceil(math.pi / omega) - 2
         n_exp = min(ub, lb)
 
         # The forward initial condition for a filter of order two is:
@@ -207,10 +239,10 @@ class TestSymIIR:
         #        r**(n + 3) * np.sin(omega * (n + 2)) / np.sin(omega) + cs
         fwd_initial_1 = (
             cs +
-            2 * r * np.cos(omega) -
+            2 * r * xp.cos(omega) -
             r**2 -
-            r**(n_exp + 2) * np.sin(omega * (n_exp + 3)) / np.sin(omega) +
-            r**(n_exp + 3) * np.sin(omega * (n_exp + 2)) / np.sin(omega))
+            r**(n_exp + 2) * xp.sin(omega * (n_exp + 3)) / xp.sin(omega) +
+            r**(n_exp + 3) * xp.sin(omega * (n_exp + 2)) / xp.sin(omega))
 
         # The second initial condition is given by
         # s[n] = 1 / np.sin(omega) * (
@@ -218,19 +250,19 @@ class TestSymIIR:
         #        r**3 * np.sin(2 * omega) -
         #        r**(n + 3) * np.sin(omega * (n + 4)) +
         #        r**(n + 4) * np.sin(omega * (n + 3)))
-        ub = np.ceil(np.log(c_precision / np.sin(omega)) / np.log(c_precision))
-        lb = np.ceil(np.pi / omega) - 3
+        ub = xp.ceil(xp.log(c_precision / xp.sin(omega)) / math.log(c_precision))
+        lb = xp.ceil(xp.pi / omega) - 3
         n_exp = min(ub, lb)
 
         fwd_initial_2 = (
-            cs + cs * 2 * r * np.cos(omega) +
-            (r**2 * np.sin(3 * omega) -
-             r**3 * np.sin(2 * omega) -
-             r**(n_exp + 3) * np.sin(omega * (n_exp + 4)) +
-             r**(n_exp + 4) * np.sin(omega * (n_exp + 3))) / np.sin(omega))
+            cs + cs * 2 * r * xp.cos(omega) +
+            (r**2 * xp.sin(3 * omega) -
+             r**3 * xp.sin(2 * omega) -
+             r**(n_exp + 3) * xp.sin(omega * (n_exp + 4)) +
+             r**(n_exp + 4) * xp.sin(omega * (n_exp + 3))) / xp.sin(omega))
 
-        expected = np.r_[fwd_initial_1, fwd_initial_2][None, :]
-        expected = expected.astype(dtype)
+        expected = npr(xp, fwd_initial_1, fwd_initial_2)[None, :]
+        expected = xp.astype(expected, dtype)
 
         n = 100
         signal = np.ones(n, dtype=dtype)
@@ -238,29 +270,33 @@ class TestSymIIR:
         out = symiirorder2_ic_fwd(signal, r, omega, precision)
         xp_assert_close(out, expected, atol=4e-6, rtol=6e-7)
 
+    @skip_xp_backends(np_only=True,
+                      reason="_initial_bwd functions are private and numpy-only")
     @pytest.mark.parametrize(
-        'dtype', [np.float32, np.float64])
+        'dtype', ['float32', 'float64'])
     @pytest.mark.parametrize('precision', [-1.0, 0.7, 0.5, 0.25, 0.0075])
-    def test_symiir2_initial_bwd(self, dtype, precision):
+    def test_symiir2_initial_bwd(self, dtype, precision, xp):
+        dtype = getattr(xp, dtype)
+
         c_precision = precision
         if precision <= 0.0 or precision > 1.0:
-            if dtype in {np.float32, np.complex64}:
+            if dtype in {xp.float32, xp.complex64}:
                 c_precision = 1e-6
             else:
                 c_precision = 1e-11
 
-        r = np.asarray(0.5, dtype=dtype)
-        omega = np.asarray(np.pi / 3.0, dtype=dtype)
-        cs = 1 - 2 * r * np.cos(omega) + r * r
-        a2 = 2 * r * np.cos(omega)
+        r = xp.asarray(0.5, dtype=dtype)
+        omega = xp.asarray(xp.pi / 3.0, dtype=dtype)
+        cs = 1 - 2 * r * xp.cos(omega) + r * r
+        a2 = 2 * r * xp.cos(omega)
         a3 = -r * r
 
         n = 100
-        signal = np.ones(n, dtype=dtype)
+        signal = xp.ones(n, dtype=dtype)
 
         # Compute initial forward conditions
         ic = symiirorder2_ic_fwd(signal, r, omega, precision)
-        out = np.zeros(n + 2, dtype=dtype)
+        out = xp.zeros(n + 2, dtype=dtype)
         out[:2] = ic[0]
 
         # Apply the forward system cs / (1 - a2 * z^-1 - a3 * z^-2))
@@ -268,52 +304,61 @@ class TestSymIIR:
             out[i] = cs * signal[i - 2] + a2 * out[i - 1] + a3 * out[i - 2]
 
         # Find the backward initial conditions
-        ic2 = np.zeros(2, dtype=dtype)
-        idx = np.arange(n)
+        ic2 = xp.zeros(2, dtype=dtype)
+        idx = xp.arange(n)
 
         diff = (_compute_symiirorder2_bwd_hs(idx, cs, r * r, omega) +
                 _compute_symiirorder2_bwd_hs(idx + 1, cs, r * r, omega))
         ic2_0_all = np.cumsum(diff * out[:1:-1])
-        pos = np.where(diff ** 2 < c_precision)[0]
+        pos = xp.nonzero(diff ** 2 < c_precision)[0]
         ic2[0] = ic2_0_all[pos[0]]
 
         diff = (_compute_symiirorder2_bwd_hs(idx - 1, cs, r * r, omega) +
                 _compute_symiirorder2_bwd_hs(idx + 2, cs, r * r, omega))
-        ic2_1_all = np.cumsum(diff * out[:1:-1])
-        pos = np.where(diff ** 2 < c_precision)[0]
+
+        ic2_1_all = xp.cumulative_sum(diff * out[:1:-1])
+        pos = xp.nonzero(diff ** 2 < c_precision)[0]
         ic2[1] = ic2_1_all[pos[0]]
 
         out_ic = symiirorder2_ic_bwd(out, r, omega, precision)[0]
         xp_assert_close(out_ic, ic2, atol=4e-6, rtol=6e-7)
 
+    @skip_xp_backends(cpu_only=True, reason="internals are numpy-only")
+    @skip_xp_backends("jax.numpy", reason="item assignment in tests")
     @pytest.mark.parametrize(
-        'dtype', [np.float32, np.float64])
+        'dtype', ['float32', 'float64'])
     @pytest.mark.parametrize('precision', [-1.0, 0.7, 0.5, 0.25, 0.0075])
-    def test_symiir2(self, dtype, precision):
-        r = np.asarray(0.5, dtype=dtype)
-        omega = np.asarray(np.pi / 3.0, dtype=dtype)
-        cs = 1 - 2 * r * np.cos(omega) + r * r
-        a2 = 2 * r * np.cos(omega)
+    def test_symiir2(self, dtype, precision, xp):
+        dtype = getattr(xp, dtype)
+
+        r = 0.5
+        omega = math.pi / 3.0
+        cs = 1 - 2 * r * math.cos(omega) + r * r
+        a2 = 2 * r * math.cos(omega)
         a3 = -r * r
 
         n = 100
-        signal = np.ones(n, dtype=dtype)
+        signal = xp.ones(n, dtype=dtype)
 
         # Compute initial forward conditions
-        ic = symiirorder2_ic_fwd(signal, r, omega, precision)
-        out1 = np.zeros(n + 2, dtype=dtype)
-        out1[:2] = ic[0]
+        signal_np = np.asarray(signal)
+        ic = symiirorder2_ic_fwd(signal_np, r, omega, precision)
+        ic = xp.asarray(ic)
+        out1 = xp.zeros(n + 2, dtype=dtype)
+        out1[:2] = ic[0, :]
 
         # Apply the forward system cs / (1 - a2 * z^-1 - a3 * z^-2))
         for i in range(2, n + 2):
             out1[i] = cs * signal[i - 2] + a2 * out1[i - 1] + a3 * out1[i - 2]
 
         # Find the backward initial conditions
-        ic2 = symiirorder2_ic_bwd(out1, r, omega, precision)[0]
+        ic2 = symiirorder2_ic_bwd(np.asarray(out1), r, omega, precision)[0]
+        ic2 = xp.asarray(ic2)
 
         # Apply the system cs / (1 - a2 * z - a3 * z^2)) in backwards
-        exp = np.empty(n, dtype=dtype)
-        exp[-2:] = ic2[::-1]
+        exp = xp.empty(n, dtype=dtype)
+
+        exp[-2:] = xp.flip(ic2)
 
         for i in range(n - 3, -1, -1):
             exp[i] = cs * out1[i] + a2 * exp[i + 1] + a3 * exp[i + 2]
@@ -321,20 +366,26 @@ class TestSymIIR:
         out = symiirorder2(signal, r, omega, precision)
         xp_assert_close(out, exp, atol=4e-6, rtol=6e-7)
 
+    @skip_xp_backends(cpu_only=True, exceptions=["cupy"], reason="C internals")
     @pytest.mark.parametrize('dtyp', ['float32', 'float64'])
-    def test_symiir2_values(self, dtyp):
-        dtyp = getattr(np, dtyp)
+    def test_symiir2_values(self, dtyp, xp):
         rng = np.random.RandomState(1234)
         s = rng.uniform(size=16).astype(dtyp)
+        s = xp.asarray(s)
+
+        # cupy returns f64 for f32 inputs
+        dtype = xp.float64 if is_cupy(xp) else getattr(xp, dtyp)
+
         res = symiirorder2(s, 0.1, 0.1, precision=1e-10)
 
         # values from scipy 1.9.1
-        exp_res = np.array([0.26572609, 0.53408018, 0.51032696, 0.72115829, 0.69486885,
-           0.3649055 , 0.37349478, 0.74165032, 0.89718521, 0.80582483,
-           0.46758053, 0.51898709, 0.65025605, 0.65394321, 0.45273595,
-           0.53539183], dtype=dtyp)
+        exp_res = xp.asarray(
+            [0.26572609, 0.53408018, 0.51032696, 0.72115829, 0.69486885,
+             0.3649055 , 0.37349478, 0.74165032, 0.89718521, 0.80582483,
+             0.46758053, 0.51898709, 0.65025605, 0.65394321, 0.45273595,
+             0.53539183], dtype=dtype
+        )
 
-        assert res.dtype == dtyp
         # The values in SciPy 1.14 agree with those in SciPy 1.9.1 to this
         # accuracy only. Implementation differences are twofold:
         # 1. boundary conditions are computed differently
@@ -345,18 +396,32 @@ class TestSymIIR:
         # In that respect, sosfilt is likely doing a better job.
         xp_assert_close(res, exp_res, atol=2e-6)
 
-        s = s + 1j*s
-        with pytest.raises(TypeError):
+        I1 = xp.asarray(1 + 1j, dtype=xp.result_type(s, xp.complex64))
+        s = s * I1
+
+        with pytest.raises((TypeError, ValueError)):
             res = symiirorder2(s, 0.5, 0.1)
 
-    def test_symiir1_integer_input(self):
-        s = np.where(np.arange(100) % 2, -1, 1)
-        expected = symiirorder1(s.astype(float), 0.5, 0.5)
+    @skip_xp_backends(cpu_only=True, exceptions=["cupy"], reason="C internals")
+    @xfail_xp_backends("cupy", reason="cupy does not accept integer arrays")
+    def test_symiir1_integer_input(self, xp):
+        s = xp.where(
+            xp.astype(xp.arange(100) % 2, xp.bool),
+            xp.asarray(-1),
+            xp.asarray(1),
+        )
+        expected = symiirorder1(xp.astype(s, xp_default_dtype(xp)), 0.5, 0.5)
         out = symiirorder1(s, 0.5, 0.5)
         xp_assert_close(out, expected)
 
-    def test_symiir2_integer_input(self):
-        s = np.where(np.arange(100) % 2, -1, 1)
-        expected = symiirorder2(s.astype(float), 0.5, np.pi / 3.0)
-        out = symiirorder2(s, 0.5, np.pi / 3.0)
+    @skip_xp_backends(cpu_only=True, exceptions=["cupy"], reason="C internals")
+    @xfail_xp_backends("cupy", reason="cupy does not accept integer arrays")
+    def test_symiir2_integer_input(self, xp):
+        s = xp.where(
+            xp.astype(xp.arange(100) % 2, xp.bool),
+            xp.asarray(-1),
+            xp.asarray(1),
+        )
+        expected = symiirorder2(xp.astype(s, xp_default_dtype(xp)), 0.5, xp.pi / 3.0)
+        out = symiirorder2(s, 0.5, xp.pi / 3.0)
         xp_assert_close(out, expected)