numpy 2.4.2__cp313-cp313t-win32.whl

numpy/lib/_function_base_impl.pyi

@@ -0,0 +1,2324 @@
+from _typeshed import ConvertibleToInt, Incomplete
+from collections.abc import Callable, Iterable, Sequence
+from typing import (
+    Any,
+    Concatenate,
+    Literal as L,
+    Never,
+    ParamSpec,
+    Protocol,
+    SupportsIndex,
+    SupportsInt,
+    TypeAlias,
+    overload,
+    type_check_only,
+)
+from typing_extensions import TypeIs, TypeVar
+
+import numpy as np
+from numpy import _OrderKACF
+from numpy._core.multiarray import bincount
+from numpy._globals import _NoValueType
+from numpy._typing import (
+    ArrayLike,
+    DTypeLike,
+    NDArray,
+    _ArrayLike,
+    _ArrayLikeBool_co,
+    _ArrayLikeComplex_co,
+    _ArrayLikeFloat_co,
+    _ArrayLikeInt_co,
+    _ArrayLikeNumber_co,
+    _ArrayLikeObject_co,
+    _ComplexLike_co,
+    _DTypeLike,
+    _FloatLike_co,
+    _NestedSequence as _SeqND,
+    _NumberLike_co,
+    _ScalarLike_co,
+    _ShapeLike,
+    _SupportsArray,
+)
+
+__all__ = [
+    "select",
+    "piecewise",
+    "trim_zeros",
+    "copy",
+    "iterable",
+    "percentile",
+    "diff",
+    "gradient",
+    "angle",
+    "unwrap",
+    "sort_complex",
+    "flip",
+    "rot90",
+    "extract",
+    "place",
+    "vectorize",
+    "asarray_chkfinite",
+    "average",
+    "bincount",
+    "digitize",
+    "cov",
+    "corrcoef",
+    "median",
+    "sinc",
+    "hamming",
+    "hanning",
+    "bartlett",
+    "blackman",
+    "kaiser",
+    "trapezoid",
+    "i0",
+    "meshgrid",
+    "delete",
+    "insert",
+    "append",
+    "interp",
+    "quantile",
+]
+
+_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
+# The `{}ss` suffix refers to the PEP 695 (Python 3.12) `ParamSpec` syntax, `**P`.
+_Tss = ParamSpec("_Tss")
+
+_ScalarT = TypeVar("_ScalarT", bound=np.generic)
+_ScalarT1 = TypeVar("_ScalarT1", bound=np.generic)
+_ScalarT2 = TypeVar("_ScalarT2", bound=np.generic)
+_FloatingT = TypeVar("_FloatingT", bound=np.floating)
+_InexactT = TypeVar("_InexactT", bound=np.inexact)
+_InexactTimeT = TypeVar("_InexactTimeT", bound=np.inexact | np.timedelta64)
+_InexactDateTimeT = TypeVar("_InexactDateTimeT", bound=np.inexact | np.timedelta64 | np.datetime64)
+_ScalarNumericT = TypeVar("_ScalarNumericT", bound=np.inexact | np.timedelta64 | np.object_)
+_AnyDoubleT = TypeVar("_AnyDoubleT", bound=np.float64 | np.longdouble | np.complex128 | np.clongdouble)
+
+_ArrayT = TypeVar("_ArrayT", bound=np.ndarray)
+_ArrayFloatingT = TypeVar("_ArrayFloatingT", bound=NDArray[np.floating])
+_ArrayFloatObjT = TypeVar("_ArrayFloatObjT", bound=NDArray[np.floating | np.object_])
+_ArrayComplexT = TypeVar("_ArrayComplexT", bound=NDArray[np.complexfloating])
+_ArrayInexactT = TypeVar("_ArrayInexactT", bound=NDArray[np.inexact])
+_ArrayNumericT = TypeVar("_ArrayNumericT", bound=NDArray[np.inexact | np.timedelta64 | np.object_])
+
+_ArrayLike1D: TypeAlias = _SupportsArray[np.dtype[_ScalarT]] | Sequence[_ScalarT]
+
+_ShapeT = TypeVar("_ShapeT", bound=tuple[int, ...])
+
+_integer_co: TypeAlias = np.integer | np.bool
+_float64_co: TypeAlias = np.float64 | _integer_co
+_floating_co: TypeAlias = np.floating | _integer_co
+
+# non-trivial scalar-types that will become `complex128` in `sort_complex()`,
+# i.e. all numeric scalar types except for `[u]int{8,16} | longdouble`
+_SortsToComplex128: TypeAlias = (
+    np.bool
+    | np.int32
+    | np.uint32
+    | np.int64
+    | np.uint64
+    | np.float16
+    | np.float32
+    | np.float64
+    | np.timedelta64
+    | np.object_
+)
+
+_Array: TypeAlias = np.ndarray[_ShapeT, np.dtype[_ScalarT]]
+_Array0D: TypeAlias = np.ndarray[tuple[()], np.dtype[_ScalarT]]
+_Array1D: TypeAlias = np.ndarray[tuple[int], np.dtype[_ScalarT]]
+_Array2D: TypeAlias = np.ndarray[tuple[int, int], np.dtype[_ScalarT]]
+_Array3D: TypeAlias = np.ndarray[tuple[int, int, int], np.dtype[_ScalarT]]
+_ArrayMax2D: TypeAlias = np.ndarray[tuple[int] | tuple[int, int], np.dtype[_ScalarT]]
+# workaround for mypy and pyright not following the typing spec for overloads
+_ArrayNoD: TypeAlias = np.ndarray[tuple[Never, Never, Never, Never], np.dtype[_ScalarT]]
+
+_Seq1D: TypeAlias = Sequence[_T]
+_Seq2D: TypeAlias = Sequence[Sequence[_T]]
+_Seq3D: TypeAlias = Sequence[Sequence[Sequence[_T]]]
+_ListSeqND: TypeAlias = list[_T] | _SeqND[list[_T]]
+
+_Tuple2: TypeAlias = tuple[_T, _T]
+_Tuple3: TypeAlias = tuple[_T, _T, _T]
+_Tuple4: TypeAlias = tuple[_T, _T, _T, _T]
+
+_Mesh1: TypeAlias = tuple[_Array1D[_ScalarT]]
+_Mesh2: TypeAlias = tuple[_Array2D[_ScalarT], _Array2D[_ScalarT1]]
+_Mesh3: TypeAlias = tuple[_Array3D[_ScalarT], _Array3D[_ScalarT1], _Array3D[_ScalarT2]]
+
+_IndexLike: TypeAlias = slice | _ArrayLikeInt_co
+
+_Indexing: TypeAlias = L["ij", "xy"]
+_InterpolationMethod = L[
+    "inverted_cdf",
+    "averaged_inverted_cdf",
+    "closest_observation",
+    "interpolated_inverted_cdf",
+    "hazen",
+    "weibull",
+    "linear",
+    "median_unbiased",
+    "normal_unbiased",
+    "lower",
+    "higher",
+    "midpoint",
+    "nearest",
+]
+
+# The resulting value will be used as `y[cond] = func(vals, *args, **kw)`, so in can
+# return any (usually 1d) array-like or scalar-like compatible with the input.
+_PiecewiseFunction: TypeAlias = Callable[Concatenate[NDArray[_ScalarT], _Tss], ArrayLike]
+_PiecewiseFunctions: TypeAlias = _SizedIterable[_PiecewiseFunction[_ScalarT, _Tss] | _ScalarLike_co]
+
+@type_check_only
+class _TrimZerosSequence(Protocol[_T_co]):
+    def __len__(self, /) -> int: ...
+    @overload
+    def __getitem__(self, key: int, /) -> object: ...
+    @overload
+    def __getitem__(self, key: slice, /) -> _T_co: ...
+
+@type_check_only
+class _SupportsRMulFloat(Protocol[_T_co]):
+    def __rmul__(self, other: float, /) -> _T_co: ...
+
+@type_check_only
+class _SizedIterable(Protocol[_T_co]):
+    def __iter__(self) -> Iterable[_T_co]: ...
+    def __len__(self) -> int: ...
+
+###
+
+class vectorize:
+    __doc__: str | None
+    __module__: L["numpy"] = "numpy"
+    pyfunc: Callable[..., Incomplete]
+    cache: bool
+    signature: str | None
+    otypes: str | None
+    excluded: set[int | str]
+
+    def __init__(
+        self,
+        /,
+        pyfunc: Callable[..., Incomplete] | _NoValueType = ...,  # = _NoValue
+        otypes: str | Iterable[DTypeLike] | None = None,
+        doc: str | None = None,
+        excluded: Iterable[int | str] | None = None,
+        cache: bool = False,
+        signature: str | None = None,
+    ) -> None: ...
+    def __call__(self, /, *args: Incomplete, **kwargs: Incomplete) -> Incomplete: ...
+
+@overload
+def rot90(m: _ArrayT, k: int = 1, axes: tuple[int, int] = (0, 1)) -> _ArrayT: ...
+@overload
+def rot90(m: _ArrayLike[_ScalarT], k: int = 1, axes: tuple[int, int] = (0, 1)) -> NDArray[_ScalarT]: ...
+@overload
+def rot90(m: ArrayLike, k: int = 1, axes: tuple[int, int] = (0, 1)) -> NDArray[Incomplete]: ...
+
+# NOTE: Technically `flip` also accept scalars, but that has no effect and complicates
+# the overloads significantly, so we ignore that case here.
+@overload
+def flip(m: _ArrayT, axis: int | tuple[int, ...] | None = None) -> _ArrayT: ...
+@overload
+def flip(m: _ArrayLike[_ScalarT], axis: int | tuple[int, ...] | None = None) -> NDArray[_ScalarT]: ...
+@overload
+def flip(m: ArrayLike, axis: int | tuple[int, ...] | None = None) -> NDArray[Incomplete]: ...
+
+#
+def iterable(y: object) -> TypeIs[Iterable[Any]]: ...
+
+# NOTE: This assumes that if `axis` is given the input is at least 2d, and will
+# therefore always return an array.
+# NOTE: This assumes that if `keepdims=True` the input is at least 1d, and will
+# therefore always return an array.
+@overload  # inexact array, keepdims=True
+def average(
+    a: _ArrayInexactT,
+    axis: int | tuple[int, ...] | None = None,
+    weights: _ArrayLikeNumber_co | None = None,
+    returned: L[False] = False,
+    *,
+    keepdims: L[True],
+) -> _ArrayInexactT: ...
+@overload  # inexact array, returned=True keepdims=True
+def average(
+    a: _ArrayInexactT,
+    axis: int | tuple[int, ...] | None = None,
+    weights: _ArrayLikeNumber_co | None = None,
+    *,
+    returned: L[True],
+    keepdims: L[True],
+) -> _Tuple2[_ArrayInexactT]: ...
+@overload  # inexact array-like, axis=None
+def average(
+    a: _ArrayLike[_InexactT],
+    axis: None = None,
+    weights: _ArrayLikeNumber_co | None = None,
+    returned: L[False] = False,
+    *,
+    keepdims: L[False] | _NoValueType = ...,
+) -> _InexactT: ...
+@overload  # inexact array-like, axis=<given>
+def average(
+    a: _ArrayLike[_InexactT],
+    axis: int | tuple[int, ...],
+    weights: _ArrayLikeNumber_co | None = None,
+    returned: L[False] = False,
+    *,
+    keepdims: L[False] | _NoValueType = ...,
+) -> NDArray[_InexactT]: ...
+@overload  # inexact array-like, keepdims=True
+def average(
+    a: _ArrayLike[_InexactT],
+    axis: int | tuple[int, ...] | None = None,
+    weights: _ArrayLikeNumber_co | None = None,
+    returned: L[False] = False,
+    *,
+    keepdims: L[True],
+) -> NDArray[_InexactT]: ...
+@overload  # inexact array-like, axis=None, returned=True
+def average(
+    a: _ArrayLike[_InexactT],
+    axis: None = None,
+    weights: _ArrayLikeNumber_co | None = None,
+    *,
+    returned: L[True],
+    keepdims: L[False] | _NoValueType = ...,
+) -> _Tuple2[_InexactT]: ...
+@overload  # inexact array-like, axis=<given>, returned=True
+def average(
+    a: _ArrayLike[_InexactT],
+    axis: int | tuple[int, ...],
+    weights: _ArrayLikeNumber_co | None = None,
+    *,
+    returned: L[True],
+    keepdims: L[False] | _NoValueType = ...,
+) -> _Tuple2[NDArray[_InexactT]]: ...
+@overload  # inexact array-like, returned=True, keepdims=True
+def average(
+    a: _ArrayLike[_InexactT],
+    axis: int | tuple[int, ...] | None = None,
+    weights: _ArrayLikeNumber_co | None = None,
+    *,
+    returned: L[True],
+    keepdims: L[True],
+) -> _Tuple2[NDArray[_InexactT]]: ...
+@overload  # bool or integer array-like, axis=None
+def average(
+    a: _SeqND[float] | _ArrayLikeInt_co,
+    axis: None = None,
+    weights: _ArrayLikeFloat_co | None = None,
+    returned: L[False] = False,
+    *,
+    keepdims: L[False] | _NoValueType = ...,
+) -> np.float64: ...
+@overload  # bool or integer array-like, axis=<given>
+def average(
+    a: _SeqND[float] | _ArrayLikeInt_co,
+    axis: int | tuple[int, ...],
+    weights: _ArrayLikeFloat_co | None = None,
+    returned: L[False] = False,
+    *,
+    keepdims: L[False] | _NoValueType = ...,
+) -> NDArray[np.float64]: ...
+@overload  # bool or integer array-like, keepdims=True
+def average(
+    a: _SeqND[float] | _ArrayLikeInt_co,
+    axis: int | tuple[int, ...] | None = None,
+    weights: _ArrayLikeFloat_co | None = None,
+    returned: L[False] = False,
+    *,
+    keepdims: L[True],
+) -> NDArray[np.float64]: ...
+@overload  # bool or integer array-like, axis=None, returned=True
+def average(
+    a: _SeqND[float] | _ArrayLikeInt_co,
+    axis: None = None,
+    weights: _ArrayLikeFloat_co | None = None,
+    *,
+    returned: L[True],
+    keepdims: L[False] | _NoValueType = ...,
+) -> _Tuple2[np.float64]: ...
+@overload  # bool or integer array-like, axis=<given>, returned=True
+def average(
+    a: _SeqND[float] | _ArrayLikeInt_co,
+    axis: int | tuple[int, ...],
+    weights: _ArrayLikeFloat_co | None = None,
+    *,
+    returned: L[True],
+    keepdims: L[False] | _NoValueType = ...,
+) -> _Tuple2[NDArray[np.float64]]: ...
+@overload  # bool or integer array-like, returned=True, keepdims=True
+def average(
+    a: _SeqND[float] | _ArrayLikeInt_co,
+    axis: int | tuple[int, ...] | None = None,
+    weights: _ArrayLikeFloat_co | None = None,
+    *,
+    returned: L[True],
+    keepdims: L[True],
+) -> _Tuple2[NDArray[np.float64]]: ...
+@overload  # complex array-like, axis=None
+def average(
+    a: _ListSeqND[complex],
+    axis: None = None,
+    weights: _ArrayLikeComplex_co | None = None,
+    returned: L[False] = False,
+    *,
+    keepdims: L[False] | _NoValueType = ...,
+) -> np.complex128: ...
+@overload  # complex array-like, axis=<given>
+def average(
+    a: _ListSeqND[complex],
+    axis: int | tuple[int, ...],
+    weights: _ArrayLikeComplex_co | None = None,
+    returned: L[False] = False,
+    *,
+    keepdims: L[False] | _NoValueType = ...,
+) -> NDArray[np.complex128]: ...
+@overload  # complex array-like, keepdims=True
+def average(
+    a: _ListSeqND[complex],
+    axis: int | tuple[int, ...] | None = None,
+    weights: _ArrayLikeComplex_co | None = None,
+    returned: L[False] = False,
+    *,
+    keepdims: L[True],
+) -> NDArray[np.complex128]: ...
+@overload  # complex array-like, axis=None, returned=True
+def average(
+    a: _ListSeqND[complex],
+    axis: None = None,
+    weights: _ArrayLikeComplex_co | None = None,
+    *,
+    returned: L[True],
+    keepdims: L[False] | _NoValueType = ...,
+) -> _Tuple2[np.complex128]: ...
+@overload  # complex array-like, axis=<given>, returned=True
+def average(
+    a: _ListSeqND[complex],
+    axis: int | tuple[int, ...],
+    weights: _ArrayLikeComplex_co | None = None,
+    *,
+    returned: L[True],
+    keepdims: L[False] | _NoValueType = ...,
+) -> _Tuple2[NDArray[np.complex128]]: ...
+@overload  # complex array-like, keepdims=True, returned=True
+def average(
+    a: _ListSeqND[complex],
+    axis: int | tuple[int, ...] | None = None,
+    weights: _ArrayLikeComplex_co | None = None,
+    *,
+    returned: L[True],
+    keepdims: L[True],
+) -> _Tuple2[NDArray[np.complex128]]: ...
+@overload  # unknown, axis=None
+def average(
+    a: _ArrayLikeNumber_co | _ArrayLikeObject_co,
+    axis: None = None,
+    weights: _ArrayLikeNumber_co | None = None,
+    returned: L[False] = False,
+    *,
+    keepdims: L[False] | _NoValueType = ...,
+) -> Any: ...
+@overload  # unknown, axis=<given>
+def average(
+    a: _ArrayLikeNumber_co | _ArrayLikeObject_co,
+    axis: int | tuple[int, ...],
+    weights: _ArrayLikeNumber_co | None = None,
+    returned: L[False] = False,
+    *,
+    keepdims: L[False] | _NoValueType = ...,
+) -> np.ndarray: ...
+@overload  # unknown, keepdims=True
+def average(
+    a: _ArrayLikeNumber_co | _ArrayLikeObject_co,
+    axis: int | tuple[int, ...] | None = None,
+    weights: _ArrayLikeNumber_co | None = None,
+    returned: L[False] = False,
+    *,
+    keepdims: L[True],
+) -> np.ndarray: ...
+@overload  # unknown, axis=None, returned=True
+def average(
+    a: _ArrayLikeNumber_co | _ArrayLikeObject_co,
+    axis: None = None,
+    weights: _ArrayLikeNumber_co | None = None,
+    *,
+    returned: L[True],
+    keepdims: L[False] | _NoValueType = ...,
+) -> _Tuple2[Any]: ...
+@overload  # unknown, axis=<given>, returned=True
+def average(
+    a: _ArrayLikeNumber_co | _ArrayLikeObject_co,
+    axis: int | tuple[int, ...],
+    weights: _ArrayLikeNumber_co | None = None,
+    *,
+    returned: L[True],
+    keepdims: L[False] | _NoValueType = ...,
+) -> _Tuple2[np.ndarray]: ...
+@overload  # unknown, returned=True, keepdims=True
+def average(
+    a: _ArrayLikeNumber_co | _ArrayLikeObject_co,
+    axis: int | tuple[int, ...] | None = None,
+    weights: _ArrayLikeNumber_co | None = None,
+    *,
+    returned: L[True],
+    keepdims: L[True],
+) -> _Tuple2[np.ndarray]: ...
+
+#
+@overload
+def asarray_chkfinite(a: _ArrayT, dtype: None = None, order: _OrderKACF = None) -> _ArrayT: ...
+@overload
+def asarray_chkfinite(
+    a: np.ndarray[_ShapeT], dtype: _DTypeLike[_ScalarT], order: _OrderKACF = None
+) -> _Array[_ShapeT, _ScalarT]: ...
+@overload
+def asarray_chkfinite(a: _ArrayLike[_ScalarT], dtype: None = None, order: _OrderKACF = None) -> NDArray[_ScalarT]: ...
+@overload
+def asarray_chkfinite(a: object, dtype: _DTypeLike[_ScalarT], order: _OrderKACF = None) -> NDArray[_ScalarT]: ...
+@overload
+def asarray_chkfinite(a: object, dtype: DTypeLike | None = None, order: _OrderKACF = None) -> NDArray[Incomplete]: ...
+
+# NOTE: Contrary to the documentation, scalars are also accepted and treated as
+# `[condlist]`. And even though the documentation says these should be boolean, in
+# practice anything that `np.array(condlist, dtype=bool)` accepts will work, i.e. any
+# array-like.
+@overload
+def piecewise(
+    x: _Array[_ShapeT, _ScalarT],
+    condlist: ArrayLike,
+    funclist: _PiecewiseFunctions[Any, _Tss],
+    *args: _Tss.args,
+    **kw: _Tss.kwargs,
+) -> _Array[_ShapeT, _ScalarT]: ...
+@overload
+def piecewise(
+    x: _ArrayLike[_ScalarT],
+    condlist: ArrayLike,
+    funclist: _PiecewiseFunctions[Any, _Tss],
+    *args: _Tss.args,
+    **kw: _Tss.kwargs,
+) -> NDArray[_ScalarT]: ...
+@overload
+def piecewise(
+    x: ArrayLike,
+    condlist: ArrayLike,
+    funclist: _PiecewiseFunctions[_ScalarT, _Tss],
+    *args: _Tss.args,
+    **kw: _Tss.kwargs,
+) -> NDArray[_ScalarT]: ...
+
+# NOTE: condition is usually boolean, but anything with zero/non-zero semantics works
+@overload
+def extract(condition: ArrayLike, arr: _ArrayLike[_ScalarT]) -> _Array1D[_ScalarT]: ...
+@overload
+def extract(condition: ArrayLike, arr: _SeqND[bool]) -> _Array1D[np.bool]: ...
+@overload
+def extract(condition: ArrayLike, arr: _ListSeqND[int]) -> _Array1D[np.int_]: ...
+@overload
+def extract(condition: ArrayLike, arr: _ListSeqND[float]) -> _Array1D[np.float64]: ...
+@overload
+def extract(condition: ArrayLike, arr: _ListSeqND[complex]) -> _Array1D[np.complex128]: ...
+@overload
+def extract(condition: ArrayLike, arr: _SeqND[bytes]) -> _Array1D[np.bytes_]: ...
+@overload
+def extract(condition: ArrayLike, arr: _SeqND[str]) -> _Array1D[np.str_]: ...
+@overload
+def extract(condition: ArrayLike, arr: ArrayLike) -> _Array1D[Incomplete]: ...
+
+# NOTE: unlike `extract`, passing non-boolean conditions for `condlist` will raise an
+# error at runtime
+@overload
+def select(
+    condlist: _SizedIterable[_ArrayLikeBool_co],
+    choicelist: Sequence[_ArrayT],
+    default: ArrayLike = 0,
+) -> _ArrayT: ...
+@overload
+def select(
+    condlist: _SizedIterable[_ArrayLikeBool_co],
+    choicelist: Sequence[_ArrayLike[_ScalarT]] | NDArray[_ScalarT],
+    default: ArrayLike = 0,
+) -> NDArray[_ScalarT]: ...
+@overload
+def select(
+    condlist: _SizedIterable[_ArrayLikeBool_co],
+    choicelist: Sequence[ArrayLike],
+    default: ArrayLike = 0,
+) -> np.ndarray: ...
+
+# keep roughly in sync with `ma.core.copy`
+@overload
+def copy(a: _ArrayT, order: _OrderKACF, subok: L[True]) -> _ArrayT: ...
+@overload
+def copy(a: _ArrayT, order: _OrderKACF = "K", *, subok: L[True]) -> _ArrayT: ...
+@overload
+def copy(a: _ArrayLike[_ScalarT], order: _OrderKACF = "K", subok: L[False] = False) -> NDArray[_ScalarT]: ...
+@overload
+def copy(a: ArrayLike, order: _OrderKACF = "K", subok: L[False] = False) -> NDArray[Incomplete]: ...
+
+#
+@overload  # ?d, known inexact scalar-type
+def gradient(
+    f: _ArrayNoD[_InexactTimeT],
+    *varargs: _ArrayLikeNumber_co,
+    axis: _ShapeLike | None = None,
+    edge_order: L[1, 2] = 1,
+    # `| Any` instead of ` | tuple` is returned to avoid several mypy_primer errors
+) -> _Array1D[_InexactTimeT] | Any: ...
+@overload  # 1d, known inexact scalar-type
+def gradient(
+    f: _Array1D[_InexactTimeT],
+    *varargs: _ArrayLikeNumber_co,
+    axis: _ShapeLike | None = None,
+    edge_order: L[1, 2] = 1,
+) -> _Array1D[_InexactTimeT]: ...
+@overload  # 2d, known inexact scalar-type
+def gradient(
+    f: _Array2D[_InexactTimeT],
+    *varargs: _ArrayLikeNumber_co,
+    axis: _ShapeLike | None = None,
+    edge_order: L[1, 2] = 1,
+) -> _Mesh2[_InexactTimeT, _InexactTimeT]: ...
+@overload  # 3d, known inexact scalar-type
+def gradient(
+    f: _Array3D[_InexactTimeT],
+    *varargs: _ArrayLikeNumber_co,
+    axis: _ShapeLike | None = None,
+    edge_order: L[1, 2] = 1,
+) -> _Mesh3[_InexactTimeT, _InexactTimeT, _InexactTimeT]: ...
+@overload  # ?d, datetime64 scalar-type
+def gradient(
+    f: _ArrayNoD[np.datetime64],
+    *varargs: _ArrayLikeNumber_co,
+    axis: _ShapeLike | None = None,
+    edge_order: L[1, 2] = 1,
+) -> _Array1D[np.timedelta64] | tuple[NDArray[np.timedelta64], ...]: ...
+@overload  # 1d, datetime64 scalar-type
+def gradient(
+    f: _Array1D[np.datetime64],
+    *varargs: _ArrayLikeNumber_co,
+    axis: _ShapeLike | None = None,
+    edge_order: L[1, 2] = 1,
+) -> _Array1D[np.timedelta64]: ...
+@overload  # 2d, datetime64 scalar-type
+def gradient(
+    f: _Array2D[np.datetime64],
+    *varargs: _ArrayLikeNumber_co,
+    axis: _ShapeLike | None = None,
+    edge_order: L[1, 2] = 1,
+) -> _Mesh2[np.timedelta64, np.timedelta64]: ...
+@overload  # 3d, datetime64 scalar-type
+def gradient(
+    f: _Array3D[np.datetime64],
+    *varargs: _ArrayLikeNumber_co,
+    axis: _ShapeLike | None = None,
+    edge_order: L[1, 2] = 1,
+) -> _Mesh3[np.timedelta64, np.timedelta64, np.timedelta64]: ...
+@overload  # 1d float-like
+def gradient(
+    f: _Seq1D[float],
+    *varargs: _ArrayLikeNumber_co,
+    axis: _ShapeLike | None = None,
+    edge_order: L[1, 2] = 1,
+) -> _Array1D[np.float64]: ...
+@overload  # 2d float-like
+def gradient(
+    f: _Seq2D[float],
+    *varargs: _ArrayLikeNumber_co,
+    axis: _ShapeLike | None = None,
+    edge_order: L[1, 2] = 1,
+) -> _Mesh2[np.float64, np.float64]: ...
+@overload  # 3d float-like
+def gradient(
+    f: _Seq3D[float],
+    *varargs: _ArrayLikeNumber_co,
+    axis: _ShapeLike | None = None,
+    edge_order: L[1, 2] = 1,
+) -> _Mesh3[np.float64, np.float64, np.float64]: ...
+@overload  # 1d complex-like  (the `list` avoids overlap with the float-like overload)
+def gradient(
+    f: list[complex],
+    *varargs: _ArrayLikeNumber_co,
+    axis: _ShapeLike | None = None,
+    edge_order: L[1, 2] = 1,
+) -> _Array1D[np.complex128]: ...
+@overload  # 2d float-like
+def gradient(
+    f: _Seq1D[list[complex]],
+    *varargs: _ArrayLikeNumber_co,
+    axis: _ShapeLike | None = None,
+    edge_order: L[1, 2] = 1,
+) -> _Mesh2[np.complex128, np.complex128]: ...
+@overload  # 3d float-like
+def gradient(
+    f: _Seq2D[list[complex]],
+    *varargs: _ArrayLikeNumber_co,
+    axis: _ShapeLike | None = None,
+    edge_order: L[1, 2] = 1,
+) -> _Mesh3[np.complex128, np.complex128, np.complex128]: ...
+@overload  # fallback
+def gradient(
+    f: ArrayLike,
+    *varargs: _ArrayLikeNumber_co,
+    axis: _ShapeLike | None = None,
+    edge_order: L[1, 2] = 1,
+) -> Incomplete: ...
+
+#
+@overload  # n == 0; return input unchanged
+def diff(
+    a: _T,
+    n: L[0],
+    axis: SupportsIndex = -1,
+    prepend: ArrayLike | _NoValueType = ...,  # = _NoValue
+    append: ArrayLike | _NoValueType = ...,  # = _NoValue
+) -> _T: ...
+@overload  # known array-type
+def diff(
+    a: _ArrayNumericT,
+    n: int = 1,
+    axis: SupportsIndex = -1,
+    prepend: ArrayLike | _NoValueType = ...,
+    append: ArrayLike | _NoValueType = ...,
+) -> _ArrayNumericT: ...
+@overload  # known shape, datetime64
+def diff(
+    a: _Array[_ShapeT, np.datetime64],
+    n: int = 1,
+    axis: SupportsIndex = -1,
+    prepend: ArrayLike | _NoValueType = ...,
+    append: ArrayLike | _NoValueType = ...,
+) -> _Array[_ShapeT, np.timedelta64]: ...
+@overload  # unknown shape, known scalar-type
+def diff(
+    a: _ArrayLike[_ScalarNumericT],
+    n: int = 1,
+    axis: SupportsIndex = -1,
+    prepend: ArrayLike | _NoValueType = ...,
+    append: ArrayLike | _NoValueType = ...,
+) -> NDArray[_ScalarNumericT]: ...
+@overload  # unknown shape, datetime64
+def diff(
+    a: _ArrayLike[np.datetime64],
+    n: int = 1,
+    axis: SupportsIndex = -1,
+    prepend: ArrayLike | _NoValueType = ...,
+    append: ArrayLike | _NoValueType = ...,
+) -> NDArray[np.timedelta64]: ...
+@overload  # 1d int
+def diff(
+    a: _Seq1D[int],
+    n: int = 1,
+    axis: SupportsIndex = -1,
+    prepend: ArrayLike | _NoValueType = ...,
+    append: ArrayLike | _NoValueType = ...,
+) -> _Array1D[np.int_]: ...
+@overload  # 2d int
+def diff(
+    a: _Seq2D[int],
+    n: int = 1,
+    axis: SupportsIndex = -1,
+    prepend: ArrayLike | _NoValueType = ...,
+    append: ArrayLike | _NoValueType = ...,
+) -> _Array2D[np.int_]: ...
+@overload  # 1d float  (the `list` avoids overlap with the `int` overloads)
+def diff(
+    a: list[float],
+    n: int = 1,
+    axis: SupportsIndex = -1,
+    prepend: ArrayLike | _NoValueType = ...,
+    append: ArrayLike | _NoValueType = ...,
+) -> _Array1D[np.float64]: ...
+@overload  # 2d float
+def diff(
+    a: _Seq1D[list[float]],
+    n: int = 1,
+    axis: SupportsIndex = -1,
+    prepend: ArrayLike | _NoValueType = ...,
+    append: ArrayLike | _NoValueType = ...,
+) -> _Array2D[np.float64]: ...
+@overload  # 1d complex  (the `list` avoids overlap with the `int` overloads)
+def diff(
+    a: list[complex],
+    n: int = 1,
+    axis: SupportsIndex = -1,
+    prepend: ArrayLike | _NoValueType = ...,
+    append: ArrayLike | _NoValueType = ...,
+) -> _Array1D[np.complex128]: ...
+@overload  # 2d complex
+def diff(
+    a: _Seq1D[list[complex]],
+    n: int = 1,
+    axis: SupportsIndex = -1,
+    prepend: ArrayLike | _NoValueType = ...,
+    append: ArrayLike | _NoValueType = ...,
+) -> _Array2D[np.complex128]: ...
+@overload  # unknown shape, unknown scalar-type
+def diff(
+    a: ArrayLike,
+    n: int = 1,
+    axis: SupportsIndex = -1,
+    prepend: ArrayLike | _NoValueType = ...,
+    append: ArrayLike | _NoValueType = ...,
+) -> NDArray[Incomplete]: ...
+
+#
+@overload  # float scalar
+def interp(
+    x: _FloatLike_co,
+    xp: _ArrayLikeFloat_co,
+    fp: _ArrayLikeFloat_co,
+    left: _FloatLike_co | None = None,
+    right: _FloatLike_co | None = None,
+    period: _FloatLike_co | None = None,
+) -> np.float64: ...
+@overload  # complex scalar
+def interp(
+    x: _FloatLike_co,
+    xp: _ArrayLikeFloat_co,
+    fp: _ArrayLike1D[np.complexfloating] | list[complex],
+    left: _NumberLike_co | None = None,
+    right: _NumberLike_co | None = None,
+    period: _FloatLike_co | None = None,
+) -> np.complex128: ...
+@overload  # float array
+def interp(
+    x: _Array[_ShapeT, _floating_co],
+    xp: _ArrayLikeFloat_co,
+    fp: _ArrayLikeFloat_co,
+    left: _FloatLike_co | None = None,
+    right: _FloatLike_co | None = None,
+    period: _FloatLike_co | None = None,
+) -> _Array[_ShapeT, np.float64]: ...
+@overload  # complex array
+def interp(
+    x: _Array[_ShapeT, _floating_co],
+    xp: _ArrayLikeFloat_co,
+    fp: _ArrayLike1D[np.complexfloating] | list[complex],
+    left: _NumberLike_co | None = None,
+    right: _NumberLike_co | None = None,
+    period: _FloatLike_co | None = None,
+) -> _Array[_ShapeT, np.complex128]: ...
+@overload  # float sequence
+def interp(
+    x: _Seq1D[_FloatLike_co],
+    xp: _ArrayLikeFloat_co,
+    fp: _ArrayLikeFloat_co,
+    left: _FloatLike_co | None = None,
+    right: _FloatLike_co | None = None,
+    period: _FloatLike_co | None = None,
+) -> _Array1D[np.float64]: ...
+@overload  # complex sequence
+def interp(
+    x: _Seq1D[_FloatLike_co],
+    xp: _ArrayLikeFloat_co,
+    fp: _ArrayLike1D[np.complexfloating] | list[complex],
+    left: _NumberLike_co | None = None,
+    right: _NumberLike_co | None = None,
+    period: _FloatLike_co | None = None,
+) -> _Array1D[np.complex128]: ...
+@overload  # float array-like
+def interp(
+    x: _SeqND[_FloatLike_co],
+    xp: _ArrayLikeFloat_co,
+    fp: _ArrayLikeFloat_co,
+    left: _FloatLike_co | None = None,
+    right: _FloatLike_co | None = None,
+    period: _FloatLike_co | None = None,
+) -> NDArray[np.float64]: ...
+@overload  # complex array-like
+def interp(
+    x: _SeqND[_FloatLike_co],
+    xp: _ArrayLikeFloat_co,
+    fp: _ArrayLike1D[np.complexfloating] | list[complex],
+    left: _NumberLike_co | None = None,
+    right: _NumberLike_co | None = None,
+    period: _FloatLike_co | None = None,
+) -> NDArray[np.complex128]: ...
+@overload  # float scalar/array-like
+def interp(
+    x: _ArrayLikeFloat_co,
+    xp: _ArrayLikeFloat_co,
+    fp: _ArrayLikeFloat_co,
+    left: _FloatLike_co | None = None,
+    right: _FloatLike_co | None = None,
+    period: _FloatLike_co | None = None,
+) -> NDArray[np.float64] | np.float64: ...
+@overload  # complex scalar/array-like
+def interp(
+    x: _ArrayLikeFloat_co,
+    xp: _ArrayLikeFloat_co,
+    fp: _ArrayLike1D[np.complexfloating],
+    left: _NumberLike_co | None = None,
+    right: _NumberLike_co | None = None,
+    period: _FloatLike_co | None = None,
+) -> NDArray[np.complex128] | np.complex128: ...
+@overload  # float/complex scalar/array-like
+def interp(
+    x: _ArrayLikeFloat_co,
+    xp: _ArrayLikeFloat_co,
+    fp: _ArrayLikeNumber_co,
+    left: _NumberLike_co | None = None,
+    right: _NumberLike_co | None = None,
+    period: _FloatLike_co | None = None,
+) -> NDArray[np.complex128 | np.float64] | np.complex128 | np.float64: ...
+
+#
+@overload  # 0d T: floating -> 0d T
+def angle(z: _FloatingT, deg: bool = False) -> _FloatingT: ...
+@overload  # 0d complex | float | ~integer -> 0d float64
+def angle(z: complex | _integer_co, deg: bool = False) -> np.float64: ...
+@overload  # 0d complex64 -> 0d float32
+def angle(z: np.complex64, deg: bool = False) -> np.float32: ...
+@overload  # 0d clongdouble -> 0d longdouble
+def angle(z: np.clongdouble, deg: bool = False) -> np.longdouble: ...
+@overload  # T: nd floating -> T
+def angle(z: _ArrayFloatingT, deg: bool = False) -> _ArrayFloatingT: ...
+@overload  # nd T: complex128 | ~integer -> nd float64
+def angle(z: _Array[_ShapeT, np.complex128 | _integer_co], deg: bool = False) -> _Array[_ShapeT, np.float64]: ...
+@overload  # nd T: complex64 -> nd float32
+def angle(z: _Array[_ShapeT, np.complex64], deg: bool = False) -> _Array[_ShapeT, np.float32]: ...
+@overload  # nd T: clongdouble -> nd longdouble
+def angle(z: _Array[_ShapeT, np.clongdouble], deg: bool = False) -> _Array[_ShapeT, np.longdouble]: ...
+@overload  # 1d complex -> 1d float64
+def angle(z: _Seq1D[complex], deg: bool = False) -> _Array1D[np.float64]: ...
+@overload  # 2d complex -> 2d float64
+def angle(z: _Seq2D[complex], deg: bool = False) -> _Array2D[np.float64]: ...
+@overload  # 3d complex -> 3d float64
+def angle(z: _Seq3D[complex], deg: bool = False) -> _Array3D[np.float64]: ...
+@overload  # fallback
+def angle(z: _ArrayLikeComplex_co, deg: bool = False) -> NDArray[np.floating] | Any: ...
+
+#
+@overload  # known array-type
+def unwrap(
+    p: _ArrayFloatObjT,
+    discont: float | None = None,
+    axis: int = -1,
+    *,
+    period: float = ...,  # = τ
+) -> _ArrayFloatObjT: ...
+@overload  # known shape, float64
+def unwrap(
+    p: _Array[_ShapeT, _float64_co],
+    discont: float | None = None,
+    axis: int = -1,
+    *,
+    period: float = ...,  # = τ
+) -> _Array[_ShapeT, np.float64]: ...
+@overload  # 1d float64-like
+def unwrap(
+    p: _Seq1D[float | _float64_co],
+    discont: float | None = None,
+    axis: int = -1,
+    *,
+    period: float = ...,  # = τ
+) -> _Array1D[np.float64]: ...
+@overload  # 2d float64-like
+def unwrap(
+    p: _Seq2D[float | _float64_co],
+    discont: float | None = None,
+    axis: int = -1,
+    *,
+    period: float = ...,  # = τ
+) -> _Array2D[np.float64]: ...
+@overload  # 3d float64-like
+def unwrap(
+    p: _Seq3D[float | _float64_co],
+    discont: float | None = None,
+    axis: int = -1,
+    *,
+    period: float = ...,  # = τ
+) -> _Array3D[np.float64]: ...
+@overload  # ?d, float64
+def unwrap(
+    p: _SeqND[float] | _ArrayLike[_float64_co],
+    discont: float | None = None,
+    axis: int = -1,
+    *,
+    period: float = ...,  # = τ
+) -> NDArray[np.float64]: ...
+@overload  # fallback
+def unwrap(
+    p: _ArrayLikeFloat_co | _ArrayLikeObject_co,
+    discont: float | None = None,
+    axis: int = -1,
+    *,
+    period: float = ...,  # = τ
+) -> np.ndarray: ...
+
+#
+@overload
+def sort_complex(a: _ArrayComplexT) -> _ArrayComplexT: ...
+@overload  # complex64, shape known
+def sort_complex(a: _Array[_ShapeT, np.int8 | np.uint8 | np.int16 | np.uint16]) -> _Array[_ShapeT, np.complex64]: ...
+@overload  # complex64, shape unknown
+def sort_complex(a: _ArrayLike[np.int8 | np.uint8 | np.int16 | np.uint16]) -> NDArray[np.complex64]: ...
+@overload  # complex128, shape known
+def sort_complex(a: _Array[_ShapeT, _SortsToComplex128]) -> _Array[_ShapeT, np.complex128]: ...
+@overload  # complex128, shape unknown
+def sort_complex(a: _ArrayLike[_SortsToComplex128]) -> NDArray[np.complex128]: ...
+@overload  # clongdouble, shape known
+def sort_complex(a: _Array[_ShapeT, np.longdouble]) -> _Array[_ShapeT, np.clongdouble]: ...
+@overload  # clongdouble, shape unknown
+def sort_complex(a: _ArrayLike[np.longdouble]) -> NDArray[np.clongdouble]: ...
+
+#
+def trim_zeros(filt: _TrimZerosSequence[_T], trim: L["f", "b", "fb", "bf"] = "fb", axis: _ShapeLike | None = None) -> _T: ...
+
+# NOTE: keep in sync with `corrcoef`
+@overload  # ?d, known inexact scalar-type >=64 precision, y=<given>.
+def cov(
+    m: _ArrayLike[_AnyDoubleT],
+    y: _ArrayLike[_AnyDoubleT],
+    rowvar: bool = True,
+    bias: bool = False,
+    ddof: SupportsIndex | SupportsInt | None = None,
+    fweights: _ArrayLikeInt_co | None = None,
+    aweights: _ArrayLikeFloat_co | None = None,
+    *,
+    dtype: None = None,
+) -> _Array2D[_AnyDoubleT]: ...
+@overload  # ?d, known inexact scalar-type >=64 precision, y=None -> 0d or 2d
+def cov(
+    m: _ArrayNoD[_AnyDoubleT],
+    y: None = None,
+    rowvar: bool = True,
+    bias: bool = False,
+    ddof: SupportsIndex | SupportsInt | None = None,
+    fweights: _ArrayLikeInt_co | None = None,
+    aweights: _ArrayLikeFloat_co | None = None,
+    *,
+    dtype: _DTypeLike[_AnyDoubleT] | None = None,
+) -> NDArray[_AnyDoubleT]: ...
+@overload  # 1d, known inexact scalar-type >=64 precision, y=None
+def cov(
+    m: _Array1D[_AnyDoubleT],
+    y: None = None,
+    rowvar: bool = True,
+    bias: bool = False,
+    ddof: SupportsIndex | SupportsInt | None = None,
+    fweights: _ArrayLikeInt_co | None = None,
+    aweights: _ArrayLikeFloat_co | None = None,
+    *,
+    dtype: _DTypeLike[_AnyDoubleT] | None = None,
+) -> _Array0D[_AnyDoubleT]: ...
+@overload  # nd, known inexact scalar-type >=64 precision, y=None -> 0d or 2d
+def cov(
+    m: _ArrayLike[_AnyDoubleT],
+    y: None = None,
+    rowvar: bool = True,
+    bias: bool = False,
+    ddof: SupportsIndex | SupportsInt | None = None,
+    fweights: _ArrayLikeInt_co | None = None,
+    aweights: _ArrayLikeFloat_co | None = None,
+    *,
+    dtype: _DTypeLike[_AnyDoubleT] | None = None,
+) -> NDArray[_AnyDoubleT]: ...
+@overload  # nd, casts to float64, y=<given>
+def cov(
+    m: NDArray[np.float32 | np.float16 | _integer_co] | _Seq1D[float] | _Seq2D[float],
+    y: NDArray[np.float32 | np.float16 | _integer_co] | _Seq1D[float] | _Seq2D[float],
+    rowvar: bool = True,
+    bias: bool = False,
+    ddof: SupportsIndex | SupportsInt | None = None,
+    fweights: _ArrayLikeInt_co | None = None,
+    aweights: _ArrayLikeFloat_co | None = None,
+    *,
+    dtype: _DTypeLike[np.float64] | None = None,
+) -> _Array2D[np.float64]: ...
+@overload  # ?d or 2d, casts to float64, y=None -> 0d or 2d
+def cov(
+    m: _ArrayNoD[np.float32 | np.float16 | _integer_co] | _Seq2D[float],
+    y: None = None,
+    rowvar: bool = True,
+    bias: bool = False,
+    ddof: SupportsIndex | SupportsInt | None = None,
+    fweights: _ArrayLikeInt_co | None = None,
+    aweights: _ArrayLikeFloat_co | None = None,
+    *,
+    dtype: _DTypeLike[np.float64] | None = None,
+) -> NDArray[np.float64]: ...
+@overload  # 1d, casts to float64, y=None
+def cov(
+    m:  _Array1D[np.float32 | np.float16 | _integer_co] | _Seq1D[float],
+    y: None = None,
+    rowvar: bool = True,
+    bias: bool = False,
+    ddof: SupportsIndex | SupportsInt | None = None,
+    fweights: _ArrayLikeInt_co | None = None,
+    aweights: _ArrayLikeFloat_co | None = None,
+    *,
+    dtype: _DTypeLike[np.float64] | None = None,
+) -> _Array0D[np.float64]: ...
+@overload  # nd, casts to float64, y=None -> 0d or 2d
+def cov(
+    m:  _ArrayLike[np.float32 | np.float16 | _integer_co],
+    y: None = None,
+    rowvar: bool = True,
+    bias: bool = False,
+    ddof: SupportsIndex | SupportsInt | None = None,
+    fweights: _ArrayLikeInt_co | None = None,
+    aweights: _ArrayLikeFloat_co | None = None,
+    *,
+    dtype: _DTypeLike[np.float64] | None = None,
+) -> NDArray[np.float64]: ...
+@overload  # 1d complex, y=<given>  (`list` avoids overlap with float overloads)
+def cov(
+    m: list[complex] | _Seq1D[list[complex]],
+    y: list[complex] | _Seq1D[list[complex]],
+    rowvar: bool = True,
+    bias: bool = False,
+    ddof: SupportsIndex | SupportsInt | None = None,
+    fweights: _ArrayLikeInt_co | None = None,
+    aweights: _ArrayLikeFloat_co | None = None,
+    *,
+    dtype: _DTypeLike[np.complex128] | None = None,
+) -> _Array2D[np.complex128]: ...
+@overload  # 1d complex, y=None
+def cov(
+    m: list[complex],
+    y: None = None,
+    rowvar: bool = True,
+    bias: bool = False,
+    ddof: SupportsIndex | SupportsInt | None = None,
+    fweights: _ArrayLikeInt_co | None = None,
+    aweights: _ArrayLikeFloat_co | None = None,
+    *,
+    dtype: _DTypeLike[np.complex128] | None = None,
+) -> _Array0D[np.complex128]: ...
+@overload  # 2d complex, y=None -> 0d or 2d
+def cov(
+    m: _Seq1D[list[complex]],
+    y: None = None,
+    rowvar: bool = True,
+    bias: bool = False,
+    ddof: SupportsIndex | SupportsInt | None = None,
+    fweights: _ArrayLikeInt_co | None = None,
+    aweights: _ArrayLikeFloat_co | None = None,
+    *,
+    dtype: _DTypeLike[np.complex128] | None = None,
+) -> NDArray[np.complex128]: ...
+@overload  # 1d complex-like, y=None, dtype=<known>
+def cov(
+    m: _Seq1D[_ComplexLike_co],
+    y: None = None,
+    rowvar: bool = True,
+    bias: bool = False,
+    ddof: SupportsIndex | SupportsInt | None = None,
+    fweights: _ArrayLikeInt_co | None = None,
+    aweights: _ArrayLikeFloat_co | None = None,
+    *,
+    dtype: _DTypeLike[_ScalarT],
+) -> _Array0D[_ScalarT]: ...
+@overload  # nd complex-like, y=<given>, dtype=<known>
+def cov(
+    m: _ArrayLikeComplex_co,
+    y: _ArrayLikeComplex_co,
+    rowvar: bool = True,
+    bias: bool = False,
+    ddof: SupportsIndex | SupportsInt | None = None,
+    fweights: _ArrayLikeInt_co | None = None,
+    aweights: _ArrayLikeFloat_co | None = None,
+    *,
+    dtype: _DTypeLike[_ScalarT],
+) -> _Array2D[_ScalarT]: ...
+@overload  # nd complex-like, y=None, dtype=<known> -> 0d or 2d
+def cov(
+    m: _ArrayLikeComplex_co,
+    y: None = None,
+    rowvar: bool = True,
+    bias: bool = False,
+    ddof: SupportsIndex | SupportsInt | None = None,
+    fweights: _ArrayLikeInt_co | None = None,
+    aweights: _ArrayLikeFloat_co | None = None,
+    *,
+    dtype: _DTypeLike[_ScalarT],
+) -> NDArray[_ScalarT]: ...
+@overload  # nd complex-like, y=<given>, dtype=?
+def cov(
+    m: _ArrayLikeComplex_co,
+    y: _ArrayLikeComplex_co,
+    rowvar: bool = True,
+    bias: bool = False,
+    ddof: SupportsIndex | SupportsInt | None = None,
+    fweights: _ArrayLikeInt_co | None = None,
+    aweights: _ArrayLikeFloat_co | None = None,
+    *,
+    dtype: DTypeLike | None = None,
+) -> _Array2D[Incomplete]: ...
+@overload  # 1d complex-like, y=None, dtype=?
+def cov(
+    m: _Seq1D[_ComplexLike_co],
+    y: None = None,
+    rowvar: bool = True,
+    bias: bool = False,
+    ddof: SupportsIndex | SupportsInt | None = None,
+    fweights: _ArrayLikeInt_co | None = None,
+    aweights: _ArrayLikeFloat_co | None = None,
+    *,
+    dtype: DTypeLike | None = None,
+) -> _Array0D[Incomplete]: ...
+@overload  # nd complex-like, dtype=?
+def cov(
+    m: _ArrayLikeComplex_co,
+    y: _ArrayLikeComplex_co | None = None,
+    rowvar: bool = True,
+    bias: bool = False,
+    ddof: SupportsIndex | SupportsInt | None = None,
+    fweights: _ArrayLikeInt_co | None = None,
+    aweights: _ArrayLikeFloat_co | None = None,
+    *,
+    dtype: DTypeLike | None = None,
+) -> NDArray[Incomplete]: ...
+
+# NOTE: If only `x` is given and the resulting array has shape (1,1), a bare scalar
+# is returned instead of a 2D array. When y is given, a 2D array is always returned.
+# This differs from `cov`, which returns 0-D arrays instead of scalars in such cases.
+# NOTE: keep in sync with `cov`
+@overload  # ?d, known inexact scalar-type >=64 precision, y=<given>.
+def corrcoef(
+    x: _ArrayLike[_AnyDoubleT],
+    y: _ArrayLike[_AnyDoubleT],
+    rowvar: bool = True,
+    *,
+    dtype: _DTypeLike[_AnyDoubleT] | None = None,
+) -> _Array2D[_AnyDoubleT]: ...
+@overload  # ?d, known inexact scalar-type >=64 precision, y=None
+def corrcoef(
+    x: _ArrayNoD[_AnyDoubleT],
+    y: None = None,
+    rowvar: bool = True,
+    *,
+    dtype: _DTypeLike[_AnyDoubleT] | None = None,
+) -> _Array2D[_AnyDoubleT] | _AnyDoubleT: ...
+@overload  # 1d, known inexact scalar-type >=64 precision, y=None
+def corrcoef(
+    x: _Array1D[_AnyDoubleT],
+    y: None = None,
+    rowvar: bool = True,
+    *,
+    dtype: _DTypeLike[_AnyDoubleT] | None = None,
+) -> _AnyDoubleT: ...
+@overload  # nd, known inexact scalar-type >=64 precision, y=None
+def corrcoef(
+    x: _ArrayLike[_AnyDoubleT],
+    y: None = None,
+    rowvar: bool = True,
+    *,
+    dtype: _DTypeLike[_AnyDoubleT] | None = None,
+) -> _Array2D[_AnyDoubleT] | _AnyDoubleT: ...
+@overload  # nd, casts to float64, y=<given>
+def corrcoef(
+    x: NDArray[np.float32 | np.float16 | _integer_co] | _Seq1D[float] | _Seq2D[float],
+    y: NDArray[np.float32 | np.float16 | _integer_co] | _Seq1D[float] | _Seq2D[float],
+    rowvar: bool = True,
+    *,
+    dtype: _DTypeLike[np.float64] | None = None,
+) -> _Array2D[np.float64]: ...
+@overload  # ?d or 2d, casts to float64, y=None
+def corrcoef(
+    x: _ArrayNoD[np.float32 | np.float16 | _integer_co] | _Seq2D[float],
+    y: None = None,
+    rowvar: bool = True,
+    *,
+    dtype: _DTypeLike[np.float64] | None = None,
+) -> _Array2D[np.float64] | np.float64: ...
+@overload  # 1d, casts to float64, y=None
+def corrcoef(
+    x: _Array1D[np.float32 | np.float16 | _integer_co] | _Seq1D[float],
+    y: None = None,
+    rowvar: bool = True,
+    *,
+    dtype: _DTypeLike[np.float64] | None = None,
+) -> np.float64: ...
+@overload  # nd, casts to float64, y=None
+def corrcoef(
+    x: _ArrayLike[np.float32 | np.float16 | _integer_co],
+    y: None = None,
+    rowvar: bool = True,
+    *,
+    dtype: _DTypeLike[np.float64] | None = None,
+) -> _Array2D[np.float64] | np.float64: ...
+@overload  # 1d complex, y=<given>  (`list` avoids overlap with float overloads)
+def corrcoef(
+    x: list[complex] | _Seq1D[list[complex]],
+    y: list[complex] | _Seq1D[list[complex]],
+    rowvar: bool = True,
+    *,
+    dtype: _DTypeLike[np.complex128] | None = None,
+) -> _Array2D[np.complex128]: ...
+@overload  # 1d complex, y=None
+def corrcoef(
+    x: list[complex],
+    y: None = None,
+    rowvar: bool = True,
+    *,
+    dtype: _DTypeLike[np.complex128] | None = None,
+) -> np.complex128: ...
+@overload  # 2d complex, y=None
+def corrcoef(
+    x: _Seq1D[list[complex]],
+    y: None = None,
+    rowvar: bool = True,
+    *,
+    dtype: _DTypeLike[np.complex128] | None = None,
+) -> _Array2D[np.complex128] | np.complex128: ...
+@overload  # 1d complex-like, y=None, dtype=<known>
+def corrcoef(
+    x: _Seq1D[_ComplexLike_co],
+    y: None = None,
+    rowvar: bool = True,
+    *,
+    dtype: _DTypeLike[_ScalarT],
+) -> _ScalarT: ...
+@overload  # nd complex-like, y=<given>, dtype=<known>
+def corrcoef(
+    x: _ArrayLikeComplex_co,
+    y: _ArrayLikeComplex_co,
+    rowvar: bool = True,
+    *,
+    dtype: _DTypeLike[_ScalarT],
+) -> _Array2D[_ScalarT]: ...
+@overload  # nd complex-like, y=None, dtype=<known>
+def corrcoef(
+    x: _ArrayLikeComplex_co,
+    y: None = None,
+    rowvar: bool = True,
+    *,
+    dtype: _DTypeLike[_ScalarT],
+) -> _Array2D[_ScalarT] | _ScalarT: ...
+@overload  # nd complex-like, y=<given>, dtype=?
+def corrcoef(
+    x: _ArrayLikeComplex_co,
+    y: _ArrayLikeComplex_co,
+    rowvar: bool = True,
+    *,
+    dtype: DTypeLike | None = None,
+) -> _Array2D[Incomplete]: ...
+@overload  # 1d complex-like, y=None, dtype=?
+def corrcoef(
+    x: _Seq1D[_ComplexLike_co],
+    y: None = None,
+    rowvar: bool = True,
+    *,
+    dtype: DTypeLike | None = None,
+) -> Incomplete: ...
+@overload  # nd complex-like, dtype=?
+def corrcoef(
+    x: _ArrayLikeComplex_co,
+    y: _ArrayLikeComplex_co | None = None,
+    rowvar: bool = True,
+    *,
+    dtype: DTypeLike | None = None,
+) -> _Array2D[Incomplete] | Incomplete: ...
+
+# note that floating `M` are accepted, but their fractional part is ignored
+def blackman(M: _FloatLike_co) -> _Array1D[np.float64]: ...
+def bartlett(M: _FloatLike_co) -> _Array1D[np.float64]: ...
+def hanning(M: _FloatLike_co) -> _Array1D[np.float64]: ...
+def hamming(M: _FloatLike_co) -> _Array1D[np.float64]: ...
+def kaiser(M: _FloatLike_co, beta: _FloatLike_co) -> _Array1D[np.float64]: ...
+
+#
+@overload
+def i0(x: _Array[_ShapeT, np.floating | np.integer]) -> _Array[_ShapeT, np.float64]: ...
+@overload
+def i0(x: _FloatLike_co) -> _Array0D[np.float64]: ...
+@overload
+def i0(x: _Seq1D[_FloatLike_co]) -> _Array1D[np.float64]: ...
+@overload
+def i0(x: _Seq2D[_FloatLike_co]) -> _Array2D[np.float64]: ...
+@overload
+def i0(x: _Seq3D[_FloatLike_co]) -> _Array3D[np.float64]: ...
+@overload
+def i0(x: _ArrayLikeFloat_co) -> NDArray[np.float64]: ...
+
+#
+@overload
+def sinc(x: _InexactT) -> _InexactT: ...
+@overload
+def sinc(x: float | _float64_co) -> np.float64: ...
+@overload
+def sinc(x: complex) -> np.complex128 | Any: ...
+@overload
+def sinc(x: _ArrayInexactT) -> _ArrayInexactT: ...
+@overload
+def sinc(x: _Array[_ShapeT, _integer_co]) -> _Array[_ShapeT, np.float64]: ...
+@overload
+def sinc(x: _Seq1D[float]) -> _Array1D[np.float64]: ...
+@overload
+def sinc(x: _Seq2D[float]) -> _Array2D[np.float64]: ...
+@overload
+def sinc(x: _Seq3D[float]) -> _Array3D[np.float64]: ...
+@overload
+def sinc(x: _SeqND[float]) -> NDArray[np.float64]: ...
+@overload
+def sinc(x: list[complex]) -> _Array1D[np.complex128]: ...
+@overload
+def sinc(x: _Seq1D[list[complex]]) -> _Array2D[np.complex128]: ...
+@overload
+def sinc(x: _Seq2D[list[complex]]) -> _Array3D[np.complex128]: ...
+@overload
+def sinc(x: _ArrayLikeComplex_co) -> np.ndarray | Any: ...
+
+# NOTE: We assume that `axis` is only provided for >=1-D arrays because for <1-D arrays
+# it has no effect, and would complicate the overloads significantly.
+@overload  # known scalar-type, keepdims=False (default)
+def median(
+    a: _ArrayLike[_InexactTimeT],
+    axis: None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    keepdims: L[False] = False,
+) -> _InexactTimeT: ...
+@overload  # float array-like, keepdims=False (default)
+def median(
+    a: _ArrayLikeInt_co | _SeqND[float] | float,
+    axis: None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    keepdims: L[False] = False,
+) -> np.float64: ...
+@overload  # complex array-like, keepdims=False (default)
+def median(
+    a: _ListSeqND[complex],
+    axis: None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    keepdims: L[False] = False,
+) -> np.complex128: ...
+@overload  # complex scalar, keepdims=False (default)
+def median(
+    a: complex,
+    axis: None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    keepdims: L[False] = False,
+) -> np.complex128 | Any: ...
+@overload  # known array-type, keepdims=True
+def median(
+    a: _ArrayNumericT,
+    axis: _ShapeLike | None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    *,
+    keepdims: L[True],
+) -> _ArrayNumericT: ...
+@overload  # known scalar-type, keepdims=True
+def median(
+    a: _ArrayLike[_ScalarNumericT],
+    axis: _ShapeLike | None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    *,
+    keepdims: L[True],
+) -> NDArray[_ScalarNumericT]: ...
+@overload  # known scalar-type, axis=<given>
+def median(
+    a: _ArrayLike[_ScalarNumericT],
+    axis: _ShapeLike,
+    out: None = None,
+    overwrite_input: bool = False,
+    keepdims: bool = False,
+) -> NDArray[_ScalarNumericT]: ...
+@overload  # float array-like, keepdims=True
+def median(
+    a: _SeqND[float],
+    axis: _ShapeLike | None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    *,
+    keepdims: L[True],
+) -> NDArray[np.float64]: ...
+@overload  # float array-like, axis=<given>
+def median(
+    a: _SeqND[float],
+    axis: _ShapeLike,
+    out: None = None,
+    overwrite_input: bool = False,
+    keepdims: bool = False,
+) -> NDArray[np.float64]: ...
+@overload  # complex array-like, keepdims=True
+def median(
+    a: _ListSeqND[complex],
+    axis: _ShapeLike | None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    *,
+    keepdims: L[True],
+) -> NDArray[np.complex128]: ...
+@overload  # complex array-like, axis=<given>
+def median(
+    a: _ListSeqND[complex],
+    axis: _ShapeLike,
+    out: None = None,
+    overwrite_input: bool = False,
+    keepdims: bool = False,
+) -> NDArray[np.complex128]: ...
+@overload  # out=<given> (keyword)
+def median(
+    a: _ArrayLikeComplex_co | _ArrayLike[np.timedelta64 | np.object_],
+    axis: _ShapeLike | None = None,
+    *,
+    out: _ArrayT,
+    overwrite_input: bool = False,
+    keepdims: bool = False,
+) -> _ArrayT: ...
+@overload  # out=<given> (positional)
+def median(
+    a: _ArrayLikeComplex_co | _ArrayLike[np.timedelta64 | np.object_],
+    axis: _ShapeLike | None,
+    out: _ArrayT,
+    overwrite_input: bool = False,
+    keepdims: bool = False,
+) -> _ArrayT: ...
+@overload  # fallback
+def median(
+    a: _ArrayLikeComplex_co | _ArrayLike[np.timedelta64 | np.object_],
+    axis: _ShapeLike | None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    keepdims: bool = False,
+) -> Incomplete: ...
+
+# NOTE: keep in sync with `quantile`
+@overload  # inexact, scalar, axis=None
+def percentile(
+    a: _ArrayLike[_InexactDateTimeT],
+    q: _FloatLike_co,
+    axis: None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: L[False] = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> _InexactDateTimeT: ...
+@overload  # inexact, scalar, axis=<given>
+def percentile(
+    a: _ArrayLike[_InexactDateTimeT],
+    q: _FloatLike_co,
+    axis: _ShapeLike,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: L[False] = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> NDArray[_InexactDateTimeT]: ...
+@overload  # inexact, scalar, keepdims=True
+def percentile(
+    a: _ArrayLike[_InexactDateTimeT],
+    q: _FloatLike_co,
+    axis: _ShapeLike | None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    *,
+    keepdims: L[True],
+    weights: _ArrayLikeFloat_co | None = None,
+) -> NDArray[_InexactDateTimeT]: ...
+@overload  # inexact, array, axis=None
+def percentile(
+    a: _ArrayLike[_InexactDateTimeT],
+    q: _Array[_ShapeT, _floating_co],
+    axis: None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: L[False] = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> _Array[_ShapeT, _InexactDateTimeT]: ...
+@overload  # inexact, array-like
+def percentile(
+    a: _ArrayLike[_InexactDateTimeT],
+    q: NDArray[_floating_co] | _SeqND[_FloatLike_co],
+    axis: _ShapeLike | None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: bool = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> NDArray[_InexactDateTimeT]: ...
+@overload  # float, scalar, axis=None
+def percentile(
+    a: _SeqND[float] | _ArrayLikeInt_co,
+    q: _FloatLike_co,
+    axis: None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: L[False] = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> np.float64: ...
+@overload  # float, scalar, axis=<given>
+def percentile(
+    a: _SeqND[float] | _ArrayLikeInt_co,
+    q: _FloatLike_co,
+    axis: _ShapeLike,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: L[False] = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> NDArray[np.float64]: ...
+@overload  # float, scalar, keepdims=True
+def percentile(
+    a: _SeqND[float] | _ArrayLikeInt_co,
+    q: _FloatLike_co,
+    axis: _ShapeLike | None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    *,
+    keepdims: L[True],
+    weights: _ArrayLikeFloat_co | None = None,
+) -> NDArray[np.float64]: ...
+@overload  # float, array, axis=None
+def percentile(
+    a: _SeqND[float] | _ArrayLikeInt_co,
+    q: _Array[_ShapeT, _floating_co],
+    axis: None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: L[False] = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> _Array[_ShapeT, np.float64]: ...
+@overload  # float, array-like
+def percentile(
+    a: _SeqND[float] | _ArrayLikeInt_co,
+    q: NDArray[_floating_co] | _SeqND[_FloatLike_co],
+    axis: _ShapeLike | None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: bool = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> NDArray[np.float64]: ...
+@overload  # complex, scalar, axis=None
+def percentile(
+    a: _ListSeqND[complex],
+    q: _FloatLike_co,
+    axis: None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: L[False] = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> np.complex128: ...
+@overload  # complex, scalar, axis=<given>
+def percentile(
+    a: _ListSeqND[complex],
+    q: _FloatLike_co,
+    axis: _ShapeLike,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: L[False] = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> NDArray[np.complex128]: ...
+@overload  # complex, scalar, keepdims=True
+def percentile(
+    a: _ListSeqND[complex],
+    q: _FloatLike_co,
+    axis: _ShapeLike | None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    *,
+    keepdims: L[True],
+    weights: _ArrayLikeFloat_co | None = None,
+) -> NDArray[np.complex128]: ...
+@overload  # complex, array, axis=None
+def percentile(
+    a: _ListSeqND[complex],
+    q: _Array[_ShapeT, _floating_co],
+    axis: None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: L[False] = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> _Array[_ShapeT, np.complex128]: ...
+@overload  # complex, array-like
+def percentile(
+    a: _ListSeqND[complex],
+    q: NDArray[_floating_co] | _SeqND[_FloatLike_co],
+    axis: _ShapeLike | None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: bool = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> NDArray[np.complex128]: ...
+@overload  # object_, scalar, axis=None
+def percentile(
+    a: _ArrayLikeObject_co,
+    q: _FloatLike_co,
+    axis: None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: L[False] = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> Any: ...
+@overload  # object_, scalar, axis=<given>
+def percentile(
+    a: _ArrayLikeObject_co,
+    q: _FloatLike_co,
+    axis: _ShapeLike,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: L[False] = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> NDArray[np.object_]: ...
+@overload  # object_, scalar, keepdims=True
+def percentile(
+    a: _ArrayLikeObject_co,
+    q: _FloatLike_co,
+    axis: _ShapeLike | None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    *,
+    keepdims: L[True],
+    weights: _ArrayLikeFloat_co | None = None,
+) -> NDArray[np.object_]: ...
+@overload  # object_, array, axis=None
+def percentile(
+    a: _ArrayLikeObject_co,
+    q: _Array[_ShapeT, _floating_co],
+    axis: None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: L[False] = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> _Array[_ShapeT, np.object_]: ...
+@overload  # object_, array-like
+def percentile(
+    a: _ArrayLikeObject_co,
+    q: NDArray[_floating_co] | _SeqND[_FloatLike_co],
+    axis: _ShapeLike | None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: bool = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> NDArray[np.object_]: ...
+@overload  # out=<given> (keyword)
+def percentile(
+    a: ArrayLike,
+    q: _ArrayLikeFloat_co,
+    axis: _ShapeLike | None,
+    out: _ArrayT,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: bool = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> _ArrayT: ...
+@overload  # out=<given> (positional)
+def percentile(
+    a: ArrayLike,
+    q: _ArrayLikeFloat_co,
+    axis: _ShapeLike | None = None,
+    *,
+    out: _ArrayT,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: bool = False,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> _ArrayT: ...
+@overload  # fallback
+def percentile(
+    a: _ArrayLikeNumber_co | _ArrayLikeObject_co,
+    q: _ArrayLikeFloat_co,
+    axis: _ShapeLike | None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: bool = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> Incomplete: ...
+
+# NOTE: keep in sync with `percentile`
+@overload  # inexact, scalar, axis=None
+def quantile(
+    a: _ArrayLike[_InexactDateTimeT],
+    q: _FloatLike_co,
+    axis: None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: L[False] = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> _InexactDateTimeT: ...
+@overload  # inexact, scalar, axis=<given>
+def quantile(
+    a: _ArrayLike[_InexactDateTimeT],
+    q: _FloatLike_co,
+    axis: _ShapeLike,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: L[False] = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> NDArray[_InexactDateTimeT]: ...
+@overload  # inexact, scalar, keepdims=True
+def quantile(
+    a: _ArrayLike[_InexactDateTimeT],
+    q: _FloatLike_co,
+    axis: _ShapeLike | None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    *,
+    keepdims: L[True],
+    weights: _ArrayLikeFloat_co | None = None,
+) -> NDArray[_InexactDateTimeT]: ...
+@overload  # inexact, array, axis=None
+def quantile(
+    a: _ArrayLike[_InexactDateTimeT],
+    q: _Array[_ShapeT, _floating_co],
+    axis: None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: L[False] = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> _Array[_ShapeT, _InexactDateTimeT]: ...
+@overload  # inexact, array-like
+def quantile(
+    a: _ArrayLike[_InexactDateTimeT],
+    q: NDArray[_floating_co] | _SeqND[_FloatLike_co],
+    axis: _ShapeLike | None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: bool = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> NDArray[_InexactDateTimeT]: ...
+@overload  # float, scalar, axis=None
+def quantile(
+    a: _SeqND[float] | _ArrayLikeInt_co,
+    q: _FloatLike_co,
+    axis: None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: L[False] = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> np.float64: ...
+@overload  # float, scalar, axis=<given>
+def quantile(
+    a: _SeqND[float] | _ArrayLikeInt_co,
+    q: _FloatLike_co,
+    axis: _ShapeLike,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: L[False] = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> NDArray[np.float64]: ...
+@overload  # float, scalar, keepdims=True
+def quantile(
+    a: _SeqND[float] | _ArrayLikeInt_co,
+    q: _FloatLike_co,
+    axis: _ShapeLike | None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    *,
+    keepdims: L[True],
+    weights: _ArrayLikeFloat_co | None = None,
+) -> NDArray[np.float64]: ...
+@overload  # float, array, axis=None
+def quantile(
+    a: _SeqND[float] | _ArrayLikeInt_co,
+    q: _Array[_ShapeT, _floating_co],
+    axis: None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: L[False] = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> _Array[_ShapeT, np.float64]: ...
+@overload  # float, array-like
+def quantile(
+    a: _SeqND[float] | _ArrayLikeInt_co,
+    q: NDArray[_floating_co] | _SeqND[_FloatLike_co],
+    axis: _ShapeLike | None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: bool = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> NDArray[np.float64]: ...
+@overload  # complex, scalar, axis=None
+def quantile(
+    a: _ListSeqND[complex],
+    q: _FloatLike_co,
+    axis: None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: L[False] = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> np.complex128: ...
+@overload  # complex, scalar, axis=<given>
+def quantile(
+    a: _ListSeqND[complex],
+    q: _FloatLike_co,
+    axis: _ShapeLike,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: L[False] = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> NDArray[np.complex128]: ...
+@overload  # complex, scalar, keepdims=True
+def quantile(
+    a: _ListSeqND[complex],
+    q: _FloatLike_co,
+    axis: _ShapeLike | None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    *,
+    keepdims: L[True],
+    weights: _ArrayLikeFloat_co | None = None,
+) -> NDArray[np.complex128]: ...
+@overload  # complex, array, axis=None
+def quantile(
+    a: _ListSeqND[complex],
+    q: _Array[_ShapeT, _floating_co],
+    axis: None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: L[False] = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> _Array[_ShapeT, np.complex128]: ...
+@overload  # complex, array-like
+def quantile(
+    a: _ListSeqND[complex],
+    q: NDArray[_floating_co] | _SeqND[_FloatLike_co],
+    axis: _ShapeLike | None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: bool = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> NDArray[np.complex128]: ...
+@overload  # object_, scalar, axis=None
+def quantile(
+    a: _ArrayLikeObject_co,
+    q: _FloatLike_co,
+    axis: None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: L[False] = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> Any: ...
+@overload  # object_, scalar, axis=<given>
+def quantile(
+    a: _ArrayLikeObject_co,
+    q: _FloatLike_co,
+    axis: _ShapeLike,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: L[False] = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> NDArray[np.object_]: ...
+@overload  # object_, scalar, keepdims=True
+def quantile(
+    a: _ArrayLikeObject_co,
+    q: _FloatLike_co,
+    axis: _ShapeLike | None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    *,
+    keepdims: L[True],
+    weights: _ArrayLikeFloat_co | None = None,
+) -> NDArray[np.object_]: ...
+@overload  # object_, array, axis=None
+def quantile(
+    a: _ArrayLikeObject_co,
+    q: _Array[_ShapeT, _floating_co],
+    axis: None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: L[False] = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> _Array[_ShapeT, np.object_]: ...
+@overload  # object_, array-like
+def quantile(
+    a: _ArrayLikeObject_co,
+    q: NDArray[_floating_co] | _SeqND[_FloatLike_co],
+    axis: _ShapeLike | None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: bool = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> NDArray[np.object_]: ...
+@overload  # out=<given> (keyword)
+def quantile(
+    a: ArrayLike,
+    q: _ArrayLikeFloat_co,
+    axis: _ShapeLike | None,
+    out: _ArrayT,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: bool = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> _ArrayT: ...
+@overload  # out=<given> (positional)
+def quantile(
+    a: ArrayLike,
+    q: _ArrayLikeFloat_co,
+    axis: _ShapeLike | None = None,
+    *,
+    out: _ArrayT,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: bool = False,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> _ArrayT: ...
+@overload  # fallback
+def quantile(
+    a: _ArrayLikeNumber_co | _ArrayLikeObject_co,
+    q: _ArrayLikeFloat_co,
+    axis: _ShapeLike | None = None,
+    out: None = None,
+    overwrite_input: bool = False,
+    method: _InterpolationMethod = "linear",
+    keepdims: bool = False,
+    *,
+    weights: _ArrayLikeFloat_co | None = None,
+) -> Incomplete: ...
+
+#
+@overload  # ?d, known inexact/timedelta64 scalar-type
+def trapezoid(
+    y: _ArrayNoD[_InexactTimeT],
+    x: _ArrayLike[_InexactTimeT] | _ArrayLikeFloat_co | None = None,
+    dx: float = 1.0,
+    axis: SupportsIndex = -1,
+) -> NDArray[_InexactTimeT] | _InexactTimeT: ...
+@overload  # ?d, casts to float64
+def trapezoid(
+    y: _ArrayNoD[_integer_co],
+    x: _ArrayLikeFloat_co | None = None,
+    dx: float = 1.0,
+    axis: SupportsIndex = -1,
+) -> NDArray[np.float64] | np.float64: ...
+@overload  # strict 1d, known inexact/timedelta64 scalar-type
+def trapezoid(
+    y: _Array1D[_InexactTimeT],
+    x: _Array1D[_InexactTimeT] | _Seq1D[float] | None = None,
+    dx: float = 1.0,
+    axis: SupportsIndex = -1,
+) -> _InexactTimeT: ...
+@overload  # strict 1d, casts to float64
+def trapezoid(
+    y: _Array1D[_float64_co] | _Seq1D[float],
+    x: _Array1D[_float64_co] | _Seq1D[float] | None = None,
+    dx: float = 1.0,
+    axis: SupportsIndex = -1,
+) -> np.float64: ...
+@overload  # strict 1d, casts to complex128 (`list` prevents overlapping overloads)
+def trapezoid(
+    y: list[complex],
+    x: _Seq1D[complex] | None = None,
+    dx: complex = 1.0,
+    axis: SupportsIndex = -1,
+) -> np.complex128: ...
+@overload  # strict 1d, casts to complex128
+def trapezoid(
+    y: _Seq1D[complex],
+    x: list[complex],
+    dx: complex = 1.0,
+    axis: SupportsIndex = -1,
+) -> np.complex128: ...
+@overload  # strict 2d, known inexact/timedelta64 scalar-type
+def trapezoid(
+    y: _Array2D[_InexactTimeT],
+    x: _ArrayMax2D[_InexactTimeT] | _Seq2D[float] | _Seq1D[float] | None = None,
+    dx: float = 1.0,
+    axis: SupportsIndex = -1,
+) -> _InexactTimeT: ...
+@overload  # strict 2d, casts to float64
+def trapezoid(
+    y: _Array2D[_float64_co] | _Seq2D[float],
+    x: _ArrayMax2D[_float64_co] | _Seq2D[float] | _Seq1D[float] | None = None,
+    dx: float = 1.0,
+    axis: SupportsIndex = -1,
+) -> np.float64: ...
+@overload  # strict 2d, casts to complex128 (`list` prevents overlapping overloads)
+def trapezoid(
+    y: _Seq1D[list[complex]],
+    x: _Seq2D[complex] | _Seq1D[complex] | None = None,
+    dx: complex = 1.0,
+    axis: SupportsIndex = -1,
+) -> np.complex128: ...
+@overload  # strict 2d, casts to complex128
+def trapezoid(
+    y: _Seq2D[complex] | _Seq1D[complex],
+    x: _Seq1D[list[complex]],
+    dx: complex = 1.0,
+    axis: SupportsIndex = -1,
+) -> np.complex128: ...
+@overload
+def trapezoid(
+    y: _ArrayLike[_InexactTimeT],
+    x: _ArrayLike[_InexactTimeT] | _ArrayLikeInt_co | None = None,
+    dx: complex = 1.0,
+    axis: SupportsIndex = -1,
+) -> NDArray[_InexactTimeT] | _InexactTimeT: ...
+@overload
+def trapezoid(
+    y: _ArrayLike[_float64_co],
+    x: _ArrayLikeFloat_co | None = None,
+    dx: float = 1.0,
+    axis: SupportsIndex = -1,
+) -> NDArray[np.float64] | np.float64: ...
+@overload
+def trapezoid(
+    y: _ArrayLike[np.complex128],
+    x: _ArrayLikeComplex_co | None = None,
+    dx: float = 1.0,
+    axis: SupportsIndex = -1,
+) -> NDArray[np.complex128] | np.complex128: ...
+@overload
+def trapezoid(
+    y: _ArrayLikeComplex_co,
+    x: _ArrayLike[np.complex128],
+    dx: float = 1.0,
+    axis: SupportsIndex = -1,
+) -> NDArray[np.complex128] | np.complex128: ...
+@overload
+def trapezoid(
+    y: _ArrayLikeObject_co,
+    x: _ArrayLikeObject_co | _ArrayLikeFloat_co | None = None,
+    dx: float = 1.0,
+    axis: SupportsIndex = -1,
+) -> NDArray[np.object_] | Any: ...
+@overload
+def trapezoid(
+    y: _Seq1D[_SupportsRMulFloat[_T]],
+    x: _Seq1D[_SupportsRMulFloat[_T] | _T] | None = None,
+    dx: complex = 1.0,
+    axis: SupportsIndex = -1,
+) -> _T: ...
+@overload
+def trapezoid(
+    y: _ArrayLikeComplex_co | _ArrayLike[np.timedelta64 | np.object_],
+    x: _ArrayLikeComplex_co | _ArrayLike[np.timedelta64 | np.object_] | None = None,
+    dx: complex = 1.0,
+    axis: SupportsIndex = -1,
+) -> Incomplete: ...
+
+#
+@overload  # 0d
+def meshgrid(*, copy: bool = True, sparse: bool = False, indexing: _Indexing = "xy") -> tuple[()]: ...
+@overload  # 1d, known scalar-type
+def meshgrid(
+    x1: _ArrayLike[_ScalarT],
+    /,
+    *,
+    copy: bool = True,
+    sparse: bool = False,
+    indexing: _Indexing = "xy",
+) -> _Mesh1[_ScalarT]: ...
+@overload  # 1d, unknown scalar-type
+def meshgrid(
+    x1: ArrayLike,
+    /,
+    *,
+    copy: bool = True,
+    sparse: bool = False,
+    indexing: _Indexing = "xy",
+) -> _Mesh1[Any]: ...
+@overload  # 2d, known scalar-types
+def meshgrid(
+    x1: _ArrayLike[_ScalarT],
+    x2: _ArrayLike[_ScalarT1],
+    /,
+    *,
+    copy: bool = True,
+    sparse: bool = False,
+    indexing: _Indexing = "xy",
+) -> _Mesh2[_ScalarT, _ScalarT1]: ...
+@overload  # 2d, known/unknown scalar-types
+def meshgrid(
+    x1: _ArrayLike[_ScalarT],
+    x2: ArrayLike,
+    /,
+    *,
+    copy: bool = True,
+    sparse: bool = False,
+    indexing: _Indexing = "xy",
+) -> _Mesh2[_ScalarT, Any]: ...
+@overload  # 2d, unknown/known scalar-types
+def meshgrid(
+    x1: ArrayLike,
+    x2: _ArrayLike[_ScalarT],
+    /,
+    *,
+    copy: bool = True,
+    sparse: bool = False,
+    indexing: _Indexing = "xy",
+) -> _Mesh2[Any, _ScalarT]: ...
+@overload  # 2d, unknown scalar-types
+def meshgrid(
+    x1: ArrayLike,
+    x2: ArrayLike,
+    /,
+    *,
+    copy: bool = True,
+    sparse: bool = False,
+    indexing: _Indexing = "xy",
+) -> _Mesh2[Any, Any]: ...
+@overload  # 3d, known scalar-types
+def meshgrid(
+    x1: _ArrayLike[_ScalarT],
+    x2: _ArrayLike[_ScalarT1],
+    x3: _ArrayLike[_ScalarT2],
+    /,
+    *,
+    copy: bool = True,
+    sparse: bool = False,
+    indexing: _Indexing = "xy",
+) -> _Mesh3[_ScalarT, _ScalarT1, _ScalarT2]: ...
+@overload  # 3d, unknown scalar-types
+def meshgrid(
+    x1: ArrayLike,
+    x2: ArrayLike,
+    x3: ArrayLike,
+    /,
+    *,
+    copy: bool = True,
+    sparse: bool = False,
+    indexing: _Indexing = "xy",
+) -> _Mesh3[Any, Any, Any]: ...
+@overload  # ?d, known scalar-types
+def meshgrid(
+    *xi: _ArrayLike[_ScalarT],
+    copy: bool = True,
+    sparse: bool = False,
+    indexing: _Indexing = "xy",
+) -> tuple[NDArray[_ScalarT], ...]: ...
+@overload  # ?d, unknown scalar-types
+def meshgrid(
+    *xi: ArrayLike,
+    copy: bool = True,
+    sparse: bool = False,
+    indexing: _Indexing = "xy",
+) -> tuple[NDArray[Any], ...]: ...
+
+#
+def place(arr: np.ndarray, mask: ConvertibleToInt | Sequence[ConvertibleToInt], vals: ArrayLike) -> None: ...
+
+# keep in sync with `insert`
+@overload  # known scalar-type, axis=None (default)
+def delete(arr: _ArrayLike[_ScalarT], obj: _IndexLike, axis: None = None) -> _Array1D[_ScalarT]: ...
+@overload  # known array-type, axis specified
+def delete(arr: _ArrayT, obj: _IndexLike, axis: SupportsIndex) -> _ArrayT: ...
+@overload  # known scalar-type, axis specified
+def delete(arr: _ArrayLike[_ScalarT], obj: _IndexLike, axis: SupportsIndex) -> NDArray[_ScalarT]: ...
+@overload  # known scalar-type, axis=None (default)
+def delete(arr: ArrayLike, obj: _IndexLike, axis: None = None) -> _Array1D[Any]: ...
+@overload  # unknown scalar-type, axis specified
+def delete(arr: ArrayLike, obj: _IndexLike, axis: SupportsIndex) -> NDArray[Any]: ...
+
+# keep in sync with `delete`
+@overload  # known scalar-type, axis=None (default)
+def insert(arr: _ArrayLike[_ScalarT], obj: _IndexLike, values: ArrayLike, axis: None = None) -> _Array1D[_ScalarT]: ...
+@overload  # known array-type, axis specified
+def insert(arr: _ArrayT, obj: _IndexLike, values: ArrayLike, axis: SupportsIndex) -> _ArrayT: ...
+@overload  # known scalar-type, axis specified
+def insert(arr: _ArrayLike[_ScalarT], obj: _IndexLike, values: ArrayLike, axis: SupportsIndex) -> NDArray[_ScalarT]: ...
+@overload  # known scalar-type, axis=None (default)
+def insert(arr: ArrayLike, obj: _IndexLike, values: ArrayLike, axis: None = None) -> _Array1D[Any]: ...
+@overload  # unknown scalar-type, axis specified
+def insert(arr: ArrayLike, obj: _IndexLike, values: ArrayLike, axis: SupportsIndex) -> NDArray[Any]: ...
+
+#
+@overload  # known array type, axis specified
+def append(arr: _ArrayT, values: _ArrayT, axis: SupportsIndex) -> _ArrayT: ...
+@overload  # 1d, known scalar type, axis specified
+def append(arr: _Seq1D[_ScalarT], values: _Seq1D[_ScalarT], axis: SupportsIndex) -> _Array1D[_ScalarT]: ...
+@overload  # 2d, known scalar type, axis specified
+def append(arr: _Seq2D[_ScalarT], values: _Seq2D[_ScalarT], axis: SupportsIndex) -> _Array2D[_ScalarT]: ...
+@overload  # 3d, known scalar type, axis specified
+def append(arr: _Seq3D[_ScalarT], values: _Seq3D[_ScalarT], axis: SupportsIndex) -> _Array3D[_ScalarT]: ...
+@overload  # ?d, known scalar type, axis specified
+def append(arr: _SeqND[_ScalarT], values: _SeqND[_ScalarT], axis: SupportsIndex) -> NDArray[_ScalarT]: ...
+@overload  # ?d, unknown scalar type, axis specified
+def append(arr: np.ndarray | _SeqND[_ScalarLike_co], values: _SeqND[_ScalarLike_co], axis: SupportsIndex) -> np.ndarray: ...
+@overload  # known scalar type, axis=None
+def append(arr: _ArrayLike[_ScalarT], values: _ArrayLike[_ScalarT], axis: None = None) -> _Array1D[_ScalarT]: ...
+@overload  # unknown scalar type, axis=None
+def append(arr: ArrayLike, values: ArrayLike, axis: None = None) -> _Array1D[Any]: ...
+
+#
+@overload
+def digitize(
+    x: _Array[_ShapeT, np.floating | np.integer], bins: _ArrayLikeFloat_co, right: bool = False
+) -> _Array[_ShapeT, np.int_]: ...
+@overload
+def digitize(x: _FloatLike_co, bins: _ArrayLikeFloat_co, right: bool = False) -> np.int_: ...
+@overload
+def digitize(x: _Seq1D[_FloatLike_co], bins: _ArrayLikeFloat_co, right: bool = False) -> _Array1D[np.int_]: ...
+@overload
+def digitize(x: _Seq2D[_FloatLike_co], bins: _ArrayLikeFloat_co, right: bool = False) -> _Array2D[np.int_]: ...
+@overload
+def digitize(x: _Seq3D[_FloatLike_co], bins: _ArrayLikeFloat_co, right: bool = False) -> _Array3D[np.int_]: ...
+@overload
+def digitize(x: _ArrayLikeFloat_co, bins: _ArrayLikeFloat_co, right: bool = False) -> NDArray[np.int_] | Any: ...