Add files using upload-large-folder tool

.gitattributes

@@ -1438,3 +1438,4 @@ parrot/lib/python3.10/site-packages/numpy/_core/tests/__pycache__/test_numeric.c
 parrot/lib/python3.10/site-packages/numpy/lib/tests/__pycache__/test_function_base.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 vllm/lib/python3.10/site-packages/huggingface_hub/inference/_generated/__pycache__/_async_client.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 vllm/lib/python3.10/site-packages/huggingface_hub/inference/__pycache__/_client.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+vglm/bin/python filter=lfs diff=lfs merge=lfs -text

vglm/bin/python

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a5893c715ba63b749ab2bb330a28cd17a9e1f8ab65c7b580e714da9cec0caee3
+size 17225608

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_foreach_log2_native.h

@@ -0,0 +1,25 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API void _foreach_log2_out(at::TensorList self, at::TensorList out);
+TORCH_API ::std::vector<at::Tensor> foreach_tensor_log2_slow(at::TensorList self);
+TORCH_API void foreach_tensor_log2_slow_(at::TensorList self);
+TORCH_API ::std::vector<at::Tensor> foreach_tensor_log2_cuda(at::TensorList self);
+TORCH_API void foreach_tensor_log2_cuda_(at::TensorList self);
+} // namespace native
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_foreach_sqrt_native.h

@@ -0,0 +1,25 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API void _foreach_sqrt_out(at::TensorList self, at::TensorList out);
+TORCH_API ::std::vector<at::Tensor> foreach_tensor_sqrt_slow(at::TensorList self);
+TORCH_API void foreach_tensor_sqrt_slow_(at::TensorList self);
+TORCH_API ::std::vector<at::Tensor> foreach_tensor_sqrt_cuda(at::TensorList self);
+TORCH_API void foreach_tensor_sqrt_cuda_(at::TensorList self);
+} // namespace native
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/grid_sampler_native.h

@@ -0,0 +1,21 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API at::Tensor grid_sampler(const at::Tensor & input, const at::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners);
+} // namespace native
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/hstack_ops.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API hstack {
+  using schema = at::Tensor (at::TensorList);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::hstack")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "hstack(Tensor[] tensors) -> Tensor")
+  static at::Tensor call(at::TensorList tensors);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList tensors);
+};
+
+struct TORCH_API hstack_out {
+  using schema = at::Tensor & (at::TensorList, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::hstack")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "hstack.out(Tensor[] tensors, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(at::TensorList tensors, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList tensors, at::Tensor & out);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/native_layer_norm_cpu_dispatch.h

@@ -0,0 +1,24 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cpu {
+
+TORCH_API ::std::tuple<at::Tensor,at::Tensor,at::Tensor> native_layer_norm(const at::Tensor & input, at::IntArrayRef normalized_shape, const c10::optional<at::Tensor> & weight, const c10::optional<at::Tensor> & bias, double eps);
+TORCH_API ::std::tuple<at::Tensor,at::Tensor,at::Tensor> native_layer_norm_symint(const at::Tensor & input, c10::SymIntArrayRef normalized_shape, const c10::optional<at::Tensor> & weight, const c10::optional<at::Tensor> & bias, double eps);
+
+} // namespace cpu
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/renorm_meta.h

@@ -0,0 +1,27 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeMetaFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/TensorIterator.h>
+#include <ATen/TensorMeta.h>
+#include <tuple>
+#include <vector>
+
+namespace at {
+namespace meta {
+
+struct TORCH_API structured_renorm : public at::impl::MetaBase {
+    
+    
+    void meta(const at::Tensor & self, const at::Scalar & p, int64_t dim, const at::Scalar & maxnorm);
+};
+
+} // namespace native
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/sinh_cuda_dispatch.h

@@ -0,0 +1,26 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cuda {
+
+TORCH_API at::Tensor sinh(const at::Tensor & self);
+TORCH_API at::Tensor & sinh_out(at::Tensor & out, const at::Tensor & self);
+TORCH_API at::Tensor & sinh_outf(const at::Tensor & self, at::Tensor & out);
+TORCH_API at::Tensor & sinh_(at::Tensor & self);
+
+} // namespace cuda
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/sparse_resize_and_clear_ops.h

@@ -0,0 +1,50 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API sparse_resize_and_clear_ {
+  using schema = const at::Tensor & (const at::Tensor &, at::IntArrayRef, int64_t, int64_t);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::sparse_resize_and_clear_")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "sparse_resize_and_clear_(Tensor(a!) self, int[] size, int sparse_dim, int dense_dim) -> Tensor(a!)")
+  static const at::Tensor & call(const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim);
+  static const at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim);
+};
+
+struct TORCH_API sparse_resize_and_clear_out {
+  using schema = const at::Tensor & (const at::Tensor &, at::IntArrayRef, int64_t, int64_t, const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::sparse_resize_and_clear")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "sparse_resize_and_clear.out(Tensor self, int[] size, int sparse_dim, int dense_dim, *, Tensor(a!) out) -> Tensor(a!)")
+  static const at::Tensor & call(const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim, const at::Tensor & out);
+  static const at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim, const at::Tensor & out);
+};
+
+struct TORCH_API sparse_resize_and_clear {
+  using schema = at::Tensor (const at::Tensor &, at::IntArrayRef, int64_t, int64_t);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::sparse_resize_and_clear")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "sparse_resize_and_clear(Tensor self, int[] size, int sparse_dim, int dense_dim) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim);
+};
+
+}} // namespace at::_ops

vllm/lib/python3.10/site-packages/cupyx/scipy/__init__.py

@@ -0,0 +1,35 @@
+import sys as _sys
+
+from cupy._core import ndarray as _ndarray
+from cupyx.scipy.sparse._base import spmatrix as _spmatrix
+
+
+try:
+    import scipy as _scipy
+    _scipy_available = True
+except ImportError:
+    _scipy_available = False
+
+
+_cupyx_scipy = _sys.modules[__name__]
+
+
+def get_array_module(*args):
+    """Returns the array module for arguments.
+
+    This function is used to implement CPU/GPU generic code. If at least one of
+    the arguments is a :class:`cupy.ndarray` object, the :mod:`cupyx.scipy`
+    module is returned.
+
+    Args:
+        args: Values to determine whether NumPy or CuPy should be used.
+
+    Returns:
+        module: :mod:`cupyx.scipy` or :mod:`scipy` is returned based on the
+        types of the arguments.
+
+    """
+    for arg in args:
+        if isinstance(arg, (_ndarray, _spmatrix)):
+            return _cupyx_scipy
+    return _scipy

vllm/lib/python3.10/site-packages/cupyx/scipy/_lib/_util.py

@@ -0,0 +1,73 @@
+import math
+
+import cupy
+
+
+def float_factorial(n):
+    """Compute the factorial and return as a float
+
+    Returns infinity when result is too large for a double
+    """
+    return float(math.factorial(n)) if n < 171 else cupy.inf
+
+
+def _asarray_validated(a, check_finite=True,
+                       sparse_ok=False, objects_ok=False, mask_ok=False,
+                       as_inexact=False):
+    """Helper function for SciPy argument validation.
+
+    Many CuPy linear algebra functions do support arbitrary array-like
+    input arguments. Examples of commonly unsupported inputs include
+    matrices containing inf/nan, sparse matrix representations, and
+    matrices with complicated elements.
+
+    Parameters
+    ----------
+    a : array-like
+        The array-like input
+    check_finite : bool, optional
+        By default True. To check whether the input matrices contain
+        only finite numbers. Disabling may give a performance gain,
+        but may result in problems (crashes, non-termination) if the
+        inputs do contain infinites or NaNs
+    sparse_ok : bool, optional
+        By default False. True if cupy sparse matrices are allowed
+    objects_ok : bool, optional
+        By default False. True if arrays with dype('O') are allowed
+    mask_ok : bool, optional
+        By default False. True if masked arrays are allowed.
+    as_inexact : bool, optional
+        By default False. True to convert the input array to a
+        cupy.inexact dtype
+
+    Returns
+    -------
+    ret : cupy.ndarray
+        The converted validated array
+
+    """
+
+    if not sparse_ok:
+        import cupyx.scipy.sparse
+        if cupyx.scipy.sparse.issparse(a):
+            msg = ('Sparse matrices are not supported by this function. '
+                   'Perhaps one of the cupyx.scipy.sparse.linalg functions '
+                   'would work instead.')
+            raise ValueError(msg)
+
+    # TODO: remove these comments when CuPy supports masked arrays
+    # Ref Issue: https://github.com/cupy/cupy/issues/2225
+    # if not mask_ok:
+    #     if cupy.ma.isMaskedArray(a):
+    #         raise ValueError('masked arrays are not supported')
+
+    # TODO: remove these comments when CuPy supports 'object' dtype
+    # if not objects_ok:
+    #    if a.dtype is cupy.dtype('O'):
+    #        raise ValueError('object arrays are not supported')
+
+    if as_inexact:
+        if not cupy.issubdtype(a, cupy.inexact):
+            a = a.astype(dtype=cupy.float64)
+
+    return a

vllm/lib/python3.10/site-packages/cupyx/scipy/fftpack/__init__.py

@@ -0,0 +1,9 @@
+from cupyx.scipy.fftpack._fft import fft  # NOQA
+from cupyx.scipy.fftpack._fft import fft2  # NOQA
+from cupyx.scipy.fftpack._fft import fftn  # NOQA
+from cupyx.scipy.fftpack._fft import ifft  # NOQA
+from cupyx.scipy.fftpack._fft import ifft2  # NOQA
+from cupyx.scipy.fftpack._fft import ifftn  # NOQA
+from cupyx.scipy.fftpack._fft import irfft  # NOQA
+from cupyx.scipy.fftpack._fft import rfft  # NOQA
+from cupyx.scipy.fftpack._fft import get_fft_plan  # NOQA

vllm/lib/python3.10/site-packages/cupyx/scipy/fftpack/_fft.py

@@ -0,0 +1,508 @@
+from numpy import prod
+
+import cupy
+from cupy.fft import config
+from cupy.fft._fft import (_convert_fft_type, _default_fft_func, _fft,
+                           _get_cufft_plan_nd, _get_fftn_out_size,
+                           _output_dtype)
+from cupy.fft._cache import get_plan_cache
+
+
+def get_fft_plan(a, shape=None, axes=None, value_type='C2C'):
+    """ Generate a CUDA FFT plan for transforming up to three axes.
+
+    Args:
+        a (cupy.ndarray): Array to be transform, assumed to be either C- or
+            F- contiguous.
+        shape (None or tuple of ints): Shape of the transformed axes of the
+            output. If ``shape`` is not given, the lengths of the input along
+            the axes specified by ``axes`` are used.
+        axes (None or int or tuple of int):  The axes of the array to
+            transform. If `None`, it is assumed that all axes are transformed.
+
+            Currently, for performing N-D transform these must be a set of up
+            to three adjacent axes, and must include either the first or the
+            last axis of the array.
+        value_type (str): The FFT type to perform. Acceptable values are:
+
+            * 'C2C': complex-to-complex transform (default)
+            * 'R2C': real-to-complex transform
+            * 'C2R': complex-to-real transform
+
+    Returns:
+        a cuFFT plan for either 1D transform (``cupy.cuda.cufft.Plan1d``) or
+        N-D transform (``cupy.cuda.cufft.PlanNd``).
+
+    .. note::
+        The returned plan can not only be passed as one of the arguments of
+        the functions in ``cupyx.scipy.fftpack``, but also be used as a
+        context manager for both ``cupy.fft`` and ``cupyx.scipy.fftpack``
+        functions:
+
+        .. code-block:: python
+
+            x = cupy.random.random(16).reshape(4, 4).astype(complex)
+            plan = cupyx.scipy.fftpack.get_fft_plan(x)
+            with plan:
+                y = cupy.fft.fftn(x)
+                # alternatively:
+                y = cupyx.scipy.fftpack.fftn(x)  # no explicit plan is given!
+            # alternatively:
+            y = cupyx.scipy.fftpack.fftn(x, plan=plan)  # pass plan explicitly
+
+        In the first case, no cuFFT plan will be generated automatically,
+        even if ``cupy.fft.config.enable_nd_planning = True`` is set.
+
+    .. note::
+        If this function is called under the context of
+        :func:`~cupy.fft.config.set_cufft_callbacks`, the generated plan will
+        have callbacks enabled.
+
+    .. warning::
+        This API is a deviation from SciPy's, is currently experimental, and
+        may be changed in the future version.
+    """
+    from cupy.cuda import cufft
+
+    # check input array
+    if a.flags.c_contiguous:
+        order = 'C'
+    elif a.flags.f_contiguous:
+        order = 'F'
+    else:
+        raise ValueError('Input array a must be contiguous')
+
+    if isinstance(shape, int):
+        shape = (shape,)
+    if isinstance(axes, int):
+        axes = (axes,)
+    if (shape is not None) and (axes is not None) and len(shape) != len(axes):
+        raise ValueError('Shape and axes have different lengths.')
+
+    # check axes
+    # n=1: 1d (need axis1D); n>1: Nd
+    if axes is None:
+        n = a.ndim if shape is None else len(shape)
+        axes = tuple(i for i in range(-n, 0))
+        if n == 1:
+            axis1D = 0
+    else:  # axes is a tuple
+        n = len(axes)
+        if n == 1:
+            axis1D = axes[0]
+            if axis1D >= a.ndim or axis1D < -a.ndim:
+                err = 'The chosen axis ({0}) exceeds the number of '\
+                      'dimensions of a ({1})'.format(axis1D, a.ndim)
+                raise ValueError(err)
+        elif n > 3:
+            raise ValueError('Only up to three axes is supported')
+
+    # Note that "shape" here refers to the shape along transformed axes, not
+    # the shape of the output array, and we need to convert it to the latter.
+    # The result is as if "a=_cook_shape(a); return a.shape" is called.
+    # Because of this, we need to use (possibly unsorted) axes.
+    transformed_shape = shape
+    shape = list(a.shape)
+    if transformed_shape is not None:
+        for s, axis in zip(transformed_shape, axes):
+            if s is not None:
+                if axis == axes[-1] and value_type == 'C2R':
+                    s = s // 2 + 1
+                shape[axis] = s
+    shape = tuple(shape)
+
+    # check value_type
+    out_dtype = _output_dtype(a.dtype, value_type)
+    fft_type = _convert_fft_type(out_dtype, value_type)
+    # TODO(leofang): figure out if we really have to skip F-order?
+    if n > 1 and value_type != 'C2C' and a.flags.f_contiguous:
+        raise ValueError('C2R/R2C PlanNd for F-order arrays is not supported')
+
+    # generate plan
+    # (load from cache if it exists, otherwise create one but don't cache it)
+    if n > 1:  # ND transform
+        if cupy.cuda.runtime.is_hip and value_type == 'C2R':
+            raise RuntimeError("hipFFT's C2R PlanNd is buggy and unsupported")
+        out_size = _get_fftn_out_size(
+            shape, transformed_shape, axes[-1], value_type)
+        # _get_cufft_plan_nd interacts with plan cache and callback
+        plan = _get_cufft_plan_nd(
+            shape, fft_type, axes=axes, order=order, out_size=out_size,
+            to_cache=False)
+    else:  # 1D transform
+        # prepare plan arguments
+        if value_type != 'C2R':
+            out_size = shape[axis1D]
+        else:
+            out_size = _get_fftn_out_size(
+                shape, transformed_shape, axis1D, value_type)
+        batch = prod(shape) // shape[axis1D]
+        devices = None if not config.use_multi_gpus else config._devices
+
+        keys = (out_size, fft_type, batch, devices)
+        mgr = config.get_current_callback_manager()
+        if mgr is not None:
+            # to avoid a weird segfault, we generate and cache distinct plans
+            # for every possible (load_aux, store_aux) pairs; the plans are
+            # still generated from the same external Python module
+            load_aux = mgr.cb_load_aux_arr
+            store_aux = mgr.cb_store_aux_arr
+            keys += (mgr.cb_load, mgr.cb_store,
+                     0 if load_aux is None else load_aux.data.ptr,
+                     0 if store_aux is None else store_aux.data.ptr)
+        cache = get_plan_cache()
+        cached_plan = cache.get(keys)
+        if cached_plan is not None:
+            plan = cached_plan
+        elif mgr is None:
+            plan = cufft.Plan1d(out_size, fft_type, batch, devices=devices)
+        else:  # has callback
+            # TODO(leofang): support multi-GPU callback (devices is ignored)
+            if devices:
+                raise NotImplementedError('multi-GPU cuFFT callbacks are not '
+                                          'yet supported')
+            plan = mgr.create_plan(('Plan1d', keys[:-3]))
+            mgr.set_callbacks(plan)
+
+    return plan
+
+
+def fft(x, n=None, axis=-1, overwrite_x=False, plan=None):
+    """Compute the one-dimensional FFT.
+
+    Args:
+        x (cupy.ndarray): Array to be transformed.
+        n (None or int): Length of the transformed axis of the output. If ``n``
+            is not given, the length of the input along the axis specified by
+            ``axis`` is used.
+        axis (int): Axis over which to compute the FFT.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+        plan (:class:`cupy.cuda.cufft.Plan1d` or ``None``): a cuFFT plan for
+            transforming ``x`` over ``axis``, which can be obtained using::
+
+                plan = cupyx.scipy.fftpack.get_fft_plan(x, axis)
+
+            Note that `plan` is defaulted to None, meaning CuPy will use an
+            auto-generated plan behind the scene.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``n`` and type
+            will convert to complex if that of the input is another.
+
+    .. note::
+       The argument `plan` is currently experimental and the interface may be
+       changed in the future version.
+
+    .. seealso:: :func:`scipy.fftpack.fft`
+    """
+    from cupy.cuda import cufft
+    return _fft(x, (n,), (axis,), None, cufft.CUFFT_FORWARD,
+                overwrite_x=overwrite_x, plan=plan)
+
+
+def ifft(x, n=None, axis=-1, overwrite_x=False, plan=None):
+    """Compute the one-dimensional inverse FFT.
+
+    Args:
+        x (cupy.ndarray): Array to be transformed.
+        n (None or int): Length of the transformed axis of the output. If ``n``
+            is not given, the length of the input along the axis specified by
+            ``axis`` is used.
+        axis (int): Axis over which to compute the FFT.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+        plan (:class:`cupy.cuda.cufft.Plan1d` or ``None``): a cuFFT plan for
+            transforming ``x`` over ``axis``, which can be obtained using::
+
+                plan = cupyx.scipy.fftpack.get_fft_plan(x, axis)
+
+            Note that `plan` is defaulted to None, meaning CuPy will use an
+            auto-generated plan behind the scene.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``n`` and type
+            will convert to complex if that of the input is another.
+
+    .. note::
+       The argument `plan` is currently experimental and the interface may be
+       changed in the future version.
+
+    .. seealso:: :func:`scipy.fftpack.ifft`
+    """
+    from cupy.cuda import cufft
+    return _fft(x, (n,), (axis,), None, cufft.CUFFT_INVERSE,
+                overwrite_x=overwrite_x, plan=plan)
+
+
+def fft2(x, shape=None, axes=(-2, -1), overwrite_x=False, plan=None):
+    """Compute the two-dimensional FFT.
+
+    Args:
+        x (cupy.ndarray): Array to be transformed.
+        shape (None or tuple of ints): Shape of the transformed axes of the
+            output. If ``shape`` is not given, the lengths of the input along
+            the axes specified by ``axes`` are used.
+        axes (tuple of ints): Axes over which to compute the FFT.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+        plan (:class:`cupy.cuda.cufft.PlanNd` or ``None``): a cuFFT plan for
+            transforming ``x`` over ``axes``, which can be obtained using::
+
+                plan = cupyx.scipy.fftpack.get_fft_plan(x, axes)
+
+            Note that `plan` is defaulted to None, meaning CuPy will either
+            use an auto-generated plan behind the scene if cupy.fft.config.
+            enable_nd_planning = True, or use no cuFFT plan if it is set to
+            False.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``shape`` and
+            type will convert to complex if that of the input is another.
+
+    .. seealso:: :func:`scipy.fftpack.fft2`
+
+    .. note::
+       The argument `plan` is currently experimental and the interface may be
+       changed in the future version.
+    """
+    from cupy.cuda import cufft
+
+    func = _default_fft_func(x, shape, axes, plan)
+    return func(x, shape, axes, None, cufft.CUFFT_FORWARD,
+                overwrite_x=overwrite_x, plan=plan)
+
+
+def ifft2(x, shape=None, axes=(-2, -1), overwrite_x=False, plan=None):
+    """Compute the two-dimensional inverse FFT.
+
+    Args:
+        x (cupy.ndarray): Array to be transformed.
+        shape (None or tuple of ints): Shape of the transformed axes of the
+            output. If ``shape`` is not given, the lengths of the input along
+            the axes specified by ``axes`` are used.
+        axes (tuple of ints): Axes over which to compute the FFT.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+        plan (:class:`cupy.cuda.cufft.PlanNd` or ``None``): a cuFFT plan for
+            transforming ``x`` over ``axes``, which can be obtained using::
+
+                plan = cupyx.scipy.fftpack.get_fft_plan(x, axes)
+
+            Note that `plan` is defaulted to None, meaning CuPy will either
+            use an auto-generated plan behind the scene if cupy.fft.config.
+            enable_nd_planning = True, or use no cuFFT plan if it is set to
+            False.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``shape`` and
+            type will convert to complex if that of the input is another.
+
+    .. seealso:: :func:`scipy.fftpack.ifft2`
+
+    .. note::
+       The argument `plan` is currently experimental and the interface may be
+       changed in the future version.
+    """
+    from cupy.cuda import cufft
+
+    func = _default_fft_func(x, shape, axes, plan)
+    return func(x, shape, axes, None, cufft.CUFFT_INVERSE,
+                overwrite_x=overwrite_x, plan=plan)
+
+
+def fftn(x, shape=None, axes=None, overwrite_x=False, plan=None):
+    """Compute the N-dimensional FFT.
+
+    Args:
+        x (cupy.ndarray): Array to be transformed.
+        shape (None or tuple of ints): Shape of the transformed axes of the
+            output. If ``shape`` is not given, the lengths of the input along
+            the axes specified by ``axes`` are used.
+        axes (tuple of ints): Axes over which to compute the FFT.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+        plan (:class:`cupy.cuda.cufft.PlanNd` or ``None``): a cuFFT plan for
+            transforming ``x`` over ``axes``, which can be obtained using::
+
+                plan = cupyx.scipy.fftpack.get_fft_plan(x, axes)
+
+            Note that `plan` is defaulted to None, meaning CuPy will either
+            use an auto-generated plan behind the scene if cupy.fft.config.
+            enable_nd_planning = True, or use no cuFFT plan if it is set to
+            False.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``shape`` and
+            type will convert to complex if that of the input is another.
+
+    .. seealso:: :func:`scipy.fftpack.fftn`
+
+    .. note::
+       The argument `plan` is currently experimental and the interface may be
+       changed in the future version.
+    """
+    from cupy.cuda import cufft
+
+    func = _default_fft_func(x, shape, axes, plan)
+    return func(x, shape, axes, None, cufft.CUFFT_FORWARD,
+                overwrite_x=overwrite_x, plan=plan)
+
+
+def ifftn(x, shape=None, axes=None, overwrite_x=False, plan=None):
+    """Compute the N-dimensional inverse FFT.
+
+    Args:
+        x (cupy.ndarray): Array to be transformed.
+        shape (None or tuple of ints): Shape of the transformed axes of the
+            output. If ``shape`` is not given, the lengths of the input along
+            the axes specified by ``axes`` are used.
+        axes (tuple of ints): Axes over which to compute the FFT.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+        plan (:class:`cupy.cuda.cufft.PlanNd` or ``None``): a cuFFT plan for
+            transforming ``x`` over ``axes``, which can be obtained using::
+
+                plan = cupyx.scipy.fftpack.get_fft_plan(x, axes)
+
+            Note that `plan` is defaulted to None, meaning CuPy will either
+            use an auto-generated plan behind the scene if cupy.fft.config.
+            enable_nd_planning = True, or use no cuFFT plan if it is set to
+            False.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array which shape is specified by ``shape`` and
+            type will convert to complex if that of the input is another.
+
+    .. seealso:: :func:`scipy.fftpack.ifftn`
+
+    .. note::
+       The argument `plan` is currently experimental and the interface may be
+       changed in the future version.
+    """
+    from cupy.cuda import cufft
+
+    func = _default_fft_func(x, shape, axes, plan)
+    return func(x, shape, axes, None, cufft.CUFFT_INVERSE,
+                overwrite_x=overwrite_x, plan=plan)
+
+
+def rfft(x, n=None, axis=-1, overwrite_x=False, plan=None):
+    """Compute the one-dimensional FFT for real input.
+
+    The returned real array contains
+
+    .. code-block:: python
+
+        [y(0),Re(y(1)),Im(y(1)),...,Re(y(n/2))]  # if n is even
+        [y(0),Re(y(1)),Im(y(1)),...,Re(y(n/2)),Im(y(n/2))]  # if n is odd
+
+    Args:
+        x (cupy.ndarray): Array to be transformed.
+        n (None or int): Length of the transformed axis of the output. If ``n``
+            is not given, the length of the input along the axis specified by
+            ``axis`` is used.
+        axis (int): Axis over which to compute the FFT.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+        plan (:class:`cupy.cuda.cufft.Plan1d` or ``None``): a cuFFT plan for
+            transforming ``x`` over ``axis``, which can be obtained using::
+
+                plan = cupyx.scipy.fftpack.get_fft_plan(
+                    x, axes, value_type='R2C')
+
+            Note that `plan` is defaulted to None, meaning CuPy will either
+            use an auto-generated plan behind the scene if cupy.fft.config.
+            enable_nd_planning = True, or use no cuFFT plan if it is set to
+            False.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array.
+
+    .. seealso:: :func:`scipy.fftpack.rfft`
+
+    .. note::
+       The argument `plan` is currently experimental and the interface may be
+       changed in the future version.
+    """
+    from cupy.cuda import cufft
+
+    if n is None:
+        n = x.shape[axis]
+
+    shape = list(x.shape)
+    shape[axis] = n
+    f = _fft(x, (n,), (axis,), None, cufft.CUFFT_FORWARD, 'R2C',
+             overwrite_x=overwrite_x, plan=plan)
+    z = cupy.empty(shape, f.real.dtype)
+
+    slice_z = [slice(None)] * x.ndim
+    slice_f = [slice(None)] * x.ndim
+
+    slice_z[axis] = slice(1)
+    slice_f[axis] = slice(1)
+    z[tuple(slice_z)] = f[tuple(slice_f)].real
+
+    slice_z[axis] = slice(1, None, 2)
+    slice_f[axis] = slice(1, None)
+    z[tuple(slice_z)] = f[tuple(slice_f)].real
+
+    slice_z[axis] = slice(2, None, 2)
+    slice_f[axis] = slice(1, n - f.shape[axis] + 1)
+    z[tuple(slice_z)] = f[tuple(slice_f)].imag
+
+    return z
+
+
+def irfft(x, n=None, axis=-1, overwrite_x=False):
+    """Compute the one-dimensional inverse FFT for real input.
+
+    Args:
+        x (cupy.ndarray): Array to be transformed.
+        n (None or int): Length of the transformed axis of the output. If ``n``
+            is not given, the length of the input along the axis specified by
+            ``axis`` is used.
+        axis (int): Axis over which to compute the FFT.
+        overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
+
+    Returns:
+        cupy.ndarray:
+            The transformed array.
+
+    .. seealso:: :func:`scipy.fftpack.irfft`
+
+    .. note::
+       This function does not support a precomputed `plan`. If you need this
+       capability, please consider using :func:`cupy.fft.irfft` or :func:`
+       cupyx.scipy.fft.irfft`.
+    """
+    from cupy.cuda import cufft
+
+    if n is None:
+        n = x.shape[axis]
+    m = min(n, x.shape[axis])
+
+    shape = list(x.shape)
+    shape[axis] = n // 2 + 1
+    if x.dtype in (cupy.float16, cupy.float32):
+        z = cupy.zeros(shape, dtype=cupy.complex64)
+    else:
+        z = cupy.zeros(shape, dtype=cupy.complex128)
+
+    slice_x = [slice(None)] * x.ndim
+    slice_z = [slice(None)] * x.ndim
+
+    slice_x[axis] = slice(1)
+    slice_z[axis] = slice(1)
+    z[tuple(slice_z)].real = x[tuple(slice_x)]
+
+    slice_x[axis] = slice(1, m, 2)
+    slice_z[axis] = slice(1, m // 2 + 1)
+    z[tuple(slice_z)].real = x[tuple(slice_x)]
+
+    slice_x[axis] = slice(2, m, 2)
+    slice_z[axis] = slice(1, (m + 1) // 2)
+    z[tuple(slice_z)].imag = x[tuple(slice_x)]
+
+    return _fft(z, (n,), (axis,), None, cufft.CUFFT_INVERSE, 'C2R',
+                overwrite_x=overwrite_x)

vllm/lib/python3.10/site-packages/cupyx/scipy/signal/__init__.py

@@ -0,0 +1,175 @@
+from cupyx.scipy.signal._signaltools import convolve  # NOQA
+from cupyx.scipy.signal._signaltools import correlate  # NOQA
+from cupyx.scipy.signal._signaltools import deconvolve  # NOQA
+from cupyx.scipy.signal._signaltools import fftconvolve  # NOQA
+from cupyx.scipy.signal._signaltools import choose_conv_method  # NOQA
+from cupyx.scipy.signal._signaltools import oaconvolve  # NOQA
+from cupyx.scipy.signal._signaltools import convolve2d  # NOQA
+from cupyx.scipy.signal._signaltools import correlate2d  # NOQA
+from cupyx.scipy.signal._signaltools import correlation_lags  # NOQA
+from cupyx.scipy.signal._signaltools import wiener  # NOQA
+from cupyx.scipy.signal._signaltools import order_filter  # NOQA
+from cupyx.scipy.signal._signaltools import medfilt  # NOQA
+from cupyx.scipy.signal._signaltools import medfilt2d  # NOQA
+from cupyx.scipy.signal._signaltools import lfilter  # NOQA
+from cupyx.scipy.signal._signaltools import lfiltic  # NOQA
+from cupyx.scipy.signal._signaltools import lfilter_zi  # NOQA
+from cupyx.scipy.signal._signaltools import detrend  # NOQA
+from cupyx.scipy.signal._signaltools import filtfilt  # NOQA
+from cupyx.scipy.signal._signaltools import sosfilt  # NOQA
+from cupyx.scipy.signal._signaltools import sosfilt_zi  # NOQA
+from cupyx.scipy.signal._signaltools import sosfiltfilt  # NOQA
+from cupyx.scipy.signal._signaltools import hilbert  # NOQA
+from cupyx.scipy.signal._signaltools import hilbert2  # NOQA
+
+from cupyx.scipy.signal._resample import resample  # NOQA
+from cupyx.scipy.signal._resample import resample_poly  # NOQA
+from cupyx.scipy.signal._resample import decimate  # NOQA
+
+from cupyx.scipy.signal._polyutils import unique_roots  # NOQA
+from cupyx.scipy.signal._polyutils import invres  # NOQA
+from cupyx.scipy.signal._polyutils import invresz  # NOQA
+from cupyx.scipy.signal._polyutils import residue  # NOQA
+from cupyx.scipy.signal._polyutils import residuez  # NOQA
+
+from cupyx.scipy.signal._bsplines import sepfir2d  # NOQA
+from cupyx.scipy.signal._bsplines import cspline1d  # NOQA
+from cupyx.scipy.signal._bsplines import qspline1d  # NOQA
+from cupyx.scipy.signal._bsplines import cspline2d  # NOQA
+from cupyx.scipy.signal._bsplines import qspline2d  # NOQA
+from cupyx.scipy.signal._bsplines import cspline1d_eval  # NOQA
+from cupyx.scipy.signal._bsplines import qspline1d_eval  # NOQA
+from cupyx.scipy.signal._bsplines import spline_filter  # NOQA
+from cupyx.scipy.signal._bsplines import gauss_spline  # NOQA
+
+from cupyx.scipy.signal._splines import symiirorder1  # NOQA
+from cupyx.scipy.signal._splines import symiirorder2  # NOQA
+
+from cupyx.scipy.signal._savitzky_golay import savgol_coeffs, savgol_filter   # NOQA
+
+from cupyx.scipy.signal._filter_design import gammatone  # NOQA
+from cupyx.scipy.signal._filter_design import group_delay  # NOQA
+
+from cupyx.scipy.signal._fir_filter_design import kaiser_atten  # NOQA
+from cupyx.scipy.signal._fir_filter_design import kaiser_beta  # NOQA
+from cupyx.scipy.signal._fir_filter_design import kaiserord  # NOQA
+
+from cupyx.scipy.signal._iir_filter_conversions import BadCoefficients  # NOQA
+from cupyx.scipy.signal._iir_filter_conversions import normalize  # NOQA
+
+from cupyx.scipy.signal._iir_filter_conversions import bilinear  # NOQA
+from cupyx.scipy.signal._iir_filter_conversions import lp2lp  # NOQA
+from cupyx.scipy.signal._iir_filter_conversions import lp2hp  # NOQA
+from cupyx.scipy.signal._iir_filter_conversions import lp2bp  # NOQA
+from cupyx.scipy.signal._iir_filter_conversions import lp2bs  # NOQA
+
+from cupyx.scipy.signal._iir_filter_conversions import bilinear_zpk  # NOQA
+from cupyx.scipy.signal._iir_filter_conversions import lp2lp_zpk  # NOQA
+from cupyx.scipy.signal._iir_filter_conversions import lp2hp_zpk  # NOQA
+from cupyx.scipy.signal._iir_filter_conversions import lp2bp_zpk  # NOQA
+from cupyx.scipy.signal._iir_filter_conversions import lp2bs_zpk  # NOQA
+
+from cupyx.scipy.signal._iir_filter_conversions import zpk2tf  # NOQA
+from cupyx.scipy.signal._iir_filter_conversions import zpk2sos  # NOQA
+from cupyx.scipy.signal._iir_filter_conversions import zpk2ss   # NOQA
+from cupyx.scipy.signal._iir_filter_conversions import tf2zpk  # NOQA
+from cupyx.scipy.signal._iir_filter_conversions import tf2sos  # NOQA
+from cupyx.scipy.signal._iir_filter_conversions import tf2ss  # NOQA
+from cupyx.scipy.signal._iir_filter_conversions import ss2tf  # NOQA
+from cupyx.scipy.signal._iir_filter_conversions import ss2zpk  # NOQA
+from cupyx.scipy.signal._iir_filter_conversions import sos2tf  # NOQA
+from cupyx.scipy.signal._iir_filter_conversions import sos2zpk  # NOQA
+
+from cupyx.scipy.signal._iir_filter_conversions import band_stop_obj  # NOQA
+from cupyx.scipy.signal.windows._windows import get_window  # NOQA
+
+from cupyx.scipy.signal._iir_filter_conversions import buttap  # NOQA
+from cupyx.scipy.signal._iir_filter_conversions import cheb1ap  # NOQA
+from cupyx.scipy.signal._iir_filter_conversions import cheb2ap  # NOQA
+from cupyx.scipy.signal._iir_filter_conversions import ellipap  # NOQA
+
+from cupyx.scipy.signal._iir_filter_conversions import buttord  # NOQA
+from cupyx.scipy.signal._iir_filter_conversions import cheb1ord  # NOQA
+from cupyx.scipy.signal._iir_filter_conversions import cheb2ord  # NOQA
+from cupyx.scipy.signal._iir_filter_conversions import ellipord  # NOQA
+
+from cupyx.scipy.signal._iir_filter_design import iirfilter  # NOQA
+from cupyx.scipy.signal._iir_filter_design import butter  # NOQA
+from cupyx.scipy.signal._iir_filter_design import cheby1  # NOQA
+from cupyx.scipy.signal._iir_filter_design import cheby2  # NOQA
+from cupyx.scipy.signal._iir_filter_design import ellip  # NOQA
+from cupyx.scipy.signal._iir_filter_design import iirdesign  # NOQA
+from cupyx.scipy.signal._iir_filter_design import iircomb  # NOQA
+from cupyx.scipy.signal._iir_filter_design import iirnotch  # NOQA
+from cupyx.scipy.signal._iir_filter_design import iirpeak  # NOQA
+
+from cupyx.scipy.signal._fir_filter_design import firwin  # NOQA
+from cupyx.scipy.signal._fir_filter_design import firwin2  # NOQA
+from cupyx.scipy.signal._fir_filter_design import firls  # NOQA
+from cupyx.scipy.signal._fir_filter_design import minimum_phase  # NOQA
+
+from cupyx.scipy.signal._filter_design import findfreqs  # NOQA
+from cupyx.scipy.signal._filter_design import freqs  # NOQA
+from cupyx.scipy.signal._filter_design import freqs_zpk  # NOQA
+
+from cupyx.scipy.signal._filter_design import freqz  # NOQA
+from cupyx.scipy.signal._filter_design import freqz_zpk  # NOQA
+from cupyx.scipy.signal._filter_design import sosfreqz  # NOQA
+
+from cupyx.scipy.signal._waveforms import chirp  # NOQA
+from cupyx.scipy.signal._waveforms import gausspulse  # NOQA
+from cupyx.scipy.signal._waveforms import sawtooth  # NOQA
+from cupyx.scipy.signal._waveforms import square  # NOQA
+from cupyx.scipy.signal._waveforms import unit_impulse  # NOQA
+from cupyx.scipy.signal._max_len_seq import max_len_seq  # NOQA
+
+from cupyx.scipy.signal._czt import *   # NOQA
+
+from cupyx.scipy.signal._wavelets import morlet  # NOQA
+from cupyx.scipy.signal._wavelets import qmf  # NOQA
+from cupyx.scipy.signal._wavelets import ricker  # NOQA
+from cupyx.scipy.signal._wavelets import morlet2  # NOQA
+from cupyx.scipy.signal._wavelets import cwt  # NOQA
+
+from cupyx.scipy.signal._lti_conversion import abcd_normalize   # NOQA
+
+from cupyx.scipy.signal._upfirdn import upfirdn  # NOQA
+
+from cupyx.scipy.signal._peak_finding import find_peaks  # NOQA
+from cupyx.scipy.signal._peak_finding import peak_prominences  # NOQA
+from cupyx.scipy.signal._peak_finding import peak_widths  # NOQA
+
+from cupyx.scipy.signal._ltisys import lti  # NOQA
+from cupyx.scipy.signal._ltisys import lsim  # NOQA
+from cupyx.scipy.signal._ltisys import impulse  # NOQA
+from cupyx.scipy.signal._ltisys import step  # NOQA
+from cupyx.scipy.signal._ltisys import freqresp  # NOQA
+from cupyx.scipy.signal._ltisys import bode  # NOQA
+
+from cupyx.scipy.signal._ltisys import dlti  # NOQA
+from cupyx.scipy.signal._ltisys import dlsim  # NOQA
+from cupyx.scipy.signal._ltisys import dstep  # NOQA
+from cupyx.scipy.signal._ltisys import dimpulse  # NOQA
+from cupyx.scipy.signal._ltisys import dbode  # NOQA
+from cupyx.scipy.signal._ltisys import dfreqresp  # NOQA
+from cupyx.scipy.signal._ltisys import StateSpace  # NOQA
+from cupyx.scipy.signal._ltisys import TransferFunction  # NOQA
+from cupyx.scipy.signal._ltisys import ZerosPolesGain  # NOQA
+from cupyx.scipy.signal._ltisys import cont2discrete  # NOQA
+from cupyx.scipy.signal._ltisys import place_poles  # NOQA
+
+from cupyx.scipy.signal._spectral import lombscargle  # NOQA
+from cupyx.scipy.signal._spectral import periodogram  # NOQA
+from cupyx.scipy.signal._spectral import welch  # NOQA
+from cupyx.scipy.signal._spectral import csd  # NOQA
+from cupyx.scipy.signal._spectral import check_COLA  # NOQA
+from cupyx.scipy.signal._spectral import check_NOLA  # NOQA
+from cupyx.scipy.signal._spectral import stft  # NOQA
+from cupyx.scipy.signal._spectral import istft  # NOQA
+from cupyx.scipy.signal._spectral import spectrogram  # NOQA
+from cupyx.scipy.signal._spectral import vectorstrength  # NOQA
+from cupyx.scipy.signal._spectral import coherence  # NOQA
+
+from cupyx.scipy.signal._peak_finding import argrelextrema  # NOQA
+from cupyx.scipy.signal._peak_finding import argrelmin  # NOQA
+from cupyx.scipy.signal._peak_finding import argrelmax  # NOQA

vllm/lib/python3.10/site-packages/cupyx/scipy/signal/_arraytools.py

@@ -0,0 +1,272 @@
+"""
+Functions for acting on a axis of an array.
+"""
+import cupy
+
+
+def axis_slice(a, start=None, stop=None, step=None, axis=-1):
+    """Take a slice along axis 'axis' from 'a'.
+
+    Parameters
+    ----------
+    a : cupy.ndarray
+        The array to be sliced.
+    start, stop, step : int or None
+        The slice parameters.
+    axis : int, optional
+        The axis of `a` to be sliced.
+
+    Examples
+    --------
+    >>> a = array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    >>> axis_slice(a, start=0, stop=1, axis=1)
+    array([[1],
+           [4],
+           [7]])
+    >>> axis_slice(a, start=1, axis=0)
+    array([[4, 5, 6],
+           [7, 8, 9]])
+
+    Notes
+    -----
+    The keyword arguments start, stop and step are used by calling
+    slice(start, stop, step). This implies axis_slice() does not
+    handle its arguments the exactly the same as indexing. To select
+    a single index k, for example, use
+        axis_slice(a, start=k, stop=k+1)
+    In this case, the length of the axis 'axis' in the result will
+    be 1; the trivial dimension is not removed. (Use cupy.squeeze()
+    to remove trivial axes.)
+    """
+    a_slice = [slice(None)] * a.ndim
+    a_slice[axis] = slice(start, stop, step)
+    b = a[tuple(a_slice)]
+    return b
+
+
+def axis_assign(a, b, start=None, stop=None, step=None, axis=-1):
+    """Take a slice along axis 'axis' from 'a' and set it to 'b' in-place.
+
+    Parameters
+    ----------
+    a : numpy.ndarray
+        The array to be sliced.
+    b : cupy.ndarray
+        The array to be assigned.
+    start, stop, step : int or None
+        The slice parameters.
+    axis : int, optional
+        The axis of `a` to be sliced.
+
+    Examples
+    --------
+    >>> a = array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    >>> b1 = array([[-1], [-4], [-7]])
+    >>> axis_assign(a, b1, start=0, stop=1, axis=1)
+    array([[-1, 2, 3],
+           [-4, 5, 6],
+           [-7, 8, 9]])
+
+    Notes
+    -----
+    The keyword arguments start, stop and step are used by calling
+    slice(start, stop, step). This implies axis_assign() does not
+    handle its arguments the exactly the same as indexing. To assign
+    a single index k, for example, use
+        axis_assign(a, start=k, stop=k+1)
+    In this case, the length of the axis 'axis' in the result will
+    be 1; the trivial dimension is not removed. (Use numpy.squeeze()
+    to remove trivial axes.)
+
+    This function works in-place and will modify the values contained in `a`
+    """
+    a_slice = [slice(None)] * a.ndim
+    a_slice[axis] = slice(start, stop, step)
+    a[tuple(a_slice)] = b
+    return a
+
+
+def axis_reverse(a, axis=-1):
+    """Reverse the 1-D slices of `a` along axis `axis`.
+
+    Returns axis_slice(a, step=-1, axis=axis).
+    """
+    return axis_slice(a, step=-1, axis=axis)
+
+
+def odd_ext(x, n, axis=-1):
+    """
+    Odd extension at the boundaries of an array
+
+    Generate a new ndarray by making an odd extension of `x` along an axis.
+
+    Parameters
+    ----------
+    x : ndarray
+        The array to be extended.
+    n : int
+        The number of elements by which to extend `x` at each end of the axis.
+    axis : int, optional
+        The axis along which to extend `x`. Default is -1.
+
+    Examples
+    --------
+    >>> from cupyx.scipy.signal._arraytools import odd_ext
+    >>> a = cupy.array([[1, 2, 3, 4, 5], [0, 1, 4, 9, 16]])
+    >>> odd_ext(a, 2)
+    array([[-1,  0,  1,  2,  3,  4,  5,  6,  7],
+           [-4, -1,  0,  1,  4,  9, 16, 23, 28]])
+    """
+    if n < 1:
+        return x
+    if n > x.shape[axis] - 1:
+        raise ValueError(("The extension length n (%d) is too big. " +
+                          "It must not exceed x.shape[axis]-1, which is %d.")
+                         % (n, x.shape[axis] - 1))
+    left_end = axis_slice(x, start=0, stop=1, axis=axis)
+    left_ext = axis_slice(x, start=n, stop=0, step=-1, axis=axis)
+    right_end = axis_slice(x, start=-1, axis=axis)
+    right_ext = axis_slice(x, start=-2, stop=-(n + 2), step=-1, axis=axis)
+    ext = cupy.concatenate((2 * left_end - left_ext, x,
+                            2 * right_end - right_ext), axis=axis)
+    return ext
+
+
+def even_ext(x, n, axis=-1):
+    """
+    Even extension at the boundaries of an array
+
+    Generate a new ndarray by making an even extension of `x` along an axis.
+
+    Parameters
+    ----------
+    x : ndarray
+        The array to be extended.
+    n : int
+        The number of elements by which to extend `x` at each end of the axis.
+    axis : int, optional
+        The axis along which to extend `x`. Default is -1.
+
+    Examples
+    --------
+    >>> from cupyx.scipy.signal._arraytools import even_ext
+    >>> a = cupy.array([[1, 2, 3, 4, 5], [0, 1, 4, 9, 16]])
+    >>> even_ext(a, 2)
+    array([[ 3,  2,  1,  2,  3,  4,  5,  4,  3],
+           [ 4,  1,  0,  1,  4,  9, 16,  9,  4]])
+
+    """
+    if n < 1:
+        return x
+    if n > x.shape[axis] - 1:
+        raise ValueError(("The extension length n (%d) is too big. " +
+                          "It must not exceed x.shape[axis]-1, which is %d.")
+                         % (n, x.shape[axis] - 1))
+    left_ext = axis_slice(x, start=n, stop=0, step=-1, axis=axis)
+    right_ext = axis_slice(x, start=-2, stop=-(n + 2), step=-1, axis=axis)
+    ext = cupy.concatenate((left_ext, x, right_ext), axis=axis)
+    return ext
+
+
+def const_ext(x, n, axis=-1):
+    """
+    Constant extension at the boundaries of an array
+
+    Generate a new ndarray that is a constant extension of `x` along an axis.
+    The extension repeats the values at the first and last element of
+    the axis.
+
+    Parameters
+    ----------
+    x : ndarray
+        The array to be extended.
+    n : int
+        The number of elements by which to extend `x` at each end of the axis.
+    axis : int, optional
+        The axis along which to extend `x`. Default is -1.
+
+    Examples
+    --------
+    >>> from cupyx.scipy.signal._arraytools import const_ext
+    >>> a = cupy.array([[1, 2, 3, 4, 5], [0, 1, 4, 9, 16]])
+    >>> const_ext(a, 2)
+    array([[ 1,  1,  1,  2,  3,  4,  5,  5,  5],
+           [ 0,  0,  0,  1,  4,  9, 16, 16, 16]])
+    """
+    if n < 1:
+        return x
+    left_end = axis_slice(x, start=0, stop=1, axis=axis)
+    ones_shape = [1] * x.ndim
+    ones_shape[axis] = n
+    ones = cupy.ones(ones_shape, dtype=x.dtype)
+    left_ext = ones * left_end
+    right_end = axis_slice(x, start=-1, axis=axis)
+    right_ext = ones * right_end
+    ext = cupy.concatenate((left_ext, x, right_ext), axis=axis)
+    return ext
+
+
+def zero_ext(x, n, axis=-1):
+    """
+    Zero padding at the boundaries of an array
+
+    Generate a new ndarray that is a zero-padded extension of `x` along
+    an axis.
+
+    Parameters
+    ----------
+    x : ndarray
+        The array to be extended.
+    n : int
+        The number of elements by which to extend `x` at each end of the
+        axis.
+    axis : int, optional
+        The axis along which to extend `x`. Default is -1.
+
+    Examples
+    --------
+    >>> from cupyx.scipy.signal._arraytools import zero_ext
+    >>> a = cupy.array([[1, 2, 3, 4, 5], [0, 1, 4, 9, 16]])
+    >>> zero_ext(a, 2)
+    array([[ 0,  0,  1,  2,  3,  4,  5,  0,  0],
+           [ 0,  0,  0,  1,  4,  9, 16,  0,  0]])
+    """
+    if n < 1:
+        return x
+    zeros_shape = list(x.shape)
+    zeros_shape[axis] = n
+    zeros = cupy.zeros(zeros_shape, dtype=x.dtype)
+    ext = cupy.concatenate((zeros, x, zeros), axis=axis)
+    return ext
+
+
+def _as_strided(x, shape=None, strides=None):
+    """
+    Create a view into the array with the given shape and strides.
+    .. warning:: This function has to be used with extreme care, see notes.
+
+    Parameters
+    ----------
+    x : ndarray
+        Array to create a new.
+    shape : sequence of int, optional
+        The shape of the new array. Defaults to ``x.shape``.
+    strides : sequence of int, optional
+        The strides of the new array. Defaults to ``x.strides``.
+
+    Returns
+    -------
+    view : ndarray
+
+    Notes
+    -----
+    ``as_strided`` creates a view into the array given the exact strides
+    and shape. This means it manipulates the internal data structure of
+    ndarray and, if done incorrectly, the array elements can point to
+    invalid memory and can corrupt results or crash your program.
+    """
+    shape = x.shape if shape is None else tuple(shape)
+    strides = x.strides if strides is None else tuple(strides)
+
+    return cupy.ndarray(
+        shape=shape, dtype=x.dtype, memptr=x.data, strides=strides)

vllm/lib/python3.10/site-packages/cupyx/scipy/signal/_bsplines.py

@@ -0,0 +1,596 @@
+
+"""
+Signal processing B-Splines
+
+Some of the functions defined here were ported directly from CuSignal under
+terms of the MIT license, under the following notice:
+
+Copyright (c) 2019-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+"""
+
+import cupy
+import cupyx.scipy.ndimage
+
+from cupyx.scipy.signal._iir_utils import apply_iir_sos
+from cupyx.scipy.signal._splines import _symiirorder1_nd, _symiirorder2_nd
+from cupyx.scipy.interpolate._bspline import BSpline
+
+import numpy as np
+
+
+def sepfir2d(input, hrow, hcol):
+    """Convolve with a 2-D separable FIR filter.
+
+    Convolve the rank-2 input array with the separable filter defined by the
+    rank-1 arrays hrow, and hcol. Mirror symmetric boundary conditions are
+    assumed. This function can be used to find an image given its B-spline
+    representation.
+
+    The arguments `hrow` and `hcol` must be 1-dimensional and of off length.
+
+    Args:
+        input (cupy.ndarray): The input signal
+        hrow (cupy.ndarray): Row direction filter
+        hcol (cupy.ndarray): Column direction filter
+
+    Returns:
+        cupy.ndarray: The filtered signal
+
+    .. seealso:: :func:`scipy.signal.sepfir2d`
+    """
+    if any(x.ndim != 1 or x.size % 2 == 0 for x in (hrow, hcol)):
+        raise ValueError('hrow and hcol must be 1 dimensional and odd length')
+    dtype = input.dtype
+    if dtype.kind == 'c':
+        dtype = cupy.complex64 if dtype == cupy.complex64 else cupy.complex128
+    elif dtype == cupy.float32 or dtype.itemsize <= 2:
+        dtype = cupy.float32
+    else:
+        dtype = cupy.float64
+    input = input.astype(dtype, copy=False)
+    hrow = hrow.astype(dtype, copy=False)
+    hcol = hcol.astype(dtype, copy=False)
+    filters = (hcol[::-1].conj(), hrow[::-1].conj())
+    return cupyx.scipy.ndimage._filters._run_1d_correlates(
+        input, (0, 1), lambda i: filters[i], None, 'reflect', 0)
+
+
+def _quadratic(x):
+    x = abs(cupy.asarray(x, dtype=float))
+    b = BSpline.basis_element(
+        cupy.asarray([-1.5, -0.5, 0.5, 1.5]), extrapolate=False)
+    out = b(x)
+    out[(x < -1.5) | (x > 1.5)] = 0
+    return out
+
+
+def _cubic(x):
+    x = cupy.asarray(x, dtype=float)
+    b = BSpline.basis_element(
+        cupy.asarray([-2, -1, 0, 1, 2]), extrapolate=False)
+    out = b(x)
+    out[(x < -2) | (x > 2)] = 0
+    return out
+
+
+@cupy.fuse()
+def _coeff_smooth(lam):
+    xi = 1 - 96 * lam + 24 * lam * cupy.sqrt(3 + 144 * lam)
+    omeg = cupy.arctan2(cupy.sqrt(144 * lam - 1), cupy.sqrt(xi))
+    rho = (24 * lam - 1 - cupy.sqrt(xi)) / (24 * lam)
+    rho = rho * cupy.sqrt(
+        (48 * lam + 24 * lam * cupy.sqrt(3 + 144 * lam)) / xi)
+    return rho, omeg
+
+
+@cupy.fuse()
+def _hc(k, cs, rho, omega):
+    return (cs / cupy.sin(omega) * (rho ** k) * cupy.sin(omega * (k + 1)) *
+            cupy.greater(k, -1))
+
+
+@cupy.fuse()
+def _hs(k, cs, rho, omega):
+    c0 = (cs * cs * (1 + rho * rho) / (1 - rho * rho) /
+          (1 - 2 * rho * rho * cupy.cos(2 * omega) + rho ** 4))
+    gamma = (1 - rho * rho) / (1 + rho * rho) / cupy.tan(omega)
+    ak = cupy.abs(k)
+    return c0 * rho ** ak * (
+        cupy.cos(omega * ak) + gamma * cupy.sin(omega * ak))
+
+
+def _cubic_smooth_coeff(signal, lamb):
+    rho, omega = _coeff_smooth(lamb)
+    cs = 1 - 2 * rho * cupy.cos(omega) + rho * rho
+    K = len(signal)
+    yp = cupy.zeros((K,), signal.dtype.char)
+    k = cupy.arange(K)
+
+    state_0 = (_hc(0, cs, rho, omega) * signal[0] +
+               cupy.sum(_hc(k + 1, cs, rho, omega) * signal))
+    state_1 = (_hc(0, cs, rho, omega) * signal[0] +
+               _hc(1, cs, rho, omega) * signal[1] +
+               cupy.sum(_hc(k + 2, cs, rho, omega) * signal))
+
+    zi = cupy.r_[0, 0, state_0, state_1]
+    zi = cupy.atleast_2d(zi)
+
+    coef = cupy.r_[cs, 0, 0, 1, -2 * rho * cupy.cos(omega), rho * rho]
+    coef = cupy.atleast_2d(coef)
+
+    # Forward pass:
+    #
+    # yp[0] = (_hc(0, cs, rho, omega) * signal[0] +
+    #          cupy.sum(_hc(k + 1, cs, rho, omega) * signal))
+    # yp[1] = (_hc(0, cs, rho, omega) * signal[0] +
+    #          _hc(1, cs, rho, omega) * signal[1] +
+    #          cupy.sum(_hc(k + 2, cs, rho, omega) * signal))
+    # for n in range(2, K):
+    #     yp[n] = (cs * signal[n] + 2 * rho * cupy.cos(omega) * yp[n - 1] -
+    #              rho * rho * yp[n - 2])
+
+    yp, _ = apply_iir_sos(signal[2:], coef, zi=zi, dtype=signal.dtype)
+    yp = cupy.r_[state_0, state_1, yp]
+
+    # Reverse pass:
+    #
+    # y[K - 1] = cupy.sum((_hs(k, cs, rho, omega) +
+    #                      _hs(k + 1, cs, rho, omega)) * signal[::-1])
+    # y[K - 2] = cupy.sum((_hs(k - 1, cs, rho, omega) +
+    #                      _hs(k + 2, cs, rho, omega)) * signal[::-1])
+    # for n in range(K - 3, -1, -1):
+    #     y[n] = (cs * yp[n] + 2 * rho * cupy.cos(omega) * y[n + 1] -
+    #             rho * rho * y[n + 2])
+
+    state_0 = cupy.sum((_hs(k, cs, rho, omega) +
+                        _hs(k + 1, cs, rho, omega)) * signal[::-1])
+    state_1 = cupy.sum((_hs(k - 1, cs, rho, omega) +
+                        _hs(k + 2, cs, rho, omega)) * signal[::-1])
+
+    zi = cupy.r_[0, 0, state_0, state_1]
+    zi = cupy.atleast_2d(zi)
+
+    y, _ = apply_iir_sos(yp[-3::-1], coef, zi=zi, dtype=signal.dtype)
+    y = cupy.r_[y[::-1], state_1, state_0]
+    return y
+
+
+def _cubic_coeff(signal):
+    zi = -2 + cupy.sqrt(3)
+    K = len(signal)
+    powers = zi ** cupy.arange(K)
+
+    if K == 1:
+        yplus = signal[0] + zi * cupy.sum(powers * signal)
+        output = zi / (zi - 1) * yplus
+        return cupy.atleast_1d(output)
+
+    state = cupy.r_[0, 0, 0, cupy.sum(powers * signal)]
+    state = cupy.atleast_2d(state)
+    coef = cupy.r_[1, 0, 0, 1, -zi, 0]
+    coef = cupy.atleast_2d(coef)
+
+    # yplus[0] = signal[0] + zi * sum(powers * signal)
+    # for k in range(1, K):
+    #     yplus[k] = signal[k] + zi * yplus[k - 1]
+    yplus, _ = apply_iir_sos(signal, coef, zi=state, apply_fir=False,
+                             dtype=signal.dtype)
+
+    out_last = zi / (zi - 1) * yplus[K - 1]
+    state = cupy.r_[0, 0, 0, out_last]
+    state = cupy.atleast_2d(state)
+
+    coef = cupy.r_[-zi, 0, 0, 1, -zi, 0]
+    coef = cupy.atleast_2d(coef)
+
+    # output[K - 1] = zi / (zi - 1) * yplus[K - 1]
+    # for k in range(K - 2, -1, -1):
+    #     output[k] = zi * (output[k + 1] - yplus[k])
+    output, _ = apply_iir_sos(
+        yplus[-2::-1], coef, zi=state, dtype=signal.dtype)
+    output = cupy.r_[output[::-1], out_last]
+    return output * 6.0
+
+
+def _quadratic_coeff(signal):
+    zi = -3 + 2 * cupy.sqrt(2.0)
+    K = len(signal)
+    powers = zi ** cupy.arange(K)
+
+    if K == 1:
+        yplus = signal[0] + zi * cupy.sum(powers * signal)
+        output = zi / (zi - 1) * yplus
+        return cupy.atleast_1d(output)
+
+    state = cupy.r_[0, 0, 0, cupy.sum(powers * signal)]
+    state = cupy.atleast_2d(state)
+    coef = cupy.r_[1, 0, 0, 1, -zi, 0]
+    coef = cupy.atleast_2d(coef)
+
+    # yplus[0] = signal[0] + zi * cupy.sum(powers * signal)
+    # for k in range(1, K):
+    #     yplus[k] = signal[k] + zi * yplus[k - 1]
+    yplus, _ = apply_iir_sos(signal, coef, zi=state, apply_fir=False,
+                             dtype=signal.dtype)
+
+    out_last = zi / (zi - 1) * yplus[K - 1]
+    state = cupy.r_[0, 0, 0, out_last]
+    state = cupy.atleast_2d(state)
+
+    coef = cupy.r_[-zi, 0, 0, 1, -zi, 0]
+    coef = cupy.atleast_2d(coef)
+
+    # output[K - 1] = zi / (zi - 1) * yplus[K - 1]
+    # for k in range(K - 2, -1, -1):
+    #     output[k] = zi * (output[k + 1] - yplus[k])
+    output, _ = apply_iir_sos(
+        yplus[-2::-1], coef, zi=state, dtype=signal.dtype)
+    output = cupy.r_[output[::-1], out_last]
+    return output * 8.0
+
+
+def compute_root_from_lambda(lamb):
+    tmp = np.sqrt(3 + 144 * lamb)
+    xi = 1 - 96 * lamb + 24 * lamb * tmp
+    omega = np.arctan(np.sqrt((144 * lamb - 1.0) / xi))
+    tmp2 = np.sqrt(xi)
+    r = ((24 * lamb - 1 - tmp2) / (24 * lamb) *
+         np.sqrt((48*lamb + 24 * lamb * tmp)) / tmp2)
+    return r, omega
+
+
+def cspline1d(signal, lamb=0.0):
+    """
+    Compute cubic spline coefficients for rank-1 array.
+
+    Find the cubic spline coefficients for a 1-D signal assuming
+    mirror-symmetric boundary conditions. To obtain the signal back from the
+    spline representation mirror-symmetric-convolve these coefficients with a
+    length 3 FIR window [1.0, 4.0, 1.0]/ 6.0 .
+
+    Parameters
+    ----------
+    signal : ndarray
+        A rank-1 array representing samples of a signal.
+    lamb : float, optional
+        Smoothing coefficient, default is 0.0.
+
+    Returns
+    -------
+    c : ndarray
+        Cubic spline coefficients.
+
+    See Also
+    --------
+    cspline1d_eval : Evaluate a cubic spline at the new set of points.
+
+    """
+    if lamb != 0.0:
+        return _cubic_smooth_coeff(signal, lamb)
+    else:
+        return _cubic_coeff(signal)
+
+
+def qspline1d(signal, lamb=0.0):
+    """Compute quadratic spline coefficients for rank-1 array.
+
+    Parameters
+    ----------
+    signal : ndarray
+        A rank-1 array representing samples of a signal.
+    lamb : float, optional
+        Smoothing coefficient (must be zero for now).
+
+    Returns
+    -------
+    c : ndarray
+        Quadratic spline coefficients.
+
+    See Also
+    --------
+    qspline1d_eval : Evaluate a quadratic spline at the new set of points.
+
+    Notes
+    -----
+    Find the quadratic spline coefficients for a 1-D signal assuming
+    mirror-symmetric boundary conditions. To obtain the signal back from the
+    spline representation mirror-symmetric-convolve these coefficients with a
+    length 3 FIR window [1.0, 6.0, 1.0]/ 8.0 .
+
+    """
+    if lamb != 0.0:
+        raise ValueError("Smoothing quadratic splines not supported yet.")
+    else:
+        return _quadratic_coeff(signal)
+
+
+def cspline1d_eval(cj, newx, dx=1.0, x0=0):
+    """Evaluate a cubic spline at the new set of points.
+
+    `dx` is the old sample-spacing while `x0` was the old origin. In
+    other-words the old-sample points (knot-points) for which the `cj`
+    represent spline coefficients were at equally-spaced points of:
+
+      oldx = x0 + j*dx  j=0...N-1, with N=len(cj)
+
+    Edges are handled using mirror-symmetric boundary conditions.
+
+    Parameters
+    ----------
+    cj : ndarray
+        cublic spline coefficients
+    newx : ndarray
+        New set of points.
+    dx : float, optional
+        Old sample-spacing, the default value is 1.0.
+    x0 : int, optional
+        Old origin, the default value is 0.
+
+    Returns
+    -------
+    res : ndarray
+        Evaluated a cubic spline points.
+
+    See Also
+    --------
+    cspline1d : Compute cubic spline coefficients for rank-1 array.
+
+    """
+    newx = (cupy.asarray(newx) - x0) / float(dx)
+    res = cupy.zeros_like(newx, dtype=cj.dtype)
+    if res.size == 0:
+        return res
+    N = len(cj)
+    cond1 = newx < 0
+    cond2 = newx > (N - 1)
+    cond3 = ~(cond1 | cond2)
+    # handle general mirror-symmetry
+    res[cond1] = cspline1d_eval(cj, -newx[cond1])
+    res[cond2] = cspline1d_eval(cj, 2 * (N - 1) - newx[cond2])
+    newx = newx[cond3]
+    if newx.size == 0:
+        return res
+    result = cupy.zeros_like(newx, dtype=cj.dtype)
+    jlower = cupy.floor(newx - 2).astype(int) + 1
+    for i in range(4):
+        thisj = jlower + i
+        indj = thisj.clip(0, N - 1)  # handle edge cases
+        result += cj[indj] * _cubic(newx - thisj)
+    res[cond3] = result
+    return res
+
+
+def qspline1d_eval(cj, newx, dx=1.0, x0=0):
+    """Evaluate a quadratic spline at the new set of points.
+
+    Parameters
+    ----------
+    cj : ndarray
+        Quadratic spline coefficients
+    newx : ndarray
+        New set of points.
+    dx : float, optional
+        Old sample-spacing, the default value is 1.0.
+    x0 : int, optional
+        Old origin, the default value is 0.
+
+    Returns
+    -------
+    res : ndarray
+        Evaluated a quadratic spline points.
+
+    See Also
+    --------
+    qspline1d : Compute quadratic spline coefficients for rank-1 array.
+
+    Notes
+    -----
+    `dx` is the old sample-spacing while `x0` was the old origin. In
+    other-words the old-sample points (knot-points) for which the `cj`
+    represent spline coefficients were at equally-spaced points of::
+
+      oldx = x0 + j*dx  j=0...N-1, with N=len(cj)
+
+    Edges are handled using mirror-symmetric boundary conditions.
+
+    """
+    newx = (cupy.asarray(newx) - x0) / dx
+    res = cupy.zeros_like(newx)
+    if res.size == 0:
+        return res
+    N = len(cj)
+    cond1 = newx < 0
+    cond2 = newx > (N - 1)
+    cond3 = ~(cond1 | cond2)
+    # handle general mirror-symmetry
+    res[cond1] = qspline1d_eval(cj, -newx[cond1])
+    res[cond2] = qspline1d_eval(cj, 2 * (N - 1) - newx[cond2])
+    newx = newx[cond3]
+    if newx.size == 0:
+        return res
+    result = cupy.zeros_like(newx)
+    jlower = cupy.floor(newx - 1.5).astype(int) + 1
+    for i in range(3):
+        thisj = jlower + i
+        indj = thisj.clip(0, N - 1)  # handle edge cases
+        result += cj[indj] * _quadratic(newx - thisj)
+    res[cond3] = result
+    return res
+
+
+def cspline2d(signal, lamb=0.0, precision=-1.0):
+    """
+    Coefficients for 2-D cubic (3rd order) B-spline.
+
+    Return the third-order B-spline coefficients over a regularly spaced
+    input grid for the two-dimensional input image.
+
+    Parameters
+    ----------
+    input : ndarray
+        The input signal.
+    lamb : float
+        Specifies the amount of smoothing in the transfer function.
+    precision : float
+        Specifies the precision for computing the infinite sum needed to apply
+        mirror-symmetric boundary conditions.
+
+    Returns
+    -------
+    output : ndarray
+        The filtered signal.
+    """
+    if lamb <= 1 / 144.0:
+        # Normal cubic spline
+        r = -2 + np.sqrt(3.0)
+        out = _symiirorder1_nd(signal, -r * 6.0, r, precision=precision,
+                               axis=-1)
+        out = _symiirorder1_nd(out, -r * 6.0, r, precision=precision,
+                               axis=0)
+        return out
+
+    r, omega = compute_root_from_lambda(lamb)
+    out = _symiirorder2_nd(signal, r, omega, precision=precision, axis=-1)
+    out = _symiirorder2_nd(out, r, omega, precision=precision, axis=0)
+    return out
+
+
+def qspline2d(signal, lamb=0.0, precision=-1.0):
+    """
+    Coefficients for 2-D quadratic (2nd order) B-spline.
+
+    Return the second-order B-spline coefficients over a regularly spaced
+    input grid for the two-dimensional input image.
+
+    Parameters
+    ----------
+    input : ndarray
+        The input signal.
+    lamb : float
+        Specifies the amount of smoothing in the transfer function.
+    precision : float
+        Specifies the precision for computing the infinite sum needed to apply
+        mirror-symmetric boundary conditions.
+
+    Returns
+    -------
+    output : ndarray
+        The filtered signal.
+    """
+
+    if lamb > 0:
+        raise ValueError('lambda must be negative or zero')
+
+    # normal quadratic spline
+    r = -3 + 2 * np.sqrt(2.0)
+
+    out = _symiirorder1_nd(signal, -r * 8.0, r, precision=precision, axis=-1)
+    out = _symiirorder1_nd(out, -r * 8.0, r, precision=precision, axis=0)
+    return out
+
+
+def spline_filter(Iin, lmbda=5.0):
+    """Smoothing spline (cubic) filtering of a rank-2 array.
+
+    Filter an input data set, `Iin`, using a (cubic) smoothing spline of
+    fall-off `lmbda`.
+
+    Parameters
+    ----------
+    Iin : array_like
+        input data set
+    lmbda : float, optional
+        spline smooghing fall-off value, default is `5.0`.
+
+    Returns
+    -------
+    res : ndarray
+        filtered input data
+
+    """
+    intype = Iin.dtype.char
+    hcol = cupy.asarray([1.0, 4.0, 1.0], 'f') / 6.0
+    if intype in ['F', 'D']:
+        Iin = Iin.astype('F')
+        ckr = cspline2d(Iin.real, lmbda)
+        cki = cspline2d(Iin.imag, lmbda)
+        outr = sepfir2d(ckr, hcol, hcol)
+        outi = sepfir2d(cki, hcol, hcol)
+        out = (outr + 1j * outi).astype(intype)
+    elif intype in ['f', 'd']:
+        ckr = cspline2d(Iin, lmbda)
+        out = sepfir2d(ckr, hcol, hcol)
+        out = out.astype(intype)
+    else:
+        raise TypeError("Invalid data type for Iin")
+    return out
+
+
+_gauss_spline_kernel = cupy.ElementwiseKernel(
+    "T x, int32 n",
+    "T output",
+    """
+    output = 1 / sqrt( 2.0 * M_PI * signsq ) * exp( -( x * x ) * r_signsq );
+    """,
+    "_gauss_spline_kernel",
+    options=("-std=c++11",),
+    loop_prep="const double signsq { ( n + 1 ) / 12.0 }; \
+               const double r_signsq { 0.5 / signsq };",
+)
+
+
+def gauss_spline(x, n):
+    r"""Gaussian approximation to B-spline basis function of order n.
+
+    Parameters
+    ----------
+    x : array_like
+        a knot vector
+    n : int
+        The order of the spline. Must be nonnegative, i.e. n >= 0
+
+    Returns
+    -------
+    res : ndarray
+        B-spline basis function values approximated by a zero-mean Gaussian
+        function.
+
+    Notes
+    -----
+    The B-spline basis function can be approximated well by a zero-mean
+    Gaussian function with standard-deviation equal to :math:`\sigma=(n+1)/12`
+    for large `n` :
+
+    .. math::  \frac{1}{\sqrt {2\pi\sigma^2}}exp(-\frac{x^2}{2\sigma})
+
+    See [1]_, [2]_ for more information.
+
+    References
+    ----------
+    .. [1] Bouma H., Vilanova A., Bescos J.O., ter Haar Romeny B.M., Gerritsen
+       F.A. (2007) Fast and Accurate Gaussian Derivatives Based on B-Splines.
+       In: Sgallari F., Murli A., Paragios N. (eds) Scale Space and Variational
+       Methods in Computer Vision. SSVM 2007. Lecture Notes in Computer
+       Science, vol 4485. Springer, Berlin, Heidelberg
+    .. [2] http://folk.uio.no/inf3330/scripting/doc/python/SciPy/tutorial/old/node24.html
+    """  # NOQA
+    x = cupy.asarray(x)
+    return _gauss_spline_kernel(x, n)

vllm/lib/python3.10/site-packages/cupyx/scipy/signal/_czt.py

@@ -0,0 +1,451 @@
+# This program is public domain
+# Authors: Paul Kienzle, Nadav Horesh
+#
+# Adapted from scipy 1.10.1.
+#
+"""
+Chirp z-transform.
+
+We provide two interfaces to the chirp z-transform: an object interface
+which precalculates part of the transform and can be applied efficiently
+to many different data sets, and a functional interface which is applied
+only to the given data set.
+
+Transforms
+----------
+
+CZT : callable (x, axis=-1) -> array
+   Define a chirp z-transform that can be applied to different signals.
+ZoomFFT : callable (x, axis=-1) -> array
+   Define a Fourier transform on a range of frequencies.
+
+Functions
+---------
+
+czt : array
+   Compute the chirp z-transform for a signal.
+zoom_fft : array
+   Compute the Fourier transform on a range of frequencies.
+"""
+
+import cmath
+import numbers
+import cupy
+from numpy import pi
+from cupyx.scipy.fft import fft, ifft, next_fast_len
+
+__all__ = ['czt', 'zoom_fft', 'CZT', 'ZoomFFT', 'czt_points']
+
+
+def _validate_sizes(n, m):
+    if n < 1 or not isinstance(n, numbers.Integral):
+        raise ValueError('Invalid number of CZT data '
+                         f'points ({n}) specified. '
+                         'n must be positive and integer type.')
+
+    if m is None:
+        m = n
+    elif m < 1 or not isinstance(m, numbers.Integral):
+        raise ValueError('Invalid number of CZT output '
+                         f'points ({m}) specified. '
+                         'm must be positive and integer type.')
+
+    return m
+
+
+def czt_points(m, w=None, a=1+0j):
+    """
+    Return the points at which the chirp z-transform is computed.
+
+    Parameters
+    ----------
+    m : int
+        The number of points desired.
+    w : complex, optional
+        The ratio between points in each step.
+        Defaults to equally spaced points around the entire unit circle.
+    a : complex, optional
+        The starting point in the complex plane.  Default is 1+0j.
+
+    Returns
+    -------
+    out : ndarray
+        The points in the Z plane at which `CZT` samples the z-transform,
+        when called with arguments `m`, `w`, and `a`, as complex numbers.
+
+    See Also
+    --------
+    CZT : Class that creates a callable chirp z-transform function.
+    czt : Convenience function for quickly calculating CZT.
+    scipy.signal.czt_points
+
+    """
+    m = _validate_sizes(1, m)
+
+    k = cupy.arange(m)
+
+    a = 1.0 * a  # at least float
+
+    if w is None:
+        # Nothing specified, default to FFT
+        return a * cupy.exp(2j * pi * k / m)
+    else:
+        # w specified
+        w = 1.0 * w  # at least float
+        return a * w**-k
+
+
+class CZT:
+    """
+    Create a callable chirp z-transform function.
+
+    Transform to compute the frequency response around a spiral.
+    Objects of this class are callables which can compute the
+    chirp z-transform on their inputs.  This object precalculates the constant
+    chirps used in the given transform.
+
+    Parameters
+    ----------
+    n : int
+        The size of the signal.
+    m : int, optional
+        The number of output points desired.  Default is `n`.
+    w : complex, optional
+        The ratio between points in each step.  This must be precise or the
+        accumulated error will degrade the tail of the output sequence.
+        Defaults to equally spaced points around the entire unit circle.
+    a : complex, optional
+        The starting point in the complex plane.  Default is 1+0j.
+
+    Returns
+    -------
+    f : CZT
+        Callable object ``f(x, axis=-1)`` for computing the chirp z-transform
+        on `x`.
+
+    See Also
+    --------
+    czt : Convenience function for quickly calculating CZT.
+    ZoomFFT : Class that creates a callable partial FFT function.
+    scipy.signal.CZT
+
+    Notes
+    -----
+    The defaults are chosen such that ``f(x)`` is equivalent to
+    ``fft.fft(x)`` and, if ``m > len(x)``, that ``f(x, m)`` is equivalent to
+    ``fft.fft(x, m)``.
+
+    If `w` does not lie on the unit circle, then the transform will be
+    around a spiral with exponentially-increasing radius.  Regardless,
+    angle will increase linearly.
+
+    For transforms that do lie on the unit circle, accuracy is better when
+    using `ZoomFFT`, since any numerical error in `w` is
+    accumulated for long data lengths, drifting away from the unit circle.
+
+    The chirp z-transform can be faster than an equivalent FFT with
+    zero padding.  Try it with your own array sizes to see.
+
+    However, the chirp z-transform is considerably less precise than the
+    equivalent zero-padded FFT.
+
+    As this CZT is implemented using the Bluestein algorithm [1]_, it can
+    compute large prime-length Fourier transforms in O(N log N) time, rather
+    than the O(N**2) time required by the direct DFT calculation.
+    (`scipy.fft` also uses Bluestein's algorithm'.)
+
+    (The name "chirp z-transform" comes from the use of a chirp in the
+    Bluestein algorithm [2]_.  It does not decompose signals into chirps, like
+    other transforms with "chirp" in the name.)
+
+    References
+    ----------
+    .. [1] Leo I. Bluestein, "A linear filtering approach to the computation
+           of the discrete Fourier transform," Northeast Electronics Research
+           and Engineering Meeting Record 10, 218-219 (1968).
+    .. [2] Rabiner, Schafer, and Rader, "The chirp z-transform algorithm and
+           its application," Bell Syst. Tech. J. 48, 1249-1292 (1969).
+
+    """
+
+    def __init__(self, n, m=None, w=None, a=1+0j):
+        m = _validate_sizes(n, m)
+
+        k = cupy.arange(max(m, n), dtype=cupy.min_scalar_type(-max(m, n)**2))
+
+        if w is None:
+            # Nothing specified, default to FFT-like
+            w = cmath.exp(-2j*pi/m)
+            wk2 = cupy.exp(-(1j * pi * ((k**2) % (2*m))) / m)
+        else:
+            # w specified
+            wk2 = w**(k**2/2.)
+
+        a = 1.0 * a  # at least float
+
+        self.w, self.a = w, a
+        self.m, self.n = m, n
+
+        nfft = next_fast_len(n + m - 1)
+        self._Awk2 = a**-k[:n] * wk2[:n]
+        self._nfft = nfft
+        self._Fwk2 = fft(1/cupy.hstack((wk2[n-1:0:-1], wk2[:m])), nfft)
+        self._wk2 = wk2[:m]
+        self._yidx = slice(n-1, n+m-1)
+
+    def __call__(self, x, *, axis=-1):
+        """
+        Calculate the chirp z-transform of a signal.
+
+        Parameters
+        ----------
+        x : array
+            The signal to transform.
+        axis : int, optional
+            Axis over which to compute the FFT. If not given, the last axis is
+            used.
+
+        Returns
+        -------
+        out : ndarray
+            An array of the same dimensions as `x`, but with the length of the
+            transformed axis set to `m`.
+        """
+        x = cupy.asarray(x)
+        if x.shape[axis] != self.n:
+            raise ValueError(f"CZT defined for length {self.n}, not "
+                             f"{x.shape[axis]}")
+        # Calculate transpose coordinates, to allow operation on any given axis
+        trnsp = list(range(x.ndim))
+        trnsp[axis], trnsp[-1] = trnsp[-1], trnsp[axis]
+        x = x.transpose(*trnsp)
+        y = ifft(self._Fwk2 * fft(x*self._Awk2, self._nfft))
+        y = y[..., self._yidx] * self._wk2
+        return y.transpose(*trnsp)
+
+    def points(self):
+        """
+        Return the points at which the chirp z-transform is computed.
+        """
+        return czt_points(self.m, self.w, self.a)
+
+
+class ZoomFFT(CZT):
+    """
+    Create a callable zoom FFT transform function.
+
+    This is a specialization of the chirp z-transform (`CZT`) for a set of
+    equally-spaced frequencies around the unit circle, used to calculate a
+    section of the FFT more efficiently than calculating the entire FFT and
+    truncating. [1]_
+
+    Parameters
+    ----------
+    n : int
+        The size of the signal.
+    fn : array_like
+        A length-2 sequence [`f1`, `f2`] giving the frequency range, or a
+        scalar, for which the range [0, `fn`] is assumed.
+    m : int, optional
+        The number of points to evaluate.  Default is `n`.
+    fs : float, optional
+        The sampling frequency.  If ``fs=10`` represented 10 kHz, for example,
+        then `f1` and `f2` would also be given in kHz.
+        The default sampling frequency is 2, so `f1` and `f2` should be
+        in the range [0, 1] to keep the transform below the Nyquist
+        frequency.
+    endpoint : bool, optional
+        If True, `f2` is the last sample. Otherwise, it is not included.
+        Default is False.
+
+    Returns
+    -------
+    f : ZoomFFT
+        Callable object ``f(x, axis=-1)`` for computing the zoom FFT on `x`.
+
+    See Also
+    --------
+    zoom_fft : Convenience function for calculating a zoom FFT.
+    scipy.signal.ZoomFFT
+
+    Notes
+    -----
+    The defaults are chosen such that ``f(x, 2)`` is equivalent to
+    ``fft.fft(x)`` and, if ``m > len(x)``, that ``f(x, 2, m)`` is equivalent to
+    ``fft.fft(x, m)``.
+
+    Sampling frequency is 1/dt, the time step between samples in the
+    signal `x`.  The unit circle corresponds to frequencies from 0 up
+    to the sampling frequency.  The default sampling frequency of 2
+    means that `f1`, `f2` values up to the Nyquist frequency are in the
+    range [0, 1). For `f1`, `f2` values expressed in radians, a sampling
+    frequency of 2*pi should be used.
+
+    Remember that a zoom FFT can only interpolate the points of the existing
+    FFT.  It cannot help to resolve two separate nearby frequencies.
+    Frequency resolution can only be increased by increasing acquisition
+    time.
+
+    These functions are implemented using Bluestein's algorithm (as is
+    `scipy.fft`). [2]_
+
+    References
+    ----------
+    .. [1] Steve Alan Shilling, "A study of the chirp z-transform and its
+           applications", pg 29 (1970)
+           https://krex.k-state.edu/dspace/bitstream/handle/2097/7844/LD2668R41972S43.pdf
+    .. [2] Leo I. Bluestein, "A linear filtering approach to the computation
+           of the discrete Fourier transform," Northeast Electronics Research
+           and Engineering Meeting Record 10, 218-219 (1968).
+    """
+
+    def __init__(self, n, fn, m=None, *, fs=2, endpoint=False):
+        m = _validate_sizes(n, m)
+
+        k = cupy.arange(max(m, n), dtype=cupy.min_scalar_type(-max(m, n)**2))
+
+        fn = cupy.asarray(fn)
+        if cupy.size(fn) == 2:
+            f1, f2 = fn
+        elif cupy.size(fn) == 1:
+            f1, f2 = 0.0, fn
+        else:
+            raise ValueError('fn must be a scalar or 2-length sequence')
+
+        self.f1, self.f2, self.fs = f1, f2, fs
+
+        if endpoint:
+            scale = ((f2 - f1) * m) / (fs * (m - 1))
+        else:
+            scale = (f2 - f1) / fs
+        a = cmath.exp(2j * pi * f1/fs)
+        wk2 = cupy.exp(-(1j * pi * scale * k**2) / m)
+
+        self.w = cmath.exp(-2j*pi/m * scale)
+        self.a = a
+        self.m, self.n = m, n
+
+        ak = cupy.exp(-2j * pi * f1/fs * k[:n])
+        self._Awk2 = ak * wk2[:n]
+
+        nfft = next_fast_len(n + m - 1)
+        self._nfft = nfft
+        self._Fwk2 = fft(1/cupy.hstack((wk2[n-1:0:-1], wk2[:m])), nfft)
+        self._wk2 = wk2[:m]
+        self._yidx = slice(n-1, n+m-1)
+
+
+def czt(x, m=None, w=None, a=1+0j, *, axis=-1):
+    """
+    Compute the frequency response around a spiral in the Z plane.
+
+    Parameters
+    ----------
+    x : array
+        The signal to transform.
+    m : int, optional
+        The number of output points desired.  Default is the length of the
+        input data.
+    w : complex, optional
+        The ratio between points in each step.  This must be precise or the
+        accumulated error will degrade the tail of the output sequence.
+        Defaults to equally spaced points around the entire unit circle.
+    a : complex, optional
+        The starting point in the complex plane.  Default is 1+0j.
+    axis : int, optional
+        Axis over which to compute the FFT. If not given, the last axis is
+        used.
+
+    Returns
+    -------
+    out : ndarray
+        An array of the same dimensions as `x`, but with the length of the
+        transformed axis set to `m`.
+
+    See Also
+    --------
+    CZT : Class that creates a callable chirp z-transform function.
+    zoom_fft : Convenience function for partial FFT calculations.
+    scipy.signal.czt
+
+    Notes
+    -----
+    The defaults are chosen such that ``signal.czt(x)`` is equivalent to
+    ``fft.fft(x)`` and, if ``m > len(x)``, that ``signal.czt(x, m)`` is
+    equivalent to ``fft.fft(x, m)``.
+
+    If the transform needs to be repeated, use `CZT` to construct a
+    specialized transform function which can be reused without
+    recomputing constants.
+
+    An example application is in system identification, repeatedly evaluating
+    small slices of the z-transform of a system, around where a pole is
+    expected to exist, to refine the estimate of the pole's true location. [1]_
+
+    References
+    ----------
+    .. [1] Steve Alan Shilling, "A study of the chirp z-transform and its
+           applications", pg 20 (1970)
+           https://krex.k-state.edu/dspace/bitstream/handle/2097/7844/LD2668R41972S43.pdf
+
+    """
+    x = cupy.asarray(x)
+    transform = CZT(x.shape[axis], m=m, w=w, a=a)
+    return transform(x, axis=axis)
+
+
+def zoom_fft(x, fn, m=None, *, fs=2, endpoint=False, axis=-1):
+    """
+    Compute the DFT of `x` only for frequencies in range `fn`.
+
+    Parameters
+    ----------
+    x : array
+        The signal to transform.
+    fn : array_like
+        A length-2 sequence [`f1`, `f2`] giving the frequency range, or a
+        scalar, for which the range [0, `fn`] is assumed.
+    m : int, optional
+        The number of points to evaluate.  The default is the length of `x`.
+    fs : float, optional
+        The sampling frequency.  If ``fs=10`` represented 10 kHz, for example,
+        then `f1` and `f2` would also be given in kHz.
+        The default sampling frequency is 2, so `f1` and `f2` should be
+        in the range [0, 1] to keep the transform below the Nyquist
+        frequency.
+    endpoint : bool, optional
+        If True, `f2` is the last sample. Otherwise, it is not included.
+        Default is False.
+    axis : int, optional
+        Axis over which to compute the FFT. If not given, the last axis is
+        used.
+
+    Returns
+    -------
+    out : ndarray
+        The transformed signal.  The Fourier transform will be calculated
+        at the points f1, f1+df, f1+2df, ..., f2, where df=(f2-f1)/m.
+
+    See Also
+    --------
+    ZoomFFT : Class that creates a callable partial FFT function.
+    scipy.signal.zoom_fft
+
+    Notes
+    -----
+    The defaults are chosen such that ``signal.zoom_fft(x, 2)`` is equivalent
+    to ``fft.fft(x)`` and, if ``m > len(x)``, that ``signal.zoom_fft(x, 2, m)``
+    is equivalent to ``fft.fft(x, m)``.
+
+    To graph the magnitude of the resulting transform, use::
+
+        plot(linspace(f1, f2, m, endpoint=False),
+             abs(zoom_fft(x, [f1, f2], m)))
+
+    If the transform needs to be repeated, use `ZoomFFT` to construct
+    a specialized transform function which can be reused without
+    recomputing constants.
+    """
+    x = cupy.asarray(x)
+    transform = ZoomFFT(x.shape[axis], fn, m=m, fs=fs, endpoint=endpoint)
+    return transform(x, axis=axis)

vllm/lib/python3.10/site-packages/cupyx/scipy/signal/_filter_design.py

@@ -0,0 +1,811 @@
+import operator
+from math import pi
+import warnings
+
+import cupy
+from cupy.polynomial.polynomial import (
+    polyval as npp_polyval, polyvalfromroots as npp_polyvalfromroots)
+import cupyx.scipy.fft as sp_fft
+from cupyx import jit
+from cupyx.scipy._lib._util import float_factorial
+from cupyx.scipy.signal._polyutils import roots
+
+EPSILON = 2e-16
+
+
+def _try_convert_to_int(x):
+    """Return an integer for ``5`` and ``array(5)``, fail if not an
+       integer scalar.
+
+    NB: would be easier if ``operator.index(cupy.array(5))`` worked
+    (numpy.array(5) does)
+    """
+    if isinstance(x, cupy.ndarray):
+        if x.ndim == 0:
+            value = x.item()
+        else:
+            return x, False
+    else:
+        value = x
+    try:
+        return operator.index(value), True
+    except TypeError:
+        return value, False
+
+
+def findfreqs(num, den, N, kind='ba'):
+    """
+    Find array of frequencies for computing the response of an analog filter.
+
+    Parameters
+    ----------
+    num, den : array_like, 1-D
+        The polynomial coefficients of the numerator and denominator of the
+        transfer function of the filter or LTI system, where the coefficients
+        are ordered from highest to lowest degree. Or, the roots  of the
+        transfer function numerator and denominator (i.e., zeroes and poles).
+    N : int
+        The length of the array to be computed.
+    kind : str {'ba', 'zp'}, optional
+        Specifies whether the numerator and denominator are specified by their
+        polynomial coefficients ('ba'), or their roots ('zp').
+
+    Returns
+    -------
+    w : (N,) ndarray
+        A 1-D array of frequencies, logarithmically spaced.
+
+    Warning
+    -------
+    This function may synchronize the device.
+
+    See Also
+    --------
+    scipy.signal.find_freqs
+
+    Examples
+    --------
+    Find a set of nine frequencies that span the "interesting part" of the
+    frequency response for the filter with the transfer function
+
+        H(s) = s / (s^2 + 8s + 25)
+
+    >>> from scipy import signal
+    >>> signal.findfreqs([1, 0], [1, 8, 25], N=9)
+    array([  1.00000000e-02,   3.16227766e-02,   1.00000000e-01,
+             3.16227766e-01,   1.00000000e+00,   3.16227766e+00,
+             1.00000000e+01,   3.16227766e+01,   1.00000000e+02])
+    """
+    if kind == 'ba':
+        ep = cupy.atleast_1d(roots(den)) + 0j
+        tz = cupy.atleast_1d(roots(num)) + 0j
+    elif kind == 'zp':
+        ep = cupy.atleast_1d(den) + 0j
+        tz = cupy.atleast_1d(num) + 0j
+    else:
+        raise ValueError("input must be one of {'ba', 'zp'}")
+
+    if len(ep) == 0:
+        ep = cupy.atleast_1d(-1000) + 0j
+
+    ez = cupy.r_[
+        cupy.compress(ep.imag >= 0, ep, axis=-1),
+        cupy.compress((abs(tz) < 1e5) & (tz.imag >= 0), tz, axis=-1)]
+
+    integ = cupy.abs(ez) < 1e-10
+    hfreq = cupy.around(cupy.log10(cupy.max(3 * cupy.abs(ez.real + integ) +
+                                            1.5 * ez.imag)) + 0.5)
+    lfreq = cupy.around(cupy.log10(0.1 * cupy.min(cupy.abs((ez + integ).real) +
+                                                  2 * ez.imag)) - 0.5)
+    w = cupy.logspace(lfreq, hfreq, N)
+    return w
+
+
+def freqs(b, a, worN=200, plot=None):
+    """
+    Compute frequency response of analog filter.
+
+    Given the M-order numerator `b` and N-order denominator `a` of an analog
+    filter, compute its frequency response::
+
+             b[0]*(jw)**M + b[1]*(jw)**(M-1) + ... + b[M]
+     H(w) = ----------------------------------------------
+             a[0]*(jw)**N + a[1]*(jw)**(N-1) + ... + a[N]
+
+    Parameters
+    ----------
+    b : array_like
+        Numerator of a linear filter.
+    a : array_like
+        Denominator of a linear filter.
+    worN : {None, int, array_like}, optional
+        If None, then compute at 200 frequencies around the interesting parts
+        of the response curve (determined by pole-zero locations). If a single
+        integer, then compute at that many frequencies. Otherwise, compute the
+        response at the angular frequencies (e.g., rad/s) given in `worN`.
+    plot : callable, optional
+        A callable that takes two arguments. If given, the return parameters
+        `w` and `h` are passed to plot. Useful for plotting the frequency
+        response inside `freqs`.
+
+    Returns
+    -------
+    w : ndarray
+        The angular frequencies at which `h` was computed.
+    h : ndarray
+        The frequency response.
+
+    See Also
+    --------
+    scipy.signal.freqs
+    freqz : Compute the frequency response of a digital filter.
+
+    """
+    if worN is None:
+        # For backwards compatibility
+        w = findfreqs(b, a, 200)
+
+    else:
+        N, _is_int = _try_convert_to_int(worN)
+        if _is_int:
+            w = findfreqs(b, a, N)
+        else:
+            w = cupy.atleast_1d(worN)
+
+    s = 1j * w
+    h = cupy.polyval(b, s) / cupy.polyval(a, s)
+
+    if plot is not None:
+        plot(w, h)
+
+    return w, h
+
+
+def freqs_zpk(z, p, k, worN=200):
+    """
+    Compute frequency response of analog filter.
+
+    Given the zeros `z`, poles `p`, and gain `k` of a filter, compute its
+    frequency response::
+
+                (jw-z[0]) * (jw-z[1]) * ... * (jw-z[-1])
+     H(w) = k * ----------------------------------------
+                (jw-p[0]) * (jw-p[1]) * ... * (jw-p[-1])
+
+    Parameters
+    ----------
+    z : array_like
+        Zeroes of a linear filter
+    p : array_like
+        Poles of a linear filter
+    k : scalar
+        Gain of a linear filter
+    worN : {None, int, array_like}, optional
+        If None, then compute at 200 frequencies around the interesting parts
+        of the response curve (determined by pole-zero locations). If a single
+        integer, then compute at that many frequencies. Otherwise, compute the
+        response at the angular frequencies (e.g., rad/s) given in `worN`.
+
+    Returns
+    -------
+    w : ndarray
+        The angular frequencies at which `h` was computed.
+    h : ndarray
+        The frequency response.
+
+    See Also
+    --------
+    scipy.signal.freqs_zpk
+
+    """
+    k = cupy.asarray(k)
+    if k.size > 1:
+        raise ValueError('k must be a single scalar gain')
+
+    if worN is None:
+        # For backwards compatibility
+        w = findfreqs(z, p, 200, kind='zp')
+    else:
+        N, _is_int = _try_convert_to_int(worN)
+        if _is_int:
+            w = findfreqs(z, p, worN, kind='zp')
+        else:
+            w = worN
+
+    w = cupy.atleast_1d(w)
+    s = 1j * w
+    num = npp_polyvalfromroots(s, z)
+    den = npp_polyvalfromroots(s, p)
+    h = k * num/den
+    return w, h
+
+
+def _is_int_type(x):
+    """
+    Check if input is of a scalar integer type (so ``5`` and ``array(5)`` will
+    pass, while ``5.0`` and ``array([5])`` will fail.
+    """
+    if cupy.ndim(x) != 0:
+        # Older versions of NumPy did not raise for np.array([1]).__index__()
+        # This is safe to remove when support for those versions is dropped
+        return False
+    try:
+        operator.index(x)
+    except TypeError:
+        return False
+    else:
+        return True
+
+
+def group_delay(system, w=512, whole=False, fs=2 * cupy.pi):
+    r"""Compute the group delay of a digital filter.
+
+    The group delay measures by how many samples amplitude envelopes of
+    various spectral components of a signal are delayed by a filter.
+    It is formally defined as the derivative of continuous (unwrapped) phase::
+
+               d        jw
+     D(w) = - -- arg H(e)
+              dw
+
+    Parameters
+    ----------
+    system : tuple of array_like (b, a)
+        Numerator and denominator coefficients of a filter transfer function.
+    w : {None, int, array_like}, optional
+        If a single integer, then compute at that many frequencies (default is
+        N=512).
+
+        If an array_like, compute the delay at the frequencies given. These
+        are in the same units as `fs`.
+    whole : bool, optional
+        Normally, frequencies are computed from 0 to the Nyquist frequency,
+        fs/2 (upper-half of unit-circle). If `whole` is True, compute
+        frequencies from 0 to fs. Ignored if w is array_like.
+    fs : float, optional
+        The sampling frequency of the digital system. Defaults to 2*pi
+        radians/sample (so w is from 0 to pi).
+
+    Returns
+    -------
+    w : ndarray
+        The frequencies at which group delay was computed, in the same units
+        as `fs`.  By default, `w` is normalized to the range [0, pi)
+        (radians/sample).
+    gd : ndarray
+        The group delay.
+
+    See Also
+    --------
+    freqz : Frequency response of a digital filter
+
+    Notes
+    -----
+    The similar function in MATLAB is called `grpdelay`.
+
+    If the transfer function :math:`H(z)` has zeros or poles on the unit
+    circle, the group delay at corresponding frequencies is undefined.
+    When such a case arises the warning is raised and the group delay
+    is set to 0 at those frequencies.
+
+    For the details of numerical computation of the group delay refer to [1]_.
+
+    References
+    ----------
+    .. [1] Richard G. Lyons, "Understanding Digital Signal Processing,
+           3rd edition", p. 830.
+
+    """
+    if w is None:
+        # For backwards compatibility
+        w = 512
+
+    if _is_int_type(w):
+        if whole:
+            w = cupy.linspace(0, 2 * cupy.pi, w, endpoint=False)
+        else:
+            w = cupy.linspace(0, cupy.pi, w, endpoint=False)
+    else:
+        w = cupy.atleast_1d(w)
+        w = 2 * cupy.pi * w / fs
+
+    b, a = map(cupy.atleast_1d, system)
+    c = cupy.convolve(b, a[::-1])
+    cr = c * cupy.arange(c.size)
+    z = cupy.exp(-1j * w)
+    num = cupy.polyval(cr[::-1], z)
+    den = cupy.polyval(c[::-1], z)
+    gd = cupy.real(num / den) - a.size + 1
+    singular = ~cupy.isfinite(gd)
+    gd[singular] = 0
+
+    w = w * fs / (2 * cupy.pi)
+    return w, gd
+
+
+def freqz(b, a=1, worN=512, whole=False, plot=None, fs=2*pi,
+          include_nyquist=False):
+    """
+    Compute the frequency response of a digital filter.
+
+    Given the M-order numerator `b` and N-order denominator `a` of a digital
+    filter, compute its frequency response::
+
+                 jw                 -jw              -jwM
+        jw    B(e  )    b[0] + b[1]e    + ... + b[M]e
+     H(e  ) = ------ = -----------------------------------
+                 jw                 -jw              -jwN
+              A(e  )    a[0] + a[1]e    + ... + a[N]e
+
+    Parameters
+    ----------
+    b : array_like
+        Numerator of a linear filter. If `b` has dimension greater than 1,
+        it is assumed that the coefficients are stored in the first dimension,
+        and ``b.shape[1:]``, ``a.shape[1:]``, and the shape of the frequencies
+        array must be compatible for broadcasting.
+    a : array_like
+        Denominator of a linear filter. If `b` has dimension greater than 1,
+        it is assumed that the coefficients are stored in the first dimension,
+        and ``b.shape[1:]``, ``a.shape[1:]``, and the shape of the frequencies
+        array must be compatible for broadcasting.
+    worN : {None, int, array_like}, optional
+        If a single integer, then compute at that many frequencies (default is
+        N=512). This is a convenient alternative to::
+
+            cupy.linspace(0, fs if whole else fs/2, N,
+                          endpoint=include_nyquist)
+
+        Using a number that is fast for FFT computations can result in
+        faster computations (see Notes).
+
+        If an array_like, compute the response at the frequencies given.
+        These are in the same units as `fs`.
+    whole : bool, optional
+        Normally, frequencies are computed from 0 to the Nyquist frequency,
+        fs/2 (upper-half of unit-circle). If `whole` is True, compute
+        frequencies from 0 to fs. Ignored if worN is array_like.
+    plot : callable
+        A callable that takes two arguments. If given, the return parameters
+        `w` and `h` are passed to plot. Useful for plotting the frequency
+        response inside `freqz`.
+    fs : float, optional
+        The sampling frequency of the digital system. Defaults to 2*pi
+        radians/sample (so w is from 0 to pi).
+    include_nyquist : bool, optional
+        If `whole` is False and `worN` is an integer, setting `include_nyquist`
+        to True will include the last frequency (Nyquist frequency) and is
+        otherwise ignored.
+
+    Returns
+    -------
+    w : ndarray
+        The frequencies at which `h` was computed, in the same units as `fs`.
+        By default, `w` is normalized to the range [0, pi) (radians/sample).
+    h : ndarray
+        The frequency response, as complex numbers.
+
+    See Also
+    --------
+    freqz_zpk
+    sosfreqz
+    scipy.signal.freqz
+
+
+    Notes
+    -----
+    Using Matplotlib's :func:`matplotlib.pyplot.plot` function as the callable
+    for `plot` produces unexpected results, as this plots the real part of the
+    complex transfer function, not the magnitude.
+    Try ``lambda w, h: plot(w, cupy.abs(h))``.
+
+    A direct computation via (R)FFT is used to compute the frequency response
+    when the following conditions are met:
+
+    1. An integer value is given for `worN`.
+    2. `worN` is fast to compute via FFT (i.e.,
+       `next_fast_len(worN) <scipy.fft.next_fast_len>` equals `worN`).
+    3. The denominator coefficients are a single value (``a.shape[0] == 1``).
+    4. `worN` is at least as long as the numerator coefficients
+       (``worN >= b.shape[0]``).
+    5. If ``b.ndim > 1``, then ``b.shape[-1] == 1``.
+
+    For long FIR filters, the FFT approach can have lower error and be much
+    faster than the equivalent direct polynomial calculation.
+    """
+    b = cupy.atleast_1d(b)
+    a = cupy.atleast_1d(a)
+
+    if worN is None:
+        # For backwards compatibility
+        worN = 512
+
+    h = None
+
+    N, _is_int = _try_convert_to_int(worN)
+    if _is_int:
+        if N < 0:
+            raise ValueError(f'worN must be nonnegative, got {N}')
+        lastpoint = 2 * pi if whole else pi
+
+        # if include_nyquist is true and whole is false, w should
+        # include end point
+        w = cupy.linspace(
+            0, lastpoint, N, endpoint=include_nyquist and not whole)
+
+        use_fft = (a.size == 1 and
+                   N >= b.shape[0] and
+                   sp_fft.next_fast_len(N) == N and
+                   (b.ndim == 1 or (b.shape[-1] == 1))
+                   )
+
+        if use_fft:
+            # if N is fast, 2 * N will be fast, too, so no need to check
+            n_fft = N if whole else N * 2
+            if cupy.isrealobj(b) and cupy.isrealobj(a):
+                fft_func = sp_fft.rfft
+            else:
+                fft_func = sp_fft.fft
+
+            h = fft_func(b, n=n_fft, axis=0)[:N]
+            h /= a
+            if fft_func is sp_fft.rfft and whole:
+                # exclude DC and maybe Nyquist (no need to use axis_reverse
+                # here because we can build reversal with the truncation)
+                stop = -1 if n_fft % 2 == 1 else -2
+                h_flip = slice(stop, 0, -1)
+                h = cupy.concatenate((h, h[h_flip].conj()))
+            if b.ndim > 1:
+                # Last axis of h has length 1, so drop it.
+                h = h[..., 0]
+                # Move the first axis of h to the end.
+                h = cupy.moveaxis(h, 0, -1)
+    else:
+        w = cupy.atleast_1d(worN)
+        w = 2 * pi * w / fs
+
+    if h is None:  # still need to compute using freqs w
+        zm1 = cupy.exp(-1j * w)
+        h = (npp_polyval(zm1, b, tensor=False) /
+             npp_polyval(zm1, a, tensor=False))
+
+    w = w * fs / (2 * pi)
+
+    if plot is not None:
+        plot(w, h)
+
+    return w, h
+
+
+def freqz_zpk(z, p, k, worN=512, whole=False, fs=2*pi):
+    r"""
+    Compute the frequency response of a digital filter in ZPK form.
+
+    Given the Zeros, Poles and Gain of a digital filter, compute its frequency
+    response:
+
+    :math:`H(z)=k \prod_i (z - Z[i]) / \prod_j (z - P[j])`
+
+    where :math:`k` is the `gain`, :math:`Z` are the `zeros` and :math:`P` are
+    the `poles`.
+
+    Parameters
+    ----------
+    z : array_like
+        Zeroes of a linear filter
+    p : array_like
+        Poles of a linear filter
+    k : scalar
+        Gain of a linear filter
+    worN : {None, int, array_like}, optional
+        If a single integer, then compute at that many frequencies (default is
+        N=512).
+
+        If an array_like, compute the response at the frequencies given.
+        These are in the same units as `fs`.
+    whole : bool, optional
+        Normally, frequencies are computed from 0 to the Nyquist frequency,
+        fs/2 (upper-half of unit-circle). If `whole` is True, compute
+        frequencies from 0 to fs. Ignored if w is array_like.
+    fs : float, optional
+        The sampling frequency of the digital system. Defaults to 2*pi
+        radians/sample (so w is from 0 to pi).
+
+    Returns
+    -------
+    w : ndarray
+        The frequencies at which `h` was computed, in the same units as `fs`.
+        By default, `w` is normalized to the range [0, pi) (radians/sample).
+    h : ndarray
+        The frequency response, as complex numbers.
+
+    See Also
+    --------
+    freqs : Compute the frequency response of an analog filter in TF form
+    freqs_zpk : Compute the frequency response of an analog filter in ZPK form
+    freqz : Compute the frequency response of a digital filter in TF form
+    scipy.signal.freqz_zpk
+
+    """
+    z, p = map(cupy.atleast_1d, (z, p))
+
+    if whole:
+        lastpoint = 2 * pi
+    else:
+        lastpoint = pi
+
+    if worN is None:
+        # For backwards compatibility
+        w = cupy.linspace(0, lastpoint, 512, endpoint=False)
+    else:
+        N, _is_int = _try_convert_to_int(worN)
+        if _is_int:
+            w = cupy.linspace(0, lastpoint, N, endpoint=False)
+        else:
+            w = cupy.atleast_1d(worN)
+            w = 2 * pi * w / fs
+
+    zm1 = cupy.exp(1j * w)
+    h = k * npp_polyvalfromroots(zm1, z) / npp_polyvalfromroots(zm1, p)
+
+    w = w * fs / (2 * pi)
+
+    return w, h
+
+
+def _validate_sos(sos):
+    """Helper to validate a SOS input"""
+    sos = cupy.atleast_2d(sos)
+    if sos.ndim != 2:
+        raise ValueError('sos array must be 2D')
+    n_sections, m = sos.shape
+    if m != 6:
+        raise ValueError('sos array must be shape (n_sections, 6)')
+    if ((sos[:, 3] - 1) > 1e-15).any():
+        raise ValueError('sos[:, 3] should be all ones')
+    return sos, n_sections
+
+
+def sosfreqz(sos, worN=512, whole=False, fs=2*pi):
+    r"""
+    Compute the frequency response of a digital filter in SOS format.
+
+    Given `sos`, an array with shape (n, 6) of second order sections of
+    a digital filter, compute the frequency response of the system function::
+
+               B0(z)   B1(z)         B{n-1}(z)
+        H(z) = ----- * ----- * ... * ---------
+               A0(z)   A1(z)         A{n-1}(z)
+
+    for z = exp(omega*1j), where B{k}(z) and A{k}(z) are numerator and
+    denominator of the transfer function of the k-th second order section.
+
+    Parameters
+    ----------
+    sos : array_like
+        Array of second-order filter coefficients, must have shape
+        ``(n_sections, 6)``. Each row corresponds to a second-order
+        section, with the first three columns providing the numerator
+        coefficients and the last three providing the denominator
+        coefficients.
+    worN : {None, int, array_like}, optional
+        If a single integer, then compute at that many frequencies (default is
+        N=512).  Using a number that is fast for FFT computations can result
+        in faster computations (see Notes of `freqz`).
+
+        If an array_like, compute the response at the frequencies given (must
+        be 1-D). These are in the same units as `fs`.
+    whole : bool, optional
+        Normally, frequencies are computed from 0 to the Nyquist frequency,
+        fs/2 (upper-half of unit-circle). If `whole` is True, compute
+        frequencies from 0 to fs.
+    fs : float, optional
+        The sampling frequency of the digital system. Defaults to 2*pi
+        radians/sample (so w is from 0 to pi).
+
+        .. versionadded:: 1.2.0
+
+    Returns
+    -------
+    w : ndarray
+        The frequencies at which `h` was computed, in the same units as `fs`.
+        By default, `w` is normalized to the range [0, pi) (radians/sample).
+    h : ndarray
+        The frequency response, as complex numbers.
+
+    See Also
+    --------
+    freqz, sosfilt
+    scipy.signal.sosfreqz
+    """
+    sos, n_sections = _validate_sos(sos)
+    if n_sections == 0:
+        raise ValueError('Cannot compute frequencies with no sections')
+    h = 1.
+    for row in sos:
+        w, rowh = freqz(row[:3], row[3:], worN=worN, whole=whole, fs=fs)
+        h *= rowh
+    return w, h
+
+
+def _hz_to_erb(hz):
+    """
+    Utility for converting from frequency (Hz) to the
+    Equivalent Rectangular Bandwidth (ERB) scale
+    ERB = frequency / EarQ + minBW
+    """
+    EarQ = 9.26449
+    minBW = 24.7
+    return hz / EarQ + minBW
+
+
+@jit.rawkernel()
+def _gammatone_iir_kernel(fs, freq, b, a):
+    tid = jit.blockIdx.x * jit.blockDim.x + jit.threadIdx.x
+
+    EarQ = 9.26449
+    minBW = 24.7
+    erb = freq / EarQ + minBW
+
+    T = 1./fs
+    bw = 2 * cupy.pi * 1.019 * erb
+    fr = 2 * freq * cupy.pi * T
+    bwT = bw * T
+
+    # Calculate the gain to normalize the volume at the center frequency
+    g1 = -2 * cupy.exp(2j * fr) * T
+    g2 = 2 * cupy.exp(-(bwT) + 1j * fr) * T
+    g3 = cupy.sqrt(3 + 2 ** (3 / 2)) * cupy.sin(fr)
+    g4 = cupy.sqrt(3 - 2 ** (3 / 2)) * cupy.sin(fr)
+    g5 = cupy.exp(2j * fr)
+
+    g = g1 + g2 * (cupy.cos(fr) - g4)
+    g *= (g1 + g2 * (cupy.cos(fr) + g4))
+    g *= (g1 + g2 * (cupy.cos(fr) - g3))
+    g *= (g1 + g2 * (cupy.cos(fr) + g3))
+    g /= ((-2 / cupy.exp(2 * bwT) - 2 * g5 + 2 * (1 + g5) /
+           cupy.exp(bwT)) ** 4)
+    g_act = cupy.abs(g)
+
+    # Calculate the numerator coefficients
+    if tid == 0:
+        b[tid] = (T ** 4) / g_act
+        a[tid] = 1
+    elif tid == 1:
+        b[tid] = -4 * T ** 4 * cupy.cos(fr) / cupy.exp(bw * T) / g_act
+        a[tid] = -8 * cupy.cos(fr) / cupy.exp(bw * T)
+    elif tid == 2:
+        b[tid] = 6 * T ** 4 * cupy.cos(2 * fr) / cupy.exp(2 * bw * T) / g_act
+        a[tid] = 4 * (4 + 3 * cupy.cos(2 * fr)) / cupy.exp(2 * bw * T)
+    elif tid == 3:
+        b[tid] = -4 * T ** 4 * cupy.cos(3 * fr) / cupy.exp(3 * bw * T) / g_act
+        a[tid] = -8 * (6 * cupy.cos(fr) + cupy.cos(3 * fr))
+        a[tid] /= cupy.exp(3 * bw * T)
+    elif tid == 4:
+        b[tid] = T ** 4 * cupy.cos(4 * fr) / cupy.exp(4 * bw * T) / g_act
+        a[tid] = 2 * (18 + 16 * cupy.cos(2 * fr) + cupy.cos(4 * fr))
+        a[tid] /= cupy.exp(4 * bw * T)
+    elif tid == 5:
+        a[tid] = -8 * (6 * cupy.cos(fr) + cupy.cos(3 * fr))
+        a[tid] /= cupy.exp(5 * bw * T)
+    elif tid == 6:
+        a[tid] = 4 * (4 + 3 * cupy.cos(2 * fr)) / cupy.exp(6 * bw * T)
+    elif tid == 7:
+        a[tid] = -8 * cupy.cos(fr) / cupy.exp(7 * bw * T)
+    elif tid == 8:
+        a[tid] = cupy.exp(-8 * bw * T)
+
+
+def gammatone(freq, ftype, order=None, numtaps=None, fs=None):
+    """
+    Gammatone filter design.
+
+    This function computes the coefficients of an FIR or IIR gammatone
+    digital filter [1]_.
+
+    Parameters
+    ----------
+    freq : float
+        Center frequency of the filter (expressed in the same units
+        as `fs`).
+    ftype : {'fir', 'iir'}
+        The type of filter the function generates. If 'fir', the function
+        will generate an Nth order FIR gammatone filter. If 'iir', the
+        function will generate an 8th order digital IIR filter, modeled as
+        as 4th order gammatone filter.
+    order : int, optional
+        The order of the filter. Only used when ``ftype='fir'``.
+        Default is 4 to model the human auditory system. Must be between
+        0 and 24.
+    numtaps : int, optional
+        Length of the filter. Only used when ``ftype='fir'``.
+        Default is ``fs*0.015`` if `fs` is greater than 1000,
+        15 if `fs` is less than or equal to 1000.
+    fs : float, optional
+        The sampling frequency of the signal. `freq` must be between
+        0 and ``fs/2``. Default is 2.
+
+    Returns
+    -------
+    b, a : ndarray, ndarray
+        Numerator (``b``) and denominator (``a``) polynomials of the filter.
+
+    Raises
+    ------
+    ValueError
+        If `freq` is less than or equal to 0 or greater than or equal to
+        ``fs/2``, if `ftype` is not 'fir' or 'iir', if `order` is less than
+        or equal to 0 or greater than 24 when ``ftype='fir'``
+
+    See Also
+    --------
+    firwin
+    iirfilter
+
+    References
+    ----------
+    .. [1] Slaney, Malcolm, "An Efficient Implementation of the
+        Patterson-Holdsworth Auditory Filter Bank", Apple Computer
+        Technical Report 35, 1993, pp.3-8, 34-39.
+    """
+    # Converts freq to float
+    freq = float(freq)
+
+    # Set sampling rate if not passed
+    if fs is None:
+        fs = 2
+    fs = float(fs)
+
+    # Check for invalid cutoff frequency or filter type
+    ftype = ftype.lower()
+    filter_types = ['fir', 'iir']
+    if not 0 < freq < fs / 2:
+        raise ValueError("The frequency must be between 0 and {}"
+                         " (nyquist), but given {}.".format(fs / 2, freq))
+    if ftype not in filter_types:
+        raise ValueError('ftype must be either fir or iir.')
+
+    # Calculate FIR gammatone filter
+    if ftype == 'fir':
+        # Set order and numtaps if not passed
+        if order is None:
+            order = 4
+        order = operator.index(order)
+
+        if numtaps is None:
+            numtaps = max(int(fs * 0.015), 15)
+        numtaps = operator.index(numtaps)
+
+        # Check for invalid order
+        if not 0 < order <= 24:
+            raise ValueError("Invalid order: order must be > 0 and <= 24.")
+
+        # Gammatone impulse response settings
+        t = cupy.arange(numtaps) / fs
+        bw = 1.019 * _hz_to_erb(freq)
+
+        # Calculate the FIR gammatone filter
+        b = (t ** (order - 1)) * cupy.exp(-2 * cupy.pi * bw * t)
+        b *= cupy.cos(2 * cupy.pi * freq * t)
+
+        # Scale the FIR filter so the frequency response is 1 at cutoff
+        scale_factor = 2 * (2 * cupy.pi * bw) ** (order)
+        scale_factor /= float_factorial(order - 1)
+        scale_factor /= fs
+        b *= scale_factor
+        a = [1.0]
+
+    # Calculate IIR gammatone filter
+    elif ftype == 'iir':
+        # Raise warning if order and/or numtaps is passed
+        if order is not None:
+            warnings.warn('order is not used for IIR gammatone filter.')
+        if numtaps is not None:
+            warnings.warn('numtaps is not used for IIR gammatone filter.')
+
+        # Create empty filter coefficient lists
+        b = cupy.empty(5)
+        a = cupy.empty(9)
+        _gammatone_iir_kernel((9,), (1,), (fs, freq, b, a))
+
+    return b, a

vllm/lib/python3.10/site-packages/cupyx/scipy/signal/_fir_filter_design.py

@@ -0,0 +1,918 @@
+"""Functions for FIR filter design."""
+import math
+
+from cupy.fft import fft, ifft
+from cupy.linalg import solve, lstsq, LinAlgError
+from cupyx.scipy.linalg import toeplitz, hankel
+import cupyx
+from cupyx.scipy.signal.windows import get_window
+
+import cupy
+import numpy
+
+
+__all__ = ["firls", "minimum_phase"]
+
+
+def kaiser_beta(a):
+    """Compute the Kaiser parameter `beta`, given the attenuation `a`.
+
+    Parameters
+    ----------
+    a : float
+        The desired attenuation in the stopband and maximum ripple in
+        the passband, in dB.  This should be a *positive* number.
+
+    Returns
+    -------
+    beta : float
+        The `beta` parameter to be used in the formula for a Kaiser window.
+
+    References
+    ----------
+    Oppenheim, Schafer, "Discrete-Time Signal Processing", p.475-476.
+
+    See Also
+    --------
+    scipy.signal.kaiser_beta
+
+    """
+    if a > 50:
+        beta = 0.1102 * (a - 8.7)
+    elif a > 21:
+        beta = 0.5842 * (a - 21) ** 0.4 + 0.07886 * (a - 21)
+    else:
+        beta = 0.0
+    return beta
+
+
+def kaiser_atten(numtaps, width):
+    """Compute the attenuation of a Kaiser FIR filter.
+
+    Given the number of taps `N` and the transition width `width`, compute the
+    attenuation `a` in dB, given by Kaiser's formula:
+
+        a = 2.285 * (N - 1) * pi * width + 7.95
+
+    Parameters
+    ----------
+    numtaps : int
+        The number of taps in the FIR filter.
+    width : float
+        The desired width of the transition region between passband and
+        stopband (or, in general, at any discontinuity) for the filter,
+        expressed as a fraction of the Nyquist frequency.
+
+    Returns
+    -------
+    a : float
+        The attenuation of the ripple, in dB.
+
+    See Also
+    --------
+    scipy.signal.kaiser_atten
+    """
+    a = 2.285 * (numtaps - 1) * cupy.pi * width + 7.95
+    return a
+
+
+def kaiserord(ripple, width):
+    """
+    Determine the filter window parameters for the Kaiser window method.
+
+    The parameters returned by this function are generally used to create
+    a finite impulse response filter using the window method, with either
+    `firwin` or `firwin2`.
+
+    Parameters
+    ----------
+    ripple : float
+        Upper bound for the deviation (in dB) of the magnitude of the
+        filter's frequency response from that of the desired filter (not
+        including frequencies in any transition intervals). That is, if w
+        is the frequency expressed as a fraction of the Nyquist frequency,
+        A(w) is the actual frequency response of the filter and D(w) is the
+        desired frequency response, the design requirement is that::
+
+            abs(A(w) - D(w))) < 10**(-ripple/20)
+
+        for 0 <= w <= 1 and w not in a transition interval.
+    width : float
+        Width of transition region, normalized so that 1 corresponds to pi
+        radians / sample. That is, the frequency is expressed as a fraction
+        of the Nyquist frequency.
+
+    Returns
+    -------
+    numtaps : int
+        The length of the Kaiser window.
+    beta : float
+        The beta parameter for the Kaiser window.
+
+    See Also
+    --------
+    scipy.signal.kaiserord
+
+
+    """
+    A = abs(ripple)  # in case somebody is confused as to what's meant
+    if A < 8:
+        # Formula for N is not valid in this range.
+        raise ValueError("Requested maximum ripple attenuation %f is too "
+                         "small for the Kaiser formula." % A)
+    beta = kaiser_beta(A)
+
+    # Kaiser's formula (as given in Oppenheim and Schafer) is for the filter
+    # order, so we have to add 1 to get the number of taps.
+    numtaps = (A - 7.95) / 2.285 / (cupy.pi * width) + 1
+
+    return int(numpy.ceil(numtaps)), beta
+
+
+_firwin_kernel = cupy.ElementwiseKernel(
+    "float64 win, int32 numtaps, raw float64 bands, int32 steps, bool scale",
+    "float64 h, float64 hc",
+    """
+    const double m { static_cast<double>( i ) - alpha ?
+        static_cast<double>( i ) - alpha : 1.0e-20 };
+
+    double temp {};
+    double left {};
+    double right {};
+
+    for ( int s = 0; s < steps; s++ ) {
+        left = bands[s * 2 + 0] ? bands[s * 2 + 0] : 1.0e-20;
+        right = bands[s * 2 + 1] ? bands[s * 2 + 1] : 1.0e-20;
+
+        temp += right * ( sin( right * m * M_PI ) / ( right * m * M_PI ) );
+        temp -= left * ( sin( left * m * M_PI ) / ( left * m * M_PI ) );
+    }
+
+    temp *= win;
+    h = temp;
+
+    double scale_frequency {};
+
+    if ( scale ) {
+        left = bands[0];
+        right = bands[1];
+
+        if ( left == 0 ) {
+            scale_frequency = 0.0;
+        } else if ( right == 1 ) {
+            scale_frequency = 1.0;
+        } else {
+            scale_frequency = 0.5 * ( left + right );
+        }
+        double c { cos( M_PI * m * scale_frequency ) };
+        hc = temp * c;
+    }
+    """,
+    "_firwin_kernel",
+    options=("-std=c++11",),
+    loop_prep="const double alpha { 0.5 * ( numtaps - 1 ) };",
+)
+
+
+# Scipy <= 1.12 has a deprecated `nyq` argument (nyq = fs/2).
+# Remove it here, to be forward-looking.
+def firwin(
+    numtaps,
+    cutoff,
+    width=None,
+    window="hamming",
+    pass_zero=True,
+    scale=True,
+    fs=2,
+):
+    """
+    FIR filter design using the window method.
+
+    This function computes the coefficients of a finite impulse response
+    filter.  The filter will have linear phase; it will be Type I if
+    `numtaps` is odd and Type II if `numtaps` is even.
+
+    Type II filters always have zero response at the Nyquist frequency, so a
+    ValueError exception is raised if firwin is called with `numtaps` even and
+    having a passband whose right end is at the Nyquist frequency.
+
+    Parameters
+    ----------
+    numtaps : int
+        Length of the filter (number of coefficients, i.e. the filter
+        order + 1).  `numtaps` must be odd if a passband includes the
+        Nyquist frequency.
+    cutoff : float or 1D array_like
+        Cutoff frequency of filter (expressed in the same units as `fs`)
+        OR an array of cutoff frequencies (that is, band edges). In the
+        latter case, the frequencies in `cutoff` should be positive and
+        monotonically increasing between 0 and `fs/2`.  The values 0 and
+        `fs/2` must not be included in `cutoff`.
+    width : float or None, optional
+        If `width` is not None, then assume it is the approximate width
+        of the transition region (expressed in the same units as `fs`)
+        for use in Kaiser FIR filter design.  In this case, the `window`
+        argument is ignored.
+    window : string or tuple of string and parameter values, optional
+        Desired window to use. See `cusignal.get_window` for a list
+        of windows and required parameters.
+    pass_zero : {True, False, 'bandpass', 'lowpass', 'highpass', 'bandstop'},
+        optional
+        If True, the gain at the frequency 0 (i.e. the "DC gain") is 1.
+        If False, the DC gain is 0. Can also be a string argument for the
+        desired filter type (equivalent to ``btype`` in IIR design functions).
+    scale : bool, optional
+        Set to True to scale the coefficients so that the frequency
+        response is exactly unity at a certain frequency.
+        That frequency is either:
+
+        - 0 (DC) if the first passband starts at 0 (i.e. pass_zero
+          is True)
+        - `fs/2` (the Nyquist frequency) if the first passband ends at
+          `fs/2` (i.e the filter is a single band highpass filter);
+          center of first passband otherwise
+    fs : float, optional
+        The sampling frequency of the signal.  Each frequency in `cutoff`
+        must be between 0 and ``fs/2``.  Default is 2.
+
+    Returns
+    -------
+    h : (numtaps,) ndarray
+        Coefficients of length `numtaps` FIR filter.
+
+    Raises
+    ------
+    ValueError
+        If any value in `cutoff` is less than or equal to 0 or greater
+        than or equal to ``fs/2``, if the values in `cutoff` are not strictly
+        monotonically increasing, or if `numtaps` is even but a passband
+        includes the Nyquist frequency.
+
+    See Also
+    --------
+    firwin2
+    firls
+    minimum_phase
+    remez
+
+    Examples
+    --------
+    Low-pass from 0 to f:
+
+    >>> import cusignal
+    >>> numtaps = 3
+    >>> f = 0.1
+    >>> cusignal.firwin(numtaps, f)
+    array([ 0.06799017,  0.86401967,  0.06799017])
+
+    Use a specific window function:
+
+    >>> cusignal.firwin(numtaps, f, window='nuttall')
+    array([  3.56607041e-04,   9.99286786e-01,   3.56607041e-04])
+
+    High-pass ('stop' from 0 to f):
+
+    >>> cusignal.firwin(numtaps, f, pass_zero=False)
+    array([-0.00859313,  0.98281375, -0.00859313])
+
+    Band-pass:
+
+    >>> f1, f2 = 0.1, 0.2
+    >>> cusignal.firwin(numtaps, [f1, f2], pass_zero=False)
+    array([ 0.06301614,  0.88770441,  0.06301614])
+
+    Band-stop:
+
+    >>> cusignal.firwin(numtaps, [f1, f2])
+    array([-0.00801395,  1.0160279 , -0.00801395])
+
+    Multi-band (passbands are [0, f1], [f2, f3] and [f4, 1]):
+
+    >>> f3, f4 = 0.3, 0.4
+    >>> cusignal.firwin(numtaps, [f1, f2, f3, f4])
+    array([-0.01376344,  1.02752689, -0.01376344])
+
+    Multi-band (passbands are [f1, f2] and [f3,f4]):
+
+    >>> cusignal.firwin(numtaps, [f1, f2, f3, f4], pass_zero=False)
+    array([ 0.04890915,  0.91284326,  0.04890915])
+
+    """
+
+    nyq = 0.5 * fs
+
+    cutoff = cupy.atleast_1d(cutoff) / float(nyq)
+
+    # Check for invalid input.
+    if cutoff.ndim > 1:
+        raise ValueError(
+            "The cutoff argument must be at most " "one-dimensional.")
+    if cutoff.size == 0:
+        raise ValueError("At least one cutoff frequency must be given.")
+    if cutoff.min() <= 0 or cutoff.max() >= 1:
+        raise ValueError(
+            "Invalid cutoff frequency: frequencies must be "
+            "greater than 0 and less than nyq."
+        )
+    if cupy.any(cupy.diff(cutoff) <= 0):
+        raise ValueError(
+            "Invalid cutoff frequencies: the frequencies "
+            "must be strictly increasing."
+        )
+
+    if width is not None:
+        # A width was given.  Find the beta parameter of the Kaiser window
+        # and set `window`.  This overrides the value of `window` passed in.
+        atten = kaiser_atten(numtaps, float(width) / nyq)
+        beta = kaiser_beta(atten)
+        window = ("kaiser", beta)
+
+    if isinstance(pass_zero, str):
+        if pass_zero in ("bandstop", "lowpass"):
+            if pass_zero == "lowpass":
+                if cutoff.size != 1:
+                    raise ValueError(
+                        "cutoff must have one element if "
+                        'pass_zero=="lowpass", got %s' % (cutoff.shape,)
+                    )
+            elif cutoff.size <= 1:
+                raise ValueError(
+                    "cutoff must have at least two elements if "
+                    'pass_zero=="bandstop", got %s' % (cutoff.shape,)
+                )
+            pass_zero = True
+        elif pass_zero in ("bandpass", "highpass"):
+            if pass_zero == "highpass":
+                if cutoff.size != 1:
+                    raise ValueError(
+                        "cutoff must have one element if "
+                        'pass_zero=="highpass", got %s' % (cutoff.shape,)
+                    )
+            elif cutoff.size <= 1:
+                raise ValueError(
+                    "cutoff must have at least two elements if "
+                    'pass_zero=="bandpass", got %s' % (cutoff.shape,)
+                )
+            pass_zero = False
+        else:
+            raise ValueError(
+                'pass_zero must be True, False, "bandpass", '
+                '"lowpass", "highpass", or "bandstop", got '
+                "{}".format(pass_zero)
+            )
+
+    pass_nyquist = bool(cutoff.size & 1) ^ pass_zero
+
+    if pass_nyquist and numtaps % 2 == 0:
+        raise ValueError(
+            "A filter with an even number of coefficients must "
+            "have zero response at the Nyquist rate."
+        )
+
+    # Insert 0 and/or 1 at the ends of cutoff so that the length of cutoff
+    # is even, and each pair in cutoff corresponds to passband.
+    cutoff = cupy.hstack(([0.0] * pass_zero, cutoff, [1.0] * pass_nyquist))
+
+    # `bands` is a 2D array; each row gives the left and right edges of
+    # a passband.
+    bands = cutoff.reshape(-1, 2)
+
+    win = get_window(window, numtaps, fftbins=False)
+    h, hc = _firwin_kernel(win, numtaps, bands, bands.shape[0], scale)
+    if scale:
+        s = cupy.sum(hc)
+        h /= s
+
+        # Build up the coefficients.
+        alpha = 0.5 * (numtaps - 1)
+        m = cupy.arange(0, numtaps) - alpha
+        h = 0
+        for left, right in bands:
+            h += right * cupy.sinc(right * m)
+            h -= left * cupy.sinc(left * m)
+
+        h *= win
+
+        # Now handle scaling if desired.
+        if scale:
+            # Get the first passband.
+            left, right = bands[0]
+            if left == 0:
+                scale_frequency = 0.0
+            elif right == 1:
+                scale_frequency = 1.0
+            else:
+                scale_frequency = 0.5 * (left + right)
+            c = cupy.cos(cupy.pi * m * scale_frequency)
+            s = cupy.sum(h * c)
+            h /= s
+
+    return h
+
+
+def firwin2(
+    numtaps,
+    freq,
+    gain,
+    nfreqs=None,
+    window="hamming",
+    nyq=None,
+    antisymmetric=False,
+    fs=2.0,
+):
+    """
+    FIR filter design using the window method.
+
+    From the given frequencies `freq` and corresponding gains `gain`,
+    this function constructs an FIR filter with linear phase and
+    (approximately) the given frequency response.
+
+    Parameters
+    ----------
+    numtaps : int
+        The number of taps in the FIR filter.  `numtaps` must be less than
+        `nfreqs`.
+    freq : array_like, 1-D
+        The frequency sampling points. Typically 0.0 to 1.0 with 1.0 being
+        Nyquist.  The Nyquist frequency is half `fs`.
+        The values in `freq` must be nondecreasing. A value can be repeated
+        once to implement a discontinuity. The first value in `freq` must
+        be 0, and the last value must be ``fs/2``. Values 0 and ``fs/2`` must
+        not be repeated.
+    gain : array_like
+        The filter gains at the frequency sampling points. Certain
+        constraints to gain values, depending on the filter type, are applied,
+        see Notes for details.
+    nfreqs : int, optional
+        The size of the interpolation mesh used to construct the filter.
+        For most efficient behavior, this should be a power of 2 plus 1
+        (e.g, 129, 257, etc). The default is one more than the smallest
+        power of 2 that is not less than `numtaps`. `nfreqs` must be greater
+        than `numtaps`.
+    window : string or (string, float) or float, or None, optional
+        Window function to use. Default is "hamming". See
+        `scipy.signal.get_window` for the complete list of possible values.
+        If None, no window function is applied.
+    antisymmetric : bool, optional
+        Whether resulting impulse response is symmetric/antisymmetric.
+        See Notes for more details.
+    fs : float, optional
+        The sampling frequency of the signal. Each frequency in `cutoff`
+        must be between 0 and ``fs/2``. Default is 2.
+
+    Returns
+    -------
+    taps : ndarray
+        The filter coefficients of the FIR filter, as a 1-D array of length
+        `numtaps`.
+
+    See Also
+    --------
+    scipy.signal.firwin2
+    firls
+    firwin
+    minimum_phase
+    remez
+
+    Notes
+    -----
+    From the given set of frequencies and gains, the desired response is
+    constructed in the frequency domain. The inverse FFT is applied to the
+    desired response to create the associated convolution kernel, and the
+    first `numtaps` coefficients of this kernel, scaled by `window`, are
+    returned.
+    The FIR filter will have linear phase. The type of filter is determined by
+    the value of 'numtaps` and `antisymmetric` flag.
+    There are four possible combinations:
+
+       - odd  `numtaps`, `antisymmetric` is False, type I filter is produced
+       - even `numtaps`, `antisymmetric` is False, type II filter is produced
+       - odd  `numtaps`, `antisymmetric` is True, type III filter is produced
+       - even `numtaps`, `antisymmetric` is True, type IV filter is produced
+
+    Magnitude response of all but type I filters are subjects to following
+    constraints:
+
+       - type II  -- zero at the Nyquist frequency
+       - type III -- zero at zero and Nyquist frequencies
+       - type IV  -- zero at zero frequency
+    """
+    nyq = 0.5 * fs
+
+    if len(freq) != len(gain):
+        raise ValueError("freq and gain must be of same length.")
+
+    if nfreqs is not None and numtaps >= nfreqs:
+        raise ValueError(
+            (
+                "ntaps must be less than nfreqs, but firwin2 was "
+                "called with ntaps=%d and nfreqs=%s"
+            )
+            % (numtaps, nfreqs)
+        )
+
+    if freq[0] != 0 or freq[-1] != nyq:
+        raise ValueError("freq must start with 0 and end with fs/2.")
+    d = cupy.diff(freq)
+    if (d < 0).any():
+        raise ValueError("The values in freq must be nondecreasing.")
+    d2 = d[:-1] + d[1:]
+    if (d2 == 0).any():
+        raise ValueError("A value in freq must not occur more than twice.")
+    if freq[1] == 0:
+        raise ValueError("Value 0 must not be repeated in freq")
+    if freq[-2] == nyq:
+        raise ValueError("Value fs/2 must not be repeated in freq")
+
+    if antisymmetric:
+        if numtaps % 2 == 0:
+            ftype = 4
+        else:
+            ftype = 3
+    else:
+        if numtaps % 2 == 0:
+            ftype = 2
+        else:
+            ftype = 1
+
+    if ftype == 2 and gain[-1] != 0.0:
+        raise ValueError(
+            "A Type II filter must have zero gain at the " "Nyquist frequency."
+        )
+    elif ftype == 3 and (gain[0] != 0.0 or gain[-1] != 0.0):
+        raise ValueError(
+            "A Type III filter must have zero gain at zero "
+            "and Nyquist frequencies."
+        )
+    elif ftype == 4 and gain[0] != 0.0:
+        raise ValueError(
+            "A Type IV filter must have zero gain at zero " "frequency.")
+
+    if nfreqs is None:
+        nfreqs = 1 + 2 ** int(math.ceil(math.log(numtaps, 2)))
+
+    if (d == 0).any():
+        # Tweak any repeated values in freq so that interp works.
+        freq = cupy.array(freq, copy=True)
+        eps = cupy.finfo(float).eps * nyq
+        for k in range(len(freq) - 1):
+            if freq[k] == freq[k + 1]:
+                freq[k] = freq[k] - eps
+                freq[k + 1] = freq[k + 1] + eps
+        # Check if freq is strictly increasing after tweak
+        d = cupy.diff(freq)
+        if (d <= 0).any():
+            raise ValueError(
+                "freq cannot contain numbers that are too close "
+                "(within eps * (fs/2): "
+                "{}) to a repeated value".format(eps)
+            )
+
+    # Linearly interpolate the desired response on a uniform mesh `x`.
+    x = cupy.linspace(0.0, nyq, nfreqs)
+    fx = cupy.interp(x, freq, gain)
+
+    # Adjust the phases of the coefficients so that the first `ntaps` of the
+    # inverse FFT are the desired filter coefficients.
+    shift = cupy.exp(-(numtaps - 1) / 2.0 * 1.0j * math.pi * x / nyq)
+    if ftype > 2:
+        shift *= 1j
+
+    fx2 = fx * shift
+
+    # Use irfft to compute the inverse FFT.
+    out_full = cupy.fft.irfft(fx2)
+
+    if window is not None:
+        # Create the window to apply to the filter coefficients.
+        wind = get_window(window, numtaps, fftbins=False)
+    else:
+        wind = 1
+
+    # Keep only the first `numtaps` coefficients in `out`, and multiply by
+    # the window.
+    out = out_full[:numtaps] * wind
+
+    if ftype == 3:
+        out[out.size // 2] = 0.0
+
+    return out
+
+
+# Scipy <= 1.12 has a deprecated `nyq` argument (nyq = fs/2).
+# Remove it here, to be forward-looking.
+def firls(numtaps, bands, desired, weight=None, fs=2):
+    """
+    FIR filter design using least-squares error minimization.
+
+    Calculate the filter coefficients for the linear-phase finite
+    impulse response (FIR) filter which has the best approximation
+    to the desired frequency response described by `bands` and
+    `desired` in the least squares sense (i.e., the integral of the
+    weighted mean-squared error within the specified bands is
+    minimized).
+
+    Parameters
+    ----------
+    numtaps : int
+        The number of taps in the FIR filter. `numtaps` must be odd.
+    bands : array_like
+        A monotonic nondecreasing sequence containing the band edges in
+        Hz. All elements must be non-negative and less than or equal to
+        the Nyquist frequency given by `fs`/2. The bands are specified as
+        frequency pairs, thus, if using a 1D array, its length must be
+        even, e.g., `cupy.array([0, 1, 2, 3, 4, 5])`. Alternatively, the
+        bands can be specified as an nx2 sized 2D array, where n is the
+        number of bands, e.g, `cupy.array([[0, 1], [2, 3], [4, 5]])`.
+        All elements of `bands` must be monotonically nondecreasing, have
+        width > 0, and must not overlap. (This is not checked by the routine).
+    desired : array_like
+        A sequence the same size as `bands` containing the desired gain
+        at the start and end point of each band.
+        All elements must be non-negative (this is not checked by the routine).
+    weight : array_like, optional
+        A relative weighting to give to each band region when solving
+        the least squares problem. `weight` has to be half the size of
+        `bands`.
+        All elements must be non-negative (this is not checked by the routine).
+    fs : float, optional
+        The sampling frequency of the signal. Each frequency in `bands`
+        must be between 0 and ``fs/2`` (inclusive). Default is 2.
+
+    Returns
+    -------
+    coeffs : ndarray
+        Coefficients of the optimal (in a least squares sense) FIR filter.
+
+    See Also
+    --------
+    firwin
+    firwin2
+    minimum_phase
+    remez
+    scipy.signal.firls
+    """
+    nyq = 0.5 * fs
+
+    numtaps = int(numtaps)
+    if numtaps % 2 == 0 or numtaps < 1:
+        raise ValueError("numtaps must be odd and >= 1")
+    M = (numtaps-1) // 2
+
+    # normalize bands 0->1 and make it 2 columns
+    nyq = float(nyq)
+    if nyq <= 0:
+        raise ValueError('nyq must be positive, got %s <= 0.' % nyq)
+    bands = cupy.asarray(bands).flatten() / nyq
+    if len(bands) % 2 != 0:
+        raise ValueError("bands must contain frequency pairs.")
+    if (bands < 0).any() or (bands > 1).any():
+        raise ValueError("bands must be between 0 and 1 relative to Nyquist")
+    bands.shape = (-1, 2)
+
+    # check remaining params
+    desired = cupy.asarray(desired).flatten()
+    if bands.size != desired.size:
+        raise ValueError("desired must have one entry per frequency, got %s "
+                         "gains for %s frequencies."
+                         % (desired.size, bands.size))
+    desired.shape = (-1, 2)
+    # if (cupy.diff(bands) <= 0).any() or (cupy.diff(bands[:, 0]) < 0).any():
+    #     raise ValueError("bands must be monotonically nondecreasing and have"
+    #                     " width > 0.")
+    # if (bands[:-1, 1] > bands[1:, 0]).any():
+    #     raise ValueError("bands must not overlap.")
+    # if (desired < 0).any():
+    #     raise ValueError("desired must be non-negative.")
+    if weight is None:
+        weight = cupy.ones(len(desired))
+    weight = cupy.asarray(weight).flatten()
+    if len(weight) != len(desired):
+        raise ValueError("weight must be the same size as the number of "
+                         "band pairs ({}).".format(len(bands)))
+    # if (weight < 0).any():
+    #    raise ValueError("weight must be non-negative.")
+
+    # Set up the linear matrix equation to be solved, Qa = b
+
+    # We can express Q(k,n) = 0.5 Q1(k,n) + 0.5 Q2(k,n)
+    # where Q1(k,n)=q(k-n) and Q2(k,n)=q(k+n), i.e. a Toeplitz plus Hankel.
+
+    # We omit the factor of 0.5 above, instead adding it during coefficient
+    # calculation.
+
+    # We also omit the 1/π from both Q and b equations, as they cancel
+    # during solving.
+
+    # We have that:
+    #     q(n) = 1/π ∫W(ω)cos(nω)dω (over 0->π)
+    # Using our normalization ω=πf and with a constant weight W over each
+    # interval f1->f2 we get:
+    #     q(n) = W∫cos(πnf)df (0->1) = Wf sin(πnf)/πnf
+    # integrated over each f1->f2 pair (i.e., value at f2 - value at f1).
+    n = cupy.arange(numtaps)[:, cupy.newaxis, cupy.newaxis]
+    q = cupy.dot(cupy.diff(cupy.sinc(bands * n) *
+                           bands, axis=2)[:, :, 0], weight)
+
+    # Now we assemble our sum of Toeplitz and Hankel
+    Q1 = toeplitz(q[:M+1])
+    Q2 = hankel(q[:M+1], q[M:])
+    Q = Q1 + Q2
+
+    # Now for b(n) we have that:
+    #     b(n) = 1/π ∫ W(ω)D(ω)cos(nω)dω (over 0->π)
+    # Using our normalization ω=πf and with a constant weight W over each
+    # interval and a linear term for D(ω) we get (over each f1->f2 interval):
+    #     b(n) = W ∫ (mf+c)cos(πnf)df
+    #          = f(mf+c)sin(πnf)/πnf + mf**2 cos(nπf)/(πnf)**2
+    # integrated over each f1->f2 pair (i.e., value at f2 - value at f1).
+    n = n[:M + 1]  # only need this many coefficients here
+    # Choose m and c such that we are at the start and end weights
+    m = (cupy.diff(desired, axis=1) / cupy.diff(bands, axis=1))
+    c = desired[:, [0]] - bands[:, [0]] * m
+    b = bands * (m*bands + c) * cupy.sinc(bands * n)
+    # Use L'Hospital's rule here for cos(nπf)/(πnf)**2 @ n=0
+    b[0] -= m * bands * bands / 2.
+    b[1:] += m * cupy.cos(n[1:] * cupy.pi * bands) / (cupy.pi * n[1:]) ** 2
+    b = cupy.diff(b, axis=2)[:, :, 0] @ weight
+
+    # Now we can solve the equation : XXX CuPy failure modes (?)
+    with cupyx.errstate(linalg="raise"):
+        try:
+            a = solve(Q, b)
+        except LinAlgError:
+            # in case Q is rank deficient
+            a = lstsq(Q, b, rcond=None)[0]
+
+    # XXX: scipy.signal does this:
+    # try:  # try the fast way
+    #     with warnings.catch_warnings(record=True) as w:
+    #         warnings.simplefilter('always')
+    #         a = solve(Q, b)
+    #     for ww in w:
+    #         if (ww.category == LinAlgWarning and
+    #                 str(ww.message).startswith('Ill-conditioned matrix')):
+    #             raise LinAlgError(str(ww.message))
+    # except LinAlgError:  # in case Q is rank deficient
+    #     a = lstsq(Q, b)[0]
+
+    # make coefficients symmetric (linear phase)
+    coeffs = cupy.hstack((a[:0:-1], 2 * a[0], a[1:]))
+    return coeffs
+
+
+def _dhtm(mag):
+    """Compute the modified 1-D discrete Hilbert transform
+
+    Parameters
+    ----------
+    mag : ndarray
+        The magnitude spectrum. Should be 1-D with an even length, and
+        preferably a fast length for FFT/IFFT.
+    """
+    # Adapted based on code by Niranjan Damera-Venkata,
+    # Brian L. Evans and Shawn R. McCaslin (see refs for `minimum_phase`)
+    sig = cupy.zeros(len(mag))
+    # Leave Nyquist and DC at 0, knowing np.abs(fftfreq(N)[midpt]) == 0.5
+    midpt = len(mag) // 2
+    sig[1:midpt] = 1
+    sig[midpt + 1:] = -1
+    # eventually if we want to support complex filters, we will need a
+    # cupy.abs() on the mag inside the log, and should remove the .real
+    recon = ifft(mag * cupy.exp(fft(sig * ifft(cupy.log(mag))))).real
+    return recon
+
+
+def minimum_phase(h, method='homomorphic', n_fft=None):
+    """Convert a linear-phase FIR filter to minimum phase
+
+    Parameters
+    ----------
+    h : array
+        Linear-phase FIR filter coefficients.
+    method : {'hilbert', 'homomorphic'}
+        The method to use:
+
+            'homomorphic' (default)
+                This method [4]_ [5]_ works best with filters with an
+                odd number of taps, and the resulting minimum phase filter
+                will have a magnitude response that approximates the square
+                root of the original filter's magnitude response.
+
+            'hilbert'
+                This method [1]_ is designed to be used with equiripple
+                filters (e.g., from `remez`) with unity or zero gain
+                regions.
+
+    n_fft : int
+        The number of points to use for the FFT. Should be at least a
+        few times larger than the signal length (see Notes).
+
+    Returns
+    -------
+    h_minimum : array
+        The minimum-phase version of the filter, with length
+        ``(length(h) + 1) // 2``.
+
+    See Also
+    --------
+    scipy.signal.minimum_phase
+
+    Notes
+    -----
+    Both the Hilbert [1]_ or homomorphic [4]_ [5]_ methods require selection
+    of an FFT length to estimate the complex cepstrum of the filter.
+
+    In the case of the Hilbert method, the deviation from the ideal
+    spectrum ``epsilon`` is related to the number of stopband zeros
+    ``n_stop`` and FFT length ``n_fft`` as::
+
+        epsilon = 2. * n_stop / n_fft
+
+    For example, with 100 stopband zeros and a FFT length of 2048,
+    ``epsilon = 0.0976``. If we conservatively assume that the number of
+    stopband zeros is one less than the filter length, we can take the FFT
+    length to be the next power of 2 that satisfies ``epsilon=0.01`` as::
+
+        n_fft = 2 ** int(np.ceil(np.log2(2 * (len(h) - 1) / 0.01)))
+
+    This gives reasonable results for both the Hilbert and homomorphic
+    methods, and gives the value used when ``n_fft=None``.
+
+    Alternative implementations exist for creating minimum-phase filters,
+    including zero inversion [2]_ and spectral factorization [3]_ [4]_ [5]_.
+    For more information, see:
+
+        http://dspguru.com/dsp/howtos/how-to-design-minimum-phase-fir-filters
+
+    References
+    ----------
+    .. [1] N. Damera-Venkata and B. L. Evans, "Optimal design of real and
+           complex minimum phase digital FIR filters," Acoustics, Speech,
+           and Signal Processing, 1999. Proceedings., 1999 IEEE International
+           Conference on, Phoenix, AZ, 1999, pp. 1145-1148 vol.3.
+           DOI:10.1109/ICASSP.1999.756179
+    .. [2] X. Chen and T. W. Parks, "Design of optimal minimum phase FIR
+           filters by direct factorization," Signal Processing,
+           vol. 10, no. 4, pp. 369-383, Jun. 1986.
+    .. [3] T. Saramaki, "Finite Impulse Response Filter Design," in
+           Handbook for Digital Signal Processing, chapter 4,
+           New York: Wiley-Interscience, 1993.
+    .. [4] J. S. Lim, Advanced Topics in Signal Processing.
+           Englewood Cliffs, N.J.: Prentice Hall, 1988.
+    .. [5] A. V. Oppenheim, R. W. Schafer, and J. R. Buck,
+           "Discrete-Time Signal Processing," 2nd edition.
+           Upper Saddle River, N.J.: Prentice Hall, 1999.
+
+    """  # noqa
+    if cupy.iscomplexobj(h):
+        raise ValueError('Complex filters not supported')
+    if h.ndim != 1 or h.size <= 2:
+        raise ValueError('h must be 1-D and at least 2 samples long')
+    n_half = len(h) // 2
+    if not cupy.allclose(h[-n_half:][::-1], h[:n_half]):
+        import warnings
+        warnings.warn('h does not appear to by symmetric, conversion may '
+                      'fail', RuntimeWarning)
+    if not isinstance(method, str) or method not in \
+            ('homomorphic', 'hilbert',):
+        raise ValueError('method must be "homomorphic" or "hilbert", got %r'
+                         % (method,))
+    if n_fft is None:
+        n_fft = 2 ** int(cupy.ceil(cupy.log2(2 * (len(h) - 1) / 0.01)))
+    n_fft = int(n_fft)
+    if n_fft < len(h):
+        raise ValueError('n_fft must be at least len(h)==%s' % len(h))
+    if method == 'hilbert':
+        w = cupy.arange(n_fft) * (2 * cupy.pi / n_fft * n_half)
+        H = cupy.real(fft(h, n_fft) * cupy.exp(1j * w))
+        dp = max(H) - 1
+        ds = 0 - min(H)
+        S = 4. / (cupy.sqrt(1 + dp + ds) + cupy.sqrt(1 - dp + ds)) ** 2
+        H += ds
+        H *= S
+        H = cupy.sqrt(H, out=H)
+        H += 1e-10  # ensure that the log does not explode
+        h_minimum = _dhtm(H)
+    else:  # method == 'homomorphic'
+        # zero-pad; calculate the DFT
+        h_temp = cupy.abs(fft(h, n_fft))
+        # take 0.25*log(|H|**2) = 0.5*log(|H|)
+        h_temp += 1e-7 * h_temp[h_temp > 0].min()  # don't let log blow up
+        cupy.log(h_temp, out=h_temp)
+        h_temp *= 0.5
+        # IDFT
+        h_temp = ifft(h_temp).real
+        # multiply pointwise by the homomorphic filter
+        # lmin[n] = 2u[n] - d[n]
+        win = cupy.zeros(n_fft)
+        win[0] = 1
+        stop = (len(h) + 1) // 2
+        win[1:stop] = 2
+        if len(h) % 2:
+            win[stop] = 1
+        h_temp *= win
+        h_temp = ifft(cupy.exp(fft(h_temp)))
+        h_minimum = h_temp.real
+    n_out = n_half + len(h) % 2
+    return h_minimum[:n_out]

vllm/lib/python3.10/site-packages/cupyx/scipy/signal/_iir_filter_conversions.py

@@ -0,0 +1,2364 @@
+""" IIR filter conversion utilities.
+
+Split off _filter_design.py
+"""
+import warnings
+import math
+from math import pi, prod
+
+import cupy
+from cupyx.scipy.special import binom as comb
+import cupyx.scipy.special as special
+from cupyx.scipy.signal import _optimize
+
+from cupyx.scipy.signal._polyutils import roots, poly
+from cupyx.scipy.signal._lti_conversion import abcd_normalize
+
+
+class BadCoefficients(UserWarning):
+    """Warning about badly conditioned filter coefficients"""
+    pass
+
+
+def _trim_zeros(filt, trim='fb'):
+    # https://github.com/numpy/numpy/blob/v1.24.0/numpy/lib/function_base.py#L1800-L1850
+
+    first = 0
+    if 'f' in trim:
+        for i in filt:
+            if i != 0.:
+                break
+            else:
+                first = first + 1
+
+    last = len(filt)
+    if 'b' in trim:
+        for i in filt[::-1]:
+            if i != 0.:
+                break
+            else:
+                last = last - 1
+    return filt[first:last]
+
+
+def _align_nums(nums):
+    """Aligns the shapes of multiple numerators.
+
+    Given an array of numerator coefficient arrays [[a_1, a_2,...,
+    a_n],..., [b_1, b_2,..., b_m]], this function pads shorter numerator
+    arrays with zero's so that all numerators have the same length. Such
+    alignment is necessary for functions like 'tf2ss', which needs the
+    alignment when dealing with SIMO transfer functions.
+
+    Parameters
+    ----------
+    nums: array_like
+        Numerator or list of numerators. Not necessarily with same length.
+
+    Returns
+    -------
+    nums: array
+        The numerator. If `nums` input was a list of numerators then a 2-D
+        array with padded zeros for shorter numerators is returned. Otherwise
+        returns ``np.asarray(nums)``.
+    """
+    try:
+        # The statement can throw a ValueError if one
+        # of the numerators is a single digit and another
+        # is array-like e.g. if nums = [5, [1, 2, 3]]
+        nums = cupy.asarray(nums)
+        return nums
+
+    except ValueError:
+        nums = [cupy.atleast_1d(num) for num in nums]
+        max_width = max(num.size for num in nums)
+
+        # pre-allocate
+        aligned_nums = cupy.zeros((len(nums), max_width))
+
+        # Create numerators with padded zeros
+        for index, num in enumerate(nums):
+            aligned_nums[index, -num.size:] = num
+
+        return aligned_nums
+
+
+def _polycoeffs_from_zeros(zeros, tol=10):
+    # a clone of numpy.poly, simplified
+    dtyp = (cupy.complex128
+            if cupy.issubdtype(zeros.dtype, cupy.complexfloating)
+            else cupy.float64)
+    a = cupy.ones(1, dtype=dtyp)
+    for z in zeros:
+        a = cupy.convolve(a, cupy.r_[1, -z], mode='full')
+
+    # Use real output if possible.
+    if dtyp == cupy.complex128:
+        mask = cupy.abs(a.imag) < tol * cupy.finfo(a.dtype).eps
+        a.imag[mask] = 0.0
+        if mask.shape[0] == a.shape[0]:
+            # all imag parts were fp noise
+            a = a.real.copy()
+        else:
+            # if all cmplx roots are complex conj, the coefficients are real
+            pos_roots = z[z.imag > 0]
+            neg_roots = z[z.imag < 0]
+            if pos_roots.shape[0] == neg_roots.shape[0]:
+                neg_roots = neg_roots.copy()
+                neg_roots.sort()
+                pos_roots = pos_roots.copy()
+                pos_roots.sort()
+                if (neg_roots == pos_roots.conj()).all():
+                    a = a.real.copy()
+    return a
+
+
+def _nearest_real_complex_idx(fro, to, which):
+    """Get the next closest real or complex element based on distance"""
+    assert which in ('real', 'complex', 'any')
+    order = cupy.argsort(cupy.abs(fro - to))
+    if which == 'any':
+        return order[0]
+    else:
+        mask = cupy.isreal(fro[order])
+        if which == 'complex':
+            mask = ~mask
+        return order[cupy.nonzero(mask)[0][0]]
+
+
+def _single_zpksos(z, p, k):
+    """Create one second-order section from up to two zeros and poles"""
+    sos = cupy.zeros(6)
+    b, a = zpk2tf(cupy.asarray(z), cupy.asarray(p), k)
+    sos[3-len(b):3] = b
+    sos[6-len(a):6] = a
+    return sos
+
+
+def zpk2sos(z, p, k, pairing=None, *, analog=False):
+    """Return second-order sections from zeros, poles, and gain of a system
+
+    Parameters
+    ----------
+    z : array_like
+        Zeros of the transfer function.
+    p : array_like
+        Poles of the transfer function.
+    k : float
+        System gain.
+    pairing : {None, 'nearest', 'keep_odd', 'minimal'}, optional
+        The method to use to combine pairs of poles and zeros into sections.
+        If analog is False and pairing is None, pairing is set to 'nearest';
+        if analog is True, pairing must be 'minimal', and is set to that if
+        it is None.
+    analog : bool, optional
+        If True, system is analog, otherwise discrete.
+
+    Returns
+    -------
+    sos : ndarray
+        Array of second-order filter coefficients, with shape
+        ``(n_sections, 6)``. See `sosfilt` for the SOS filter format
+        specification.
+
+    See Also
+    --------
+    sosfilt
+    scipy.signal.zpk2sos
+
+    """
+    if pairing is None:
+        pairing = 'minimal' if analog else 'nearest'
+
+    valid_pairings = ['nearest', 'keep_odd', 'minimal']
+    if pairing not in valid_pairings:
+        raise ValueError('pairing must be one of %s, not %s'
+                         % (valid_pairings, pairing))
+
+    if analog and pairing != 'minimal':
+        raise ValueError('for analog zpk2sos conversion, '
+                         'pairing must be "minimal"')
+
+    if len(z) == len(p) == 0:
+        if not analog:
+            return cupy.array([[k, 0., 0., 1., 0., 0.]])
+        else:
+            return cupy.array([[0., 0., k, 0., 0., 1.]])
+
+    if pairing != 'minimal':
+        # ensure we have the same number of poles and zeros, and make copies
+        p = cupy.concatenate((p, cupy.zeros(max(len(z) - len(p), 0))))
+        z = cupy.concatenate((z, cupy.zeros(max(len(p) - len(z), 0))))
+        n_sections = (max(len(p), len(z)) + 1) // 2
+
+        if len(p) % 2 == 1 and pairing == 'nearest':
+            p = cupy.concatenate((p, cupy.zeros(1)))
+            z = cupy.concatenate((z, cupy.zeros(1)))
+        assert len(p) == len(z)
+    else:
+        if len(p) < len(z):
+            raise ValueError('for analog zpk2sos conversion, '
+                             'must have len(p)>=len(z)')
+
+        n_sections = (len(p) + 1) // 2
+
+    # Ensure we have complex conjugate pairs
+    # (note that _cplxreal only gives us one element of each complex pair):
+    z = cupy.concatenate(_cplxreal(z))
+    p = cupy.concatenate(_cplxreal(p))
+    if not cupy.isreal(k):
+        raise ValueError('k must be real')
+    k = k.real
+
+    if not analog:
+        # digital: "worst" is the closest to the unit circle
+        def idx_worst(p):
+            return cupy.argmin(cupy.abs(1 - cupy.abs(p)))
+    else:
+        # analog: "worst" is the closest to the imaginary axis
+        def idx_worst(p):
+            return cupy.argmin(cupy.abs(cupy.real(p)))
+
+    sos = cupy.zeros((n_sections, 6))
+
+    # Construct the system, reversing order so the "worst" are last
+    for si in range(n_sections-1, -1, -1):
+        # Select the next "worst" pole
+        p1_idx = idx_worst(p)
+        p1 = p[p1_idx]
+        p = cupy.delete(p, p1_idx)
+
+        # Pair that pole with a zero
+
+        if cupy.isreal(p1) and cupy.isreal(p).sum() == 0:
+            # Special case (1): last remaining real pole
+            if pairing != 'minimal':
+                z1_idx = _nearest_real_complex_idx(z, p1, 'real')
+                z1 = z[z1_idx]
+                z = cupy.delete(z, z1_idx)
+                sos[si] = _single_zpksos(cupy.r_[z1, 0], cupy.r_[p1, 0], 1)
+            elif len(z) > 0:
+                z1_idx = _nearest_real_complex_idx(z, p1, 'real')
+                z1 = z[z1_idx]
+                z = cupy.delete(z, z1_idx)
+                sos[si] = _single_zpksos([z1], [p1], 1)
+            else:
+                sos[si] = _single_zpksos([], [p1], 1)
+
+        elif (len(p) + 1 == len(z)
+              and not cupy.isreal(p1)
+              and cupy.isreal(p).sum() == 1
+              and cupy.isreal(z).sum() == 1):
+
+            # Special case (2): there's one real pole and one real zero
+            # left, and an equal number of poles and zeros to pair up.
+            # We *must* pair with a complex zero
+
+            z1_idx = _nearest_real_complex_idx(z, p1, 'complex')
+            z1 = z[z1_idx]
+            z = cupy.delete(z, z1_idx)
+            sos[si] = _single_zpksos(
+                cupy.r_[z1, z1.conj()], cupy.r_[p1, p1.conj()], 1)
+
+        else:
+            if cupy.isreal(p1):
+                prealidx = cupy.flatnonzero(cupy.isreal(p))
+                p2_idx = prealidx[idx_worst(p[prealidx])]
+                p2 = p[p2_idx]
+                p = cupy.delete(p, p2_idx)
+            else:
+                p2 = p1.conj()
+
+            # find closest zero
+            if len(z) > 0:
+                z1_idx = _nearest_real_complex_idx(z, p1, 'any')
+                z1 = z[z1_idx]
+                z = cupy.delete(z, z1_idx)
+
+                if not cupy.isreal(z1):
+                    sos[si] = _single_zpksos(
+                        cupy.r_[z1, z1.conj()], cupy.r_[p1, p2], 1)
+                else:
+                    if len(z) > 0:
+                        z2_idx = _nearest_real_complex_idx(z, p1, 'real')
+                        z2 = z[z2_idx]
+                        assert cupy.isreal(z2)
+                        z = cupy.delete(z, z2_idx)
+                        sos[si] = _single_zpksos(cupy.r_[z1, z2], [p1, p2], 1)
+                    else:
+                        sos[si] = _single_zpksos([z1], [p1, p2], 1)
+            else:
+                # no more zeros
+                sos[si] = _single_zpksos([], [p1, p2], 1)
+
+    assert len(p) == len(z) == 0  # we've consumed all poles and zeros
+    del p, z
+
+    # put gain in first sos
+    sos[0][:3] *= k
+    return sos
+
+
+def _cplxreal(z, tol=None):
+    """
+    Split into complex and real parts, combining conjugate pairs.
+
+    The 1-D input vector `z` is split up into its complex (zc) and real (zr)
+    elements. Every complex element must be part of a complex-conjugate pair,
+    which are combined into a single number (with positive imaginary part) in
+    the output. Two complex numbers are considered a conjugate pair if their
+    real and imaginary parts differ in magnitude by less than ``tol * abs(z)``.
+
+    Parameters
+    ----------
+    z : array_like
+        Vector of complex numbers to be sorted and split
+    tol : float, optional
+        Relative tolerance for testing realness and conjugate equality.
+        Default is ``100 * spacing(1)`` of `z`'s data type (i.e., 2e-14 for
+        float64)
+
+    Returns
+    -------
+    zc : ndarray
+        Complex elements of `z`, with each pair represented by a single value
+        having positive imaginary part, sorted first by real part, and then
+        by magnitude of imaginary part. The pairs are averaged when combined
+        to reduce error.
+    zr : ndarray
+        Real elements of `z` (those having imaginary part less than
+        `tol` times their magnitude), sorted by value.
+
+    Raises
+    ------
+    ValueError
+        If there are any complex numbers in `z` for which a conjugate
+        cannot be found.
+
+    See Also
+    --------
+    scipy.signal.cmplxreal
+
+    Examples
+    --------
+    >>> a = [4, 3, 1, 2-2j, 2+2j, 2-1j, 2+1j, 2-1j, 2+1j, 1+1j, 1-1j]
+    >>> zc, zr = _cplxreal(a)
+    >>> print(zc)
+    [ 1.+1.j  2.+1.j  2.+1.j  2.+2.j]
+    >>> print(zr)
+    [ 1.  3.  4.]
+    """
+
+    z = cupy.atleast_1d(z)
+    if z.size == 0:
+        return z, z
+    elif z.ndim != 1:
+        raise ValueError('_cplxreal only accepts 1-D input')
+
+    if tol is None:
+        # Get tolerance from dtype of input
+        tol = 100 * cupy.finfo((1.0 * z).dtype).eps
+
+    # Sort by real part, magnitude of imaginary part (speed up further sorting)
+    z = z[cupy.lexsort(cupy.array([abs(z.imag), z.real]))]
+
+    # Split reals from conjugate pairs
+    real_indices = abs(z.imag) <= tol * abs(z)
+    zr = z[real_indices].real
+
+    if len(zr) == len(z):
+        # Input is entirely real
+        return cupy.array([]), zr
+
+    # Split positive and negative halves of conjugates
+    z = z[~real_indices]
+    zp = z[z.imag > 0]
+    zn = z[z.imag < 0]
+
+    if len(zp) != len(zn):
+        raise ValueError('Array contains complex value with no matching '
+                         'conjugate.')
+
+    # Find runs of (approximately) the same real part
+    same_real = cupy.diff(zp.real) <= tol * abs(zp[:-1])
+    diffs = cupy.diff(cupy.r_[0, same_real, 0])
+    run_starts = cupy.nonzero(diffs > 0)[0]
+    run_stops = cupy.nonzero(diffs < 0)[0]
+
+    # Sort each run by their imaginary parts
+    for i in range(len(run_starts)):
+        start = run_starts[i]
+        stop = run_stops[i] + 1
+        for chunk in (zp[start:stop], zn[start:stop]):
+            chunk[...] = chunk[cupy.lexsort(cupy.array([abs(chunk.imag)]))]
+
+    # Check that negatives match positives
+    if any(abs(zp - zn.conj()) > tol * abs(zn)):
+        raise ValueError('Array contains complex value with no matching '
+                         'conjugate.')
+
+    # Average out numerical inaccuracy in real vs imag parts of pairs
+    zc = (zp + zn.conj()) / 2
+
+    return zc, zr
+
+
+def normalize(b, a):
+    """Normalize numerator/denominator of a continuous-time transfer function.
+
+    If values of `b` are too close to 0, they are removed. In that case, a
+    BadCoefficients warning is emitted.
+
+    Parameters
+    ----------
+    b: array_like
+        Numerator of the transfer function. Can be a 2-D array to normalize
+        multiple transfer functions.
+    a: array_like
+        Denominator of the transfer function. At most 1-D.
+
+    Returns
+    -------
+    num: array
+        The numerator of the normalized transfer function. At least a 1-D
+        array. A 2-D array if the input `num` is a 2-D array.
+    den: 1-D array
+        The denominator of the normalized transfer function.
+
+    Notes
+    -----
+    Coefficients for both the numerator and denominator should be specified in
+    descending exponent order (e.g., ``s^2 + 3s + 5`` would be represented as
+    ``[1, 3, 5]``).
+
+    See Also
+    --------
+    scipy.signal.normalize
+
+    """
+    num, den = b, a
+
+    den = cupy.atleast_1d(den)
+    num = cupy.atleast_2d(_align_nums(num))
+
+    if den.ndim != 1:
+        raise ValueError("Denominator polynomial must be rank-1 array.")
+    if num.ndim > 2:
+        raise ValueError("Numerator polynomial must be rank-1 or"
+                         " rank-2 array.")
+    if cupy.all(den == 0):
+        raise ValueError("Denominator must have at least on nonzero element.")
+
+    # Trim leading zeros in denominator, leave at least one.
+    den = _trim_zeros(den, 'f')
+
+    # Normalize transfer function
+    num, den = num / den[0], den / den[0]
+
+    # Count numerator columns that are all zero
+    leading_zeros = 0
+    for col in num.T:
+        if cupy.allclose(col, 0, atol=1e-14):
+            leading_zeros += 1
+        else:
+            break
+
+    # Trim leading zeros of numerator
+    if leading_zeros > 0:
+        warnings.warn("Badly conditioned filter coefficients (numerator): the "
+                      "results may be meaningless", BadCoefficients)
+        # Make sure at least one column remains
+        if leading_zeros == num.shape[1]:
+            leading_zeros -= 1
+        num = num[:, leading_zeros:]
+
+    # Squeeze first dimension if singular
+    if num.shape[0] == 1:
+        num = num[0, :]
+
+    return num, den
+
+
+def _relative_degree(z, p):
+    """
+    Return relative degree of transfer function from zeros and poles
+    """
+    degree = len(p) - len(z)
+    if degree < 0:
+        raise ValueError("Improper transfer function. "
+                         "Must have at least as many poles as zeros.")
+    else:
+        return degree
+
+
+def bilinear_zpk(z, p, k, fs):
+    r"""
+    Return a digital IIR filter from an analog one using a bilinear transform.
+
+    Transform a set of poles and zeros from the analog s-plane to the digital
+    z-plane using Tustin's method, which substitutes ``2*fs*(z-1) / (z+1)`` for
+    ``s``, maintaining the shape of the frequency response.
+
+    Parameters
+    ----------
+    z : array_like
+        Zeros of the analog filter transfer function.
+    p : array_like
+        Poles of the analog filter transfer function.
+    k : float
+        System gain of the analog filter transfer function.
+    fs : float
+        Sample rate, as ordinary frequency (e.g., hertz). No prewarping is
+        done in this function.
+
+    Returns
+    -------
+    z : ndarray
+        Zeros of the transformed digital filter transfer function.
+    p : ndarray
+        Poles of the transformed digital filter transfer function.
+    k : float
+        System gain of the transformed digital filter.
+
+    See Also
+    --------
+    lp2lp_zpk, lp2hp_zpk, lp2bp_zpk, lp2bs_zpk
+    bilinear
+    scipy.signal.bilinear_zpk
+
+    """
+    z = cupy.atleast_1d(z)
+    p = cupy.atleast_1d(p)
+
+    degree = _relative_degree(z, p)
+
+    fs2 = 2.0 * fs
+
+    # Bilinear transform the poles and zeros
+    z_z = (fs2 + z) / (fs2 - z)
+    p_z = (fs2 + p) / (fs2 - p)
+
+    # Any zeros that were at infinity get moved to the Nyquist frequency
+    z_z = cupy.append(z_z, -cupy.ones(degree))
+
+    # Compensate for gain change
+    k_z = k * (cupy.prod(fs2 - z) / cupy.prod(fs2 - p)).real
+
+    return z_z, p_z, k_z
+
+
+def lp2lp_zpk(z, p, k, wo=1.0):
+    r"""
+    Transform a lowpass filter prototype to a different frequency.
+
+    Return an analog low-pass filter with cutoff frequency `wo`
+    from an analog low-pass filter prototype with unity cutoff frequency,
+    using zeros, poles, and gain ('zpk') representation.
+
+    Parameters
+    ----------
+    z : array_like
+        Zeros of the analog filter transfer function.
+    p : array_like
+        Poles of the analog filter transfer function.
+    k : float
+        System gain of the analog filter transfer function.
+    wo : float
+        Desired cutoff, as angular frequency (e.g., rad/s).
+        Defaults to no change.
+
+    Returns
+    -------
+    z : ndarray
+        Zeros of the transformed low-pass filter transfer function.
+    p : ndarray
+        Poles of the transformed low-pass filter transfer function.
+    k : float
+        System gain of the transformed low-pass filter.
+
+    See Also
+    --------
+    lp2hp_zpk, lp2bp_zpk, lp2bs_zpk, bilinear
+    lp2lp
+    scipy.signal.lp2lp_zpk
+
+    """
+    z = cupy.atleast_1d(z)
+    p = cupy.atleast_1d(p)
+    wo = float(wo)  # Avoid int wraparound
+
+    degree = _relative_degree(z, p)
+
+    # Scale all points radially from origin to shift cutoff frequency
+    z_lp = wo * z
+    p_lp = wo * p
+
+    # Each shifted pole decreases gain by wo, each shifted zero increases it.
+    # Cancel out the net change to keep overall gain the same
+    k_lp = k * wo**degree
+
+    return z_lp, p_lp, k_lp
+
+
+def lp2hp_zpk(z, p, k, wo=1.0):
+    r"""
+    Transform a lowpass filter prototype to a highpass filter.
+
+    Return an analog high-pass filter with cutoff frequency `wo`
+    from an analog low-pass filter prototype with unity cutoff frequency,
+    using zeros, poles, and gain ('zpk') representation.
+
+    Parameters
+    ----------
+    z : array_like
+        Zeros of the analog filter transfer function.
+    p : array_like
+        Poles of the analog filter transfer function.
+    k : float
+        System gain of the analog filter transfer function.
+    wo : float
+        Desired cutoff, as angular frequency (e.g., rad/s).
+        Defaults to no change.
+
+    Returns
+    -------
+    z : ndarray
+        Zeros of the transformed high-pass filter transfer function.
+    p : ndarray
+        Poles of the transformed high-pass filter transfer function.
+    k : float
+        System gain of the transformed high-pass filter.
+
+    See Also
+    --------
+    lp2lp_zpk, lp2bp_zpk, lp2bs_zpk, bilinear
+    lp2hp
+    scipy.signal.lp2hp_zpk
+
+    Notes
+    -----
+    This is derived from the s-plane substitution
+
+    .. math:: s \rightarrow \frac{\omega_0}{s}
+
+    This maintains symmetry of the lowpass and highpass responses on a
+    logarithmic scale.
+
+    """
+    z = cupy.atleast_1d(z)
+    p = cupy.atleast_1d(p)
+    wo = float(wo)
+
+    degree = _relative_degree(z, p)
+
+    # Invert positions radially about unit circle to convert LPF to HPF
+    # Scale all points radially from origin to shift cutoff frequency
+    z_hp = wo / z
+    p_hp = wo / p
+
+    # If lowpass had zeros at infinity, inverting moves them to origin.
+    z_hp = cupy.append(z_hp, cupy.zeros(degree))
+
+    # Cancel out gain change caused by inversion
+    k_hp = k * cupy.real(cupy.prod(-z) / cupy.prod(-p))
+
+    return z_hp, p_hp, k_hp
+
+
+def lp2bp_zpk(z, p, k, wo=1.0, bw=1.0):
+    r"""
+    Transform a lowpass filter prototype to a bandpass filter.
+
+    Return an analog band-pass filter with center frequency `wo` and
+    bandwidth `bw` from an analog low-pass filter prototype with unity
+    cutoff frequency, using zeros, poles, and gain ('zpk') representation.
+
+    Parameters
+    ----------
+    z : array_like
+        Zeros of the analog filter transfer function.
+    p : array_like
+        Poles of the analog filter transfer function.
+    k : float
+        System gain of the analog filter transfer function.
+    wo : float
+        Desired passband center, as angular frequency (e.g., rad/s).
+        Defaults to no change.
+    bw : float
+        Desired passband width, as angular frequency (e.g., rad/s).
+        Defaults to 1.
+
+    Returns
+    -------
+    z : ndarray
+        Zeros of the transformed band-pass filter transfer function.
+    p : ndarray
+        Poles of the transformed band-pass filter transfer function.
+    k : float
+        System gain of the transformed band-pass filter.
+
+    See Also
+    --------
+    lp2lp_zpk, lp2hp_zpk, lp2bs_zpk, bilinear
+    lp2bp
+    scipy.signal.lp2bp_zpk
+
+    Notes
+    -----
+    This is derived from the s-plane substitution
+
+    .. math:: s \rightarrow \frac{s^2 + {\omega_0}^2}{s \cdot \mathrm{BW}}
+
+    This is the "wideband" transformation, producing a passband with
+    geometric (log frequency) symmetry about `wo`.
+
+    """
+    z = cupy.atleast_1d(z)
+    p = cupy.atleast_1d(p)
+    wo = float(wo)
+    bw = float(bw)
+
+    degree = _relative_degree(z, p)
+
+    # Scale poles and zeros to desired bandwidth
+    z_lp = z * bw/2
+    p_lp = p * bw/2
+
+    # Square root needs to produce complex result, not NaN
+    z_lp = z_lp.astype(complex)
+    p_lp = p_lp.astype(complex)
+
+    # Duplicate poles and zeros and shift from baseband to +wo and -wo
+    z_bp = cupy.concatenate((z_lp + cupy.sqrt(z_lp**2 - wo**2),
+                             z_lp - cupy.sqrt(z_lp**2 - wo**2)))
+    p_bp = cupy.concatenate((p_lp + cupy.sqrt(p_lp**2 - wo**2),
+                             p_lp - cupy.sqrt(p_lp**2 - wo**2)))
+
+    # Move degree zeros to origin, leaving degree zeros at infinity for BPF
+    z_bp = cupy.append(z_bp, cupy.zeros(degree))
+
+    # Cancel out gain change from frequency scaling
+    k_bp = k * bw**degree
+
+    return z_bp, p_bp, k_bp
+
+
+def lp2bs_zpk(z, p, k, wo=1.0, bw=1.0):
+    r"""
+    Transform a lowpass filter prototype to a bandstop filter.
+
+    Return an analog band-stop filter with center frequency `wo` and
+    stopband width `bw` from an analog low-pass filter prototype with unity
+    cutoff frequency, using zeros, poles, and gain ('zpk') representation.
+
+    Parameters
+    ----------
+    z : array_like
+        Zeros of the analog filter transfer function.
+    p : array_like
+        Poles of the analog filter transfer function.
+    k : float
+        System gain of the analog filter transfer function.
+    wo : float
+        Desired stopband center, as angular frequency (e.g., rad/s).
+        Defaults to no change.
+    bw : float
+        Desired stopband width, as angular frequency (e.g., rad/s).
+        Defaults to 1.
+
+    Returns
+    -------
+    z : ndarray
+        Zeros of the transformed band-stop filter transfer function.
+    p : ndarray
+        Poles of the transformed band-stop filter transfer function.
+    k : float
+        System gain of the transformed band-stop filter.
+
+    See Also
+    --------
+    lp2lp_zpk, lp2hp_zpk, lp2bp_zpk, bilinear
+    lp2bs
+    scipy.signal.lp2bs_zpk
+
+    Notes
+    -----
+    This is derived from the s-plane substitution
+
+    .. math:: s \rightarrow \frac{s \cdot \mathrm{BW}}{s^2 + {\omega_0}^2}
+
+    This is the "wideband" transformation, producing a stopband with
+    geometric (log frequency) symmetry about `wo`.
+
+    """
+    z = cupy.atleast_1d(z)
+    p = cupy.atleast_1d(p)
+    wo = float(wo)
+    bw = float(bw)
+
+    degree = _relative_degree(z, p)
+
+    # Invert to a highpass filter with desired bandwidth
+    z_hp = (bw/2) / z
+    p_hp = (bw/2) / p
+
+    # Square root needs to produce complex result, not NaN
+    z_hp = z_hp.astype(complex)
+    p_hp = p_hp.astype(complex)
+
+    # Duplicate poles and zeros and shift from baseband to +wo and -wo
+    z_bs = cupy.concatenate((z_hp + cupy.sqrt(z_hp**2 - wo**2),
+                             z_hp - cupy.sqrt(z_hp**2 - wo**2)))
+    p_bs = cupy.concatenate((p_hp + cupy.sqrt(p_hp**2 - wo**2),
+                             p_hp - cupy.sqrt(p_hp**2 - wo**2)))
+
+    # Move any zeros that were at infinity to the center of the stopband
+    z_bs = cupy.append(z_bs, cupy.full(degree, +1j*wo))
+    z_bs = cupy.append(z_bs, cupy.full(degree, -1j*wo))
+
+    # Cancel out gain change caused by inversion
+    k_bs = k * cupy.real(cupy.prod(-z) / cupy.prod(-p))
+
+    return z_bs, p_bs, k_bs
+
+
+def bilinear(b, a, fs=1.0):
+    r"""
+    Return a digital IIR filter from an analog one using a bilinear transform.
+
+    Transform a set of poles and zeros from the analog s-plane to the digital
+    z-plane using Tustin's method, which substitutes ``2*fs*(z-1) / (z+1)`` for
+    ``s``, maintaining the shape of the frequency response.
+
+    Parameters
+    ----------
+    b : array_like
+        Numerator of the analog filter transfer function.
+    a : array_like
+        Denominator of the analog filter transfer function.
+    fs : float
+        Sample rate, as ordinary frequency (e.g., hertz). No prewarping is
+        done in this function.
+
+    Returns
+    -------
+    b : ndarray
+        Numerator of the transformed digital filter transfer function.
+    a : ndarray
+        Denominator of the transformed digital filter transfer function.
+
+    See Also
+    --------
+    lp2lp, lp2hp, lp2bp, lp2bs
+    bilinear_zpk
+    scipy.signal.bilinear
+
+    """
+    fs = float(fs)
+    a, b = map(cupy.atleast_1d, (a, b))
+    D = a.shape[0] - 1
+    N = b.shape[0] - 1
+
+    M = max(N, D)
+    Np, Dp = M, M
+
+    bprime = cupy.empty(Np + 1, float)
+    aprime = cupy.empty(Dp + 1, float)
+
+    # XXX (ev-br): worth turning into a ufunc invocation? (loops are short)
+    for j in range(Dp + 1):
+        val = 0.0
+        for i in range(N + 1):
+            bNi = b[N - i] * (2 * fs)**i
+            for k in range(i + 1):
+                for s in range(M - i + 1):
+                    if k + s == j:
+                        val += comb(i, k) * comb(M - i, s) * bNi * (-1)**k
+        bprime[j] = cupy.real(val)
+
+    for j in range(Dp + 1):
+        val = 0.0
+        for i in range(D + 1):
+            aDi = a[D - i] * (2 * fs)**i
+            for k in range(i + 1):
+                for s in range(M - i + 1):
+                    if k + s == j:
+                        val += comb(i, k) * comb(M - i, s) * aDi * (-1)**k
+        aprime[j] = cupy.real(val)
+
+    return normalize(bprime, aprime)
+
+
+def lp2lp(b, a, wo=1.0):
+    r"""
+    Transform a lowpass filter prototype to a different frequency.
+
+    Return an analog low-pass filter with cutoff frequency `wo`
+    from an analog low-pass filter prototype with unity cutoff frequency, in
+    transfer function ('ba') representation.
+
+    Parameters
+    ----------
+    b : array_like
+        Numerator polynomial coefficients.
+    a : array_like
+        Denominator polynomial coefficients.
+    wo : float
+        Desired cutoff, as angular frequency (e.g. rad/s).
+        Defaults to no change.
+
+    Returns
+    -------
+    b : array_like
+        Numerator polynomial coefficients of the transformed low-pass filter.
+    a : array_like
+        Denominator polynomial coefficients of the transformed low-pass filter.
+
+    See Also
+    --------
+    lp2hp, lp2bp, lp2bs, bilinear
+    lp2lp_zpk
+    scipy.signal.lp2lp
+
+    Notes
+    -----
+    This is derived from the s-plane substitution
+
+    .. math:: s \rightarrow \frac{s}{\omega_0}
+
+    """
+    a, b = map(cupy.atleast_1d, (a, b))
+    try:
+        wo = float(wo)
+    except TypeError:
+        wo = float(wo[0])
+    d = len(a)
+    n = len(b)
+    M = max(d, n)
+    pwo = wo ** cupy.arange(M - 1, -1, -1)
+    start1 = max((n - d, 0))
+    start2 = max((d - n, 0))
+    b = b * pwo[start1] / pwo[start2:]
+    a = a * pwo[start1] / pwo[start1:]
+    return normalize(b, a)
+
+
+def lp2hp(b, a, wo=1.0):
+    r"""
+    Transform a lowpass filter prototype to a highpass filter.
+
+    Return an analog high-pass filter with cutoff frequency `wo`
+    from an analog low-pass filter prototype with unity cutoff frequency, in
+    transfer function ('ba') representation.
+
+    Parameters
+    ----------
+    b : array_like
+        Numerator polynomial coefficients.
+    a : array_like
+        Denominator polynomial coefficients.
+    wo : float
+        Desired cutoff, as angular frequency (e.g., rad/s).
+        Defaults to no change.
+
+    Returns
+    -------
+    b : array_like
+        Numerator polynomial coefficients of the transformed high-pass filter.
+    a : array_like
+        Denominator polynomial coefficients of the transformed high-pass
+        filter.
+
+    See Also
+    --------
+    lp2lp, lp2bp, lp2bs, bilinear
+    lp2hp_zpk
+    scipy.signal.lp2hp
+
+    Notes
+    -----
+    This is derived from the s-plane substitution
+
+    .. math:: s \rightarrow \frac{\omega_0}{s}
+
+    This maintains symmetry of the lowpass and highpass responses on a
+    logarithmic scale.
+    """
+    a, b = map(cupy.atleast_1d, (a, b))
+    try:
+        wo = float(wo)
+    except TypeError:
+        wo = float(wo[0])
+    d = len(a)
+    n = len(b)
+    if wo != 1:
+        pwo = wo ** cupy.arange(max(d, n))
+    else:
+        pwo = cupy.ones(max(d, n), b.dtype)
+    if d >= n:
+        outa = a[::-1] * pwo
+        outb = cupy.resize(b, (d,))
+        outb[n:] = 0.0
+        outb[:n] = b[::-1] * pwo[:n]
+    else:
+        outb = b[::-1] * pwo
+        outa = cupy.resize(a, (n,))
+        outa[d:] = 0.0
+        outa[:d] = a[::-1] * pwo[:d]
+
+    return normalize(outb, outa)
+
+
+def lp2bp(b, a, wo=1.0, bw=1.0):
+    r"""
+    Transform a lowpass filter prototype to a bandpass filter.
+
+    Return an analog band-pass filter with center frequency `wo` and
+    bandwidth `bw` from an analog low-pass filter prototype with unity
+    cutoff frequency, in transfer function ('ba') representation.
+
+    Parameters
+    ----------
+    b : array_like
+        Numerator polynomial coefficients.
+    a : array_like
+        Denominator polynomial coefficients.
+    wo : float
+        Desired passband center, as angular frequency (e.g., rad/s).
+        Defaults to no change.
+    bw : float
+        Desired passband width, as angular frequency (e.g., rad/s).
+        Defaults to 1.
+
+    Returns
+    -------
+    b : array_like
+        Numerator polynomial coefficients of the transformed band-pass filter.
+    a : array_like
+        Denominator polynomial coefficients of the transformed band-pass
+        filter.
+
+    See Also
+    --------
+    lp2lp, lp2hp, lp2bs, bilinear
+    lp2bp_zpk
+    scipy.signal.lp2bp
+
+    Notes
+    -----
+    This is derived from the s-plane substitution
+
+    .. math:: s \rightarrow \frac{s^2 + {\omega_0}^2}{s \cdot \mathrm{BW}}
+
+    This is the "wideband" transformation, producing a passband with
+    geometric (log frequency) symmetry about `wo`.
+
+    """
+    a, b = map(cupy.atleast_1d, (a, b))
+    D = len(a) - 1
+    N = len(b) - 1
+    artype = cupy.mintypecode((a.dtype, b.dtype))
+    ma = max(N, D)
+    Np = N + ma
+    Dp = D + ma
+    bprime = cupy.empty(Np + 1, artype)
+    aprime = cupy.empty(Dp + 1, artype)
+    wosq = wo * wo
+    for j in range(Np + 1):
+        val = 0.0
+        for i in range(0, N + 1):
+            for k in range(0, i + 1):
+                if ma - i + 2 * k == j:
+                    val += comb(i, k) * b[N - i] * (wosq) ** (i - k) / bw ** i
+        bprime[Np - j] = val
+
+    for j in range(Dp + 1):
+        val = 0.0
+        for i in range(0, D + 1):
+            for k in range(0, i + 1):
+                if ma - i + 2 * k == j:
+                    val += comb(i, k) * a[D - i] * (wosq) ** (i - k) / bw ** i
+        aprime[Dp - j] = val
+
+    return normalize(bprime, aprime)
+
+
+def lp2bs(b, a, wo=1.0, bw=1.0):
+    r"""
+    Transform a lowpass filter prototype to a bandstop filter.
+
+    Return an analog band-stop filter with center frequency `wo` and
+    bandwidth `bw` from an analog low-pass filter prototype with unity
+    cutoff frequency, in transfer function ('ba') representation.
+
+    Parameters
+    ----------
+    b : array_like
+        Numerator polynomial coefficients.
+    a : array_like
+        Denominator polynomial coefficients.
+    wo : float
+        Desired stopband center, as angular frequency (e.g., rad/s).
+        Defaults to no change.
+    bw : float
+        Desired stopband width, as angular frequency (e.g., rad/s).
+        Defaults to 1.
+
+    Returns
+    -------
+    b : array_like
+        Numerator polynomial coefficients of the transformed band-stop filter.
+    a : array_like
+        Denominator polynomial coefficients of the transformed band-stop
+        filter.
+
+    See Also
+    --------
+    lp2lp, lp2hp, lp2bp, bilinear
+    lp2bs_zpk
+    scipy.signal.lp2bs
+
+    Notes
+    -----
+    This is derived from the s-plane substitution
+
+    .. math:: s \rightarrow \frac{s \cdot \mathrm{BW}}{s^2 + {\omega_0}^2}
+
+    This is the "wideband" transformation, producing a stopband with
+    geometric (log frequency) symmetry about `wo`.
+    """
+    a, b = map(cupy.atleast_1d, (a, b))
+    D = len(a) - 1
+    N = len(b) - 1
+    artype = cupy.mintypecode((a.dtype, b.dtype))
+    M = max(N, D)
+    Np = M + M
+    Dp = M + M
+    bprime = cupy.empty(Np + 1, artype)
+    aprime = cupy.empty(Dp + 1, artype)
+    wosq = wo * wo
+    for j in range(Np + 1):
+        val = 0.0
+        for i in range(0, N + 1):
+            for k in range(0, M - i + 1):
+                if i + 2 * k == j:
+                    val += (comb(M - i, k) * b[N - i] *
+                            (wosq) ** (M - i - k) * bw ** i)
+        bprime[Np - j] = val
+
+    for j in range(Dp + 1):
+        val = 0.0
+        for i in range(0, D + 1):
+            for k in range(0, M - i + 1):
+                if i + 2 * k == j:
+                    val += (comb(M - i, k) * a[D - i] *
+                            (wosq) ** (M - i - k) * bw ** i)
+        aprime[Dp - j] = val
+
+    return normalize(bprime, aprime)
+
+
+# ### LTI conversions ###
+
+def zpk2tf(z, p, k):
+    """
+    Return polynomial transfer function representation from zeros and poles
+
+    Parameters
+    ----------
+    z : array_like
+        Zeros of the transfer function.
+    p : array_like
+        Poles of the transfer function.
+    k : float
+        System gain.
+
+    Returns
+    -------
+    b : ndarray
+        Numerator polynomial coefficients.
+    a : ndarray
+        Denominator polynomial coefficients.
+
+    See Also
+    --------
+    scipy.signal.zpk2tf
+    """
+    if z.ndim > 1:
+        raise NotImplementedError(f"zpk2tf: z.ndim = {z.ndim}.")
+    b = _polycoeffs_from_zeros(z) * k
+    a = _polycoeffs_from_zeros(p)
+    return b, a
+
+
+def tf2zpk(b, a):
+    r"""Return zero, pole, gain (z, p, k) representation from a numerator,
+    denominator representation of a linear filter.
+
+    Parameters
+    ----------
+    b : array_like
+        Numerator polynomial coefficients.
+    a : array_like
+        Denominator polynomial coefficients.
+
+    Returns
+    -------
+    z : ndarray
+        Zeros of the transfer function.
+    p : ndarray
+        Poles of the transfer function.
+    k : float
+        System gain.
+
+    Warning
+    -------
+    This function may synchronize the device.
+
+    See Also
+    --------
+    scipy.signal.tf2zpk
+
+    Notes
+    -----
+    If some values of `b` are too close to 0, they are removed. In that case,
+    a BadCoefficients warning is emitted.
+
+    The `b` and `a` arrays are interpreted as coefficients for positive,
+    descending powers of the transfer function variable. So the inputs
+    :math:`b = [b_0, b_1, ..., b_M]` and :math:`a =[a_0, a_1, ..., a_N]`
+    can represent an analog filter of the form:
+
+    .. math::
+
+        H(s) = \frac
+        {b_0 s^M + b_1 s^{(M-1)} + \cdots + b_M}
+        {a_0 s^N + a_1 s^{(N-1)} + \cdots + a_N}
+
+    or a discrete-time filter of the form:
+
+    .. math::
+
+        H(z) = \frac
+        {b_0 z^M + b_1 z^{(M-1)} + \cdots + b_M}
+        {a_0 z^N + a_1 z^{(N-1)} + \cdots + a_N}
+
+    This "positive powers" form is found more commonly in controls
+    engineering. If `M` and `N` are equal (which is true for all filters
+    generated by the bilinear transform), then this happens to be equivalent
+    to the "negative powers" discrete-time form preferred in DSP:
+
+    .. math::
+
+        H(z) = \frac
+        {b_0 + b_1 z^{-1} + \cdots + b_M z^{-M}}
+        {a_0 + a_1 z^{-1} + \cdots + a_N z^{-N}}
+
+    Although this is true for common filters, remember that this is not true
+    in the general case. If `M` and `N` are not equal, the discrete-time
+    transfer function coefficients must first be converted to the "positive
+    powers" form before finding the poles and zeros.
+
+    """
+    b, a = normalize(b, a)
+    b = (b + 0.0) / a[0]
+    a = (a + 0.0) / a[0]
+    k = b[0].copy()
+    b /= b[0]
+    z = roots(b)
+    p = roots(a)
+    return z, p, k
+
+
+def tf2sos(b, a, pairing=None, *, analog=False):
+    """
+    Return second-order sections from transfer function representation
+
+    Parameters
+    ----------
+    b : array_like
+        Numerator polynomial coefficients.
+    a : array_like
+        Denominator polynomial coefficients.
+    pairing : {None, 'nearest', 'keep_odd', 'minimal'}, optional
+        The method to use to combine pairs of poles and zeros into sections.
+        See `zpk2sos` for information and restrictions on `pairing` and
+        `analog` arguments.
+    analog : bool, optional
+        If True, system is analog, otherwise discrete.
+
+    Returns
+    -------
+    sos : ndarray
+        Array of second-order filter coefficients, with shape
+        ``(n_sections, 6)``. See `sosfilt` for the SOS filter format
+        specification.
+
+    See Also
+    --------
+    scipy.signal.tf2sos
+
+    Notes
+    -----
+    It is generally discouraged to convert from TF to SOS format, since doing
+    so usually will not improve numerical precision errors. Instead, consider
+    designing filters in ZPK format and converting directly to SOS. TF is
+    converted to SOS by first converting to ZPK format, then converting
+    ZPK to SOS.
+
+    """
+    return zpk2sos(*tf2zpk(b, a), pairing=pairing, analog=analog)
+
+
+def sos2tf(sos):
+    """
+    Return a single transfer function from a series of second-order sections
+
+    Parameters
+    ----------
+    sos : array_like
+        Array of second-order filter coefficients, must have shape
+        ``(n_sections, 6)``. See `sosfilt` for the SOS filter format
+        specification.
+
+    Returns
+    -------
+    b : ndarray
+        Numerator polynomial coefficients.
+    a : ndarray
+        Denominator polynomial coefficients.
+
+    See Also
+    --------
+    scipy.signal.sos2tf
+
+    """
+    sos = cupy.asarray(sos)
+    result_type = sos.dtype
+    if result_type.kind in 'bui':
+        result_type = cupy.float64
+
+    b = cupy.array([1], dtype=result_type)
+    a = cupy.array([1], dtype=result_type)
+    n_sections = sos.shape[0]
+    for section in range(n_sections):
+        b = cupy.polymul(b, sos[section, :3])
+        a = cupy.polymul(a, sos[section, 3:])
+    return b, a
+
+
+def sos2zpk(sos):
+    """
+    Return zeros, poles, and gain of a series of second-order sections
+
+    Parameters
+    ----------
+    sos : array_like
+        Array of second-order filter coefficients, must have shape
+        ``(n_sections, 6)``. See `sosfilt` for the SOS filter format
+        specification.
+
+    Returns
+    -------
+    z : ndarray
+        Zeros of the transfer function.
+    p : ndarray
+        Poles of the transfer function.
+    k : float
+        System gain.
+
+    Notes
+    -----
+    The number of zeros and poles returned will be ``n_sections * 2``
+    even if some of these are (effectively) zero.
+
+    See Also
+    --------
+    scipy.signal.sos2zpk
+
+    """
+    n_sections = sos.shape[0]
+    z = cupy.zeros(n_sections*2, cupy.complex128)
+    p = cupy.zeros(n_sections*2, cupy.complex128)
+    k = 1.
+    for section in range(n_sections):
+        # XXX: may just solve a quadratic equation instead of tf2zpk
+        zpk = tf2zpk(sos[section, :3], sos[section, 3:])
+        z[2*section:2*section + len(zpk[0])] = zpk[0]
+        p[2*section:2*section + len(zpk[1])] = zpk[1]
+        k *= zpk[2]
+    return z, p, k
+
+
+def tf2ss(num, den):
+    r"""Transfer function to state-space representation.
+
+    Parameters
+    ----------
+    num, den : array_like
+        Sequences representing the coefficients of the numerator and
+        denominator polynomials, in order of descending degree. The
+        denominator needs to be at least as long as the numerator.
+
+    Returns
+    -------
+    A, B, C, D : ndarray
+        State space representation of the system, in controller canonical
+        form.
+
+    See Also
+    --------
+    scipy.signal.tf2ss
+    """
+    # Controller canonical state-space representation.
+    #  if M+1 = len(num) and K+1 = len(den) then we must have M <= K
+    #  states are found by asserting that X(s) = U(s) / D(s)
+    #  then Y(s) = N(s) * X(s)
+    #
+    #   A, B, C, and D follow quite naturally.
+    #
+    num, den = normalize(num, den)   # Strips zeros, checks arrays
+    nn = len(num.shape)
+    if nn == 1:
+        num = cupy.asarray([num], num.dtype)
+    M = num.shape[1]
+    K = len(den)
+    if M > K:
+        msg = "Improper transfer function. `num` is longer than `den`."
+        raise ValueError(msg)
+    if M == 0 or K == 0:  # Null system
+        return (cupy.array([], float),
+                cupy.array([], float),
+                cupy.array([], float),
+                cupy.array([], float))
+
+    # pad numerator to have same number of columns has denominator
+    num = cupy.hstack((cupy.zeros((num.shape[0], K - M), num.dtype), num))
+
+    if num.shape[-1] > 0:
+        D = cupy.atleast_2d(num[:, 0])
+
+    else:
+        # We don't assign it an empty array because this system
+        # is not 'null'. It just doesn't have a non-zero D
+        # matrix. Thus, it should have a non-zero shape so that
+        # it can be operated on by functions like 'ss2tf'
+        D = cupy.array([[0]], float)
+
+    if K == 1:
+        D = D.reshape(num.shape)
+
+        return (cupy.zeros((1, 1)), cupy.zeros((1, D.shape[1])),
+                cupy.zeros((D.shape[0], 1)), D)
+
+    frow = -cupy.array([den[1:]])
+    A = cupy.r_[frow, cupy.eye(K - 2, K - 1)]
+    B = cupy.eye(K - 1, 1)
+    C = num[:, 1:] - cupy.outer(num[:, 0], den[1:])
+    D = D.reshape((C.shape[0], B.shape[1]))
+
+    return A, B, C, D
+
+
+def ss2tf(A, B, C, D, input=0):
+    r"""State-space to transfer function.
+
+    A, B, C, D defines a linear state-space system with `p` inputs,
+    `q` outputs, and `n` state variables.
+
+    Parameters
+    ----------
+    A : array_like
+        State (or system) matrix of shape ``(n, n)``
+    B : array_like
+        Input matrix of shape ``(n, p)``
+    C : array_like
+        Output matrix of shape ``(q, n)``
+    D : array_like
+        Feedthrough (or feedforward) matrix of shape ``(q, p)``
+    input : int, optional
+        For multiple-input systems, the index of the input to use.
+
+    Returns
+    -------
+    num : 2-D ndarray
+        Numerator(s) of the resulting transfer function(s). `num` has one row
+        for each of the system's outputs. Each row is a sequence representation
+        of the numerator polynomial.
+    den : 1-D ndarray
+        Denominator of the resulting transfer function(s). `den` is a sequence
+        representation of the denominator polynomial.
+
+    Warning
+    -------
+    This function may synchronize the device.
+
+    See Also
+    --------
+    scipy.signal.ss2tf
+
+    """
+    # transfer function is C (sI - A)**(-1) B + D
+
+    # Check consistency and make them all rank-2 arrays
+    A, B, C, D = abcd_normalize(A, B, C, D)
+
+    nout, nin = D.shape
+    if input >= nin:
+        raise ValueError("System does not have the input specified.")
+
+    # make SIMO from possibly MIMO system.
+    B = B[:, input:input + 1]
+    D = D[:, input:input + 1]
+
+    try:
+        den = poly(A)
+    except ValueError:
+        den = 1
+
+    if (prod(B.shape) == 0) and (prod(C.shape) == 0):
+        num = cupy.ravel(D)
+        if (prod(D.shape) == 0) and (prod(A.shape) == 0):
+            den = []
+        return num, den
+
+    num_states = A.shape[0]
+    type_test = A[:, 0] + B[:, 0] + C[0, :] + D + 0.0
+    num = cupy.empty((nout, num_states + 1), type_test.dtype)
+    for k in range(nout):
+        Ck = cupy.atleast_2d(C[k, :])
+        num[k] = poly(A - B @ Ck) + (D[k] - 1) * den
+
+    return num, den
+
+
+def zpk2ss(z, p, k):
+    """Zero-pole-gain representation to state-space representation
+
+    Parameters
+    ----------
+    z, p : sequence
+        Zeros and poles.
+    k : float
+        System gain.
+
+    Returns
+    -------
+    A, B, C, D : ndarray
+        State space representation of the system, in controller canonical
+        form.
+
+    See Also
+    --------
+    scipy.signal.zpk2ss
+
+    """
+    return tf2ss(*zpk2tf(z, p, k))
+
+
+def ss2zpk(A, B, C, D, input=0):
+    """State-space representation to zero-pole-gain representation.
+
+    A, B, C, D defines a linear state-space system with `p` inputs,
+    `q` outputs, and `n` state variables.
+
+    Parameters
+    ----------
+    A : array_like
+        State (or system) matrix of shape ``(n, n)``
+    B : array_like
+        Input matrix of shape ``(n, p)``
+    C : array_like
+        Output matrix of shape ``(q, n)``
+    D : array_like
+        Feedthrough (or feedforward) matrix of shape ``(q, p)``
+    input : int, optional
+        For multiple-input systems, the index of the input to use.
+
+    Returns
+    -------
+    z, p : sequence
+        Zeros and poles.
+    k : float
+        System gain.
+
+    See Also
+    --------
+    scipy.signal.ss2zpk
+
+    """
+    return tf2zpk(*ss2tf(A, B, C, D, input=input))
+
+
+# ### Low-level analog filter prototypes ###
+
+# TODO (ev-br): move to a better place (_filter_design.py (?))
+
+def buttap(N):
+    """Return (z,p,k) for analog prototype of Nth-order Butterworth filter.
+
+    The filter will have an angular (e.g., rad/s) cutoff frequency of 1.
+
+    See Also
+    --------
+    butter : Filter design function using this prototype
+    scipy.signal.buttap
+
+    """
+    if abs(int(N)) != N:
+        raise ValueError("Filter order must be a nonnegative integer")
+    z = cupy.array([])
+    m = cupy.arange(-N+1, N, 2)
+    # Middle value is 0 to ensure an exactly real pole
+    p = -cupy.exp(1j * pi * m / (2 * N))
+    k = 1
+    return z, p, k
+
+
+def cheb1ap(N, rp):
+    """
+    Return (z,p,k) for Nth-order Chebyshev type I analog lowpass filter.
+
+    The returned filter prototype has `rp` decibels of ripple in the passband.
+
+    The filter's angular (e.g. rad/s) cutoff frequency is normalized to 1,
+    defined as the point at which the gain first drops below ``-rp``.
+
+    See Also
+    --------
+    cheby1 : Filter design function using this prototype
+
+    """
+    if abs(int(N)) != N:
+        raise ValueError("Filter order must be a nonnegative integer")
+    elif N == 0:
+        # Avoid divide-by-zero error
+        # Even order filters have DC gain of -rp dB
+        return cupy.array([]), cupy.array([]), 10**(-rp/20)
+    z = cupy.array([])
+
+    # Ripple factor (epsilon)
+    eps = cupy.sqrt(10 ** (0.1 * rp) - 1.0)
+    mu = 1.0 / N * cupy.arcsinh(1 / eps)
+
+    # Arrange poles in an ellipse on the left half of the S-plane
+    m = cupy.arange(-N+1, N, 2)
+    theta = pi * m / (2*N)
+    p = -cupy.sinh(mu + 1j*theta)
+
+    k = cupy.prod(-p, axis=0).real
+    if N % 2 == 0:
+        k = k / cupy.sqrt(1 + eps * eps)
+
+    return z, p, k
+
+
+def cheb2ap(N, rs):
+    """
+    Return (z,p,k) for Nth-order Chebyshev type I analog lowpass filter.
+
+    The returned filter prototype has `rs` decibels of ripple in the stopband.
+
+    The filter's angular (e.g. rad/s) cutoff frequency is normalized to 1,
+    defined as the point at which the gain first reaches ``-rs``.
+
+    See Also
+    --------
+    cheby2 : Filter design function using this prototype
+
+    """
+    if abs(int(N)) != N:
+        raise ValueError("Filter order must be a nonnegative integer")
+    elif N == 0:
+        # Avoid divide-by-zero warning
+        return cupy.array([]), cupy.array([]), 1
+
+    # Ripple factor (epsilon)
+    de = 1.0 / cupy.sqrt(10 ** (0.1 * rs) - 1)
+    mu = cupy.arcsinh(1.0 / de) / N
+
+    if N % 2:
+        m = cupy.concatenate((cupy.arange(-N+1, 0, 2),
+                              cupy.arange(2, N, 2)))
+    else:
+        m = cupy.arange(-N+1, N, 2)
+
+    z = -cupy.conjugate(1j / cupy.sin(m * pi / (2.0 * N)))
+
+    # Poles around the unit circle like Butterworth
+    p = -cupy.exp(1j * pi * cupy.arange(-N+1, N, 2) / (2 * N))
+    # Warp into Chebyshev II
+    p = cupy.sinh(mu) * p.real + 1j * cupy.cosh(mu) * p.imag
+    p = 1.0 / p
+
+    k = (cupy.prod(-p, axis=0) / cupy.prod(-z, axis=0)).real
+    return z, p, k
+
+
+# ### Elliptic filter prototype ###
+
+_POW10_LOG10 = math.log(10)
+
+
+def _pow10m1(x):
+    """10 ** x - 1 for x near 0"""
+    return cupy.expm1(_POW10_LOG10 * x)
+
+
+def _ellipdeg(n, m1):
+    """Solve degree equation using nomes
+
+    Given n, m1, solve
+       n * K(m) / K'(m) = K1(m1) / K1'(m1)
+    for m
+
+    See [1], Eq. (49)
+
+    References
+    ----------
+    .. [1] Orfanidis, "Lecture Notes on Elliptic Filter Design",
+           https://www.ece.rutgers.edu/~orfanidi/ece521/notes.pdf
+    """
+    # number of terms in solving degree equation
+    _ELLIPDEG_MMAX = 7
+
+    K1 = special.ellipk(m1)
+    K1p = special.ellipkm1(m1)
+
+    q1 = cupy.exp(-pi * K1p / K1)
+    q = q1 ** (1/n)
+
+    mnum = cupy.arange(_ELLIPDEG_MMAX + 1)
+    mden = cupy.arange(1, _ELLIPDEG_MMAX + 2)
+
+    num = (q ** (mnum * (mnum+1))).sum()
+    den = 1 + 2 * (q ** (mden**2)).sum()
+
+    return 16 * q * (num / den) ** 4
+
+
+def _arc_jac_sn(w, m):
+    """Inverse Jacobian elliptic sn
+
+    Solve for z in w = sn(z, m)
+
+    Parameters
+    ----------
+    w : complex scalar
+        argument
+
+    m : scalar
+        modulus; in interval [0, 1]
+
+
+    See [1], Eq. (56)
+
+    References
+    ----------
+    .. [1] Orfanidis, "Lecture Notes on Elliptic Filter Design",
+           https://www.ece.rutgers.edu/~orfanidi/ece521/notes.pdf
+
+    """
+    # Maximum number of iterations in Landen transformation recursion
+    # sequence.  10 is conservative; unit tests pass with 4, Orfanidis
+    # (see _arc_jac_cn [1]) suggests 5.
+    _ARC_JAC_SN_MAXITER = 10
+
+    def _complement(kx):
+        # (1-k**2) ** 0.5; the expression below
+        # works for small kx
+        return ((1 - kx) * (1 + kx)) ** 0.5
+
+    k = m ** 0.5
+
+    if k > 1:
+        return cupy.nan
+    elif k == 1:
+        return cupy.arctanh(w)
+
+    ks = [k]
+    niter = 0
+    while ks[-1] != 0:
+        k_ = ks[-1]
+        k_p = _complement(k_)
+        ks.append((1 - k_p) / (1 + k_p))
+        niter += 1
+        if niter > _ARC_JAC_SN_MAXITER:
+            raise ValueError('Landen transformation not converging')
+
+    K = cupy.prod(1 + cupy.array(ks[1:])) * pi/2
+
+    wns = [w]
+
+    for kn, knext in zip(ks[:-1], ks[1:]):
+        wn = wns[-1]
+        wnext = (2 * wn /
+                 ((1 + knext) * (1 + _complement(kn * wn))))
+        wns.append(wnext)
+
+    u = 2 / pi * cupy.arcsin(wns[-1])
+
+    z = K * u
+    return z
+
+
+def _arc_jac_sc1(w, m):
+    """Real inverse Jacobian sc, with complementary modulus
+
+    Solve for z in w = sc(z, 1-m)
+
+    w - real scalar
+
+    m - modulus
+
+    Using that sc(z, m) = -i * sn(i * z, 1 - m)
+    cf scipy/signal/_filter_design.py analog for an explanation
+    and a reference.
+
+    """
+
+    zcomplex = _arc_jac_sn(1j * w, m)
+    if abs(zcomplex.real) > 1e-14:
+        raise ValueError
+
+    return zcomplex.imag
+
+
+def ellipap(N, rp, rs):
+    """Return (z,p,k) of Nth-order elliptic analog lowpass filter.
+
+    The filter is a normalized prototype that has `rp` decibels of ripple
+    in the passband and a stopband `rs` decibels down.
+
+    The filter's angular (e.g., rad/s) cutoff frequency is normalized to 1,
+    defined as the point at which the gain first drops below ``-rp``.
+
+    See Also
+    --------
+    ellip : Filter design function using this prototype
+    scipy.signal.elliap
+
+    """
+    if abs(int(N)) != N:
+        raise ValueError("Filter order must be a nonnegative integer")
+    elif N == 0:
+        # Avoid divide-by-zero warning
+        # Even order filters have DC gain of -rp dB
+        return cupy.array([]), cupy.array([]), 10**(-rp/20)
+    elif N == 1:
+        p = -cupy.sqrt(1.0 / _pow10m1(0.1 * rp))
+        k = -p
+        z = []
+        return cupy.asarray(z), cupy.asarray(p), k
+
+    eps_sq = _pow10m1(0.1 * rp)
+
+    eps = cupy.sqrt(eps_sq)
+    ck1_sq = eps_sq / _pow10m1(0.1 * rs)
+    if ck1_sq == 0:
+        raise ValueError("Cannot design a filter with given rp and rs"
+                         " specifications.")
+
+    m = _ellipdeg(N, ck1_sq)
+    capk = special.ellipk(m)
+    j = cupy.arange(1 - N % 2, N, 2)
+    EPSILON = 2e-16
+
+    s, c, d, phi = special.ellipj(j * capk / N, m * cupy.ones_like(j))
+    snew = cupy.compress(cupy.abs(s) > EPSILON, s, axis=-1)
+    z = 1.j / (cupy.sqrt(m) * snew)
+    z = cupy.concatenate((z, z.conj()))
+
+    r = _arc_jac_sc1(1. / eps, ck1_sq)
+    v0 = capk * r / (N * special.ellipk(ck1_sq))
+
+    sv, cv, dv, phi = special.ellipj(v0, 1 - m)
+    p = -(c * d * sv * cv + 1j * s * dv) / (1 - (d * sv) ** 2.0)
+
+    if N % 2:
+        mask = cupy.abs(p.imag) > EPSILON * \
+            cupy.sqrt((p * p.conj()).sum(axis=0).real)
+        newp = cupy.compress(mask, p, axis=-1)
+        p = cupy.concatenate((p, newp.conj()))
+    else:
+        p = cupy.concatenate((p, p.conj()))
+
+    k = (cupy.prod(-p, axis=0) / cupy.prod(-z, axis=0)).real
+    if N % 2 == 0:
+        k = k / cupy.sqrt(1 + eps_sq)
+
+    return z, p, k
+
+
+# ### *ord functions to accopany *ap functions
+
+def _validate_gpass_gstop(gpass, gstop):
+
+    if gpass <= 0.0:
+        raise ValueError("gpass should be larger than 0.0")
+    elif gstop <= 0.0:
+        raise ValueError("gstop should be larger than 0.0")
+    elif gpass > gstop:
+        raise ValueError("gpass should be smaller than gstop")
+
+
+def _pre_warp(wp, ws, analog):
+    # Pre-warp frequencies for digital filter design
+    if not analog:
+        passb = cupy.tan(pi * wp / 2.0)
+        stopb = cupy.tan(pi * ws / 2.0)
+    else:
+        passb = wp * 1.0
+        stopb = ws * 1.0
+    return passb, stopb
+
+
+def _validate_wp_ws(wp, ws, fs, analog):
+    wp = cupy.atleast_1d(wp)
+    ws = cupy.atleast_1d(ws)
+    if fs is not None:
+        if analog:
+            raise ValueError("fs cannot be specified for an analog filter")
+        wp = 2 * wp / fs
+        ws = 2 * ws / fs
+
+    filter_type = 2 * (len(wp) - 1) + 1
+    if wp[0] >= ws[0]:
+        filter_type += 1
+
+    return wp, ws, filter_type
+
+
+def _find_nat_freq(stopb, passb, gpass, gstop, filter_type, filter_kind):
+    if filter_type == 1:            # low
+        nat = stopb / passb
+    elif filter_type == 2:          # high
+        nat = passb / stopb
+    elif filter_type == 3:          # stop
+        wp0 = _optimize.fminbound(band_stop_obj, passb[0], stopb[0] - 1e-12,
+                                  args=(0, passb, stopb, gpass, gstop,
+                                        filter_kind),
+                                  disp=0)
+        passb[0] = wp0
+        wp1 = _optimize.fminbound(band_stop_obj, stopb[1] + 1e-12, passb[1],
+                                  args=(1, passb, stopb, gpass, gstop,
+                                        filter_kind),
+                                  disp=0)
+        passb[1] = wp1
+        nat = ((stopb * (passb[0] - passb[1])) /
+               (stopb ** 2 - passb[0] * passb[1]))
+    elif filter_type == 4:          # pass
+        nat = ((stopb ** 2 - passb[0] * passb[1]) /
+               (stopb * (passb[0] - passb[1])))
+    else:
+        raise ValueError(f"should not happen: {filter_type=}.")
+
+    nat = min(cupy.abs(nat))
+    return nat, passb
+
+
+def _postprocess_wn(WN, analog, fs):
+    wn = WN if analog else cupy.arctan(WN) * 2.0 / pi
+    if len(wn) == 1:
+        wn = wn[0]
+    if fs is not None:
+        wn = wn * fs / 2
+    return wn
+
+
+def band_stop_obj(wp, ind, passb, stopb, gpass, gstop, type):
+    """
+    Band Stop Objective Function for order minimization.
+
+    Returns the non-integer order for an analog band stop filter.
+
+    Parameters
+    ----------
+    wp : scalar
+        Edge of passband `passb`.
+    ind : int, {0, 1}
+        Index specifying which `passb` edge to vary (0 or 1).
+    passb : ndarray
+        Two element sequence of fixed passband edges.
+    stopb : ndarray
+        Two element sequence of fixed stopband edges.
+    gstop : float
+        Amount of attenuation in stopband in dB.
+    gpass : float
+        Amount of ripple in the passband in dB.
+    type : {'butter', 'cheby', 'ellip'}
+        Type of filter.
+
+    Returns
+    -------
+    n : scalar
+        Filter order (possibly non-integer).
+
+    See Also
+    --------
+    scipy.signal.band_stop_obj
+
+    """
+
+    _validate_gpass_gstop(gpass, gstop)
+
+    passbC = passb.copy()
+    passbC[ind] = wp
+    nat = (stopb * (passbC[0] - passbC[1]) /
+           (stopb ** 2 - passbC[0] * passbC[1]))
+    nat = min(cupy.abs(nat))
+
+    if type == 'butter':
+        GSTOP = 10 ** (0.1 * cupy.abs(gstop))
+        GPASS = 10 ** (0.1 * cupy.abs(gpass))
+        n = (cupy.log10((GSTOP - 1.0) / (GPASS - 1.0)) / (2 * cupy.log10(nat)))
+    elif type == 'cheby':
+        GSTOP = 10 ** (0.1 * cupy.abs(gstop))
+        GPASS = 10 ** (0.1 * cupy.abs(gpass))
+        n = cupy.arccosh(
+            cupy.sqrt((GSTOP - 1.0) / (GPASS - 1.0))) / cupy.arccosh(nat)
+    elif type == 'ellip':
+        GSTOP = 10 ** (0.1 * gstop)
+        GPASS = 10 ** (0.1 * gpass)
+        arg1 = cupy.sqrt((GPASS - 1.0) / (GSTOP - 1.0))
+        arg0 = 1.0 / nat
+        d0 = special.ellipk(cupy.array([arg0 ** 2, 1 - arg0 ** 2]))
+        d1 = special.ellipk(cupy.array([arg1 ** 2, 1 - arg1 ** 2]))
+        n = (d0[0] * d1[1] / (d0[1] * d1[0]))
+    else:
+        raise ValueError("Incorrect type: %s" % type)
+    return n
+
+
+def buttord(wp, ws, gpass, gstop, analog=False, fs=None):
+    """Butterworth filter order selection.
+
+    Return the order of the lowest order digital or analog Butterworth filter
+    that loses no more than `gpass` dB in the passband and has at least
+    `gstop` dB attenuation in the stopband.
+
+    Parameters
+    ----------
+    wp, ws : float
+        Passband and stopband edge frequencies.
+
+        For digital filters, these are in the same units as `fs`. By default,
+        `fs` is 2 half-cycles/sample, so these are normalized from 0 to 1,
+        where 1 is the Nyquist frequency. (`wp` and `ws` are thus in
+        half-cycles / sample.) For example:
+
+            - Lowpass:   wp = 0.2,          ws = 0.3
+            - Highpass:  wp = 0.3,          ws = 0.2
+            - Bandpass:  wp = [0.2, 0.5],   ws = [0.1, 0.6]
+            - Bandstop:  wp = [0.1, 0.6],   ws = [0.2, 0.5]
+
+        For analog filters, `wp` and `ws` are angular frequencies
+        (e.g., rad/s).
+    gpass : float
+        The maximum loss in the passband (dB).
+    gstop : float
+        The minimum attenuation in the stopband (dB).
+    analog : bool, optional
+        When True, return an analog filter, otherwise a digital filter is
+        returned.
+    fs : float, optional
+        The sampling frequency of the digital system.
+
+        .. versionadded:: 1.2.0
+
+    Returns
+    -------
+    ord : int
+        The lowest order for a Butterworth filter which meets specs.
+    wn : ndarray or float
+        The Butterworth natural frequency (i.e. the "3dB frequency"). Should
+        be used with `butter` to give filter results. If `fs` is specified,
+        this is in the same units, and `fs` must also be passed to `butter`.
+
+    See Also
+    --------
+    scipy.signal.buttord
+    butter : Filter design using order and critical points
+    cheb1ord : Find order and critical points from passband and stopband spec
+    cheb2ord, ellipord
+    iirfilter : General filter design using order and critical frequencies
+    iirdesign : General filter design using passband and stopband spec
+
+    """
+    _validate_gpass_gstop(gpass, gstop)
+    wp, ws, filter_type = _validate_wp_ws(wp, ws, fs, analog)
+    passb, stopb = _pre_warp(wp, ws, analog)
+    nat, passb = _find_nat_freq(
+        stopb, passb, gpass, gstop, filter_type, 'butter')
+
+    GSTOP = 10 ** (0.1 * cupy.abs(gstop))
+    GPASS = 10 ** (0.1 * cupy.abs(gpass))
+    ord = int(cupy.ceil(cupy.log10((GSTOP - 1.0) /
+              (GPASS - 1.0)) / (2 * cupy.log10(nat))))
+
+    # Find the Butterworth natural frequency WN (or the "3dB" frequency")
+    # to give exactly gpass at passb.
+    try:
+        W0 = (GPASS - 1.0) ** (-1.0 / (2.0 * ord))
+    except ZeroDivisionError:
+        W0 = 1.0
+        warnings.warn("Order is zero...check input parameters.",
+                      RuntimeWarning, 2)
+
+    # now convert this frequency back from lowpass prototype
+    # to the original analog filter
+
+    if filter_type == 1:  # low
+        WN = W0 * passb
+    elif filter_type == 2:  # high
+        WN = passb / W0
+    elif filter_type == 3:  # stop
+        WN = cupy.empty(2, float)
+        discr = cupy.sqrt((passb[1] - passb[0]) ** 2 +
+                          4 * W0 ** 2 * passb[0] * passb[1])
+        WN[0] = ((passb[1] - passb[0]) + discr) / (2 * W0)
+        WN[1] = ((passb[1] - passb[0]) - discr) / (2 * W0)
+        WN = cupy.sort(cupy.abs(WN))
+    elif filter_type == 4:  # pass
+        W0 = cupy.array([-W0, W0], dtype=float)
+        WN = (-W0 * (passb[1] - passb[0]) / 2.0 +
+              cupy.sqrt(W0 ** 2 / 4.0 * (passb[1] - passb[0]) ** 2 +
+                        passb[0] * passb[1]))
+        WN = cupy.sort(cupy.abs(WN))
+    else:
+        raise ValueError("Bad type: %s" % filter_type)
+
+    wn = _postprocess_wn(WN, analog, fs)
+
+    return ord, wn
+
+
+def cheb1ord(wp, ws, gpass, gstop, analog=False, fs=None):
+    """Chebyshev type I filter order selection.
+
+    Return the order of the lowest order digital or analog Chebyshev Type I
+    filter that loses no more than `gpass` dB in the passband and has at
+    least `gstop` dB attenuation in the stopband.
+
+    Parameters
+    ----------
+    wp, ws : float
+        Passband and stopband edge frequencies.
+
+        For digital filters, these are in the same units as `fs`. By default,
+        `fs` is 2 half-cycles/sample, so these are normalized from 0 to 1,
+        where 1 is the Nyquist frequency. (`wp` and `ws` are thus in
+        half-cycles / sample.)  For example:
+
+            - Lowpass:   wp = 0.2,          ws = 0.3
+            - Highpass:  wp = 0.3,          ws = 0.2
+            - Bandpass:  wp = [0.2, 0.5],   ws = [0.1, 0.6]
+            - Bandstop:  wp = [0.1, 0.6],   ws = [0.2, 0.5]
+
+        For analog filters, `wp` and `ws` are angular frequencies
+        (e.g., rad/s).
+    gpass : float
+        The maximum loss in the passband (dB).
+    gstop : float
+        The minimum attenuation in the stopband (dB).
+    analog : bool, optional
+        When True, return an analog filter, otherwise a digital filter is
+        returned.
+    fs : float, optional
+        The sampling frequency of the digital system.
+
+    Returns
+    -------
+    ord : int
+        The lowest order for a Chebyshev type I filter that meets specs.
+    wn : ndarray or float
+        The Chebyshev natural frequency (the "3dB frequency") for use with
+        `cheby1` to give filter results. If `fs` is specified,
+        this is in the same units, and `fs` must also be passed to `cheby1`.
+
+    See Also
+    --------
+    scipy.signal.cheb1ord
+    cheby1 : Filter design using order and critical points
+    buttord : Find order and critical points from passband and stopband spec
+    cheb2ord, ellipord
+    iirfilter : General filter design using order and critical frequencies
+    iirdesign : General filter design using passband and stopband spec
+
+    """
+    _validate_gpass_gstop(gpass, gstop)
+    wp, ws, filter_type = _validate_wp_ws(wp, ws, fs, analog)
+    passb, stopb = _pre_warp(wp, ws, analog)
+    nat, passb = _find_nat_freq(
+        stopb, passb, gpass, gstop, filter_type, 'cheby')
+
+    GSTOP = 10 ** (0.1 * cupy.abs(gstop))
+    GPASS = 10 ** (0.1 * cupy.abs(gpass))
+    v_pass_stop = cupy.arccosh(cupy.sqrt((GSTOP - 1.0) / (GPASS - 1.0)))
+    ord = int(cupy.ceil(v_pass_stop / cupy.arccosh(nat)))
+
+    # Natural frequencies are just the passband edges
+    wn = _postprocess_wn(passb, analog, fs)
+
+    return ord, wn
+
+
+def cheb2ord(wp, ws, gpass, gstop, analog=False, fs=None):
+    """Chebyshev type II filter order selection.
+
+    Return the order of the lowest order digital or analog Chebyshev Type II
+    filter that loses no more than `gpass` dB in the passband and has at least
+    `gstop` dB attenuation in the stopband.
+
+    Parameters
+    ----------
+    wp, ws : float
+        Passband and stopband edge frequencies.
+
+        For digital filters, these are in the same units as `fs`. By default,
+        `fs` is 2 half-cycles/sample, so these are normalized from 0 to 1,
+        where 1 is the Nyquist frequency. (`wp` and `ws` are thus in
+        half-cycles / sample.)  For example:
+
+            - Lowpass:   wp = 0.2,          ws = 0.3
+            - Highpass:  wp = 0.3,          ws = 0.2
+            - Bandpass:  wp = [0.2, 0.5],   ws = [0.1, 0.6]
+            - Bandstop:  wp = [0.1, 0.6],   ws = [0.2, 0.5]
+
+        For analog filters, `wp` and `ws` are angular frequencies
+        (e.g., rad/s).
+    gpass : float
+        The maximum loss in the passband (dB).
+    gstop : float
+        The minimum attenuation in the stopband (dB).
+    analog : bool, optional
+        When True, return an analog filter, otherwise a digital filter is
+        returned.
+    fs : float, optional
+        The sampling frequency of the digital system.
+
+    Returns
+    -------
+    ord : int
+        The lowest order for a Chebyshev type II filter that meets specs.
+    wn : ndarray or float
+        The Chebyshev natural frequency (the "3dB frequency") for use with
+        `cheby2` to give filter results. If `fs` is specified,
+        this is in the same units, and `fs` must also be passed to `cheby2`.
+
+    See Also
+    --------
+    scipy.signal.cheb2ord
+    cheby2 : Filter design using order and critical points
+    buttord : Find order and critical points from passband and stopband spec
+    cheb1ord, ellipord
+    iirfilter : General filter design using order and critical frequencies
+    iirdesign : General filter design using passband and stopband spec
+
+    """
+    _validate_gpass_gstop(gpass, gstop)
+    wp, ws, filter_type = _validate_wp_ws(wp, ws, fs, analog)
+    passb, stopb = _pre_warp(wp, ws, analog)
+    nat, passb = _find_nat_freq(
+        stopb, passb, gpass, gstop, filter_type, 'cheby')
+
+    GSTOP = 10 ** (0.1 * cupy.abs(gstop))
+    GPASS = 10 ** (0.1 * cupy.abs(gpass))
+    v_pass_stop = cupy.arccosh(cupy.sqrt((GSTOP - 1.0) / (GPASS - 1.0)))
+    ord = int(cupy.ceil(v_pass_stop / cupy.arccosh(nat)))
+
+    # Find frequency where analog response is -gpass dB.
+    # Then convert back from low-pass prototype to the original filter.
+
+    new_freq = cupy.cosh(1.0 / ord * v_pass_stop)
+    new_freq = 1.0 / new_freq
+
+    if filter_type == 1:
+        nat = passb / new_freq
+    elif filter_type == 2:
+        nat = passb * new_freq
+    elif filter_type == 3:
+        nat = cupy.empty(2, dtype=float)
+        nat[0] = (new_freq / 2.0 * (passb[0] - passb[1]) +
+                  cupy.sqrt(new_freq ** 2 * (passb[1] - passb[0]) ** 2 / 4.0 +
+                            passb[1] * passb[0]))
+        nat[1] = passb[1] * passb[0] / nat[0]
+    elif filter_type == 4:
+        nat = cupy.empty(2, dtype=float)
+        nat[0] = (1.0 / (2.0 * new_freq) * (passb[0] - passb[1]) +
+                  cupy.sqrt((passb[1] - passb[0]) ** 2 / (4.0 * new_freq ** 2)
+                            + passb[1] * passb[0]))
+        nat[1] = passb[0] * passb[1] / nat[0]
+
+    wn = _postprocess_wn(nat, analog, fs)
+
+    return ord, wn
+
+
+def ellipord(wp, ws, gpass, gstop, analog=False, fs=None):
+    """Elliptic (Cauer) filter order selection.
+
+    Return the order of the lowest order digital or analog elliptic filter
+    that loses no more than `gpass` dB in the passband and has at least
+    `gstop` dB attenuation in the stopband.
+
+    Parameters
+    ----------
+    wp, ws : float
+        Passband and stopband edge frequencies.
+
+        For digital filters, these are in the same units as `fs`. By default,
+        `fs` is 2 half-cycles/sample, so these are normalized from 0 to 1,
+        where 1 is the Nyquist frequency. (`wp` and `ws` are thus in
+        half-cycles / sample.) For example:
+
+            - Lowpass:   wp = 0.2,          ws = 0.3
+            - Highpass:  wp = 0.3,          ws = 0.2
+            - Bandpass:  wp = [0.2, 0.5],   ws = [0.1, 0.6]
+            - Bandstop:  wp = [0.1, 0.6],   ws = [0.2, 0.5]
+
+        For analog filters, `wp` and `ws` are angular frequencies
+        (e.g., rad/s).
+    gpass : float
+        The maximum loss in the passband (dB).
+    gstop : float
+        The minimum attenuation in the stopband (dB).
+    analog : bool, optional
+        When True, return an analog filter, otherwise a digital filter is
+        returned.
+    fs : float, optional
+        The sampling frequency of the digital system.
+
+    Returns
+    -------
+    ord : int
+        The lowest order for an Elliptic (Cauer) filter that meets specs.
+    wn : ndarray or float
+        The Chebyshev natural frequency (the "3dB frequency") for use with
+        `ellip` to give filter results. If `fs` is specified,
+        this is in the same units, and `fs` must also be passed to `ellip`.
+
+    See Also
+    --------
+    scipy.signal.ellipord
+    ellip : Filter design using order and critical points
+    buttord : Find order and critical points from passband and stopband spec
+    cheb1ord, cheb2ord
+    iirfilter : General filter design using order and critical frequencies
+    iirdesign : General filter design using passband and stopband spec
+    """
+    _validate_gpass_gstop(gpass, gstop)
+    wp, ws, filter_type = _validate_wp_ws(wp, ws, fs, analog)
+    passb, stopb = _pre_warp(wp, ws, analog)
+    nat, passb = _find_nat_freq(
+        stopb, passb, gpass, gstop, filter_type, 'ellip')
+
+    arg1_sq = _pow10m1(0.1 * gpass) / _pow10m1(0.1 * gstop)
+    arg0 = 1.0 / nat
+    d0 = special.ellipk(arg0 ** 2), special.ellipkm1(arg0 ** 2)
+    d1 = special.ellipk(arg1_sq), special.ellipkm1(arg1_sq)
+    ord = int(cupy.ceil(d0[0] * d1[1] / (d0[1] * d1[0])))
+
+    wn = _postprocess_wn(passb, analog, fs)
+
+    return ord, wn

vllm/lib/python3.10/site-packages/cupyx/scipy/signal/_iir_filter_design.py

@@ -0,0 +1,994 @@
+"""IIR filter design APIs"""
+from math import pi
+import math
+
+import cupy
+
+from cupyx.scipy.signal._iir_filter_conversions import (
+    lp2bp_zpk, lp2lp_zpk, lp2hp_zpk, lp2bs_zpk, bilinear_zpk, zpk2tf, zpk2sos)
+from cupyx.scipy.signal._iir_filter_conversions import (
+    buttap, cheb1ap, cheb2ap, ellipap, buttord, ellipord, cheb1ord, cheb2ord,
+    _validate_gpass_gstop)
+
+
+# FIXME
+
+def besselap():
+    raise NotImplementedError
+
+
+bessel_norms = {'fix': 'me'}
+
+
+def iirfilter(N, Wn, rp=None, rs=None, btype='band', analog=False,
+              ftype='butter', output='ba', fs=None):
+    """
+    IIR digital and analog filter design given order and critical points.
+
+    Design an Nth-order digital or analog filter and return the filter
+    coefficients.
+
+    Parameters
+    ----------
+    N : int
+        The order of the filter.
+    Wn : array_like
+        A scalar or length-2 sequence giving the critical frequencies.
+
+        For digital filters, `Wn` are in the same units as `fs`. By default,
+        `fs` is 2 half-cycles/sample, so these are normalized from 0 to 1,
+        where 1 is the Nyquist frequency. (`Wn` is thus in
+        half-cycles / sample.)
+
+        For analog filters, `Wn` is an angular frequency (e.g., rad/s).
+
+        When Wn is a length-2 sequence, ``Wn[0]`` must be less than ``Wn[1]``.
+    rp : float, optional
+        For Chebyshev and elliptic filters, provides the maximum ripple
+        in the passband. (dB)
+    rs : float, optional
+        For Chebyshev and elliptic filters, provides the minimum attenuation
+        in the stop band. (dB)
+    btype : {'bandpass', 'lowpass', 'highpass', 'bandstop'}, optional
+        The type of filter.  Default is 'bandpass'.
+    analog : bool, optional
+        When True, return an analog filter, otherwise a digital filter is
+        returned.
+    ftype : str, optional
+        The type of IIR filter to design:
+
+            - Butterworth   : 'butter'
+            - Chebyshev I   : 'cheby1'
+            - Chebyshev II  : 'cheby2'
+            - Cauer/elliptic: 'ellip'
+            - Bessel/Thomson: 'bessel'
+
+    output : {'ba', 'zpk', 'sos'}, optional
+        Filter form of the output:
+
+            - second-order sections (recommended): 'sos'
+            - numerator/denominator (default)    : 'ba'
+            - pole-zero                          : 'zpk'
+
+        In general the second-order sections ('sos') form  is
+        recommended because inferring the coefficients for the
+        numerator/denominator form ('ba') suffers from numerical
+        instabilities. For reasons of backward compatibility the default
+        form is the numerator/denominator form ('ba'), where the 'b'
+        and the 'a' in 'ba' refer to the commonly used names of the
+        coefficients used.
+
+        Note: Using the second-order sections form ('sos') is sometimes
+        associated with additional computational costs: for
+        data-intense use cases it is therefore recommended to also
+        investigate the numerator/denominator form ('ba').
+
+    fs : float, optional
+        The sampling frequency of the digital system.
+
+    Returns
+    -------
+    b, a : ndarray, ndarray
+        Numerator (`b`) and denominator (`a`) polynomials of the IIR filter.
+        Only returned if ``output='ba'``.
+    z, p, k : ndarray, ndarray, float
+        Zeros, poles, and system gain of the IIR filter transfer
+        function.  Only returned if ``output='zpk'``.
+    sos : ndarray
+        Second-order sections representation of the IIR filter.
+        Only returned if ``output='sos'``.
+
+    See Also
+    --------
+    butter : Filter design using order and critical points
+    cheby1, cheby2, ellip, bessel
+    buttord : Find order and critical points from passband and stopband spec
+    cheb1ord, cheb2ord, ellipord
+    iirdesign : General filter design using passband and stopband spec
+    scipy.signal.iirfilter
+
+    """
+    ftype, btype, output = [x.lower() for x in (ftype, btype, output)]
+
+    Wn = cupy.asarray(Wn)
+    # if cupy.any(Wn <= 0):
+    #    raise ValueError("filter critical frequencies must be greater than 0")
+
+    if Wn.size > 1 and not Wn[0] < Wn[1]:
+        raise ValueError("Wn[0] must be less than Wn[1]")
+
+    if fs is not None:
+        if analog:
+            raise ValueError("fs cannot be specified for an analog filter")
+        Wn = 2*Wn/fs
+
+    try:
+        btype = band_dict[btype]
+    except KeyError as e:
+        raise ValueError(
+            "'%s' is an invalid bandtype for filter." % btype) from e
+
+    try:
+        typefunc = filter_dict[ftype][0]
+    except KeyError as e:
+        raise ValueError(
+            "'%s' is not a valid basic IIR filter." % ftype) from e
+
+    if output not in ['ba', 'zpk', 'sos']:
+        raise ValueError("'%s' is not a valid output form." % output)
+
+    if rp is not None and rp < 0:
+        raise ValueError("passband ripple (rp) must be positive")
+
+    if rs is not None and rs < 0:
+        raise ValueError("stopband attenuation (rs) must be positive")
+
+    # Get analog lowpass prototype
+    if typefunc == buttap:
+        z, p, k = typefunc(N)
+    elif typefunc == besselap:
+        z, p, k = typefunc(N, norm=bessel_norms[ftype])
+    elif typefunc == cheb1ap:
+        if rp is None:
+            raise ValueError("passband ripple (rp) must be provided to "
+                             "design a Chebyshev I filter.")
+        z, p, k = typefunc(N, rp)
+    elif typefunc == cheb2ap:
+        if rs is None:
+            raise ValueError("stopband attenuation (rs) must be provided to "
+                             "design an Chebyshev II filter.")
+        z, p, k = typefunc(N, rs)
+    elif typefunc == ellipap:
+        if rs is None or rp is None:
+            raise ValueError("Both rp and rs must be provided to design an "
+                             "elliptic filter.")
+        z, p, k = typefunc(N, rp, rs)
+    else:
+        raise NotImplementedError("'%s' not implemented in iirfilter." % ftype)
+
+    # Pre-warp frequencies for digital filter design
+    if not analog:
+        if cupy.any(Wn <= 0) or cupy.any(Wn >= 1):
+            if fs is not None:
+                raise ValueError("Digital filter critical frequencies must "
+                                 f"be 0 < Wn < fs/2 (fs={fs} -> fs/2={fs/2})")
+            raise ValueError("Digital filter critical frequencies "
+                             "must be 0 < Wn < 1")
+        fs = 2.0
+        warped = 2 * fs * cupy.tan(pi * Wn / fs)
+    else:
+        warped = Wn
+
+    # transform to lowpass, bandpass, highpass, or bandstop
+    if btype in ('lowpass', 'highpass'):
+        if cupy.size(Wn) != 1:
+            raise ValueError('Must specify a single critical frequency Wn '
+                             'for lowpass or highpass filter')
+
+        if btype == 'lowpass':
+            z, p, k = lp2lp_zpk(z, p, k, wo=warped)
+        elif btype == 'highpass':
+            z, p, k = lp2hp_zpk(z, p, k, wo=warped)
+    elif btype in ('bandpass', 'bandstop'):
+        try:
+            bw = warped[1] - warped[0]
+            wo = cupy.sqrt(warped[0] * warped[1])
+        except IndexError as e:
+            raise ValueError('Wn must specify start and stop frequencies for '
+                             'bandpass or bandstop filter') from e
+
+        if btype == 'bandpass':
+            z, p, k = lp2bp_zpk(z, p, k, wo=wo, bw=bw)
+        elif btype == 'bandstop':
+            z, p, k = lp2bs_zpk(z, p, k, wo=wo, bw=bw)
+    else:
+        raise NotImplementedError("'%s' not implemented in iirfilter." % btype)
+
+    # Find discrete equivalent if necessary
+    if not analog:
+        z, p, k = bilinear_zpk(z, p, k, fs=fs)
+
+    # Transform to proper out type (pole-zero, state-space, numer-denom)
+    if output == 'zpk':
+        return z, p, k
+    elif output == 'ba':
+        return zpk2tf(z, p, k)
+    elif output == 'sos':
+        return zpk2sos(z, p, k, analog=analog)
+
+
+def butter(N, Wn, btype='low', analog=False, output='ba', fs=None):
+    """
+    Butterworth digital and analog filter design.
+
+    Design an Nth-order digital or analog Butterworth filter and return
+    the filter coefficients.
+
+    Parameters
+    ----------
+    N : int
+        The order of the filter. For 'bandpass' and 'bandstop' filters,
+        the resulting order of the final second-order sections ('sos')
+        matrix is ``2*N``, with `N` the number of biquad sections
+        of the desired system.
+    Wn : array_like
+        The critical frequency or frequencies. For lowpass and highpass
+        filters, Wn is a scalar; for bandpass and bandstop filters,
+        Wn is a length-2 sequence.
+
+        For a Butterworth filter, this is the point at which the gain
+        drops to 1/sqrt(2) that of the passband (the "-3 dB point").
+
+        For digital filters, if `fs` is not specified, `Wn` units are
+        normalized from 0 to 1, where 1 is the Nyquist frequency (`Wn` is
+        thus in half cycles / sample and defined as 2*critical frequencies
+        / `fs`). If `fs` is specified, `Wn` is in the same units as `fs`.
+
+        For analog filters, `Wn` is an angular frequency (e.g. rad/s).
+    btype : {'lowpass', 'highpass', 'bandpass', 'bandstop'}, optional
+        The type of filter.  Default is 'lowpass'.
+    analog : bool, optional
+        When True, return an analog filter, otherwise a digital filter is
+        returned.
+    output : {'ba', 'zpk', 'sos'}, optional
+        Type of output:  numerator/denominator ('ba'), pole-zero ('zpk'), or
+        second-order sections ('sos'). Default is 'ba' for backwards
+        compatibility, but 'sos' should be used for general-purpose filtering.
+    fs : float, optional
+        The sampling frequency of the digital system.
+
+    Returns
+    -------
+    b, a : ndarray, ndarray
+        Numerator (`b`) and denominator (`a`) polynomials of the IIR filter.
+        Only returned if ``output='ba'``.
+    z, p, k : ndarray, ndarray, float
+        Zeros, poles, and system gain of the IIR filter transfer
+        function.  Only returned if ``output='zpk'``.
+    sos : ndarray
+        Second-order sections representation of the IIR filter.
+        Only returned if ``output='sos'``.
+
+    See Also
+    --------
+    buttord, buttap
+    iirfilter
+    scipy.signal.butter
+
+
+    Notes
+    -----
+    The Butterworth filter has maximally flat frequency response in the
+    passband.
+
+    If the transfer function form ``[b, a]`` is requested, numerical
+    problems can occur since the conversion between roots and
+    the polynomial coefficients is a numerically sensitive operation,
+    even for N >= 4. It is recommended to work with the SOS
+    representation.
+
+    .. warning::
+        Designing high-order and narrowband IIR filters in TF form can
+        result in unstable or incorrect filtering due to floating point
+        numerical precision issues. Consider inspecting output filter
+        characteristics `freqz` or designing the filters with second-order
+        sections via ``output='sos'``.
+    """
+    return iirfilter(N, Wn, btype=btype, analog=analog,
+                     output=output, ftype='butter', fs=fs)
+
+
+def cheby1(N, rp, Wn, btype='low', analog=False, output='ba', fs=None):
+    """
+    Chebyshev type I digital and analog filter design.
+
+    Design an Nth-order digital or analog Chebyshev type I filter and
+    return the filter coefficients.
+
+    Parameters
+    ----------
+    N : int
+        The order of the filter.
+    rp : float
+        The maximum ripple allowed below unity gain in the passband.
+        Specified in decibels, as a positive number.
+    Wn : array_like
+        A scalar or length-2 sequence giving the critical frequencies.
+        For Type I filters, this is the point in the transition band at which
+        the gain first drops below -`rp`.
+
+        For digital filters, `Wn` are in the same units as `fs`. By default,
+        `fs` is 2 half-cycles/sample, so these are normalized from 0 to 1,
+        where 1 is the Nyquist frequency. (`Wn` is thus in
+        half-cycles / sample.)
+
+        For analog filters, `Wn` is an angular frequency (e.g., rad/s).
+    btype : {'lowpass', 'highpass', 'bandpass', 'bandstop'}, optional
+        The type of filter.  Default is 'lowpass'.
+    analog : bool, optional
+        When True, return an analog filter, otherwise a digital filter is
+        returned.
+    output : {'ba', 'zpk', 'sos'}, optional
+        Type of output:  numerator/denominator ('ba'), pole-zero ('zpk'), or
+        second-order sections ('sos'). Default is 'ba' for backwards
+        compatibility, but 'sos' should be used for general-purpose filtering.
+    fs : float, optional
+        The sampling frequency of the digital system.
+
+    Returns
+    -------
+    b, a : ndarray, ndarray
+        Numerator (`b`) and denominator (`a`) polynomials of the IIR filter.
+        Only returned if ``output='ba'``.
+    z, p, k : ndarray, ndarray, float
+        Zeros, poles, and system gain of the IIR filter transfer
+        function.  Only returned if ``output='zpk'``.
+    sos : ndarray
+        Second-order sections representation of the IIR filter.
+        Only returned if ``output='sos'``.
+
+    See Also
+    --------
+    cheb1ord, cheb1ap
+    iirfilter
+    scipy.signal.cheby1
+
+    Notes
+    -----
+    The Chebyshev type I filter maximizes the rate of cutoff between the
+    frequency response's passband and stopband, at the expense of ripple in
+    the passband and increased ringing in the step response.
+
+    Type I filters roll off faster than Type II (`cheby2`), but Type II
+    filters do not have any ripple in the passband.
+
+    The equiripple passband has N maxima or minima (for example, a
+    5th-order filter has 3 maxima and 2 minima). Consequently, the DC gain is
+    unity for odd-order filters, or -rp dB for even-order filters.
+    """
+    return iirfilter(N, Wn, rp=rp, btype=btype, analog=analog,
+                     output=output, ftype='cheby1', fs=fs)
+
+
+def cheby2(N, rs, Wn, btype='low', analog=False, output='ba', fs=None):
+    """
+    Chebyshev type II digital and analog filter design.
+
+    Design an Nth-order digital or analog Chebyshev type II filter and
+    return the filter coefficients.
+
+    Parameters
+    ----------
+    N : int
+        The order of the filter.
+    rs : float
+        The minimum attenuation required in the stop band.
+        Specified in decibels, as a positive number.
+    Wn : array_like
+        A scalar or length-2 sequence giving the critical frequencies.
+        For Type II filters, this is the point in the transition band at which
+        the gain first reaches -`rs`.
+
+        For digital filters, `Wn` are in the same units as `fs`. By default,
+        `fs` is 2 half-cycles/sample, so these are normalized from 0 to 1,
+        where 1 is the Nyquist frequency. (`Wn` is thus in
+        half-cycles / sample.)
+
+        For analog filters, `Wn` is an angular frequency (e.g., rad/s).
+    btype : {'lowpass', 'highpass', 'bandpass', 'bandstop'}, optional
+        The type of filter.  Default is 'lowpass'.
+    analog : bool, optional
+        When True, return an analog filter, otherwise a digital filter is
+        returned.
+    output : {'ba', 'zpk', 'sos'}, optional
+        Type of output:  numerator/denominator ('ba'), pole-zero ('zpk'), or
+        second-order sections ('sos'). Default is 'ba' for backwards
+        compatibility, but 'sos' should be used for general-purpose filtering.
+    fs : float, optional
+        The sampling frequency of the digital system.
+
+    Returns
+    -------
+    b, a : ndarray, ndarray
+        Numerator (`b`) and denominator (`a`) polynomials of the IIR filter.
+        Only returned if ``output='ba'``.
+    z, p, k : ndarray, ndarray, float
+        Zeros, poles, and system gain of the IIR filter transfer
+        function.  Only returned if ``output='zpk'``.
+    sos : ndarray
+        Second-order sections representation of the IIR filter.
+        Only returned if ``output='sos'``.
+
+    See Also
+    --------
+    cheb2ord, cheb2ap
+    iirfilter
+    scipy.signal.cheby2
+
+    Notes
+    -----
+    The Chebyshev type II filter maximizes the rate of cutoff between the
+    frequency response's passband and stopband, at the expense of ripple in
+    the stopband and increased ringing in the step response.
+
+    Type II filters do not roll off as fast as Type I (`cheby1`).
+    """
+    return iirfilter(N, Wn, rs=rs, btype=btype, analog=analog,
+                     output=output, ftype='cheby2', fs=fs)
+
+
+def ellip(N, rp, rs, Wn, btype='low', analog=False, output='ba', fs=None):
+    """
+    Elliptic (Cauer) digital and analog filter design.
+
+    Design an Nth-order digital or analog elliptic filter and return
+    the filter coefficients.
+
+    Parameters
+    ----------
+    N : int
+        The order of the filter.
+    rp : float
+        The maximum ripple allowed below unity gain in the passband.
+        Specified in decibels, as a positive number.
+    rs : float
+        The minimum attenuation required in the stop band.
+        Specified in decibels, as a positive number.
+    Wn : array_like
+        A scalar or length-2 sequence giving the critical frequencies.
+        For elliptic filters, this is the point in the transition band at
+        which the gain first drops below -`rp`.
+
+        For digital filters, `Wn` are in the same units as `fs`. By default,
+        `fs` is 2 half-cycles/sample, so these are normalized from 0 to 1,
+        where 1 is the Nyquist frequency. (`Wn` is thus in
+        half-cycles / sample.)
+
+        For analog filters, `Wn` is an angular frequency (e.g., rad/s).
+    btype : {'lowpass', 'highpass', 'bandpass', 'bandstop'}, optional
+        The type of filter. Default is 'lowpass'.
+    analog : bool, optional
+        When True, return an analog filter, otherwise a digital filter is
+        returned.
+    output : {'ba', 'zpk', 'sos'}, optional
+        Type of output:  numerator/denominator ('ba'), pole-zero ('zpk'), or
+        second-order sections ('sos'). Default is 'ba' for backwards
+        compatibility, but 'sos' should be used for general-purpose filtering.
+    fs : float, optional
+        The sampling frequency of the digital system.
+
+    Returns
+    -------
+    b, a : ndarray, ndarray
+        Numerator (`b`) and denominator (`a`) polynomials of the IIR filter.
+        Only returned if ``output='ba'``.
+    z, p, k : ndarray, ndarray, float
+        Zeros, poles, and system gain of the IIR filter transfer
+        function.  Only returned if ``output='zpk'``.
+    sos : ndarray
+        Second-order sections representation of the IIR filter.
+        Only returned if ``output='sos'``.
+
+    See Also
+    --------
+    ellipord, ellipap
+    iirfilter
+    scipy.signal.ellip
+
+    Notes
+    -----
+    Also known as Cauer or Zolotarev filters, the elliptical filter maximizes
+    the rate of transition between the frequency response's passband and
+    stopband, at the expense of ripple in both, and increased ringing in the
+    step response.
+
+    As `rp` approaches 0, the elliptical filter becomes a Chebyshev
+    type II filter (`cheby2`). As `rs` approaches 0, it becomes a Chebyshev
+    type I filter (`cheby1`). As both approach 0, it becomes a Butterworth
+    filter (`butter`).
+
+    The equiripple passband has N maxima or minima (for example, a
+    5th-order filter has 3 maxima and 2 minima). Consequently, the DC gain is
+    unity for odd-order filters, or -rp dB for even-order filters.
+    """
+    return iirfilter(N, Wn, rs=rs, rp=rp, btype=btype, analog=analog,
+                     output=output, ftype='elliptic', fs=fs)
+
+
+def iirdesign(wp, ws, gpass, gstop, analog=False, ftype='ellip', output='ba',
+              fs=None):
+    """Complete IIR digital and analog filter design.
+
+    Given passband and stopband frequencies and gains, construct an analog or
+    digital IIR filter of minimum order for a given basic type. Return the
+    output in numerator, denominator ('ba'), pole-zero ('zpk') or second order
+    sections ('sos') form.
+
+    Parameters
+    ----------
+    wp, ws : float or array like, shape (2,)
+        Passband and stopband edge frequencies. Possible values are scalars
+        (for lowpass and highpass filters) or ranges (for bandpass and bandstop
+        filters).
+        For digital filters, these are in the same units as `fs`. By default,
+        `fs` is 2 half-cycles/sample, so these are normalized from 0 to 1,
+        where 1 is the Nyquist frequency. For example:
+
+            - Lowpass:   wp = 0.2,          ws = 0.3
+            - Highpass:  wp = 0.3,          ws = 0.2
+            - Bandpass:  wp = [0.2, 0.5],   ws = [0.1, 0.6]
+            - Bandstop:  wp = [0.1, 0.6],   ws = [0.2, 0.5]
+
+        For analog filters, `wp` and `ws` are angular frequencies
+        (e.g., rad/s). Note, that for bandpass and bandstop filters passband
+        must lie strictly inside stopband or vice versa.
+    gpass : float
+        The maximum loss in the passband (dB).
+    gstop : float
+        The minimum attenuation in the stopband (dB).
+    analog : bool, optional
+        When True, return an analog filter, otherwise a digital filter is
+        returned.
+    ftype : str, optional
+        The type of IIR filter to design:
+
+            - Butterworth   : 'butter'
+            - Chebyshev I   : 'cheby1'
+            - Chebyshev II  : 'cheby2'
+            - Cauer/elliptic: 'ellip'
+
+    output : {'ba', 'zpk', 'sos'}, optional
+        Filter form of the output:
+
+            - second-order sections (recommended): 'sos'
+            - numerator/denominator (default)    : 'ba'
+            - pole-zero                          : 'zpk'
+
+        In general the second-order sections ('sos') form  is
+        recommended because inferring the coefficients for the
+        numerator/denominator form ('ba') suffers from numerical
+        instabilities. For reasons of backward compatibility the default
+        form is the numerator/denominator form ('ba'), where the 'b'
+        and the 'a' in 'ba' refer to the commonly used names of the
+        coefficients used.
+
+        Note: Using the second-order sections form ('sos') is sometimes
+        associated with additional computational costs: for
+        data-intense use cases it is therefore recommended to also
+        investigate the numerator/denominator form ('ba').
+
+    fs : float, optional
+        The sampling frequency of the digital system.
+
+        .. versionadded:: 1.2.0
+
+    Returns
+    -------
+    b, a : ndarray, ndarray
+        Numerator (`b`) and denominator (`a`) polynomials of the IIR filter.
+        Only returned if ``output='ba'``.
+    z, p, k : ndarray, ndarray, float
+        Zeros, poles, and system gain of the IIR filter transfer
+        function.  Only returned if ``output='zpk'``.
+    sos : ndarray
+        Second-order sections representation of the IIR filter.
+        Only returned if ``output='sos'``.
+
+    See Also
+    --------
+    scipy.signal.iirdesign
+    butter : Filter design using order and critical points
+    cheby1, cheby2, ellip, bessel
+    buttord : Find order and critical points from passband and stopband spec
+    cheb1ord, cheb2ord, ellipord
+    iirfilter : General filter design using order and critical frequencies
+    """
+    try:
+        ordfunc = filter_dict[ftype][1]
+    except KeyError as e:
+        raise ValueError("Invalid IIR filter type: %s" % ftype) from e
+    except IndexError as e:
+        raise ValueError(("%s does not have order selection. Use "
+                          "iirfilter function.") % ftype) from e
+
+    _validate_gpass_gstop(gpass, gstop)
+
+    wp = cupy.atleast_1d(wp)
+    ws = cupy.atleast_1d(ws)
+
+    if wp.shape[0] != ws.shape[0] or wp.shape not in [(1,), (2,)]:
+        raise ValueError("wp and ws must have one or two elements each, and"
+                         "the same shape, got %s and %s"
+                         % (wp.shape, ws.shape))
+
+    if any(wp <= 0) or any(ws <= 0):
+        raise ValueError("Values for wp, ws must be greater than 0")
+
+    if not analog:
+        if fs is None:
+            if any(wp >= 1) or any(ws >= 1):
+                raise ValueError("Values for wp, ws must be less than 1")
+        elif any(wp >= fs/2) or any(ws >= fs/2):
+            raise ValueError("Values for wp, ws must be less than fs/2"
+                             " (fs={} -> fs/2={})".format(fs, fs/2))
+
+    if wp.shape[0] == 2:
+        if not ((ws[0] < wp[0] and wp[1] < ws[1]) or
+                (wp[0] < ws[0] and ws[1] < wp[1])):
+            raise ValueError("Passband must lie strictly inside stopband"
+                             " or vice versa")
+
+    band_type = 2 * (len(wp) - 1)
+    band_type += 1
+    if wp[0] >= ws[0]:
+        band_type += 1
+
+    btype = {1: 'lowpass', 2: 'highpass',
+             3: 'bandstop', 4: 'bandpass'}[band_type]
+
+    N, Wn = ordfunc(wp, ws, gpass, gstop, analog=analog, fs=fs)
+    return iirfilter(N, Wn, rp=gpass, rs=gstop, analog=analog, btype=btype,
+                     ftype=ftype, output=output, fs=fs)
+
+
+def iircomb(w0, Q, ftype='notch', fs=2.0, *, pass_zero=False):
+    """
+    Design IIR notching or peaking digital comb filter.
+
+    A notching comb filter consists of regularly-spaced band-stop filters with
+    a narrow bandwidth (high quality factor). Each rejects a narrow frequency
+    band and leaves the rest of the spectrum little changed.
+
+    A peaking comb filter consists of regularly-spaced band-pass filters with
+    a narrow bandwidth (high quality factor). Each rejects components outside
+    a narrow frequency band.
+
+    Parameters
+    ----------
+    w0 : float
+        The fundamental frequency of the comb filter (the spacing between its
+        peaks). This must evenly divide the sampling frequency. If `fs` is
+        specified, this is in the same units as `fs`. By default, it is
+        a normalized scalar that must satisfy  ``0 < w0 < 1``, with
+        ``w0 = 1`` corresponding to half of the sampling frequency.
+    Q : float
+        Quality factor. Dimensionless parameter that characterizes
+        notch filter -3 dB bandwidth ``bw`` relative to its center
+        frequency, ``Q = w0/bw``.
+    ftype : {'notch', 'peak'}
+        The type of comb filter generated by the function. If 'notch', then
+        the Q factor applies to the notches. If 'peak', then the Q factor
+        applies to the peaks.  Default is 'notch'.
+    fs : float, optional
+        The sampling frequency of the signal. Default is 2.0.
+    pass_zero : bool, optional
+        If False (default), the notches (nulls) of the filter are centered on
+        frequencies [0, w0, 2*w0, ...], and the peaks are centered on the
+        midpoints [w0/2, 3*w0/2, 5*w0/2, ...].  If True, the peaks are centered
+        on [0, w0, 2*w0, ...] (passing zero frequency) and vice versa.
+
+    Returns
+    -------
+    b, a : ndarray, ndarray
+        Numerator (``b``) and denominator (``a``) polynomials
+        of the IIR filter.
+
+    Raises
+    ------
+    ValueError
+        If `w0` is less than or equal to 0 or greater than or equal to
+        ``fs/2``, if `fs` is not divisible by `w0`, if `ftype`
+        is not 'notch' or 'peak'
+
+    See Also
+    --------
+    scipy.signal.iircomb
+    iirnotch
+    iirpeak
+
+    Notes
+    -----
+    The TF implementation of the
+    comb filter is numerically stable even at higher orders due to the
+    use of a single repeated pole, which won't suffer from precision loss.
+
+    References
+    ----------
+    Sophocles J. Orfanidis, "Introduction To Signal Processing",
+         Prentice-Hall, 1996, ch. 11, "Digital Filter Design"
+    """
+
+    # Convert w0, Q, and fs to float
+    w0 = float(w0)
+    Q = float(Q)
+    fs = float(fs)
+
+    # Check for invalid cutoff frequency or filter type
+    ftype = ftype.lower()
+    if not 0 < w0 < fs / 2:
+        raise ValueError("w0 must be between 0 and {}"
+                         " (nyquist), but given {}.".format(fs / 2, w0))
+    if ftype not in ('notch', 'peak'):
+        raise ValueError('ftype must be either notch or peak.')
+
+    # Compute the order of the filter
+    N = round(fs / w0)
+
+    # Check for cutoff frequency divisibility
+    if abs(w0 - fs/N)/fs > 1e-14:
+        raise ValueError('fs must be divisible by w0.')
+
+    # Compute frequency in radians and filter bandwidth
+    # Eq. 11.3.1 (p. 574) from reference [1]
+    w0 = (2 * pi * w0) / fs
+    w_delta = w0 / Q
+
+    # Define base gain values depending on notch or peak filter
+    # Compute -3dB attenuation
+    # Eqs. 11.4.1 and 11.4.2 (p. 582) from reference [1]
+    if ftype == 'notch':
+        G0, G = 1, 0
+    elif ftype == 'peak':
+        G0, G = 0, 1
+    GB = 1 / math.sqrt(2)
+
+    # Compute beta
+    # Eq. 11.5.3 (p. 591) from reference [1]
+    beta = math.sqrt((GB**2 - G0**2) / (G**2 - GB**2)) * \
+        math.tan(N * w_delta / 4)
+
+    # Compute filter coefficients
+    # Eq 11.5.1 (p. 590) variables a, b, c from reference [1]
+    ax = (1 - beta) / (1 + beta)
+    bx = (G0 + G * beta) / (1 + beta)
+    cx = (G0 - G * beta) / (1 + beta)
+
+    # Last coefficients are negative to get peaking comb that passes zero or
+    # notching comb that doesn't.
+    negative_coef = ((ftype == 'peak' and pass_zero) or
+                     (ftype == 'notch' and not pass_zero))
+
+    # Compute numerator coefficients
+    # Eq 11.5.1 (p. 590) or Eq 11.5.4 (p. 591) from reference [1]
+    # b - cz^-N or b + cz^-N
+    b = cupy.zeros(N + 1)
+    b[0] = bx
+    if negative_coef:
+        b[-1] = -cx
+    else:
+        b[-1] = +cx
+
+    # Compute denominator coefficients
+    # Eq 11.5.1 (p. 590) or Eq 11.5.4 (p. 591) from reference [1]
+    # 1 - az^-N or 1 + az^-N
+    a = cupy.zeros(N + 1)
+    a[0] = 1
+    if negative_coef:
+        a[-1] = -ax
+    else:
+        a[-1] = +ax
+
+    return b, a
+
+
+def iirnotch(w0, Q, fs=2.0):
+    """
+    Design second-order IIR notch digital filter.
+
+    A notch filter is a band-stop filter with a narrow bandwidth
+    (high quality factor). It rejects a narrow frequency band and
+    leaves the rest of the spectrum little changed.
+
+    Parameters
+    ----------
+    w0 : float
+        Frequency to remove from a signal. If `fs` is specified, this is in
+        the same units as `fs`. By default, it is a normalized scalar that must
+        satisfy  ``0 < w0 < 1``, with ``w0 = 1`` corresponding to half of the
+        sampling frequency.
+    Q : float
+        Quality factor. Dimensionless parameter that characterizes
+        notch filter -3 dB bandwidth ``bw`` relative to its center
+        frequency, ``Q = w0/bw``.
+    fs : float, optional
+        The sampling frequency of the digital system.
+
+    Returns
+    -------
+    b, a : ndarray, ndarray
+        Numerator (``b``) and denominator (``a``) polynomials
+        of the IIR filter.
+
+    See Also
+    --------
+    scipy.signal.iirnotch
+
+    References
+    ----------
+    Sophocles J. Orfanidis, "Introduction To Signal Processing",
+         Prentice-Hall, 1996
+    """
+
+    return _design_notch_peak_filter(w0, Q, "notch", fs)
+
+
+def iirpeak(w0, Q, fs=2.0):
+    """
+    Design second-order IIR peak (resonant) digital filter.
+
+    A peak filter is a band-pass filter with a narrow bandwidth
+    (high quality factor). It rejects components outside a narrow
+    frequency band.
+
+    Parameters
+    ----------
+    w0 : float
+        Frequency to be retained in a signal. If `fs` is specified, this is in
+        the same units as `fs`. By default, it is a normalized scalar that must
+        satisfy  ``0 < w0 < 1``, with ``w0 = 1`` corresponding to half of the
+        sampling frequency.
+    Q : float
+        Quality factor. Dimensionless parameter that characterizes
+        peak filter -3 dB bandwidth ``bw`` relative to its center
+        frequency, ``Q = w0/bw``.
+    fs : float, optional
+        The sampling frequency of the digital system.
+
+
+    Returns
+    -------
+    b, a : ndarray, ndarray
+        Numerator (``b``) and denominator (``a``) polynomials
+        of the IIR filter.
+
+    See Also
+    --------
+    scpy.signal.iirpeak
+
+    References
+    ----------
+    Sophocles J. Orfanidis, "Introduction To Signal Processing",
+       Prentice-Hall, 1996
+    """
+
+    return _design_notch_peak_filter(w0, Q, "peak", fs)
+
+
+def _design_notch_peak_filter(w0, Q, ftype, fs=2.0):
+    """
+    Design notch or peak digital filter.
+
+    Parameters
+    ----------
+    w0 : float
+        Normalized frequency to remove from a signal. If `fs` is specified,
+        this is in the same units as `fs`. By default, it is a normalized
+        scalar that must satisfy  ``0 < w0 < 1``, with ``w0 = 1``
+        corresponding to half of the sampling frequency.
+    Q : float
+        Quality factor. Dimensionless parameter that characterizes
+        notch filter -3 dB bandwidth ``bw`` relative to its center
+        frequency, ``Q = w0/bw``.
+    ftype : str
+        The type of IIR filter to design:
+
+            - notch filter : ``notch``
+            - peak filter  : ``peak``
+    fs : float, optional
+        The sampling frequency of the digital system.
+
+    Returns
+    -------
+    b, a : ndarray, ndarray
+        Numerator (``b``) and denominator (``a``) polynomials
+        of the IIR filter.
+    """
+
+    # Guarantee that the inputs are floats
+    w0 = float(w0)
+    Q = float(Q)
+    w0 = 2 * w0 / fs
+
+    # Checks if w0 is within the range
+    if w0 > 1.0 or w0 < 0.0:
+        raise ValueError("w0 should be such that 0 < w0 < 1")
+
+    # Get bandwidth
+    bw = w0 / Q
+
+    # Normalize inputs
+    bw = bw * pi
+    w0 = w0 * pi
+
+    # Compute -3dB attenuation
+    gb = 1 / math.sqrt(2)
+
+    if ftype == "notch":
+        # Compute beta: formula 11.3.4 (p.575) from reference [1]
+        beta = (math.sqrt(1.0 - gb**2.0) / gb) * math.tan(bw / 2.0)
+    elif ftype == "peak":
+        # Compute beta: formula 11.3.19 (p.579) from reference [1]
+        beta = (gb / math.sqrt(1.0 - gb**2.0)) * math.tan(bw / 2.0)
+    else:
+        raise ValueError("Unknown ftype.")
+
+    # Compute gain: formula 11.3.6 (p.575) from reference [1]
+    gain = 1.0 / (1.0 + beta)
+
+    # Compute numerator b and denominator a
+    # formulas 11.3.7 (p.575) and 11.3.21 (p.579)
+    # from reference [1]
+    if ftype == "notch":
+        b = [gain * x for x in (1.0, -2.0 * math.cos(w0), 1.0)]
+    else:
+        b = [(1.0 - gain) * x for x in (1.0, 0.0, -1.0)]
+
+    a = [1.0, -2.0 * gain * math.cos(w0), 2.0 * gain - 1.0]
+
+    a = cupy.asarray(a)
+    b = cupy.asarray(b)
+
+    return b, a
+
+
+filter_dict = {'butter': [buttap, buttord],
+               'butterworth': [buttap, buttord],
+
+               'cauer': [ellipap, ellipord],
+               'elliptic': [ellipap, ellipord],
+               'ellip': [ellipap, ellipord],
+
+               'bessel': [besselap],
+               'bessel_phase': [besselap],
+               'bessel_delay': [besselap],
+               'bessel_mag': [besselap],
+
+               'cheby1': [cheb1ap, cheb1ord],
+               'chebyshev1': [cheb1ap, cheb1ord],
+               'chebyshevi': [cheb1ap, cheb1ord],
+
+               'cheby2': [cheb2ap, cheb2ord],
+               'chebyshev2': [cheb2ap, cheb2ord],
+               'chebyshevii': [cheb2ap, cheb2ord],
+               }
+
+band_dict = {'band': 'bandpass',
+             'bandpass': 'bandpass',
+             'pass': 'bandpass',
+             'bp': 'bandpass',
+
+             'bs': 'bandstop',
+             'bandstop': 'bandstop',
+             'bands': 'bandstop',
+             'stop': 'bandstop',
+
+             'l': 'lowpass',
+             'low': 'lowpass',
+             'lowpass': 'lowpass',
+             'lp': 'lowpass',
+
+             'high': 'highpass',
+             'highpass': 'highpass',
+             'h': 'highpass',
+             'hp': 'highpass',
+             }

vllm/lib/python3.10/site-packages/cupyx/scipy/signal/_iir_utils.py

@@ -0,0 +1,737 @@
+
+from itertools import product
+
+import cupy
+from cupy._core.internal import _normalize_axis_index
+from cupy._core._scalar import get_typename
+from cupy_backends.cuda.api import runtime
+from cupyx.scipy.signal._arraytools import axis_slice
+
+
+def _get_typename(dtype):
+    typename = get_typename(dtype)
+    if cupy.dtype(dtype).kind == 'c':
+        typename = 'thrust::' + typename
+    elif typename == 'float16':
+        if runtime.is_hip:
+            # 'half' in name_expressions weirdly raises
+            # HIPRTC_ERROR_NAME_EXPRESSION_NOT_VALID in getLoweredName() on
+            # ROCm
+            typename = '__half'
+        else:
+            typename = 'half'
+    return typename
+
+
+FLOAT_TYPES = [cupy.float16, cupy.float32, cupy.float64]
+INT_TYPES = [cupy.int8, cupy.int16, cupy.int32, cupy.int64]
+COMPLEX_TYPES = [cupy.complex64, cupy.complex128]
+UNSIGNED_TYPES = [cupy.uint8, cupy.uint16, cupy.uint32, cupy.uint64]
+TYPES = FLOAT_TYPES + INT_TYPES + UNSIGNED_TYPES + COMPLEX_TYPES  # type: ignore  # NOQA
+TYPE_PAIRS = [(x, y) for x, y in product(TYPES, TYPES)
+              if cupy.promote_types(x, y) is cupy.dtype(x)]
+
+TYPE_NAMES = [_get_typename(t) for t in TYPES]
+TYPE_PAIR_NAMES = [(_get_typename(x), _get_typename(y)) for x, y in TYPE_PAIRS]
+
+
+IIR_KERNEL = r"""
+#include <cupy/math_constants.h>
+#include <cupy/carray.cuh>
+#include <cupy/complex.cuh>
+
+template<typename U, typename T>
+__global__ void compute_correction_factors(
+        const int m, const int k, const T* b, U* out) {
+    int idx = blockDim.x * blockIdx.x + threadIdx.x;
+    if(idx >= k) {
+        return;
+    }
+
+    U* out_start = out + idx * (k + m);
+    U* out_off = out_start + k;
+
+    for(int i = 0; i < m; i++) {
+        U acc = 0.0;
+        for(int j = 0; j < k; j++) {
+            acc += ((U) b[j]) * out_off[i - j - 1];
+
+        }
+        out_off[i] = acc;
+    }
+}
+
+template<typename T>
+__global__ void first_pass_iir(
+        const int m, const int k, const int n, const int n_blocks,
+        const int carries_stride, const T* factors, T* out,
+        T* carries) {
+    int orig_idx = blockDim.x * (blockIdx.x % n_blocks) + threadIdx.x;
+
+    int num_row = blockIdx.x / n_blocks;
+    int idx = 2 * orig_idx + 1;
+
+    if(idx >= n) {
+        return;
+    }
+
+    int group_num = idx / m;
+    int group_pos = idx % m;
+
+    T* out_off = out + num_row * n;
+    T* carries_off = carries + num_row * carries_stride;
+
+    T* group_start = out_off + m * group_num;
+    T* group_carries = carries_off + k * group_num;
+
+    int pos = group_pos;
+    int up_bound = pos;
+    int low_bound = pos;
+    int rel_pos;
+
+    for(int level = 1, iter = 1; level < m; level *=2, iter++) {
+        int sz = min(pow(2.0f, ((float) iter)), ((float) m));
+
+        if(level > 1) {
+            int factor = ceil(pos / ((float) sz));
+            up_bound = sz * factor - 1;
+            low_bound = up_bound - level + 1;
+        }
+
+        if(level == 1) {
+            pos = low_bound;
+        }
+
+        if(pos < low_bound) {
+            pos += level / 2;
+        }
+
+        if(pos + m * group_num >= n) {
+            break;
+        }
+
+        rel_pos = pos % level;
+        T carry = 0.0;
+        for(int i = 1; i <= min(k, level); i++) {
+            T k_value = group_start[low_bound - i];
+            const T* k_factors = factors + (m + k) * (i - 1) + k;
+            T factor = k_factors[rel_pos];
+            carry += k_value * factor;
+        }
+
+        group_start[pos] += carry;
+        __syncthreads();
+    }
+
+    if(pos >= m - k) {
+        if(carries != NULL) {
+            group_carries[pos - (m - k)] = group_start[pos];
+        }
+    }
+
+}
+
+template<typename T>
+__global__ void correct_carries(
+    const int m, const int k, const int n_blocks, const int carries_stride,
+    const int offset, const T* factors, T* carries) {
+
+    int idx = threadIdx.x;
+    int pos = idx + (m - k);
+    T* row_carries = carries + carries_stride * blockIdx.x;
+
+    for(int i = offset; i < n_blocks; i++) {
+        T* this_carries = row_carries + k * (i + (1 - offset));
+        T* prev_carries = row_carries + k * (i - offset);
+
+        T carry = 0.0;
+        for(int j = 1; j <= k; j++) {
+            const T* k_factors = factors + (m + k) * (j - 1) + k;
+            T factor = k_factors[pos];
+            T k_value = prev_carries[k - j];
+            carry += factor * k_value;
+        }
+
+        this_carries[idx] += carry;
+        __syncthreads();
+    }
+}
+
+template<typename T>
+__global__ void second_pass_iir(
+        const int m, const int k, const int n, const int carries_stride,
+        const int n_blocks, const int offset, const T* factors,
+        T* carries, T* out) {
+
+    int idx = blockDim.x * (blockIdx.x % n_blocks) + threadIdx.x;
+    idx += offset * m;
+
+    int row_num = blockIdx.x / n_blocks;
+    int n_group = idx / m;
+    int pos = idx % m;
+
+    if(idx >= n) {
+        return;
+    }
+
+    T* out_off = out + row_num * n;
+    T* carries_off = carries + row_num * carries_stride;
+    const T* prev_carries = carries_off + (n_group - offset) * k;
+
+    T carry = 0.0;
+    for(int i = 1; i <= k; i++) {
+        const T* k_factors = factors + (m + k) * (i - 1) + k;
+        T factor = k_factors[pos];
+        T k_value = prev_carries[k - i];
+        carry += factor * k_value;
+    }
+
+    out_off[idx] += carry;
+}
+"""
+
+IIR_SOS_KERNEL = r"""
+#include <cupy/math_constants.h>
+#include <cupy/carray.cuh>
+#include <cupy/complex.cuh>
+
+template<typename T>
+__global__ void pick_carries(
+        const int m, const int n, const int carries_stride, const int n_blocks,
+        const int offset, T* x, T* carries) {
+
+    int idx = m * (blockIdx.x % n_blocks) + threadIdx.x + m - 2;
+    int pos = threadIdx.x;
+    int row_num = blockIdx.x / n_blocks;
+    int n_group = idx / m;
+
+    T* x_off = x + row_num * n;
+    T* carries_off = carries + row_num * carries_stride;
+    T* group_carries = carries_off + (n_group + (1 - offset)) * 2;
+
+    if(idx >= n) {
+        return;
+    }
+
+    group_carries[pos] = x_off[idx];
+}
+
+template<typename U, typename T>
+__global__ void compute_correction_factors_sos(
+        const int m, const T* f_const, U* all_out) {
+
+    extern __shared__ __align__(sizeof(T)) thrust::complex<double> bc_d[2];
+    T* b_c = reinterpret_cast<T*>(bc_d);
+
+    extern __shared__ __align__(sizeof(T)) thrust::complex<double> off_d[4];
+    U* off_cache = reinterpret_cast<U*>(off_d);
+
+    int idx = threadIdx.x;
+    int num_section = blockIdx.x;
+
+    const int n_const = 6;
+    const int a_off = 3;
+    const int k = 2;
+    const int off_idx = 1;
+
+    U* out = all_out + num_section * k * m;
+    U* out_start = out + idx * m;
+    const T* b = f_const + num_section * n_const + a_off + 1;
+
+    b_c[idx] = b[idx];
+    __syncthreads();
+
+    U* this_cache = off_cache + k * idx;
+    this_cache[off_idx - idx] = 1;
+    this_cache[idx] = 0;
+
+    for(int i = 0; i < m; i++) {
+        U acc = 0.0;
+        for(int j = 0; j < k; j++) {
+            acc += -((U) b_c[j]) * this_cache[off_idx - j];
+
+        }
+        this_cache[0] = this_cache[1];
+        this_cache[1] = acc;
+        out_start[i] = acc;
+    }
+}
+
+
+template<typename T>
+__global__ void first_pass_iir_sos(
+        const int m, const int n, const int n_blocks,
+        const T* factors, T* out, T* carries) {
+
+    extern __shared__ unsigned int thread_status[2];
+    extern __shared__ __align__(sizeof(T)) thrust::complex<double> fc_d[2 * 1024];
+    T* factor_cache = reinterpret_cast<T*>(fc_d);
+
+    int orig_idx = blockDim.x * (blockIdx.x % n_blocks) + threadIdx.x;
+
+    int num_row = blockIdx.x / n_blocks;
+    int idx = 2 * orig_idx + 1;
+    const int k = 2;
+
+    if(idx >= n) {
+        return;
+    }
+
+    int group_num = idx / m;
+    int group_pos = idx % m;
+    T* out_off = out + num_row * n;
+    T* carries_off = carries + num_row * n_blocks * k;
+
+    T* group_start = out_off + m * group_num;
+    T* group_carries = carries_off + group_num * k;
+
+    const T* section_factors = factors;
+    T* section_carries = group_carries;
+
+    factor_cache[group_pos] = section_factors[group_pos];
+    factor_cache[group_pos - 1] = section_factors[group_pos - 1];
+    factor_cache[m + group_pos] = section_factors[m + group_pos];
+    factor_cache[m + group_pos - 1] = section_factors[m + group_pos - 1];
+    __syncthreads();
+
+    int pos = group_pos;
+    int up_bound = pos;
+    int low_bound = pos;
+    int rel_pos;
+
+    for(int level = 1, iter = 1; level < m; level *= 2, iter++) {
+        int sz = min(pow(2.0f, ((float) iter)), ((float) m));
+
+        if(level > 1) {
+            int factor = ceil(pos / ((float) sz));
+            up_bound = sz * factor - 1;
+            low_bound = up_bound - level + 1;
+        }
+
+        if(level == 1) {
+            pos = low_bound;
+        }
+
+        if(pos < low_bound) {
+            pos += level / 2;
+        }
+
+        if(pos + m * group_num >= n) {
+            break;
+        }
+
+        rel_pos = pos % level;
+        T carry = 0.0;
+        for(int i = 1; i <= min(k, level); i++) {
+            T k_value = group_start[low_bound - i];
+            const T* k_factors = factor_cache + m  * (i - 1);
+            T factor = k_factors[rel_pos];
+            carry += k_value * factor;
+        }
+
+        group_start[pos] += carry;
+        __syncthreads();
+    }
+
+    if(pos >= m - k) {
+        if(carries != NULL) {
+            section_carries[pos - (m - k)] = group_start[pos];
+        }
+    }
+}
+
+template<typename T>
+__global__ void correct_carries_sos(
+    const int m, const int n_blocks, const int carries_stride,
+    const int offset, const T* factors, T* carries) {
+
+    extern __shared__ __align__(sizeof(T)) thrust::complex<double> fcd3[4];
+    T* factor_cache = reinterpret_cast<T*>(fcd3);
+
+    int idx = threadIdx.x;
+    const int k = 2;
+    int pos = idx + (m - k);
+    T* row_carries = carries + carries_stride * blockIdx.x;
+
+    factor_cache[2 * idx] = factors[pos];
+    factor_cache[2 * idx + 1] = factors[m + pos];
+    __syncthreads();
+
+    for(int i = offset; i < n_blocks; i++) {
+        T* this_carries = row_carries + k * (i + (1 - offset));
+        T* prev_carries = row_carries + k * (i - offset);
+
+        T carry = 0.0;
+        for(int j = 1; j <= k; j++) {
+            // const T* k_factors = factors + m * (j - 1);
+            // T factor = k_factors[pos];
+            T factor = factor_cache[2 * idx + (j - 1)];
+            T k_value = prev_carries[k - j];
+            carry += factor * k_value;
+        }
+
+        this_carries[idx] += carry;
+        __syncthreads();
+    }
+}
+
+template<typename T>
+__global__ void second_pass_iir_sos(
+        const int m, const int n, const int carries_stride,
+        const int n_blocks, const int offset, const T* factors,
+        T* carries, T* out) {
+
+    extern __shared__ __align__(sizeof(T)) thrust::complex<double> fcd2[2 * 1024];
+    T* factor_cache = reinterpret_cast<T*>(fcd2);
+
+    extern __shared__ __align__(sizeof(T)) thrust::complex<double> c_d[2];
+    T* carries_cache = reinterpret_cast<T*>(c_d);
+
+    int idx = blockDim.x * (blockIdx.x % n_blocks) + threadIdx.x;
+    idx += offset * m;
+
+    int row_num = blockIdx.x / n_blocks;
+    int n_group = idx / m;
+    int pos = idx % m;
+    const int k = 2;
+
+    T* out_off = out + row_num * n;
+    T* carries_off = carries + row_num * carries_stride;
+    const T* prev_carries = carries_off + (n_group - offset) * k;
+
+    if(pos < k) {
+        carries_cache[pos] = prev_carries[pos];
+    }
+
+    if(idx >= n) {
+        return;
+    }
+
+    factor_cache[pos] = factors[pos];
+    factor_cache[pos + m] = factors[pos + m];
+    __syncthreads();
+
+    T carry = 0.0;
+    for(int i = 1; i <= k; i++) {
+        const T* k_factors = factor_cache + m * (i - 1);
+        T factor = k_factors[pos];
+        T k_value = carries_cache[k - i];
+        carry += factor * k_value;
+    }
+
+    out_off[idx] += carry;
+}
+
+template<typename T>
+__global__ void fir_sos(
+        const int m, const int n, const int carries_stride, const int n_blocks,
+        const int offset, const T* sos, T* carries, T* out) {
+
+    extern __shared__ __align__(sizeof(T)) thrust::complex<double> fir_cc[1024 + 2];
+    T* fir_cache = reinterpret_cast<T*>(fir_cc);
+
+    extern __shared__ __align__(sizeof(T)) thrust::complex<double> fir_b[3];
+    T* b = reinterpret_cast<T*>(fir_b);
+
+    int idx = blockDim.x * (blockIdx.x % n_blocks) + threadIdx.x;
+    int row_num = blockIdx.x / n_blocks;
+    int n_group = idx / m;
+    int pos = idx % m;
+    const int k = 2;
+
+    T* out_row = out + row_num * n;
+    T* out_off = out_row + n_group * m;
+    T* carries_off = carries + row_num * carries_stride;
+    T* this_carries = carries_off + k * (n_group + (1 - offset));
+    T* group_carries = carries_off + (n_group - offset) * k;
+
+    if(pos <= k) {
+        b[pos] = sos[pos];
+    }
+
+    if(pos < k) {
+        if(offset && n_group == 0) {
+            fir_cache[pos] = 0;
+        } else {
+            fir_cache[pos] = group_carries[pos];
+        }
+    }
+
+    if(idx >= n) {
+        return;
+    }
+
+    fir_cache[pos + k] = out_off[pos];
+    __syncthreads();
+
+    T acc = 0.0;
+    for(int i = k; i >= 0; i--) {
+        acc += fir_cache[pos + i] * b[k - i];
+    }
+
+    out_off[pos] = acc;
+}
+"""  # NOQA
+
+IIR_MODULE = cupy.RawModule(
+    code=IIR_KERNEL, options=('-std=c++11',),
+    name_expressions=[f'compute_correction_factors<{x}, {y}>'
+                      for x, y in TYPE_PAIR_NAMES] +
+                     [f'correct_carries<{x}>' for x in TYPE_NAMES] +
+                     [f'first_pass_iir<{x}>' for x in TYPE_NAMES] +
+                     [f'second_pass_iir<{x}>' for x in TYPE_NAMES])
+
+IIR_SOS_MODULE = cupy.RawModule(
+    code=IIR_SOS_KERNEL, options=('-std=c++11',),
+    name_expressions=[f'compute_correction_factors_sos<{x}, {y}>'
+                      for x, y in TYPE_PAIR_NAMES] +
+    [f'pick_carries<{x}>' for x in TYPE_NAMES] +
+    [f'correct_carries_sos<{x}>' for x in TYPE_NAMES] +
+    [f'first_pass_iir_sos<{x}>' for x in TYPE_NAMES] +
+    [f'second_pass_iir_sos<{x}>' for x in TYPE_NAMES] +
+    [f'fir_sos<{x}>' for x in TYPE_NAMES])
+
+
+def _get_module_func(module, func_name, *template_args):
+    args_dtypes = [_get_typename(arg.dtype) for arg in template_args]
+    template = ', '.join(args_dtypes)
+    kernel_name = f'{func_name}<{template}>' if template_args else func_name
+    kernel = module.get_function(kernel_name)
+    return kernel
+
+
+def collapse_2d(x, axis):
+    x = cupy.moveaxis(x, axis, -1)
+    x_shape = x.shape
+    x = x.reshape(-1, x.shape[-1])
+    if not x.flags.c_contiguous:
+        x = x.copy()
+    return x, x_shape
+
+
+def collapse_2d_rest(x, axis):
+    x = cupy.moveaxis(x, axis + 1, -1)
+    x_shape = x.shape
+    x = x.reshape(x.shape[0], -1, x.shape[-1])
+    if not x.flags.c_contiguous:
+        x = x.copy()
+    return x, x_shape
+
+
+def compute_correction_factors(a, block_sz, dtype):
+    k = a.size
+    correction = cupy.eye(k, dtype=dtype)
+    correction = cupy.c_[
+        correction[::-1], cupy.empty((k, block_sz), dtype=dtype)]
+    corr_kernel = _get_module_func(
+        IIR_MODULE, 'compute_correction_factors', correction, a)
+    corr_kernel((k,), (1,), (block_sz, k, a, correction))
+    return correction
+
+
+def apply_iir(x, a, axis=-1, zi=None, dtype=None, block_sz=1024):
+    # GPU throughput is faster when using single precision floating point
+    # numbers
+    # x = x.astype(cupy.float32)
+    if dtype is None:
+        dtype = cupy.result_type(x.dtype, a.dtype)
+
+    a = a.astype(dtype)
+
+    if zi is not None:
+        zi = zi.astype(dtype)
+
+    x_shape = x.shape
+    x_ndim = x.ndim
+    axis = _normalize_axis_index(axis, x_ndim)
+    k = a.size
+    n = x_shape[axis]
+
+    if x_ndim > 1:
+        x, x_shape = collapse_2d(x, axis)
+        if zi is not None:
+            zi, _ = collapse_2d(zi, axis)
+
+    out = cupy.array(x, dtype=dtype, copy=True)
+
+    num_rows = 1 if x.ndim == 1 else x.shape[0]
+    n_blocks = (n + block_sz - 1) // block_sz
+    total_blocks = num_rows * n_blocks
+
+    correction = cupy.eye(k, dtype=dtype)
+    correction = cupy.c_[
+        correction[::-1], cupy.empty((k, block_sz), dtype=dtype)]
+    carries = cupy.empty(
+        (num_rows, n_blocks, k), dtype=dtype)
+
+    corr_kernel = _get_module_func(
+        IIR_MODULE, 'compute_correction_factors', correction, a)
+    first_pass_kernel = _get_module_func(IIR_MODULE, 'first_pass_iir', out)
+    second_pass_kernel = _get_module_func(IIR_MODULE, 'second_pass_iir', out)
+    carry_correction_kernel = _get_module_func(
+        IIR_MODULE, 'correct_carries', out)
+
+    corr_kernel((k,), (1,), (block_sz, k, a, correction))
+    first_pass_kernel((total_blocks,), (block_sz // 2,),
+                      (block_sz, k, n, n_blocks, (n_blocks) * k,
+                       correction, out, carries))
+
+    if zi is not None:
+        if zi.ndim == 1:
+            zi = cupy.broadcast_to(zi, (num_rows, 1, zi.size))
+        elif zi.ndim == 2:
+            zi = zi.reshape(num_rows, 1, zi.shape[-1])
+
+        if carries.size == 0:
+            carries = zi
+        else:
+            carries = cupy.concatenate((zi, carries), axis=1)
+
+        if not carries.flags.c_contiguous:
+            carries = carries.copy()
+
+    if n_blocks > 1 or zi is not None:
+        starting_group = int(zi is None)
+        blocks_to_merge = n_blocks - starting_group
+        carries_stride = (n_blocks + (1 - starting_group)) * k
+        carry_correction_kernel(
+            (num_rows,), (k,),
+            (block_sz, k, n_blocks, carries_stride, starting_group,
+             correction, carries))
+        second_pass_kernel(
+            (num_rows * blocks_to_merge,), (block_sz,),
+            (block_sz, k, n, carries_stride, blocks_to_merge,
+             starting_group, correction, carries, out))
+
+    if x_ndim > 1:
+        out = out.reshape(x_shape)
+        out = cupy.moveaxis(out, -1, axis)
+        if not out.flags.c_contiguous:
+            out = out.copy()
+
+    return out
+
+
+def compute_correction_factors_sos(sos, block_sz, dtype):
+    n_sections = sos.shape[0]
+    correction = cupy.empty((n_sections, 2, block_sz), dtype=dtype)
+    corr_kernel = _get_module_func(
+        IIR_SOS_MODULE, 'compute_correction_factors_sos', correction, sos)
+    corr_kernel((n_sections,), (2,), (block_sz, sos, correction))
+    return correction
+
+
+def apply_iir_sos(x, sos, axis=-1, zi=None, dtype=None, block_sz=1024,
+                  apply_fir=True, out=None):
+    if dtype is None:
+        dtype = cupy.result_type(x.dtype, sos.dtype)
+
+    sos = sos.astype(dtype)
+
+    if zi is not None:
+        zi = zi.astype(dtype)
+
+    x_shape = x.shape
+    x_ndim = x.ndim
+    n_sections = sos.shape[0]
+    axis = _normalize_axis_index(axis, x_ndim)
+    k = 2
+    n = x_shape[axis]
+    zi_shape = None
+
+    if x_ndim > 1:
+        x, x_shape = collapse_2d(x, axis)
+
+    if zi is not None:
+        zi, zi_shape = collapse_2d_rest(zi, axis)
+
+    if out is None:
+        out = cupy.array(x, dtype=dtype, copy=True)
+
+    num_rows = 1 if x.ndim == 1 else x.shape[0]
+    n_blocks = (n + block_sz - 1) // block_sz
+    total_blocks = num_rows * n_blocks
+
+    correction = compute_correction_factors_sos(sos, block_sz, dtype)
+    carries = cupy.empty(
+        (num_rows, n_blocks, k), dtype=dtype)
+    all_carries = carries
+    zi_out = None
+    if zi is not None:
+        zi_out = cupy.empty_like(zi)
+        all_carries = cupy.empty(
+            (num_rows, n_blocks + 1, k), dtype=dtype)
+
+    first_pass_kernel = _get_module_func(
+        IIR_SOS_MODULE, 'first_pass_iir_sos', out)
+    second_pass_kernel = _get_module_func(
+        IIR_SOS_MODULE, 'second_pass_iir_sos', out)
+    carry_correction_kernel = _get_module_func(
+        IIR_SOS_MODULE, 'correct_carries_sos', out)
+    fir_kernel = _get_module_func(IIR_SOS_MODULE, 'fir_sos', out)
+    carries_kernel = _get_module_func(IIR_SOS_MODULE, 'pick_carries', out)
+
+    starting_group = int(zi is None)
+    blocks_to_merge = n_blocks - starting_group
+    carries_stride = (n_blocks + (1 - starting_group)) * k
+
+    carries_kernel((num_rows * n_blocks,), (k,),
+                   (block_sz, n, carries_stride, n_blocks, starting_group,
+                    out, all_carries))
+
+    for s in range(n_sections):
+        b = sos[s]
+        if zi is not None:
+            section_zi = zi[s, :, :2]
+            all_carries[:, 0, :] = section_zi
+            zi_out[s, :, :2] = axis_slice(out, n - 2, n)
+
+        if apply_fir:
+            fir_kernel((num_rows * n_blocks,), (block_sz,),
+                       (block_sz, n, carries_stride, n_blocks, starting_group,
+                        b, all_carries, out))
+
+        first_pass_kernel(
+            (total_blocks,), (block_sz // 2,),
+            (block_sz, n, n_blocks, correction[s], out, carries))
+
+        if n_blocks > 1 or zi is not None:
+            if zi is not None:
+                section_zi = zi[s, :, 2:]
+                all_carries[:, 0, :] = section_zi
+                all_carries[:, 1:, :] = carries
+
+            carry_correction_kernel(
+                (num_rows,), (k,),
+                (block_sz, n_blocks, carries_stride, starting_group,
+                    correction[s], all_carries))
+            second_pass_kernel(
+                (num_rows * blocks_to_merge,), (block_sz,),
+                (block_sz, n, carries_stride, blocks_to_merge,
+                    starting_group, correction[s], all_carries, out))
+
+        if apply_fir:
+            carries_kernel(
+                (num_rows * n_blocks,), (k,),
+                (block_sz, n, carries_stride, n_blocks, starting_group,
+                 out, all_carries))
+
+        if zi is not None:
+            zi_out[s, :, 2:] = axis_slice(out, n - 2, n)
+
+    if x_ndim > 1:
+        out = out.reshape(x_shape)
+        out = cupy.moveaxis(out, -1, axis)
+        if not out.flags.c_contiguous:
+            out = out.copy()
+
+    if zi is not None:
+        zi_out = zi_out.reshape(zi_shape)
+        if len(zi_shape) > 2:
+            zi_out = cupy.moveaxis(zi_out, -1, axis)
+        if not zi_out.flags.c_contiguous:
+            zi_out = zi_out.copy()
+
+    if zi is not None:
+        return out, zi_out
+    return out

vllm/lib/python3.10/site-packages/cupyx/scipy/signal/_lti_conversion.py

@@ -0,0 +1,82 @@
+import cupy
+
+
+def _none_to_empty_2d(arg):
+    if arg is None:
+        return cupy.zeros((0, 0))
+    else:
+        return arg
+
+
+def _atleast_2d_or_none(arg):
+    if arg is not None:
+        return cupy.atleast_2d(arg)
+
+
+def _shape_or_none(M):
+    if M is not None:
+        return M.shape
+    else:
+        return (None,) * 2
+
+
+def _choice_not_none(*args):
+    for arg in args:
+        if arg is not None:
+            return arg
+
+
+def _restore(M, shape):
+    if M.shape == (0, 0):
+        return cupy.zeros(shape)
+    else:
+        if M.shape != shape:
+            raise ValueError("The input arrays have incompatible shapes.")
+        return M
+
+
+def abcd_normalize(A=None, B=None, C=None, D=None):
+    """Check state-space matrices and ensure they are 2-D.
+
+    If enough information on the system is provided, that is, enough
+    properly-shaped arrays are passed to the function, the missing ones
+    are built from this information, ensuring the correct number of
+    rows and columns. Otherwise a ValueError is raised.
+
+    Parameters
+    ----------
+    A, B, C, D : array_like, optional
+        State-space matrices. All of them are None (missing) by default.
+        See `ss2tf` for format.
+
+    Returns
+    -------
+    A, B, C, D : array
+        Properly shaped state-space matrices.
+
+    Raises
+    ------
+    ValueError
+        If not enough information on the system was provided.
+
+    """
+    A, B, C, D = map(_atleast_2d_or_none, (A, B, C, D))
+
+    MA, NA = _shape_or_none(A)
+    MB, NB = _shape_or_none(B)
+    MC, NC = _shape_or_none(C)
+    MD, ND = _shape_or_none(D)
+
+    p = _choice_not_none(MA, MB, NC)
+    q = _choice_not_none(NB, ND)
+    r = _choice_not_none(MC, MD)
+    if p is None or q is None or r is None:
+        raise ValueError("Not enough information on the system.")
+
+    A, B, C, D = map(_none_to_empty_2d, (A, B, C, D))
+    A = _restore(A, (p, p))
+    B = _restore(B, (p, q))
+    C = _restore(C, (r, p))
+    D = _restore(D, (r, q))
+
+    return A, B, C, D

vllm/lib/python3.10/site-packages/cupyx/scipy/signal/_max_len_seq.py

@@ -0,0 +1,119 @@
+import cupy
+
+
+_mls_taps = {2: [1], 3: [2], 4: [3], 5: [3], 6: [5], 7: [6], 8: [7, 6, 1],
+             9: [5], 10: [7], 11: [9], 12: [11, 10, 4], 13: [12, 11, 8],
+             14: [13, 12, 2], 15: [14], 16: [15, 13, 4], 17: [14],
+             18: [11], 19: [18, 17, 14], 20: [17], 21: [19], 22: [21],
+             23: [18], 24: [23, 22, 17], 25: [22], 26: [25, 24, 20],
+             27: [26, 25, 22], 28: [25], 29: [27], 30: [29, 28, 7],
+             31: [28], 32: [31, 30, 10]}
+
+
+MAX_LEN_SEQ_KERNEL = r"""
+#include <cupy/math_constants.h>
+#include <cupy/carray.cuh>
+#include <cupy/complex.cuh>
+
+extern "C" __global__ void max_len_seq(
+        long long length, long long n_taps, int n_state, long long* taps,
+        signed char* state, signed char* seq) {
+
+    int idx = blockDim.x * blockIdx.x + threadIdx.x;
+    for(long long i = 0; i < length; i++) {
+        signed char next_state = state[(idx + 1) % n_state];
+        if(idx == n_state - 1) {
+            seq[i] = state[0];
+            for(int n_tap = 0; n_tap < n_taps; n_tap++) {
+                long long tap = taps[n_tap];
+                next_state ^= state[tap];
+            }
+        }
+        state[idx] = next_state;
+    }
+}
+"""
+
+_max_len_seq = cupy.RawKernel(MAX_LEN_SEQ_KERNEL, 'max_len_seq')
+
+
+def max_len_seq(nbits, state=None, length=None, taps=None):
+    """
+    Maximum length sequence (MLS) generator.
+
+    Parameters
+    ----------
+    nbits : int
+        Number of bits to use. Length of the resulting sequence will
+        be ``(2**nbits) - 1``. Note that generating long sequences
+        (e.g., greater than ``nbits == 16``) can take a long time.
+    state : array_like, optional
+        If array, must be of length ``nbits``, and will be cast to binary
+        (bool) representation. If None, a seed of ones will be used,
+        producing a repeatable representation. If ``state`` is all
+        zeros, an error is raised as this is invalid. Default: None.
+    length : int, optional
+        Number of samples to compute. If None, the entire length
+        ``(2**nbits) - 1`` is computed.
+    taps : array_like, optional
+        Polynomial taps to use (e.g., ``[7, 6, 1]`` for an 8-bit sequence).
+        If None, taps will be automatically selected (for up to
+        ``nbits == 32``).
+
+    Returns
+    -------
+    seq : array
+        Resulting MLS sequence of 0's and 1's.
+    state : array
+        The final state of the shift register.
+
+    Notes
+    -----
+    The algorithm for MLS generation is generically described in:
+
+        https://en.wikipedia.org/wiki/Maximum_length_sequence
+
+    The default values for taps are specifically taken from the first
+    option listed for each value of ``nbits`` in:
+
+        https://web.archive.org/web/20181001062252/http://www.newwaveinstruments.com/resources/articles/m_sequence_linear_feedback_shift_register_lfsr.htm
+
+    """  # NOQA
+    if taps is None:
+        if nbits not in _mls_taps:
+            known_taps = cupy.array(list(_mls_taps.keys()))
+            raise ValueError('nbits must be between %s and %s if taps is None'
+                             % (known_taps.min(), known_taps.max()))
+        taps = cupy.array(_mls_taps[nbits], cupy.int64)
+    else:
+        taps = cupy.unique(cupy.array(taps, cupy.int64))[::-1]
+        if cupy.any(taps < 0) or cupy.any(taps > nbits) or taps.size < 1:
+            raise ValueError('taps must be non-empty with values between '
+                             'zero and nbits (inclusive)')
+        taps = cupy.array(taps)  # needed for Cython and Pythran
+
+    n_max = (2 ** nbits) - 1
+    if length is None:
+        length = n_max
+    else:
+        length = int(length)
+        if length < 0:
+            raise ValueError('length must be greater than or equal to 0')
+
+    # We use int8 instead of bool here because NumPy arrays of bools
+    # don't seem to work nicely with Cython
+    if state is None:
+        state = cupy.ones(nbits, dtype=cupy.int8, order='c')
+    else:
+        # makes a copy if need be, ensuring it's 0's and 1's
+        state = cupy.array(state, dtype=bool, order='c').astype(cupy.int8)
+    if state.ndim != 1 or state.size != nbits:
+        raise ValueError('state must be a 1-D array of size nbits')
+    if cupy.all(state == 0):
+        raise ValueError('state must not be all zeros')
+
+    seq = cupy.empty(length, dtype=cupy.int8, order='c')
+    n_taps = len(taps)
+
+    _max_len_seq((1,), (nbits,), (length, n_taps, nbits, taps, state, seq))
+    return seq, state