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

scipy/signal/tests/test_fir_filter_design.py

@@ -1,18 +1,23 @@
+import math
 import numpy as np
+
 from numpy.testing import assert_warns
-from scipy._lib._array_api import (
-    xp_assert_close, xp_assert_equal,
-    assert_almost_equal, assert_array_almost_equal,
-)
 from pytest import raises as assert_raises
 import pytest
 
-from scipy.fft import fft
-from scipy.special import sinc
+import scipy._lib.array_api_extra as xpx
+from scipy._lib._array_api import (
+    xp_assert_close, xp_assert_equal, assert_almost_equal, assert_array_almost_equal,
+    array_namespace, xp_default_dtype
+)
+from scipy.fft import fft, fft2
 from scipy.signal import (kaiser_beta, kaiser_atten, kaiserord,
-    firwin, firwin2, freqz, remez, firls, minimum_phase
+    firwin, firwin2, freqz, remez, firls, minimum_phase, convolve2d, firwin_2d
 )
 
+skip_xp_backends = pytest.mark.skip_xp_backends
+xfail_xp_backends = pytest.mark.xfail_xp_backends
+
 
 def test_kaiser_beta():
     b = kaiser_beta(58.7)
@@ -41,17 +46,19 @@ def test_kaiserord():
 class TestFirwin:
 
     def check_response(self, h, expected_response, tol=.05):
-        N = len(h)
+        xp = array_namespace(h)
+        N = h.shape[0]
         alpha = 0.5 * (N-1)
-        m = np.arange(0,N) - alpha   # time indices of taps
+        m = xp.arange(0, N) - alpha   # time indices of taps
         for freq, expected in expected_response:
-            actual = abs(np.sum(h*np.exp(-1.j*np.pi*m*freq)))
-            mse = abs(actual-expected)**2
+            actual = abs(xp.sum(h * xp.exp(-1j * xp.pi * m * freq)))
+            mse = abs(actual - expected)**2
             assert mse < tol, f'response not as expected, mse={mse:g} > {tol:g}'
 
-    def test_response(self):
+    def test_response(self, xp):
         N = 51
         f = .5
+
         # increase length just to try even/odd
         h = firwin(N, f)  # low-pass from 0 to f
         self.check_response(h, [(.25,1), (.75,0)])
@@ -97,7 +104,7 @@ class TestFirwin:
         mse = np.mean(abs(abs(H)-Hideal)**2)
         return mse
 
-    def test_scaling(self):
+    def test_scaling(self, xp):
         """
         For one lowpass, bandpass, and highpass example filter, this test
         checks two things:
@@ -133,110 +140,130 @@ class TestFirwin:
 class TestFirWinMore:
     """Different author, different style, different tests..."""
 
-    def test_lowpass(self):
+    def test_lowpass(self, xp):
         width = 0.04
         ntaps, beta = kaiserord(120, width)
-        kwargs = dict(cutoff=0.5, window=('kaiser', beta), scale=False)
+        cutoff = xp.asarray(0.5)
+        kwargs = dict(cutoff=cutoff, window=('kaiser', beta), scale=False)
         taps = firwin(ntaps, **kwargs)
 
         # Check the symmetry of taps.
-        assert_array_almost_equal(taps[:ntaps//2], taps[ntaps:ntaps-ntaps//2-1:-1])
+        assert_array_almost_equal(taps[:ntaps//2], xp.flip(taps)[:ntaps//2])
 
         # Check the gain at a few samples where
         # we know it should be approximately 0 or 1.
-        freq_samples = np.array([0.0, 0.25, 0.5-width/2, 0.5+width/2, 0.75, 1.0])
-        freqs, response = freqz(taps, worN=np.pi*freq_samples)
-        assert_array_almost_equal(np.abs(response),
-                                    [1.0, 1.0, 1.0, 0.0, 0.0, 0.0], decimal=5)
+        freq_samples = xp.asarray([0.0, 0.25, 0.5-width/2, 0.5+width/2, 0.75, 1.0])
+        freqs, response = freqz(taps, worN=xp.pi*freq_samples)
+
+        assert_array_almost_equal(
+            xp.abs(response),
+            xp.asarray([1.0, 1.0, 1.0, 0.0, 0.0, 0.0]), decimal=5
+        )
 
         taps_str = firwin(ntaps, pass_zero='lowpass', **kwargs)
         xp_assert_close(taps, taps_str)
 
-    def test_highpass(self):
+    def test_highpass(self, xp):
         width = 0.04
         ntaps, beta = kaiserord(120, width)
 
         # Ensure that ntaps is odd.
         ntaps |= 1
 
-        kwargs = dict(cutoff=0.5, window=('kaiser', beta), scale=False)
+        cutoff = xp.asarray(0.5)
+        kwargs = dict(cutoff=cutoff, window=('kaiser', beta), scale=False)
         taps = firwin(ntaps, pass_zero=False, **kwargs)
 
         # Check the symmetry of taps.
-        assert_array_almost_equal(taps[:ntaps//2], taps[ntaps:ntaps-ntaps//2-1:-1])
+        assert_array_almost_equal(taps[:ntaps//2], xp.flip(taps)[:ntaps//2])
 
         # Check the gain at a few samples where
         # we know it should be approximately 0 or 1.
-        freq_samples = np.array([0.0, 0.25, 0.5-width/2, 0.5+width/2, 0.75, 1.0])
+        freq_samples = xp.asarray([0.0, 0.25, 0.5 - width/2, 0.5 + width/2, 0.75, 1.0])
         freqs, response = freqz(taps, worN=np.pi*freq_samples)
-        assert_array_almost_equal(np.abs(response),
-                                    [0.0, 0.0, 0.0, 1.0, 1.0, 1.0], decimal=5)
+
+        assert_array_almost_equal(xp.abs(response),
+                                  xp.asarray([0.0, 0.0, 0.0, 1.0, 1.0, 1.0]), decimal=5)
 
         taps_str = firwin(ntaps, pass_zero='highpass', **kwargs)
         xp_assert_close(taps, taps_str)
 
-    def test_bandpass(self):
+    def test_bandpass(self, xp):
         width = 0.04
         ntaps, beta = kaiserord(120, width)
-        kwargs = dict(cutoff=[0.3, 0.7], window=('kaiser', beta), scale=False)
+        kwargs = dict(
+            cutoff=xp.asarray([0.3, 0.7]), window=('kaiser', beta), scale=False
+        )
         taps = firwin(ntaps, pass_zero=False, **kwargs)
 
         # Check the symmetry of taps.
-        assert_array_almost_equal(taps[:ntaps//2], taps[ntaps:ntaps-ntaps//2-1:-1])
+        assert_array_almost_equal(taps[:ntaps//2], xp.flip(taps)[:ntaps//2])
 
         # Check the gain at a few samples where
         # we know it should be approximately 0 or 1.
-        freq_samples = np.array([0.0, 0.2, 0.3-width/2, 0.3+width/2, 0.5,
-                                0.7-width/2, 0.7+width/2, 0.8, 1.0])
+        freq_samples = xp.asarray([0.0, 0.2, 0.3 - width/2, 0.3 + width/2, 0.5,
+                                   0.7 - width/2, 0.7 + width/2, 0.8, 1.0])
         freqs, response = freqz(taps, worN=np.pi*freq_samples)
-        assert_array_almost_equal(np.abs(response),
-                [0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0], decimal=5)
+
+        assert_array_almost_equal(xp.abs(response),
+                xp.asarray([0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0]), decimal=5)
 
         taps_str = firwin(ntaps, pass_zero='bandpass', **kwargs)
         xp_assert_close(taps, taps_str)
 
-    def test_bandstop_multi(self):
+    def test_bandstop_multi(self, xp):
         width = 0.04
         ntaps, beta = kaiserord(120, width)
-        kwargs = dict(cutoff=[0.2, 0.5, 0.8], window=('kaiser', beta),
+        kwargs = dict(cutoff=xp.asarray([0.2, 0.5, 0.8]), window=('kaiser', beta),
                       scale=False)
         taps = firwin(ntaps, **kwargs)
 
         # Check the symmetry of taps.
-        assert_array_almost_equal(taps[:ntaps//2], taps[ntaps:ntaps-ntaps//2-1:-1])
+        assert_array_almost_equal(taps[:ntaps//2], xp.flip(taps)[:ntaps//2])
 
         # Check the gain at a few samples where
         # we know it should be approximately 0 or 1.
-        freq_samples = np.array([0.0, 0.1, 0.2-width/2, 0.2+width/2, 0.35,
-                                0.5-width/2, 0.5+width/2, 0.65,
-                                0.8-width/2, 0.8+width/2, 0.9, 1.0])
+        freq_samples = xp.asarray([0.0, 0.1, 0.2 - width/2, 0.2 + width/2, 0.35,
+                                   0.5 - width/2, 0.5 + width/2, 0.65,
+                                   0.8 - width/2, 0.8 + width/2, 0.9, 1.0])
         freqs, response = freqz(taps, worN=np.pi*freq_samples)
-        assert_array_almost_equal(np.abs(response),
-                [1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0],
-                decimal=5)
+
+        assert_array_almost_equal(
+            xp.abs(response),
+            xp.asarray([1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0]),
+            decimal=5
+        )
 
         taps_str = firwin(ntaps, pass_zero='bandstop', **kwargs)
         xp_assert_close(taps, taps_str)
 
-    def test_fs_nyq(self):
+    def test_fs_nyq(self, xp):
         """Test the fs and nyq keywords."""
         nyquist = 1000
         width = 40.0
         relative_width = width/nyquist
         ntaps, beta = kaiserord(120, relative_width)
-        taps = firwin(ntaps, cutoff=[300, 700], window=('kaiser', beta),
+        taps = firwin(ntaps, cutoff=xp.asarray([300, 700]), window=('kaiser', beta),
                         pass_zero=False, scale=False, fs=2*nyquist)
 
         # Check the symmetry of taps.
-        assert_array_almost_equal(taps[:ntaps//2], taps[ntaps:ntaps-ntaps//2-1:-1])
+        assert_array_almost_equal(taps[:ntaps//2], xp.flip(taps)[:ntaps//2])
 
         # Check the gain at a few samples where
         # we know it should be approximately 0 or 1.
-        freq_samples = np.array([0.0, 200, 300-width/2, 300+width/2, 500,
-                                700-width/2, 700+width/2, 800, 1000])
+        freq_samples = xp.asarray([0.0, 200, 300 - width/2, 300 + width/2, 500,
+                                   700 - width/2, 700 + width/2, 800, 1000])
         freqs, response = freqz(taps, worN=np.pi*freq_samples/nyquist)
-        assert_array_almost_equal(np.abs(response),
-                [0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0], decimal=5)
+
+        assert_array_almost_equal(xp.abs(response),
+                xp.asarray([0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0]), decimal=5)
+
+    def test_array_cutoff(self, xp):
+        taps = firwin(3, xp.asarray([.1, .2]))
+        # smoke test against the value computed by scipy==1.5.2
+        xp_assert_close(
+            taps, xp.asarray([-0.00801395, 1.0160279, -0.00801395]), atol=1e-8
+        )
 
     def test_bad_cutoff(self):
         """Test that invalid cutoff argument raises ValueError."""
@@ -265,9 +292,9 @@ class TestFirWinMore:
 
     def test_bad_pass_zero(self):
         """Test degenerate pass_zero cases."""
-        with assert_raises(ValueError, match='pass_zero must be'):
+        with assert_raises(ValueError, match="^Parameter pass_zero='foo' not in "):
             firwin(41, 0.5, pass_zero='foo')
-        with assert_raises(TypeError, match='cannot be interpreted'):
+        with assert_raises(ValueError, match="^Parameter pass_zero=1.0 not in "):
             firwin(41, 0.5, pass_zero=1.)
         for pass_zero in ('lowpass', 'highpass'):
             with assert_raises(ValueError, match='cutoff must have one'):
@@ -281,6 +308,7 @@ class TestFirWinMore:
             firwin2(51, .5, 1, fs=np.array([10, 20]))
 
 
+@skip_xp_backends(cpu_only=True, reason="firwin2 uses np.interp")
 class TestFirwin2:
 
     def test_invalid_args(self):
@@ -330,90 +358,117 @@ class TestFirwin2:
         with assert_raises(ValueError, match='Type IV filter'):
             firwin2(16, [0.0, 0.5, 1.0], [1.0, 1.0, 0.0], antisymmetric=True)
 
-    def test01(self):
+    def test01(self, xp):
         width = 0.04
         beta = 12.0
         ntaps = 400
         # Filter is 1 from w=0 to w=0.5, then decreases linearly from 1 to 0 as w
         # increases from w=0.5 to w=1  (w=1 is the Nyquist frequency).
-        freq = [0.0, 0.5, 1.0]
-        gain = [1.0, 1.0, 0.0]
+        freq = xp.asarray([0.0, 0.5, 1.0])
+        gain = xp.asarray([1.0, 1.0, 0.0])
         taps = firwin2(ntaps, freq, gain, window=('kaiser', beta))
-        freq_samples = np.array([0.0, 0.25, 0.5-width/2, 0.5+width/2,
-                                                        0.75, 1.0-width/2])
+        freq_samples = xp.asarray([0.0, 0.25, 0.5 - width/2, 0.5 + width/2,
+                                                        0.75, 1.0 - width/2])
         freqs, response = freqz(taps, worN=np.pi*freq_samples)
-        assert_array_almost_equal(np.abs(response),
-                        [1.0, 1.0, 1.0, 1.0-width, 0.5, width], decimal=5)
-
-    def test02(self):
+        freqs, response = xp.asarray(freqs), xp.asarray(response)
+        assert_array_almost_equal(
+            xp.abs(response),
+            xp.asarray([1.0, 1.0, 1.0, 1.0 - width, 0.5, width]), decimal=5
+        )
+
+    @skip_xp_backends("jax.numpy", reason="immutable arrays")
+    def test02(self, xp):
         width = 0.04
         beta = 12.0
         # ntaps must be odd for positive gain at Nyquist.
         ntaps = 401
         # An ideal highpass filter.
-        freq = [0.0, 0.5, 0.5, 1.0]
-        gain = [0.0, 0.0, 1.0, 1.0]
+        freq = xp.asarray([0.0, 0.5, 0.5, 1.0])
+        gain = xp.asarray([0.0, 0.0, 1.0, 1.0])
         taps = firwin2(ntaps, freq, gain, window=('kaiser', beta))
-        freq_samples = np.array([0.0, 0.25, 0.5-width, 0.5+width, 0.75, 1.0])
+        freq_samples = np.array([0.0, 0.25, 0.5 - width, 0.5 + width, 0.75, 1.0])
         freqs, response = freqz(taps, worN=np.pi*freq_samples)
-        assert_array_almost_equal(np.abs(response),
-                                [0.0, 0.0, 0.0, 1.0, 1.0, 1.0], decimal=5)
-
-    def test03(self):
+        freqs, response = xp.asarray(freqs), xp.asarray(response)
+        assert_array_almost_equal(
+            xp.abs(response),
+            xp.asarray([0.0, 0.0, 0.0, 1.0, 1.0, 1.0]), decimal=5
+        )
+
+    @skip_xp_backends("jax.numpy", reason="immutable arrays")
+    def test03(self, xp):
         width = 0.02
         ntaps, beta = kaiserord(120, width)
         # ntaps must be odd for positive gain at Nyquist.
         ntaps = int(ntaps) | 1
-        freq = [0.0, 0.4, 0.4, 0.5, 0.5, 1.0]
-        gain = [1.0, 1.0, 0.0, 0.0, 1.0, 1.0]
+        freq = xp.asarray([0.0, 0.4, 0.4, 0.5, 0.5, 1.0])
+        gain = xp.asarray([1.0, 1.0, 0.0, 0.0, 1.0, 1.0])
         taps = firwin2(ntaps, freq, gain, window=('kaiser', beta))
-        freq_samples = np.array([0.0, 0.4-width, 0.4+width, 0.45,
-                                    0.5-width, 0.5+width, 0.75, 1.0])
+        freq_samples = np.array([0.0, 0.4 - width, 0.4 + width, 0.45,
+                                    0.5 - width, 0.5 + width, 0.75, 1.0])
         freqs, response = freqz(taps, worN=np.pi*freq_samples)
-        assert_array_almost_equal(np.abs(response),
-                    [1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0], decimal=5)
-
-    def test04(self):
+        freqs, response = xp.asarray(freqs), xp.asarray(response)
+        assert_array_almost_equal(
+            xp.abs(response),
+            xp.asarray([1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0]), decimal=5
+        )
+
+    @skip_xp_backends("jax.numpy", reason="immutable arrays")
+    def test04(self, xp):
         """Test firwin2 when window=None."""
         ntaps = 5
         # Ideal lowpass: gain is 1 on [0,0.5], and 0 on [0.5, 1.0]
-        freq = [0.0, 0.5, 0.5, 1.0]
-        gain = [1.0, 1.0, 0.0, 0.0]
+        freq = xp.asarray([0.0, 0.5, 0.5, 1.0])
+        gain = xp.asarray([1.0, 1.0, 0.0, 0.0])
+
         taps = firwin2(ntaps, freq, gain, window=None, nfreqs=8193)
         alpha = 0.5 * (ntaps - 1)
-        m = np.arange(0, ntaps) - alpha
-        h = 0.5 * sinc(0.5 * m)
+        m = xp.arange(0, ntaps, dtype=freq.dtype) - alpha
+        h = 0.5 * xpx.sinc(0.5 * m)
         assert_array_almost_equal(h, taps)
 
-    def test05(self):
+    def test05(self, xp):
         """Test firwin2 for calculating Type IV filters"""
         ntaps = 1500
 
-        freq = [0.0, 1.0]
-        gain = [0.0, 1.0]
+        freq = xp.asarray([0.0, 1.0])
+        gain = xp.asarray([0.0, 1.0])
         taps = firwin2(ntaps, freq, gain, window=None, antisymmetric=True)
-        assert_array_almost_equal(taps[: ntaps // 2], -taps[ntaps // 2:][::-1])
 
-        freqs, response = freqz(taps, worN=2048)
-        assert_array_almost_equal(abs(response), freqs / np.pi, decimal=4)
+        flip = array_namespace(freq).flip
+        dec = {'decimal': 4.5} if xp_default_dtype(xp) == xp.float32 else {}
+        assert_array_almost_equal(taps[: ntaps // 2], flip(-taps[ntaps // 2:]), **dec)
 
-    def test06(self):
+        freqs, response = freqz(np.asarray(taps), worN=2048)    # XXX convert freqz
+        assert_array_almost_equal(abs(xp.asarray(response)),
+                                  xp.asarray(freqs / np.pi), decimal=4)
+
+    @skip_xp_backends("jax.numpy", reason="immutable arrays")
+    def test06(self, xp):
         """Test firwin2 for calculating Type III filters"""
         ntaps = 1501
 
-        freq = [0.0, 0.5, 0.55, 1.0]
-        gain = [0.0, 0.5, 0.0, 0.0]
+        freq = xp.asarray([0.0, 0.5, 0.55, 1.0])
+        gain = xp.asarray([0.0, 0.5, 0.0, 0.0])
         taps = firwin2(ntaps, freq, gain, window=None, antisymmetric=True)
         assert taps[ntaps // 2] == 0.0
-        assert_array_almost_equal(taps[: ntaps // 2], -taps[ntaps // 2 + 1:][::-1])
 
-        freqs, response1 = freqz(taps, worN=2048)
-        response2 = np.interp(freqs / np.pi, freq, gain)
+        flip = array_namespace(freq).flip
+        dec = {'decimal': 4.5} if xp_default_dtype(xp) == xp.float32 else {}
+        assert_array_almost_equal(taps[: ntaps // 2],
+                                  flip(-taps[ntaps // 2 + 1:]), **dec
+        )
+
+        freqs, response1 = freqz(np.asarray(taps), worN=2048)  # XXX convert freqz
+        response1 = xp.asarray(response1)
+        response2 = xp.asarray(
+            np.interp(np.asarray(freqs) / np.pi, np.asarray(freq), np.asarray(gain))
+        )
         assert_array_almost_equal(abs(response1), response2, decimal=3)
 
-    def test_fs_nyq(self):
-        taps1 = firwin2(80, [0.0, 0.5, 1.0], [1.0, 1.0, 0.0])
-        taps2 = firwin2(80, [0.0, 30.0, 60.0], [1.0, 1.0, 0.0], fs=120.0)
+    def test_fs_nyq(self, xp):
+        taps1 = firwin2(80, xp.asarray([0.0, 0.5, 1.0]), xp.asarray([1.0, 1.0, 0.0]))
+        taps2 = firwin2(80, xp.asarray([0.0, 30.0, 60.0]), xp.asarray([1.0, 1.0, 0.0]),
+                        fs=120.0)
         assert_array_almost_equal(taps1, taps2)
 
     def test_tuple(self):
@@ -421,13 +476,15 @@ class TestFirwin2:
         taps2 = firwin2(150, [0.0, 0.5, 0.5, 1.0], [1.0, 1.0, 0.0, 0.0])
         assert_array_almost_equal(taps1, taps2)
 
-    def test_input_modyfication(self):
-        freq1 = np.array([0.0, 0.5, 0.5, 1.0])
-        freq2 = np.array(freq1)
-        firwin2(80, freq1, [1.0, 1.0, 0.0, 0.0])
+    @skip_xp_backends("jax.numpy", reason="immutable arrays")
+    def test_input_modyfication(self, xp):
+        freq1 = xp.asarray([0.0, 0.5, 0.5, 1.0])
+        freq2 = xp.asarray(freq1)
+        firwin2(80, freq1, xp.asarray([1.0, 1.0, 0.0, 0.0]))
         xp_assert_equal(freq1, freq2)
 
 
+@skip_xp_backends(cpu_only=True)
 class TestRemez:
 
     def test_bad_args(self):
@@ -462,14 +519,15 @@ class TestRemez:
         idx = np.logical_and(f > a, f < 0.5-a)
         assert (abs(Hmag[idx] - 1) < 0.015).all(), "Pass Band Close To Unity"
 
-    def test_compare(self):
+    def test_compare(self, xp):
         # test comparison to MATLAB
         k = [0.024590270518440, -0.041314581814658, -0.075943803756711,
              -0.003530911231040, 0.193140296954975, 0.373400753484939,
              0.373400753484939, 0.193140296954975, -0.003530911231040,
              -0.075943803756711, -0.041314581814658, 0.024590270518440]
-        h = remez(12, [0, 0.3, 0.5, 1], [1, 0], fs=2.)
-        xp_assert_close(h, k)
+        h = remez(12, xp.asarray([0, 0.3, 0.5, 1]), xp.asarray([1, 0]), fs=2.)
+        atol_arg = {'atol': 1e-8} if xp_default_dtype(xp) == xp.float32 else {}
+        xp_assert_close(h, xp.asarray(k, dtype=xp.float64), **atol_arg)
 
         h = [-0.038976016082299, 0.018704846485491, -0.014644062687875,
              0.002879152556419, 0.016849978528150, -0.043276706138248,
@@ -478,12 +536,19 @@ class TestRemez:
              0.129770906801075, -0.103908158578635, 0.073641298245579,
              -0.043276706138248, 0.016849978528150, 0.002879152556419,
              -0.014644062687875, 0.018704846485491, -0.038976016082299]
-        xp_assert_close(remez(21, [0, 0.8, 0.9, 1], [0, 1], fs=2.), h)
+        atol_arg = {'atol': 3e-8} if xp_default_dtype(xp) == xp.float32 else {}
+        xp_assert_close(
+            remez(21, xp.asarray([0, 0.8, 0.9, 1]), xp.asarray([0, 1]), fs=2.),
+            xp.asarray(h, dtype=xp.float64), **atol_arg
+        )
 
     def test_fs_validation(self):
         with pytest.raises(ValueError, match="Sampling.*single scalar"):
             remez(11, .1, 1, fs=np.array([10, 20]))
 
+
+
+@skip_xp_backends(cpu_only=True, reason="lstsq")
 class TestFirls:
 
     def test_bad_args(self):
@@ -505,105 +570,121 @@ class TestFirls:
         # negative weight
         assert_raises(ValueError, firls, 11, [0.1, 0.2], [0, 0], weight=[-1])
 
-    def test_firls(self):
+    @skip_xp_backends("dask.array", reason="dask fancy indexing shape=(nan,)")
+    def test_firls(self, xp):
         N = 11  # number of taps in the filter
         a = 0.1  # width of the transition band
 
         # design a halfband symmetric low-pass filter
-        h = firls(11, [0, a, 0.5-a, 0.5], [1, 1, 0, 0], fs=1.0)
+        h = firls(11, xp.asarray([0, a, 0.5 - a, 0.5]), xp.asarray([1, 1, 0, 0]),
+                  fs=1.0)
 
         # make sure the filter has correct # of taps
         assert h.shape[0] == N
 
         # make sure it is symmetric
         midx = (N-1) // 2
-        assert_array_almost_equal(h[:midx], h[:-midx-1:-1])
+        flip = array_namespace(h).flip
+        assert_array_almost_equal(h[:midx],  flip(h[midx+1:])) # h[:-midx-1:-1])
 
         # make sure the center tap is 0.5
-        assert_almost_equal(h[midx], 0.5)
+        assert math.isclose(h[midx], 0.5, abs_tol=1e-8) 
 
         # For halfband symmetric, odd coefficients (except the center)
         # should be zero (really small)
-        hodd = np.hstack((h[1:midx:2], h[-midx+1::2]))
-        assert_array_almost_equal(hodd, np.zeros_like(hodd))
+        hodd = xp.stack((h[1:midx:2], h[-midx+1::2]))
+        assert_array_almost_equal(hodd, xp.zeros_like(hodd))
 
         # now check the frequency response
-        w, H = freqz(h, 1)
-        f = w/2/np.pi
-        Hmag = np.abs(H)
+        w, H = freqz(np.asarray(h), 1)
+        w, H = xp.asarray(w), xp.asarray(H)
+        f = w/2/xp.pi
+        Hmag = xp.abs(H)
 
         # check that the pass band is close to unity
-        idx = np.logical_and(f > 0, f < a)
-        assert_array_almost_equal(Hmag[idx], np.ones_like(Hmag[idx]), decimal=3)
+        idx = xp.logical_and(f > 0, f < a)
+        assert_array_almost_equal(Hmag[idx], xp.ones_like(Hmag[idx]), decimal=3)
 
         # check that the stop band is close to zero
-        idx = np.logical_and(f > 0.5-a, f < 0.5)
-        assert_array_almost_equal(Hmag[idx], np.zeros_like(Hmag[idx]), decimal=3)
+        idx = xp.logical_and(f > 0.5 - a, f < 0.5)
+        assert_array_almost_equal(Hmag[idx], xp.zeros_like(Hmag[idx]), decimal=3)
 
-    def test_compare(self):
+    def test_compare(self, xp):
         # compare to OCTAVE output
-        taps = firls(9, [0, 0.5, 0.55, 1], [1, 1, 0, 0], weight=[1, 2])
+        taps = firls(9, xp.asarray([0, 0.5, 0.55, 1]),
+                    xp.asarray([1, 1, 0, 0]), weight=xp.asarray([1, 2]))
         # >> taps = firls(8, [0 0.5 0.55 1], [1 1 0 0], [1, 2]);
         known_taps = [-6.26930101730182e-04, -1.03354450635036e-01,
                       -9.81576747564301e-03, 3.17271686090449e-01,
                       5.11409425599933e-01, 3.17271686090449e-01,
                       -9.81576747564301e-03, -1.03354450635036e-01,
                       -6.26930101730182e-04]
-        xp_assert_close(taps, known_taps)
+        atol_arg = {'atol': 5e-8} if xp_default_dtype(xp) == xp.float32 else {}
+        known_taps = xp.asarray(known_taps, dtype=xp.float64)
+        xp_assert_close(taps, known_taps, **atol_arg)
 
         # compare to MATLAB output
-        taps = firls(11, [0, 0.5, 0.5, 1], [1, 1, 0, 0], weight=[1, 2])
+        taps = firls(11, xp.asarray([0, 0.5, 0.5, 1]),
+                     xp.asarray([1, 1, 0, 0]), weight=xp.asarray([1, 2]))
         # >> taps = firls(10, [0 0.5 0.5 1], [1 1 0 0], [1, 2]);
         known_taps = [
             0.058545300496815, -0.014233383714318, -0.104688258464392,
             0.012403323025279, 0.317930861136062, 0.488047220029700,
             0.317930861136062, 0.012403323025279, -0.104688258464392,
             -0.014233383714318, 0.058545300496815]
-        xp_assert_close(taps, known_taps)
+        known_taps = xp.asarray(known_taps, dtype=xp.float64)
+        atol_arg = {'atol': 3e-8} if xp_default_dtype(xp) == xp.float32 else {}
+        xp_assert_close(taps, known_taps, **atol_arg)
 
         # With linear changes:
-        taps = firls(7, (0, 1, 2, 3, 4, 5), [1, 0, 0, 1, 1, 0], fs=20)
+        taps = firls(7, xp.asarray((0, 1, 2, 3, 4, 5)),
+                     xp.asarray([1, 0, 0, 1, 1, 0]), fs=20)
         # >> taps = firls(6, [0, 0.1, 0.2, 0.3, 0.4, 0.5], [1, 0, 0, 1, 1, 0])
         known_taps = [
             1.156090832768218, -4.1385894727395849, 7.5288619164321826,
             -8.5530572592947856, 7.5288619164321826, -4.1385894727395849,
             1.156090832768218]
+        known_taps = xp.asarray(known_taps, dtype=xp.float64)
         xp_assert_close(taps, known_taps)
 
-    def test_rank_deficient(self):
+    def test_rank_deficient(self, xp):
         # solve() runs but warns (only sometimes, so here we don't use match)
-        x = firls(21, [0, 0.1, 0.9, 1], [1, 1, 0, 0])
-        w, h = freqz(x, fs=2.)
-        absh2 = np.abs(h[:2])
-        xp_assert_close(absh2, np.ones_like(absh2), atol=1e-5)
-        absh2 = np.abs(h[-2:])
-        xp_assert_close(absh2, np.zeros_like(absh2), atol=1e-6, rtol=1e-7)
+        x = firls(21, xp.asarray([0, 0.1, 0.9, 1]), xp.asarray([1, 1, 0, 0]))
+        w, h = freqz(np.asarray(x), fs=2.)
+        w, h = map(xp.asarray, (w, h))   # XXX convert freqz
+        absh2 = xp.abs(h[:2])
+        xp_assert_close(absh2, xp.ones_like(absh2), atol=1e-5)
+        absh2 = xp.abs(h[-2:])
+        xp_assert_close(absh2, xp.zeros_like(absh2), atol=1e-6, rtol=1e-7)
         # switch to pinvh (tolerances could be higher with longer
         # filters, but using shorter ones is faster computationally and
         # the idea is the same)
-        x = firls(101, [0, 0.01, 0.99, 1], [1, 1, 0, 0])
-        w, h = freqz(x, fs=2.)
-        mask = w < 0.01
-        assert mask.sum() > 3
-        habs = np.abs(h[mask])
-        xp_assert_close(habs, np.ones_like(habs), atol=1e-4)
-        mask = w > 0.99
-        assert mask.sum() > 3
-        habs = np.abs(h[mask])
-        xp_assert_close(habs, np.zeros_like(habs), atol=1e-4)
+        x = firls(101, xp.asarray([0, 0.01, 0.99, 1]), xp.asarray([1, 1, 0, 0]))
+        w, h = freqz(np.asarray(x), fs=2.)
+        w, h = map(xp.asarray, (w, h))   # XXX convert freqz
+        mask = xp.asarray(w < 0.01)
+        h = xp.asarray(h)
+        assert xp.sum(xp.astype(mask, xp.int64)) > 3
+        habs = xp.abs(h[mask])
+        xp_assert_close(habs, xp.ones_like(habs), atol=1e-4)
+        mask = xp.asarray(w > 0.99)
+        assert xp.sum(xp.astype(mask, xp.int64)) > 3
+        habs = xp.abs(h[mask])
+        xp_assert_close(habs, xp.zeros_like(habs), atol=1e-4)
 
     def test_fs_validation(self):
         with pytest.raises(ValueError, match="Sampling.*single scalar"):
             firls(11, .1, 1, fs=np.array([10, 20]))
 
 class TestMinimumPhase:
+
     @pytest.mark.thread_unsafe
     def test_bad_args(self):
         # not enough taps
         assert_raises(ValueError, minimum_phase, [1.])
         assert_raises(ValueError, minimum_phase, [1., 1.])
         assert_raises(ValueError, minimum_phase, np.full(10, 1j))
-        assert_raises(ValueError, minimum_phase, 'foo')
+        assert_raises((ValueError, TypeError), minimum_phase, 'foo')
         assert_raises(ValueError, minimum_phase, np.ones(10), n_fft=8)
         assert_raises(ValueError, minimum_phase, np.ones(10), method='foo')
         assert_warns(RuntimeWarning, minimum_phase, np.arange(3))
@@ -630,7 +711,9 @@ class TestMinimumPhase:
             assert len(h_linear) == len(h_new)
             xp_assert_close(np.abs(fft(h_new)), np.abs(fft(h_linear)), rtol=1e-4)
 
-    def test_hilbert(self):
+    @skip_xp_backends("dask.array", reason="too slow")
+    @skip_xp_backends("jax.numpy", reason="immutable arrays")
+    def test_hilbert(self, xp):
         # compare to MATLAB output of reference implementation
 
         # f=[0 0.3 0.5 1];
@@ -639,6 +722,8 @@ class TestMinimumPhase:
         h = remez(12, [0, 0.3, 0.5, 1], [1, 0], fs=2.)
         k = [0.349585548646686, 0.373552164395447, 0.326082685363438,
              0.077152207480935, -0.129943946349364, -0.059355880509749]
+        h = xp.asarray(h)
+        k = xp.asarray(k, dtype=xp.float64)
         m = minimum_phase(h, 'hilbert')
         xp_assert_close(m, k, rtol=5e-3)
 
@@ -650,5 +735,112 @@ class TestMinimumPhase:
              -0.157957283165866, 0.151739294892963, -0.129293146705090,
              0.100787844523204, -0.065832656741252, 0.035361328741024,
              -0.014977068692269, -0.158416139047557]
+        h = xp.asarray(h)
+        k = xp.asarray(k, dtype=xp.float64)
         m = minimum_phase(h, 'hilbert', n_fft=2**19)
         xp_assert_close(m, k, rtol=2e-3)
+
+
+class Testfirwin_2d:
+    def test_invalid_args(self):
+        with pytest.raises(ValueError,
+                           match="hsize must be a 2-element tuple or list"):
+            firwin_2d((50,), window=(("kaiser", 5.0), "boxcar"), fc=0.4)
+
+        with pytest.raises(ValueError,
+                           match="window must be a 2-element tuple or list"):
+            firwin_2d((51, 51), window=("hamming",), fc=0.5)
+
+        with pytest.raises(ValueError,
+                           match="window must be a 2-element tuple or list"):
+            firwin_2d((51, 51), window="invalid_window", fc=0.5)
+
+    def test_filter_design(self):
+        hsize = (51, 51)
+        window = (("kaiser", 8.0), ("kaiser", 8.0))
+        fc = 0.4
+        taps_kaiser = firwin_2d(hsize, window, fc=fc)
+        assert taps_kaiser.shape == (51, 51)
+
+        window = ("hamming", "hamming")
+        taps_hamming = firwin_2d(hsize, window, fc=fc)
+        assert taps_hamming.shape == (51, 51)
+
+    def test_impulse_response(self):
+        hsize = (31, 31)
+        window = ("hamming", "hamming")
+        fc = 0.4
+        taps = firwin_2d(hsize, window, fc=fc)
+
+        impulse = np.zeros((63, 63))
+        impulse[31, 31] = 1
+
+        response = convolve2d(impulse, taps, mode='same')
+
+        expected_response = taps
+        xp_assert_close(response[16:47, 16:47], expected_response, rtol=1e-5)
+
+    def test_frequency_response(self):
+        """Compare 1d and 2d frequency response. """
+        hsize = (31, 31)
+        windows = ("hamming", "hamming")
+        fc = 0.4
+        taps_1d = firwin(numtaps=hsize[0], cutoff=fc, window=windows[0])
+        taps_2d = firwin_2d(hsize, windows, fc=fc)
+
+        f_resp_1d = fft(taps_1d)
+        f_resp_2d = fft2(taps_2d)
+
+        xp_assert_close(f_resp_2d[0, :], f_resp_1d,
+                        err_msg='DC Gain at (0, f1) is not unity!')
+        xp_assert_close(f_resp_2d[:, 0], f_resp_1d,
+                        err_msg='DC Gain at (f0, 0) is not unity!')
+        xp_assert_close(f_resp_2d, np.outer(f_resp_1d, f_resp_1d),
+                        atol=np.finfo(f_resp_2d.dtype).resolution,
+                        err_msg='2d frequency response is not product of 1d responses')
+
+    def test_symmetry(self):
+        hsize = (51, 51)
+        window = ("hamming", "hamming")
+        fc = 0.4
+        taps = firwin_2d(hsize, window, fc=fc)
+        xp_assert_close(taps, np.flip(taps), rtol=1e-5)
+
+    def test_circular_symmetry(self):
+        hsize = (51, 51)
+        window = "hamming"
+        taps = firwin_2d(hsize, window, circular=True, fc=0.5)
+        center = hsize[0] // 2
+        for i in range(hsize[0]):
+            for j in range(hsize[1]):
+                xp_assert_close(taps[i, j], 
+                                taps[center - (i - center), center - (j - center)], 
+                                rtol=1e-5)
+
+    def test_edge_case_circular(self):
+        hsize = (3, 3)
+        window = "hamming"
+        taps_small = firwin_2d(hsize, window, circular=True, fc=0.5)
+        assert taps_small.shape == (3, 3)
+
+        hsize = (101, 101)
+        taps_large = firwin_2d(hsize, window, circular=True, fc=0.5)
+        assert taps_large.shape == (101, 101)
+
+    def test_known_result(self):
+        hsize = (5, 5)
+        window = ('kaiser', 8.0)
+        fc = 0.1
+        fs = 2
+
+        row_filter = firwin(hsize[0], cutoff=fc, window=window, fs=fs)
+        col_filter = firwin(hsize[1], cutoff=fc, window=window, fs=fs)
+        known_result = np.outer(row_filter, col_filter)
+
+        taps = firwin_2d(hsize, (window, window), fc=fc)
+        assert taps.shape == known_result.shape, (
+            f"Shape mismatch: {taps.shape} vs {known_result.shape}"
+        )
+        assert np.allclose(taps, known_result, rtol=1e-1), (
+            f"Filter shape mismatch: {taps} vs {known_result}"
+        )