codekingpro/portable-devtools
115k
1from _typeshed import Incomplete
2from builtins import bool as py_bool
3from collections.abc import Callable, Iterable, Sequence
4from typing import (
5 Any,
6 Final,
7 Literal as L,
8 SupportsAbs,
9 SupportsIndex,
10 TypeAlias,
11 TypeGuard,
12 TypeVar,
13 overload,
14)
15
16import numpy as np
17from numpy import (
18 False_,
19 True_,
20 _OrderCF,
21 _OrderKACF,
22 bitwise_not,
23 inf,
24 little_endian,
25 nan,
26 newaxis,
27 ufunc,
28)
29from numpy._typing import (
30 ArrayLike,
31 DTypeLike,
32 NDArray,
33 _ArrayLike,
34 _ArrayLikeBool_co,
35 _ArrayLikeComplex_co,
36 _ArrayLikeFloat_co,
37 _ArrayLikeInt_co,
38 _ArrayLikeNumber_co,
39 _ArrayLikeTD64_co,
40 _CDoubleCodes,
41 _Complex128Codes,
42 _DoubleCodes,
43 _DTypeLike,
44 _DTypeLikeBool,
45 _Float64Codes,
46 _IntCodes,
47 _NestedSequence,
48 _NumberLike_co,
49 _ScalarLike_co,
50 _Shape,
51 _ShapeLike,
52 _SupportsArray,
53 _SupportsArrayFunc,
54 _SupportsDType,
55)
56
57from ._asarray import require
58from ._ufunc_config import (
59 errstate,
60 getbufsize,
61 geterr,
62 geterrcall,
63 setbufsize,
64 seterr,
65 seterrcall,
66)
67from .arrayprint import (
68 array2string,
69 array_repr,
70 array_str,
71 format_float_positional,
72 format_float_scientific,
73 get_printoptions,
74 printoptions,
75 set_printoptions,
76)
77from .fromnumeric import (
78 all,
79 amax,
80 amin,
81 any,
82 argmax,
83 argmin,
84 argpartition,
85 argsort,
86 around,
87 choose,
88 clip,
89 compress,
90 cumprod,
91 cumsum,
92 cumulative_prod,
93 cumulative_sum,
94 diagonal,
95 matrix_transpose,
96 max,
97 mean,
98 min,
99 ndim,
100 nonzero,
101 partition,
102 prod,
103 ptp,
104 put,
105 ravel,
106 repeat,
107 reshape,
108 resize,
109 round,
110 searchsorted,
111 shape,
112 size,
113 sort,
114 squeeze,
115 std,
116 sum,
117 swapaxes,
118 take,
119 trace,
120 transpose,
121 var,
122)
123from .multiarray import (
124 ALLOW_THREADS as ALLOW_THREADS,
125 BUFSIZE as BUFSIZE,
126 CLIP as CLIP,
127 MAXDIMS as MAXDIMS,
128 MAY_SHARE_BOUNDS as MAY_SHARE_BOUNDS,
129 MAY_SHARE_EXACT as MAY_SHARE_EXACT,
130 RAISE as RAISE,
131 WRAP as WRAP,
132 _Array,
133 _ConstructorEmpty,
134 arange,
135 array,
136 asanyarray,
137 asarray,
138 ascontiguousarray,
139 asfortranarray,
140 broadcast,
141 can_cast,
142 concatenate,
143 copyto,
144 dot,
145 dtype,
146 empty,
147 empty_like,
148 flatiter,
149 from_dlpack,
150 frombuffer,
151 fromfile,
152 fromiter,
153 fromstring,
154 inner,
155 lexsort,
156 matmul,
157 may_share_memory,
158 min_scalar_type,
159 ndarray,
160 nditer,
161 nested_iters,
162 normalize_axis_index as normalize_axis_index,
163 promote_types,
164 putmask,
165 result_type,
166 shares_memory,
167 vdot,
168 where,
169 zeros,
170)
171from .numerictypes import (
172 ScalarType,
173 bool,
174 bool_,
175 busday_count,
176 busday_offset,
177 busdaycalendar,
178 byte,
179 bytes_,
180 cdouble,
181 character,
182 clongdouble,
183 complex64,
184 complex128,
185 complex192,
186 complex256,
187 complexfloating,
188 csingle,
189 datetime64,
190 datetime_as_string,
191 datetime_data,
192 double,
193 flexible,
194 float16,
195 float32,
196 float64,
197 float96,
198 float128,
199 floating,
200 generic,
201 half,
202 inexact,
203 int8,
204 int16,
205 int32,
206 int64,
207 int_,
208 intc,
209 integer,
210 intp,
211 is_busday,
212 isdtype,
213 issubdtype,
214 long,
215 longdouble,
216 longlong,
217 number,
218 object_,
219 short,
220 signedinteger,
221 single,
222 str_,
223 timedelta64,
224 typecodes,
225 ubyte,
226 uint,
227 uint8,
228 uint16,
229 uint32,
230 uint64,
231 uintc,
232 uintp,
233 ulong,
234 ulonglong,
235 unsignedinteger,
236 ushort,
237 void,
238)
239from .umath import (
240 absolute,
241 add,
242 arccos,
243 arccosh,
244 arcsin,
245 arcsinh,
246 arctan,
247 arctan2,
248 arctanh,
249 bitwise_and,
250 bitwise_count,
251 bitwise_or,
252 bitwise_xor,
253 cbrt,
254 ceil,
255 conj,
256 conjugate,
257 copysign,
258 cos,
259 cosh,
260 deg2rad,
261 degrees,
262 divide,
263 divmod,
264 e,
265 equal,
266 euler_gamma,
267 exp,
268 exp2,
269 expm1,
270 fabs,
271 float_power,
272 floor,
273 floor_divide,
274 fmax,
275 fmin,
276 fmod,
277 frexp,
278 frompyfunc,
279 gcd,
280 greater,
281 greater_equal,
282 heaviside,
283 hypot,
284 invert,
285 isfinite,
286 isinf,
287 isnan,
288 isnat,
289 lcm,
290 ldexp,
291 left_shift,
292 less,
293 less_equal,
294 log,
295 log1p,
296 log2,
297 log10,
298 logaddexp,
299 logaddexp2,
300 logical_and,
301 logical_not,
302 logical_or,
303 logical_xor,
304 matvec,
305 maximum,
306 minimum,
307 mod,
308 modf,
309 multiply,
310 negative,
311 nextafter,
312 not_equal,
313 pi,
314 positive,
315 power,
316 rad2deg,
317 radians,
318 reciprocal,
319 remainder,
320 right_shift,
321 rint,
322 sign,
323 signbit,
324 sin,
325 sinh,
326 spacing,
327 sqrt,
328 square,
329 subtract,
330 tan,
331 tanh,
332 true_divide,
333 trunc,
334 vecdot,
335 vecmat,
336)
337
338__all__ = [
339 "False_",
340 "ScalarType",
341 "True_",
342 "absolute",
343 "add",
344 "all",
345 "allclose",
346 "amax",
347 "amin",
348 "any",
349 "arange",
350 "arccos",
351 "arccosh",
352 "arcsin",
353 "arcsinh",
354 "arctan",
355 "arctan2",
356 "arctanh",
357 "argmax",
358 "argmin",
359 "argpartition",
360 "argsort",
361 "argwhere",
362 "around",
363 "array",
364 "array2string",
365 "array_equal",
366 "array_equiv",
367 "array_repr",
368 "array_str",
369 "asanyarray",
370 "asarray",
371 "ascontiguousarray",
372 "asfortranarray",
373 "astype",
374 "base_repr",
375 "binary_repr",
376 "bitwise_and",
377 "bitwise_count",
378 "bitwise_not",
379 "bitwise_or",
380 "bitwise_xor",
381 "bool",
382 "bool_",
383 "broadcast",
384 "busday_count",
385 "busday_offset",
386 "busdaycalendar",
387 "byte",
388 "bytes_",
389 "can_cast",
390 "cbrt",
391 "cdouble",
392 "ceil",
393 "character",
394 "choose",
395 "clip",
396 "clongdouble",
397 "complex64",
398 "complex128",
399 "complex192",
400 "complex256",
401 "complexfloating",
402 "compress",
403 "concatenate",
404 "conj",
405 "conjugate",
406 "convolve",
407 "copysign",
408 "copyto",
409 "correlate",
410 "cos",
411 "cosh",
412 "count_nonzero",
413 "cross",
414 "csingle",
415 "cumprod",
416 "cumsum",
417 "cumulative_prod",
418 "cumulative_sum",
419 "datetime64",
420 "datetime_as_string",
421 "datetime_data",
422 "deg2rad",
423 "degrees",
424 "diagonal",
425 "divide",
426 "divmod",
427 "dot",
428 "double",
429 "dtype",
430 "e",
431 "empty",
432 "empty_like",
433 "equal",
434 "errstate",
435 "euler_gamma",
436 "exp",
437 "exp2",
438 "expm1",
439 "fabs",
440 "flatiter",
441 "flatnonzero",
442 "flexible",
443 "float16",
444 "float32",
445 "float64",
446 "float96",
447 "float128",
448 "float_power",
449 "floating",
450 "floor",
451 "floor_divide",
452 "fmax",
453 "fmin",
454 "fmod",
455 "format_float_positional",
456 "format_float_scientific",
457 "frexp",
458 "from_dlpack",
459 "frombuffer",
460 "fromfile",
461 "fromfunction",
462 "fromiter",
463 "frompyfunc",
464 "fromstring",
465 "full",
466 "full_like",
467 "gcd",
468 "generic",
469 "get_printoptions",
470 "getbufsize",
471 "geterr",
472 "geterrcall",
473 "greater",
474 "greater_equal",
475 "half",
476 "heaviside",
477 "hypot",
478 "identity",
479 "indices",
480 "inexact",
481 "inf",
482 "inner",
483 "int8",
484 "int16",
485 "int32",
486 "int64",
487 "int_",
488 "intc",
489 "integer",
490 "intp",
491 "invert",
492 "is_busday",
493 "isclose",
494 "isdtype",
495 "isfinite",
496 "isfortran",
497 "isinf",
498 "isnan",
499 "isnat",
500 "isscalar",
501 "issubdtype",
502 "lcm",
503 "ldexp",
504 "left_shift",
505 "less",
506 "less_equal",
507 "lexsort",
508 "little_endian",
509 "log",
510 "log1p",
511 "log2",
512 "log10",
513 "logaddexp",
514 "logaddexp2",
515 "logical_and",
516 "logical_not",
517 "logical_or",
518 "logical_xor",
519 "long",
520 "longdouble",
521 "longlong",
522 "matmul",
523 "matrix_transpose",
524 "matvec",
525 "max",
526 "maximum",
527 "may_share_memory",
528 "mean",
529 "min",
530 "min_scalar_type",
531 "minimum",
532 "mod",
533 "modf",
534 "moveaxis",
535 "multiply",
536 "nan",
537 "ndarray",
538 "ndim",
539 "nditer",
540 "negative",
541 "nested_iters",
542 "newaxis",
543 "nextafter",
544 "nonzero",
545 "not_equal",
546 "number",
547 "object_",
548 "ones",
549 "ones_like",
550 "outer",
551 "partition",
552 "pi",
553 "positive",
554 "power",
555 "printoptions",
556 "prod",
557 "promote_types",
558 "ptp",
559 "put",
560 "putmask",
561 "rad2deg",
562 "radians",
563 "ravel",
564 "reciprocal",
565 "remainder",
566 "repeat",
567 "require",
568 "reshape",
569 "resize",
570 "result_type",
571 "right_shift",
572 "rint",
573 "roll",
574 "rollaxis",
575 "round",
576 "searchsorted",
577 "set_printoptions",
578 "setbufsize",
579 "seterr",
580 "seterrcall",
581 "shape",
582 "shares_memory",
583 "short",
584 "sign",
585 "signbit",
586 "signedinteger",
587 "sin",
588 "single",
589 "sinh",
590 "size",
591 "sort",
592 "spacing",
593 "sqrt",
594 "square",
595 "squeeze",
596 "std",
597 "str_",
598 "subtract",
599 "sum",
600 "swapaxes",
601 "take",
602 "tan",
603 "tanh",
604 "tensordot",
605 "timedelta64",
606 "trace",
607 "transpose",
608 "true_divide",
609 "trunc",
610 "typecodes",
611 "ubyte",
612 "ufunc",
613 "uint",
614 "uint8",
615 "uint16",
616 "uint32",
617 "uint64",
618 "uintc",
619 "uintp",
620 "ulong",
621 "ulonglong",
622 "unsignedinteger",
623 "ushort",
624 "var",
625 "vdot",
626 "vecdot",
627 "vecmat",
628 "void",
629 "where",
630 "zeros",
631 "zeros_like",
632]
633
634_T = TypeVar("_T")
635_ScalarT = TypeVar("_ScalarT", bound=generic)
636_NumberObjectT = TypeVar("_NumberObjectT", bound=number | object_)
637_NumericScalarT = TypeVar("_NumericScalarT", bound=number | timedelta64 | object_)
638_DTypeT = TypeVar("_DTypeT", bound=dtype)
639_ArrayT = TypeVar("_ArrayT", bound=np.ndarray[Any, Any])
640_ShapeT = TypeVar("_ShapeT", bound=_Shape)
641
642_AnyShapeT = TypeVar(
643 "_AnyShapeT",
644 tuple[()],
645 tuple[int],
646 tuple[int, int],
647 tuple[int, int, int],
648 tuple[int, int, int, int],
649 tuple[int, ...],
650)
651_AnyNumericScalarT = TypeVar(
652 "_AnyNumericScalarT",
653 np.int8, np.int16, np.int32, np.int64,
654 np.uint8, np.uint16, np.uint32, np.uint64,
655 np.float16, np.float32, np.float64, np.longdouble,
656 np.complex64, np.complex128, np.clongdouble,
657 np.timedelta64,
658 np.object_,
659)
660
661_CorrelateMode: TypeAlias = L["valid", "same", "full"]
662
663_Array1D: TypeAlias = np.ndarray[tuple[int], np.dtype[_ScalarT]]
664_Array2D: TypeAlias = np.ndarray[tuple[int, int], np.dtype[_ScalarT]]
665_Array3D: TypeAlias = np.ndarray[tuple[int, int, int], np.dtype[_ScalarT]]
666_Array4D: TypeAlias = np.ndarray[tuple[int, int, int, int], np.dtype[_ScalarT]]
667
668_Int_co: TypeAlias = np.integer | np.bool
669_Float_co: TypeAlias = np.floating | _Int_co
670_Number_co: TypeAlias = np.number | np.bool
671_TD64_co: TypeAlias = np.timedelta64 | _Int_co
672
673_ArrayLike1D: TypeAlias = _SupportsArray[np.dtype[_ScalarT]] | Sequence[_ScalarT]
674_ArrayLike1DBool_co: TypeAlias = _SupportsArray[np.dtype[np.bool]] | Sequence[py_bool | np.bool]
675_ArrayLike1DInt_co: TypeAlias = _SupportsArray[np.dtype[_Int_co]] | Sequence[int | _Int_co]
676_ArrayLike1DFloat_co: TypeAlias = _SupportsArray[np.dtype[_Float_co]] | Sequence[float | _Float_co]
677_ArrayLike1DNumber_co: TypeAlias = _SupportsArray[np.dtype[_Number_co]] | Sequence[complex | _Number_co]
678_ArrayLike1DTD64_co: TypeAlias = _ArrayLike1D[_TD64_co]
679_ArrayLike1DObject_co: TypeAlias = _ArrayLike1D[np.object_]
680
681_DTypeLikeInt: TypeAlias = type[int] | _IntCodes
682_DTypeLikeFloat64: TypeAlias = type[float] | _Float64Codes | _DoubleCodes
683_DTypeLikeComplex128: TypeAlias = type[complex] | _Complex128Codes | _CDoubleCodes
684
685###
686
687# keep in sync with `ones_like`
688@overload
689def zeros_like(
690 a: _ArrayT,
691 dtype: None = None,
692 order: _OrderKACF = "K",
693 subok: L[True] = True,
694 shape: None = None,
695 *,
696 device: L["cpu"] | None = None,
697) -> _ArrayT: ...
698@overload
699def zeros_like(
700 a: _ArrayLike[_ScalarT],
701 dtype: None = None,
702 order: _OrderKACF = "K",
703 subok: py_bool = True,
704 shape: _ShapeLike | None = None,
705 *,
706 device: L["cpu"] | None = None,
707) -> NDArray[_ScalarT]: ...
708@overload
709def zeros_like(
710 a: object,
711 dtype: _DTypeLike[_ScalarT],
712 order: _OrderKACF = "K",
713 subok: py_bool = True,
714 shape: _ShapeLike | None = None,
715 *,
716 device: L["cpu"] | None = None,
717) -> NDArray[_ScalarT]: ...
718@overload
719def zeros_like(
720 a: object,
721 dtype: DTypeLike | None = None,
722 order: _OrderKACF = "K",
723 subok: py_bool = True,
724 shape: _ShapeLike | None = None,
725 *,
726 device: L["cpu"] | None = None,
727) -> NDArray[Any]: ...
728
729ones: Final[_ConstructorEmpty]
730
731# keep in sync with `zeros_like`
732@overload
733def ones_like(
734 a: _ArrayT,
735 dtype: None = None,
736 order: _OrderKACF = "K",
737 subok: L[True] = True,
738 shape: None = None,
739 *,
740 device: L["cpu"] | None = None,
741) -> _ArrayT: ...
742@overload
743def ones_like(
744 a: _ArrayLike[_ScalarT],
745 dtype: None = None,
746 order: _OrderKACF = "K",
747 subok: py_bool = True,
748 shape: _ShapeLike | None = None,
749 *,
750 device: L["cpu"] | None = None,
751) -> NDArray[_ScalarT]: ...
752@overload
753def ones_like(
754 a: object,
755 dtype: _DTypeLike[_ScalarT],
756 order: _OrderKACF = "K",
757 subok: py_bool = True,
758 shape: _ShapeLike | None = None,
759 *,
760 device: L["cpu"] | None = None,
761) -> NDArray[_ScalarT]: ...
762@overload
763def ones_like(
764 a: object,
765 dtype: DTypeLike | None = None,
766 order: _OrderKACF = "K",
767 subok: py_bool = True,
768 shape: _ShapeLike | None = None,
769 *,
770 device: L["cpu"] | None = None,
771) -> NDArray[Any]: ...
772
773# TODO: Add overloads for bool, int, float, complex, str, bytes, and memoryview
774# 1-D shape
775@overload
776def full(
777 shape: SupportsIndex,
778 fill_value: _ScalarT,
779 dtype: None = None,
780 order: _OrderCF = "C",
781 *,
782 device: L["cpu"] | None = None,
783 like: _SupportsArrayFunc | None = None,
784) -> _Array[tuple[int], _ScalarT]: ...
785@overload
786def full(
787 shape: SupportsIndex,
788 fill_value: Any,
789 dtype: _DTypeT | _SupportsDType[_DTypeT],
790 order: _OrderCF = "C",
791 *,
792 device: L["cpu"] | None = None,
793 like: _SupportsArrayFunc | None = None,
794) -> np.ndarray[tuple[int], _DTypeT]: ...
795@overload
796def full(
797 shape: SupportsIndex,
798 fill_value: Any,
799 dtype: type[_ScalarT],
800 order: _OrderCF = "C",
801 *,
802 device: L["cpu"] | None = None,
803 like: _SupportsArrayFunc | None = None,
804) -> _Array[tuple[int], _ScalarT]: ...
805@overload
806def full(
807 shape: SupportsIndex,
808 fill_value: Any,
809 dtype: DTypeLike | None = None,
810 order: _OrderCF = "C",
811 *,
812 device: L["cpu"] | None = None,
813 like: _SupportsArrayFunc | None = None,
814) -> _Array[tuple[int], Any]: ...
815# known shape
816@overload
817def full(
818 shape: _AnyShapeT,
819 fill_value: _ScalarT,
820 dtype: None = None,
821 order: _OrderCF = "C",
822 *,
823 device: L["cpu"] | None = None,
824 like: _SupportsArrayFunc | None = None,
825) -> _Array[_AnyShapeT, _ScalarT]: ...
826@overload
827def full(
828 shape: _AnyShapeT,
829 fill_value: Any,
830 dtype: _DTypeT | _SupportsDType[_DTypeT],
831 order: _OrderCF = "C",
832 *,
833 device: L["cpu"] | None = None,
834 like: _SupportsArrayFunc | None = None,
835) -> np.ndarray[_AnyShapeT, _DTypeT]: ...
836@overload
837def full(
838 shape: _AnyShapeT,
839 fill_value: Any,
840 dtype: type[_ScalarT],
841 order: _OrderCF = "C",
842 *,
843 device: L["cpu"] | None = None,
844 like: _SupportsArrayFunc | None = None,
845) -> _Array[_AnyShapeT, _ScalarT]: ...
846@overload
847def full(
848 shape: _AnyShapeT,
849 fill_value: Any,
850 dtype: DTypeLike | None = None,
851 order: _OrderCF = "C",
852 *,
853 device: L["cpu"] | None = None,
854 like: _SupportsArrayFunc | None = None,
855) -> _Array[_AnyShapeT, Any]: ...
856# unknown shape
857@overload
858def full(
859 shape: _ShapeLike,
860 fill_value: _ScalarT,
861 dtype: None = None,
862 order: _OrderCF = "C",
863 *,
864 device: L["cpu"] | None = None,
865 like: _SupportsArrayFunc | None = None,
866) -> NDArray[_ScalarT]: ...
867@overload
868def full(
869 shape: _ShapeLike,
870 fill_value: Any,
871 dtype: _DTypeT | _SupportsDType[_DTypeT],
872 order: _OrderCF = "C",
873 *,
874 device: L["cpu"] | None = None,
875 like: _SupportsArrayFunc | None = None,
876) -> np.ndarray[Any, _DTypeT]: ...
877@overload
878def full(
879 shape: _ShapeLike,
880 fill_value: Any,
881 dtype: type[_ScalarT],
882 order: _OrderCF = "C",
883 *,
884 device: L["cpu"] | None = None,
885 like: _SupportsArrayFunc | None = None,
886) -> NDArray[_ScalarT]: ...
887@overload
888def full(
889 shape: _ShapeLike,
890 fill_value: Any,
891 dtype: DTypeLike | None = None,
892 order: _OrderCF = "C",
893 *,
894 device: L["cpu"] | None = None,
895 like: _SupportsArrayFunc | None = None,
896) -> NDArray[Any]: ...
897
898@overload
899def full_like(
900 a: _ArrayT,
901 fill_value: object,
902 dtype: None = None,
903 order: _OrderKACF = "K",
904 subok: L[True] = True,
905 shape: None = None,
906 *,
907 device: L["cpu"] | None = None,
908) -> _ArrayT: ...
909@overload
910def full_like(
911 a: _ArrayLike[_ScalarT],
912 fill_value: object,
913 dtype: None = None,
914 order: _OrderKACF = "K",
915 subok: py_bool = True,
916 shape: _ShapeLike | None = None,
917 *,
918 device: L["cpu"] | None = None,
919) -> NDArray[_ScalarT]: ...
920@overload
921def full_like(
922 a: object,
923 fill_value: object,
924 dtype: _DTypeLike[_ScalarT],
925 order: _OrderKACF = "K",
926 subok: py_bool = True,
927 shape: _ShapeLike | None = None,
928 *,
929 device: L["cpu"] | None = None,
930) -> NDArray[_ScalarT]: ...
931@overload
932def full_like(
933 a: object,
934 fill_value: object,
935 dtype: DTypeLike | None = None,
936 order: _OrderKACF = "K",
937 subok: py_bool = True,
938 shape: _ShapeLike | None = None,
939 *,
940 device: L["cpu"] | None = None,
941) -> NDArray[Any]: ...
942
943#
944@overload
945def count_nonzero(a: ArrayLike, axis: None = None, *, keepdims: L[False] = False) -> np.intp: ...
946@overload
947def count_nonzero(a: _ScalarLike_co, axis: _ShapeLike | None = None, *, keepdims: L[True]) -> np.intp: ...
948@overload
949def count_nonzero(
950 a: NDArray[Any] | _NestedSequence[ArrayLike], axis: _ShapeLike | None = None, *, keepdims: L[True]
951) -> NDArray[np.intp]: ...
952@overload
953def count_nonzero(a: ArrayLike, axis: _ShapeLike | None = None, *, keepdims: py_bool = False) -> Any: ...
954
955#
956def isfortran(a: ndarray | generic) -> py_bool: ...
957
958#
959def argwhere(a: ArrayLike) -> _Array2D[np.intp]: ...
960def flatnonzero(a: ArrayLike) -> _Array1D[np.intp]: ...
961
962# keep in sync with `convolve`
963@overload
964def correlate(
965 a: _ArrayLike1D[_AnyNumericScalarT], v: _ArrayLike1D[_AnyNumericScalarT], mode: _CorrelateMode = "valid"
966) -> _Array1D[_AnyNumericScalarT]: ...
967@overload
968def correlate(a: _ArrayLike1DBool_co, v: _ArrayLike1DBool_co, mode: _CorrelateMode = "valid") -> _Array1D[np.bool]: ...
969@overload
970def correlate(a: _ArrayLike1DInt_co, v: _ArrayLike1DInt_co, mode: _CorrelateMode = "valid") -> _Array1D[np.int_ | Any]: ...
971@overload
972def correlate(a: _ArrayLike1DFloat_co, v: _ArrayLike1DFloat_co, mode: _CorrelateMode = "valid") -> _Array1D[np.float64 | Any]: ...
973@overload
974def correlate(
975 a: _ArrayLike1DNumber_co, v: _ArrayLike1DNumber_co, mode: _CorrelateMode = "valid"
976) -> _Array1D[np.complex128 | Any]: ...
977@overload
978def correlate(
979 a: _ArrayLike1DTD64_co, v: _ArrayLike1DTD64_co, mode: _CorrelateMode = "valid"
980) -> _Array1D[np.timedelta64 | Any]: ...
981
982# keep in sync with `correlate`
983@overload
984def convolve(
985 a: _ArrayLike1D[_AnyNumericScalarT], v: _ArrayLike1D[_AnyNumericScalarT], mode: _CorrelateMode = "valid"
986) -> _Array1D[_AnyNumericScalarT]: ...
987@overload
988def convolve(a: _ArrayLike1DBool_co, v: _ArrayLike1DBool_co, mode: _CorrelateMode = "valid") -> _Array1D[np.bool]: ...
989@overload
990def convolve(a: _ArrayLike1DInt_co, v: _ArrayLike1DInt_co, mode: _CorrelateMode = "valid") -> _Array1D[np.int_ | Any]: ...
991@overload
992def convolve(a: _ArrayLike1DFloat_co, v: _ArrayLike1DFloat_co, mode: _CorrelateMode = "valid") -> _Array1D[np.float64 | Any]: ...
993@overload
994def convolve(
995 a: _ArrayLike1DNumber_co, v: _ArrayLike1DNumber_co, mode: _CorrelateMode = "valid"
996) -> _Array1D[np.complex128 | Any]: ...
997@overload
998def convolve(
999 a: _ArrayLike1DTD64_co, v: _ArrayLike1DTD64_co, mode: _CorrelateMode = "valid"
1000) -> _Array1D[np.timedelta64 | Any]: ...
1001
1002# keep roughly in sync with `convolve` and `correlate`, but for 2-D output and an additional `out` overload
1003@overload
1004def outer(
1005 a: _ArrayLike[_AnyNumericScalarT], b: _ArrayLike[_AnyNumericScalarT], out: None = None
1006) -> _Array2D[_AnyNumericScalarT]: ...
1007@overload
1008def outer(a: _ArrayLikeBool_co, b: _ArrayLikeBool_co, out: None = None) -> _Array2D[np.bool]: ...
1009@overload
1010def outer(a: _ArrayLikeInt_co, b: _ArrayLikeInt_co, out: None = None) -> _Array2D[np.int_ | Any]: ...
1011@overload
1012def outer(a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co, out: None = None) -> _Array2D[np.float64 | Any]: ...
1013@overload
1014def outer(a: _ArrayLikeComplex_co, b: _ArrayLikeComplex_co, out: None = None) -> _Array2D[np.complex128 | Any]: ...
1015@overload
1016def outer(a: _ArrayLikeTD64_co, b: _ArrayLikeTD64_co, out: None = None) -> _Array2D[np.timedelta64 | Any]: ...
1017@overload
1018def outer(a: _ArrayLikeNumber_co | _ArrayLikeTD64_co, b: _ArrayLikeNumber_co | _ArrayLikeTD64_co, out: _ArrayT) -> _ArrayT: ...
1019
1020# keep in sync with numpy.linalg._linalg.tensordot (ignoring `/, *`)
1021@overload
1022def tensordot(
1023 a: _ArrayLike[_AnyNumericScalarT], b: _ArrayLike[_AnyNumericScalarT], axes: int | tuple[_ShapeLike, _ShapeLike] = 2
1024) -> NDArray[_AnyNumericScalarT]: ...
1025@overload
1026def tensordot(a: _ArrayLikeBool_co, b: _ArrayLikeBool_co, axes: int | tuple[_ShapeLike, _ShapeLike] = 2) -> NDArray[np.bool]: ...
1027@overload
1028def tensordot(
1029 a: _ArrayLikeInt_co, b: _ArrayLikeInt_co, axes: int | tuple[_ShapeLike, _ShapeLike] = 2
1030) -> NDArray[np.int_ | Any]: ...
1031@overload
1032def tensordot(
1033 a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co, axes: int | tuple[_ShapeLike, _ShapeLike] = 2
1034) -> NDArray[np.float64 | Any]: ...
1035@overload
1036def tensordot(
1037 a: _ArrayLikeComplex_co, b: _ArrayLikeComplex_co, axes: int | tuple[_ShapeLike, _ShapeLike] = 2
1038) -> NDArray[np.complex128 | Any]: ...
1039
1040#
1041@overload
1042def cross(
1043 a: _ArrayLike[_AnyNumericScalarT],
1044 b: _ArrayLike[_AnyNumericScalarT],
1045 axisa: int = -1,
1046 axisb: int = -1,
1047 axisc: int = -1,
1048 axis: int | None = None,
1049) -> NDArray[_AnyNumericScalarT]: ...
1050@overload
1051def cross(
1052 a: _ArrayLikeInt_co,
1053 b: _ArrayLikeInt_co,
1054 axisa: int = -1,
1055 axisb: int = -1,
1056 axisc: int = -1,
1057 axis: int | None = None,
1058) -> NDArray[np.int_ | Any]: ...
1059@overload
1060def cross(
1061 a: _ArrayLikeFloat_co,
1062 b: _ArrayLikeFloat_co,
1063 axisa: int = -1,
1064 axisb: int = -1,
1065 axisc: int = -1,
1066 axis: int | None = None,
1067) -> NDArray[np.float64 | Any]: ...
1068@overload
1069def cross(
1070 a: _ArrayLikeComplex_co,
1071 b: _ArrayLikeComplex_co,
1072 axisa: int = -1,
1073 axisb: int = -1,
1074 axisc: int = -1,
1075 axis: int | None = None,
1076) -> NDArray[np.complex128 | Any]: ...
1077
1078#
1079@overload
1080def roll(a: _ArrayT, shift: _ShapeLike, axis: _ShapeLike | None = None) -> _ArrayT: ...
1081@overload
1082def roll(a: _ArrayLike[_ScalarT], shift: _ShapeLike, axis: _ShapeLike | None = None) -> NDArray[_ScalarT]: ...
1083@overload
1084def roll(a: ArrayLike, shift: _ShapeLike, axis: _ShapeLike | None = None) -> NDArray[Any]: ...
1085
1086#
1087def rollaxis(a: _ArrayT, axis: int, start: int = 0) -> _ArrayT: ...
1088def moveaxis(a: _ArrayT, source: _ShapeLike, destination: _ShapeLike) -> _ArrayT: ...
1089def normalize_axis_tuple(
1090 axis: int | Iterable[int],
1091 ndim: int,
1092 argname: str | None = None,
1093 allow_duplicate: py_bool | None = False,
1094) -> tuple[int, ...]: ...
1095
1096#
1097@overload # 0d, dtype=int (default), sparse=False (default)
1098def indices(dimensions: tuple[()], dtype: type[int] = int, sparse: L[False] = False) -> _Array1D[np.intp]: ...
1099@overload # 0d, dtype=<irrelevant>, sparse=True
1100def indices(dimensions: tuple[()], dtype: DTypeLike | None = int, *, sparse: L[True]) -> tuple[()]: ...
1101@overload # 0d, dtype=<known>, sparse=False (default)
1102def indices(dimensions: tuple[()], dtype: _DTypeLike[_ScalarT], sparse: L[False] = False) -> _Array1D[_ScalarT]: ...
1103@overload # 0d, dtype=<unknown>, sparse=False (default)
1104def indices(dimensions: tuple[()], dtype: DTypeLike, sparse: L[False] = False) -> _Array1D[Any]: ...
1105@overload # 1d, dtype=int (default), sparse=False (default)
1106def indices(dimensions: tuple[int], dtype: type[int] = int, sparse: L[False] = False) -> _Array2D[np.intp]: ...
1107@overload # 1d, dtype=int (default), sparse=True
1108def indices(dimensions: tuple[int], dtype: type[int] = int, *, sparse: L[True]) -> tuple[_Array1D[np.intp]]: ...
1109@overload # 1d, dtype=<known>, sparse=False (default)
1110def indices(dimensions: tuple[int], dtype: _DTypeLike[_ScalarT], sparse: L[False] = False) -> _Array2D[_ScalarT]: ...
1111@overload # 1d, dtype=<known>, sparse=True
1112def indices(dimensions: tuple[int], dtype: _DTypeLike[_ScalarT], sparse: L[True]) -> tuple[_Array1D[_ScalarT]]: ...
1113@overload # 1d, dtype=<unknown>, sparse=False (default)
1114def indices(dimensions: tuple[int], dtype: DTypeLike, sparse: L[False] = False) -> _Array2D[Any]: ...
1115@overload # 1d, dtype=<unknown>, sparse=True
1116def indices(dimensions: tuple[int], dtype: DTypeLike, sparse: L[True]) -> tuple[_Array1D[Any]]: ...
1117@overload # 2d, dtype=int (default), sparse=False (default)
1118def indices(dimensions: tuple[int, int], dtype: type[int] = int, sparse: L[False] = False) -> _Array3D[np.intp]: ...
1119@overload # 2d, dtype=int (default), sparse=True
1120def indices(
1121 dimensions: tuple[int, int], dtype: type[int] = int, *, sparse: L[True]
1122) -> tuple[_Array2D[np.intp], _Array2D[np.intp]]: ...
1123@overload # 2d, dtype=<known>, sparse=False (default)
1124def indices(dimensions: tuple[int, int], dtype: _DTypeLike[_ScalarT], sparse: L[False] = False) -> _Array3D[_ScalarT]: ...
1125@overload # 2d, dtype=<known>, sparse=True
1126def indices(
1127 dimensions: tuple[int, int], dtype: _DTypeLike[_ScalarT], sparse: L[True]
1128) -> tuple[_Array2D[_ScalarT], _Array2D[_ScalarT]]: ...
1129@overload # 2d, dtype=<unknown>, sparse=False (default)
1130def indices(dimensions: tuple[int, int], dtype: DTypeLike, sparse: L[False] = False) -> _Array3D[Any]: ...
1131@overload # 2d, dtype=<unknown>, sparse=True
1132def indices(dimensions: tuple[int, int], dtype: DTypeLike, sparse: L[True]) -> tuple[_Array2D[Any], _Array2D[Any]]: ...
1133@overload # ?d, dtype=int (default), sparse=False (default)
1134def indices(dimensions: Sequence[int], dtype: type[int] = int, sparse: L[False] = False) -> NDArray[np.intp]: ...
1135@overload # ?d, dtype=int (default), sparse=True
1136def indices(dimensions: Sequence[int], dtype: type[int] = int, *, sparse: L[True]) -> tuple[NDArray[np.intp], ...]: ...
1137@overload # ?d, dtype=<known>, sparse=False (default)
1138def indices(dimensions: Sequence[int], dtype: _DTypeLike[_ScalarT], sparse: L[False] = False) -> NDArray[_ScalarT]: ...
1139@overload # ?d, dtype=<known>, sparse=True
1140def indices(dimensions: Sequence[int], dtype: _DTypeLike[_ScalarT], sparse: L[True]) -> tuple[NDArray[_ScalarT], ...]: ...
1141@overload # ?d, dtype=<unknown>, sparse=False (default)
1142def indices(dimensions: Sequence[int], dtype: DTypeLike, sparse: L[False] = False) -> ndarray: ...
1143@overload # ?d, dtype=<unknown>, sparse=True
1144def indices(dimensions: Sequence[int], dtype: DTypeLike, sparse: L[True]) -> tuple[ndarray, ...]: ...
1145
1146#
1147def fromfunction(
1148 function: Callable[..., _T],
1149 shape: Sequence[int],
1150 *,
1151 dtype: DTypeLike | None = float,
1152 like: _SupportsArrayFunc | None = None,
1153 **kwargs: object,
1154) -> _T: ...
1155
1156#
1157def isscalar(element: object) -> TypeGuard[generic | complex | str | bytes | memoryview]: ...
1158
1159#
1160def binary_repr(num: SupportsIndex, width: int | None = None) -> str: ...
1161def base_repr(number: SupportsAbs[float], base: float = 2, padding: SupportsIndex | None = 0) -> str: ...
1162
1163#
1164@overload # dtype: None (default)
1165def identity(n: int, dtype: None = None, *, like: _SupportsArrayFunc | None = None) -> _Array2D[np.float64]: ...
1166@overload # dtype: known scalar type
1167def identity(n: int, dtype: _DTypeLike[_ScalarT], *, like: _SupportsArrayFunc | None = None) -> _Array2D[_ScalarT]: ...
1168@overload # dtype: like bool
1169def identity(n: int, dtype: _DTypeLikeBool, *, like: _SupportsArrayFunc | None = None) -> _Array2D[np.bool]: ...
1170@overload # dtype: like int_
1171def identity(n: int, dtype: _DTypeLikeInt, *, like: _SupportsArrayFunc | None = None) -> _Array2D[np.int_ | Any]: ...
1172@overload # dtype: like float64
1173def identity(n: int, dtype: _DTypeLikeFloat64, *, like: _SupportsArrayFunc | None = None) -> _Array2D[np.float64 | Any]: ...
1174@overload # dtype: like complex128
1175def identity(n: int, dtype: _DTypeLikeComplex128, *, like: _SupportsArrayFunc | None = None) -> _Array2D[np.complex128 | Any]: ...
1176@overload # dtype: unknown
1177def identity(n: int, dtype: DTypeLike, *, like: _SupportsArrayFunc | None = None) -> _Array2D[Incomplete]: ...
1178
1179#
1180def allclose(
1181 a: ArrayLike,
1182 b: ArrayLike,
1183 rtol: ArrayLike = 1e-5,
1184 atol: ArrayLike = 1e-8,
1185 equal_nan: py_bool = False,
1186) -> py_bool: ...
1187
1188#
1189@overload # scalar, scalar
1190def isclose(
1191 a: _NumberLike_co,
1192 b: _NumberLike_co,
1193 rtol: ArrayLike = 1e-5,
1194 atol: ArrayLike = 1e-8,
1195 equal_nan: py_bool = False,
1196) -> np.bool: ...
1197@overload # known shape, same shape or scalar
1198def isclose(
1199 a: np.ndarray[_ShapeT],
1200 b: np.ndarray[_ShapeT] | _NumberLike_co,