codekingpro/portable-devtools
115k
1from _typeshed import ConvertibleToInt, Incomplete
2from collections.abc import Callable, Iterable, Sequence
3from typing import (
4 Any,
5 Concatenate,
6 Literal as L,
7 Never,
8 ParamSpec,
9 Protocol,
10 SupportsIndex,
11 SupportsInt,
12 TypeAlias,
13 overload,
14 type_check_only,
15)
16from typing_extensions import TypeIs, TypeVar
17
18import numpy as np
19from numpy import _OrderKACF
20from numpy._core.multiarray import bincount
21from numpy._globals import _NoValueType
22from numpy._typing import (
23 ArrayLike,
24 DTypeLike,
25 NDArray,
26 _ArrayLike,
27 _ArrayLikeBool_co,
28 _ArrayLikeComplex_co,
29 _ArrayLikeFloat_co,
30 _ArrayLikeInt_co,
31 _ArrayLikeNumber_co,
32 _ArrayLikeObject_co,
33 _ComplexLike_co,
34 _DTypeLike,
35 _FloatLike_co,
36 _NestedSequence as _SeqND,
37 _NumberLike_co,
38 _ScalarLike_co,
39 _ShapeLike,
40 _SupportsArray,
41)
42
43__all__ = [
44 "select",
45 "piecewise",
46 "trim_zeros",
47 "copy",
48 "iterable",
49 "percentile",
50 "diff",
51 "gradient",
52 "angle",
53 "unwrap",
54 "sort_complex",
55 "flip",
56 "rot90",
57 "extract",
58 "place",
59 "vectorize",
60 "asarray_chkfinite",
61 "average",
62 "bincount",
63 "digitize",
64 "cov",
65 "corrcoef",
66 "median",
67 "sinc",
68 "hamming",
69 "hanning",
70 "bartlett",
71 "blackman",
72 "kaiser",
73 "trapezoid",
74 "i0",
75 "meshgrid",
76 "delete",
77 "insert",
78 "append",
79 "interp",
80 "quantile",
81]
82
83_T = TypeVar("_T")
84_T_co = TypeVar("_T_co", covariant=True)
85# The `{}ss` suffix refers to the PEP 695 (Python 3.12) `ParamSpec` syntax, `**P`.
86_Tss = ParamSpec("_Tss")
87
88_ScalarT = TypeVar("_ScalarT", bound=np.generic)
89_ScalarT1 = TypeVar("_ScalarT1", bound=np.generic)
90_ScalarT2 = TypeVar("_ScalarT2", bound=np.generic)
91_FloatingT = TypeVar("_FloatingT", bound=np.floating)
92_InexactT = TypeVar("_InexactT", bound=np.inexact)
93_InexactTimeT = TypeVar("_InexactTimeT", bound=np.inexact | np.timedelta64)
94_InexactDateTimeT = TypeVar("_InexactDateTimeT", bound=np.inexact | np.timedelta64 | np.datetime64)
95_ScalarNumericT = TypeVar("_ScalarNumericT", bound=np.inexact | np.timedelta64 | np.object_)
96_AnyDoubleT = TypeVar("_AnyDoubleT", bound=np.float64 | np.longdouble | np.complex128 | np.clongdouble)
97
98_ArrayT = TypeVar("_ArrayT", bound=np.ndarray)
99_ArrayFloatingT = TypeVar("_ArrayFloatingT", bound=NDArray[np.floating])
100_ArrayFloatObjT = TypeVar("_ArrayFloatObjT", bound=NDArray[np.floating | np.object_])
101_ArrayComplexT = TypeVar("_ArrayComplexT", bound=NDArray[np.complexfloating])
102_ArrayInexactT = TypeVar("_ArrayInexactT", bound=NDArray[np.inexact])
103_ArrayNumericT = TypeVar("_ArrayNumericT", bound=NDArray[np.inexact | np.timedelta64 | np.object_])
104
105_ArrayLike1D: TypeAlias = _SupportsArray[np.dtype[_ScalarT]] | Sequence[_ScalarT]
106
107_ShapeT = TypeVar("_ShapeT", bound=tuple[int, ...])
108
109_integer_co: TypeAlias = np.integer | np.bool
110_float64_co: TypeAlias = np.float64 | _integer_co
111_floating_co: TypeAlias = np.floating | _integer_co
112
113# non-trivial scalar-types that will become `complex128` in `sort_complex()`,
114# i.e. all numeric scalar types except for `[u]int{8,16} | longdouble`
115_SortsToComplex128: TypeAlias = (
116 np.bool
117 | np.int32
118 | np.uint32
119 | np.int64
120 | np.uint64
121 | np.float16
122 | np.float32
123 | np.float64
124 | np.timedelta64
125 | np.object_
126)
127
128_Array: TypeAlias = np.ndarray[_ShapeT, np.dtype[_ScalarT]]
129_Array0D: TypeAlias = np.ndarray[tuple[()], np.dtype[_ScalarT]]
130_Array1D: TypeAlias = np.ndarray[tuple[int], np.dtype[_ScalarT]]
131_Array2D: TypeAlias = np.ndarray[tuple[int, int], np.dtype[_ScalarT]]
132_Array3D: TypeAlias = np.ndarray[tuple[int, int, int], np.dtype[_ScalarT]]
133_ArrayMax2D: TypeAlias = np.ndarray[tuple[int] | tuple[int, int], np.dtype[_ScalarT]]
134# workaround for mypy and pyright not following the typing spec for overloads
135_ArrayNoD: TypeAlias = np.ndarray[tuple[Never, Never, Never, Never], np.dtype[_ScalarT]]
136
137_Seq1D: TypeAlias = Sequence[_T]
138_Seq2D: TypeAlias = Sequence[Sequence[_T]]
139_Seq3D: TypeAlias = Sequence[Sequence[Sequence[_T]]]
140_ListSeqND: TypeAlias = list[_T] | _SeqND[list[_T]]
141
142_Tuple2: TypeAlias = tuple[_T, _T]
143_Tuple3: TypeAlias = tuple[_T, _T, _T]
144_Tuple4: TypeAlias = tuple[_T, _T, _T, _T]
145
146_Mesh1: TypeAlias = tuple[_Array1D[_ScalarT]]
147_Mesh2: TypeAlias = tuple[_Array2D[_ScalarT], _Array2D[_ScalarT1]]
148_Mesh3: TypeAlias = tuple[_Array3D[_ScalarT], _Array3D[_ScalarT1], _Array3D[_ScalarT2]]
149
150_IndexLike: TypeAlias = slice | _ArrayLikeInt_co
151
152_Indexing: TypeAlias = L["ij", "xy"]
153_InterpolationMethod = L[
154 "inverted_cdf",
155 "averaged_inverted_cdf",
156 "closest_observation",
157 "interpolated_inverted_cdf",
158 "hazen",
159 "weibull",
160 "linear",
161 "median_unbiased",
162 "normal_unbiased",
163 "lower",
164 "higher",
165 "midpoint",
166 "nearest",
167]
168
169# The resulting value will be used as `y[cond] = func(vals, *args, **kw)`, so in can
170# return any (usually 1d) array-like or scalar-like compatible with the input.
171_PiecewiseFunction: TypeAlias = Callable[Concatenate[NDArray[_ScalarT], _Tss], ArrayLike]
172_PiecewiseFunctions: TypeAlias = _SizedIterable[_PiecewiseFunction[_ScalarT, _Tss] | _ScalarLike_co]
173
174@type_check_only
175class _TrimZerosSequence(Protocol[_T_co]):
176 def __len__(self, /) -> int: ...
177 @overload
178 def __getitem__(self, key: int, /) -> object: ...
179 @overload
180 def __getitem__(self, key: slice, /) -> _T_co: ...
181
182@type_check_only
183class _SupportsRMulFloat(Protocol[_T_co]):
184 def __rmul__(self, other: float, /) -> _T_co: ...
185
186@type_check_only
187class _SizedIterable(Protocol[_T_co]):
188 def __iter__(self) -> Iterable[_T_co]: ...
189 def __len__(self) -> int: ...
190
191###
192
193class vectorize:
194 __doc__: str | None
195 __module__: L["numpy"] = "numpy"
196 pyfunc: Callable[..., Incomplete]
197 cache: bool
198 signature: str | None
199 otypes: str | None
200 excluded: set[int | str]
201
202 def __init__(
203 self,
204 /,
205 pyfunc: Callable[..., Incomplete] | _NoValueType = ..., # = _NoValue
206 otypes: str | Iterable[DTypeLike] | None = None,
207 doc: str | None = None,
208 excluded: Iterable[int | str] | None = None,
209 cache: bool = False,
210 signature: str | None = None,
211 ) -> None: ...
212 def __call__(self, /, *args: Incomplete, **kwargs: Incomplete) -> Incomplete: ...
213
214@overload
215def rot90(m: _ArrayT, k: int = 1, axes: tuple[int, int] = (0, 1)) -> _ArrayT: ...
216@overload
217def rot90(m: _ArrayLike[_ScalarT], k: int = 1, axes: tuple[int, int] = (0, 1)) -> NDArray[_ScalarT]: ...
218@overload
219def rot90(m: ArrayLike, k: int = 1, axes: tuple[int, int] = (0, 1)) -> NDArray[Incomplete]: ...
220
221# NOTE: Technically `flip` also accept scalars, but that has no effect and complicates
222# the overloads significantly, so we ignore that case here.
223@overload
224def flip(m: _ArrayT, axis: int | tuple[int, ...] | None = None) -> _ArrayT: ...
225@overload
226def flip(m: _ArrayLike[_ScalarT], axis: int | tuple[int, ...] | None = None) -> NDArray[_ScalarT]: ...
227@overload
228def flip(m: ArrayLike, axis: int | tuple[int, ...] | None = None) -> NDArray[Incomplete]: ...
229
230#
231def iterable(y: object) -> TypeIs[Iterable[Any]]: ...
232
233# NOTE: This assumes that if `axis` is given the input is at least 2d, and will
234# therefore always return an array.
235# NOTE: This assumes that if `keepdims=True` the input is at least 1d, and will
236# therefore always return an array.
237@overload # inexact array, keepdims=True
238def average(
239 a: _ArrayInexactT,
240 axis: int | tuple[int, ...] | None = None,
241 weights: _ArrayLikeNumber_co | None = None,
242 returned: L[False] = False,
243 *,
244 keepdims: L[True],
245) -> _ArrayInexactT: ...
246@overload # inexact array, returned=True keepdims=True
247def average(
248 a: _ArrayInexactT,
249 axis: int | tuple[int, ...] | None = None,
250 weights: _ArrayLikeNumber_co | None = None,
251 *,
252 returned: L[True],
253 keepdims: L[True],
254) -> _Tuple2[_ArrayInexactT]: ...
255@overload # inexact array-like, axis=None
256def average(
257 a: _ArrayLike[_InexactT],
258 axis: None = None,
259 weights: _ArrayLikeNumber_co | None = None,
260 returned: L[False] = False,
261 *,
262 keepdims: L[False] | _NoValueType = ...,
263) -> _InexactT: ...
264@overload # inexact array-like, axis=<given>
265def average(
266 a: _ArrayLike[_InexactT],
267 axis: int | tuple[int, ...],
268 weights: _ArrayLikeNumber_co | None = None,
269 returned: L[False] = False,
270 *,
271 keepdims: L[False] | _NoValueType = ...,
272) -> NDArray[_InexactT]: ...
273@overload # inexact array-like, keepdims=True
274def average(
275 a: _ArrayLike[_InexactT],
276 axis: int | tuple[int, ...] | None = None,
277 weights: _ArrayLikeNumber_co | None = None,
278 returned: L[False] = False,
279 *,
280 keepdims: L[True],
281) -> NDArray[_InexactT]: ...
282@overload # inexact array-like, axis=None, returned=True
283def average(
284 a: _ArrayLike[_InexactT],
285 axis: None = None,
286 weights: _ArrayLikeNumber_co | None = None,
287 *,
288 returned: L[True],
289 keepdims: L[False] | _NoValueType = ...,
290) -> _Tuple2[_InexactT]: ...
291@overload # inexact array-like, axis=<given>, returned=True
292def average(
293 a: _ArrayLike[_InexactT],
294 axis: int | tuple[int, ...],
295 weights: _ArrayLikeNumber_co | None = None,
296 *,
297 returned: L[True],
298 keepdims: L[False] | _NoValueType = ...,
299) -> _Tuple2[NDArray[_InexactT]]: ...
300@overload # inexact array-like, returned=True, keepdims=True
301def average(
302 a: _ArrayLike[_InexactT],
303 axis: int | tuple[int, ...] | None = None,
304 weights: _ArrayLikeNumber_co | None = None,
305 *,
306 returned: L[True],
307 keepdims: L[True],
308) -> _Tuple2[NDArray[_InexactT]]: ...
309@overload # bool or integer array-like, axis=None
310def average(
311 a: _SeqND[float] | _ArrayLikeInt_co,
312 axis: None = None,
313 weights: _ArrayLikeFloat_co | None = None,
314 returned: L[False] = False,
315 *,
316 keepdims: L[False] | _NoValueType = ...,
317) -> np.float64: ...
318@overload # bool or integer array-like, axis=<given>
319def average(
320 a: _SeqND[float] | _ArrayLikeInt_co,
321 axis: int | tuple[int, ...],
322 weights: _ArrayLikeFloat_co | None = None,
323 returned: L[False] = False,
324 *,
325 keepdims: L[False] | _NoValueType = ...,
326) -> NDArray[np.float64]: ...
327@overload # bool or integer array-like, keepdims=True
328def average(
329 a: _SeqND[float] | _ArrayLikeInt_co,
330 axis: int | tuple[int, ...] | None = None,
331 weights: _ArrayLikeFloat_co | None = None,
332 returned: L[False] = False,
333 *,
334 keepdims: L[True],
335) -> NDArray[np.float64]: ...
336@overload # bool or integer array-like, axis=None, returned=True
337def average(
338 a: _SeqND[float] | _ArrayLikeInt_co,
339 axis: None = None,
340 weights: _ArrayLikeFloat_co | None = None,
341 *,
342 returned: L[True],
343 keepdims: L[False] | _NoValueType = ...,
344) -> _Tuple2[np.float64]: ...
345@overload # bool or integer array-like, axis=<given>, returned=True
346def average(
347 a: _SeqND[float] | _ArrayLikeInt_co,
348 axis: int | tuple[int, ...],
349 weights: _ArrayLikeFloat_co | None = None,
350 *,
351 returned: L[True],
352 keepdims: L[False] | _NoValueType = ...,
353) -> _Tuple2[NDArray[np.float64]]: ...
354@overload # bool or integer array-like, returned=True, keepdims=True
355def average(
356 a: _SeqND[float] | _ArrayLikeInt_co,
357 axis: int | tuple[int, ...] | None = None,
358 weights: _ArrayLikeFloat_co | None = None,
359 *,
360 returned: L[True],
361 keepdims: L[True],
362) -> _Tuple2[NDArray[np.float64]]: ...
363@overload # complex array-like, axis=None
364def average(
365 a: _ListSeqND[complex],
366 axis: None = None,
367 weights: _ArrayLikeComplex_co | None = None,
368 returned: L[False] = False,
369 *,
370 keepdims: L[False] | _NoValueType = ...,
371) -> np.complex128: ...
372@overload # complex array-like, axis=<given>
373def average(
374 a: _ListSeqND[complex],
375 axis: int | tuple[int, ...],
376 weights: _ArrayLikeComplex_co | None = None,
377 returned: L[False] = False,
378 *,
379 keepdims: L[False] | _NoValueType = ...,
380) -> NDArray[np.complex128]: ...
381@overload # complex array-like, keepdims=True
382def average(
383 a: _ListSeqND[complex],
384 axis: int | tuple[int, ...] | None = None,
385 weights: _ArrayLikeComplex_co | None = None,
386 returned: L[False] = False,
387 *,
388 keepdims: L[True],
389) -> NDArray[np.complex128]: ...
390@overload # complex array-like, axis=None, returned=True
391def average(
392 a: _ListSeqND[complex],
393 axis: None = None,
394 weights: _ArrayLikeComplex_co | None = None,
395 *,
396 returned: L[True],
397 keepdims: L[False] | _NoValueType = ...,
398) -> _Tuple2[np.complex128]: ...
399@overload # complex array-like, axis=<given>, returned=True
400def average(
401 a: _ListSeqND[complex],
402 axis: int | tuple[int, ...],
403 weights: _ArrayLikeComplex_co | None = None,
404 *,
405 returned: L[True],
406 keepdims: L[False] | _NoValueType = ...,
407) -> _Tuple2[NDArray[np.complex128]]: ...
408@overload # complex array-like, keepdims=True, returned=True
409def average(
410 a: _ListSeqND[complex],
411 axis: int | tuple[int, ...] | None = None,
412 weights: _ArrayLikeComplex_co | None = None,
413 *,
414 returned: L[True],
415 keepdims: L[True],
416) -> _Tuple2[NDArray[np.complex128]]: ...
417@overload # unknown, axis=None
418def average(
419 a: _ArrayLikeNumber_co | _ArrayLikeObject_co,
420 axis: None = None,
421 weights: _ArrayLikeNumber_co | None = None,
422 returned: L[False] = False,
423 *,
424 keepdims: L[False] | _NoValueType = ...,
425) -> Any: ...
426@overload # unknown, axis=<given>
427def average(
428 a: _ArrayLikeNumber_co | _ArrayLikeObject_co,
429 axis: int | tuple[int, ...],
430 weights: _ArrayLikeNumber_co | None = None,
431 returned: L[False] = False,
432 *,
433 keepdims: L[False] | _NoValueType = ...,
434) -> np.ndarray: ...
435@overload # unknown, keepdims=True
436def average(
437 a: _ArrayLikeNumber_co | _ArrayLikeObject_co,
438 axis: int | tuple[int, ...] | None = None,
439 weights: _ArrayLikeNumber_co | None = None,
440 returned: L[False] = False,
441 *,
442 keepdims: L[True],
443) -> np.ndarray: ...
444@overload # unknown, axis=None, returned=True
445def average(
446 a: _ArrayLikeNumber_co | _ArrayLikeObject_co,
447 axis: None = None,
448 weights: _ArrayLikeNumber_co | None = None,
449 *,
450 returned: L[True],
451 keepdims: L[False] | _NoValueType = ...,
452) -> _Tuple2[Any]: ...
453@overload # unknown, axis=<given>, returned=True
454def average(
455 a: _ArrayLikeNumber_co | _ArrayLikeObject_co,
456 axis: int | tuple[int, ...],
457 weights: _ArrayLikeNumber_co | None = None,
458 *,
459 returned: L[True],
460 keepdims: L[False] | _NoValueType = ...,
461) -> _Tuple2[np.ndarray]: ...
462@overload # unknown, returned=True, keepdims=True
463def average(
464 a: _ArrayLikeNumber_co | _ArrayLikeObject_co,
465 axis: int | tuple[int, ...] | None = None,
466 weights: _ArrayLikeNumber_co | None = None,
467 *,
468 returned: L[True],
469 keepdims: L[True],
470) -> _Tuple2[np.ndarray]: ...
471
472#
473@overload
474def asarray_chkfinite(a: _ArrayT, dtype: None = None, order: _OrderKACF = None) -> _ArrayT: ...
475@overload
476def asarray_chkfinite(
477 a: np.ndarray[_ShapeT], dtype: _DTypeLike[_ScalarT], order: _OrderKACF = None
478) -> _Array[_ShapeT, _ScalarT]: ...
479@overload
480def asarray_chkfinite(a: _ArrayLike[_ScalarT], dtype: None = None, order: _OrderKACF = None) -> NDArray[_ScalarT]: ...
481@overload
482def asarray_chkfinite(a: object, dtype: _DTypeLike[_ScalarT], order: _OrderKACF = None) -> NDArray[_ScalarT]: ...
483@overload
484def asarray_chkfinite(a: object, dtype: DTypeLike | None = None, order: _OrderKACF = None) -> NDArray[Incomplete]: ...
485
486# NOTE: Contrary to the documentation, scalars are also accepted and treated as
487# `[condlist]`. And even though the documentation says these should be boolean, in
488# practice anything that `np.array(condlist, dtype=bool)` accepts will work, i.e. any
489# array-like.
490@overload
491def piecewise(
492 x: _Array[_ShapeT, _ScalarT],
493 condlist: ArrayLike,
494 funclist: _PiecewiseFunctions[Any, _Tss],
495 *args: _Tss.args,
496 **kw: _Tss.kwargs,
497) -> _Array[_ShapeT, _ScalarT]: ...
498@overload
499def piecewise(
500 x: _ArrayLike[_ScalarT],
501 condlist: ArrayLike,
502 funclist: _PiecewiseFunctions[Any, _Tss],
503 *args: _Tss.args,
504 **kw: _Tss.kwargs,
505) -> NDArray[_ScalarT]: ...
506@overload
507def piecewise(
508 x: ArrayLike,
509 condlist: ArrayLike,
510 funclist: _PiecewiseFunctions[_ScalarT, _Tss],
511 *args: _Tss.args,
512 **kw: _Tss.kwargs,
513) -> NDArray[_ScalarT]: ...
514
515# NOTE: condition is usually boolean, but anything with zero/non-zero semantics works
516@overload
517def extract(condition: ArrayLike, arr: _ArrayLike[_ScalarT]) -> _Array1D[_ScalarT]: ...
518@overload
519def extract(condition: ArrayLike, arr: _SeqND[bool]) -> _Array1D[np.bool]: ...
520@overload
521def extract(condition: ArrayLike, arr: _ListSeqND[int]) -> _Array1D[np.int_]: ...
522@overload
523def extract(condition: ArrayLike, arr: _ListSeqND[float]) -> _Array1D[np.float64]: ...
524@overload
525def extract(condition: ArrayLike, arr: _ListSeqND[complex]) -> _Array1D[np.complex128]: ...
526@overload
527def extract(condition: ArrayLike, arr: _SeqND[bytes]) -> _Array1D[np.bytes_]: ...
528@overload
529def extract(condition: ArrayLike, arr: _SeqND[str]) -> _Array1D[np.str_]: ...
530@overload
531def extract(condition: ArrayLike, arr: ArrayLike) -> _Array1D[Incomplete]: ...
532
533# NOTE: unlike `extract`, passing non-boolean conditions for `condlist` will raise an
534# error at runtime
535@overload
536def select(
537 condlist: _SizedIterable[_ArrayLikeBool_co],
538 choicelist: Sequence[_ArrayT],
539 default: ArrayLike = 0,
540) -> _ArrayT: ...
541@overload
542def select(
543 condlist: _SizedIterable[_ArrayLikeBool_co],
544 choicelist: Sequence[_ArrayLike[_ScalarT]] | NDArray[_ScalarT],
545 default: ArrayLike = 0,
546) -> NDArray[_ScalarT]: ...
547@overload
548def select(
549 condlist: _SizedIterable[_ArrayLikeBool_co],
550 choicelist: Sequence[ArrayLike],
551 default: ArrayLike = 0,
552) -> np.ndarray: ...
553
554# keep roughly in sync with `ma.core.copy`
555@overload
556def copy(a: _ArrayT, order: _OrderKACF, subok: L[True]) -> _ArrayT: ...
557@overload
558def copy(a: _ArrayT, order: _OrderKACF = "K", *, subok: L[True]) -> _ArrayT: ...
559@overload
560def copy(a: _ArrayLike[_ScalarT], order: _OrderKACF = "K", subok: L[False] = False) -> NDArray[_ScalarT]: ...
561@overload
562def copy(a: ArrayLike, order: _OrderKACF = "K", subok: L[False] = False) -> NDArray[Incomplete]: ...
563
564#
565@overload # ?d, known inexact scalar-type
566def gradient(
567 f: _ArrayNoD[_InexactTimeT],
568 *varargs: _ArrayLikeNumber_co,
569 axis: _ShapeLike | None = None,
570 edge_order: L[1, 2] = 1,
571 # `| Any` instead of ` | tuple` is returned to avoid several mypy_primer errors
572) -> _Array1D[_InexactTimeT] | Any: ...
573@overload # 1d, known inexact scalar-type
574def gradient(
575 f: _Array1D[_InexactTimeT],
576 *varargs: _ArrayLikeNumber_co,
577 axis: _ShapeLike | None = None,
578 edge_order: L[1, 2] = 1,
579) -> _Array1D[_InexactTimeT]: ...
580@overload # 2d, known inexact scalar-type
581def gradient(
582 f: _Array2D[_InexactTimeT],
583 *varargs: _ArrayLikeNumber_co,
584 axis: _ShapeLike | None = None,
585 edge_order: L[1, 2] = 1,
586) -> _Mesh2[_InexactTimeT, _InexactTimeT]: ...
587@overload # 3d, known inexact scalar-type
588def gradient(
589 f: _Array3D[_InexactTimeT],
590 *varargs: _ArrayLikeNumber_co,
591 axis: _ShapeLike | None = None,
592 edge_order: L[1, 2] = 1,
593) -> _Mesh3[_InexactTimeT, _InexactTimeT, _InexactTimeT]: ...
594@overload # ?d, datetime64 scalar-type
595def gradient(
596 f: _ArrayNoD[np.datetime64],
597 *varargs: _ArrayLikeNumber_co,
598 axis: _ShapeLike | None = None,
599 edge_order: L[1, 2] = 1,
600) -> _Array1D[np.timedelta64] | tuple[NDArray[np.timedelta64], ...]: ...
601@overload # 1d, datetime64 scalar-type
602def gradient(
603 f: _Array1D[np.datetime64],
604 *varargs: _ArrayLikeNumber_co,
605 axis: _ShapeLike | None = None,
606 edge_order: L[1, 2] = 1,
607) -> _Array1D[np.timedelta64]: ...
608@overload # 2d, datetime64 scalar-type
609def gradient(
610 f: _Array2D[np.datetime64],
611 *varargs: _ArrayLikeNumber_co,
612 axis: _ShapeLike | None = None,
613 edge_order: L[1, 2] = 1,
614) -> _Mesh2[np.timedelta64, np.timedelta64]: ...
615@overload # 3d, datetime64 scalar-type
616def gradient(
617 f: _Array3D[np.datetime64],
618 *varargs: _ArrayLikeNumber_co,
619 axis: _ShapeLike | None = None,
620 edge_order: L[1, 2] = 1,
621) -> _Mesh3[np.timedelta64, np.timedelta64, np.timedelta64]: ...
622@overload # 1d float-like
623def gradient(
624 f: _Seq1D[float],
625 *varargs: _ArrayLikeNumber_co,
626 axis: _ShapeLike | None = None,
627 edge_order: L[1, 2] = 1,
628) -> _Array1D[np.float64]: ...
629@overload # 2d float-like
630def gradient(
631 f: _Seq2D[float],
632 *varargs: _ArrayLikeNumber_co,
633 axis: _ShapeLike | None = None,
634 edge_order: L[1, 2] = 1,
635) -> _Mesh2[np.float64, np.float64]: ...
636@overload # 3d float-like
637def gradient(
638 f: _Seq3D[float],
639 *varargs: _ArrayLikeNumber_co,
640 axis: _ShapeLike | None = None,
641 edge_order: L[1, 2] = 1,
642) -> _Mesh3[np.float64, np.float64, np.float64]: ...
643@overload # 1d complex-like (the `list` avoids overlap with the float-like overload)
644def gradient(
645 f: list[complex],
646 *varargs: _ArrayLikeNumber_co,
647 axis: _ShapeLike | None = None,
648 edge_order: L[1, 2] = 1,
649) -> _Array1D[np.complex128]: ...
650@overload # 2d float-like
651def gradient(
652 f: _Seq1D[list[complex]],
653 *varargs: _ArrayLikeNumber_co,
654 axis: _ShapeLike | None = None,
655 edge_order: L[1, 2] = 1,
656) -> _Mesh2[np.complex128, np.complex128]: ...
657@overload # 3d float-like
658def gradient(
659 f: _Seq2D[list[complex]],
660 *varargs: _ArrayLikeNumber_co,
661 axis: _ShapeLike | None = None,
662 edge_order: L[1, 2] = 1,
663) -> _Mesh3[np.complex128, np.complex128, np.complex128]: ...
664@overload # fallback
665def gradient(
666 f: ArrayLike,
667 *varargs: _ArrayLikeNumber_co,
668 axis: _ShapeLike | None = None,
669 edge_order: L[1, 2] = 1,
670) -> Incomplete: ...
671
672#
673@overload # n == 0; return input unchanged
674def diff(
675 a: _T,
676 n: L[0],
677 axis: SupportsIndex = -1,
678 prepend: ArrayLike | _NoValueType = ..., # = _NoValue
679 append: ArrayLike | _NoValueType = ..., # = _NoValue
680) -> _T: ...
681@overload # known array-type
682def diff(
683 a: _ArrayNumericT,
684 n: int = 1,
685 axis: SupportsIndex = -1,
686 prepend: ArrayLike | _NoValueType = ...,
687 append: ArrayLike | _NoValueType = ...,
688) -> _ArrayNumericT: ...
689@overload # known shape, datetime64
690def diff(
691 a: _Array[_ShapeT, np.datetime64],
692 n: int = 1,
693 axis: SupportsIndex = -1,
694 prepend: ArrayLike | _NoValueType = ...,
695 append: ArrayLike | _NoValueType = ...,
696) -> _Array[_ShapeT, np.timedelta64]: ...
697@overload # unknown shape, known scalar-type
698def diff(
699 a: _ArrayLike[_ScalarNumericT],
700 n: int = 1,
701 axis: SupportsIndex = -1,
702 prepend: ArrayLike | _NoValueType = ...,
703 append: ArrayLike | _NoValueType = ...,
704) -> NDArray[_ScalarNumericT]: ...
705@overload # unknown shape, datetime64
706def diff(
707 a: _ArrayLike[np.datetime64],
708 n: int = 1,
709 axis: SupportsIndex = -1,
710 prepend: ArrayLike | _NoValueType = ...,
711 append: ArrayLike | _NoValueType = ...,
712) -> NDArray[np.timedelta64]: ...
713@overload # 1d int
714def diff(
715 a: _Seq1D[int],
716 n: int = 1,
717 axis: SupportsIndex = -1,
718 prepend: ArrayLike | _NoValueType = ...,
719 append: ArrayLike | _NoValueType = ...,
720) -> _Array1D[np.int_]: ...
721@overload # 2d int
722def diff(
723 a: _Seq2D[int],
724 n: int = 1,
725 axis: SupportsIndex = -1,
726 prepend: ArrayLike | _NoValueType = ...,
727 append: ArrayLike | _NoValueType = ...,
728) -> _Array2D[np.int_]: ...
729@overload # 1d float (the `list` avoids overlap with the `int` overloads)
730def diff(
731 a: list[float],
732 n: int = 1,
733 axis: SupportsIndex = -1,
734 prepend: ArrayLike | _NoValueType = ...,
735 append: ArrayLike | _NoValueType = ...,
736) -> _Array1D[np.float64]: ...
737@overload # 2d float
738def diff(
739 a: _Seq1D[list[float]],
740 n: int = 1,
741 axis: SupportsIndex = -1,
742 prepend: ArrayLike | _NoValueType = ...,
743 append: ArrayLike | _NoValueType = ...,
744) -> _Array2D[np.float64]: ...
745@overload # 1d complex (the `list` avoids overlap with the `int` overloads)
746def diff(
747 a: list[complex],
748 n: int = 1,
749 axis: SupportsIndex = -1,
750 prepend: ArrayLike | _NoValueType = ...,
751 append: ArrayLike | _NoValueType = ...,
752) -> _Array1D[np.complex128]: ...
753@overload # 2d complex
754def diff(
755 a: _Seq1D[list[complex]],
756 n: int = 1,
757 axis: SupportsIndex = -1,
758 prepend: ArrayLike | _NoValueType = ...,
759 append: ArrayLike | _NoValueType = ...,
760) -> _Array2D[np.complex128]: ...
761@overload # unknown shape, unknown scalar-type
762def diff(
763 a: ArrayLike,
764 n: int = 1,
765 axis: SupportsIndex = -1,
766 prepend: ArrayLike | _NoValueType = ...,
767 append: ArrayLike | _NoValueType = ...,
768) -> NDArray[Incomplete]: ...
769
770#
771@overload # float scalar
772def interp(
773 x: _FloatLike_co,
774 xp: _ArrayLikeFloat_co,
775 fp: _ArrayLikeFloat_co,
776 left: _FloatLike_co | None = None,
777 right: _FloatLike_co | None = None,
778 period: _FloatLike_co | None = None,
779) -> np.float64: ...
780@overload # complex scalar
781def interp(
782 x: _FloatLike_co,
783 xp: _ArrayLikeFloat_co,
784 fp: _ArrayLike1D[np.complexfloating] | list[complex],
785 left: _NumberLike_co | None = None,
786 right: _NumberLike_co | None = None,
787 period: _FloatLike_co | None = None,
788) -> np.complex128: ...
789@overload # float array
790def interp(
791 x: _Array[_ShapeT, _floating_co],
792 xp: _ArrayLikeFloat_co,
793 fp: _ArrayLikeFloat_co,
794 left: _FloatLike_co | None = None,
795 right: _FloatLike_co | None = None,
796 period: _FloatLike_co | None = None,
797) -> _Array[_ShapeT, np.float64]: ...
798@overload # complex array
799def interp(
800 x: _Array[_ShapeT, _floating_co],
801 xp: _ArrayLikeFloat_co,
802 fp: _ArrayLike1D[np.complexfloating] | list[complex],
803 left: _NumberLike_co | None = None,
804 right: _NumberLike_co | None = None,
805 period: _FloatLike_co | None = None,
806) -> _Array[_ShapeT, np.complex128]: ...
807@overload # float sequence
808def interp(
809 x: _Seq1D[_FloatLike_co],
810 xp: _ArrayLikeFloat_co,
811 fp: _ArrayLikeFloat_co,
812 left: _FloatLike_co | None = None,
813 right: _FloatLike_co | None = None,
814 period: _FloatLike_co | None = None,
815) -> _Array1D[np.float64]: ...
816@overload # complex sequence
817def interp(
818 x: _Seq1D[_FloatLike_co],
819 xp: _ArrayLikeFloat_co,
820 fp: _ArrayLike1D[np.complexfloating] | list[complex],
821 left: _NumberLike_co | None = None,
822 right: _NumberLike_co | None = None,
823 period: _FloatLike_co | None = None,
824) -> _Array1D[np.complex128]: ...
825@overload # float array-like
826def interp(
827 x: _SeqND[_FloatLike_co],
828 xp: _ArrayLikeFloat_co,
829 fp: _ArrayLikeFloat_co,
830 left: _FloatLike_co | None = None,
831 right: _FloatLike_co | None = None,
832 period: _FloatLike_co | None = None,
833) -> NDArray[np.float64]: ...
834@overload # complex array-like
835def interp(
836 x: _SeqND[_FloatLike_co],
837 xp: _ArrayLikeFloat_co,
838 fp: _ArrayLike1D[np.complexfloating] | list[complex],
839 left: _NumberLike_co | None = None,
840 right: _NumberLike_co | None = None,
841 period: _FloatLike_co | None = None,
842) -> NDArray[np.complex128]: ...
843@overload # float scalar/array-like
844def interp(
845 x: _ArrayLikeFloat_co,
846 xp: _ArrayLikeFloat_co,
847 fp: _ArrayLikeFloat_co,
848 left: _FloatLike_co | None = None,
849 right: _FloatLike_co | None = None,
850 period: _FloatLike_co | None = None,
851) -> NDArray[np.float64] | np.float64: ...
852@overload # complex scalar/array-like
853def interp(
854 x: _ArrayLikeFloat_co,
855 xp: _ArrayLikeFloat_co,
856 fp: _ArrayLike1D[np.complexfloating],
857 left: _NumberLike_co | None = None,
858 right: _NumberLike_co | None = None,
859 period: _FloatLike_co | None = None,
860) -> NDArray[np.complex128] | np.complex128: ...
861@overload # float/complex scalar/array-like
862def interp(
863 x: _ArrayLikeFloat_co,
864 xp: _ArrayLikeFloat_co,
865 fp: _ArrayLikeNumber_co,
866 left: _NumberLike_co | None = None,
867 right: _NumberLike_co | None = None,
868 period: _FloatLike_co | None = None,
869) -> NDArray[np.complex128 | np.float64] | np.complex128 | np.float64: ...
870
871#
872@overload # 0d T: floating -> 0d T
873def angle(z: _FloatingT, deg: bool = False) -> _FloatingT: ...
874@overload # 0d complex | float | ~integer -> 0d float64
875def angle(z: complex | _integer_co, deg: bool = False) -> np.float64: ...
876@overload # 0d complex64 -> 0d float32
877def angle(z: np.complex64, deg: bool = False) -> np.float32: ...
878@overload # 0d clongdouble -> 0d longdouble
879def angle(z: np.clongdouble, deg: bool = False) -> np.longdouble: ...
880@overload # T: nd floating -> T
881def angle(z: _ArrayFloatingT, deg: bool = False) -> _ArrayFloatingT: ...
882@overload # nd T: complex128 | ~integer -> nd float64
883def angle(z: _Array[_ShapeT, np.complex128 | _integer_co], deg: bool = False) -> _Array[_ShapeT, np.float64]: ...
884@overload # nd T: complex64 -> nd float32
885def angle(z: _Array[_ShapeT, np.complex64], deg: bool = False) -> _Array[_ShapeT, np.float32]: ...
886@overload # nd T: clongdouble -> nd longdouble
887def angle(z: _Array[_ShapeT, np.clongdouble], deg: bool = False) -> _Array[_ShapeT, np.longdouble]: ...
888@overload # 1d complex -> 1d float64
889def angle(z: _Seq1D[complex], deg: bool = False) -> _Array1D[np.float64]: ...
890@overload # 2d complex -> 2d float64
891def angle(z: _Seq2D[complex], deg: bool = False) -> _Array2D[np.float64]: ...
892@overload # 3d complex -> 3d float64
893def angle(z: _Seq3D[complex], deg: bool = False) -> _Array3D[np.float64]: ...
894@overload # fallback
895def angle(z: _ArrayLikeComplex_co, deg: bool = False) -> NDArray[np.floating] | Any: ...
896
897#
898@overload # known array-type
899def unwrap(
900 p: _ArrayFloatObjT,
901 discont: float | None = None,
902 axis: int = -1,
903 *,
904 period: float = ..., # = τ
905) -> _ArrayFloatObjT: ...
906@overload # known shape, float64
907def unwrap(
908 p: _Array[_ShapeT, _float64_co],
909 discont: float | None = None,
910 axis: int = -1,
911 *,
912 period: float = ..., # = τ
913) -> _Array[_ShapeT, np.float64]: ...
914@overload # 1d float64-like
915def unwrap(
916 p: _Seq1D[float | _float64_co],
917 discont: float | None = None,
918 axis: int = -1,
919 *,
920 period: float = ..., # = τ
921) -> _Array1D[np.float64]: ...
922@overload # 2d float64-like
923def unwrap(
924 p: _Seq2D[float | _float64_co],
925 discont: float | None = None,
926 axis: int = -1,
927 *,
928 period: float = ..., # = τ
929) -> _Array2D[np.float64]: ...
930@overload # 3d float64-like
931def unwrap(
932 p: _Seq3D[float | _float64_co],
933 discont: float | None = None,
934 axis: int = -1,
935 *,
936 period: float = ..., # = τ
937) -> _Array3D[np.float64]: ...
938@overload # ?d, float64
939def unwrap(
940 p: _SeqND[float] | _ArrayLike[_float64_co],
941 discont: float | None = None,
942 axis: int = -1,
943 *,
944 period: float = ..., # = τ
945) -> NDArray[np.float64]: ...
946@overload # fallback
947def unwrap(
948 p: _ArrayLikeFloat_co | _ArrayLikeObject_co,
949 discont: float | None = None,
950 axis: int = -1,
951 *,
952 period: float = ..., # = τ
953) -> np.ndarray: ...
954
955#
956@overload
957def sort_complex(a: _ArrayComplexT) -> _ArrayComplexT: ...
958@overload # complex64, shape known
959def sort_complex(a: _Array[_ShapeT, np.int8 | np.uint8 | np.int16 | np.uint16]) -> _Array[_ShapeT, np.complex64]: ...
960@overload # complex64, shape unknown
961def sort_complex(a: _ArrayLike[np.int8 | np.uint8 | np.int16 | np.uint16]) -> NDArray[np.complex64]: ...
962@overload # complex128, shape known
963def sort_complex(a: _Array[_ShapeT, _SortsToComplex128]) -> _Array[_ShapeT, np.complex128]: ...
964@overload # complex128, shape unknown
965def sort_complex(a: _ArrayLike[_SortsToComplex128]) -> NDArray[np.complex128]: ...
966@overload # clongdouble, shape known
967def sort_complex(a: _Array[_ShapeT, np.longdouble]) -> _Array[_ShapeT, np.clongdouble]: ...
968@overload # clongdouble, shape unknown
969def sort_complex(a: _ArrayLike[np.longdouble]) -> NDArray[np.clongdouble]: ...
970
971#
972def trim_zeros(filt: _TrimZerosSequence[_T], trim: L["f", "b", "fb", "bf"] = "fb", axis: _ShapeLike | None = None) -> _T: ...
973
974# NOTE: keep in sync with `corrcoef`
975@overload # ?d, known inexact scalar-type >=64 precision, y=<given>.
976def cov(
977 m: _ArrayLike[_AnyDoubleT],
978 y: _ArrayLike[_AnyDoubleT],
979 rowvar: bool = True,
980 bias: bool = False,
981 ddof: SupportsIndex | SupportsInt | None = None,
982 fweights: _ArrayLikeInt_co | None = None,
983 aweights: _ArrayLikeFloat_co | None = None,
984 *,
985 dtype: None = None,
986) -> _Array2D[_AnyDoubleT]: ...
987@overload # ?d, known inexact scalar-type >=64 precision, y=None -> 0d or 2d
988def cov(
989 m: _ArrayNoD[_AnyDoubleT],
990 y: None = None,
991 rowvar: bool = True,
992 bias: bool = False,
993 ddof: SupportsIndex | SupportsInt | None = None,
994 fweights: _ArrayLikeInt_co | None = None,
995 aweights: _ArrayLikeFloat_co | None = None,
996 *,
997 dtype: _DTypeLike[_AnyDoubleT] | None = None,
998) -> NDArray[_AnyDoubleT]: ...
999@overload # 1d, known inexact scalar-type >=64 precision, y=None
1000def cov(
1001 m: _Array1D[_AnyDoubleT],
1002 y: None = None,
1003 rowvar: bool = True,
1004 bias: bool = False,
1005 ddof: SupportsIndex | SupportsInt | None = None,
1006 fweights: _ArrayLikeInt_co | None = None,
1007 aweights: _ArrayLikeFloat_co | None = None,
1008 *,
1009 dtype: _DTypeLike[_AnyDoubleT] | None = None,
1010) -> _Array0D[_AnyDoubleT]: ...
1011@overload # nd, known inexact scalar-type >=64 precision, y=None -> 0d or 2d
1012def cov(
1013 m: _ArrayLike[_AnyDoubleT],
1014 y: None = None,
1015 rowvar: bool = True,
1016 bias: bool = False,
1017 ddof: SupportsIndex | SupportsInt | None = None,
1018 fweights: _ArrayLikeInt_co | None = None,
1019 aweights: _ArrayLikeFloat_co | None = None,
1020 *,
1021 dtype: _DTypeLike[_AnyDoubleT] | None = None,
1022) -> NDArray[_AnyDoubleT]: ...
1023@overload # nd, casts to float64, y=<given>
1024def cov(
1025 m: NDArray[np.float32 | np.float16 | _integer_co] | _Seq1D[float] | _Seq2D[float],
1026 y: NDArray[np.float32 | np.float16 | _integer_co] | _Seq1D[float] | _Seq2D[float],
1027 rowvar: bool = True,
1028 bias: bool = False,
1029 ddof: SupportsIndex | SupportsInt | None = None,
1030 fweights: _ArrayLikeInt_co | None = None,
1031 aweights: _ArrayLikeFloat_co | None = None,
1032 *,
1033 dtype: _DTypeLike[np.float64] | None = None,
1034) -> _Array2D[np.float64]: ...
1035@overload # ?d or 2d, casts to float64, y=None -> 0d or 2d
1036def cov(
1037 m: _ArrayNoD[np.float32 | np.float16 | _integer_co] | _Seq2D[float],
1038 y: None = None,
1039 rowvar: bool = True,
1040 bias: bool = False,
1041 ddof: SupportsIndex | SupportsInt | None = None,
1042 fweights: _ArrayLikeInt_co | None = None,
1043 aweights: _ArrayLikeFloat_co | None = None,
1044 *,
1045 dtype: _DTypeLike[np.float64] | None = None,
1046) -> NDArray[np.float64]: ...
1047@overload # 1d, casts to float64, y=None
1048def cov(
1049 m: _Array1D[np.float32 | np.float16 | _integer_co] | _Seq1D[float],
1050 y: None = None,
1051 rowvar: bool = True,
1052 bias: bool = False,
1053 ddof: SupportsIndex | SupportsInt | None = None,
1054 fweights: _ArrayLikeInt_co | None = None,
1055 aweights: _ArrayLikeFloat_co | None = None,
1056 *,
1057 dtype: _DTypeLike[np.float64] | None = None,
1058) -> _Array0D[np.float64]: ...
1059@overload # nd, casts to float64, y=None -> 0d or 2d
1060def cov(
1061 m: _ArrayLike[np.float32 | np.float16 | _integer_co],
1062 y: None = None,
1063 rowvar: bool = True,
1064 bias: bool = False,
1065 ddof: SupportsIndex | SupportsInt | None = None,
1066 fweights: _ArrayLikeInt_co | None = None,
1067 aweights: _ArrayLikeFloat_co | None = None,
1068 *,
1069 dtype: _DTypeLike[np.float64] | None = None,
1070) -> NDArray[np.float64]: ...
1071@overload # 1d complex, y=<given> (`list` avoids overlap with float overloads)
1072def cov(
1073 m: list[complex] | _Seq1D[list[complex]],
1074 y: list[complex] | _Seq1D[list[complex]],
1075 rowvar: bool = True,
1076 bias: bool = False,
1077 ddof: SupportsIndex | SupportsInt | None = None,
1078 fweights: _ArrayLikeInt_co | None = None,
1079 aweights: _ArrayLikeFloat_co | None = None,
1080 *,
1081 dtype: _DTypeLike[np.complex128] | None = None,
1082) -> _Array2D[np.complex128]: ...
1083@overload # 1d complex, y=None
1084def cov(
1085 m: list[complex],
1086 y: None = None,
1087 rowvar: bool = True,
1088 bias: bool = False,
1089 ddof: SupportsIndex | SupportsInt | None = None,
1090 fweights: _ArrayLikeInt_co | None = None,
1091 aweights: _ArrayLikeFloat_co | None = None,
1092 *,
1093 dtype: _DTypeLike[np.complex128] | None = None,
1094) -> _Array0D[np.complex128]: ...
1095@overload # 2d complex, y=None -> 0d or 2d
1096def cov(
1097 m: _Seq1D[list[complex]],
1098 y: None = None,
1099 rowvar: bool = True,
1100 bias: bool = False,
1101 ddof: SupportsIndex | SupportsInt | None = None,
1102 fweights: _ArrayLikeInt_co | None = None,
1103 aweights: _ArrayLikeFloat_co | None = None,
1104 *,
1105 dtype: _DTypeLike[np.complex128] | None = None,
1106) -> NDArray[np.complex128]: ...
1107@overload # 1d complex-like, y=None, dtype=<known>
1108def cov(
1109 m: _Seq1D[_ComplexLike_co],
1110 y: None = None,
1111 rowvar: bool = True,
1112 bias: bool = False,
1113 ddof: SupportsIndex | SupportsInt | None = None,
1114 fweights: _ArrayLikeInt_co | None = None,
1115 aweights: _ArrayLikeFloat_co | None = None,
1116 *,
1117 dtype: _DTypeLike[_ScalarT],
1118) -> _Array0D[_ScalarT]: ...
1119@overload # nd complex-like, y=<given>, dtype=<known>
1120def cov(
1121 m: _ArrayLikeComplex_co,
1122 y: _ArrayLikeComplex_co,
1123 rowvar: bool = True,
1124 bias: bool = False,
1125 ddof: SupportsIndex | SupportsInt | None = None,
1126 fweights: _ArrayLikeInt_co | None = None,
1127 aweights: _ArrayLikeFloat_co | None = None,
1128 *,
1129 dtype: _DTypeLike[_ScalarT],
1130) -> _Array2D[_ScalarT]: ...
1131@overload # nd complex-like, y=None, dtype=<known> -> 0d or 2d
1132def cov(
1133 m: _ArrayLikeComplex_co,
1134 y: None = None,
1135 rowvar: bool = True,
1136 bias: bool = False,
1137 ddof: SupportsIndex | SupportsInt | None = None,
1138 fweights: _ArrayLikeInt_co | None = None,
1139 aweights: _ArrayLikeFloat_co | None = None,
1140 *,
1141 dtype: _DTypeLike[_ScalarT],
1142) -> NDArray[_ScalarT]: ...
1143@overload # nd complex-like, y=<given>, dtype=?
1144def cov(
1145 m: _ArrayLikeComplex_co,
1146 y: _ArrayLikeComplex_co,
1147 rowvar: bool = True,
1148 bias: bool = False,
1149 ddof: SupportsIndex | SupportsInt | None = None,
1150 fweights: _ArrayLikeInt_co | None = None,
1151 aweights: _ArrayLikeFloat_co | None = None,
1152 *,
1153 dtype: DTypeLike | None = None,
1154) -> _Array2D[Incomplete]: ...
1155@overload # 1d complex-like, y=None, dtype=?
1156def cov(
1157 m: _Seq1D[_ComplexLike_co],
1158 y: None = None,
1159 rowvar: bool = True,
1160 bias: bool = False,
1161 ddof: SupportsIndex | SupportsInt | None = None,
1162 fweights: _ArrayLikeInt_co | None = None,
1163 aweights: _ArrayLikeFloat_co | None = None,
1164 *,
1165 dtype: DTypeLike | None = None,
1166) -> _Array0D[Incomplete]: ...
1167@overload # nd complex-like, dtype=?
1168def cov(
1169 m: _ArrayLikeComplex_co,
1170 y: _ArrayLikeComplex_co | None = None,
1171 rowvar: bool = True,
1172 bias: bool = False,
1173 ddof: SupportsIndex | SupportsInt | None = None,
1174 fweights: _ArrayLikeInt_co | None = None,
1175 aweights: _ArrayLikeFloat_co | None = None,
1176 *,
1177 dtype: DTypeLike | None = None,
1178) -> NDArray[Incomplete]: ...
1179
1180# NOTE: If only `x` is given and the resulting array has shape (1,1), a bare scalar
1181# is returned instead of a 2D array. When y is given, a 2D array is always returned.
1182# This differs from `cov`, which returns 0-D arrays instead of scalars in such cases.
1183# NOTE: keep in sync with `cov`
1184@overload # ?d, known inexact scalar-type >=64 precision, y=<given>.
1185def corrcoef(
1186 x: _ArrayLike[_AnyDoubleT],
1187 y: _ArrayLike[_AnyDoubleT],
1188 rowvar: bool = True,
1189 *,
1190 dtype: _DTypeLike[_AnyDoubleT] | None = None,
1191) -> _Array2D[_AnyDoubleT]: ...
1192@overload # ?d, known inexact scalar-type >=64 precision, y=None
1193def corrcoef(
1194 x: _ArrayNoD[_AnyDoubleT],
1195 y: None = None,
1196 rowvar: bool = True,
1197 *,
1198 dtype: _DTypeLike[_AnyDoubleT] | None = None,
1199) -> _Array2D[_AnyDoubleT] | _AnyDoubleT: ...
1200@overload # 1d, known inexact scalar-type >=64 precision, y=None