MAINT: filter windows only accept ints, not array_likes

Author: ev-br

torch_np/_funcs.py

@@ -1913,35 +1913,30 @@ def __getitem__(self, item):
 
 
 @normalizer
-def hamming(M: ArrayLike):
-    M = int(M.item())
+def hamming(M):
     dtype = _dtypes_impl.default_float_dtype
     return torch.hamming_window(M, periodic=False, dtype=dtype)
 
 
 @normalizer
-def hanning(M: ArrayLike):
-    M = int(M.item())
+def hanning(M):
     dtype = _dtypes_impl.default_float_dtype
     return torch.hann_window(M, periodic=False, dtype=dtype)
 
 
 @normalizer
-def kaiser(M: ArrayLike, beta):
-    M = int(M.item())
+def kaiser(M, beta):
     dtype = _dtypes_impl.default_float_dtype
     return torch.kaiser_window(M, beta=beta, periodic=False, dtype=dtype)
 
 
 @normalizer
-def blackman(M: ArrayLike):
-    M = int(M.item())
+def blackman(M):
     dtype = _dtypes_impl.default_float_dtype
     return torch.blackman_window(M, periodic=False, dtype=dtype)
 
 
 @normalizer
-def bartlett(M: ArrayLike):
-    M = int(M.item())
+def bartlett(M):
     dtype = _dtypes_impl.default_float_dtype
     return torch.bartlett_window(M, periodic=False, dtype=dtype)

torch_np/tests/numpy_tests/lib/test_function_base.py

@@ -1709,10 +1709,10 @@ def test_period(self):
 class TestFilterwindows:
 
     def test_hanning(self, dtype: str, M: int) -> None:
-        scalar = np.array(M, dtype=dtype)[()]
+        scalar = M
 
         w = hanning(scalar)
-        ref_dtype = np.result_type(scalar.dtype, np.float64)
+        ref_dtype = np.result_type(dtype, np.float64)
         assert w.dtype == ref_dtype
 
         # check symmetry
@@ -1727,10 +1727,10 @@ def test_hanning(self, dtype: str, M: int) -> None:
             assert_almost_equal(np.sum(w, axis=0), 4.500, 4)
 
     def test_hamming(self, dtype: str, M: int) -> None:
-        scalar = np.array(M, dtype=dtype)[()]
+        scalar = M
 
         w = hamming(scalar)
-        ref_dtype = np.result_type(scalar.dtype, np.float64)
+        ref_dtype = np.result_type(dtype, np.float64)
         assert w.dtype == ref_dtype
 
         # check symmetry
@@ -1745,10 +1745,10 @@ def test_hamming(self, dtype: str, M: int) -> None:
             assert_almost_equal(np.sum(w, axis=0), 4.9400, 4)
 
     def test_bartlett(self, dtype: str, M: int) -> None:
-        scalar = np.array(M, dtype=dtype)[()]
+        scalar = M
 
         w = bartlett(scalar)
-        ref_dtype = np.result_type(scalar.dtype, np.float64)
+        ref_dtype = np.result_type(dtype, np.float64)
         assert w.dtype == ref_dtype
 
         # check symmetry
@@ -1763,10 +1763,10 @@ def test_bartlett(self, dtype: str, M: int) -> None:
             assert_almost_equal(np.sum(w, axis=0), 4.4444, 4)
 
     def test_blackman(self, dtype: str, M: int) -> None:
-        scalar = np.array(M, dtype=dtype)[()]
+        scalar = M
 
         w = blackman(scalar)
-        ref_dtype = np.result_type(scalar.dtype, np.float64)
+        ref_dtype = np.result_type(dtype, np.float64)
         assert w.dtype == ref_dtype
 
         # check symmetry
@@ -1781,10 +1781,10 @@ def test_blackman(self, dtype: str, M: int) -> None:
             assert_almost_equal(np.sum(w, axis=0), 3.7800, 4)
 
     def test_kaiser(self, dtype: str, M: int) -> None:
-        scalar = np.array(M, dtype=dtype)[()]
+        scalar = M
 
         w = kaiser(scalar, 0)
-        ref_dtype = np.result_type(scalar.dtype, np.float64)
+        ref_dtype = np.result_type(dtype, np.float64)
         assert w.dtype == ref_dtype
 
         # check symmetry