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

scipy/signal/windows/_windows.py

@@ -1,10 +1,14 @@
 """The suite of window functions."""
 
+import math
 import operator
 import warnings
+from scipy._lib import doccer
 
-import numpy as np
 from scipy import linalg, special, fft as sp_fft
+from scipy._lib.array_api_compat import numpy as np_compat
+from scipy._lib._array_api import array_namespace, xp_device
+from scipy._lib import array_api_extra as xpx
 
 __all__ = ['boxcar', 'triang', 'parzen', 'bohman', 'blackman', 'nuttall',
            'blackmanharris', 'flattop', 'bartlett', 'barthann',
@@ -37,6 +41,28 @@ def _truncate(w, needed):
         return w
 
 
+def _namespace(xp):
+    """A shim for the `device` arg of `np.asarray(x, device=device)` and acos/arccos.
+
+    Will be able to replace with `np_compat if xp is None else xp` when we drop
+    support for numpy 1.x and cupy 13.x
+    """
+    return np_compat if xp is None else array_namespace(xp.empty(0))
+
+
+def _general_cosine_impl(M, a, xp, device, sym=True):
+    if _len_guards(M):
+        return xp.ones(M, dtype=xp.float64, device=device)
+    M, needs_trunc = _extend(M, sym)
+
+    fac = xp.linspace(-xp.pi, xp.pi, M, dtype=xp.float64, device=device)
+    w = xp.zeros(M, dtype=xp.float64, device=device)
+    for k in range(a.shape[0]):
+        w += a[k] * xp.cos(k * fac)
+
+    return _truncate(w, needs_trunc)
+
+
 def general_cosine(M, a, sym=True):
     r"""
     Generic weighted sum of cosine terms window
@@ -113,19 +139,13 @@ def general_cosine(M, a, sym=True):
     >>> plt.axhline(-90.2, color='red')
     >>> plt.show()
     """
-    if _len_guards(M):
-        return np.ones(M)
-    M, needs_trunc = _extend(M, sym)
-
-    fac = np.linspace(-np.pi, np.pi, M)
-    w = np.zeros(M)
-    for k in range(len(a)):
-        w += a[k] * np.cos(k * fac)
-
-    return _truncate(w, needs_trunc)
+    xp = array_namespace(a)
+    a = xp.asarray(a)
+    device = xp_device(a)
+    return _general_cosine_impl(M, a, xp, device, sym=sym)
 
 
-def boxcar(M, sym=True):
+def boxcar(M, sym=True, *, xp=None, device=None):
     """Return a boxcar or rectangular window.
 
     Also known as a rectangular window or Dirichlet window, this is equivalent
@@ -138,6 +158,7 @@ def boxcar(M, sym=True):
         is returned. An exception is thrown when it is negative.
     sym : bool, optional
         Whether the window is symmetric. (Has no effect for boxcar.)
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -170,16 +191,18 @@ def boxcar(M, sym=True):
     >>> plt.xlabel("Normalized frequency [cycles per sample]")
 
     """
+    xp = _namespace(xp)
+
     if _len_guards(M):
-        return np.ones(M)
+        return xp.ones(M, dtype=xp.float64, device=device)
     M, needs_trunc = _extend(M, sym)
 
-    w = np.ones(M, float)
+    w = xp.ones(M, dtype=xp.float64, device=device)
 
     return _truncate(w, needs_trunc)
 
 
-def triang(M, sym=True):
+def triang(M, sym=True, *, xp=None, device=None):
     """Return a triangular window.
 
     Parameters
@@ -191,6 +214,7 @@ def triang(M, sym=True):
         When True (default), generates a symmetric window, for use in filter
         design.
         When False, generates a periodic window, for use in spectral analysis.
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -229,22 +253,24 @@ def triang(M, sym=True):
     >>> plt.xlabel("Normalized frequency [cycles per sample]")
 
     """
+    xp = _namespace(xp)
+
     if _len_guards(M):
-        return np.ones(M)
+        return xp.ones(M, dtype=xp.float64, device=device)
     M, needs_trunc = _extend(M, sym)
 
-    n = np.arange(1, (M + 1) // 2 + 1)
+    n = xp.arange(1, (M + 1) // 2 + 1, dtype=xp.float64, device=device)
     if M % 2 == 0:
         w = (2 * n - 1.0) / M
-        w = np.r_[w, w[::-1]]
+        w = xp.concat([w, xp.flip(w)])
     else:
         w = 2 * n / (M + 1.0)
-        w = np.r_[w, w[-2::-1]]
+        w = xp.concat([w, xp.flip(w[:-1])])
 
     return _truncate(w, needs_trunc)
 
 
-def parzen(M, sym=True):
+def parzen(M, sym=True, *, xp=None, device=None):
     """Return a Parzen window.
 
     Parameters
@@ -256,6 +282,7 @@ def parzen(M, sym=True):
         When True (default), generates a symmetric window, for use in filter
         design.
         When False, generates a periodic window, for use in spectral analysis.
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -294,22 +321,22 @@ def parzen(M, sym=True):
     >>> plt.xlabel("Normalized frequency [cycles per sample]")
 
     """
+    xp = _namespace(xp)
+
     if _len_guards(M):
-        return np.ones(M)
+        return xp.ones(M, dtype=xp.float64, device=device)
     M, needs_trunc = _extend(M, sym)
 
-    n = np.arange(-(M - 1) / 2.0, (M - 1) / 2.0 + 0.5, 1.0)
-    na = np.extract(n < -(M - 1) / 4.0, n)
-    nb = np.extract(abs(n) <= (M - 1) / 4.0, n)
-    wa = 2 * (1 - np.abs(na) / (M / 2.0)) ** 3.0
-    wb = (1 - 6 * (np.abs(nb) / (M / 2.0)) ** 2.0 +
-          6 * (np.abs(nb) / (M / 2.0)) ** 3.0)
-    w = np.r_[wa, wb, wa[::-1]]
-
+    n = xp.arange(-(M - 1) / 2.0, (M - 1) / 2.0 + 0.5, 1.0,
+                  dtype=xp.float64, device=device)
+    w = xp.where(abs(n) <= (M - 1) / 4.0,
+                 (1 - 6 * (abs(n) / (M / 2.0)) ** 2.0 +
+                  6 * (abs(n) / (M / 2.0)) ** 3.0),
+                 2 * (1 - abs(n) / (M / 2.0)) ** 3.0)
     return _truncate(w, needs_trunc)
 
 
-def bohman(M, sym=True):
+def bohman(M, sym=True, *, xp=None, device=None):
     """Return a Bohman window.
 
     Parameters
@@ -321,6 +348,7 @@ def bohman(M, sym=True):
         When True (default), generates a symmetric window, for use in filter
         design.
         When False, generates a periodic window, for use in spectral analysis.
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -354,18 +382,21 @@ def bohman(M, sym=True):
     >>> plt.xlabel("Normalized frequency [cycles per sample]")
 
     """
+    xp = _namespace(xp)
+
     if _len_guards(M):
-        return np.ones(M)
+        return xp.ones(M, dtype=xp.float64, device=device)
     M, needs_trunc = _extend(M, sym)
 
-    fac = np.abs(np.linspace(-1, 1, M)[1:-1])
-    w = (1 - fac) * np.cos(np.pi * fac) + 1.0 / np.pi * np.sin(np.pi * fac)
-    w = np.r_[0, w, 0]
+    fac = abs(xp.linspace(-1, 1, M, dtype=xp.float64, device=device)[1:-1])
+    w = (1 - fac) * xp.cos(xp.pi * fac) + 1.0 / xp.pi * xp.sin(xp.pi * fac)
+    one = xp.zeros(1, dtype=xp.float64, device=device)
+    w = xp.concat([one, w, one])
 
     return _truncate(w, needs_trunc)
 
 
-def blackman(M, sym=True):
+def blackman(M, sym=True, *, xp=None, device=None):
     r"""
     Return a Blackman window.
 
@@ -383,6 +414,7 @@ def blackman(M, sym=True):
         When True (default), generates a symmetric window, for use in filter
         design.
         When False, generates a periodic window, for use in spectral analysis.
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -448,10 +480,13 @@ def blackman(M, sym=True):
 
     """
     # Docstring adapted from NumPy's blackman function
-    return general_cosine(M, [0.42, 0.50, 0.08], sym)
+    xp = _namespace(xp)
+    a = xp.asarray([0.42, 0.50, 0.08], dtype=xp.float64, device=device)
+    device = xp_device(a)
+    return _general_cosine_impl(M, a, xp, device, sym=sym)
 
 
-def nuttall(M, sym=True):
+def nuttall(M, sym=True, *, xp=None, device=None):
     """Return a minimum 4-term Blackman-Harris window according to Nuttall.
 
     This variation is called "Nuttall4c" by Heinzel. [2]_
@@ -465,6 +500,7 @@ def nuttall(M, sym=True):
         When True (default), generates a symmetric window, for use in filter
         design.
         When False, generates a periodic window, for use in spectral analysis.
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -508,10 +544,15 @@ def nuttall(M, sym=True):
     >>> plt.xlabel("Normalized frequency [cycles per sample]")
 
     """
-    return general_cosine(M, [0.3635819, 0.4891775, 0.1365995, 0.0106411], sym)
+    xp = _namespace(xp)
+    a = xp.asarray(
+        [0.3635819, 0.4891775, 0.1365995, 0.0106411], dtype=xp.float64, device=device
+    )
+    device = xp_device(a)
+    return _general_cosine_impl(M, a, xp, device, sym=sym)
 
 
-def blackmanharris(M, sym=True):
+def blackmanharris(M, sym=True, *, xp=None, device=None):
     """Return a minimum 4-term Blackman-Harris window.
 
     Parameters
@@ -523,6 +564,7 @@ def blackmanharris(M, sym=True):
         When True (default), generates a symmetric window, for use in filter
         design.
         When False, generates a periodic window, for use in spectral analysis.
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -556,10 +598,15 @@ def blackmanharris(M, sym=True):
     >>> plt.xlabel("Normalized frequency [cycles per sample]")
 
     """
-    return general_cosine(M, [0.35875, 0.48829, 0.14128, 0.01168], sym)
+    xp = _namespace(xp)
+    a = xp.asarray(
+        [0.35875, 0.48829, 0.14128, 0.01168], dtype=xp.float64, device=device
+    )
+    device = xp_device(a)
+    return _general_cosine_impl(M, a, xp, device, sym=sym)
 
 
-def flattop(M, sym=True):
+def flattop(M, sym=True, *, xp=None, device=None):
     """Return a flat top window.
 
     Parameters
@@ -571,6 +618,7 @@ def flattop(M, sym=True):
         When True (default), generates a symmetric window, for use in filter
         design.
         When False, generates a periodic window, for use in spectral analysis.
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -618,11 +666,16 @@ def flattop(M, sym=True):
     >>> plt.xlabel("Normalized frequency [cycles per sample]")
 
     """
-    a = [0.21557895, 0.41663158, 0.277263158, 0.083578947, 0.006947368]
-    return general_cosine(M, a, sym)
+    xp = _namespace(xp)
+    a = xp.asarray(
+        [0.21557895, 0.41663158, 0.277263158, 0.083578947, 0.006947368],
+        dtype=xp.float64, device=device
+    )
+    device = xp_device(a)
+    return _general_cosine_impl(M, a, xp, device, sym=sym)
 
 
-def bartlett(M, sym=True):
+def bartlett(M, sym=True, *, xp=None, device=None):
     r"""
     Return a Bartlett window.
 
@@ -640,6 +693,7 @@ def bartlett(M, sym=True):
         When True (default), generates a symmetric window, for use in filter
         design.
         When False, generates a periodic window, for use in spectral analysis.
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -710,18 +764,22 @@ def bartlett(M, sym=True):
 
     """
     # Docstring adapted from NumPy's bartlett function
+    xp = _namespace(xp)
+
     if _len_guards(M):
-        return np.ones(M)
+        return xp.ones(M, dtype=xp.float64, device=device)
     M, needs_trunc = _extend(M, sym)
 
-    n = np.arange(0, M)
-    w = np.where(np.less_equal(n, (M - 1) / 2.0),
+    n = xp.arange(0, M, dtype=xp.float64, device=device)
+
+    # cf https://github.com/data-apis/array-api-strict/issues/77
+    w = xp.where(n <= (M - 1) / 2.0,
                  2.0 * n / (M - 1), 2.0 - 2.0 * n / (M - 1))
 
     return _truncate(w, needs_trunc)
 
 
-def hann(M, sym=True):
+def hann(M, sym=True, *, xp=None, device=None):
     r"""
     Return a Hann window.
 
@@ -737,6 +795,7 @@ def hann(M, sym=True):
         When True (default), generates a symmetric window, for use in filter
         design.
         When False, generates a periodic window, for use in spectral analysis.
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -801,10 +860,10 @@ def hann(M, sym=True):
 
     """
     # Docstring adapted from NumPy's hanning function
-    return general_hamming(M, 0.5, sym)
+    return general_hamming(M, 0.5, sym, xp=xp, device=device)
 
 
-def tukey(M, alpha=0.5, sym=True):
+def tukey(M, alpha=0.5, sym=True, *, xp=None, device=None):
     r"""Return a Tukey window, also known as a tapered cosine window.
 
     Parameters
@@ -821,6 +880,7 @@ def tukey(M, alpha=0.5, sym=True):
         When True (default), generates a symmetric window, for use in filter
         design.
         When False, generates a periodic window, for use in spectral analysis.
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -863,32 +923,34 @@ def tukey(M, alpha=0.5, sym=True):
     >>> plt.xlabel("Normalized frequency [cycles per sample]")
 
     """
+    xp = _namespace(xp)
+
     if _len_guards(M):
-        return np.ones(M)
+        return xp.ones(M, dtype=xp.float64, device=device)
 
     if alpha <= 0:
-        return np.ones(M, 'd')
+        return xp.ones(M, dtype=xp.float64, device=device)
     elif alpha >= 1.0:
-        return hann(M, sym=sym)
+        return hann(M, sym=sym, xp=xp, device=device)
 
     M, needs_trunc = _extend(M, sym)
 
-    n = np.arange(0, M)
-    width = int(np.floor(alpha*(M-1)/2.0))
+    n = xp.arange(0, M, dtype=xp.float64, device=device)
+    width = int(math.floor(alpha*(M-1)/2.0))
     n1 = n[0:width+1]
     n2 = n[width+1:M-width-1]
     n3 = n[M-width-1:]
 
-    w1 = 0.5 * (1 + np.cos(np.pi * (-1 + 2.0*n1/alpha/(M-1))))
-    w2 = np.ones(n2.shape)
-    w3 = 0.5 * (1 + np.cos(np.pi * (-2.0/alpha + 1 + 2.0*n3/alpha/(M-1))))
+    w1 = 0.5 * (1 + xp.cos(xp.pi * (-1 + 2.0*n1/alpha/(M-1))))
+    w2 = xp.ones(n2.shape, device=device)
+    w3 = 0.5 * (1 + xp.cos(xp.pi * (-2.0/alpha + 1 + 2.0*n3/alpha/(M-1))))
 
-    w = np.concatenate((w1, w2, w3))
+    w = xp.concat((w1, w2, w3))
 
     return _truncate(w, needs_trunc)
 
 
-def barthann(M, sym=True):
+def barthann(M, sym=True, *, xp=None, device=None):
     """Return a modified Bartlett-Hann window.
 
     Parameters
@@ -900,6 +962,7 @@ def barthann(M, sym=True):
         When True (default), generates a symmetric window, for use in filter
         design.
         When False, generates a periodic window, for use in spectral analysis.
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -933,18 +996,20 @@ def barthann(M, sym=True):
     >>> plt.xlabel("Normalized frequency [cycles per sample]")
 
     """
+    xp = _namespace(xp)
+
     if _len_guards(M):
-        return np.ones(M)
+        return xp.ones(M, dtype=xp.float64, device=device)
     M, needs_trunc = _extend(M, sym)
 
-    n = np.arange(0, M)
-    fac = np.abs(n / (M - 1.0) - 0.5)
-    w = 0.62 - 0.48 * fac + 0.38 * np.cos(2 * np.pi * fac)
+    n = xp.arange(0, M, dtype=xp.float64, device=device)
+    fac = abs(n / (M - 1.0) - 0.5)
+    w = 0.62 - 0.48 * fac + 0.38 * xp.cos(2 * xp.pi * fac)
 
     return _truncate(w, needs_trunc)
 
 
-def general_hamming(M, alpha, sym=True):
+def general_hamming(M, alpha, sym=True, *, xp=None, device=None):
     r"""Return a generalized Hamming window.
 
     The generalized Hamming window is constructed by multiplying a rectangular
@@ -961,6 +1026,7 @@ def general_hamming(M, alpha, sym=True):
         When True (default), generates a symmetric window, for use in filter
         design.
         When False, generates a periodic window, for use in spectral analysis.
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -1030,10 +1096,13 @@ def general_hamming(M, alpha, sym=True):
     >>> spatial_plot.legend(loc="upper right")
 
     """
-    return general_cosine(M, [alpha, 1. - alpha], sym)
+    xp = _namespace(xp)
+    a = xp.asarray([alpha, 1. - alpha], dtype=xp.float64, device=device)
+    device = xp_device(a)
+    return _general_cosine_impl(M, a, xp, device, sym=sym)
 
 
-def hamming(M, sym=True):
+def hamming(M, sym=True, *, xp=None, device=None):
     r"""Return a Hamming window.
 
     The Hamming window is a taper formed by using a raised cosine with
@@ -1048,6 +1117,7 @@ def hamming(M, sym=True):
         When True (default), generates a symmetric window, for use in filter
         design.
         When False, generates a periodic window, for use in spectral analysis.
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -1109,10 +1179,10 @@ def hamming(M, sym=True):
 
     """
     # Docstring adapted from NumPy's hamming function
-    return general_hamming(M, 0.54, sym)
+    return general_hamming(M, 0.54, sym, xp=xp, device=device)
 
 
-def kaiser(M, beta, sym=True):
+def kaiser(M, beta, sym=True, *, xp=None, device=None):
     r"""Return a Kaiser window.
 
     The Kaiser window is a taper formed by using a Bessel function.
@@ -1129,6 +1199,7 @@ def kaiser(M, beta, sym=True):
         When True (default), generates a symmetric window, for use in filter
         design.
         When False, generates a periodic window, for use in spectral analysis.
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -1218,20 +1289,22 @@ def kaiser(M, beta, sym=True):
     >>> plt.xlabel("Normalized frequency [cycles per sample]")
 
     """
+    xp = _namespace(xp)
+
     # Docstring adapted from NumPy's kaiser function
     if _len_guards(M):
-        return np.ones(M)
+        return xp.ones(M, dtype=xp.float64, device=device)
     M, needs_trunc = _extend(M, sym)
 
-    n = np.arange(0, M)
+    n = xp.arange(0, M, dtype=xp.float64, device=device)
     alpha = (M - 1) / 2.0
-    w = (special.i0(beta * np.sqrt(1 - ((n - alpha) / alpha) ** 2.0)) /
-         special.i0(beta))
+    w = (special.i0(beta * xp.sqrt(1 - ((n - alpha) / alpha) ** 2.0)) /
+         special.i0(xp.asarray(beta, dtype=xp.float64)))
 
     return _truncate(w, needs_trunc)
 
 
-def kaiser_bessel_derived(M, beta, *, sym=True):
+def kaiser_bessel_derived(M, beta, *, sym=True, xp=None, device=None):
     """Return a Kaiser-Bessel derived window.
 
     Parameters
@@ -1248,6 +1321,7 @@ def kaiser_bessel_derived(M, beta, *, sym=True):
         the other window functions and to be callable by `get_window`.
         When True (default), generates a symmetric window, for use in filter
         design.
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -1297,27 +1371,29 @@ def kaiser_bessel_derived(M, beta, *, sym=True):
     >>> fig.tight_layout()
     >>> fig.show()
     """
+    xp = _namespace(xp)
+
     if not sym:
         raise ValueError(
             "Kaiser-Bessel Derived windows are only defined for symmetric "
             "shapes"
         )
     elif M < 1:
-        return np.array([])
+        return xp.asarray([])
     elif M % 2:
         raise ValueError(
             "Kaiser-Bessel Derived windows are only defined for even number "
             "of points"
         )
 
-    kaiser_window = kaiser(M // 2 + 1, beta)
-    csum = np.cumsum(kaiser_window)
-    half_window = np.sqrt(csum[:-1] / csum[-1])
-    w = np.concatenate((half_window, half_window[::-1]), axis=0)
-    return w
+    kaiser_window = kaiser(M // 2 + 1, beta, xp=xp, device=device)
+    csum = xp.cumulative_sum(kaiser_window)
+    half_window = xp.sqrt(csum[:-1] / csum[-1])
+    w = xp.concat((half_window, xp.flip(half_window)), axis=0)
+    return xp.asarray(w, device=device)
 
 
-def gaussian(M, std, sym=True):
+def gaussian(M, std, sym=True, *, xp=None, device=None):
     r"""Return a Gaussian window.
 
     Parameters
@@ -1331,6 +1407,7 @@ def gaussian(M, std, sym=True):
         When True (default), generates a symmetric window, for use in filter
         design.
         When False, generates a periodic window, for use in spectral analysis.
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -1370,18 +1447,20 @@ def gaussian(M, std, sym=True):
     >>> plt.xlabel("Normalized frequency [cycles per sample]")
 
     """
+    xp = _namespace(xp)
+
     if _len_guards(M):
-        return np.ones(M)
+        return xp.ones(M, dtype=xp.float64, device=device)
     M, needs_trunc = _extend(M, sym)
 
-    n = np.arange(0, M) - (M - 1.0) / 2.0
+    n = xp.arange(0, M, dtype=xp.float64, device=device) - (M - 1.0) / 2.0
     sig2 = 2 * std * std
-    w = np.exp(-n ** 2 / sig2)
+    w = xp.exp(-n ** 2 / sig2)
 
     return _truncate(w, needs_trunc)
 
 
-def general_gaussian(M, p, sig, sym=True):
+def general_gaussian(M, p, sig, sym=True, *, xp=None, device=None):
     r"""Return a window with a generalized Gaussian shape.
 
     Parameters
@@ -1398,6 +1477,7 @@ def general_gaussian(M, p, sig, sym=True):
         When True (default), generates a symmetric window, for use in filter
         design.
         When False, generates a periodic window, for use in spectral analysis.
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -1442,18 +1522,20 @@ def general_gaussian(M, p, sig, sym=True):
     >>> plt.xlabel("Normalized frequency [cycles per sample]")
 
     """
+    xp = _namespace(xp)
+
     if _len_guards(M):
-        return np.ones(M)
+        return xp.ones(M, dtype=xp.float64, device=device)
     M, needs_trunc = _extend(M, sym)
 
-    n = np.arange(0, M) - (M - 1.0) / 2.0
-    w = np.exp(-0.5 * np.abs(n / sig) ** (2 * p))
+    n = xp.arange(0, M, dtype=xp.float64, device=device) - (M - 1.0) / 2.0
+    w = xp.exp(-0.5 * abs(n / sig) ** (2 * p))
 
     return _truncate(w, needs_trunc)
 
 
 # `chebwin` contributed by Kumar Appaiah.
-def chebwin(M, at, sym=True):
+def chebwin(M, at, sym=True, *, xp=None, device=None):
     r"""Return a Dolph-Chebyshev window.
 
     Parameters
@@ -1467,6 +1549,7 @@ def chebwin(M, at, sym=True):
         When True (default), generates a symmetric window, for use in filter
         design.
         When False, generates a periodic window, for use in spectral analysis.
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -1539,7 +1622,9 @@ def chebwin(M, at, sym=True):
     >>> plt.xlabel("Normalized frequency [cycles per sample]")
 
     """
-    if np.abs(at) < 45:
+    xp = _namespace(xp)
+
+    if abs(at) < 45:
         warnings.warn("This window is not suitable for spectral analysis "
                       "for attenuation values lower than about 45dB because "
                       "the equivalent noise bandwidth of a Chebyshev window "
@@ -1548,40 +1633,41 @@ def chebwin(M, at, sym=True):
                       "about 45 dB.",
                       stacklevel=2)
     if _len_guards(M):
-        return np.ones(M)
+        return xp.ones(M, dtype=xp.float64, device=device)
     M, needs_trunc = _extend(M, sym)
 
     # compute the parameter beta
     order = M - 1.0
-    beta = np.cosh(1.0 / order * np.arccosh(10 ** (np.abs(at) / 20.)))
-    k = np.r_[0:M] * 1.0
-    x = beta * np.cos(np.pi * k / M)
+    _val = xp.asarray(10 ** (abs(at) / 20.), dtype=xp.float64, device=device)
+    beta = xp.cosh(1.0 / order * xp.acosh(_val))
+    k = xp.arange(M, dtype=xp.float64, device=device)
+    x = beta * xp.cos(xp.pi * k / M)
     # Find the window's DFT coefficients
     # Use analytic definition of Chebyshev polynomial instead of expansion
     # from scipy.special. Using the expansion in scipy.special leads to errors.
-    p = np.zeros(x.shape)
-    p[x > 1] = np.cosh(order * np.arccosh(x[x > 1]))
-    p[x < -1] = (2 * (M % 2) - 1) * np.cosh(order * np.arccosh(-x[x < -1]))
-    p[np.abs(x) <= 1] = np.cos(order * np.arccos(x[np.abs(x) <= 1]))
+    p = xp.zeros_like(x)
+    p[x > 1] = xp.cosh(order * xp.acosh(x[x > 1]))
+    p[x < -1] = (2 * (M % 2) - 1) * xp.cosh(order * xp.acosh(-x[x < -1]))
+    p[abs(x) <= 1] = xp.cos(order * xp.acos(x[abs(x) <= 1]))
 
     # Appropriate IDFT and filling up
     # depending on even/odd M
     if M % 2:
-        w = np.real(sp_fft.fft(p))
+        w = xp.real(sp_fft.fft(p))
         n = (M + 1) // 2
         w = w[:n]
-        w = np.concatenate((w[n - 1:0:-1], w))
+        w = xp.concat((xp.flip(w[1:n]), w))
     else:
-        p = p * np.exp(1.j * np.pi / M * np.r_[0:M])
-        w = np.real(sp_fft.fft(p))
+        p = p * xp.exp(1j * xp.pi / M * xp.arange(M, dtype=xp.float64, device=device))
+        w = xp.real(sp_fft.fft(p))
         n = M // 2 + 1
-        w = np.concatenate((w[n - 1:0:-1], w[1:n]))
-    w = w / max(w)
+        w = xp.concat((xp.flip(w[1:n]), w[1:n]))
+    w = w / xp.max(w)
 
     return _truncate(w, needs_trunc)
 
 
-def cosine(M, sym=True):
+def cosine(M, sym=True, *, xp=None, device=None):
     """Return a window with a simple cosine shape.
 
     Parameters
@@ -1593,6 +1679,7 @@ def cosine(M, sym=True):
         When True (default), generates a symmetric window, for use in filter
         design.
         When False, generates a periodic window, for use in spectral analysis.
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -1632,16 +1719,18 @@ def cosine(M, sym=True):
     >>> plt.show()
 
     """
+    xp = _namespace(xp)
+
     if _len_guards(M):
-        return np.ones(M)
+        return xp.ones(M, dtype=xp.float64, device=device)
     M, needs_trunc = _extend(M, sym)
 
-    w = np.sin(np.pi / M * (np.arange(0, M) + .5))
+    w = xp.sin(xp.pi / M * (xp.arange(M, dtype=xp.float64, device=device) + .5))
 
     return _truncate(w, needs_trunc)
 
 
-def exponential(M, center=None, tau=1., sym=True):
+def exponential(M, center=None, tau=1., sym=True, *, xp=None, device=None):
     r"""Return an exponential (or Poisson) window.
 
     Parameters
@@ -1661,6 +1750,7 @@ def exponential(M, center=None, tau=1., sym=True):
         When True (default), generates a symmetric window, for use in filter
         design.
         When False, generates a periodic window, for use in spectral analysis.
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -1715,22 +1805,24 @@ def exponential(M, center=None, tau=1., sym=True):
     >>> plt.ylabel("Amplitude")
     >>> plt.xlabel("Sample")
     """
+    xp = _namespace(xp)
+
     if sym and center is not None:
         raise ValueError("If sym==True, center must be None.")
     if _len_guards(M):
-        return np.ones(M)
+        return xp.ones(M, dtype=xp.float64, device=device)
     M, needs_trunc = _extend(M, sym)
 
     if center is None:
         center = (M-1) / 2
 
-    n = np.arange(0, M)
-    w = np.exp(-np.abs(n-center) / tau)
+    n = xp.arange(0, M, dtype=xp.float64, device=device)
+    w = xp.exp(-abs(n-center) / tau)
 
     return _truncate(w, needs_trunc)
 
 
-def taylor(M, nbar=4, sll=30, norm=True, sym=True):
+def taylor(M, nbar=4, sll=30, norm=True, sym=True, *, xp=None, device=None):
     """
     Return a Taylor window.
 
@@ -1763,6 +1855,7 @@ def taylor(M, nbar=4, sll=30, norm=True, sym=True):
         When True (default), generates a symmetric window, for use in filter
         design.
         When False, generates a periodic window, for use in spectral analysis.
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -1810,33 +1903,35 @@ def taylor(M, nbar=4, sll=30, norm=True, sym=True):
     >>> plt.xlabel("Normalized frequency [cycles per sample]")
 
     """  # noqa: E501
+    xp = _namespace(xp)
+
     if _len_guards(M):
-        return np.ones(M)
+        return xp.ones(M, dtype=xp.float64, device=device)
     M, needs_trunc = _extend(M, sym)
 
     # Original text uses a negative sidelobe level parameter and then negates
     # it in the calculation of B. To keep consistent with other methods we
     # assume the sidelobe level parameter to be positive.
-    B = 10**(sll / 20)
-    A = np.arccosh(B) / np.pi
+    B = xp.asarray(10**(sll / 20), device=device)
+    A = xp.acosh(B) / xp.pi
     s2 = nbar**2 / (A**2 + (nbar - 0.5)**2)
-    ma = np.arange(1, nbar)
+    ma = xp.arange(1, nbar, dtype=xp.float64, device=device)
 
-    Fm = np.empty(nbar-1)
-    signs = np.empty_like(ma)
+    Fm = xp.empty(nbar - 1, dtype=xp.float64, device=device)
+    signs = xp.empty_like(ma)
     signs[::2] = 1
     signs[1::2] = -1
     m2 = ma*ma
     for mi, m in enumerate(ma):
-        numer = signs[mi] * np.prod(1 - m2[mi]/s2/(A**2 + (ma - 0.5)**2))
-        denom = 2 * np.prod(1 - m2[mi]/m2[:mi]) * np.prod(1 - m2[mi]/m2[mi+1:])
+        numer = signs[mi] * xp.prod(1 - m2[mi]/s2/(A**2 + (ma - 0.5)**2))
+        denom = 2 * xp.prod(1 - m2[mi]/m2[:mi]) * xp.prod(1 - m2[mi]/m2[mi+1:])
         Fm[mi] = numer / denom
 
     def W(n):
-        return 1 + 2*np.dot(Fm, np.cos(
-            2*np.pi*ma[:, np.newaxis]*(n-M/2.+0.5)/M))
+        return 1 + 2*xp.matmul(Fm, xp.cos(
+            2*xp.pi*ma[:, xp.newaxis]*(n-M/2.+0.5)/M))
 
-    w = W(np.arange(M))
+    w = W(xp.arange(M, dtype=xp.float64, device=device))
 
     # normalize (Note that this is not described in the original text [1])
     if norm:
@@ -1846,7 +1941,8 @@ def taylor(M, nbar=4, sll=30, norm=True, sym=True):
     return _truncate(w, needs_trunc)
 
 
-def dpss(M, NW, Kmax=None, sym=True, norm=None, return_ratios=False):
+def dpss(M, NW, Kmax=None, sym=True, norm=None, return_ratios=False,
+         *, xp=None, device=None):
     """
     Compute the Discrete Prolate Spheroidal Sequences (DPSS).
 
@@ -1880,6 +1976,7 @@ def dpss(M, NW, Kmax=None, sym=True, norm=None, return_ratios=False):
     return_ratios : bool, optional
         If True, also return the concentration ratios in addition to the
         windows.
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -1937,12 +2034,12 @@ def dpss(M, NW, Kmax=None, sym=True, norm=None, return_ratios=False):
     ...     for win, c in ((win_dpss, 'k'), (win_kaiser, 'r')):
     ...         win /= win.sum()
     ...         axes[ai, 0].plot(win, color=c, lw=1.)
-    ...         axes[ai, 0].set(xlim=[0, M-1], title=r'$\\alpha$ = %s' % alpha,
+    ...         axes[ai, 0].set(xlim=[0, M-1], title=rf'$\\alpha$ = {alpha}',
     ...                         ylabel='Amplitude')
     ...         w, h = freqz(win)
     ...         axes[ai, 1].plot(w, 20 * np.log10(np.abs(h)), color=c, lw=1.)
     ...         axes[ai, 1].set(xlim=[0, np.pi],
-    ...                         title=r'$\\beta$ = %0.2f' % beta,
+    ...                         title=rf'$\\beta$ = {beta:0.2f}',
     ...                         ylabel='Magnitude (dB)')
     >>> for ax in axes.ravel():
     ...     ax.grid(True)
@@ -1959,8 +2056,8 @@ def dpss(M, NW, Kmax=None, sym=True, norm=None, return_ratios=False):
     >>> fig, ax = plt.subplots(1)
     >>> ax.plot(win.T, linewidth=1.)
     >>> ax.set(xlim=[0, M-1], ylim=[-0.1, 0.1], xlabel='Samples',
-    ...        title='DPSS, M=%d, NW=%0.1f' % (M, NW))
-    >>> ax.legend(['win[%d] (%0.4f)' % (ii, ratio)
+    ...        title=f'DPSS, {M:d}, {NW:0.1f}')
+    >>> ax.legend([f'win[{ii}] ({ratio:0.4f})'
     ...            for ii, ratio in enumerate(eigvals)])
     >>> fig.tight_layout()
     >>> plt.show()
@@ -2009,8 +2106,8 @@ def dpss(M, NW, Kmax=None, sym=True, norm=None, return_ratios=False):
     >>> fig.tight_layout()
 
     """
-    if _len_guards(M):
-        return np.ones(M)
+    xp = _namespace(xp)
+
     if norm is None:
         norm = 'approximate' if Kmax is None else 2
     known_norms = (2, 'approximate', 'subsample')
@@ -2021,6 +2118,13 @@ def dpss(M, NW, Kmax=None, sym=True, norm=None, return_ratios=False):
         Kmax = 1
     else:
         singleton = False
+    if _len_guards(M):
+        if not return_ratios:
+            return xp.ones(M, dtype=xp.float64)
+        elif singleton:
+            return xp.ones(M, dtype=xp.float64), 1.
+        else:
+            return xp.ones(M, dtype=xp.float64), xp.ones(1, dtype=xp.float64)
     Kmax = operator.index(Kmax)
     if not 0 < Kmax <= M:
         raise ValueError('Kmax must be greater than 0 and less than M')
@@ -2030,7 +2134,7 @@ def dpss(M, NW, Kmax=None, sym=True, norm=None, return_ratios=False):
         raise ValueError('NW must be positive')
     M, needs_trunc = _extend(M, sym)
     W = float(NW) / M
-    nidx = np.arange(M)
+    nidx = xp.arange(M, dtype=xp.float64, device=device)
 
     # Here we want to set up an optimization problem to find a sequence
     # whose energy is maximally concentrated within band [-W,W].
@@ -2050,7 +2154,7 @@ def dpss(M, NW, Kmax=None, sym=True, norm=None, return_ratios=False):
     # the main diagonal = ([M-1-2*t]/2)**2 cos(2PIW), t=[0,1,2,...,M-1]
     # and the first off-diagonal = t(M-t)/2, t=[1,2,...,M-1]
     # [see Percival and Walden, 1993]
-    d = ((M - 1 - 2 * nidx) / 2.) ** 2 * np.cos(2 * np.pi * W)
+    d = ((M - 1 - 2 * nidx) / 2.) ** 2 * xp.cos(xp.asarray(2 * xp.pi * W))
     e = nidx[1:] * (M - nidx[1:]) / 2.
 
     # only calculate the highest Kmax eigenvalues
@@ -2061,7 +2165,7 @@ def dpss(M, NW, Kmax=None, sym=True, norm=None, return_ratios=False):
 
     # By convention (Percival and Walden, 1993 pg 379)
     # * symmetric tapers (k=0,2,4,...) should have a positive average.
-    fix_even = (windows[::2].sum(axis=1) < 0)
+    fix_even = (windows[::2, ...].sum(axis=1) < 0)
     for i, f in enumerate(fix_even):
         if f:
             windows[2 * i] *= -1
@@ -2072,19 +2176,20 @@ def dpss(M, NW, Kmax=None, sym=True, norm=None, return_ratios=False):
     #   algorithm that uses max(abs(w)), which is susceptible to numerical
     #   noise problems)
     thresh = max(1e-7, 1. / M)
-    for i, w in enumerate(windows[1::2]):
+    for i, w in enumerate(windows[1::2, ...]):
         if w[w * w > thresh][0] < 0:
             windows[2 * i + 1] *= -1
 
     # Now find the eigenvalues of the original spectral concentration problem
     # Use the autocorr sequence technique from Percival and Walden, 1993 pg 390
     if return_ratios:
-        dpss_rxx = _fftautocorr(windows)
-        r = 4 * W * np.sinc(2 * W * nidx)
+        dpss_rxx = _fftautocorr(xp.asarray(windows))
+        r = 4 * W * xpx.sinc(xp.asarray(2 * W * nidx), xp=xp)
         r[0] = 2 * W
-        ratios = np.dot(dpss_rxx, r)
+        ratios = xp.matmul(dpss_rxx, r)
         if singleton:
             ratios = ratios[0]
+        ratios = xp.asarray(ratios, device=device)
     # Deal with sym and Kmax=None
     if norm != 2:
         windows /= windows.max()
@@ -2093,8 +2198,8 @@ def dpss(M, NW, Kmax=None, sym=True, norm=None, return_ratios=False):
                 correction = M**2 / float(M**2 + NW)
             else:
                 s = sp_fft.rfft(windows[0])
-                shift = -(1 - 1./M) * np.arange(1, M//2 + 1)
-                s[1:] *= 2 * np.exp(-1j * np.pi * shift)
+                shift = -(1 - 1./M) * xp.arange(1, M//2 + 1, dtype=xp.float64)
+                s[1:] *= 2 * xp.exp(-1j * xp.pi * shift)
                 correction = M / s.real.sum()
             windows *= correction
     # else we're already l2 normed, so do nothing
@@ -2102,10 +2207,11 @@ def dpss(M, NW, Kmax=None, sym=True, norm=None, return_ratios=False):
         windows = windows[:, :-1]
     if singleton:
         windows = windows[0]
+    windows = xp.asarray(windows, device=device)
     return (windows, ratios) if return_ratios else windows
 
 
-def lanczos(M, *, sym=True):
+def lanczos(M, *, sym=True, xp=None, device=None):
     r"""Return a Lanczos window also known as a sinc window.
 
     Parameters
@@ -2117,6 +2223,7 @@ def lanczos(M, *, sym=True):
         When True (default), generates a symmetric window, for use in filter
         design.
         When False, generates a periodic window, for use in spectral analysis.
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -2183,22 +2290,24 @@ def lanczos(M, *, sym=True):
     >>> fig.tight_layout()
     >>> plt.show()
     """
+    xp = _namespace(xp)
+
     if _len_guards(M):
-        return np.ones(M)
+        return xp.ones(M, dtype=xp.float64, device=device)
     M, needs_trunc = _extend(M, sym)
 
     # To make sure that the window is symmetric, we concatenate the right hand
     # half of the window and the flipped one which is the left hand half of
     # the window.
     def _calc_right_side_lanczos(n, m):
-        return np.sinc(2. * np.arange(n, m) / (m - 1) - 1.0)
+        return xpx.sinc(2. * xp.arange(n, m, dtype=xp.float64) / (m - 1) - 1.0, xp=xp)
 
     if M % 2 == 0:
         wh = _calc_right_side_lanczos(M/2, M)
-        w = np.r_[np.flip(wh), wh]
+        w = xp.concat([xp.flip(wh), wh])
     else:
         wh = _calc_right_side_lanczos((M+1)/2, M)
-        w = np.r_[np.flip(wh), 1.0, wh]
+        w = xp.concat([xp.flip(wh), xp.ones(1), wh])
 
     return _truncate(w, needs_trunc)
 
@@ -2210,8 +2319,8 @@ def _fftautocorr(x):
     x_fft = sp_fft.rfft(x, use_N, axis=-1)
     cxy = sp_fft.irfft(x_fft * x_fft.conj(), n=use_N)[:, :N]
     # Or equivalently (but in most cases slower):
-    # cxy = np.array([np.convolve(xx, yy[::-1], mode='full')
-    #                 for xx, yy in zip(x, x)])[:, N-1:2*N-1]
+    # cxy = xp.asarray([xp.convolve(xx, yy[::-1], mode='full')
+    #                   for xx, yy in zip(x, x)])[:, N-1:2*N-1]
     return cxy
 
 
@@ -2258,7 +2367,7 @@ for k, v in _win_equiv_raw.items():
         _needs_param.update(k)
 
 
-def get_window(window, Nx, fftbins=True):
+def get_window(window, Nx, fftbins=True, *, xp=None, device=None):
     """
     Return a window of a given length and type.
 
@@ -2273,6 +2382,7 @@ def get_window(window, Nx, fftbins=True):
         `ifftshift` and be multiplied by the result of an FFT (see also
         :func:`~scipy.fft.fftfreq`).
         If False, create a "symmetric" window, for use in filter design.
+    %(xp_device_snippet)s
 
     Returns
     -------
@@ -2358,6 +2468,11 @@ def get_window(window, Nx, fftbins=True):
             raise ValueError(
                 f"{str(type(window))} as window type is not supported.") from e
 
+        if winstr == 'general_cosine' and (xp is not None or device is not None):
+            raise ValueError(
+                'general_cosine window does not accept xp and device kwargs '
+            )
+
         try:
             winfunc = _win_equiv[winstr]
         except KeyError as e:
@@ -2371,4 +2486,28 @@ def get_window(window, Nx, fftbins=True):
         winfunc = kaiser
         params = (Nx, beta)
 
-    return winfunc(*params, sym=sym)
+    if winfunc == general_cosine:
+        return winfunc(*params, sym=sym)
+    else:
+        return winfunc(*params, sym=sym, xp=xp, device=device)
+
+
+########## complete the docstrings, on import
+_xp_device_snippet = {'xp_device_snippet':
+"""\
+xp : array_namespace, optional
+    Optional array namespace.
+    Should be compatible with the array API standard, or supported by array-api-compat.
+    Default: ``numpy``
+device: any
+    optional device specification for output. Should match one of the
+    supported device specification in ``xp``.
+"""
+}
+
+
+_names = [x for x in __all__ if x != 'general_cosine']
+for name in _names:
+    window = vars()[name]
+    window.__doc__ = doccer.docformat(window.__doc__, _xp_device_snippet)
+