| import builtins |
| import os |
| import mmap |
| import ctypes as ct |
| import array as _array |
| import datetime as dt |
| import enum |
| from abc import abstractmethod |
| from types import TracebackType, MappingProxyType, GenericAlias |
| from contextlib import ContextDecorator |
| from contextlib import contextmanager |
| |
| from numpy._pytesttester import PytestTester |
| from numpy.core._internal import _ctypes |
| |
| from numpy._typing import ( |
| # Arrays |
| ArrayLike, |
| NDArray, |
| _SupportsArray, |
| _NestedSequence, |
| _FiniteNestedSequence, |
| _SupportsArray, |
| _ArrayLikeBool_co, |
| _ArrayLikeUInt_co, |
| _ArrayLikeInt_co, |
| _ArrayLikeFloat_co, |
| _ArrayLikeComplex_co, |
| _ArrayLikeNumber_co, |
| _ArrayLikeTD64_co, |
| _ArrayLikeDT64_co, |
| _ArrayLikeObject_co, |
| _ArrayLikeStr_co, |
| _ArrayLikeBytes_co, |
| _ArrayLikeUnknown, |
| _UnknownType, |
| |
| # DTypes |
| DTypeLike, |
| _DTypeLike, |
| _DTypeLikeVoid, |
| _SupportsDType, |
| _VoidDTypeLike, |
| |
| # Shapes |
| _Shape, |
| _ShapeLike, |
| |
| # Scalars |
| _CharLike_co, |
| _BoolLike_co, |
| _IntLike_co, |
| _FloatLike_co, |
| _ComplexLike_co, |
| _TD64Like_co, |
| _NumberLike_co, |
| _ScalarLike_co, |
| |
| # `number` precision |
| NBitBase, |
| _256Bit, |
| _128Bit, |
| _96Bit, |
| _80Bit, |
| _64Bit, |
| _32Bit, |
| _16Bit, |
| _8Bit, |
| _NBitByte, |
| _NBitShort, |
| _NBitIntC, |
| _NBitIntP, |
| _NBitInt, |
| _NBitLongLong, |
| _NBitHalf, |
| _NBitSingle, |
| _NBitDouble, |
| _NBitLongDouble, |
| |
| # Character codes |
| _BoolCodes, |
| _UInt8Codes, |
| _UInt16Codes, |
| _UInt32Codes, |
| _UInt64Codes, |
| _Int8Codes, |
| _Int16Codes, |
| _Int32Codes, |
| _Int64Codes, |
| _Float16Codes, |
| _Float32Codes, |
| _Float64Codes, |
| _Complex64Codes, |
| _Complex128Codes, |
| _ByteCodes, |
| _ShortCodes, |
| _IntCCodes, |
| _IntPCodes, |
| _IntCodes, |
| _LongLongCodes, |
| _UByteCodes, |
| _UShortCodes, |
| _UIntCCodes, |
| _UIntPCodes, |
| _UIntCodes, |
| _ULongLongCodes, |
| _HalfCodes, |
| _SingleCodes, |
| _DoubleCodes, |
| _LongDoubleCodes, |
| _CSingleCodes, |
| _CDoubleCodes, |
| _CLongDoubleCodes, |
| _DT64Codes, |
| _TD64Codes, |
| _StrCodes, |
| _BytesCodes, |
| _VoidCodes, |
| _ObjectCodes, |
| |
| # Ufuncs |
| _UFunc_Nin1_Nout1, |
| _UFunc_Nin2_Nout1, |
| _UFunc_Nin1_Nout2, |
| _UFunc_Nin2_Nout2, |
| _GUFunc_Nin2_Nout1, |
| ) |
| |
| from numpy._typing._callable import ( |
| _BoolOp, |
| _BoolBitOp, |
| _BoolSub, |
| _BoolTrueDiv, |
| _BoolMod, |
| _BoolDivMod, |
| _TD64Div, |
| _IntTrueDiv, |
| _UnsignedIntOp, |
| _UnsignedIntBitOp, |
| _UnsignedIntMod, |
| _UnsignedIntDivMod, |
| _SignedIntOp, |
| _SignedIntBitOp, |
| _SignedIntMod, |
| _SignedIntDivMod, |
| _FloatOp, |
| _FloatMod, |
| _FloatDivMod, |
| _ComplexOp, |
| _NumberOp, |
| _ComparisonOp, |
| ) |
| |
| # NOTE: Numpy's mypy plugin is used for removing the types unavailable |
| # to the specific platform |
| from numpy._typing._extended_precision import ( |
| uint128 as uint128, |
| uint256 as uint256, |
| int128 as int128, |
| int256 as int256, |
| float80 as float80, |
| float96 as float96, |
| float128 as float128, |
| float256 as float256, |
| complex160 as complex160, |
| complex192 as complex192, |
| complex256 as complex256, |
| complex512 as complex512, |
| ) |
| |
| from collections.abc import ( |
| Callable, |
| Container, |
| Iterable, |
| Iterator, |
| Mapping, |
| Sequence, |
| Sized, |
| ) |
| from typing import ( |
| Literal as L, |
| Any, |
| Generator, |
| Generic, |
| IO, |
| NoReturn, |
| overload, |
| SupportsComplex, |
| SupportsFloat, |
| SupportsInt, |
| TypeVar, |
| Union, |
| Protocol, |
| SupportsIndex, |
| Final, |
| final, |
| ClassVar, |
| ) |
| |
| # Ensures that the stubs are picked up |
| from numpy import ( |
| ctypeslib as ctypeslib, |
| exceptions as exceptions, |
| fft as fft, |
| lib as lib, |
| linalg as linalg, |
| ma as ma, |
| polynomial as polynomial, |
| random as random, |
| testing as testing, |
| version as version, |
| exceptions as exceptions, |
| dtypes as dtypes, |
| ) |
| |
| from numpy.core import defchararray, records |
| char = defchararray |
| rec = records |
| |
| from numpy.core.function_base import ( |
| linspace as linspace, |
| logspace as logspace, |
| geomspace as geomspace, |
| ) |
| |
| from numpy.core.fromnumeric import ( |
| take as take, |
| reshape as reshape, |
| choose as choose, |
| repeat as repeat, |
| put as put, |
| swapaxes as swapaxes, |
| transpose as transpose, |
| partition as partition, |
| argpartition as argpartition, |
| sort as sort, |
| argsort as argsort, |
| argmax as argmax, |
| argmin as argmin, |
| searchsorted as searchsorted, |
| resize as resize, |
| squeeze as squeeze, |
| diagonal as diagonal, |
| trace as trace, |
| ravel as ravel, |
| nonzero as nonzero, |
| shape as shape, |
| compress as compress, |
| clip as clip, |
| sum as sum, |
| all as all, |
| any as any, |
| cumsum as cumsum, |
| ptp as ptp, |
| max as max, |
| min as min, |
| amax as amax, |
| amin as amin, |
| prod as prod, |
| cumprod as cumprod, |
| ndim as ndim, |
| size as size, |
| around as around, |
| round as round, |
| mean as mean, |
| std as std, |
| var as var, |
| ) |
| |
| from numpy.core._asarray import ( |
| require as require, |
| ) |
| |
| from numpy.core._type_aliases import ( |
| sctypes as sctypes, |
| sctypeDict as sctypeDict, |
| ) |
| |
| from numpy.core._ufunc_config import ( |
| seterr as seterr, |
| geterr as geterr, |
| setbufsize as setbufsize, |
| getbufsize as getbufsize, |
| seterrcall as seterrcall, |
| geterrcall as geterrcall, |
| _ErrKind, |
| _ErrFunc, |
| _ErrDictOptional, |
| ) |
| |
| from numpy.core.arrayprint import ( |
| set_printoptions as set_printoptions, |
| get_printoptions as get_printoptions, |
| array2string as array2string, |
| format_float_scientific as format_float_scientific, |
| format_float_positional as format_float_positional, |
| array_repr as array_repr, |
| array_str as array_str, |
| set_string_function as set_string_function, |
| printoptions as printoptions, |
| ) |
| |
| from numpy.core.einsumfunc import ( |
| einsum as einsum, |
| einsum_path as einsum_path, |
| ) |
| |
| from numpy.core.multiarray import ( |
| ALLOW_THREADS as ALLOW_THREADS, |
| BUFSIZE as BUFSIZE, |
| CLIP as CLIP, |
| MAXDIMS as MAXDIMS, |
| MAY_SHARE_BOUNDS as MAY_SHARE_BOUNDS, |
| MAY_SHARE_EXACT as MAY_SHARE_EXACT, |
| RAISE as RAISE, |
| WRAP as WRAP, |
| tracemalloc_domain as tracemalloc_domain, |
| array as array, |
| empty_like as empty_like, |
| empty as empty, |
| zeros as zeros, |
| concatenate as concatenate, |
| inner as inner, |
| where as where, |
| lexsort as lexsort, |
| can_cast as can_cast, |
| min_scalar_type as min_scalar_type, |
| result_type as result_type, |
| dot as dot, |
| vdot as vdot, |
| bincount as bincount, |
| copyto as copyto, |
| putmask as putmask, |
| packbits as packbits, |
| unpackbits as unpackbits, |
| shares_memory as shares_memory, |
| may_share_memory as may_share_memory, |
| asarray as asarray, |
| asanyarray as asanyarray, |
| ascontiguousarray as ascontiguousarray, |
| asfortranarray as asfortranarray, |
| arange as arange, |
| busday_count as busday_count, |
| busday_offset as busday_offset, |
| compare_chararrays as compare_chararrays, |
| datetime_as_string as datetime_as_string, |
| datetime_data as datetime_data, |
| frombuffer as frombuffer, |
| fromfile as fromfile, |
| fromiter as fromiter, |
| is_busday as is_busday, |
| promote_types as promote_types, |
| seterrobj as seterrobj, |
| geterrobj as geterrobj, |
| fromstring as fromstring, |
| frompyfunc as frompyfunc, |
| nested_iters as nested_iters, |
| flagsobj, |
| ) |
| |
| from numpy.core.numeric import ( |
| zeros_like as zeros_like, |
| ones as ones, |
| ones_like as ones_like, |
| full as full, |
| full_like as full_like, |
| count_nonzero as count_nonzero, |
| isfortran as isfortran, |
| argwhere as argwhere, |
| flatnonzero as flatnonzero, |
| correlate as correlate, |
| convolve as convolve, |
| outer as outer, |
| tensordot as tensordot, |
| roll as roll, |
| rollaxis as rollaxis, |
| moveaxis as moveaxis, |
| cross as cross, |
| indices as indices, |
| fromfunction as fromfunction, |
| isscalar as isscalar, |
| binary_repr as binary_repr, |
| base_repr as base_repr, |
| identity as identity, |
| allclose as allclose, |
| isclose as isclose, |
| array_equal as array_equal, |
| array_equiv as array_equiv, |
| ) |
| |
| from numpy.core.numerictypes import ( |
| maximum_sctype as maximum_sctype, |
| issctype as issctype, |
| obj2sctype as obj2sctype, |
| issubclass_ as issubclass_, |
| issubsctype as issubsctype, |
| issubdtype as issubdtype, |
| sctype2char as sctype2char, |
| nbytes as nbytes, |
| cast as cast, |
| ScalarType as ScalarType, |
| typecodes as typecodes, |
| ) |
| |
| from numpy.core.shape_base import ( |
| atleast_1d as atleast_1d, |
| atleast_2d as atleast_2d, |
| atleast_3d as atleast_3d, |
| block as block, |
| hstack as hstack, |
| stack as stack, |
| vstack as vstack, |
| ) |
| |
| from numpy.exceptions import ( |
| ComplexWarning as ComplexWarning, |
| ModuleDeprecationWarning as ModuleDeprecationWarning, |
| VisibleDeprecationWarning as VisibleDeprecationWarning, |
| TooHardError as TooHardError, |
| DTypePromotionError as DTypePromotionError, |
| AxisError as AxisError, |
| ) |
| |
| from numpy.lib import ( |
| emath as emath, |
| ) |
| |
| from numpy.lib.arraypad import ( |
| pad as pad, |
| ) |
| |
| from numpy.lib.arraysetops import ( |
| ediff1d as ediff1d, |
| intersect1d as intersect1d, |
| setxor1d as setxor1d, |
| union1d as union1d, |
| setdiff1d as setdiff1d, |
| unique as unique, |
| in1d as in1d, |
| isin as isin, |
| ) |
| |
| from numpy.lib.arrayterator import ( |
| Arrayterator as Arrayterator, |
| ) |
| |
| from numpy.lib.function_base import ( |
| select as select, |
| piecewise as piecewise, |
| trim_zeros as trim_zeros, |
| copy as copy, |
| iterable as iterable, |
| percentile as percentile, |
| diff as diff, |
| gradient as gradient, |
| angle as angle, |
| unwrap as unwrap, |
| sort_complex as sort_complex, |
| disp as disp, |
| flip as flip, |
| rot90 as rot90, |
| extract as extract, |
| place as place, |
| asarray_chkfinite as asarray_chkfinite, |
| average as average, |
| bincount as bincount, |
| digitize as digitize, |
| cov as cov, |
| corrcoef as corrcoef, |
| median as median, |
| sinc as sinc, |
| hamming as hamming, |
| hanning as hanning, |
| bartlett as bartlett, |
| blackman as blackman, |
| kaiser as kaiser, |
| trapz as trapz, |
| i0 as i0, |
| add_newdoc as add_newdoc, |
| add_docstring as add_docstring, |
| meshgrid as meshgrid, |
| delete as delete, |
| insert as insert, |
| append as append, |
| interp as interp, |
| add_newdoc_ufunc as add_newdoc_ufunc, |
| quantile as quantile, |
| ) |
| |
| from numpy.lib.histograms import ( |
| histogram_bin_edges as histogram_bin_edges, |
| histogram as histogram, |
| histogramdd as histogramdd, |
| ) |
| |
| from numpy.lib.index_tricks import ( |
| ravel_multi_index as ravel_multi_index, |
| unravel_index as unravel_index, |
| mgrid as mgrid, |
| ogrid as ogrid, |
| r_ as r_, |
| c_ as c_, |
| s_ as s_, |
| index_exp as index_exp, |
| ix_ as ix_, |
| fill_diagonal as fill_diagonal, |
| diag_indices as diag_indices, |
| diag_indices_from as diag_indices_from, |
| ) |
| |
| from numpy.lib.nanfunctions import ( |
| nansum as nansum, |
| nanmax as nanmax, |
| nanmin as nanmin, |
| nanargmax as nanargmax, |
| nanargmin as nanargmin, |
| nanmean as nanmean, |
| nanmedian as nanmedian, |
| nanpercentile as nanpercentile, |
| nanvar as nanvar, |
| nanstd as nanstd, |
| nanprod as nanprod, |
| nancumsum as nancumsum, |
| nancumprod as nancumprod, |
| nanquantile as nanquantile, |
| ) |
| |
| from numpy.lib.npyio import ( |
| savetxt as savetxt, |
| loadtxt as loadtxt, |
| genfromtxt as genfromtxt, |
| recfromtxt as recfromtxt, |
| recfromcsv as recfromcsv, |
| load as load, |
| save as save, |
| savez as savez, |
| savez_compressed as savez_compressed, |
| packbits as packbits, |
| unpackbits as unpackbits, |
| fromregex as fromregex, |
| ) |
| |
| from numpy.lib.polynomial import ( |
| poly as poly, |
| roots as roots, |
| polyint as polyint, |
| polyder as polyder, |
| polyadd as polyadd, |
| polysub as polysub, |
| polymul as polymul, |
| polydiv as polydiv, |
| polyval as polyval, |
| polyfit as polyfit, |
| ) |
| |
| from numpy.lib.shape_base import ( |
| column_stack as column_stack, |
| row_stack as row_stack, |
| dstack as dstack, |
| array_split as array_split, |
| split as split, |
| hsplit as hsplit, |
| vsplit as vsplit, |
| dsplit as dsplit, |
| apply_over_axes as apply_over_axes, |
| expand_dims as expand_dims, |
| apply_along_axis as apply_along_axis, |
| kron as kron, |
| tile as tile, |
| get_array_wrap as get_array_wrap, |
| take_along_axis as take_along_axis, |
| put_along_axis as put_along_axis, |
| ) |
| |
| from numpy.lib.stride_tricks import ( |
| broadcast_to as broadcast_to, |
| broadcast_arrays as broadcast_arrays, |
| broadcast_shapes as broadcast_shapes, |
| ) |
| |
| from numpy.lib.twodim_base import ( |
| diag as diag, |
| diagflat as diagflat, |
| eye as eye, |
| fliplr as fliplr, |
| flipud as flipud, |
| tri as tri, |
| triu as triu, |
| tril as tril, |
| vander as vander, |
| histogram2d as histogram2d, |
| mask_indices as mask_indices, |
| tril_indices as tril_indices, |
| tril_indices_from as tril_indices_from, |
| triu_indices as triu_indices, |
| triu_indices_from as triu_indices_from, |
| ) |
| |
| from numpy.lib.type_check import ( |
| mintypecode as mintypecode, |
| asfarray as asfarray, |
| real as real, |
| imag as imag, |
| iscomplex as iscomplex, |
| isreal as isreal, |
| iscomplexobj as iscomplexobj, |
| isrealobj as isrealobj, |
| nan_to_num as nan_to_num, |
| real_if_close as real_if_close, |
| typename as typename, |
| common_type as common_type, |
| ) |
| |
| from numpy.lib.ufunclike import ( |
| fix as fix, |
| isposinf as isposinf, |
| isneginf as isneginf, |
| ) |
| |
| from numpy.lib.utils import ( |
| issubclass_ as issubclass_, |
| issubsctype as issubsctype, |
| issubdtype as issubdtype, |
| deprecate as deprecate, |
| deprecate_with_doc as deprecate_with_doc, |
| get_include as get_include, |
| info as info, |
| source as source, |
| who as who, |
| lookfor as lookfor, |
| byte_bounds as byte_bounds, |
| safe_eval as safe_eval, |
| show_runtime as show_runtime, |
| ) |
| |
| from numpy.matrixlib import ( |
| asmatrix as asmatrix, |
| mat as mat, |
| bmat as bmat, |
| ) |
| |
| _AnyStr_contra = TypeVar("_AnyStr_contra", str, bytes, contravariant=True) |
| |
| # Protocol for representing file-like-objects accepted |
| # by `ndarray.tofile` and `fromfile` |
| class _IOProtocol(Protocol): |
| def flush(self) -> object: ... |
| def fileno(self) -> int: ... |
| def tell(self) -> SupportsIndex: ... |
| def seek(self, offset: int, whence: int, /) -> object: ... |
| |
| # NOTE: `seek`, `write` and `flush` are technically only required |
| # for `readwrite`/`write` modes |
| class _MemMapIOProtocol(Protocol): |
| def flush(self) -> object: ... |
| def fileno(self) -> SupportsIndex: ... |
| def tell(self) -> int: ... |
| def seek(self, offset: int, whence: int, /) -> object: ... |
| def write(self, s: bytes, /) -> object: ... |
| @property |
| def read(self) -> object: ... |
| |
| class _SupportsWrite(Protocol[_AnyStr_contra]): |
| def write(self, s: _AnyStr_contra, /) -> object: ... |
| |
| __all__: list[str] |
| __path__: list[str] |
| __version__: str |
| __git_version__: str |
| test: PytestTester |
| |
| # TODO: Move placeholders to their respective module once |
| # their annotations are properly implemented |
| # |
| # Placeholders for classes |
| |
| def show_config() -> None: ... |
| |
| _NdArraySubClass = TypeVar("_NdArraySubClass", bound=ndarray[Any, Any]) |
| _DTypeScalar_co = TypeVar("_DTypeScalar_co", covariant=True, bound=generic) |
| _ByteOrder = L["S", "<", ">", "=", "|", "L", "B", "N", "I"] |
| |
| @final |
| class dtype(Generic[_DTypeScalar_co]): |
| names: None | tuple[builtins.str, ...] |
| # Overload for subclass of generic |
| @overload |
| def __new__( |
| cls, |
| dtype: type[_DTypeScalar_co], |
| align: bool = ..., |
| copy: bool = ..., |
| metadata: dict[builtins.str, Any] = ..., |
| ) -> dtype[_DTypeScalar_co]: ... |
| # Overloads for string aliases, Python types, and some assorted |
| # other special cases. Order is sometimes important because of the |
| # subtype relationships |
| # |
| # bool < int < float < complex < object |
| # |
| # so we have to make sure the overloads for the narrowest type is |
| # first. |
| # Builtin types |
| @overload |
| def __new__(cls, dtype: type[bool], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[bool_]: ... |
| @overload |
| def __new__(cls, dtype: type[int], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[int_]: ... |
| @overload |
| def __new__(cls, dtype: None | type[float], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[float_]: ... |
| @overload |
| def __new__(cls, dtype: type[complex], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[complex_]: ... |
| @overload |
| def __new__(cls, dtype: type[builtins.str], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[str_]: ... |
| @overload |
| def __new__(cls, dtype: type[bytes], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[bytes_]: ... |
| |
| # `unsignedinteger` string-based representations and ctypes |
| @overload |
| def __new__(cls, dtype: _UInt8Codes | type[ct.c_uint8], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uint8]: ... |
| @overload |
| def __new__(cls, dtype: _UInt16Codes | type[ct.c_uint16], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uint16]: ... |
| @overload |
| def __new__(cls, dtype: _UInt32Codes | type[ct.c_uint32], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uint32]: ... |
| @overload |
| def __new__(cls, dtype: _UInt64Codes | type[ct.c_uint64], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uint64]: ... |
| @overload |
| def __new__(cls, dtype: _UByteCodes | type[ct.c_ubyte], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[ubyte]: ... |
| @overload |
| def __new__(cls, dtype: _UShortCodes | type[ct.c_ushort], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[ushort]: ... |
| @overload |
| def __new__(cls, dtype: _UIntCCodes | type[ct.c_uint], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uintc]: ... |
| |
| # NOTE: We're assuming here that `uint_ptr_t == size_t`, |
| # an assumption that does not hold in rare cases (same for `ssize_t`) |
| @overload |
| def __new__(cls, dtype: _UIntPCodes | type[ct.c_void_p] | type[ct.c_size_t], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uintp]: ... |
| @overload |
| def __new__(cls, dtype: _UIntCodes | type[ct.c_ulong], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uint]: ... |
| @overload |
| def __new__(cls, dtype: _ULongLongCodes | type[ct.c_ulonglong], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[ulonglong]: ... |
| |
| # `signedinteger` string-based representations and ctypes |
| @overload |
| def __new__(cls, dtype: _Int8Codes | type[ct.c_int8], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[int8]: ... |
| @overload |
| def __new__(cls, dtype: _Int16Codes | type[ct.c_int16], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[int16]: ... |
| @overload |
| def __new__(cls, dtype: _Int32Codes | type[ct.c_int32], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[int32]: ... |
| @overload |
| def __new__(cls, dtype: _Int64Codes | type[ct.c_int64], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[int64]: ... |
| @overload |
| def __new__(cls, dtype: _ByteCodes | type[ct.c_byte], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[byte]: ... |
| @overload |
| def __new__(cls, dtype: _ShortCodes | type[ct.c_short], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[short]: ... |
| @overload |
| def __new__(cls, dtype: _IntCCodes | type[ct.c_int], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[intc]: ... |
| @overload |
| def __new__(cls, dtype: _IntPCodes | type[ct.c_ssize_t], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[intp]: ... |
| @overload |
| def __new__(cls, dtype: _IntCodes | type[ct.c_long], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[int_]: ... |
| @overload |
| def __new__(cls, dtype: _LongLongCodes | type[ct.c_longlong], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[longlong]: ... |
| |
| # `floating` string-based representations and ctypes |
| @overload |
| def __new__(cls, dtype: _Float16Codes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[float16]: ... |
| @overload |
| def __new__(cls, dtype: _Float32Codes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[float32]: ... |
| @overload |
| def __new__(cls, dtype: _Float64Codes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[float64]: ... |
| @overload |
| def __new__(cls, dtype: _HalfCodes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[half]: ... |
| @overload |
| def __new__(cls, dtype: _SingleCodes | type[ct.c_float], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[single]: ... |
| @overload |
| def __new__(cls, dtype: _DoubleCodes | type[ct.c_double], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[double]: ... |
| @overload |
| def __new__(cls, dtype: _LongDoubleCodes | type[ct.c_longdouble], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[longdouble]: ... |
| |
| # `complexfloating` string-based representations |
| @overload |
| def __new__(cls, dtype: _Complex64Codes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[complex64]: ... |
| @overload |
| def __new__(cls, dtype: _Complex128Codes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[complex128]: ... |
| @overload |
| def __new__(cls, dtype: _CSingleCodes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[csingle]: ... |
| @overload |
| def __new__(cls, dtype: _CDoubleCodes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[cdouble]: ... |
| @overload |
| def __new__(cls, dtype: _CLongDoubleCodes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[clongdouble]: ... |
| |
| # Miscellaneous string-based representations and ctypes |
| @overload |
| def __new__(cls, dtype: _BoolCodes | type[ct.c_bool], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[bool_]: ... |
| @overload |
| def __new__(cls, dtype: _TD64Codes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[timedelta64]: ... |
| @overload |
| def __new__(cls, dtype: _DT64Codes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[datetime64]: ... |
| @overload |
| def __new__(cls, dtype: _StrCodes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[str_]: ... |
| @overload |
| def __new__(cls, dtype: _BytesCodes | type[ct.c_char], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[bytes_]: ... |
| @overload |
| def __new__(cls, dtype: _VoidCodes, align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[void]: ... |
| @overload |
| def __new__(cls, dtype: _ObjectCodes | type[ct.py_object[Any]], align: bool = ..., copy: bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[object_]: ... |
| |
| # dtype of a dtype is the same dtype |
| @overload |
| def __new__( |
| cls, |
| dtype: dtype[_DTypeScalar_co], |
| align: bool = ..., |
| copy: bool = ..., |
| metadata: dict[builtins.str, Any] = ..., |
| ) -> dtype[_DTypeScalar_co]: ... |
| @overload |
| def __new__( |
| cls, |
| dtype: _SupportsDType[dtype[_DTypeScalar_co]], |
| align: bool = ..., |
| copy: bool = ..., |
| metadata: dict[builtins.str, Any] = ..., |
| ) -> dtype[_DTypeScalar_co]: ... |
| # Handle strings that can't be expressed as literals; i.e. s1, s2, ... |
| @overload |
| def __new__( |
| cls, |
| dtype: builtins.str, |
| align: bool = ..., |
| copy: bool = ..., |
| metadata: dict[builtins.str, Any] = ..., |
| ) -> dtype[Any]: ... |
| # Catchall overload for void-likes |
| @overload |
| def __new__( |
| cls, |
| dtype: _VoidDTypeLike, |
| align: bool = ..., |
| copy: bool = ..., |
| metadata: dict[builtins.str, Any] = ..., |
| ) -> dtype[void]: ... |
| # Catchall overload for object-likes |
| @overload |
| def __new__( |
| cls, |
| dtype: type[object], |
| align: bool = ..., |
| copy: bool = ..., |
| metadata: dict[builtins.str, Any] = ..., |
| ) -> dtype[object_]: ... |
| |
| def __class_getitem__(self, item: Any) -> GenericAlias: ... |
| |
| @overload |
| def __getitem__(self: dtype[void], key: list[builtins.str]) -> dtype[void]: ... |
| @overload |
| def __getitem__(self: dtype[void], key: builtins.str | SupportsIndex) -> dtype[Any]: ... |
| |
| # NOTE: In the future 1-based multiplications will also yield `flexible` dtypes |
| @overload |
| def __mul__(self: _DType, value: L[1]) -> _DType: ... |
| @overload |
| def __mul__(self: _FlexDType, value: SupportsIndex) -> _FlexDType: ... |
| @overload |
| def __mul__(self, value: SupportsIndex) -> dtype[void]: ... |
| |
| # NOTE: `__rmul__` seems to be broken when used in combination with |
| # literals as of mypy 0.902. Set the return-type to `dtype[Any]` for |
| # now for non-flexible dtypes. |
| @overload |
| def __rmul__(self: _FlexDType, value: SupportsIndex) -> _FlexDType: ... |
| @overload |
| def __rmul__(self, value: SupportsIndex) -> dtype[Any]: ... |
| |
| def __gt__(self, other: DTypeLike) -> bool: ... |
| def __ge__(self, other: DTypeLike) -> bool: ... |
| def __lt__(self, other: DTypeLike) -> bool: ... |
| def __le__(self, other: DTypeLike) -> bool: ... |
| |
| # Explicitly defined `__eq__` and `__ne__` to get around mypy's |
| # `strict_equality` option; even though their signatures are |
| # identical to their `object`-based counterpart |
| def __eq__(self, other: Any) -> bool: ... |
| def __ne__(self, other: Any) -> bool: ... |
| |
| @property |
| def alignment(self) -> int: ... |
| @property |
| def base(self) -> dtype[Any]: ... |
| @property |
| def byteorder(self) -> builtins.str: ... |
| @property |
| def char(self) -> builtins.str: ... |
| @property |
| def descr(self) -> list[tuple[builtins.str, builtins.str] | tuple[builtins.str, builtins.str, _Shape]]: ... |
| @property |
| def fields( |
| self, |
| ) -> None | MappingProxyType[builtins.str, tuple[dtype[Any], int] | tuple[dtype[Any], int, Any]]: ... |
| @property |
| def flags(self) -> int: ... |
| @property |
| def hasobject(self) -> bool: ... |
| @property |
| def isbuiltin(self) -> int: ... |
| @property |
| def isnative(self) -> bool: ... |
| @property |
| def isalignedstruct(self) -> bool: ... |
| @property |
| def itemsize(self) -> int: ... |
| @property |
| def kind(self) -> builtins.str: ... |
| @property |
| def metadata(self) -> None | MappingProxyType[builtins.str, Any]: ... |
| @property |
| def name(self) -> builtins.str: ... |
| @property |
| def num(self) -> int: ... |
| @property |
| def shape(self) -> _Shape: ... |
| @property |
| def ndim(self) -> int: ... |
| @property |
| def subdtype(self) -> None | tuple[dtype[Any], _Shape]: ... |
| def newbyteorder(self: _DType, __new_order: _ByteOrder = ...) -> _DType: ... |
| @property |
| def str(self) -> builtins.str: ... |
| @property |
| def type(self) -> type[_DTypeScalar_co]: ... |
| |
| _ArrayLikeInt = Union[ |
| int, |
| integer[Any], |
| Sequence[Union[int, integer[Any]]], |
| Sequence[Sequence[Any]], # TODO: wait for support for recursive types |
| ndarray[Any, Any] |
| ] |
| |
| _FlatIterSelf = TypeVar("_FlatIterSelf", bound=flatiter[Any]) |
| |
| @final |
| class flatiter(Generic[_NdArraySubClass]): |
| __hash__: ClassVar[None] |
| @property |
| def base(self) -> _NdArraySubClass: ... |
| @property |
| def coords(self) -> _Shape: ... |
| @property |
| def index(self) -> int: ... |
| def copy(self) -> _NdArraySubClass: ... |
| def __iter__(self: _FlatIterSelf) -> _FlatIterSelf: ... |
| def __next__(self: flatiter[ndarray[Any, dtype[_ScalarType]]]) -> _ScalarType: ... |
| def __len__(self) -> int: ... |
| @overload |
| def __getitem__( |
| self: flatiter[ndarray[Any, dtype[_ScalarType]]], |
| key: int | integer[Any] | tuple[int | integer[Any]], |
| ) -> _ScalarType: ... |
| @overload |
| def __getitem__( |
| self, |
| key: _ArrayLikeInt | slice | ellipsis | tuple[_ArrayLikeInt | slice | ellipsis], |
| ) -> _NdArraySubClass: ... |
| # TODO: `__setitem__` operates via `unsafe` casting rules, and can |
| # thus accept any type accepted by the relevant underlying `np.generic` |
| # constructor. |
| # This means that `value` must in reality be a supertype of `npt.ArrayLike`. |
| def __setitem__( |
| self, |
| key: _ArrayLikeInt | slice | ellipsis | tuple[_ArrayLikeInt | slice | ellipsis], |
| value: Any, |
| ) -> None: ... |
| @overload |
| def __array__(self: flatiter[ndarray[Any, _DType]], dtype: None = ..., /) -> ndarray[Any, _DType]: ... |
| @overload |
| def __array__(self, dtype: _DType, /) -> ndarray[Any, _DType]: ... |
| |
| _OrderKACF = L[None, "K", "A", "C", "F"] |
| _OrderACF = L[None, "A", "C", "F"] |
| _OrderCF = L[None, "C", "F"] |
| |
| _ModeKind = L["raise", "wrap", "clip"] |
| _PartitionKind = L["introselect"] |
| _SortKind = L["quicksort", "mergesort", "heapsort", "stable"] |
| _SortSide = L["left", "right"] |
| |
| _ArraySelf = TypeVar("_ArraySelf", bound=_ArrayOrScalarCommon) |
| |
| class _ArrayOrScalarCommon: |
| @property |
| def T(self: _ArraySelf) -> _ArraySelf: ... |
| @property |
| def data(self) -> memoryview: ... |
| @property |
| def flags(self) -> flagsobj: ... |
| @property |
| def itemsize(self) -> int: ... |
| @property |
| def nbytes(self) -> int: ... |
| def __bool__(self) -> bool: ... |
| def __bytes__(self) -> bytes: ... |
| def __str__(self) -> str: ... |
| def __repr__(self) -> str: ... |
| def __copy__(self: _ArraySelf) -> _ArraySelf: ... |
| def __deepcopy__(self: _ArraySelf, memo: None | dict[int, Any], /) -> _ArraySelf: ... |
| |
| # TODO: How to deal with the non-commutative nature of `==` and `!=`? |
| # xref numpy/numpy#17368 |
| def __eq__(self, other: Any) -> Any: ... |
| def __ne__(self, other: Any) -> Any: ... |
| def copy(self: _ArraySelf, order: _OrderKACF = ...) -> _ArraySelf: ... |
| def dump(self, file: str | bytes | os.PathLike[str] | os.PathLike[bytes] | _SupportsWrite[bytes]) -> None: ... |
| def dumps(self) -> bytes: ... |
| def tobytes(self, order: _OrderKACF = ...) -> bytes: ... |
| # NOTE: `tostring()` is deprecated and therefore excluded |
| # def tostring(self, order=...): ... |
| def tofile( |
| self, |
| fid: str | bytes | os.PathLike[str] | os.PathLike[bytes] | _IOProtocol, |
| sep: str = ..., |
| format: str = ..., |
| ) -> None: ... |
| # generics and 0d arrays return builtin scalars |
| def tolist(self) -> Any: ... |
| |
| @property |
| def __array_interface__(self) -> dict[str, Any]: ... |
| @property |
| def __array_priority__(self) -> float: ... |
| @property |
| def __array_struct__(self) -> Any: ... # builtins.PyCapsule |
| def __setstate__(self, state: tuple[ |
| SupportsIndex, # version |
| _ShapeLike, # Shape |
| _DType_co, # DType |
| bool, # F-continuous |
| bytes | list[Any], # Data |
| ], /) -> None: ... |
| # a `bool_` is returned when `keepdims=True` and `self` is a 0d array |
| |
| @overload |
| def all( |
| self, |
| axis: None = ..., |
| out: None = ..., |
| keepdims: L[False] = ..., |
| *, |
| where: _ArrayLikeBool_co = ..., |
| ) -> bool_: ... |
| @overload |
| def all( |
| self, |
| axis: None | _ShapeLike = ..., |
| out: None = ..., |
| keepdims: bool = ..., |
| *, |
| where: _ArrayLikeBool_co = ..., |
| ) -> Any: ... |
| @overload |
| def all( |
| self, |
| axis: None | _ShapeLike = ..., |
| out: _NdArraySubClass = ..., |
| keepdims: bool = ..., |
| *, |
| where: _ArrayLikeBool_co = ..., |
| ) -> _NdArraySubClass: ... |
| |
| @overload |
| def any( |
| self, |
| axis: None = ..., |
| out: None = ..., |
| keepdims: L[False] = ..., |
| *, |
| where: _ArrayLikeBool_co = ..., |
| ) -> bool_: ... |
| @overload |
| def any( |
| self, |
| axis: None | _ShapeLike = ..., |
| out: None = ..., |
| keepdims: bool = ..., |
| *, |
| where: _ArrayLikeBool_co = ..., |
| ) -> Any: ... |
| @overload |
| def any( |
| self, |
| axis: None | _ShapeLike = ..., |
| out: _NdArraySubClass = ..., |
| keepdims: bool = ..., |
| *, |
| where: _ArrayLikeBool_co = ..., |
| ) -> _NdArraySubClass: ... |
| |
| @overload |
| def argmax( |
| self, |
| axis: None = ..., |
| out: None = ..., |
| *, |
| keepdims: L[False] = ..., |
| ) -> intp: ... |
| @overload |
| def argmax( |
| self, |
| axis: SupportsIndex = ..., |
| out: None = ..., |
| *, |
| keepdims: bool = ..., |
| ) -> Any: ... |
| @overload |
| def argmax( |
| self, |
| axis: None | SupportsIndex = ..., |
| out: _NdArraySubClass = ..., |
| *, |
| keepdims: bool = ..., |
| ) -> _NdArraySubClass: ... |
| |
| @overload |
| def argmin( |
| self, |
| axis: None = ..., |
| out: None = ..., |
| *, |
| keepdims: L[False] = ..., |
| ) -> intp: ... |
| @overload |
| def argmin( |
| self, |
| axis: SupportsIndex = ..., |
| out: None = ..., |
| *, |
| keepdims: bool = ..., |
| ) -> Any: ... |
| @overload |
| def argmin( |
| self, |
| axis: None | SupportsIndex = ..., |
| out: _NdArraySubClass = ..., |
| *, |
| keepdims: bool = ..., |
| ) -> _NdArraySubClass: ... |
| |
| def argsort( |
| self, |
| axis: None | SupportsIndex = ..., |
| kind: None | _SortKind = ..., |
| order: None | str | Sequence[str] = ..., |
| ) -> ndarray[Any, Any]: ... |
| |
| @overload |
| def choose( |
| self, |
| choices: ArrayLike, |
| out: None = ..., |
| mode: _ModeKind = ..., |
| ) -> ndarray[Any, Any]: ... |
| @overload |
| def choose( |
| self, |
| choices: ArrayLike, |
| out: _NdArraySubClass = ..., |
| mode: _ModeKind = ..., |
| ) -> _NdArraySubClass: ... |
| |
| @overload |
| def clip( |
| self, |
| min: ArrayLike = ..., |
| max: None | ArrayLike = ..., |
| out: None = ..., |
| **kwargs: Any, |
| ) -> ndarray[Any, Any]: ... |
| @overload |
| def clip( |
| self, |
| min: None = ..., |
| max: ArrayLike = ..., |
| out: None = ..., |
| **kwargs: Any, |
| ) -> ndarray[Any, Any]: ... |
| @overload |
| def clip( |
| self, |
| min: ArrayLike = ..., |
| max: None | ArrayLike = ..., |
| out: _NdArraySubClass = ..., |
| **kwargs: Any, |
| ) -> _NdArraySubClass: ... |
| @overload |
| def clip( |
| self, |
| min: None = ..., |
| max: ArrayLike = ..., |
| out: _NdArraySubClass = ..., |
| **kwargs: Any, |
| ) -> _NdArraySubClass: ... |
| |
| @overload |
| def compress( |
| self, |
| a: ArrayLike, |
| axis: None | SupportsIndex = ..., |
| out: None = ..., |
| ) -> ndarray[Any, Any]: ... |
| @overload |
| def compress( |
| self, |
| a: ArrayLike, |
| axis: None | SupportsIndex = ..., |
| out: _NdArraySubClass = ..., |
| ) -> _NdArraySubClass: ... |
| |
| def conj(self: _ArraySelf) -> _ArraySelf: ... |
| |
| def conjugate(self: _ArraySelf) -> _ArraySelf: ... |
| |
| @overload |
| def cumprod( |
| self, |
| axis: None | SupportsIndex = ..., |
| dtype: DTypeLike = ..., |
| out: None = ..., |
| ) -> ndarray[Any, Any]: ... |
| @overload |
| def cumprod( |
| self, |
| axis: None | SupportsIndex = ..., |
| dtype: DTypeLike = ..., |
| out: _NdArraySubClass = ..., |
| ) -> _NdArraySubClass: ... |
| |
| @overload |
| def cumsum( |
| self, |
| axis: None | SupportsIndex = ..., |
| dtype: DTypeLike = ..., |
| out: None = ..., |
| ) -> ndarray[Any, Any]: ... |
| @overload |
| def cumsum( |
| self, |
| axis: None | SupportsIndex = ..., |
| dtype: DTypeLike = ..., |
| out: _NdArraySubClass = ..., |
| ) -> _NdArraySubClass: ... |
| |
| @overload |
| def max( |
| self, |
| axis: None | _ShapeLike = ..., |
| out: None = ..., |
| keepdims: bool = ..., |
| initial: _NumberLike_co = ..., |
| where: _ArrayLikeBool_co = ..., |
| ) -> Any: ... |
| @overload |
| def max( |
| self, |
| axis: None | _ShapeLike = ..., |
| out: _NdArraySubClass = ..., |
| keepdims: bool = ..., |
| initial: _NumberLike_co = ..., |
| where: _ArrayLikeBool_co = ..., |
| ) -> _NdArraySubClass: ... |
| |
| @overload |
| def mean( |
| self, |
| axis: None | _ShapeLike = ..., |
| dtype: DTypeLike = ..., |
| out: None = ..., |
| keepdims: bool = ..., |
| *, |
| where: _ArrayLikeBool_co = ..., |
| ) -> Any: ... |
| @overload |
| def mean( |
| self, |
| axis: None | _ShapeLike = ..., |
| dtype: DTypeLike = ..., |
| out: _NdArraySubClass = ..., |
| keepdims: bool = ..., |
| *, |
| where: _ArrayLikeBool_co = ..., |
| ) -> _NdArraySubClass: ... |
| |
| @overload |
| def min( |
| self, |
| axis: None | _ShapeLike = ..., |
| out: None = ..., |
| keepdims: bool = ..., |
| initial: _NumberLike_co = ..., |
| where: _ArrayLikeBool_co = ..., |
| ) -> Any: ... |
| @overload |
| def min( |
| self, |
| axis: None | _ShapeLike = ..., |
| out: _NdArraySubClass = ..., |
| keepdims: bool = ..., |
| initial: _NumberLike_co = ..., |
| where: _ArrayLikeBool_co = ..., |
| ) -> _NdArraySubClass: ... |
| |
| def newbyteorder( |
| self: _ArraySelf, |
| __new_order: _ByteOrder = ..., |
| ) -> _ArraySelf: ... |
| |
| @overload |
| def prod( |
| self, |
| axis: None | _ShapeLike = ..., |
| dtype: DTypeLike = ..., |
| out: None = ..., |
| keepdims: bool = ..., |
| initial: _NumberLike_co = ..., |
| where: _ArrayLikeBool_co = ..., |
| ) -> Any: ... |
| @overload |
| def prod( |
| self, |
| axis: None | _ShapeLike = ..., |
| dtype: DTypeLike = ..., |
| out: _NdArraySubClass = ..., |
| keepdims: bool = ..., |
| initial: _NumberLike_co = ..., |
| where: _ArrayLikeBool_co = ..., |
| ) -> _NdArraySubClass: ... |
| |
| @overload |
| def ptp( |
| self, |
| axis: None | _ShapeLike = ..., |
| out: None = ..., |
| keepdims: bool = ..., |
| ) -> Any: ... |
| @overload |
| def ptp( |
| self, |
| axis: None | _ShapeLike = ..., |
| out: _NdArraySubClass = ..., |
| keepdims: bool = ..., |
| ) -> _NdArraySubClass: ... |
| |
| @overload |
| def round( |
| self: _ArraySelf, |
| decimals: SupportsIndex = ..., |
| out: None = ..., |
| ) -> _ArraySelf: ... |
| @overload |
| def round( |
| self, |
| decimals: SupportsIndex = ..., |
| out: _NdArraySubClass = ..., |
| ) -> _NdArraySubClass: ... |
| |
| @overload |
| def std( |
| self, |
| axis: None | _ShapeLike = ..., |
| dtype: DTypeLike = ..., |
| out: None = ..., |
| ddof: float = ..., |
| keepdims: bool = ..., |
| *, |
| where: _ArrayLikeBool_co = ..., |
| ) -> Any: ... |
| @overload |
| def std( |
| self, |
| axis: None | _ShapeLike = ..., |
| dtype: DTypeLike = ..., |
| out: _NdArraySubClass = ..., |
| ddof: float = ..., |
| keepdims: bool = ..., |
| *, |
| where: _ArrayLikeBool_co = ..., |
| ) -> _NdArraySubClass: ... |
| |
| @overload |
| def sum( |
| self, |
| axis: None | _ShapeLike = ..., |
| dtype: DTypeLike = ..., |
| out: None = ..., |
| keepdims: bool = ..., |
| initial: _NumberLike_co = ..., |
| where: _ArrayLikeBool_co = ..., |
| ) -> Any: ... |
| @overload |
| def sum( |
| self, |
| axis: None | _ShapeLike = ..., |
| dtype: DTypeLike = ..., |
| out: _NdArraySubClass = ..., |
| keepdims: bool = ..., |
| initial: _NumberLike_co = ..., |
| where: _ArrayLikeBool_co = ..., |
| ) -> _NdArraySubClass: ... |
| |
| @overload |
| def var( |
| self, |
| axis: None | _ShapeLike = ..., |
| dtype: DTypeLike = ..., |
| out: None = ..., |
| ddof: float = ..., |
| keepdims: bool = ..., |
| *, |
| where: _ArrayLikeBool_co = ..., |
| ) -> Any: ... |
| @overload |
| def var( |
| self, |
| axis: None | _ShapeLike = ..., |
| dtype: DTypeLike = ..., |
| out: _NdArraySubClass = ..., |
| ddof: float = ..., |
| keepdims: bool = ..., |
| *, |
| where: _ArrayLikeBool_co = ..., |
| ) -> _NdArraySubClass: ... |
| |
| _DType = TypeVar("_DType", bound=dtype[Any]) |
| _DType_co = TypeVar("_DType_co", covariant=True, bound=dtype[Any]) |
| _FlexDType = TypeVar("_FlexDType", bound=dtype[flexible]) |
| |
| # TODO: Set the `bound` to something more suitable once we |
| # have proper shape support |
| _ShapeType = TypeVar("_ShapeType", bound=Any) |
| _ShapeType2 = TypeVar("_ShapeType2", bound=Any) |
| _NumberType = TypeVar("_NumberType", bound=number[Any]) |
| |
| # There is currently no exhaustive way to type the buffer protocol, |
| # as it is implemented exclusively in the C API (python/typing#593) |
| _SupportsBuffer = Union[ |
| bytes, |
| bytearray, |
| memoryview, |
| _array.array[Any], |
| mmap.mmap, |
| NDArray[Any], |
| generic, |
| ] |
| |
| _T = TypeVar("_T") |
| _T_co = TypeVar("_T_co", covariant=True) |
| _T_contra = TypeVar("_T_contra", contravariant=True) |
| _2Tuple = tuple[_T, _T] |
| _CastingKind = L["no", "equiv", "safe", "same_kind", "unsafe"] |
| |
| _ArrayUInt_co = NDArray[Union[bool_, unsignedinteger[Any]]] |
| _ArrayInt_co = NDArray[Union[bool_, integer[Any]]] |
| _ArrayFloat_co = NDArray[Union[bool_, integer[Any], floating[Any]]] |
| _ArrayComplex_co = NDArray[Union[bool_, integer[Any], floating[Any], complexfloating[Any, Any]]] |
| _ArrayNumber_co = NDArray[Union[bool_, number[Any]]] |
| _ArrayTD64_co = NDArray[Union[bool_, integer[Any], timedelta64]] |
| |
| # Introduce an alias for `dtype` to avoid naming conflicts. |
| _dtype = dtype |
| |
| # `builtins.PyCapsule` unfortunately lacks annotations as of the moment; |
| # use `Any` as a stopgap measure |
| _PyCapsule = Any |
| |
| class _SupportsItem(Protocol[_T_co]): |
| def item(self, args: Any, /) -> _T_co: ... |
| |
| class _SupportsReal(Protocol[_T_co]): |
| @property |
| def real(self) -> _T_co: ... |
| |
| class _SupportsImag(Protocol[_T_co]): |
| @property |
| def imag(self) -> _T_co: ... |
| |
| class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]): |
| __hash__: ClassVar[None] |
| @property |
| def base(self) -> None | ndarray[Any, Any]: ... |
| @property |
| def ndim(self) -> int: ... |
| @property |
| def size(self) -> int: ... |
| @property |
| def real( |
| self: ndarray[_ShapeType, dtype[_SupportsReal[_ScalarType]]], # type: ignore[type-var] |
| ) -> ndarray[_ShapeType, _dtype[_ScalarType]]: ... |
| @real.setter |
| def real(self, value: ArrayLike) -> None: ... |
| @property |
| def imag( |
| self: ndarray[_ShapeType, dtype[_SupportsImag[_ScalarType]]], # type: ignore[type-var] |
| ) -> ndarray[_ShapeType, _dtype[_ScalarType]]: ... |
| @imag.setter |
| def imag(self, value: ArrayLike) -> None: ... |
| def __new__( |
| cls: type[_ArraySelf], |
| shape: _ShapeLike, |
| dtype: DTypeLike = ..., |
| buffer: None | _SupportsBuffer = ..., |
| offset: SupportsIndex = ..., |
| strides: None | _ShapeLike = ..., |
| order: _OrderKACF = ..., |
| ) -> _ArraySelf: ... |
| |
| def __class_getitem__(self, item: Any) -> GenericAlias: ... |
| |
| @overload |
| def __array__(self, dtype: None = ..., /) -> ndarray[Any, _DType_co]: ... |
| @overload |
| def __array__(self, dtype: _DType, /) -> ndarray[Any, _DType]: ... |
| |
| def __array_ufunc__( |
| self, |
| ufunc: ufunc, |
| method: L["__call__", "reduce", "reduceat", "accumulate", "outer", "inner"], |
| *inputs: Any, |
| **kwargs: Any, |
| ) -> Any: ... |
| |
| def __array_function__( |
| self, |
| func: Callable[..., Any], |
| types: Iterable[type], |
| args: Iterable[Any], |
| kwargs: Mapping[str, Any], |
| ) -> Any: ... |
| |
| # NOTE: In practice any object is accepted by `obj`, but as `__array_finalize__` |
| # is a pseudo-abstract method the type has been narrowed down in order to |
| # grant subclasses a bit more flexibility |
| def __array_finalize__(self, obj: None | NDArray[Any], /) -> None: ... |
| |
| def __array_wrap__( |
| self, |
| array: ndarray[_ShapeType2, _DType], |
| context: None | tuple[ufunc, tuple[Any, ...], int] = ..., |
| /, |
| ) -> ndarray[_ShapeType2, _DType]: ... |
| |
| def __array_prepare__( |
| self, |
| array: ndarray[_ShapeType2, _DType], |
| context: None | tuple[ufunc, tuple[Any, ...], int] = ..., |
| /, |
| ) -> ndarray[_ShapeType2, _DType]: ... |
| |
| @overload |
| def __getitem__(self, key: ( |
| NDArray[integer[Any]] |
| | NDArray[bool_] |
| | tuple[NDArray[integer[Any]] | NDArray[bool_], ...] |
| )) -> ndarray[Any, _DType_co]: ... |
| @overload |
| def __getitem__(self, key: SupportsIndex | tuple[SupportsIndex, ...]) -> Any: ... |
| @overload |
| def __getitem__(self, key: ( |
| None |
| | slice |
| | ellipsis |
| | SupportsIndex |
| | _ArrayLikeInt_co |
| | tuple[None | slice | ellipsis | _ArrayLikeInt_co | SupportsIndex, ...] |
| )) -> ndarray[Any, _DType_co]: ... |
| @overload |
| def __getitem__(self: NDArray[void], key: str) -> NDArray[Any]: ... |
| @overload |
| def __getitem__(self: NDArray[void], key: list[str]) -> ndarray[_ShapeType, _dtype[void]]: ... |
| |
| @property |
| def ctypes(self) -> _ctypes[int]: ... |
| @property |
| def shape(self) -> _Shape: ... |
| @shape.setter |
| def shape(self, value: _ShapeLike) -> None: ... |
| @property |
| def strides(self) -> _Shape: ... |
| @strides.setter |
| def strides(self, value: _ShapeLike) -> None: ... |
| def byteswap(self: _ArraySelf, inplace: bool = ...) -> _ArraySelf: ... |
| def fill(self, value: Any) -> None: ... |
| @property |
| def flat(self: _NdArraySubClass) -> flatiter[_NdArraySubClass]: ... |
| |
| # Use the same output type as that of the underlying `generic` |
| @overload |
| def item( |
| self: ndarray[Any, _dtype[_SupportsItem[_T]]], # type: ignore[type-var] |
| *args: SupportsIndex, |
| ) -> _T: ... |
| @overload |
| def item( |
| self: ndarray[Any, _dtype[_SupportsItem[_T]]], # type: ignore[type-var] |
| args: tuple[SupportsIndex, ...], |
| /, |
| ) -> _T: ... |
| |
| @overload |
| def itemset(self, value: Any, /) -> None: ... |
| @overload |
| def itemset(self, item: _ShapeLike, value: Any, /) -> None: ... |
| |
| @overload |
| def resize(self, new_shape: _ShapeLike, /, *, refcheck: bool = ...) -> None: ... |
| @overload |
| def resize(self, *new_shape: SupportsIndex, refcheck: bool = ...) -> None: ... |
| |
| def setflags( |
| self, write: bool = ..., align: bool = ..., uic: bool = ... |
| ) -> None: ... |
| |
| def squeeze( |
| self, |
| axis: None | SupportsIndex | tuple[SupportsIndex, ...] = ..., |
| ) -> ndarray[Any, _DType_co]: ... |
| |
| def swapaxes( |
| self, |
| axis1: SupportsIndex, |
| axis2: SupportsIndex, |
| ) -> ndarray[Any, _DType_co]: ... |
| |
| @overload |
| def transpose(self: _ArraySelf, axes: None | _ShapeLike, /) -> _ArraySelf: ... |
| @overload |
| def transpose(self: _ArraySelf, *axes: SupportsIndex) -> _ArraySelf: ... |
| |
| def argpartition( |
| self, |
| kth: _ArrayLikeInt_co, |
| axis: None | SupportsIndex = ..., |
| kind: _PartitionKind = ..., |
| order: None | str | Sequence[str] = ..., |
| ) -> ndarray[Any, _dtype[intp]]: ... |
| |
| def diagonal( |
| self, |
| offset: SupportsIndex = ..., |
| axis1: SupportsIndex = ..., |
| axis2: SupportsIndex = ..., |
| ) -> ndarray[Any, _DType_co]: ... |
| |
| # 1D + 1D returns a scalar; |
| # all other with at least 1 non-0D array return an ndarray. |
| @overload |
| def dot(self, b: _ScalarLike_co, out: None = ...) -> ndarray[Any, Any]: ... |
| @overload |
| def dot(self, b: ArrayLike, out: None = ...) -> Any: ... # type: ignore[misc] |
| @overload |
| def dot(self, b: ArrayLike, out: _NdArraySubClass) -> _NdArraySubClass: ... |
| |
| # `nonzero()` is deprecated for 0d arrays/generics |
| def nonzero(self) -> tuple[ndarray[Any, _dtype[intp]], ...]: ... |
| |
| def partition( |
| self, |
| kth: _ArrayLikeInt_co, |
| axis: SupportsIndex = ..., |
| kind: _PartitionKind = ..., |
| order: None | str | Sequence[str] = ..., |
| ) -> None: ... |
| |
| # `put` is technically available to `generic`, |
| # but is pointless as `generic`s are immutable |
| def put( |
| self, |
| ind: _ArrayLikeInt_co, |
| v: ArrayLike, |
| mode: _ModeKind = ..., |
| ) -> None: ... |
| |
| @overload |
| def searchsorted( # type: ignore[misc] |
| self, # >= 1D array |
| v: _ScalarLike_co, # 0D array-like |
| side: _SortSide = ..., |
| sorter: None | _ArrayLikeInt_co = ..., |
| ) -> intp: ... |
| @overload |
| def searchsorted( |
| self, # >= 1D array |
| v: ArrayLike, |
| side: _SortSide = ..., |
| sorter: None | _ArrayLikeInt_co = ..., |
| ) -> ndarray[Any, _dtype[intp]]: ... |
| |
| def setfield( |
| self, |
| val: ArrayLike, |
| dtype: DTypeLike, |
| offset: SupportsIndex = ..., |
| ) -> None: ... |
| |
| def sort( |
| self, |
| axis: SupportsIndex = ..., |
| kind: None | _SortKind = ..., |
| order: None | str | Sequence[str] = ..., |
| ) -> None: ... |
| |
| @overload |
| def trace( |
| self, # >= 2D array |
| offset: SupportsIndex = ..., |
| axis1: SupportsIndex = ..., |
| axis2: SupportsIndex = ..., |
| dtype: DTypeLike = ..., |
| out: None = ..., |
| ) -> Any: ... |
| @overload |
| def trace( |
| self, # >= 2D array |
| offset: SupportsIndex = ..., |
| axis1: SupportsIndex = ..., |
| axis2: SupportsIndex = ..., |
| dtype: DTypeLike = ..., |
| out: _NdArraySubClass = ..., |
| ) -> _NdArraySubClass: ... |
| |
| @overload |
| def take( # type: ignore[misc] |
| self: ndarray[Any, _dtype[_ScalarType]], |
| indices: _IntLike_co, |
| axis: None | SupportsIndex = ..., |
| out: None = ..., |
| mode: _ModeKind = ..., |
| ) -> _ScalarType: ... |
| @overload |
| def take( # type: ignore[misc] |
| self, |
| indices: _ArrayLikeInt_co, |
| axis: None | SupportsIndex = ..., |
| out: None = ..., |
| mode: _ModeKind = ..., |
| ) -> ndarray[Any, _DType_co]: ... |
| @overload |
| def take( |
| self, |
| indices: _ArrayLikeInt_co, |
| axis: None | SupportsIndex = ..., |
| out: _NdArraySubClass = ..., |
| mode: _ModeKind = ..., |
| ) -> _NdArraySubClass: ... |
| |
| def repeat( |
| self, |
| repeats: _ArrayLikeInt_co, |
| axis: None | SupportsIndex = ..., |
| ) -> ndarray[Any, _DType_co]: ... |
| |
| def flatten( |
| self, |
| order: _OrderKACF = ..., |
| ) -> ndarray[Any, _DType_co]: ... |
| |
| def ravel( |
| self, |
| order: _OrderKACF = ..., |
| ) -> ndarray[Any, _DType_co]: ... |
| |
| @overload |
| def reshape( |
| self, shape: _ShapeLike, /, *, order: _OrderACF = ... |
| ) -> ndarray[Any, _DType_co]: ... |
| @overload |
| def reshape( |
| self, *shape: SupportsIndex, order: _OrderACF = ... |
| ) -> ndarray[Any, _DType_co]: ... |
| |
| @overload |
| def astype( |
| self, |
| dtype: _DTypeLike[_ScalarType], |
| order: _OrderKACF = ..., |
| casting: _CastingKind = ..., |
| subok: bool = ..., |
| copy: bool | _CopyMode = ..., |
| ) -> NDArray[_ScalarType]: ... |
| @overload |
| def astype( |
| self, |
| dtype: DTypeLike, |
| order: _OrderKACF = ..., |
| casting: _CastingKind = ..., |
| subok: bool = ..., |
| copy: bool | _CopyMode = ..., |
| ) -> NDArray[Any]: ... |
| |
| @overload |
| def view(self: _ArraySelf) -> _ArraySelf: ... |
| @overload |
| def view(self, type: type[_NdArraySubClass]) -> _NdArraySubClass: ... |
| @overload |
| def view(self, dtype: _DTypeLike[_ScalarType]) -> NDArray[_ScalarType]: ... |
| @overload |
| def view(self, dtype: DTypeLike) -> NDArray[Any]: ... |
| @overload |
| def view( |
| self, |
| dtype: DTypeLike, |
| type: type[_NdArraySubClass], |
| ) -> _NdArraySubClass: ... |
| |
| @overload |
| def getfield( |
| self, |
| dtype: _DTypeLike[_ScalarType], |
| offset: SupportsIndex = ... |
| ) -> NDArray[_ScalarType]: ... |
| @overload |
| def getfield( |
| self, |
| dtype: DTypeLike, |
| offset: SupportsIndex = ... |
| ) -> NDArray[Any]: ... |
| |
| # Dispatch to the underlying `generic` via protocols |
| def __int__( |
| self: ndarray[Any, _dtype[SupportsInt]], # type: ignore[type-var] |
| ) -> int: ... |
| |
| def __float__( |
| self: ndarray[Any, _dtype[SupportsFloat]], # type: ignore[type-var] |
| ) -> float: ... |
| |
| def __complex__( |
| self: ndarray[Any, _dtype[SupportsComplex]], # type: ignore[type-var] |
| ) -> complex: ... |
| |
| def __index__( |
| self: ndarray[Any, _dtype[SupportsIndex]], # type: ignore[type-var] |
| ) -> int: ... |
| |
| def __len__(self) -> int: ... |
| def __setitem__(self, key, value): ... |
| def __iter__(self) -> Any: ... |
| def __contains__(self, key) -> bool: ... |
| |
| # The last overload is for catching recursive objects whose |
| # nesting is too deep. |
| # The first overload is for catching `bytes` (as they are a subtype of |
| # `Sequence[int]`) and `str`. As `str` is a recursive sequence of |
| # strings, it will pass through the final overload otherwise |
| |
| @overload |
| def __lt__(self: _ArrayNumber_co, other: _ArrayLikeNumber_co) -> NDArray[bool_]: ... |
| @overload |
| def __lt__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co) -> NDArray[bool_]: ... |
| @overload |
| def __lt__(self: NDArray[datetime64], other: _ArrayLikeDT64_co) -> NDArray[bool_]: ... |
| @overload |
| def __lt__(self: NDArray[object_], other: Any) -> NDArray[bool_]: ... |
| @overload |
| def __lt__(self: NDArray[Any], other: _ArrayLikeObject_co) -> NDArray[bool_]: ... |
| |
| @overload |
| def __le__(self: _ArrayNumber_co, other: _ArrayLikeNumber_co) -> NDArray[bool_]: ... |
| @overload |
| def __le__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co) -> NDArray[bool_]: ... |
| @overload |
| def __le__(self: NDArray[datetime64], other: _ArrayLikeDT64_co) -> NDArray[bool_]: ... |
| @overload |
| def __le__(self: NDArray[object_], other: Any) -> NDArray[bool_]: ... |
| @overload |
| def __le__(self: NDArray[Any], other: _ArrayLikeObject_co) -> NDArray[bool_]: ... |
| |
| @overload |
| def __gt__(self: _ArrayNumber_co, other: _ArrayLikeNumber_co) -> NDArray[bool_]: ... |
| @overload |
| def __gt__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co) -> NDArray[bool_]: ... |
| @overload |
| def __gt__(self: NDArray[datetime64], other: _ArrayLikeDT64_co) -> NDArray[bool_]: ... |
| @overload |
| def __gt__(self: NDArray[object_], other: Any) -> NDArray[bool_]: ... |
| @overload |
| def __gt__(self: NDArray[Any], other: _ArrayLikeObject_co) -> NDArray[bool_]: ... |
| |
| @overload |
| def __ge__(self: _ArrayNumber_co, other: _ArrayLikeNumber_co) -> NDArray[bool_]: ... |
| @overload |
| def __ge__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co) -> NDArray[bool_]: ... |
| @overload |
| def __ge__(self: NDArray[datetime64], other: _ArrayLikeDT64_co) -> NDArray[bool_]: ... |
| @overload |
| def __ge__(self: NDArray[object_], other: Any) -> NDArray[bool_]: ... |
| @overload |
| def __ge__(self: NDArray[Any], other: _ArrayLikeObject_co) -> NDArray[bool_]: ... |
| |
| # Unary ops |
| @overload |
| def __abs__(self: NDArray[bool_]) -> NDArray[bool_]: ... |
| @overload |
| def __abs__(self: NDArray[complexfloating[_NBit1, _NBit1]]) -> NDArray[floating[_NBit1]]: ... |
| @overload |
| def __abs__(self: NDArray[_NumberType]) -> NDArray[_NumberType]: ... |
| @overload |
| def __abs__(self: NDArray[timedelta64]) -> NDArray[timedelta64]: ... |
| @overload |
| def __abs__(self: NDArray[object_]) -> Any: ... |
| |
| @overload |
| def __invert__(self: NDArray[bool_]) -> NDArray[bool_]: ... |
| @overload |
| def __invert__(self: NDArray[_IntType]) -> NDArray[_IntType]: ... |
| @overload |
| def __invert__(self: NDArray[object_]) -> Any: ... |
| |
| @overload |
| def __pos__(self: NDArray[_NumberType]) -> NDArray[_NumberType]: ... |
| @overload |
| def __pos__(self: NDArray[timedelta64]) -> NDArray[timedelta64]: ... |
| @overload |
| def __pos__(self: NDArray[object_]) -> Any: ... |
| |
| @overload |
| def __neg__(self: NDArray[_NumberType]) -> NDArray[_NumberType]: ... |
| @overload |
| def __neg__(self: NDArray[timedelta64]) -> NDArray[timedelta64]: ... |
| @overload |
| def __neg__(self: NDArray[object_]) -> Any: ... |
| |
| # Binary ops |
| @overload |
| def __matmul__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] |
| @overload |
| def __matmul__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __matmul__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __matmul__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] |
| @overload |
| def __matmul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... |
| @overload |
| def __matmul__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... |
| @overload |
| def __matmul__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __matmul__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __rmatmul__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] |
| @overload |
| def __rmatmul__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __rmatmul__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __rmatmul__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] |
| @overload |
| def __rmatmul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... |
| @overload |
| def __rmatmul__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... |
| @overload |
| def __rmatmul__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __rmatmul__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __mod__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[int8]: ... # type: ignore[misc] |
| @overload |
| def __mod__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __mod__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __mod__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] |
| @overload |
| def __mod__(self: _ArrayTD64_co, other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]]) -> NDArray[timedelta64]: ... |
| @overload |
| def __mod__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __mod__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __rmod__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[int8]: ... # type: ignore[misc] |
| @overload |
| def __rmod__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __rmod__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __rmod__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] |
| @overload |
| def __rmod__(self: _ArrayTD64_co, other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]]) -> NDArray[timedelta64]: ... |
| @overload |
| def __rmod__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __rmod__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __divmod__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> _2Tuple[NDArray[int8]]: ... # type: ignore[misc] |
| @overload |
| def __divmod__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> _2Tuple[NDArray[unsignedinteger[Any]]]: ... # type: ignore[misc] |
| @overload |
| def __divmod__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> _2Tuple[NDArray[signedinteger[Any]]]: ... # type: ignore[misc] |
| @overload |
| def __divmod__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> _2Tuple[NDArray[floating[Any]]]: ... # type: ignore[misc] |
| @overload |
| def __divmod__(self: _ArrayTD64_co, other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]]) -> tuple[NDArray[int64], NDArray[timedelta64]]: ... |
| |
| @overload |
| def __rdivmod__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> _2Tuple[NDArray[int8]]: ... # type: ignore[misc] |
| @overload |
| def __rdivmod__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> _2Tuple[NDArray[unsignedinteger[Any]]]: ... # type: ignore[misc] |
| @overload |
| def __rdivmod__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> _2Tuple[NDArray[signedinteger[Any]]]: ... # type: ignore[misc] |
| @overload |
| def __rdivmod__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> _2Tuple[NDArray[floating[Any]]]: ... # type: ignore[misc] |
| @overload |
| def __rdivmod__(self: _ArrayTD64_co, other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]]) -> tuple[NDArray[int64], NDArray[timedelta64]]: ... |
| |
| @overload |
| def __add__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] |
| @overload |
| def __add__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __add__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __add__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] |
| @overload |
| def __add__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] |
| @overload |
| def __add__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... |
| @overload |
| def __add__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... # type: ignore[misc] |
| @overload |
| def __add__(self: _ArrayTD64_co, other: _ArrayLikeDT64_co) -> NDArray[datetime64]: ... |
| @overload |
| def __add__(self: NDArray[datetime64], other: _ArrayLikeTD64_co) -> NDArray[datetime64]: ... |
| @overload |
| def __add__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __add__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __radd__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] |
| @overload |
| def __radd__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __radd__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __radd__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] |
| @overload |
| def __radd__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] |
| @overload |
| def __radd__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... |
| @overload |
| def __radd__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... # type: ignore[misc] |
| @overload |
| def __radd__(self: _ArrayTD64_co, other: _ArrayLikeDT64_co) -> NDArray[datetime64]: ... |
| @overload |
| def __radd__(self: NDArray[datetime64], other: _ArrayLikeTD64_co) -> NDArray[datetime64]: ... |
| @overload |
| def __radd__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __radd__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __sub__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown) -> NDArray[Any]: ... |
| @overload |
| def __sub__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NoReturn: ... |
| @overload |
| def __sub__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __sub__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __sub__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] |
| @overload |
| def __sub__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] |
| @overload |
| def __sub__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... |
| @overload |
| def __sub__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... # type: ignore[misc] |
| @overload |
| def __sub__(self: NDArray[datetime64], other: _ArrayLikeTD64_co) -> NDArray[datetime64]: ... |
| @overload |
| def __sub__(self: NDArray[datetime64], other: _ArrayLikeDT64_co) -> NDArray[timedelta64]: ... |
| @overload |
| def __sub__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __sub__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __rsub__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown) -> NDArray[Any]: ... |
| @overload |
| def __rsub__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NoReturn: ... |
| @overload |
| def __rsub__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __rsub__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __rsub__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] |
| @overload |
| def __rsub__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] |
| @overload |
| def __rsub__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... |
| @overload |
| def __rsub__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... # type: ignore[misc] |
| @overload |
| def __rsub__(self: _ArrayTD64_co, other: _ArrayLikeDT64_co) -> NDArray[datetime64]: ... # type: ignore[misc] |
| @overload |
| def __rsub__(self: NDArray[datetime64], other: _ArrayLikeDT64_co) -> NDArray[timedelta64]: ... |
| @overload |
| def __rsub__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __rsub__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __mul__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] |
| @overload |
| def __mul__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __mul__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __mul__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] |
| @overload |
| def __mul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] |
| @overload |
| def __mul__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... |
| @overload |
| def __mul__(self: _ArrayTD64_co, other: _ArrayLikeFloat_co) -> NDArray[timedelta64]: ... |
| @overload |
| def __mul__(self: _ArrayFloat_co, other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... |
| @overload |
| def __mul__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __mul__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __rmul__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] |
| @overload |
| def __rmul__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __rmul__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __rmul__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] |
| @overload |
| def __rmul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] |
| @overload |
| def __rmul__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... |
| @overload |
| def __rmul__(self: _ArrayTD64_co, other: _ArrayLikeFloat_co) -> NDArray[timedelta64]: ... |
| @overload |
| def __rmul__(self: _ArrayFloat_co, other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... |
| @overload |
| def __rmul__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __rmul__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __floordiv__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[int8]: ... # type: ignore[misc] |
| @overload |
| def __floordiv__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __floordiv__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __floordiv__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] |
| @overload |
| def __floordiv__(self: NDArray[timedelta64], other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]]) -> NDArray[int64]: ... |
| @overload |
| def __floordiv__(self: NDArray[timedelta64], other: _ArrayLikeBool_co) -> NoReturn: ... |
| @overload |
| def __floordiv__(self: NDArray[timedelta64], other: _ArrayLikeFloat_co) -> NDArray[timedelta64]: ... |
| @overload |
| def __floordiv__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __floordiv__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __rfloordiv__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[int8]: ... # type: ignore[misc] |
| @overload |
| def __rfloordiv__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __rfloordiv__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __rfloordiv__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] |
| @overload |
| def __rfloordiv__(self: NDArray[timedelta64], other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]]) -> NDArray[int64]: ... |
| @overload |
| def __rfloordiv__(self: NDArray[bool_], other: _ArrayLikeTD64_co) -> NoReturn: ... |
| @overload |
| def __rfloordiv__(self: _ArrayFloat_co, other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... |
| @overload |
| def __rfloordiv__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __rfloordiv__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __pow__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[int8]: ... # type: ignore[misc] |
| @overload |
| def __pow__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __pow__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __pow__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] |
| @overload |
| def __pow__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... |
| @overload |
| def __pow__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... |
| @overload |
| def __pow__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __pow__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __rpow__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[int8]: ... # type: ignore[misc] |
| @overload |
| def __rpow__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __rpow__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __rpow__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] |
| @overload |
| def __rpow__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... |
| @overload |
| def __rpow__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... |
| @overload |
| def __rpow__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __rpow__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __truediv__(self: _ArrayInt_co, other: _ArrayInt_co) -> NDArray[float64]: ... # type: ignore[misc] |
| @overload |
| def __truediv__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] |
| @overload |
| def __truediv__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] |
| @overload |
| def __truediv__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... |
| @overload |
| def __truediv__(self: NDArray[timedelta64], other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]]) -> NDArray[float64]: ... |
| @overload |
| def __truediv__(self: NDArray[timedelta64], other: _ArrayLikeBool_co) -> NoReturn: ... |
| @overload |
| def __truediv__(self: NDArray[timedelta64], other: _ArrayLikeFloat_co) -> NDArray[timedelta64]: ... |
| @overload |
| def __truediv__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __truediv__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __rtruediv__(self: _ArrayInt_co, other: _ArrayInt_co) -> NDArray[float64]: ... # type: ignore[misc] |
| @overload |
| def __rtruediv__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ... # type: ignore[misc] |
| @overload |
| def __rtruediv__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] |
| @overload |
| def __rtruediv__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co) -> NDArray[number[Any]]: ... |
| @overload |
| def __rtruediv__(self: NDArray[timedelta64], other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]]) -> NDArray[float64]: ... |
| @overload |
| def __rtruediv__(self: NDArray[bool_], other: _ArrayLikeTD64_co) -> NoReturn: ... |
| @overload |
| def __rtruediv__(self: _ArrayFloat_co, other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... |
| @overload |
| def __rtruediv__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __rtruediv__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __lshift__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[int8]: ... # type: ignore[misc] |
| @overload |
| def __lshift__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __lshift__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... |
| @overload |
| def __lshift__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __lshift__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __rlshift__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[int8]: ... # type: ignore[misc] |
| @overload |
| def __rlshift__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __rlshift__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... |
| @overload |
| def __rlshift__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __rlshift__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __rshift__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[int8]: ... # type: ignore[misc] |
| @overload |
| def __rshift__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __rshift__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... |
| @overload |
| def __rshift__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __rshift__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __rrshift__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[int8]: ... # type: ignore[misc] |
| @overload |
| def __rrshift__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __rrshift__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... |
| @overload |
| def __rrshift__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __rrshift__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __and__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] |
| @overload |
| def __and__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __and__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... |
| @overload |
| def __and__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __and__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __rand__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] |
| @overload |
| def __rand__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __rand__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... |
| @overload |
| def __rand__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __rand__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __xor__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] |
| @overload |
| def __xor__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __xor__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... |
| @overload |
| def __xor__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __xor__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __rxor__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] |
| @overload |
| def __rxor__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __rxor__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... |
| @overload |
| def __rxor__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __rxor__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __or__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] |
| @overload |
| def __or__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __or__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... |
| @overload |
| def __or__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __or__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| @overload |
| def __ror__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... # type: ignore[misc] |
| @overload |
| def __ror__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] |
| @overload |
| def __ror__(self: _ArrayInt_co, other: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ... |
| @overload |
| def __ror__(self: NDArray[object_], other: Any) -> Any: ... |
| @overload |
| def __ror__(self: NDArray[Any], other: _ArrayLikeObject_co) -> Any: ... |
| |
| # `np.generic` does not support inplace operations |
| |
| # NOTE: Inplace ops generally use "same_kind" casting w.r.t. to the left |
| # operand. An exception to this rule are unsigned integers though, which |
| # also accepts a signed integer for the right operand as long it is a 0D |
| # object and its value is >= 0 |
| @overload |
| def __iadd__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... |
| @overload |
| def __iadd__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... |
| @overload |
| def __iadd__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... |
| @overload |
| def __iadd__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co) -> NDArray[floating[_NBit1]]: ... |
| @overload |
| def __iadd__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... |
| @overload |
| def __iadd__(self: NDArray[timedelta64], other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... |
| @overload |
| def __iadd__(self: NDArray[datetime64], other: _ArrayLikeTD64_co) -> NDArray[datetime64]: ... |
| @overload |
| def __iadd__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... |
| |
| @overload |
| def __isub__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... |
| @overload |
| def __isub__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... |
| @overload |
| def __isub__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co) -> NDArray[floating[_NBit1]]: ... |
| @overload |
| def __isub__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... |
| @overload |
| def __isub__(self: NDArray[timedelta64], other: _ArrayLikeTD64_co) -> NDArray[timedelta64]: ... |
| @overload |
| def __isub__(self: NDArray[datetime64], other: _ArrayLikeTD64_co) -> NDArray[datetime64]: ... |
| @overload |
| def __isub__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... |
| |
| @overload |
| def __imul__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... |
| @overload |
| def __imul__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... |
| @overload |
| def __imul__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... |
| @overload |
| def __imul__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co) -> NDArray[floating[_NBit1]]: ... |
| @overload |
| def __imul__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... |
| @overload |
| def __imul__(self: NDArray[timedelta64], other: _ArrayLikeFloat_co) -> NDArray[timedelta64]: ... |
| @overload |
| def __imul__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... |
| |
| @overload |
| def __itruediv__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co) -> NDArray[floating[_NBit1]]: ... |
| @overload |
| def __itruediv__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... |
| @overload |
| def __itruediv__(self: NDArray[timedelta64], other: _ArrayLikeBool_co) -> NoReturn: ... |
| @overload |
| def __itruediv__(self: NDArray[timedelta64], other: _ArrayLikeInt_co) -> NDArray[timedelta64]: ... |
| @overload |
| def __itruediv__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... |
| |
| @overload |
| def __ifloordiv__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... |
| @overload |
| def __ifloordiv__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... |
| @overload |
| def __ifloordiv__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co) -> NDArray[floating[_NBit1]]: ... |
| @overload |
| def __ifloordiv__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... |
| @overload |
| def __ifloordiv__(self: NDArray[timedelta64], other: _ArrayLikeBool_co) -> NoReturn: ... |
| @overload |
| def __ifloordiv__(self: NDArray[timedelta64], other: _ArrayLikeInt_co) -> NDArray[timedelta64]: ... |
| @overload |
| def __ifloordiv__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... |
| |
| @overload |
| def __ipow__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... |
| @overload |
| def __ipow__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... |
| @overload |
| def __ipow__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co) -> NDArray[floating[_NBit1]]: ... |
| @overload |
| def __ipow__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... |
| @overload |
| def __ipow__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... |
| |
| @overload |
| def __imod__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... |
| @overload |
| def __imod__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... |
| @overload |
| def __imod__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co) -> NDArray[floating[_NBit1]]: ... |
| @overload |
| def __imod__(self: NDArray[timedelta64], other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]]) -> NDArray[timedelta64]: ... |
| @overload |
| def __imod__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... |
| |
| @overload |
| def __ilshift__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... |
| @overload |
| def __ilshift__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... |
| @overload |
| def __ilshift__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... |
| |
| @overload |
| def __irshift__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... |
| @overload |
| def __irshift__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... |
| @overload |
| def __irshift__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... |
| |
| @overload |
| def __iand__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... |
| @overload |
| def __iand__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... |
| @overload |
| def __iand__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... |
| @overload |
| def __iand__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... |
| |
| @overload |
| def __ixor__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... |
| @overload |
| def __ixor__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... |
| @overload |
| def __ixor__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... |
| @overload |
| def __ixor__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... |
| |
| @overload |
| def __ior__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... |
| @overload |
| def __ior__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co) -> NDArray[unsignedinteger[_NBit1]]: ... |
| @overload |
| def __ior__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... |
| @overload |
| def __ior__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... |
| |
| @overload |
| def __imatmul__(self: NDArray[bool_], other: _ArrayLikeBool_co) -> NDArray[bool_]: ... |
| @overload |
| def __imatmul__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[_NBit1]]: ... |
| @overload |
| def __imatmul__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co) -> NDArray[signedinteger[_NBit1]]: ... |
| @overload |
| def __imatmul__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co) -> NDArray[floating[_NBit1]]: ... |
| @overload |
| def __imatmul__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... |
| @overload |
| def __imatmul__(self: NDArray[object_], other: Any) -> NDArray[object_]: ... |
| |
| def __dlpack__(self: NDArray[number[Any]], *, stream: None = ...) -> _PyCapsule: ... |
| def __dlpack_device__(self) -> tuple[int, L[0]]: ... |
| |
| # Keep `dtype` at the bottom to avoid name conflicts with `np.dtype` |
| @property |
| def dtype(self) -> _DType_co: ... |
| |
| # NOTE: while `np.generic` is not technically an instance of `ABCMeta`, |
| # the `@abstractmethod` decorator is herein used to (forcefully) deny |
| # the creation of `np.generic` instances. |
| # The `# type: ignore` comments are necessary to silence mypy errors regarding |
| # the missing `ABCMeta` metaclass. |
| |
| # See https://github.com/numpy/numpy-stubs/pull/80 for more details. |
| |
| _ScalarType = TypeVar("_ScalarType", bound=generic) |
| _NBit1 = TypeVar("_NBit1", bound=NBitBase) |
| _NBit2 = TypeVar("_NBit2", bound=NBitBase) |
| |
| class generic(_ArrayOrScalarCommon): |
| @abstractmethod |
| def __init__(self, *args: Any, **kwargs: Any) -> None: ... |
| @overload |
| def __array__(self: _ScalarType, dtype: None = ..., /) -> ndarray[Any, _dtype[_ScalarType]]: ... |
| @overload |
| def __array__(self, dtype: _DType, /) -> ndarray[Any, _DType]: ... |
| @property |
| def base(self) -> None: ... |
| @property |
| def ndim(self) -> L[0]: ... |
| @property |
| def size(self) -> L[1]: ... |
| @property |
| def shape(self) -> tuple[()]: ... |
| @property |
| def strides(self) -> tuple[()]: ... |
| def byteswap(self: _ScalarType, inplace: L[False] = ...) -> _ScalarType: ... |
| @property |
| def flat(self: _ScalarType) -> flatiter[ndarray[Any, _dtype[_ScalarType]]]: ... |
| |
| @overload |
| def astype( |
| self, |
| dtype: _DTypeLike[_ScalarType], |
| order: _OrderKACF = ..., |
| casting: _CastingKind = ..., |
| subok: bool = ..., |
| copy: bool | _CopyMode = ..., |
| ) -> _ScalarType: ... |
| @overload |
| def astype( |
| self, |
| dtype: DTypeLike, |
| order: _OrderKACF = ..., |
| casting: _CastingKind = ..., |
| subok: bool = ..., |
| copy: bool | _CopyMode = ..., |
| ) -> Any: ... |
| |
| # NOTE: `view` will perform a 0D->scalar cast, |
| # thus the array `type` is irrelevant to the output type |
| @overload |
| def view( |
| self: _ScalarType, |
| type: type[ndarray[Any, Any]] = ..., |
| ) -> _ScalarType: ... |
| @overload |
| def view( |
| self, |
| dtype: _DTypeLike[_ScalarType], |
| type: type[ndarray[Any, Any]] = ..., |
| ) -> _ScalarType: ... |
| @overload |
| def view( |
| self, |
| dtype: DTypeLike, |
| type: type[ndarray[Any, Any]] = ..., |
| ) -> Any: ... |
| |
| @overload |
| def getfield( |
| self, |
| dtype: _DTypeLike[_ScalarType], |
| offset: SupportsIndex = ... |
| ) -> _ScalarType: ... |
| @overload |
| def getfield( |
| self, |
| dtype: DTypeLike, |
| offset: SupportsIndex = ... |
| ) -> Any: ... |
| |
| def item( |
| self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, |
| ) -> Any: ... |
| |
| @overload |
| def take( # type: ignore[misc] |
| self: _ScalarType, |
| indices: _IntLike_co, |
| axis: None | SupportsIndex = ..., |
| out: None = ..., |
| mode: _ModeKind = ..., |
| ) -> _ScalarType: ... |
| @overload |
| def take( # type: ignore[misc] |
| self: _ScalarType, |
| indices: _ArrayLikeInt_co, |
| axis: None | SupportsIndex = ..., |
| out: None = ..., |
| mode: _ModeKind = ..., |
| ) -> ndarray[Any, _dtype[_ScalarType]]: ... |
| @overload |
| def take( |
| self, |
| indices: _ArrayLikeInt_co, |
| axis: None | SupportsIndex = ..., |
| out: _NdArraySubClass = ..., |
| mode: _ModeKind = ..., |
| ) -> _NdArraySubClass: ... |
| |
| def repeat( |
| self: _ScalarType, |
| repeats: _ArrayLikeInt_co, |
| axis: None | SupportsIndex = ..., |
| ) -> ndarray[Any, _dtype[_ScalarType]]: ... |
| |
| def flatten( |
| self: _ScalarType, |
| order: _OrderKACF = ..., |
| ) -> ndarray[Any, _dtype[_ScalarType]]: ... |
| |
| def ravel( |
| self: _ScalarType, |
| order: _OrderKACF = ..., |
| ) -> ndarray[Any, _dtype[_ScalarType]]: ... |
| |
| @overload |
| def reshape( |
| self: _ScalarType, shape: _ShapeLike, /, *, order: _OrderACF = ... |
| ) -> ndarray[Any, _dtype[_ScalarType]]: ... |
| @overload |
| def reshape( |
| self: _ScalarType, *shape: SupportsIndex, order: _OrderACF = ... |
| ) -> ndarray[Any, _dtype[_ScalarType]]: ... |
| |
| def squeeze( |
| self: _ScalarType, axis: None | L[0] | tuple[()] = ... |
| ) -> _ScalarType: ... |
| def transpose(self: _ScalarType, axes: None | tuple[()] = ..., /) -> _ScalarType: ... |
| # Keep `dtype` at the bottom to avoid name conflicts with `np.dtype` |
| @property |
| def dtype(self: _ScalarType) -> _dtype[_ScalarType]: ... |
| |
| class number(generic, Generic[_NBit1]): # type: ignore |
| @property |
| def real(self: _ArraySelf) -> _ArraySelf: ... |
| @property |
| def imag(self: _ArraySelf) -> _ArraySelf: ... |
| def __class_getitem__(self, item: Any) -> GenericAlias: ... |
| def __int__(self) -> int: ... |
| def __float__(self) -> float: ... |
| def __complex__(self) -> complex: ... |
| def __neg__(self: _ArraySelf) -> _ArraySelf: ... |
| def __pos__(self: _ArraySelf) -> _ArraySelf: ... |
| def __abs__(self: _ArraySelf) -> _ArraySelf: ... |
| # Ensure that objects annotated as `number` support arithmetic operations |
| __add__: _NumberOp |
| __radd__: _NumberOp |
| __sub__: _NumberOp |
| __rsub__: _NumberOp |
| __mul__: _NumberOp |
| __rmul__: _NumberOp |
| __floordiv__: _NumberOp |
| __rfloordiv__: _NumberOp |
| __pow__: _NumberOp |
| __rpow__: _NumberOp |
| __truediv__: _NumberOp |
| __rtruediv__: _NumberOp |
| __lt__: _ComparisonOp[_NumberLike_co, _ArrayLikeNumber_co] |
| __le__: _ComparisonOp[_NumberLike_co, _ArrayLikeNumber_co] |
| __gt__: _ComparisonOp[_NumberLike_co, _ArrayLikeNumber_co] |
| __ge__: _ComparisonOp[_NumberLike_co, _ArrayLikeNumber_co] |
| |
| class bool_(generic): |
| def __init__(self, value: object = ..., /) -> None: ... |
| def item( |
| self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, |
| ) -> bool: ... |
| def tolist(self) -> bool: ... |
| @property |
| def real(self: _ArraySelf) -> _ArraySelf: ... |
| @property |
| def imag(self: _ArraySelf) -> _ArraySelf: ... |
| def __int__(self) -> int: ... |
| def __float__(self) -> float: ... |
| def __complex__(self) -> complex: ... |
| def __abs__(self: _ArraySelf) -> _ArraySelf: ... |
| __add__: _BoolOp[bool_] |
| __radd__: _BoolOp[bool_] |
| __sub__: _BoolSub |
| __rsub__: _BoolSub |
| __mul__: _BoolOp[bool_] |
| __rmul__: _BoolOp[bool_] |
| __floordiv__: _BoolOp[int8] |
| __rfloordiv__: _BoolOp[int8] |
| __pow__: _BoolOp[int8] |
| __rpow__: _BoolOp[int8] |
| __truediv__: _BoolTrueDiv |
| __rtruediv__: _BoolTrueDiv |
| def __invert__(self) -> bool_: ... |
| __lshift__: _BoolBitOp[int8] |
| __rlshift__: _BoolBitOp[int8] |
| __rshift__: _BoolBitOp[int8] |
| __rrshift__: _BoolBitOp[int8] |
| __and__: _BoolBitOp[bool_] |
| __rand__: _BoolBitOp[bool_] |
| __xor__: _BoolBitOp[bool_] |
| __rxor__: _BoolBitOp[bool_] |
| __or__: _BoolBitOp[bool_] |
| __ror__: _BoolBitOp[bool_] |
| __mod__: _BoolMod |
| __rmod__: _BoolMod |
| __divmod__: _BoolDivMod |
| __rdivmod__: _BoolDivMod |
| __lt__: _ComparisonOp[_NumberLike_co, _ArrayLikeNumber_co] |
| __le__: _ComparisonOp[_NumberLike_co, _ArrayLikeNumber_co] |
| __gt__: _ComparisonOp[_NumberLike_co, _ArrayLikeNumber_co] |
| __ge__: _ComparisonOp[_NumberLike_co, _ArrayLikeNumber_co] |
| |
| class object_(generic): |
| def __init__(self, value: object = ..., /) -> None: ... |
| @property |
| def real(self: _ArraySelf) -> _ArraySelf: ... |
| @property |
| def imag(self: _ArraySelf) -> _ArraySelf: ... |
| # The 3 protocols below may or may not raise, |
| # depending on the underlying object |
| def __int__(self) -> int: ... |
| def __float__(self) -> float: ... |
| def __complex__(self) -> complex: ... |
| |
| # The `datetime64` constructors requires an object with the three attributes below, |
| # and thus supports datetime duck typing |
| class _DatetimeScalar(Protocol): |
| @property |
| def day(self) -> int: ... |
| @property |
| def month(self) -> int: ... |
| @property |
| def year(self) -> int: ... |
| |
| # TODO: `item`/`tolist` returns either `dt.date`, `dt.datetime` or `int` |
| # depending on the unit |
| class datetime64(generic): |
| @overload |
| def __init__( |
| self, |
| value: None | datetime64 | _CharLike_co | _DatetimeScalar = ..., |
| format: _CharLike_co | tuple[_CharLike_co, _IntLike_co] = ..., |
| /, |
| ) -> None: ... |
| @overload |
| def __init__( |
| self, |
| value: int, |
| format: _CharLike_co | tuple[_CharLike_co, _IntLike_co], |
| /, |
| ) -> None: ... |
| def __add__(self, other: _TD64Like_co) -> datetime64: ... |
| def __radd__(self, other: _TD64Like_co) -> datetime64: ... |
| @overload |
| def __sub__(self, other: datetime64) -> timedelta64: ... |
| @overload |
| def __sub__(self, other: _TD64Like_co) -> datetime64: ... |
| def __rsub__(self, other: datetime64) -> timedelta64: ... |
| __lt__: _ComparisonOp[datetime64, _ArrayLikeDT64_co] |
| __le__: _ComparisonOp[datetime64, _ArrayLikeDT64_co] |
| __gt__: _ComparisonOp[datetime64, _ArrayLikeDT64_co] |
| __ge__: _ComparisonOp[datetime64, _ArrayLikeDT64_co] |
| |
| _IntValue = Union[SupportsInt, _CharLike_co, SupportsIndex] |
| _FloatValue = Union[None, _CharLike_co, SupportsFloat, SupportsIndex] |
| _ComplexValue = Union[ |
| None, |
| _CharLike_co, |
| SupportsFloat, |
| SupportsComplex, |
| SupportsIndex, |
| complex, # `complex` is not a subtype of `SupportsComplex` |
| ] |
| |
| class integer(number[_NBit1]): # type: ignore |
| @property |
| def numerator(self: _ScalarType) -> _ScalarType: ... |
| @property |
| def denominator(self) -> L[1]: ... |
| @overload |
| def __round__(self, ndigits: None = ...) -> int: ... |
| @overload |
| def __round__(self: _ScalarType, ndigits: SupportsIndex) -> _ScalarType: ... |
| |
| # NOTE: `__index__` is technically defined in the bottom-most |
| # sub-classes (`int64`, `uint32`, etc) |
| def item( |
| self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, |
| ) -> int: ... |
| def tolist(self) -> int: ... |
| def is_integer(self) -> L[True]: ... |
| def bit_count(self: _ScalarType) -> int: ... |
| def __index__(self) -> int: ... |
| __truediv__: _IntTrueDiv[_NBit1] |
| __rtruediv__: _IntTrueDiv[_NBit1] |
| def __mod__(self, value: _IntLike_co) -> integer[Any]: ... |
| def __rmod__(self, value: _IntLike_co) -> integer[Any]: ... |
| def __invert__(self: _IntType) -> _IntType: ... |
| # Ensure that objects annotated as `integer` support bit-wise operations |
| def __lshift__(self, other: _IntLike_co) -> integer[Any]: ... |
| def __rlshift__(self, other: _IntLike_co) -> integer[Any]: ... |
| def __rshift__(self, other: _IntLike_co) -> integer[Any]: ... |
| def __rrshift__(self, other: _IntLike_co) -> integer[Any]: ... |
| def __and__(self, other: _IntLike_co) -> integer[Any]: ... |
| def __rand__(self, other: _IntLike_co) -> integer[Any]: ... |
| def __or__(self, other: _IntLike_co) -> integer[Any]: ... |
| def __ror__(self, other: _IntLike_co) -> integer[Any]: ... |
| def __xor__(self, other: _IntLike_co) -> integer[Any]: ... |
| def __rxor__(self, other: _IntLike_co) -> integer[Any]: ... |
| |
| class signedinteger(integer[_NBit1]): |
| def __init__(self, value: _IntValue = ..., /) -> None: ... |
| __add__: _SignedIntOp[_NBit1] |
| __radd__: _SignedIntOp[_NBit1] |
| __sub__: _SignedIntOp[_NBit1] |
| __rsub__: _SignedIntOp[_NBit1] |
| __mul__: _SignedIntOp[_NBit1] |
| __rmul__: _SignedIntOp[_NBit1] |
| __floordiv__: _SignedIntOp[_NBit1] |
| __rfloordiv__: _SignedIntOp[_NBit1] |
| __pow__: _SignedIntOp[_NBit1] |
| __rpow__: _SignedIntOp[_NBit1] |
| __lshift__: _SignedIntBitOp[_NBit1] |
| __rlshift__: _SignedIntBitOp[_NBit1] |
| __rshift__: _SignedIntBitOp[_NBit1] |
| __rrshift__: _SignedIntBitOp[_NBit1] |
| __and__: _SignedIntBitOp[_NBit1] |
| __rand__: _SignedIntBitOp[_NBit1] |
| __xor__: _SignedIntBitOp[_NBit1] |
| __rxor__: _SignedIntBitOp[_NBit1] |
| __or__: _SignedIntBitOp[_NBit1] |
| __ror__: _SignedIntBitOp[_NBit1] |
| __mod__: _SignedIntMod[_NBit1] |
| __rmod__: _SignedIntMod[_NBit1] |
| __divmod__: _SignedIntDivMod[_NBit1] |
| __rdivmod__: _SignedIntDivMod[_NBit1] |
| |
| int8 = signedinteger[_8Bit] |
| int16 = signedinteger[_16Bit] |
| int32 = signedinteger[_32Bit] |
| int64 = signedinteger[_64Bit] |
| |
| byte = signedinteger[_NBitByte] |
| short = signedinteger[_NBitShort] |
| intc = signedinteger[_NBitIntC] |
| intp = signedinteger[_NBitIntP] |
| int_ = signedinteger[_NBitInt] |
| longlong = signedinteger[_NBitLongLong] |
| |
| # TODO: `item`/`tolist` returns either `dt.timedelta` or `int` |
| # depending on the unit |
| class timedelta64(generic): |
| def __init__( |
| self, |
| value: None | int | _CharLike_co | dt.timedelta | timedelta64 = ..., |
| format: _CharLike_co | tuple[_CharLike_co, _IntLike_co] = ..., |
| /, |
| ) -> None: ... |
| @property |
| def numerator(self: _ScalarType) -> _ScalarType: ... |
| @property |
| def denominator(self) -> L[1]: ... |
| |
| # NOTE: Only a limited number of units support conversion |
| # to builtin scalar types: `Y`, `M`, `ns`, `ps`, `fs`, `as` |
| def __int__(self) -> int: ... |
| def __float__(self) -> float: ... |
| def __complex__(self) -> complex: ... |
| def __neg__(self: _ArraySelf) -> _ArraySelf: ... |
| def __pos__(self: _ArraySelf) -> _ArraySelf: ... |
| def __abs__(self: _ArraySelf) -> _ArraySelf: ... |
| def __add__(self, other: _TD64Like_co) -> timedelta64: ... |
| def __radd__(self, other: _TD64Like_co) -> timedelta64: ... |
| def __sub__(self, other: _TD64Like_co) -> timedelta64: ... |
| def __rsub__(self, other: _TD64Like_co) -> timedelta64: ... |
| def __mul__(self, other: _FloatLike_co) -> timedelta64: ... |
| def __rmul__(self, other: _FloatLike_co) -> timedelta64: ... |
| __truediv__: _TD64Div[float64] |
| __floordiv__: _TD64Div[int64] |
| def __rtruediv__(self, other: timedelta64) -> float64: ... |
| def __rfloordiv__(self, other: timedelta64) -> int64: ... |
| def __mod__(self, other: timedelta64) -> timedelta64: ... |
| def __rmod__(self, other: timedelta64) -> timedelta64: ... |
| def __divmod__(self, other: timedelta64) -> tuple[int64, timedelta64]: ... |
| def __rdivmod__(self, other: timedelta64) -> tuple[int64, timedelta64]: ... |
| __lt__: _ComparisonOp[_TD64Like_co, _ArrayLikeTD64_co] |
| __le__: _ComparisonOp[_TD64Like_co, _ArrayLikeTD64_co] |
| __gt__: _ComparisonOp[_TD64Like_co, _ArrayLikeTD64_co] |
| __ge__: _ComparisonOp[_TD64Like_co, _ArrayLikeTD64_co] |
| |
| class unsignedinteger(integer[_NBit1]): |
| # NOTE: `uint64 + signedinteger -> float64` |
| def __init__(self, value: _IntValue = ..., /) -> None: ... |
| __add__: _UnsignedIntOp[_NBit1] |
| __radd__: _UnsignedIntOp[_NBit1] |
| __sub__: _UnsignedIntOp[_NBit1] |
| __rsub__: _UnsignedIntOp[_NBit1] |
| __mul__: _UnsignedIntOp[_NBit1] |
| __rmul__: _UnsignedIntOp[_NBit1] |
| __floordiv__: _UnsignedIntOp[_NBit1] |
| __rfloordiv__: _UnsignedIntOp[_NBit1] |
| __pow__: _UnsignedIntOp[_NBit1] |
| __rpow__: _UnsignedIntOp[_NBit1] |
| __lshift__: _UnsignedIntBitOp[_NBit1] |
| __rlshift__: _UnsignedIntBitOp[_NBit1] |
| __rshift__: _UnsignedIntBitOp[_NBit1] |
| __rrshift__: _UnsignedIntBitOp[_NBit1] |
| __and__: _UnsignedIntBitOp[_NBit1] |
| __rand__: _UnsignedIntBitOp[_NBit1] |
| __xor__: _UnsignedIntBitOp[_NBit1] |
| __rxor__: _UnsignedIntBitOp[_NBit1] |
| __or__: _UnsignedIntBitOp[_NBit1] |
| __ror__: _UnsignedIntBitOp[_NBit1] |
| __mod__: _UnsignedIntMod[_NBit1] |
| __rmod__: _UnsignedIntMod[_NBit1] |
| __divmod__: _UnsignedIntDivMod[_NBit1] |
| __rdivmod__: _UnsignedIntDivMod[_NBit1] |
| |
| uint8 = unsignedinteger[_8Bit] |
| uint16 = unsignedinteger[_16Bit] |
| uint32 = unsignedinteger[_32Bit] |
| uint64 = unsignedinteger[_64Bit] |
| |
| ubyte = unsignedinteger[_NBitByte] |
| ushort = unsignedinteger[_NBitShort] |
| uintc = unsignedinteger[_NBitIntC] |
| uintp = unsignedinteger[_NBitIntP] |
| uint = unsignedinteger[_NBitInt] |
| ulonglong = unsignedinteger[_NBitLongLong] |
| |
| class inexact(number[_NBit1]): # type: ignore |
| def __getnewargs__(self: inexact[_64Bit]) -> tuple[float, ...]: ... |
| |
| _IntType = TypeVar("_IntType", bound=integer[Any]) |
| _FloatType = TypeVar('_FloatType', bound=floating[Any]) |
| |
| class floating(inexact[_NBit1]): |
| def __init__(self, value: _FloatValue = ..., /) -> None: ... |
| def item( |
| self, args: L[0] | tuple[()] | tuple[L[0]] = ..., |
| /, |
| ) -> float: ... |
| def tolist(self) -> float: ... |
| def is_integer(self) -> bool: ... |
| def hex(self: float64) -> str: ... |
| @classmethod |
| def fromhex(cls: type[float64], string: str, /) -> float64: ... |
| def as_integer_ratio(self) -> tuple[int, int]: ... |
| def __ceil__(self: float64) -> int: ... |
| def __floor__(self: float64) -> int: ... |
| def __trunc__(self: float64) -> int: ... |
| def __getnewargs__(self: float64) -> tuple[float]: ... |
| def __getformat__(self: float64, typestr: L["double", "float"], /) -> str: ... |
| @overload |
| def __round__(self, ndigits: None = ...) -> int: ... |
| @overload |
| def __round__(self: _ScalarType, ndigits: SupportsIndex) -> _ScalarType: ... |
| __add__: _FloatOp[_NBit1] |
| __radd__: _FloatOp[_NBit1] |
| __sub__: _FloatOp[_NBit1] |
| __rsub__: _FloatOp[_NBit1] |
| __mul__: _FloatOp[_NBit1] |
| __rmul__: _FloatOp[_NBit1] |
| __truediv__: _FloatOp[_NBit1] |
| __rtruediv__: _FloatOp[_NBit1] |
| __floordiv__: _FloatOp[_NBit1] |
| __rfloordiv__: _FloatOp[_NBit1] |
| __pow__: _FloatOp[_NBit1] |
| __rpow__: _FloatOp[_NBit1] |
| __mod__: _FloatMod[_NBit1] |
| __rmod__: _FloatMod[_NBit1] |
| __divmod__: _FloatDivMod[_NBit1] |
| __rdivmod__: _FloatDivMod[_NBit1] |
| |
| float16 = floating[_16Bit] |
| float32 = floating[_32Bit] |
| float64 = floating[_64Bit] |
| |
| half = floating[_NBitHalf] |
| single = floating[_NBitSingle] |
| double = floating[_NBitDouble] |
| float_ = floating[_NBitDouble] |
| longdouble = floating[_NBitLongDouble] |
| longfloat = floating[_NBitLongDouble] |
| |
| # The main reason for `complexfloating` having two typevars is cosmetic. |
| # It is used to clarify why `complex128`s precision is `_64Bit`, the latter |
| # describing the two 64 bit floats representing its real and imaginary component |
| |
| class complexfloating(inexact[_NBit1], Generic[_NBit1, _NBit2]): |
| def __init__(self, value: _ComplexValue = ..., /) -> None: ... |
| def item( |
| self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, |
| ) -> complex: ... |
| def tolist(self) -> complex: ... |
| @property |
| def real(self) -> floating[_NBit1]: ... # type: ignore[override] |
| @property |
| def imag(self) -> floating[_NBit2]: ... # type: ignore[override] |
| def __abs__(self) -> floating[_NBit1]: ... # type: ignore[override] |
| def __getnewargs__(self: complex128) -> tuple[float, float]: ... |
| # NOTE: Deprecated |
| # def __round__(self, ndigits=...): ... |
| __add__: _ComplexOp[_NBit1] |
| __radd__: _ComplexOp[_NBit1] |
| __sub__: _ComplexOp[_NBit1] |
| __rsub__: _ComplexOp[_NBit1] |
| __mul__: _ComplexOp[_NBit1] |
| __rmul__: _ComplexOp[_NBit1] |
| __truediv__: _ComplexOp[_NBit1] |
| __rtruediv__: _ComplexOp[_NBit1] |
| __pow__: _ComplexOp[_NBit1] |
| __rpow__: _ComplexOp[_NBit1] |
| |
| complex64 = complexfloating[_32Bit, _32Bit] |
| complex128 = complexfloating[_64Bit, _64Bit] |
| |
| csingle = complexfloating[_NBitSingle, _NBitSingle] |
| singlecomplex = complexfloating[_NBitSingle, _NBitSingle] |
| cdouble = complexfloating[_NBitDouble, _NBitDouble] |
| complex_ = complexfloating[_NBitDouble, _NBitDouble] |
| cfloat = complexfloating[_NBitDouble, _NBitDouble] |
| clongdouble = complexfloating[_NBitLongDouble, _NBitLongDouble] |
| clongfloat = complexfloating[_NBitLongDouble, _NBitLongDouble] |
| longcomplex = complexfloating[_NBitLongDouble, _NBitLongDouble] |
| |
| class flexible(generic): ... # type: ignore |
| |
| # TODO: `item`/`tolist` returns either `bytes` or `tuple` |
| # depending on whether or not it's used as an opaque bytes sequence |
| # or a structure |
| class void(flexible): |
| @overload |
| def __init__(self, value: _IntLike_co | bytes, /, dtype : None = ...) -> None: ... |
| @overload |
| def __init__(self, value: Any, /, dtype: _DTypeLikeVoid) -> None: ... |
| @property |
| def real(self: _ArraySelf) -> _ArraySelf: ... |
| @property |
| def imag(self: _ArraySelf) -> _ArraySelf: ... |
| def setfield( |
| self, val: ArrayLike, dtype: DTypeLike, offset: int = ... |
| ) -> None: ... |
| @overload |
| def __getitem__(self, key: str | SupportsIndex) -> Any: ... |
| @overload |
| def __getitem__(self, key: list[str]) -> void: ... |
| def __setitem__( |
| self, |
| key: str | list[str] | SupportsIndex, |
| value: ArrayLike, |
| ) -> None: ... |
| |
| class character(flexible): # type: ignore |
| def __int__(self) -> int: ... |
| def __float__(self) -> float: ... |
| |
| # NOTE: Most `np.bytes_` / `np.str_` methods return their |
| # builtin `bytes` / `str` counterpart |
| |
| class bytes_(character, bytes): |
| @overload |
| def __init__(self, value: object = ..., /) -> None: ... |
| @overload |
| def __init__( |
| self, value: str, /, encoding: str = ..., errors: str = ... |
| ) -> None: ... |
| def item( |
| self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, |
| ) -> bytes: ... |
| def tolist(self) -> bytes: ... |
| |
| string_ = bytes_ |
| |
| class str_(character, str): |
| @overload |
| def __init__(self, value: object = ..., /) -> None: ... |
| @overload |
| def __init__( |
| self, value: bytes, /, encoding: str = ..., errors: str = ... |
| ) -> None: ... |
| def item( |
| self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, |
| ) -> str: ... |
| def tolist(self) -> str: ... |
| |
| unicode_ = str_ |
| |
| # |
| # Constants |
| # |
| |
| Inf: Final[float] |
| Infinity: Final[float] |
| NAN: Final[float] |
| NINF: Final[float] |
| NZERO: Final[float] |
| NaN: Final[float] |
| PINF: Final[float] |
| PZERO: Final[float] |
| e: Final[float] |
| euler_gamma: Final[float] |
| inf: Final[float] |
| infty: Final[float] |
| nan: Final[float] |
| pi: Final[float] |
| |
| ERR_IGNORE: L[0] |
| ERR_WARN: L[1] |
| ERR_RAISE: L[2] |
| ERR_CALL: L[3] |
| ERR_PRINT: L[4] |
| ERR_LOG: L[5] |
| ERR_DEFAULT: L[521] |
| |
| SHIFT_DIVIDEBYZERO: L[0] |
| SHIFT_OVERFLOW: L[3] |
| SHIFT_UNDERFLOW: L[6] |
| SHIFT_INVALID: L[9] |
| |
| FPE_DIVIDEBYZERO: L[1] |
| FPE_OVERFLOW: L[2] |
| FPE_UNDERFLOW: L[4] |
| FPE_INVALID: L[8] |
| |
| FLOATING_POINT_SUPPORT: L[1] |
| UFUNC_BUFSIZE_DEFAULT = BUFSIZE |
| |
| little_endian: Final[bool] |
| True_: Final[bool_] |
| False_: Final[bool_] |
| |
| UFUNC_PYVALS_NAME: L["UFUNC_PYVALS"] |
| |
| newaxis: None |
| |
| # See `numpy._typing._ufunc` for more concrete nin-/nout-specific stubs |
| @final |
| class ufunc: |
| @property |
| def __name__(self) -> str: ... |
| @property |
| def __doc__(self) -> str: ... |
| __call__: Callable[..., Any] |
| @property |
| def nin(self) -> int: ... |
| @property |
| def nout(self) -> int: ... |
| @property |
| def nargs(self) -> int: ... |
| @property |
| def ntypes(self) -> int: ... |
| @property |
| def types(self) -> list[str]: ... |
| # Broad return type because it has to encompass things like |
| # |
| # >>> np.logical_and.identity is True |
| # True |
| # >>> np.add.identity is 0 |
| # True |
| # >>> np.sin.identity is None |
| # True |
| # |
| # and any user-defined ufuncs. |
| @property |
| def identity(self) -> Any: ... |
| # This is None for ufuncs and a string for gufuncs. |
| @property |
| def signature(self) -> None | str: ... |
| # The next four methods will always exist, but they will just |
| # raise a ValueError ufuncs with that don't accept two input |
| # arguments and return one output argument. Because of that we |
| # can't type them very precisely. |
| reduce: Any |
| accumulate: Any |
| reduceat: Any |
| outer: Any |
| # Similarly at won't be defined for ufuncs that return multiple |
| # outputs, so we can't type it very precisely. |
| at: Any |
| |
| # Parameters: `__name__`, `ntypes` and `identity` |
| absolute: _UFunc_Nin1_Nout1[L['absolute'], L[20], None] |
| add: _UFunc_Nin2_Nout1[L['add'], L[22], L[0]] |
| arccos: _UFunc_Nin1_Nout1[L['arccos'], L[8], None] |
| arccosh: _UFunc_Nin1_Nout1[L['arccosh'], L[8], None] |
| arcsin: _UFunc_Nin1_Nout1[L['arcsin'], L[8], None] |
| arcsinh: _UFunc_Nin1_Nout1[L['arcsinh'], L[8], None] |
| arctan2: _UFunc_Nin2_Nout1[L['arctan2'], L[5], None] |
| arctan: _UFunc_Nin1_Nout1[L['arctan'], L[8], None] |
| arctanh: _UFunc_Nin1_Nout1[L['arctanh'], L[8], None] |
| bitwise_and: _UFunc_Nin2_Nout1[L['bitwise_and'], L[12], L[-1]] |
| bitwise_not: _UFunc_Nin1_Nout1[L['invert'], L[12], None] |
| bitwise_or: _UFunc_Nin2_Nout1[L['bitwise_or'], L[12], L[0]] |
| bitwise_xor: _UFunc_Nin2_Nout1[L['bitwise_xor'], L[12], L[0]] |
| cbrt: _UFunc_Nin1_Nout1[L['cbrt'], L[5], None] |
| ceil: _UFunc_Nin1_Nout1[L['ceil'], L[7], None] |
| conj: _UFunc_Nin1_Nout1[L['conjugate'], L[18], None] |
| conjugate: _UFunc_Nin1_Nout1[L['conjugate'], L[18], None] |
| copysign: _UFunc_Nin2_Nout1[L['copysign'], L[4], None] |
| cos: _UFunc_Nin1_Nout1[L['cos'], L[9], None] |
| cosh: _UFunc_Nin1_Nout1[L['cosh'], L[8], None] |
| deg2rad: _UFunc_Nin1_Nout1[L['deg2rad'], L[5], None] |
| degrees: _UFunc_Nin1_Nout1[L['degrees'], L[5], None] |
| divide: _UFunc_Nin2_Nout1[L['true_divide'], L[11], None] |
| divmod: _UFunc_Nin2_Nout2[L['divmod'], L[15], None] |
| equal: _UFunc_Nin2_Nout1[L['equal'], L[23], None] |
| exp2: _UFunc_Nin1_Nout1[L['exp2'], L[8], None] |
| exp: _UFunc_Nin1_Nout1[L['exp'], L[10], None] |
| expm1: _UFunc_Nin1_Nout1[L['expm1'], L[8], None] |
| fabs: _UFunc_Nin1_Nout1[L['fabs'], L[5], None] |
| float_power: _UFunc_Nin2_Nout1[L['float_power'], L[4], None] |
| floor: _UFunc_Nin1_Nout1[L['floor'], L[7], None] |
| floor_divide: _UFunc_Nin2_Nout1[L['floor_divide'], L[21], None] |
| fmax: _UFunc_Nin2_Nout1[L['fmax'], L[21], None] |
| fmin: _UFunc_Nin2_Nout1[L['fmin'], L[21], None] |
| fmod: _UFunc_Nin2_Nout1[L['fmod'], L[15], None] |
| frexp: _UFunc_Nin1_Nout2[L['frexp'], L[4], None] |
| gcd: _UFunc_Nin2_Nout1[L['gcd'], L[11], L[0]] |
| greater: _UFunc_Nin2_Nout1[L['greater'], L[23], None] |
| greater_equal: _UFunc_Nin2_Nout1[L['greater_equal'], L[23], None] |
| heaviside: _UFunc_Nin2_Nout1[L['heaviside'], L[4], None] |
| hypot: _UFunc_Nin2_Nout1[L['hypot'], L[5], L[0]] |
| invert: _UFunc_Nin1_Nout1[L['invert'], L[12], None] |
| isfinite: _UFunc_Nin1_Nout1[L['isfinite'], L[20], None] |
| isinf: _UFunc_Nin1_Nout1[L['isinf'], L[20], None] |
| isnan: _UFunc_Nin1_Nout1[L['isnan'], L[20], None] |
| isnat: _UFunc_Nin1_Nout1[L['isnat'], L[2], None] |
| lcm: _UFunc_Nin2_Nout1[L['lcm'], L[11], None] |
| ldexp: _UFunc_Nin2_Nout1[L['ldexp'], L[8], None] |
| left_shift: _UFunc_Nin2_Nout1[L['left_shift'], L[11], None] |
| less: _UFunc_Nin2_Nout1[L['less'], L[23], None] |
| less_equal: _UFunc_Nin2_Nout1[L['less_equal'], L[23], None] |
| log10: _UFunc_Nin1_Nout1[L['log10'], L[8], None] |
| log1p: _UFunc_Nin1_Nout1[L['log1p'], L[8], None] |
| log2: _UFunc_Nin1_Nout1[L['log2'], L[8], None] |
| log: _UFunc_Nin1_Nout1[L['log'], L[10], None] |
| logaddexp2: _UFunc_Nin2_Nout1[L['logaddexp2'], L[4], float] |
| logaddexp: _UFunc_Nin2_Nout1[L['logaddexp'], L[4], float] |
| logical_and: _UFunc_Nin2_Nout1[L['logical_and'], L[20], L[True]] |
| logical_not: _UFunc_Nin1_Nout1[L['logical_not'], L[20], None] |
| logical_or: _UFunc_Nin2_Nout1[L['logical_or'], L[20], L[False]] |
| logical_xor: _UFunc_Nin2_Nout1[L['logical_xor'], L[19], L[False]] |
| matmul: _GUFunc_Nin2_Nout1[L['matmul'], L[19], None] |
| maximum: _UFunc_Nin2_Nout1[L['maximum'], L[21], None] |
| minimum: _UFunc_Nin2_Nout1[L['minimum'], L[21], None] |
| mod: _UFunc_Nin2_Nout1[L['remainder'], L[16], None] |
| modf: _UFunc_Nin1_Nout2[L['modf'], L[4], None] |
| multiply: _UFunc_Nin2_Nout1[L['multiply'], L[23], L[1]] |
| negative: _UFunc_Nin1_Nout1[L['negative'], L[19], None] |
| nextafter: _UFunc_Nin2_Nout1[L['nextafter'], L[4], None] |
| not_equal: _UFunc_Nin2_Nout1[L['not_equal'], L[23], None] |
| positive: _UFunc_Nin1_Nout1[L['positive'], L[19], None] |
| power: _UFunc_Nin2_Nout1[L['power'], L[18], None] |
| rad2deg: _UFunc_Nin1_Nout1[L['rad2deg'], L[5], None] |
| radians: _UFunc_Nin1_Nout1[L['radians'], L[5], None] |
| reciprocal: _UFunc_Nin1_Nout1[L['reciprocal'], L[18], None] |
| remainder: _UFunc_Nin2_Nout1[L['remainder'], L[16], None] |
| right_shift: _UFunc_Nin2_Nout1[L['right_shift'], L[11], None] |
| rint: _UFunc_Nin1_Nout1[L['rint'], L[10], None] |
| sign: _UFunc_Nin1_Nout1[L['sign'], L[19], None] |
| signbit: _UFunc_Nin1_Nout1[L['signbit'], L[4], None] |
| sin: _UFunc_Nin1_Nout1[L['sin'], L[9], None] |
| sinh: _UFunc_Nin1_Nout1[L['sinh'], L[8], None] |
| spacing: _UFunc_Nin1_Nout1[L['spacing'], L[4], None] |
| sqrt: _UFunc_Nin1_Nout1[L['sqrt'], L[10], None] |
| square: _UFunc_Nin1_Nout1[L['square'], L[18], None] |
| subtract: _UFunc_Nin2_Nout1[L['subtract'], L[21], None] |
| tan: _UFunc_Nin1_Nout1[L['tan'], L[8], None] |
| tanh: _UFunc_Nin1_Nout1[L['tanh'], L[8], None] |
| true_divide: _UFunc_Nin2_Nout1[L['true_divide'], L[11], None] |
| trunc: _UFunc_Nin1_Nout1[L['trunc'], L[7], None] |
| |
| abs = absolute |
| |
| class _CopyMode(enum.Enum): |
| ALWAYS: L[True] |
| IF_NEEDED: L[False] |
| NEVER: L[2] |
| |
| # Warnings |
| class RankWarning(UserWarning): ... |
| |
| _CallType = TypeVar("_CallType", bound=_ErrFunc | _SupportsWrite[str]) |
| |
| class errstate(Generic[_CallType], ContextDecorator): |
| call: _CallType |
| kwargs: _ErrDictOptional |
| |
| # Expand `**kwargs` into explicit keyword-only arguments |
| def __init__( |
| self, |
| *, |
| call: _CallType = ..., |
| all: None | _ErrKind = ..., |
| divide: None | _ErrKind = ..., |
| over: None | _ErrKind = ..., |
| under: None | _ErrKind = ..., |
| invalid: None | _ErrKind = ..., |
| ) -> None: ... |
| def __enter__(self) -> None: ... |
| def __exit__( |
| self, |
| exc_type: None | type[BaseException], |
| exc_value: None | BaseException, |
| traceback: None | TracebackType, |
| /, |
| ) -> None: ... |
| |
| @contextmanager |
| def _no_nep50_warning() -> Generator[None, None, None]: ... |
| def _get_promotion_state() -> str: ... |
| def _set_promotion_state(state: str, /) -> None: ... |
| |
| class ndenumerate(Generic[_ScalarType]): |
| iter: flatiter[NDArray[_ScalarType]] |
| @overload |
| def __new__( |
| cls, arr: _FiniteNestedSequence[_SupportsArray[dtype[_ScalarType]]], |
| ) -> ndenumerate[_ScalarType]: ... |
| @overload |
| def __new__(cls, arr: str | _NestedSequence[str]) -> ndenumerate[str_]: ... |
| @overload |
| def __new__(cls, arr: bytes | _NestedSequence[bytes]) -> ndenumerate[bytes_]: ... |
| @overload |
| def __new__(cls, arr: bool | _NestedSequence[bool]) -> ndenumerate[bool_]: ... |
| @overload |
| def __new__(cls, arr: int | _NestedSequence[int]) -> ndenumerate[int_]: ... |
| @overload |
| def __new__(cls, arr: float | _NestedSequence[float]) -> ndenumerate[float_]: ... |
| @overload |
| def __new__(cls, arr: complex | _NestedSequence[complex]) -> ndenumerate[complex_]: ... |
| def __next__(self: ndenumerate[_ScalarType]) -> tuple[_Shape, _ScalarType]: ... |
| def __iter__(self: _T) -> _T: ... |
| |
| class ndindex: |
| @overload |
| def __init__(self, shape: tuple[SupportsIndex, ...], /) -> None: ... |
| @overload |
| def __init__(self, *shape: SupportsIndex) -> None: ... |
| def __iter__(self: _T) -> _T: ... |
| def __next__(self) -> _Shape: ... |
| |
| class DataSource: |
| def __init__( |
| self, |
| destpath: None | str | os.PathLike[str] = ..., |
| ) -> None: ... |
| def __del__(self) -> None: ... |
| def abspath(self, path: str) -> str: ... |
| def exists(self, path: str) -> bool: ... |
| |
| # Whether the file-object is opened in string or bytes mode (by default) |
| # depends on the file-extension of `path` |
| def open( |
| self, |
| path: str, |
| mode: str = ..., |
| encoding: None | str = ..., |
| newline: None | str = ..., |
| ) -> IO[Any]: ... |
| |
| # TODO: The type of each `__next__` and `iters` return-type depends |
| # on the length and dtype of `args`; we can't describe this behavior yet |
| # as we lack variadics (PEP 646). |
| @final |
| class broadcast: |
| def __new__(cls, *args: ArrayLike) -> broadcast: ... |
| @property |
| def index(self) -> int: ... |
| @property |
| def iters(self) -> tuple[flatiter[Any], ...]: ... |
| @property |
| def nd(self) -> int: ... |
| @property |
| def ndim(self) -> int: ... |
| @property |
| def numiter(self) -> int: ... |
| @property |
| def shape(self) -> _Shape: ... |
| @property |
| def size(self) -> int: ... |
| def __next__(self) -> tuple[Any, ...]: ... |
| def __iter__(self: _T) -> _T: ... |
| def reset(self) -> None: ... |
| |
| @final |
| class busdaycalendar: |
| def __new__( |
| cls, |
| weekmask: ArrayLike = ..., |
| holidays: ArrayLike | dt.date | _NestedSequence[dt.date] = ..., |
| ) -> busdaycalendar: ... |
| @property |
| def weekmask(self) -> NDArray[bool_]: ... |
| @property |
| def holidays(self) -> NDArray[datetime64]: ... |
| |
| class finfo(Generic[_FloatType]): |
| dtype: dtype[_FloatType] |
| bits: int |
| eps: _FloatType |
| epsneg: _FloatType |
| iexp: int |
| machep: int |
| max: _FloatType |
| maxexp: int |
| min: _FloatType |
| minexp: int |
| negep: int |
| nexp: int |
| nmant: int |
| precision: int |
| resolution: _FloatType |
| smallest_subnormal: _FloatType |
| @property |
| def smallest_normal(self) -> _FloatType: ... |
| @property |
| def tiny(self) -> _FloatType: ... |
| @overload |
| def __new__( |
| cls, dtype: inexact[_NBit1] | _DTypeLike[inexact[_NBit1]] |
| ) -> finfo[floating[_NBit1]]: ... |
| @overload |
| def __new__( |
| cls, dtype: complex | float | type[complex] | type[float] |
| ) -> finfo[float_]: ... |
| @overload |
| def __new__( |
| cls, dtype: str |
| ) -> finfo[floating[Any]]: ... |
| |
| class iinfo(Generic[_IntType]): |
| dtype: dtype[_IntType] |
| kind: str |
| bits: int |
| key: str |
| @property |
| def min(self) -> int: ... |
| @property |
| def max(self) -> int: ... |
| |
| @overload |
| def __new__(cls, dtype: _IntType | _DTypeLike[_IntType]) -> iinfo[_IntType]: ... |
| @overload |
| def __new__(cls, dtype: int | type[int]) -> iinfo[int_]: ... |
| @overload |
| def __new__(cls, dtype: str) -> iinfo[Any]: ... |
| |
| class format_parser: |
| dtype: dtype[void] |
| def __init__( |
| self, |
| formats: DTypeLike, |
| names: None | str | Sequence[str], |
| titles: None | str | Sequence[str], |
| aligned: bool = ..., |
| byteorder: None | _ByteOrder = ..., |
| ) -> None: ... |
| |
| class recarray(ndarray[_ShapeType, _DType_co]): |
| # NOTE: While not strictly mandatory, we're demanding here that arguments |
| # for the `format_parser`- and `dtype`-based dtype constructors are |
| # mutually exclusive |
| @overload |
| def __new__( |
| subtype, |
| shape: _ShapeLike, |
| dtype: None = ..., |
| buf: None | _SupportsBuffer = ..., |
| offset: SupportsIndex = ..., |
| strides: None | _ShapeLike = ..., |
| *, |
| formats: DTypeLike, |
| names: None | str | Sequence[str] = ..., |
| titles: None | str | Sequence[str] = ..., |
| byteorder: None | _ByteOrder = ..., |
| aligned: bool = ..., |
| order: _OrderKACF = ..., |
| ) -> recarray[Any, dtype[record]]: ... |
| @overload |
| def __new__( |
| subtype, |
| shape: _ShapeLike, |
| dtype: DTypeLike, |
| buf: None | _SupportsBuffer = ..., |
| offset: SupportsIndex = ..., |
| strides: None | _ShapeLike = ..., |
| formats: None = ..., |
| names: None = ..., |
| titles: None = ..., |
| byteorder: None = ..., |
| aligned: L[False] = ..., |
| order: _OrderKACF = ..., |
| ) -> recarray[Any, dtype[Any]]: ... |
| def __array_finalize__(self, obj: object) -> None: ... |
| def __getattribute__(self, attr: str) -> Any: ... |
| def __setattr__(self, attr: str, val: ArrayLike) -> None: ... |
| @overload |
| def __getitem__(self, indx: ( |
| SupportsIndex |
| | _ArrayLikeInt_co |
| | tuple[SupportsIndex | _ArrayLikeInt_co, ...] |
| )) -> Any: ... |
| @overload |
| def __getitem__(self: recarray[Any, dtype[void]], indx: ( |
| None |
| | slice |
| | ellipsis |
| | SupportsIndex |
| | _ArrayLikeInt_co |
| | tuple[None | slice | ellipsis | _ArrayLikeInt_co | SupportsIndex, ...] |
| )) -> recarray[Any, _DType_co]: ... |
| @overload |
| def __getitem__(self, indx: ( |
| None |
| | slice |
| | ellipsis |
| | SupportsIndex |
| | _ArrayLikeInt_co |
| | tuple[None | slice | ellipsis | _ArrayLikeInt_co | SupportsIndex, ...] |
| )) -> ndarray[Any, _DType_co]: ... |
| @overload |
| def __getitem__(self, indx: str) -> NDArray[Any]: ... |
| @overload |
| def __getitem__(self, indx: list[str]) -> recarray[_ShapeType, dtype[record]]: ... |
| @overload |
| def field(self, attr: int | str, val: None = ...) -> Any: ... |
| @overload |
| def field(self, attr: int | str, val: ArrayLike) -> None: ... |
| |
| class record(void): |
| def __getattribute__(self, attr: str) -> Any: ... |
| def __setattr__(self, attr: str, val: ArrayLike) -> None: ... |
| def pprint(self) -> str: ... |
| @overload |
| def __getitem__(self, key: str | SupportsIndex) -> Any: ... |
| @overload |
| def __getitem__(self, key: list[str]) -> record: ... |
| |
| _NDIterFlagsKind = L[ |
| "buffered", |
| "c_index", |
| "copy_if_overlap", |
| "common_dtype", |
| "delay_bufalloc", |
| "external_loop", |
| "f_index", |
| "grow_inner", "growinner", |
| "multi_index", |
| "ranged", |
| "refs_ok", |
| "reduce_ok", |
| "zerosize_ok", |
| ] |
| |
| _NDIterOpFlagsKind = L[ |
| "aligned", |
| "allocate", |
| "arraymask", |
| "copy", |
| "config", |
| "nbo", |
| "no_subtype", |
| "no_broadcast", |
| "overlap_assume_elementwise", |
| "readonly", |
| "readwrite", |
| "updateifcopy", |
| "virtual", |
| "writeonly", |
| "writemasked" |
| ] |
| |
| @final |
| class nditer: |
| def __new__( |
| cls, |
| op: ArrayLike | Sequence[ArrayLike], |
| flags: None | Sequence[_NDIterFlagsKind] = ..., |
| op_flags: None | Sequence[Sequence[_NDIterOpFlagsKind]] = ..., |
| op_dtypes: DTypeLike | Sequence[DTypeLike] = ..., |
| order: _OrderKACF = ..., |
| casting: _CastingKind = ..., |
| op_axes: None | Sequence[Sequence[SupportsIndex]] = ..., |
| itershape: None | _ShapeLike = ..., |
| buffersize: SupportsIndex = ..., |
| ) -> nditer: ... |
| def __enter__(self) -> nditer: ... |
| def __exit__( |
| self, |
| exc_type: None | type[BaseException], |
| exc_value: None | BaseException, |
| traceback: None | TracebackType, |
| ) -> None: ... |
| def __iter__(self) -> nditer: ... |
| def __next__(self) -> tuple[NDArray[Any], ...]: ... |
| def __len__(self) -> int: ... |
| def __copy__(self) -> nditer: ... |
| @overload |
| def __getitem__(self, index: SupportsIndex) -> NDArray[Any]: ... |
| @overload |
| def __getitem__(self, index: slice) -> tuple[NDArray[Any], ...]: ... |
| def __setitem__(self, index: slice | SupportsIndex, value: ArrayLike) -> None: ... |
| def close(self) -> None: ... |
| def copy(self) -> nditer: ... |
| def debug_print(self) -> None: ... |
| def enable_external_loop(self) -> None: ... |
| def iternext(self) -> bool: ... |
| def remove_axis(self, i: SupportsIndex, /) -> None: ... |
| def remove_multi_index(self) -> None: ... |
| def reset(self) -> None: ... |
| @property |
| def dtypes(self) -> tuple[dtype[Any], ...]: ... |
| @property |
| def finished(self) -> bool: ... |
| @property |
| def has_delayed_bufalloc(self) -> bool: ... |
| @property |
| def has_index(self) -> bool: ... |
| @property |
| def has_multi_index(self) -> bool: ... |
| @property |
| def index(self) -> int: ... |
| @property |
| def iterationneedsapi(self) -> bool: ... |
| @property |
| def iterindex(self) -> int: ... |
| @property |
| def iterrange(self) -> tuple[int, ...]: ... |
| @property |
| def itersize(self) -> int: ... |
| @property |
| def itviews(self) -> tuple[NDArray[Any], ...]: ... |
| @property |
| def multi_index(self) -> tuple[int, ...]: ... |
| @property |
| def ndim(self) -> int: ... |
| @property |
| def nop(self) -> int: ... |
| @property |
| def operands(self) -> tuple[NDArray[Any], ...]: ... |
| @property |
| def shape(self) -> tuple[int, ...]: ... |
| @property |
| def value(self) -> tuple[NDArray[Any], ...]: ... |
| |
| _MemMapModeKind = L[ |
| "readonly", "r", |
| "copyonwrite", "c", |
| "readwrite", "r+", |
| "write", "w+", |
| ] |
| |
| class memmap(ndarray[_ShapeType, _DType_co]): |
| __array_priority__: ClassVar[float] |
| filename: str | None |
| offset: int |
| mode: str |
| @overload |
| def __new__( |
| subtype, |
| filename: str | bytes | os.PathLike[str] | os.PathLike[bytes] | _MemMapIOProtocol, |
| dtype: type[uint8] = ..., |
| mode: _MemMapModeKind = ..., |
| offset: int = ..., |
| shape: None | int | tuple[int, ...] = ..., |
| order: _OrderKACF = ..., |
| ) -> memmap[Any, dtype[uint8]]: ... |
| @overload |
| def __new__( |
| subtype, |
| filename: str | bytes | os.PathLike[str] | os.PathLike[bytes] | _MemMapIOProtocol, |
| dtype: _DTypeLike[_ScalarType], |
| mode: _MemMapModeKind = ..., |
| offset: int = ..., |
| shape: None | int | tuple[int, ...] = ..., |
| order: _OrderKACF = ..., |
| ) -> memmap[Any, dtype[_ScalarType]]: ... |
| @overload |
| def __new__( |
| subtype, |
| filename: str | bytes | os.PathLike[str] | os.PathLike[bytes] | _MemMapIOProtocol, |
| dtype: DTypeLike, |
| mode: _MemMapModeKind = ..., |
| offset: int = ..., |
| shape: None | int | tuple[int, ...] = ..., |
| order: _OrderKACF = ..., |
| ) -> memmap[Any, dtype[Any]]: ... |
| def __array_finalize__(self, obj: object) -> None: ... |
| def __array_wrap__( |
| self, |
| array: memmap[_ShapeType, _DType_co], |
| context: None | tuple[ufunc, tuple[Any, ...], int] = ..., |
| ) -> Any: ... |
| def flush(self) -> None: ... |
| |
| # TODO: Add a mypy plugin for managing functions whose output type is dependent |
| # on the literal value of some sort of signature (e.g. `einsum` and `vectorize`) |
| class vectorize: |
| pyfunc: Callable[..., Any] |
| cache: bool |
| signature: None | str |
| otypes: None | str |
| excluded: set[int | str] |
| __doc__: None | str |
| def __init__( |
| self, |
| pyfunc: Callable[..., Any], |
| otypes: None | str | Iterable[DTypeLike] = ..., |
| doc: None | str = ..., |
| excluded: None | Iterable[int | str] = ..., |
| cache: bool = ..., |
| signature: None | str = ..., |
| ) -> None: ... |
| def __call__(self, *args: Any, **kwargs: Any) -> Any: ... |
| |
| class poly1d: |
| @property |
| def variable(self) -> str: ... |
| @property |
| def order(self) -> int: ... |
| @property |
| def o(self) -> int: ... |
| @property |
| def roots(self) -> NDArray[Any]: ... |
| @property |
| def r(self) -> NDArray[Any]: ... |
| |
| @property |
| def coeffs(self) -> NDArray[Any]: ... |
| @coeffs.setter |
| def coeffs(self, value: NDArray[Any]) -> None: ... |
| |
| @property |
| def c(self) -> NDArray[Any]: ... |
| @c.setter |
| def c(self, value: NDArray[Any]) -> None: ... |
| |
| @property |
| def coef(self) -> NDArray[Any]: ... |
| @coef.setter |
| def coef(self, value: NDArray[Any]) -> None: ... |
| |
| @property |
| def coefficients(self) -> NDArray[Any]: ... |
| @coefficients.setter |
| def coefficients(self, value: NDArray[Any]) -> None: ... |
| |
| __hash__: ClassVar[None] # type: ignore |
| |
| @overload |
| def __array__(self, t: None = ...) -> NDArray[Any]: ... |
| @overload |
| def __array__(self, t: _DType) -> ndarray[Any, _DType]: ... |
| |
| @overload |
| def __call__(self, val: _ScalarLike_co) -> Any: ... |
| @overload |
| def __call__(self, val: poly1d) -> poly1d: ... |
| @overload |
| def __call__(self, val: ArrayLike) -> NDArray[Any]: ... |
| |
| def __init__( |
| self, |
| c_or_r: ArrayLike, |
| r: bool = ..., |
| variable: None | str = ..., |
| ) -> None: ... |
| def __len__(self) -> int: ... |
| def __neg__(self) -> poly1d: ... |
| def __pos__(self) -> poly1d: ... |
| def __mul__(self, other: ArrayLike) -> poly1d: ... |
| def __rmul__(self, other: ArrayLike) -> poly1d: ... |
| def __add__(self, other: ArrayLike) -> poly1d: ... |
| def __radd__(self, other: ArrayLike) -> poly1d: ... |
| def __pow__(self, val: _FloatLike_co) -> poly1d: ... # Integral floats are accepted |
| def __sub__(self, other: ArrayLike) -> poly1d: ... |
| def __rsub__(self, other: ArrayLike) -> poly1d: ... |
| def __div__(self, other: ArrayLike) -> poly1d: ... |
| def __truediv__(self, other: ArrayLike) -> poly1d: ... |
| def __rdiv__(self, other: ArrayLike) -> poly1d: ... |
| def __rtruediv__(self, other: ArrayLike) -> poly1d: ... |
| def __getitem__(self, val: int) -> Any: ... |
| def __setitem__(self, key: int, val: Any) -> None: ... |
| def __iter__(self) -> Iterator[Any]: ... |
| def deriv(self, m: SupportsInt | SupportsIndex = ...) -> poly1d: ... |
| def integ( |
| self, |
| m: SupportsInt | SupportsIndex = ..., |
| k: None | _ArrayLikeComplex_co | _ArrayLikeObject_co = ..., |
| ) -> poly1d: ... |
| |
| class matrix(ndarray[_ShapeType, _DType_co]): |
| __array_priority__: ClassVar[float] |
| def __new__( |
| subtype, |
| data: ArrayLike, |
| dtype: DTypeLike = ..., |
| copy: bool = ..., |
| ) -> matrix[Any, Any]: ... |
| def __array_finalize__(self, obj: object) -> None: ... |
| |
| @overload |
| def __getitem__(self, key: ( |
| SupportsIndex |
| | _ArrayLikeInt_co |
| | tuple[SupportsIndex | _ArrayLikeInt_co, ...] |
| )) -> Any: ... |
| @overload |
| def __getitem__(self, key: ( |
| None |
| | slice |
| | ellipsis |
| | SupportsIndex |
| | _ArrayLikeInt_co |
| | tuple[None | slice | ellipsis | _ArrayLikeInt_co | SupportsIndex, ...] |
| )) -> matrix[Any, _DType_co]: ... |
| @overload |
| def __getitem__(self: NDArray[void], key: str) -> matrix[Any, dtype[Any]]: ... |
| @overload |
| def __getitem__(self: NDArray[void], key: list[str]) -> matrix[_ShapeType, dtype[void]]: ... |
| |
| def __mul__(self, other: ArrayLike) -> matrix[Any, Any]: ... |
| def __rmul__(self, other: ArrayLike) -> matrix[Any, Any]: ... |
| def __imul__(self, other: ArrayLike) -> matrix[_ShapeType, _DType_co]: ... |
| def __pow__(self, other: ArrayLike) -> matrix[Any, Any]: ... |
| def __ipow__(self, other: ArrayLike) -> matrix[_ShapeType, _DType_co]: ... |
| |
| @overload |
| def sum(self, axis: None = ..., dtype: DTypeLike = ..., out: None = ...) -> Any: ... |
| @overload |
| def sum(self, axis: _ShapeLike, dtype: DTypeLike = ..., out: None = ...) -> matrix[Any, Any]: ... |
| @overload |
| def sum(self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... |
| |
| @overload |
| def mean(self, axis: None = ..., dtype: DTypeLike = ..., out: None = ...) -> Any: ... |
| @overload |
| def mean(self, axis: _ShapeLike, dtype: DTypeLike = ..., out: None = ...) -> matrix[Any, Any]: ... |
| @overload |
| def mean(self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... |
| |
| @overload |
| def std(self, axis: None = ..., dtype: DTypeLike = ..., out: None = ..., ddof: float = ...) -> Any: ... |
| @overload |
| def std(self, axis: _ShapeLike, dtype: DTypeLike = ..., out: None = ..., ddof: float = ...) -> matrix[Any, Any]: ... |
| @overload |
| def std(self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., ddof: float = ...) -> _NdArraySubClass: ... |
| |
| @overload |
| def var(self, axis: None = ..., dtype: DTypeLike = ..., out: None = ..., ddof: float = ...) -> Any: ... |
| @overload |
| def var(self, axis: _ShapeLike, dtype: DTypeLike = ..., out: None = ..., ddof: float = ...) -> matrix[Any, Any]: ... |
| @overload |
| def var(self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., ddof: float = ...) -> _NdArraySubClass: ... |
| |
| @overload |
| def prod(self, axis: None = ..., dtype: DTypeLike = ..., out: None = ...) -> Any: ... |
| @overload |
| def prod(self, axis: _ShapeLike, dtype: DTypeLike = ..., out: None = ...) -> matrix[Any, Any]: ... |
| @overload |
| def prod(self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... |
| |
| @overload |
| def any(self, axis: None = ..., out: None = ...) -> bool_: ... |
| @overload |
| def any(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, dtype[bool_]]: ... |
| @overload |
| def any(self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... |
| |
| @overload |
| def all(self, axis: None = ..., out: None = ...) -> bool_: ... |
| @overload |
| def all(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, dtype[bool_]]: ... |
| @overload |
| def all(self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... |
| |
| @overload |
| def max(self: NDArray[_ScalarType], axis: None = ..., out: None = ...) -> _ScalarType: ... |
| @overload |
| def max(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, _DType_co]: ... |
| @overload |
| def max(self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... |
| |
| @overload |
| def min(self: NDArray[_ScalarType], axis: None = ..., out: None = ...) -> _ScalarType: ... |
| @overload |
| def min(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, _DType_co]: ... |
| @overload |
| def min(self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... |
| |
| @overload |
| def argmax(self: NDArray[_ScalarType], axis: None = ..., out: None = ...) -> intp: ... |
| @overload |
| def argmax(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, dtype[intp]]: ... |
| @overload |
| def argmax(self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... |
| |
| @overload |
| def argmin(self: NDArray[_ScalarType], axis: None = ..., out: None = ...) -> intp: ... |
| @overload |
| def argmin(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, dtype[intp]]: ... |
| @overload |
| def argmin(self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... |
| |
| @overload |
| def ptp(self: NDArray[_ScalarType], axis: None = ..., out: None = ...) -> _ScalarType: ... |
| @overload |
| def ptp(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, _DType_co]: ... |
| @overload |
| def ptp(self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... |
| |
| def squeeze(self, axis: None | _ShapeLike = ...) -> matrix[Any, _DType_co]: ... |
| def tolist(self: matrix[Any, dtype[_SupportsItem[_T]]]) -> list[list[_T]]: ... # type: ignore[typevar] |
| def ravel(self, order: _OrderKACF = ...) -> matrix[Any, _DType_co]: ... |
| def flatten(self, order: _OrderKACF = ...) -> matrix[Any, _DType_co]: ... |
| |
| @property |
| def T(self) -> matrix[Any, _DType_co]: ... |
| @property |
| def I(self) -> matrix[Any, Any]: ... |
| @property |
| def A(self) -> ndarray[_ShapeType, _DType_co]: ... |
| @property |
| def A1(self) -> ndarray[Any, _DType_co]: ... |
| @property |
| def H(self) -> matrix[Any, _DType_co]: ... |
| def getT(self) -> matrix[Any, _DType_co]: ... |
| def getI(self) -> matrix[Any, Any]: ... |
| def getA(self) -> ndarray[_ShapeType, _DType_co]: ... |
| def getA1(self) -> ndarray[Any, _DType_co]: ... |
| def getH(self) -> matrix[Any, _DType_co]: ... |
| |
| _CharType = TypeVar("_CharType", str_, bytes_) |
| _CharDType = TypeVar("_CharDType", dtype[str_], dtype[bytes_]) |
| _CharArray = chararray[Any, dtype[_CharType]] |
| |
| class chararray(ndarray[_ShapeType, _CharDType]): |
| @overload |
| def __new__( |
| subtype, |
| shape: _ShapeLike, |
| itemsize: SupportsIndex | SupportsInt = ..., |
| unicode: L[False] = ..., |
| buffer: _SupportsBuffer = ..., |
| offset: SupportsIndex = ..., |
| strides: _ShapeLike = ..., |
| order: _OrderKACF = ..., |
| ) -> chararray[Any, dtype[bytes_]]: ... |
| @overload |
| def __new__( |
| subtype, |
| shape: _ShapeLike, |
| itemsize: SupportsIndex | SupportsInt = ..., |
| unicode: L[True] = ..., |
| buffer: _SupportsBuffer = ..., |
| offset: SupportsIndex = ..., |
| strides: _ShapeLike = ..., |
| order: _OrderKACF = ..., |
| ) -> chararray[Any, dtype[str_]]: ... |
| |
| def __array_finalize__(self, obj: object) -> None: ... |
| def __mul__(self, other: _ArrayLikeInt_co) -> chararray[Any, _CharDType]: ... |
| def __rmul__(self, other: _ArrayLikeInt_co) -> chararray[Any, _CharDType]: ... |
| def __mod__(self, i: Any) -> chararray[Any, _CharDType]: ... |
| |
| @overload |
| def __eq__( |
| self: _CharArray[str_], |
| other: _ArrayLikeStr_co, |
| ) -> NDArray[bool_]: ... |
| @overload |
| def __eq__( |
| self: _CharArray[bytes_], |
| other: _ArrayLikeBytes_co, |
| ) -> NDArray[bool_]: ... |
| |
| @overload |
| def __ne__( |
| self: _CharArray[str_], |
| other: _ArrayLikeStr_co, |
| ) -> NDArray[bool_]: ... |
| @overload |
| def __ne__( |
| self: _CharArray[bytes_], |
| other: _ArrayLikeBytes_co, |
| ) -> NDArray[bool_]: ... |
| |
| @overload |
| def __ge__( |
| self: _CharArray[str_], |
| other: _ArrayLikeStr_co, |
| ) -> NDArray[bool_]: ... |
| @overload |
| def __ge__( |
| self: _CharArray[bytes_], |
| other: _ArrayLikeBytes_co, |
| ) -> NDArray[bool_]: ... |
| |
| @overload |
| def __le__( |
| self: _CharArray[str_], |
| other: _ArrayLikeStr_co, |
| ) -> NDArray[bool_]: ... |
| @overload |
| def __le__( |
| self: _CharArray[bytes_], |
| other: _ArrayLikeBytes_co, |
| ) -> NDArray[bool_]: ... |
| |
| @overload |
| def __gt__( |
| self: _CharArray[str_], |
| other: _ArrayLikeStr_co, |
| ) -> NDArray[bool_]: ... |
| @overload |
| def __gt__( |
| self: _CharArray[bytes_], |
| other: _ArrayLikeBytes_co, |
| ) -> NDArray[bool_]: ... |
| |
| @overload |
| def __lt__( |
| self: _CharArray[str_], |
| other: _ArrayLikeStr_co, |
| ) -> NDArray[bool_]: ... |
| @overload |
| def __lt__( |
| self: _CharArray[bytes_], |
| other: _ArrayLikeBytes_co, |
| ) -> NDArray[bool_]: ... |
| |
| @overload |
| def __add__( |
| self: _CharArray[str_], |
| other: _ArrayLikeStr_co, |
| ) -> _CharArray[str_]: ... |
| @overload |
| def __add__( |
| self: _CharArray[bytes_], |
| other: _ArrayLikeBytes_co, |
| ) -> _CharArray[bytes_]: ... |
| |
| @overload |
| def __radd__( |
| self: _CharArray[str_], |
| other: _ArrayLikeStr_co, |
| ) -> _CharArray[str_]: ... |
| @overload |
| def __radd__( |
| self: _CharArray[bytes_], |
| other: _ArrayLikeBytes_co, |
| ) -> _CharArray[bytes_]: ... |
| |
| @overload |
| def center( |
| self: _CharArray[str_], |
| width: _ArrayLikeInt_co, |
| fillchar: _ArrayLikeStr_co = ..., |
| ) -> _CharArray[str_]: ... |
| @overload |
| def center( |
| self: _CharArray[bytes_], |
| width: _ArrayLikeInt_co, |
| fillchar: _ArrayLikeBytes_co = ..., |
| ) -> _CharArray[bytes_]: ... |
| |
| @overload |
| def count( |
| self: _CharArray[str_], |
| sub: _ArrayLikeStr_co, |
| start: _ArrayLikeInt_co = ..., |
| end: None | _ArrayLikeInt_co = ..., |
| ) -> NDArray[int_]: ... |
| @overload |
| def count( |
| self: _CharArray[bytes_], |
| sub: _ArrayLikeBytes_co, |
| start: _ArrayLikeInt_co = ..., |
| end: None | _ArrayLikeInt_co = ..., |
| ) -> NDArray[int_]: ... |
| |
| def decode( |
| self: _CharArray[bytes_], |
| encoding: None | str = ..., |
| errors: None | str = ..., |
| ) -> _CharArray[str_]: ... |
| |
| def encode( |
| self: _CharArray[str_], |
| encoding: None | str = ..., |
| errors: None | str = ..., |
| ) -> _CharArray[bytes_]: ... |
| |
| @overload |
| def endswith( |
| self: _CharArray[str_], |
| suffix: _ArrayLikeStr_co, |
| start: _ArrayLikeInt_co = ..., |
| end: None | _ArrayLikeInt_co = ..., |
| ) -> NDArray[bool_]: ... |
| @overload |
| def endswith( |
| self: _CharArray[bytes_], |
| suffix: _ArrayLikeBytes_co, |
| start: _ArrayLikeInt_co = ..., |
| end: None | _ArrayLikeInt_co = ..., |
| ) -> NDArray[bool_]: ... |
| |
| def expandtabs( |
| self, |
| tabsize: _ArrayLikeInt_co = ..., |
| ) -> chararray[Any, _CharDType]: ... |
| |
| @overload |
| def find( |
| self: _CharArray[str_], |
| sub: _ArrayLikeStr_co, |
| start: _ArrayLikeInt_co = ..., |
| end: None | _ArrayLikeInt_co = ..., |
| ) -> NDArray[int_]: ... |
| @overload |
| def find( |
| self: _CharArray[bytes_], |
| sub: _ArrayLikeBytes_co, |
| start: _ArrayLikeInt_co = ..., |
| end: None | _ArrayLikeInt_co = ..., |
| ) -> NDArray[int_]: ... |
| |
| @overload |
| def index( |
| self: _CharArray[str_], |
| sub: _ArrayLikeStr_co, |
| start: _ArrayLikeInt_co = ..., |
| end: None | _ArrayLikeInt_co = ..., |
| ) -> NDArray[int_]: ... |
| @overload |
| def index( |
| self: _CharArray[bytes_], |
| sub: _ArrayLikeBytes_co, |
| start: _ArrayLikeInt_co = ..., |
| end: None | _ArrayLikeInt_co = ..., |
| ) -> NDArray[int_]: ... |
| |
| @overload |
| def join( |
| self: _CharArray[str_], |
| seq: _ArrayLikeStr_co, |
| ) -> _CharArray[str_]: ... |
| @overload |
| def join( |
| self: _CharArray[bytes_], |
| seq: _ArrayLikeBytes_co, |
| ) -> _CharArray[bytes_]: ... |
| |
| @overload |
| def ljust( |
| self: _CharArray[str_], |
| width: _ArrayLikeInt_co, |
| fillchar: _ArrayLikeStr_co = ..., |
| ) -> _CharArray[str_]: ... |
| @overload |
| def ljust( |
| self: _CharArray[bytes_], |
| width: _ArrayLikeInt_co, |
| fillchar: _ArrayLikeBytes_co = ..., |
| ) -> _CharArray[bytes_]: ... |
| |
| @overload |
| def lstrip( |
| self: _CharArray[str_], |
| chars: None | _ArrayLikeStr_co = ..., |
| ) -> _CharArray[str_]: ... |
| @overload |
| def lstrip( |
| self: _CharArray[bytes_], |
| chars: None | _ArrayLikeBytes_co = ..., |
| ) -> _CharArray[bytes_]: ... |
| |
| @overload |
| def partition( |
| self: _CharArray[str_], |
| sep: _ArrayLikeStr_co, |
| ) -> _CharArray[str_]: ... |
| @overload |
| def partition( |
| self: _CharArray[bytes_], |
| sep: _ArrayLikeBytes_co, |
| ) -> _CharArray[bytes_]: ... |
| |
| @overload |
| def replace( |
| self: _CharArray[str_], |
| old: _ArrayLikeStr_co, |
| new: _ArrayLikeStr_co, |
| count: None | _ArrayLikeInt_co = ..., |
| ) -> _CharArray[str_]: ... |
| @overload |
| def replace( |
| self: _CharArray[bytes_], |
| old: _ArrayLikeBytes_co, |
| new: _ArrayLikeBytes_co, |
| count: None | _ArrayLikeInt_co = ..., |
| ) -> _CharArray[bytes_]: ... |
| |
| @overload |
| def rfind( |
| self: _CharArray[str_], |
| sub: _ArrayLikeStr_co, |
| start: _ArrayLikeInt_co = ..., |
| end: None | _ArrayLikeInt_co = ..., |
| ) -> NDArray[int_]: ... |
| @overload |
| def rfind( |
| self: _CharArray[bytes_], |
| sub: _ArrayLikeBytes_co, |
| start: _ArrayLikeInt_co = ..., |
| end: None | _ArrayLikeInt_co = ..., |
| ) -> NDArray[int_]: ... |
| |
| @overload |
| def rindex( |
| self: _CharArray[str_], |
| sub: _ArrayLikeStr_co, |
| start: _ArrayLikeInt_co = ..., |
| end: None | _ArrayLikeInt_co = ..., |
| ) -> NDArray[int_]: ... |
| @overload |
| def rindex( |
| self: _CharArray[bytes_], |
| sub: _ArrayLikeBytes_co, |
| start: _ArrayLikeInt_co = ..., |
| end: None | _ArrayLikeInt_co = ..., |
| ) -> NDArray[int_]: ... |
| |
| @overload |
| def rjust( |
| self: _CharArray[str_], |
| width: _ArrayLikeInt_co, |
| fillchar: _ArrayLikeStr_co = ..., |
| ) -> _CharArray[str_]: ... |
| @overload |
| def rjust( |
| self: _CharArray[bytes_], |
| width: _ArrayLikeInt_co, |
| fillchar: _ArrayLikeBytes_co = ..., |
| ) -> _CharArray[bytes_]: ... |
| |
| @overload |
| def rpartition( |
| self: _CharArray[str_], |
| sep: _ArrayLikeStr_co, |
| ) -> _CharArray[str_]: ... |
| @overload |
| def rpartition( |
| self: _CharArray[bytes_], |
| sep: _ArrayLikeBytes_co, |
| ) -> _CharArray[bytes_]: ... |
| |
| @overload |
| def rsplit( |
| self: _CharArray[str_], |
| sep: None | _ArrayLikeStr_co = ..., |
| maxsplit: None | _ArrayLikeInt_co = ..., |
| ) -> NDArray[object_]: ... |
| @overload |
| def rsplit( |
| self: _CharArray[bytes_], |
| sep: None | _ArrayLikeBytes_co = ..., |
| maxsplit: None | _ArrayLikeInt_co = ..., |
| ) -> NDArray[object_]: ... |
| |
| @overload |
| def rstrip( |
| self: _CharArray[str_], |
| chars: None | _ArrayLikeStr_co = ..., |
| ) -> _CharArray[str_]: ... |
| @overload |
| def rstrip( |
| self: _CharArray[bytes_], |
| chars: None | _ArrayLikeBytes_co = ..., |
| ) -> _CharArray[bytes_]: ... |
| |
| @overload |
| def split( |
| self: _CharArray[str_], |
| sep: None | _ArrayLikeStr_co = ..., |
| maxsplit: None | _ArrayLikeInt_co = ..., |
| ) -> NDArray[object_]: ... |
| @overload |
| def split( |
| self: _CharArray[bytes_], |
| sep: None | _ArrayLikeBytes_co = ..., |
| maxsplit: None | _ArrayLikeInt_co = ..., |
| ) -> NDArray[object_]: ... |
| |
| def splitlines(self, keepends: None | _ArrayLikeBool_co = ...) -> NDArray[object_]: ... |
| |
| @overload |
| def startswith( |
| self: _CharArray[str_], |
| prefix: _ArrayLikeStr_co, |
| start: _ArrayLikeInt_co = ..., |
| end: None | _ArrayLikeInt_co = ..., |
| ) -> NDArray[bool_]: ... |
| @overload |
| def startswith( |
| self: _CharArray[bytes_], |
| prefix: _ArrayLikeBytes_co, |
| start: _ArrayLikeInt_co = ..., |
| end: None | _ArrayLikeInt_co = ..., |
| ) -> NDArray[bool_]: ... |
| |
| @overload |
| def strip( |
| self: _CharArray[str_], |
| chars: None | _ArrayLikeStr_co = ..., |
| ) -> _CharArray[str_]: ... |
| @overload |
| def strip( |
| self: _CharArray[bytes_], |
| chars: None | _ArrayLikeBytes_co = ..., |
| ) -> _CharArray[bytes_]: ... |
| |
| @overload |
| def translate( |
| self: _CharArray[str_], |
| table: _ArrayLikeStr_co, |
| deletechars: None | _ArrayLikeStr_co = ..., |
| ) -> _CharArray[str_]: ... |
| @overload |
| def translate( |
| self: _CharArray[bytes_], |
| table: _ArrayLikeBytes_co, |
| deletechars: None | _ArrayLikeBytes_co = ..., |
| ) -> _CharArray[bytes_]: ... |
| |
| def zfill(self, width: _ArrayLikeInt_co) -> chararray[Any, _CharDType]: ... |
| def capitalize(self) -> chararray[_ShapeType, _CharDType]: ... |
| def title(self) -> chararray[_ShapeType, _CharDType]: ... |
| def swapcase(self) -> chararray[_ShapeType, _CharDType]: ... |
| def lower(self) -> chararray[_ShapeType, _CharDType]: ... |
| def upper(self) -> chararray[_ShapeType, _CharDType]: ... |
| def isalnum(self) -> ndarray[_ShapeType, dtype[bool_]]: ... |
| def isalpha(self) -> ndarray[_ShapeType, dtype[bool_]]: ... |
| def isdigit(self) -> ndarray[_ShapeType, dtype[bool_]]: ... |
| def islower(self) -> ndarray[_ShapeType, dtype[bool_]]: ... |
| def isspace(self) -> ndarray[_ShapeType, dtype[bool_]]: ... |
| def istitle(self) -> ndarray[_ShapeType, dtype[bool_]]: ... |
| def isupper(self) -> ndarray[_ShapeType, dtype[bool_]]: ... |
| def isnumeric(self) -> ndarray[_ShapeType, dtype[bool_]]: ... |
| def isdecimal(self) -> ndarray[_ShapeType, dtype[bool_]]: ... |
| |
| # NOTE: Deprecated |
| # class MachAr: ... |
| |
| class _SupportsDLPack(Protocol[_T_contra]): |
| def __dlpack__(self, *, stream: None | _T_contra = ...) -> _PyCapsule: ... |
| |
| def from_dlpack(obj: _SupportsDLPack[None], /) -> NDArray[Any]: ... |
