From 1201a5ef1cf1159d979666fd773befb47746062a Mon Sep 17 00:00:00 2001 From: jorenham Date: Wed, 25 Dec 2024 02:20:20 +0100 Subject: [PATCH 1/3] =?UTF-8?q?=F0=9F=8E=A8=20`=5Ftyping`:=20rename=20`Cor?= =?UTF-8?q?relateMode`=20to=20`ConvMode`?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- scipy-stubs/_typing.pyi | 4 ++-- scipy-stubs/linalg/_special_matrices.pyi | 20 ++++++++++---------- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/scipy-stubs/_typing.pyi b/scipy-stubs/_typing.pyi index 6b7b1c72..80f69192 100644 --- a/scipy-stubs/_typing.pyi +++ b/scipy-stubs/_typing.pyi @@ -17,7 +17,7 @@ __all__ = [ "AnyShape", "ByteOrder", "Casting", - "CorrelateMode", + "ConvMode", "EnterNoneMixin", "EnterSelfMixin", "FileLike", @@ -102,7 +102,7 @@ ByteOrder: TypeAlias = Literal["S", "<", "little", ">", "big", "=", "native", "| OrderCF: TypeAlias = Literal["C", "F"] OrderKACF: TypeAlias = Literal["K", "A", OrderCF] Casting: TypeAlias = Literal["no", "equiv", "safe", "same_kind", "unsafe"] -CorrelateMode: TypeAlias = Literal["valid", "same", "full"] +ConvMode: TypeAlias = Literal["valid", "same", "full"] # scipy literals NanPolicy: TypeAlias = Literal["raise", "propagate", "omit"] diff --git a/scipy-stubs/linalg/_special_matrices.pyi b/scipy-stubs/linalg/_special_matrices.pyi index eedf7d71..0b1071f8 100644 --- a/scipy-stubs/linalg/_special_matrices.pyi +++ b/scipy-stubs/linalg/_special_matrices.pyi @@ -6,7 +6,7 @@ import numpy as np import numpy.typing as npt import optype.numpy as onp import optype.typing as opt -from scipy._typing import CorrelateMode +from scipy._typing import ConvMode __all__ = [ "block_diag", @@ -148,23 +148,23 @@ def companion(a: _ToArrayNd[_SCT]) -> _Array2dPlus[_SCT]: ... # @overload -def convolution_matrix(a: _JustInt1d, n: onp.ToInt, mode: CorrelateMode = "full") -> _Int2d: ... +def convolution_matrix(a: _JustInt1d, n: onp.ToInt, mode: ConvMode = "full") -> _Int2d: ... @overload -def convolution_matrix(a: _JustInt2dPlus, n: onp.ToInt, mode: CorrelateMode = "full") -> _Int3dPlus: ... +def convolution_matrix(a: _JustInt2dPlus, n: onp.ToInt, mode: ConvMode = "full") -> _Int3dPlus: ... @overload -def convolution_matrix(a: _JustFloat1d, n: onp.ToInt, mode: CorrelateMode = "full") -> _Float2d: ... +def convolution_matrix(a: _JustFloat1d, n: onp.ToInt, mode: ConvMode = "full") -> _Float2d: ... @overload -def convolution_matrix(a: _JustFloat2dPlus, n: onp.ToInt, mode: CorrelateMode = "full") -> _Float3dPlus: ... +def convolution_matrix(a: _JustFloat2dPlus, n: onp.ToInt, mode: ConvMode = "full") -> _Float3dPlus: ... @overload -def convolution_matrix(a: _JustComplex1d, n: onp.ToInt, mode: CorrelateMode = "full") -> _Complex2d: ... +def convolution_matrix(a: _JustComplex1d, n: onp.ToInt, mode: ConvMode = "full") -> _Complex2d: ... @overload -def convolution_matrix(a: _JustComplex2dPlus, n: onp.ToInt, mode: CorrelateMode = "full") -> _Complex3dPlus: ... +def convolution_matrix(a: _JustComplex2dPlus, n: onp.ToInt, mode: ConvMode = "full") -> _Complex3dPlus: ... @overload -def convolution_matrix(a: _ToArrayStrict1d[_SCT], n: onp.ToInt, mode: CorrelateMode = "full") -> _Array2d[_SCT]: ... +def convolution_matrix(a: _ToArrayStrict1d[_SCT], n: onp.ToInt, mode: ConvMode = "full") -> _Array2d[_SCT]: ... @overload -def convolution_matrix(a: _ToArrayStrict1dPlus[_SCT], n: onp.ToInt, mode: CorrelateMode = "full") -> _Array3dPlus[_SCT]: ... +def convolution_matrix(a: _ToArrayStrict1dPlus[_SCT], n: onp.ToInt, mode: ConvMode = "full") -> _Array3dPlus[_SCT]: ... @overload -def convolution_matrix(a: _ToArrayNd[_SCT], n: onp.ToInt, mode: CorrelateMode = "full") -> _Array2dPlus[_SCT]: ... +def convolution_matrix(a: _ToArrayNd[_SCT], n: onp.ToInt, mode: ConvMode = "full") -> _Array2dPlus[_SCT]: ... # @overload From 6d2db1d59a64de37010f3e90f375576a628a434e Mon Sep 17 00:00:00 2001 From: jorenham Date: Sat, 28 Dec 2024 21:46:15 +0100 Subject: [PATCH 2/3] =?UTF-8?q?=F0=9F=8E=A8=20`signal`:=20code=20simplicif?= =?UTF-8?q?actions=20related=20to=20`window`?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- scipy-stubs/signal/_short_time_fft.pyi | 65 ++++--- scipy-stubs/signal/_spectral_py.pyi | 44 ++--- scipy-stubs/signal/windows/_windows.pyi | 249 ++++++++++-------------- 3 files changed, 155 insertions(+), 203 deletions(-) diff --git a/scipy-stubs/signal/_short_time_fft.pyi b/scipy-stubs/signal/_short_time_fft.pyi index a44460d0..205d4157 100644 --- a/scipy-stubs/signal/_short_time_fft.pyi +++ b/scipy-stubs/signal/_short_time_fft.pyi @@ -1,13 +1,24 @@ from collections.abc import Callable from typing import Any, Literal, TypeAlias -from typing_extensions import Self, Unpack +from typing_extensions import Self import numpy as np import optype.numpy as onp -from .windows._windows import _Window, _WindowNeedsParams +from .windows._windows import _ToWindow __all__ = ["ShortTimeFFT"] +_InexactND: TypeAlias = onp.ArrayND[np.inexact[Any]] + +_ScaleTo: TypeAlias = Literal["magnitude", "psd"] +_Detr: TypeAlias = ( + Literal["linear", "constant"] + | Callable[[onp.ArrayND[np.float64]], onp.ToComplexND] + | Callable[[onp.ArrayND[np.complex128]], onp.ToComplexND] +) + +### + # awkward naming, but this matches the "attempts at type-aliases" in the implementation PAD_TYPE: TypeAlias = Literal["zeros", "edge", "even", "odd"] FFT_MODE_TYPE: TypeAlias = Literal["twosided", "centered", "onesided", "onesided2X"] @@ -16,32 +27,32 @@ class ShortTimeFFT: def __init__( self, /, - win: onp.ArrayND[np.inexact[Any]], + win: _InexactND, hop: int, fs: float, *, fft_mode: FFT_MODE_TYPE = "onesided", mfft: int | None = None, - dual_win: onp.ArrayND[np.inexact[Any]] | None = None, - scale_to: Literal["magnitude", "psd"] | None = None, + dual_win: _InexactND | None = None, + scale_to: _ScaleTo | None = None, phase_shift: int | None = 0, ) -> None: ... @classmethod def from_dual( cls, - dual_win: onp.ArrayND[np.inexact[Any]], + dual_win: _InexactND, hop: int, fs: float, *, fft_mode: FFT_MODE_TYPE = "onesided", mfft: int | None = None, - scale_to: Literal["magnitude", "psd"] | None = None, + scale_to: _ScaleTo | None = None, phase_shift: int | None = 0, ) -> Self: ... @classmethod def from_window( cls, - win_param: _Window | onp.ToFloat | tuple[_Window | _WindowNeedsParams, Unpack[tuple[object, ...]]], + win_param: _ToWindow, fs: float, nperseg: int, noverlap: int, @@ -49,11 +60,11 @@ class ShortTimeFFT: symmetric_win: bool = False, fft_mode: FFT_MODE_TYPE = "onesided", mfft: int | None = None, - scale_to: Literal["magnitude", "psd"] | None = None, + scale_to: _ScaleTo | None = None, phase_shift: int | None = 0, ) -> Self: ... @property - def win(self, /) -> onp.ArrayND[np.inexact[Any]]: ... + def win(self, /) -> _InexactND: ... @property def hop(self, /) -> int: ... @property @@ -73,8 +84,8 @@ class ShortTimeFFT: @mfft.setter def mfft(self, /, n_: int) -> None: ... @property - def scaling(self, /) -> Literal["magnitude", "psd"] | None: ... - def scale_to(self, /, scaling: Literal["magnitude", "psd"]) -> None: ... + def scaling(self, /) -> _ScaleTo | None: ... + def scale_to(self, /, scaling: _ScaleTo) -> None: ... @property def phase_shift(self, /) -> int | None: ... @phase_shift.setter @@ -82,55 +93,53 @@ class ShortTimeFFT: def stft( self, /, - x: onp.ArrayND[np.inexact[Any]], + x: _InexactND, p0: int | None = None, p1: int | None = None, *, k_offset: int = 0, padding: PAD_TYPE = "zeros", axis: int = -1, - ) -> onp.ArrayND[np.inexact[Any]]: ... + ) -> _InexactND: ... def stft_detrend( self, /, - x: onp.ArrayND[np.inexact[Any]], - detr: Callable[[onp.ArrayND[np.inexact[Any]]], onp.ArrayND[np.inexact[Any]]] | Literal["linear", "constant"] | None, + x: _InexactND, + detr: _Detr | None, p0: int | None = None, p1: int | None = None, *, k_offset: int = 0, padding: PAD_TYPE = "zeros", axis: int = -1, - ) -> onp.ArrayND[np.inexact[Any]]: ... + ) -> _InexactND: ... def spectrogram( self, /, - x: onp.ArrayND[np.inexact[Any]], - y: onp.ArrayND[np.inexact[Any]] | None = None, - detr: Callable[[onp.ArrayND[np.inexact[Any]]], onp.ArrayND[np.inexact[Any]]] - | Literal["linear", "constant"] - | None = None, + x: _InexactND, + y: _InexactND | None = None, + detr: _Detr | None = None, *, p0: int | None = None, p1: int | None = None, k_offset: int = 0, padding: PAD_TYPE = "zeros", axis: int = -1, - ) -> onp.ArrayND[np.inexact[Any]]: ... + ) -> _InexactND: ... @property - def dual_win(self, /) -> onp.ArrayND[np.inexact[Any]]: ... + def dual_win(self, /) -> _InexactND: ... @property def invertible(self, /) -> bool: ... def istft( self, /, - S: onp.ArrayND[np.inexact[Any]], + S: _InexactND, k0: int = 0, k1: int | None = None, *, f_axis: int = -2, t_axis: int = -1, - ) -> onp.ArrayND[np.inexact[Any]]: ... + ) -> _InexactND: ... @property def fac_magnitude(self, /) -> float: ... @property @@ -152,7 +161,7 @@ class ShortTimeFFT: @property def delta_t(self, /) -> float: ... def p_range(self, /, n: int, p0: int | None = None, p1: int | None = None) -> tuple[int, int]: ... - def t(self, /, n: int, p0: int | None = None, p1: int | None = None, k_offset: int = 0) -> onp.ArrayND[np.inexact[Any]]: ... + def t(self, /, n: int, p0: int | None = None, p1: int | None = None, k_offset: int = 0) -> _InexactND: ... def nearest_k_p(self, /, k: int, left: bool = True) -> int: ... @property def delta_f(self, /) -> float: ... @@ -161,7 +170,7 @@ class ShortTimeFFT: @property def onesided_fft(self, /) -> bool: ... @property - def f(self, /) -> onp.ArrayND[np.inexact[Any]]: ... + def f(self, /) -> _InexactND: ... def extent( self, /, diff --git a/scipy-stubs/signal/_spectral_py.pyi b/scipy-stubs/signal/_spectral_py.pyi index 83d6e316..7f1b405d 100644 --- a/scipy-stubs/signal/_spectral_py.pyi +++ b/scipy-stubs/signal/_spectral_py.pyi @@ -1,32 +1,18 @@ from collections.abc import Callable from typing import Literal, TypeAlias, overload -from typing_extensions import Unpack import numpy as np import optype as op import optype.numpy as onp -from .windows._windows import _Window, _WindowNeedsParams +from .windows._windows import _ToWindow -__all__ = [ - "check_COLA", - "check_NOLA", - "coherence", - "csd", - "istft", - "lombscargle", - "periodogram", - "spectrogram", - "stft", - "welch", -] +__all__ = ["check_COLA", "check_NOLA", "coherence", "csd", "istft", "lombscargle", "periodogram", "spectrogram", "stft", "welch"] _Float1D: TypeAlias = onp.Array1D[np.float64] _FloatND: TypeAlias = onp.ArrayND[np.float64] _FloatingND: TypeAlias = onp.ArrayND[np.float32 | np.float64 | np.longdouble] _CFloatingND: TypeAlias = onp.ArrayND[np.complex64 | np.complex128 | np.clongdouble] -_GetWindowArgument: TypeAlias = _Window | tuple[_Window | _WindowNeedsParams, Unpack[tuple[object, ...]]] -_WindowLike: TypeAlias = _GetWindowArgument | onp.ToFloat1D _Detrend: TypeAlias = Literal["literal", "constant", False] | Callable[[onp.ArrayND], onp.ArrayND] _Scaling: TypeAlias = Literal["density", "spectrum"] _LegacyScaling: TypeAlias = Literal["psd", "spectrum"] @@ -50,7 +36,7 @@ def lombscargle( def periodogram( x: onp.ToComplexND, fs: onp.ToFloat = 1.0, - window: _WindowLike | None = "boxcar", + window: _ToWindow | None = "boxcar", nfft: onp.ToInt | None = None, detrend: _Detrend = "constant", return_onesided: op.CanBool = True, @@ -62,7 +48,7 @@ def periodogram( def welch( x: onp.ToComplexND, fs: onp.ToFloat = 1.0, - window: _WindowLike = "hann", + window: _ToWindow = "hann", nperseg: onp.ToInt | None = None, noverlap: onp.ToInt | None = None, nfft: onp.ToInt | None = None, @@ -78,7 +64,7 @@ def csd( x: onp.ToComplexND, y: onp.ToComplexND, fs: onp.ToFloat = 1.0, - window: _WindowLike = "hann", + window: _ToWindow = "hann", nperseg: onp.ToInt | None = None, noverlap: onp.ToInt | None = None, nfft: onp.ToInt | None = None, @@ -94,7 +80,7 @@ def csd( def spectrogram( x: onp.ToComplexND, fs: onp.ToFloat = 1.0, - window: _WindowLike = ("tukey", 0.25), + window: _ToWindow = ("tukey", 0.25), nperseg: onp.ToInt | None = None, noverlap: onp.ToInt | None = None, nfft: onp.ToInt | None = None, @@ -108,7 +94,7 @@ def spectrogram( def spectrogram( x: onp.ToComplexND, fs: onp.ToFloat, - window: _WindowLike, + window: _ToWindow, nperseg: onp.ToInt | None, noverlap: onp.ToInt | None, nfft: onp.ToInt | None, @@ -122,7 +108,7 @@ def spectrogram( def spectrogram( x: onp.ToComplexND, fs: onp.ToFloat = 1.0, - window: _WindowLike = ("tukey", 0.25), + window: _ToWindow = ("tukey", 0.25), nperseg: onp.ToInt | None = None, noverlap: onp.ToInt | None = None, nfft: onp.ToInt | None = None, @@ -135,14 +121,14 @@ def spectrogram( ) -> tuple[_FloatND, _FloatND, _CFloatingND]: ... # -def check_COLA(window: _WindowLike, nperseg: onp.ToInt, noverlap: onp.ToInt, tol: onp.ToFloat = 1e-10) -> np.bool_: ... -def check_NOLA(window: _WindowLike, nperseg: onp.ToInt, noverlap: onp.ToInt, tol: onp.ToFloat = 1e-10) -> np.bool_: ... +def check_COLA(window: _ToWindow, nperseg: onp.ToInt, noverlap: onp.ToInt, tol: onp.ToFloat = 1e-10) -> np.bool_: ... +def check_NOLA(window: _ToWindow, nperseg: onp.ToInt, noverlap: onp.ToInt, tol: onp.ToFloat = 1e-10) -> np.bool_: ... # def stft( x: onp.ToComplexND, fs: onp.ToFloat = 1.0, - window: _WindowLike = "hann", + window: _ToWindow = "hann", nperseg: onp.ToInt = 256, noverlap: onp.ToInt | None = None, nfft: onp.ToInt | None = None, @@ -159,7 +145,7 @@ def stft( def istft( Zxx: onp.ToComplexND, fs: onp.ToFloat = 1.0, - window: _WindowLike = "hann", + window: _ToWindow = "hann", nperseg: onp.ToInt | None = None, noverlap: onp.ToInt | None = None, nfft: onp.ToInt | None = None, @@ -173,7 +159,7 @@ def istft( def istft( Zxx: onp.ToComplexND, fs: onp.ToFloat, - window: _WindowLike, + window: _ToWindow, nperseg: onp.ToInt | None, noverlap: onp.ToInt | None, nfft: onp.ToInt | None, @@ -187,7 +173,7 @@ def istft( def istft( Zxx: onp.ToComplexND, fs: onp.ToFloat = 1.0, - window: _WindowLike = "hann", + window: _ToWindow = "hann", nperseg: onp.ToInt | None = None, noverlap: onp.ToInt | None = None, nfft: onp.ToInt | None = None, @@ -204,7 +190,7 @@ def coherence( x: onp.ToComplexND, y: onp.ToComplexND, fs: onp.ToFloat = 1.0, - window: _WindowLike = "hann", + window: _ToWindow = "hann", nperseg: onp.ToInt | None = None, noverlap: onp.ToInt | None = None, nfft: onp.ToInt | None = None, diff --git a/scipy-stubs/signal/windows/_windows.pyi b/scipy-stubs/signal/windows/_windows.pyi index 6b26b349..67c3d492 100644 --- a/scipy-stubs/signal/windows/_windows.pyi +++ b/scipy-stubs/signal/windows/_windows.pyi @@ -1,6 +1,5 @@ -from collections.abc import Sequence -from typing import Any, Literal, TypeAlias, overload -from typing_extensions import Unpack +from typing import Literal, TypeAlias, overload +from typing_extensions import TypeAliasType import numpy as np import optype as op @@ -35,189 +34,147 @@ __all__ = [ "tukey", ] -_Array_f8_1d: TypeAlias = onp.Array1D[np.float64] -_Array_f8_2d: TypeAlias = onp.Array2D[np.float64] -_Weights: TypeAlias = Sequence[onp.ToFloat] | onp.ArrayND[np.floating[Any]] | onp.ArrayND[np.integer[Any]] | onp.ArrayND[np.bool_] +_Float1D: TypeAlias = onp.Array1D[np.float64] +_Float2D: TypeAlias = onp.Array2D[np.float64] _Norm: TypeAlias = Literal[2, "approximate", "subsample"] -_WindowLength: TypeAlias = int | np.int16 | np.int32 | np.int64 -_Window: TypeAlias = Literal[ - "barthann", - "brthan", - "bth", - "bartlett", - "bart", - "brt", - "blackman", - "black", - "blk", - "blackmanharris", - "blackharr", - "bkh", - "bohman", - "bman", - "bmn", - "boxcar", - "box", - "ones", - "rect", - "rectangular", - "cosine", - "halfcosine", - "exponential", - "poisson", - "flattop", - "flat", - "flt", - "hamming", - "hamm", - "ham", - "hann", - "han", - "lanczos", - "sinc", - "nuttall", - "nutl", - "nut", - "parzen", - "parz", - "par", - "taylor", - "taylorwin", - "triangle", - "triang", - "tri", - "tukey", - "tuk", -] -_WindowNeedsParams: TypeAlias = Literal[ - "chebwin", - "cheb", +_ToM: TypeAlias = int | np.int16 | np.int32 | np.int64 +_WindowName0: TypeAlias = Literal[ + "barthann", "brthan", "bth", + "bartlett", "bart", "brt", + "blackman", "black", "blk", + "blackmanharris", "blackharr", "bkh", + "bohman", "bman", "bmn", + "boxcar", "box", "ones", "rect", "rectangular", + "cosine", "halfcosine", + "exponential", "poisson", + "flattop", "flat", "flt", + "hamming", "hamm", "ham", + "hann", "han", + "lanczos", "sinc", + "nuttall", "nutl", "nut", + "parzen", "parz", "par", + "taylor", "taylorwin", + "triangle", "triang", "tri", + "tukey", "tuk", +] # fmt: skip +_WindowName1: TypeAlias = Literal[ + "chebwin", "cheb", "dpss", - "gaussian", - "gauss", - "gss", - "general cosine", - "general_cosine", - "general gaussian", - "general_gaussian", - "general gauss", - "general_gauss", - "ggs", - "general hamming", - "general_hamming", - "kaiser", - "ksr", - "kaiser bessel derived", - "kbd", -] + "exponential", "poisson", + "gaussian", "gauss", "gss", + "general hamming", "general_hamming", + "kaiser", "ksr", + "kaiser bessel derived", "kbd", + "tukey", "tuk", +] # fmt: skip +_WindowName2: TypeAlias = Literal[ + "general gaussian", "general_gaussian", "general gauss", "general_gauss", "ggs", + "exponential", "poisson", +] # fmt: skip +_WindowName_taylor: TypeAlias = Literal["taylor", "taylorwin"] +_WindowName_gencos: TypeAlias = Literal["general cosine", "general_cosine"] -def general_cosine(M: _WindowLength, a: _Weights, sym: op.CanBool = True) -> _Array_f8_1d: ... -def boxcar(M: _WindowLength, sym: op.CanBool = True) -> _Array_f8_1d: ... -def triang(M: _WindowLength, sym: op.CanBool = True) -> _Array_f8_1d: ... -def parzen(M: _WindowLength, sym: op.CanBool = True) -> _Array_f8_1d: ... -def bohman(M: _WindowLength, sym: op.CanBool = True) -> _Array_f8_1d: ... -def blackman(M: _WindowLength, sym: op.CanBool = True) -> _Array_f8_1d: ... -def nuttall(M: _WindowLength, sym: op.CanBool = True) -> _Array_f8_1d: ... -def blackmanharris(M: _WindowLength, sym: op.CanBool = True) -> _Array_f8_1d: ... -def flattop(M: _WindowLength, sym: op.CanBool = True) -> _Array_f8_1d: ... -def bartlett(M: _WindowLength, sym: op.CanBool = True) -> _Array_f8_1d: ... -def hann(M: _WindowLength, sym: op.CanBool = True) -> _Array_f8_1d: ... -def tukey(M: _WindowLength, alpha: onp.ToFloat = 0.5, sym: op.CanBool = True) -> _Array_f8_1d: ... -def barthann(M: _WindowLength, sym: op.CanBool = True) -> _Array_f8_1d: ... -def general_hamming(M: _WindowLength, alpha: onp.ToFloat, sym: op.CanBool = True) -> _Array_f8_1d: ... -def hamming(M: _WindowLength, sym: op.CanBool = True) -> _Array_f8_1d: ... -def kaiser(M: _WindowLength, beta: onp.ToFloat, sym: op.CanBool = True) -> _Array_f8_1d: ... -def kaiser_bessel_derived(M: _WindowLength, beta: onp.ToFloat, *, sym: op.CanBool = True) -> _Array_f8_1d: ... -def gaussian(M: _WindowLength, std: onp.ToFloat, sym: op.CanBool = True) -> _Array_f8_1d: ... -def general_gaussian(M: _WindowLength, p: onp.ToFloat, sig: onp.ToFloat, sym: op.CanBool = True) -> _Array_f8_1d: ... -def chebwin(M: _WindowLength, at: onp.ToFloat, sym: op.CanBool = True) -> _Array_f8_1d: ... -def cosine(M: _WindowLength, sym: op.CanBool = True) -> _Array_f8_1d: ... -def exponential( - M: _WindowLength, - center: onp.ToFloat | None = None, - tau: onp.ToFloat = 1.0, - sym: op.CanBool = True, -) -> _Array_f8_1d: ... -def taylor( - M: _WindowLength, - nbar: onp.ToInt = 4, - sll: onp.ToInt = 30, - norm: op.CanBool = True, - sym: op.CanBool = True, -) -> _Array_f8_1d: ... -def lanczos(M: _WindowLength, *, sym: op.CanBool = True) -> _Array_f8_1d: ... +_ToWindow = TypeAliasType( + "_ToWindow", + onp.ToFloat + | _WindowName0 + | tuple[_WindowName0] + | tuple[_WindowName1, onp.ToFloat] + | tuple[_WindowName2, onp.ToFloat1D, onp.ToFloat1D] + | tuple[_WindowName_taylor, onp.ToInt] + | tuple[_WindowName_taylor, onp.ToInt, onp.ToInt] + | tuple[_WindowName_taylor, onp.ToInt, onp.ToInt, op.CanBool] + | tuple[_WindowName_gencos, onp.ToFloat1D] + | tuple[Literal["dpss"], onp.ToFloat, op.CanIndex], +) + +### + +def get_window(window: _ToWindow, Nx: _ToM, fftbins: op.CanBool = True) -> _Float1D: ... + +# +def barthann(M: _ToM, sym: op.CanBool = True) -> _Float1D: ... +def bartlett(M: _ToM, sym: op.CanBool = True) -> _Float1D: ... +def blackman(M: _ToM, sym: op.CanBool = True) -> _Float1D: ... +def blackmanharris(M: _ToM, sym: op.CanBool = True) -> _Float1D: ... +def bohman(M: _ToM, sym: op.CanBool = True) -> _Float1D: ... +def boxcar(M: _ToM, sym: op.CanBool = True) -> _Float1D: ... +def cosine(M: _ToM, sym: op.CanBool = True) -> _Float1D: ... +def flattop(M: _ToM, sym: op.CanBool = True) -> _Float1D: ... +def hamming(M: _ToM, sym: op.CanBool = True) -> _Float1D: ... +def hann(M: _ToM, sym: op.CanBool = True) -> _Float1D: ... +def lanczos(M: _ToM, *, sym: op.CanBool = True) -> _Float1D: ... +def nuttall(M: _ToM, sym: op.CanBool = True) -> _Float1D: ... +def parzen(M: _ToM, sym: op.CanBool = True) -> _Float1D: ... +def triang(M: _ToM, sym: op.CanBool = True) -> _Float1D: ... + +# +def exponential(M: _ToM, center: onp.ToFloat | None = None, tau: onp.ToFloat = 1.0, sym: op.CanBool = True) -> _Float1D: ... +def taylor(M: _ToM, nbar: onp.ToInt = 4, sll: onp.ToInt = 30, norm: op.CanBool = True, sym: op.CanBool = True) -> _Float1D: ... +def tukey(M: _ToM, alpha: onp.ToFloat = 0.5, sym: op.CanBool = True) -> _Float1D: ... -# Overloads where `return_ratios` is `False`. -@overload +# +def chebwin(M: _ToM, at: onp.ToFloat, sym: op.CanBool = True) -> _Float1D: ... +def gaussian(M: _ToM, std: onp.ToFloat, sym: op.CanBool = True) -> _Float1D: ... +def general_cosine(M: _ToM, a: onp.ToFloat1D, sym: op.CanBool = True) -> _Float1D: ... +def general_hamming(M: _ToM, alpha: onp.ToFloat, sym: op.CanBool = True) -> _Float1D: ... +def general_gaussian(M: _ToM, p: onp.ToFloat, sig: onp.ToFloat, sym: op.CanBool = True) -> _Float1D: ... +def kaiser(M: _ToM, beta: onp.ToFloat, sym: op.CanBool = True) -> _Float1D: ... +def kaiser_bessel_derived(M: _ToM, beta: onp.ToFloat, *, sym: op.CanBool = True) -> _Float1D: ... +@overload # `return_ratios` is `False` def dpss( - M: _WindowLength, + M: _ToM, NW: onp.ToFloat, Kmax: op.CanIndex, sym: op.CanBool = True, norm: _Norm | None = None, return_ratios: Literal[False] = False, -) -> _Array_f8_2d: ... -@overload +) -> _Float2D: ... +@overload # `return_ratios` is `False`. def dpss( - M: _WindowLength, + M: _ToM, NW: onp.ToFloat, Kmax: None = None, sym: op.CanBool = True, norm: _Norm | None = None, return_ratios: Literal[False] = False, -) -> _Array_f8_1d: ... - -# Overloads where `return_ratios` is `True`. -# `return_ratios` as a positional argument -@overload +) -> _Float1D: ... +@overload # `return_ratios` is `True`, `return_ratios` as a positional argument def dpss( - M: _WindowLength, + M: _ToM, NW: onp.ToFloat, Kmax: op.CanIndex, sym: op.CanBool, norm: _Norm | None, return_ratios: Literal[True], -) -> tuple[_Array_f8_2d, _Array_f8_1d]: ... - -# `return_ratios` as a keyword argument -@overload +) -> tuple[_Float2D, _Float1D]: ... +@overload # `return_ratios` as a keyword argument def dpss( - M: _WindowLength, + M: _ToM, NW: onp.ToFloat, Kmax: op.CanIndex, sym: op.CanBool = True, norm: _Norm | None = None, *, return_ratios: Literal[True], -) -> tuple[_Array_f8_2d, _Array_f8_1d]: ... - -# `return_ratios` as a positional argument -@overload +) -> tuple[_Float2D, _Float1D]: ... +@overload # `return_ratios` as a positional argument def dpss( - M: _WindowLength, + M: _ToM, NW: onp.ToFloat, Kmax: None, sym: op.CanBool, norm: _Norm | None, return_ratios: Literal[True], -) -> tuple[_Array_f8_1d, np.float64]: ... - -# `return_ratios` as a keyword argument -@overload +) -> tuple[_Float1D, np.float64]: ... +@overload # `return_ratios` as a keyword argument def dpss( - M: _WindowLength, + M: _ToM, NW: onp.ToFloat, Kmax: None = None, sym: op.CanBool = True, norm: _Norm | None = None, *, return_ratios: Literal[True], -) -> tuple[_Array_f8_1d, np.float64]: ... - -# -def get_window( - window: _Window | onp.ToFloat | tuple[_Window | _WindowNeedsParams, Unpack[tuple[object, ...]]], - Nx: _WindowLength, - fftbins: op.CanBool = True, -) -> _Array_f8_1d: ... +) -> tuple[_Float1D, np.float64]: ... From 5b03c74a39b814ebaa26fe4c100c006a7203a499 Mon Sep 17 00:00:00 2001 From: jorenham Date: Sat, 28 Dec 2024 22:00:01 +0100 Subject: [PATCH 3/3] =?UTF-8?q?=E2=9C=A8=20`signal`:=20complete=20`=5Fsign?= =?UTF-8?q?altools`?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- scipy-stubs/signal/_signaltools.pyi | 773 ++++++++++++++++++++++++---- 1 file changed, 667 insertions(+), 106 deletions(-) diff --git a/scipy-stubs/signal/_signaltools.pyi b/scipy-stubs/signal/_signaltools.pyi index ca7d8804..b8dc53d7 100644 --- a/scipy-stubs/signal/_signaltools.pyi +++ b/scipy-stubs/signal/_signaltools.pyi @@ -1,9 +1,12 @@ -from typing import Any, Literal, TypeAlias, overload +from collections.abc import Callable, Sequence +from typing import Any, Literal as L, TypeAlias, TypedDict, TypeVar, overload, type_check_only import numpy as np +import optype as op import optype.numpy as onp -from scipy._typing import CorrelateMode, Untyped, UntypedArray +from scipy._typing import ConvMode from ._ltisys import dlti +from .windows._windows import _ToWindow __all__ = [ "choose_conv_method", @@ -41,163 +44,721 @@ __all__ = [ "wiener", ] -_CorrelateMethod: TypeAlias = Literal["auto", "direct", "fft"] -_BoundaryConditions: TypeAlias = Literal["fill", "wrap", "symm"] -_ResidueType: TypeAlias = Literal["avg", "min", "max"] -_RootType: TypeAlias = Literal[_ResidueType, "maximum", "avg", "mean"] -_Domain: TypeAlias = Literal["time", "freq"] -_TrendType: TypeAlias = Literal["linear", "constant"] -_PadType: TypeAlias = Literal["constant", "line", "mean", "median", "maximum", "minimum", "symmetric", "reflect", "edge", "wrap"] -_FiltFiltPadType: TypeAlias = Literal["odd", "even", "constant"] -_ResidualKind: TypeAlias = Literal["lowpass", "all"] -_FilterType: TypeAlias = Literal["iir", "fir"] | dlti +### + +_T = TypeVar("_T") +_InexactT = TypeVar("_InexactT", bound=np.inexact[Any]) +_EnvelopeSCT = TypeVar("_EnvelopeSCT", bound=_OutFloat | np.longdouble | _Complex | np.clongdouble) +_FilterSCT = TypeVar("_FilterSCT", bound=_Int | _Float) +_ShapeT = TypeVar("_ShapeT", bound=tuple[int, ...]) +_AnyShapeT = TypeVar("_AnyShapeT", tuple[int], tuple[int, int], tuple[int, int, int], tuple[int, ...]) + +_Tuple2: TypeAlias = tuple[_T, _T] + +_Falsy: TypeAlias = L[False, 0] +_Truthy: TypeAlias = L[True, 1] + +_ConvMethod: TypeAlias = L["direct", "fft"] +_ToConvMethod: TypeAlias = L["auto", _ConvMethod] +_BoundaryConditions: TypeAlias = L["fill", "wrap", "symm"] +_ResidueType: TypeAlias = L["avg", "min", "max"] +_RootType: TypeAlias = L[_ResidueType, "maximum", "avg", "mean"] +_Domain: TypeAlias = L["time", "freq"] +_TrendType: TypeAlias = L["linear", "constant"] +_PadType: TypeAlias = L["constant", "line", "mean", "median", "maximum", "minimum", "symmetric", "reflect", "edge", "wrap"] +_FiltFiltPadType: TypeAlias = L["odd", "even", "constant"] | None +_FiltFiltMethod: TypeAlias = L["pad", "gust"] +_ResidualKind: TypeAlias = L["lowpass", "all"] +_FilterType: TypeAlias = L["iir", "fir"] | dlti + +_Bool: TypeAlias = np.bool_ +_CoBool: TypeAlias = _Bool +_ToBool: TypeAlias = bool | _CoBool +_ToBoolND: TypeAlias = onp.CanArrayND[_CoBool] | onp.SequenceND[_ToBool] | onp.SequenceND[onp.CanArrayND[_CoBool]] + +_Int: TypeAlias = np.integer[Any] +_CoInt: TypeAlias = _Bool | _Int +_ToInt: TypeAlias = int | _CoInt +_ToIntND: TypeAlias = onp.CanArrayND[_CoInt] | onp.SequenceND[_ToInt] | onp.SequenceND[onp.CanArrayND[_CoInt]] + +_Float: TypeAlias = np.float16 | np.float32 | np.float64 +_LFloat: TypeAlias = np.float64 | np.longdouble +_OutFloat: TypeAlias = np.float32 | np.float64 +_CoFloat: TypeAlias = _CoInt | _Float +_ToFloat: TypeAlias = float | _CoFloat +_ToFloat1D: TypeAlias = onp.CanArrayND[_CoFloat] | Sequence[_ToFloat | onp.CanArray0D[_CoFloat]] +_ToFloat2D: TypeAlias = onp.CanArrayND[_CoFloat] | Sequence[_ToFloat1D] | Sequence[Sequence[_ToFloat | onp.CanArray0D[_CoFloat]]] +_ToFloatND: TypeAlias = onp.CanArrayND[_CoFloat] | onp.SequenceND[_ToFloat] | onp.SequenceND[onp.CanArrayND[_CoFloat]] + +_Complex: TypeAlias = np.complex64 | np.complex128 +_LComplex: TypeAlias = np.complex128 | np.clongdouble +_CoComplex: TypeAlias = _CoFloat | _Complex +_ToComplex: TypeAlias = complex | _CoComplex +_ToComplex1D: TypeAlias = onp.CanArrayND[_CoComplex] | Sequence[_ToComplex | onp.CanArray0D[_CoComplex]] +_ToComplex2D: TypeAlias = ( + onp.CanArrayND[_CoComplex] | Sequence[_ToComplex1D] | Sequence[Sequence[_ToComplex | onp.CanArray0D[_CoComplex]]] +) +_ToComplexND: TypeAlias = onp.CanArrayND[_CoComplex] | onp.SequenceND[_ToComplex] | onp.SequenceND[onp.CanArrayND[_CoFloat]] + +_WindowFuncFloat: TypeAlias = Callable[[onp.Array1D[np.float64]], onp.ToFloat1D] +_WindowFuncComplex: TypeAlias = Callable[[onp.Array1D[np.complex128]], onp.ToFloat1D] + +@type_check_only +class _ConvMeasureDict(TypedDict): + direct: float + fft: float ### -# TODO(jorenham): deprecate `longdouble` and `object_` input -def choose_conv_method(in1: Untyped, in2: Untyped, mode: CorrelateMode = "full", measure: bool = False) -> Untyped: ... -def correlate(in1: Untyped, in2: Untyped, mode: CorrelateMode = "full", method: _CorrelateMethod = "auto") -> Untyped: ... -def convolve(in1: Untyped, in2: Untyped, mode: CorrelateMode = "full", method: _CorrelateMethod = "auto") -> Untyped: ... -def lfilter(b: Untyped, a: Untyped, x: Untyped, axis: int = -1, zi: Untyped | None = None) -> Untyped: ... -def sosfilt(sos: Untyped, x: Untyped, axis: int = -1, zi: Untyped | None = None) -> Untyped: ... +@overload +def choose_conv_method( + in1: _ToIntND, + in2: _ToIntND, + mode: ConvMode = "full", + measure: _Falsy = False, +) -> L["direct"]: ... +@overload +def choose_conv_method( + in1: _ToComplexND, + in2: _ToComplexND, + mode: ConvMode = "full", + measure: _Falsy = False, +) -> _ConvMethod: ... +@overload +def choose_conv_method( + in1: _ToComplexND, + in2: _ToComplexND, + mode: ConvMode, + measure: _Truthy, +) -> tuple[_ConvMethod, _ConvMeasureDict]: ... +@overload +def choose_conv_method( + in1: _ToComplexND, + in2: _ToComplexND, + mode: ConvMode = "full", + *, + measure: _Truthy, +) -> tuple[_ConvMethod, _ConvMeasureDict]: ... + +# +@overload +def convolve( + in1: _ToBoolND, + in2: _ToBoolND, + mode: ConvMode = "full", + method: _ToConvMethod = "auto", +) -> onp.ArrayND[_CoBool]: ... +@overload +def convolve( + in1: _ToIntND, + in2: _ToIntND, + mode: ConvMode = "full", + method: _ToConvMethod = "auto", +) -> onp.ArrayND[_CoInt]: ... +@overload +def convolve( + in1: _ToFloatND, + in2: _ToFloatND, + mode: ConvMode = "full", + method: _ToConvMethod = "auto", +) -> onp.ArrayND[_CoFloat]: ... +@overload +def convolve( + in1: _ToComplexND, + in2: _ToComplexND, + mode: ConvMode = "full", + method: _ToConvMethod = "auto", +) -> onp.ArrayND[_CoComplex]: ... # -def correlation_lags(in1_len: Untyped, in2_len: Untyped, mode: CorrelateMode = "full") -> Untyped: ... -def fftconvolve(in1: Untyped, in2: Untyped, mode: CorrelateMode = "full", axes: Untyped | None = None) -> Untyped: ... -def oaconvolve(in1: Untyped, in2: Untyped, mode: CorrelateMode = "full", axes: Untyped | None = None) -> Untyped: ... +@overload +def convolve2d( + in1: onp.ToInt2D, + in2: onp.ToInt2D, + mode: ConvMode = "full", + boundary: _BoundaryConditions = "fill", + fillvalue: onp.ToInt = 0, +) -> onp.Array2D[_Int]: ... +@overload +def convolve2d( + in1: onp.ToFloat2D, + in2: onp.ToFloat2D, + mode: ConvMode = "full", + boundary: _BoundaryConditions = "fill", + fillvalue: onp.ToFloat = 0, +) -> onp.Array2D[_OutFloat | _Int]: ... +@overload +def convolve2d( + in1: onp.ToComplex2D, + in2: onp.ToComplex2D, + mode: ConvMode = "full", + boundary: _BoundaryConditions = "fill", + fillvalue: onp.ToComplex = 0, +) -> onp.Array2D[_Complex | _OutFloat | _Int]: ... # -def order_filter(a: Untyped, domain: Untyped, rank: Untyped) -> Untyped: ... +@overload +def fftconvolve( # type: ignore[overload-overlap] + in1: onp.ArrayND[np.float16, _AnyShapeT], + in2: onp.ArrayND[np.float16 | np.float32, _AnyShapeT], + mode: ConvMode = "full", + axes: None = None, +) -> onp.ArrayND[np.float32, _AnyShapeT]: ... +@overload +def fftconvolve( + in1: onp.ArrayND[_EnvelopeSCT, _AnyShapeT], + in2: onp.ArrayND[_EnvelopeSCT, _AnyShapeT], + mode: ConvMode = "full", + axes: None = None, +) -> onp.ArrayND[_EnvelopeSCT, _AnyShapeT]: ... +@overload +def fftconvolve( + in1: onp.ToFloatND, + in2: onp.ToFloatND, + mode: ConvMode = "full", + axes: op.CanIndex | Sequence[op.CanIndex] | None = None, +) -> onp.ArrayND[_OutFloat | np.longdouble]: ... +@overload +def fftconvolve( + in1: onp.ToComplexND, + in2: onp.ToComplexND, + mode: ConvMode = "full", + axes: op.CanIndex | Sequence[op.CanIndex] | None = None, +) -> onp.ArrayND[_OutFloat | np.longdouble | _Complex | np.clongdouble]: ... # -def medfilt(volume: Untyped, kernel_size: Untyped | None = None) -> Untyped: ... -def medfilt2d(input: Untyped, kernel_size: int = 3) -> Untyped: ... +@overload +def oaconvolve( # type: ignore[overload-overlap] + in1: onp.ArrayND[np.float16, _AnyShapeT], + in2: onp.ArrayND[np.float16 | np.float32, _AnyShapeT], + mode: ConvMode = "full", + axes: None = None, +) -> onp.ArrayND[np.float32, _AnyShapeT]: ... +@overload +def oaconvolve( + in1: onp.ArrayND[_EnvelopeSCT, _AnyShapeT], + in2: onp.ArrayND[_EnvelopeSCT, _AnyShapeT], + mode: ConvMode = "full", + axes: None = None, +) -> onp.ArrayND[_EnvelopeSCT, _AnyShapeT]: ... +@overload +def oaconvolve( + in1: onp.ToFloatND, + in2: onp.ToFloatND, + mode: ConvMode = "full", + axes: op.CanIndex | Sequence[op.CanIndex] | None = None, +) -> onp.ArrayND[_OutFloat | np.longdouble]: ... +@overload +def oaconvolve( + in1: onp.ToComplexND, + in2: onp.ToComplexND, + mode: ConvMode = "full", + axes: op.CanIndex | Sequence[op.CanIndex] | None = None, +) -> onp.ArrayND[_OutFloat | np.longdouble | _Complex | np.clongdouble]: ... # -def wiener(im: Untyped, mysize: Untyped | None = None, noise: Untyped | None = None) -> Untyped: ... +@overload +def deconvolve(signal: onp.ToFloat1D, divisor: onp.ToFloat1D) -> _Tuple2[onp.Array1D[_LFloat]]: ... +@overload +def deconvolve(signal: onp.ToComplex1D, divisor: onp.ToComplex1D) -> _Tuple2[onp.Array1D[_LFloat | _LComplex]]: ... # -def convolve2d( - in1: Untyped, - in2: Untyped, - mode: CorrelateMode = "full", +@overload +def correlate( + in1: _ToBoolND, + in2: _ToBoolND, + mode: ConvMode = "full", + method: _ToConvMethod = "auto", +) -> onp.ArrayND[_CoBool]: ... +@overload +def correlate( + in1: _ToIntND, + in2: _ToIntND, + mode: ConvMode = "full", + method: _ToConvMethod = "auto", +) -> onp.ArrayND[_CoInt]: ... +@overload +def correlate( + in1: _ToFloatND, + in2: _ToFloatND, + mode: ConvMode = "full", + method: _ToConvMethod = "auto", +) -> onp.ArrayND[_CoFloat]: ... +@overload +def correlate( + in1: _ToComplexND, + in2: _ToComplexND, + mode: ConvMode = "full", + method: _ToConvMethod = "auto", +) -> onp.ArrayND[_CoComplex]: ... + +# +@overload +def correlate2d( + in1: onp.ToInt2D, + in2: onp.ToInt2D, + mode: ConvMode = "full", boundary: _BoundaryConditions = "fill", - fillvalue: onp.ToComplex = 0, -) -> Untyped: ... + fillvalue: onp.ToInt = 0, +) -> onp.Array2D[_Int]: ... +@overload +def correlate2d( + in1: onp.ToFloat2D, + in2: onp.ToFloat2D, + mode: ConvMode = "full", + boundary: _BoundaryConditions = "fill", + fillvalue: onp.ToFloat = 0, +) -> onp.Array2D[_OutFloat | _Int]: ... +@overload def correlate2d( - in1: Untyped, - in2: Untyped, - mode: CorrelateMode = "full", + in1: onp.ToComplex2D, + in2: onp.ToComplex2D, + mode: ConvMode = "full", boundary: _BoundaryConditions = "fill", fillvalue: onp.ToComplex = 0, -) -> Untyped: ... +) -> onp.Array2D[_Complex | _OutFloat | _Int]: ... # -def lfiltic(b: Untyped, a: Untyped, y: Untyped, x: Untyped | None = None) -> Untyped: ... +def correlation_lags(in1_len: onp.ToInt, in2_len: onp.ToInt, mode: ConvMode = "full") -> onp.Array1D[np.int_]: ... # -def deconvolve(signal: Untyped, divisor: Untyped) -> Untyped: ... +@overload +def lfilter_zi(b: _ToFloat1D, a: _ToFloat1D) -> onp.Array1D[_Float]: ... +@overload +def lfilter_zi(b: _ToComplex1D, a: _ToComplex1D) -> onp.Array1D[_Float | _Complex]: ... # -def hilbert(x: Untyped, N: Untyped | None = None, axis: int = -1) -> Untyped: ... -def hilbert2(x: Untyped, N: Untyped | None = None) -> Untyped: ... +@overload +def lfiltic( + b: onp.ToFloat1D, + a: onp.ToFloat1D, + y: onp.ToFloat1D, + x: onp.ToFloat1D | None = None, +) -> onp.Array1D[np.floating[Any]]: ... +@overload +def lfiltic( + b: onp.ToComplex1D, + a: onp.ToComplex1D, + y: onp.ToComplex1D, + x: onp.ToComplex1D | None = None, +) -> onp.Array1D[np.inexact[Any]]: ... # -def unique_roots(p: Untyped, tol: float = 0.001, rtype: _RootType = "min") -> Untyped: ... +@overload +def lfilter( + b: _ToFloat1D, + a: _ToFloat1D, + x: _ToFloatND, + axis: op.CanIndex = -1, + zi: None = None, +) -> onp.ArrayND[_Float]: ... +@overload +def lfilter( + b: _ToFloat1D, + a: _ToFloat1D, + x: _ToFloatND, + axis: op.CanIndex, + zi: _ToFloatND, +) -> _Tuple2[onp.ArrayND[_Float]]: ... +@overload +def lfilter( + b: _ToFloat1D, + a: _ToFloat1D, + x: _ToFloatND, + axis: op.CanIndex = -1, + *, + zi: _ToFloatND, +) -> _Tuple2[onp.ArrayND[_Float]]: ... +@overload +def lfilter( + b: _ToComplex1D, + a: _ToComplex1D, + x: _ToComplexND, + axis: op.CanIndex = -1, + zi: None = None, +) -> onp.ArrayND[_Complex | _Float]: ... +@overload +def lfilter( + b: _ToComplex1D, + a: _ToComplex1D, + x: _ToComplexND, + axis: op.CanIndex, + zi: _ToComplexND, +) -> _Tuple2[onp.ArrayND[_Complex | _Float]]: ... +@overload +def lfilter( + b: _ToComplex1D, + a: _ToComplex1D, + x: _ToComplexND, + axis: op.CanIndex = -1, + *, + zi: _ToComplexND, +) -> _Tuple2[onp.ArrayND[_Complex | _Float]]: ... # -def residue(b: Untyped, a: Untyped, tol: float = 0.001, rtype: _ResidueType = "avg") -> Untyped: ... -def residuez(b: Untyped, a: Untyped, tol: float = 0.001, rtype: _ResidueType = "avg") -> Untyped: ... +@overload +def filtfilt( + b: _ToFloat1D, + a: _ToFloat1D, + x: _ToFloatND, + axis: op.CanIndex = -1, + padtype: _FiltFiltPadType = "odd", + padlen: onp.ToInt | None = None, + method: _FiltFiltMethod = "pad", + irlen: onp.ToInt | None = None, +) -> onp.ArrayND[_Float]: ... +@overload +def filtfilt( + b: _ToComplex1D, + a: _ToComplex1D, + x: _ToComplexND, + axis: op.CanIndex = -1, + padtype: _FiltFiltPadType = "odd", + padlen: onp.ToInt | None = None, + method: _FiltFiltMethod = "pad", + irlen: onp.ToInt | None = None, +) -> onp.ArrayND[_Complex | _Float]: ... # -def invres(r: Untyped, p: Untyped, k: Untyped, tol: float = 0.001, rtype: _ResidueType = "avg") -> Untyped: ... -def invresz(r: Untyped, p: Untyped, k: Untyped, tol: float = 0.001, rtype: _ResidueType = "avg") -> Untyped: ... +@overload +def sosfilt_zi(sos: onp.ArrayND[_InexactT]) -> onp.Array2D[_InexactT]: ... +@overload +def sosfilt_zi(sos: onp.ToFloat2D) -> onp.Array2D[np.floating[Any]]: ... +@overload +def sosfilt_zi(sos: onp.ToComplex2D) -> onp.Array2D[np.inexact[Any]]: ... # +@overload +def sosfilt(sos: _ToFloat2D, x: _ToFloatND, axis: op.CanIndex = -1, zi: None = None) -> onp.ArrayND[_Float]: ... +@overload +def sosfilt(sos: _ToFloat2D, x: _ToFloatND, axis: op.CanIndex, zi: _ToFloatND) -> _Tuple2[onp.ArrayND[_Float]]: ... +@overload +def sosfilt(sos: _ToFloat2D, x: _ToFloatND, axis: op.CanIndex = -1, *, zi: _ToFloatND) -> _Tuple2[onp.ArrayND[_Float]]: ... +@overload +def sosfilt(sos: _ToComplex2D, x: _ToComplexND, axis: op.CanIndex = -1, zi: None = None) -> onp.ArrayND[_Float | _Complex]: ... +@overload +def sosfilt( + sos: _ToComplex2D, + x: _ToComplexND, + axis: op.CanIndex, + zi: _ToFloatND, +) -> _Tuple2[onp.ArrayND[_Float | _Complex]]: ... +@overload +def sosfilt( + sos: _ToComplex2D, + x: _ToComplexND, + axis: op.CanIndex = -1, + *, + zi: _ToFloatND, +) -> _Tuple2[onp.ArrayND[_Float | _Complex]]: ... + +# +@overload +def sosfiltfilt( + sos: _ToFloat2D, + x: _ToFloatND, + axis: op.CanIndex = -1, + padtype: _FiltFiltPadType = "odd", + padlen: onp.ToInt | None = None, +) -> onp.ArrayND[_Float]: ... +@overload +def sosfiltfilt( + sos: _ToComplex2D, + x: _ToComplexND, + axis: op.CanIndex = -1, + padtype: _FiltFiltPadType = "odd", + padlen: onp.ToInt | None = None, +) -> onp.ArrayND[_Float | _Complex]: ... + +# +@overload +def order_filter( + a: onp.ArrayND[_FilterSCT, _ShapeT], + domain: onp.ToArrayND, + rank: onp.ToJustInt, +) -> onp.ArrayND[_FilterSCT, _ShapeT]: ... +@overload +def order_filter(a: _ToIntND, domain: onp.ToArrayND, rank: onp.ToJustInt) -> onp.ArrayND[_Int]: ... +@overload +def order_filter(a: _ToFloatND, domain: onp.ToArrayND, rank: onp.ToJustInt) -> onp.ArrayND[_Float | _Int]: ... + +# +@overload +def medfilt( + volume: onp.ArrayND[_FilterSCT, _ShapeT], + kernel_size: onp.ToInt | onp.ToInt1D | None = None, +) -> onp.ArrayND[_FilterSCT, _ShapeT]: ... +@overload +def medfilt(volume: _ToIntND, kernel_size: onp.ToInt | onp.ToInt1D | None = None) -> onp.ArrayND[_Int]: ... +@overload +def medfilt(volume: _ToFloatND, kernel_size: onp.ToInt | onp.ToInt1D | None = None) -> onp.ArrayND[_Float | _Int]: ... + +# +def medfilt2d(input: _ToFloat2D, kernel_size: onp.ToInt | onp.ToInt1D = 3) -> onp.Array2D[_Float]: ... + +# +@overload +def wiener( + im: onp.ToFloatND, + mysize: onp.ToInt | onp.ToInt1D | None = None, + noise: onp.ToFloat | None = None, +) -> onp.ArrayND[_LFloat]: ... +@overload +def wiener( + im: onp.ToComplexND, + mysize: onp.ToInt | onp.ToInt1D | None = None, + noise: onp.ToFloat | None = None, +) -> onp.ArrayND[_LFloat | _LComplex]: ... + +# +def hilbert( + x: onp.ToFloatND, + N: onp.ToInt | None = None, + axis: op.CanIndex = -1, +) -> onp.ArrayND[np.complexfloating[Any, Any]]: ... + +# +def hilbert2( + x: onp.ToFloat2D, + N: onp.ToInt | tuple[onp.ToInt, onp.ToInt] | None = None, +) -> onp.Array2D[np.complexfloating[Any, Any]]: ... + +# +@overload +def unique_roots( + p: onp.ToFloat1D, + tol: onp.ToFloat = 0.001, + rtype: _RootType = "min", +) -> tuple[onp.Array1D[np.floating[Any]], onp.Array1D[np.int_]]: ... +@overload +def unique_roots( + p: onp.ToComplex1D, + tol: onp.ToFloat = 0.001, + rtype: _RootType = "min", +) -> tuple[onp.Array1D[np.inexact[Any]], onp.Array1D[np.int_]]: ... + +# +def residue( + b: onp.ToComplex1D, + a: onp.ToComplex1D, + tol: onp.ToFloat = 0.001, + rtype: _ResidueType = "avg", +) -> tuple[onp.Array1D[np.complex128], onp.Array1D[np.complex128], onp.Array1D[np.float64]]: ... + +# +def residuez( + b: onp.ToComplex1D, + a: onp.ToComplex1D, + tol: onp.ToFloat = 0.001, + rtype: _ResidueType = "avg", +) -> tuple[onp.Array1D[np.complex128], onp.Array1D[np.complex128], onp.Array1D[np.float64]]: ... + +# +def invres( + r: onp.ToComplex1D, + p: onp.ToComplex1D, + k: onp.ToFloat1D, + tol: onp.ToFloat = 0.001, + rtype: _ResidueType = "avg", +) -> tuple[onp.Array1D[np.complex128], onp.Array1D[np.complex128]]: ... +def invresz( + r: onp.ToComplex1D, + p: onp.ToComplex1D, + k: onp.ToFloat1D, + tol: onp.ToFloat = 0.001, + rtype: _ResidueType = "avg", +) -> tuple[onp.Array1D[np.complex128], onp.Array1D[np.complex128]]: ... + +# +@overload +def resample( + x: onp.ArrayND[_EnvelopeSCT, _AnyShapeT], + num: onp.ToJustInt, + t: None = None, + axis: op.CanIndex = 0, + window: _WindowFuncFloat | _WindowFuncComplex | onp.ToFloat1D | _ToWindow | None = None, + domain: _Domain = "time", +) -> onp.ArrayND[_EnvelopeSCT, _AnyShapeT]: ... +@overload +def resample( + x: onp.ToFloatND, + num: onp.ToJustInt, + t: None = None, + axis: op.CanIndex = 0, + window: _WindowFuncFloat | onp.ToFloat1D | _ToWindow | None = None, + domain: _Domain = "time", +) -> onp.ArrayND[np.floating[Any]]: ... +@overload +def resample( + x: onp.ToComplexND, + num: onp.ToJustInt, + t: None = None, + axis: op.CanIndex = 0, + window: _WindowFuncComplex | onp.ToFloat1D | _ToWindow | None = None, + domain: _Domain = "time", +) -> onp.ArrayND[np.inexact[Any]]: ... +@overload +def resample( + x: onp.ArrayND[_EnvelopeSCT, _AnyShapeT], + num: onp.ToJustInt, + t: onp.ToFloat1D, + axis: op.CanIndex = 0, + window: _WindowFuncFloat | _WindowFuncComplex | onp.ToFloat1D | _ToWindow | None = None, + domain: _Domain = "time", +) -> tuple[onp.ArrayND[_EnvelopeSCT, _AnyShapeT], onp.Array1D[np.floating[Any]]]: ... +@overload +def resample( + x: onp.ToFloatND, + num: onp.ToJustInt, + t: onp.ToFloat1D, + axis: op.CanIndex = 0, + window: _WindowFuncFloat | onp.ToFloat1D | _ToWindow | None = None, + domain: _Domain = "time", +) -> tuple[onp.ArrayND[np.floating[Any]], onp.Array1D[np.floating[Any]]]: ... +@overload def resample( - x: Untyped, - num: Untyped, - t: Untyped | None = None, - axis: int = 0, - window: Untyped | None = None, + x: onp.ToComplexND, + num: onp.ToJustInt, + t: onp.ToFloat1D, + axis: op.CanIndex = 0, + window: _WindowFuncComplex | onp.ToFloat1D | _ToWindow | None = None, domain: _Domain = "time", -) -> Untyped: ... +) -> tuple[onp.ArrayND[np.inexact[Any]], onp.Array1D[np.floating[Any]]]: ... + +# +@overload +def resample_poly( + x: _ToFloatND, + up: onp.ToInt, + down: onp.ToInt, + axis: op.CanIndex = 0, + window: _ToWindow = ("kaiser", 5.0), + padtype: _PadType = "constant", + cval: onp.ToFloat | None = None, +) -> onp.ArrayND[_Float]: ... +@overload def resample_poly( - x: Untyped, - up: Untyped, - down: Untyped, - axis: int = 0, - window: Untyped = ("kaiser", 5.0), + x: _ToComplexND, + up: onp.ToInt, + down: onp.ToInt, + axis: op.CanIndex = 0, + window: _ToWindow = ("kaiser", 5.0), padtype: _PadType = "constant", - cval: Untyped | None = None, -) -> Untyped: ... + cval: onp.ToFloat | None = None, +) -> onp.ArrayND[_Complex | _Float]: ... # -def vectorstrength(events: Untyped, period: Untyped) -> Untyped: ... +@overload +def vectorstrength(events: onp.ToFloat1D, period: onp.ToFloat) -> _Tuple2[_Float | np.longdouble]: ... +@overload +def vectorstrength(events: onp.ToFloat1D, period: onp.ToFloat1D) -> _Tuple2[onp.Array1D[_Float | np.longdouble]]: ... +@overload +def vectorstrength( + events: onp.ToComplex1D, + period: onp.ToComplex, +) -> _Tuple2[_Float | np.longdouble | _Complex | np.clongdouble]: ... +@overload +def vectorstrength( + events: onp.ToComplex1D, + period: onp.ToComplex1D, +) -> _Tuple2[onp.Array1D[_Float | np.longdouble | _Complex | np.clongdouble]]: ... # +@overload def detrend( - data: UntypedArray, - axis: int = -1, + data: onp.ToFloatND, + axis: op.CanIndex = -1, type: _TrendType = "linear", bp: onp.ToJustInt | onp.ToJustIntND = 0, - overwrite_data: bool = False, -) -> UntypedArray: ... - -# -def lfilter_zi(b: Untyped, a: Untyped) -> Untyped: ... -def sosfilt_zi(sos: Untyped) -> Untyped: ... - -# -def filtfilt( - b: Untyped, - a: Untyped, - x: Untyped, - axis: int = -1, - padtype: _FiltFiltPadType = "odd", - padlen: int | None = None, - method: Literal["pad", "gust"] = "pad", - irlen: int | None = None, -) -> Untyped: ... - -# -def sosfiltfilt( - sos: Untyped, - x: Untyped, - axis: int = -1, - padtype: _FiltFiltPadType = "odd", - padlen: int | None = None, -) -> Untyped: ... + overwrite_data: op.CanBool = False, +) -> onp.ArrayND[_Float]: ... +@overload +def detrend( + data: onp.ToComplexND, + axis: op.CanIndex = -1, + type: _TrendType = "linear", + bp: onp.ToJustInt | onp.ToJustIntND = 0, + overwrite_data: op.CanBool = False, +) -> onp.ArrayND[_Complex | _Float]: ... # +@overload +def decimate( + x: onp.ToFloatND, + q: onp.ToInt, + n: onp.ToInt | None = None, + ftype: _FilterType = "iir", + axis: op.CanIndex = -1, + zero_phase: op.CanBool = True, +) -> onp.ArrayND[_Float | np.longdouble]: ... +@overload def decimate( - x: Untyped, - q: int, - n: int | None = None, + x: onp.ToComplexND, + q: onp.ToInt, + n: onp.ToInt | None = None, ftype: _FilterType = "iir", - axis: int = -1, - zero_phase: bool = True, -) -> Untyped: ... + axis: op.CanIndex = -1, + zero_phase: op.CanBool = True, +) -> onp.ArrayND[_Float | np.longdouble | _Complex | np.clongdouble]: ... # - @overload def envelope( - z: onp.ArrayND[np.floating[Any]], - bp_in: tuple[int | None, int | None] = (1, None), + z: onp.Array1D[np.float16], + bp_in: tuple[_ToInt | None, _ToInt | None] = (1, None), *, - n_out: int | None = None, - squared: bool = False, + n_out: onp.ToInt | None = None, + squared: op.CanBool = False, residual: _ResidualKind | None = "lowpass", - axis: int = -1, -) -> onp.ArrayND[np.floating[Any]]: ... + axis: op.CanIndex = -1, +) -> onp.Array2D[np.float32]: ... @overload def envelope( - z: onp.ArrayND[np.inexact[Any]], - bp_in: tuple[int | None, int | None] = (1, None), + z: onp.Array2D[np.float16], + bp_in: tuple[_ToInt | None, _ToInt | None] = (1, None), *, - n_out: int | None = None, - squared: bool = False, + n_out: onp.ToInt | None = None, + squared: op.CanBool = False, residual: _ResidualKind | None = "lowpass", - axis: int = -1, -) -> onp.ArrayND[np.inexact[Any]]: ... + axis: op.CanIndex = -1, +) -> onp.Array3D[np.float32]: ... +@overload +def envelope( # type: ignore[overload-overlap] + z: onp.ArrayND[np.float16], + bp_in: tuple[_ToInt | None, _ToInt | None] = (1, None), + *, + n_out: onp.ToInt | None = None, + squared: op.CanBool = False, + residual: _ResidualKind | None = "lowpass", + axis: op.CanIndex = -1, +) -> onp.ArrayND[np.float32]: ... +@overload +def envelope( + z: onp.Array1D[_EnvelopeSCT], + bp_in: tuple[_ToInt | None, _ToInt | None] = (1, None), + *, + n_out: onp.ToInt | None = None, + squared: op.CanBool = False, + residual: _ResidualKind | None = "lowpass", + axis: op.CanIndex = -1, +) -> onp.Array2D[_EnvelopeSCT]: ... +@overload +def envelope( + z: onp.Array2D[_EnvelopeSCT], + bp_in: tuple[_ToInt | None, _ToInt | None] = (1, None), + *, + n_out: onp.ToInt | None = None, + squared: op.CanBool = False, + residual: _ResidualKind | None = "lowpass", + axis: op.CanIndex = -1, +) -> onp.Array3D[_EnvelopeSCT]: ... +@overload +def envelope( + z: onp.ArrayND[_EnvelopeSCT], + bp_in: tuple[_ToInt | None, _ToInt | None] = (1, None), + *, + n_out: onp.ToInt | None = None, + squared: op.CanBool = False, + residual: _ResidualKind | None = "lowpass", + axis: op.CanIndex = -1, +) -> onp.ArrayND[_EnvelopeSCT]: ...