Buckets:
| # ruff: noqa: I001 | |
| import builtins | |
| import sys | |
| import mmap | |
| import ctypes as ct | |
| import array as _array | |
| import datetime as dt | |
| import inspect | |
| from abc import abstractmethod | |
| from types import EllipsisType, ModuleType, TracebackType, MappingProxyType, GenericAlias | |
| from decimal import Decimal | |
| from fractions import Fraction | |
| from uuid import UUID | |
| import numpy as np | |
| from numpy.__config__ import show as show_config | |
| from numpy._pytesttester import PytestTester | |
| from numpy._core._internal import _ctypes | |
| from numpy._typing import ( # type: ignore[deprecated] | |
| # Arrays | |
| ArrayLike, | |
| NDArray, | |
| _SupportsArray, | |
| _NestedSequence, | |
| _ArrayLike, | |
| _ArrayLikeBool_co, | |
| _ArrayLikeUInt_co, | |
| _ArrayLikeInt, | |
| _ArrayLikeInt_co, | |
| _ArrayLikeFloat64_co, | |
| _ArrayLikeFloat_co, | |
| _ArrayLikeComplex128_co, | |
| _ArrayLikeComplex_co, | |
| _ArrayLikeNumber_co, | |
| _ArrayLikeObject_co, | |
| _ArrayLikeBytes_co, | |
| _ArrayLikeStr_co, | |
| _ArrayLikeString_co, | |
| _ArrayLikeTD64_co, | |
| _ArrayLikeDT64_co, | |
| # DTypes | |
| DTypeLike, | |
| _DTypeLike, | |
| _DTypeLikeVoid, | |
| _VoidDTypeLike, | |
| # Shapes | |
| _AnyShape, | |
| _Shape, | |
| _ShapeLike, | |
| # Scalars | |
| _CharLike_co, | |
| _IntLike_co, | |
| _FloatLike_co, | |
| _TD64Like_co, | |
| _NumberLike_co, | |
| _ScalarLike_co, | |
| # `number` precision | |
| NBitBase, | |
| # NOTE: Do not remove the extended precision bit-types even if seemingly unused; | |
| # they're used by the mypy plugin | |
| _128Bit, | |
| _96Bit, | |
| _64Bit, | |
| _32Bit, | |
| _16Bit, | |
| _8Bit, | |
| _NBitByte, | |
| _NBitShort, | |
| _NBitIntC, | |
| _NBitIntP, | |
| _NBitLong, | |
| _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, | |
| _LongCodes, | |
| _LongLongCodes, | |
| _UByteCodes, | |
| _UShortCodes, | |
| _UIntCCodes, | |
| _UIntPCodes, | |
| _ULongCodes, | |
| _ULongLongCodes, | |
| _HalfCodes, | |
| _SingleCodes, | |
| _DoubleCodes, | |
| _LongDoubleCodes, | |
| _CSingleCodes, | |
| _CDoubleCodes, | |
| _CLongDoubleCodes, | |
| _DT64Codes, | |
| _TD64Codes, | |
| _StrCodes, | |
| _BytesCodes, | |
| _VoidCodes, | |
| _ObjectCodes, | |
| _StringCodes, | |
| _UnsignedIntegerCodes, | |
| _SignedIntegerCodes, | |
| _IntegerCodes, | |
| _FloatingCodes, | |
| _ComplexFloatingCodes, | |
| _InexactCodes, | |
| _CharacterCodes, | |
| # Ufuncs | |
| _UFunc_Nin1_Nout1, | |
| _UFunc_Nin2_Nout1, | |
| _UFunc_Nin1_Nout2, | |
| _UFunc_Nin2_Nout2, | |
| _GUFunc_Nin2_Nout1, | |
| ) | |
| # NOTE: Numpy's mypy plugin is used for removing the types unavailable to the specific platform | |
| from numpy._typing._extended_precision import ( | |
| float96, | |
| float128, | |
| complex192, | |
| complex256, | |
| ) | |
| from numpy._array_api_info import __array_namespace_info__ | |
| from collections.abc import ( | |
| Callable, | |
| Iterable, | |
| Iterator, | |
| Mapping, | |
| Sequence, | |
| ) | |
| if sys.version_info >= (3, 12): | |
| from collections.abc import Buffer as _SupportsBuffer | |
| else: | |
| _SupportsBuffer: TypeAlias = ( | |
| bytes | |
| | bytearray | |
| | memoryview | |
| | _array.array[Any] | |
| | mmap.mmap | |
| | NDArray[Any] | |
| | generic | |
| ) | |
| from typing import ( | |
| Any, | |
| ClassVar, | |
| Final, | |
| Generic, | |
| Literal as L, | |
| LiteralString, | |
| Never, | |
| NoReturn, | |
| Protocol, | |
| Self, | |
| SupportsComplex, | |
| SupportsFloat, | |
| SupportsInt, | |
| SupportsIndex, | |
| TypeAlias, | |
| TypedDict, | |
| final, | |
| overload, | |
| type_check_only, | |
| ) | |
| # NOTE: `typing_extensions` and `_typeshed` are always available in `.pyi` stubs, even | |
| # if not available at runtime. This is because the `typeshed` stubs for the standard | |
| # library include `typing_extensions` stubs: | |
| # https://github.com/python/typeshed/blob/main/stdlib/typing_extensions.pyi | |
| from _typeshed import Incomplete, StrOrBytesPath, SupportsFlush, SupportsLenAndGetItem, SupportsWrite | |
| from typing_extensions import CapsuleType, TypeVar, deprecated, override | |
| from numpy import ( | |
| char, | |
| core, | |
| ctypeslib, | |
| dtypes, | |
| exceptions, | |
| f2py, | |
| fft, | |
| lib, | |
| linalg, | |
| ma, | |
| polynomial, | |
| random, | |
| rec, | |
| strings, | |
| testing, | |
| typing, | |
| ) | |
| # available through `__getattr__`, but not in `__all__` or `__dir__` | |
| from numpy import ( | |
| __config__ as __config__, | |
| matlib as matlib, | |
| matrixlib as matrixlib, | |
| version as version, | |
| ) | |
| if sys.version_info < (3, 12): | |
| from numpy import distutils as distutils | |
| from numpy._core.records import ( | |
| record, | |
| recarray, | |
| ) | |
| from numpy._core.function_base import ( | |
| linspace, | |
| logspace, | |
| geomspace, | |
| ) | |
| from numpy._core.fromnumeric import ( | |
| take, | |
| reshape, | |
| choose, | |
| repeat, | |
| put, | |
| swapaxes, | |
| transpose, | |
| matrix_transpose, | |
| partition, | |
| argpartition, | |
| sort, | |
| argsort, | |
| argmax, | |
| argmin, | |
| searchsorted, | |
| resize, | |
| squeeze, | |
| diagonal, | |
| trace, | |
| ravel, | |
| nonzero, | |
| shape, | |
| compress, | |
| clip, | |
| sum, | |
| all, | |
| any, | |
| cumsum, | |
| cumulative_sum, | |
| ptp, | |
| max, | |
| min, | |
| amax, | |
| amin, | |
| prod, | |
| cumprod, | |
| cumulative_prod, | |
| ndim, | |
| size, | |
| around, | |
| round, | |
| mean, | |
| std, | |
| var, | |
| ) | |
| from numpy._core._asarray import ( | |
| require, | |
| ) | |
| from numpy._core._type_aliases import ( | |
| sctypeDict, | |
| ) | |
| from numpy._core._ufunc_config import ( | |
| seterr, | |
| geterr, | |
| setbufsize, | |
| getbufsize, | |
| seterrcall, | |
| geterrcall, | |
| errstate, | |
| ) | |
| from numpy._core.arrayprint import ( | |
| set_printoptions, | |
| get_printoptions, | |
| array2string, | |
| format_float_scientific, | |
| format_float_positional, | |
| array_repr, | |
| array_str, | |
| printoptions, | |
| ) | |
| from numpy._core.einsumfunc import ( | |
| einsum, | |
| einsum_path, | |
| ) | |
| from numpy._core.getlimits import ( | |
| finfo, | |
| iinfo, | |
| ) | |
| from numpy._core.multiarray import ( | |
| array, | |
| empty_like, | |
| empty, | |
| zeros, | |
| concatenate, | |
| inner, | |
| where, | |
| lexsort, | |
| can_cast, | |
| min_scalar_type, | |
| result_type, | |
| dot, | |
| vdot, | |
| bincount, | |
| copyto, | |
| putmask, | |
| packbits, | |
| unpackbits, | |
| shares_memory, | |
| may_share_memory, | |
| asarray, | |
| asanyarray, | |
| ascontiguousarray, | |
| asfortranarray, | |
| arange, | |
| busday_count, | |
| busday_offset, | |
| datetime_as_string, | |
| datetime_data, | |
| frombuffer, | |
| fromfile, | |
| fromiter, | |
| is_busday, | |
| promote_types, | |
| fromstring, | |
| frompyfunc, | |
| nested_iters, | |
| flagsobj, | |
| ) | |
| from numpy._core.numeric import ( | |
| zeros_like, | |
| ones, | |
| ones_like, | |
| full, | |
| full_like, | |
| count_nonzero, | |
| isfortran, | |
| argwhere, | |
| flatnonzero, | |
| correlate, | |
| convolve, | |
| outer, | |
| tensordot, | |
| roll, | |
| rollaxis, | |
| moveaxis, | |
| cross, | |
| indices, | |
| fromfunction, | |
| isscalar, | |
| binary_repr, | |
| base_repr, | |
| identity, | |
| allclose, | |
| isclose, | |
| array_equal, | |
| array_equiv, | |
| astype, | |
| ) | |
| from numpy._core.numerictypes import ( | |
| isdtype, | |
| issubdtype, | |
| ScalarType, | |
| typecodes, | |
| ) | |
| from numpy._core.shape_base import ( | |
| atleast_1d, | |
| atleast_2d, | |
| atleast_3d, | |
| block, | |
| hstack, | |
| stack, | |
| vstack, | |
| unstack, | |
| ) | |
| from ._expired_attrs_2_0 import __expired_attributes__ as __expired_attributes__ | |
| from ._globals import _CopyMode as _CopyMode | |
| from ._globals import _NoValue as _NoValue, _NoValueType | |
| from numpy.lib import ( | |
| scimath as emath, | |
| ) | |
| from numpy.lib._arraypad_impl import ( | |
| pad, | |
| ) | |
| from numpy.lib._arraysetops_impl import ( | |
| ediff1d, | |
| intersect1d, | |
| isin, | |
| setdiff1d, | |
| setxor1d, | |
| union1d, | |
| unique, | |
| unique_all, | |
| unique_counts, | |
| unique_inverse, | |
| unique_values, | |
| ) | |
| from numpy.lib._function_base_impl import ( # type: ignore[deprecated] | |
| select, | |
| piecewise, | |
| trim_zeros, | |
| copy, | |
| iterable, | |
| percentile, | |
| diff, | |
| gradient, | |
| angle, | |
| unwrap, | |
| sort_complex, | |
| flip, | |
| rot90, | |
| extract, | |
| place, | |
| asarray_chkfinite, | |
| average, | |
| digitize, | |
| cov, | |
| corrcoef, | |
| median, | |
| sinc, | |
| hamming, | |
| hanning, | |
| bartlett, | |
| blackman, | |
| kaiser, | |
| trapezoid, | |
| i0, | |
| meshgrid, | |
| delete, | |
| insert, | |
| append, | |
| interp, | |
| quantile, | |
| vectorize, | |
| ) | |
| from numpy.lib._histograms_impl import ( | |
| histogram_bin_edges, | |
| histogram, | |
| histogramdd, | |
| ) | |
| from numpy.lib._index_tricks_impl import ( | |
| ndenumerate, | |
| ndindex, | |
| ravel_multi_index, | |
| unravel_index, | |
| mgrid, | |
| ogrid, | |
| r_, | |
| c_, | |
| s_, | |
| index_exp, | |
| ix_, | |
| fill_diagonal, | |
| diag_indices, | |
| diag_indices_from, | |
| ) | |
| from numpy.lib._nanfunctions_impl import ( | |
| nansum, | |
| nanmax, | |
| nanmin, | |
| nanargmax, | |
| nanargmin, | |
| nanmean, | |
| nanmedian, | |
| nanpercentile, | |
| nanvar, | |
| nanstd, | |
| nanprod, | |
| nancumsum, | |
| nancumprod, | |
| nanquantile, | |
| ) | |
| from numpy.lib._npyio_impl import ( | |
| savetxt, | |
| loadtxt, | |
| genfromtxt, | |
| load, | |
| save, | |
| savez, | |
| savez_compressed, | |
| fromregex, | |
| ) | |
| from numpy.lib._polynomial_impl import ( | |
| poly, | |
| roots, | |
| polyint, | |
| polyder, | |
| polyadd, | |
| polysub, | |
| polymul, | |
| polydiv, | |
| polyval, | |
| polyfit, | |
| ) | |
| from numpy.lib._shape_base_impl import ( # type: ignore[deprecated] | |
| column_stack, | |
| row_stack, | |
| dstack, | |
| array_split, | |
| split, | |
| hsplit, | |
| vsplit, | |
| dsplit, | |
| apply_over_axes, | |
| expand_dims, | |
| apply_along_axis, | |
| kron, | |
| tile, | |
| take_along_axis, | |
| put_along_axis, | |
| ) | |
| from numpy.lib._stride_tricks_impl import ( | |
| broadcast_to, | |
| broadcast_arrays, | |
| broadcast_shapes, | |
| ) | |
| from numpy.lib._twodim_base_impl import ( | |
| diag, | |
| diagflat, | |
| eye, | |
| fliplr, | |
| flipud, | |
| tri, | |
| triu, | |
| tril, | |
| vander, | |
| histogram2d, | |
| mask_indices, | |
| tril_indices, | |
| tril_indices_from, | |
| triu_indices, | |
| triu_indices_from, | |
| ) | |
| from numpy.lib._type_check_impl import ( | |
| mintypecode, | |
| real, | |
| imag, | |
| iscomplex, | |
| isreal, | |
| iscomplexobj, | |
| isrealobj, | |
| nan_to_num, | |
| real_if_close, | |
| typename, | |
| common_type, | |
| ) | |
| from numpy.lib._ufunclike_impl import ( | |
| fix, | |
| isposinf, | |
| isneginf, | |
| ) | |
| from numpy.lib._utils_impl import ( | |
| get_include, | |
| info, | |
| show_runtime, | |
| ) | |
| from numpy.matrixlib import ( | |
| asmatrix, | |
| bmat, | |
| matrix, | |
| ) | |
| __all__ = [ # noqa: RUF022 | |
| # __numpy_submodules__ | |
| "char", "core", "ctypeslib", "dtypes", "exceptions", "f2py", "fft", "lib", "linalg", | |
| "ma", "polynomial", "random", "rec", "strings", "test", "testing", "typing", | |
| # _core.__all__ | |
| "abs", "acos", "acosh", "asin", "asinh", "atan", "atanh", "atan2", "bitwise_invert", | |
| "bitwise_left_shift", "bitwise_right_shift", "concat", "pow", "permute_dims", | |
| "memmap", "sctypeDict", "record", "recarray", | |
| # _core.numeric.__all__ | |
| "newaxis", "ndarray", "flatiter", "nditer", "nested_iters", "ufunc", "arange", | |
| "array", "asarray", "asanyarray", "ascontiguousarray", "asfortranarray", "zeros", | |
| "count_nonzero", "empty", "broadcast", "dtype", "fromstring", "fromfile", | |
| "frombuffer", "from_dlpack", "where", "argwhere", "copyto", "concatenate", | |
| "lexsort", "astype", "can_cast", "promote_types", "min_scalar_type", "result_type", | |
| "isfortran", "empty_like", "zeros_like", "ones_like", "correlate", "convolve", | |
| "inner", "dot", "outer", "vdot", "roll", "rollaxis", "moveaxis", "cross", | |
| "tensordot", "little_endian", "fromiter", "array_equal", "array_equiv", "indices", | |
| "fromfunction", "isclose", "isscalar", "binary_repr", "base_repr", "ones", | |
| "identity", "allclose", "putmask", "flatnonzero", "inf", "nan", "False_", "True_", | |
| "bitwise_not", "full", "full_like", "matmul", "vecdot", "vecmat", | |
| "shares_memory", "may_share_memory", | |
| "all", "amax", "amin", "any", "argmax", "argmin", "argpartition", "argsort", | |
| "around", "choose", "clip", "compress", "cumprod", "cumsum", "cumulative_prod", | |
| "cumulative_sum", "diagonal", "mean", "max", "min", "matrix_transpose", "ndim", | |
| "nonzero", "partition", "prod", "ptp", "put", "ravel", "repeat", "reshape", | |
| "resize", "round", "searchsorted", "shape", "size", "sort", "squeeze", "std", "sum", | |
| "swapaxes", "take", "trace", "transpose", "var", | |
| "absolute", "add", "arccos", "arccosh", "arcsin", "arcsinh", "arctan", "arctan2", | |
| "arctanh", "bitwise_and", "bitwise_or", "bitwise_xor", "cbrt", "ceil", "conj", | |
| "conjugate", "copysign", "cos", "cosh", "bitwise_count", "deg2rad", "degrees", | |
| "divide", "divmod", "e", "equal", "euler_gamma", "exp", "exp2", "expm1", "fabs", | |
| "floor", "floor_divide", "float_power", "fmax", "fmin", "fmod", "frexp", | |
| "frompyfunc", "gcd", "greater", "greater_equal", "heaviside", "hypot", "invert", | |
| "isfinite", "isinf", "isnan", "isnat", "lcm", "ldexp", "left_shift", "less", | |
| "less_equal", "log", "log10", "log1p", "log2", "logaddexp", "logaddexp2", | |
| "logical_and", "logical_not", "logical_or", "logical_xor", "matvec", "maximum", "minimum", | |
| "mod", "modf", "multiply", "negative", "nextafter", "not_equal", "pi", "positive", | |
| "power", "rad2deg", "radians", "reciprocal", "remainder", "right_shift", "rint", | |
| "sign", "signbit", "sin", "sinh", "spacing", "sqrt", "square", "subtract", "tan", | |
| "tanh", "true_divide", "trunc", "ScalarType", "typecodes", "issubdtype", | |
| "datetime_data", "datetime_as_string", "busday_offset", "busday_count", "is_busday", | |
| "busdaycalendar", "isdtype", | |
| "complexfloating", "character", "unsignedinteger", "inexact", "generic", "floating", | |
| "integer", "signedinteger", "number", "flexible", "bool", "float16", "float32", | |
| "float64", "longdouble", "complex64", "complex128", "clongdouble", | |
| "bytes_", "str_", "void", "object_", "datetime64", "timedelta64", "int8", "byte", | |
| "uint8", "ubyte", "int16", "short", "uint16", "ushort", "int32", "intc", "uint32", | |
| "uintc", "int64", "long", "uint64", "ulong", "longlong", "ulonglong", "intp", | |
| "uintp", "double", "cdouble", "single", "csingle", "half", "bool_", "int_", "uint", | |
| "float96", "float128", "complex192", "complex256", | |
| "array2string", "array_str", "array_repr", "set_printoptions", "get_printoptions", | |
| "printoptions", "format_float_positional", "format_float_scientific", "require", | |
| "seterr", "geterr", "setbufsize", "getbufsize", "seterrcall", "geterrcall", | |
| "errstate", | |
| # _core.function_base.__all__ | |
| "logspace", "linspace", "geomspace", | |
| # _core.getlimits.__all__ | |
| "finfo", "iinfo", | |
| # _core.shape_base.__all__ | |
| "atleast_1d", "atleast_2d", "atleast_3d", "block", "hstack", "stack", "unstack", | |
| "vstack", | |
| # _core.einsumfunc.__all__ | |
| "einsum", "einsum_path", | |
| # matrixlib.__all__ | |
| "matrix", "bmat", "asmatrix", | |
| # lib._histograms_impl.__all__ | |
| "histogram", "histogramdd", "histogram_bin_edges", | |
| # lib._nanfunctions_impl.__all__ | |
| "nansum", "nanmax", "nanmin", "nanargmax", "nanargmin", "nanmean", "nanmedian", | |
| "nanpercentile", "nanvar", "nanstd", "nanprod", "nancumsum", "nancumprod", | |
| "nanquantile", | |
| # lib._function_base_impl.__all__ | |
| "select", "piecewise", "trim_zeros", "copy", "iterable", "percentile", "diff", | |
| "gradient", "angle", "unwrap", "sort_complex", "flip", "rot90", "extract", "place", | |
| "vectorize", "asarray_chkfinite", "average", "bincount", "digitize", "cov", | |
| "corrcoef", "median", "sinc", "hamming", "hanning", "bartlett", "blackman", | |
| "kaiser", "trapezoid", "i0", "meshgrid", "delete", "insert", "append", | |
| "interp", "quantile", | |
| # lib._twodim_base_impl.__all__ | |
| "diag", "diagflat", "eye", "fliplr", "flipud", "tri", "triu", "tril", "vander", | |
| "histogram2d", "mask_indices", "tril_indices", "tril_indices_from", "triu_indices", | |
| "triu_indices_from", | |
| # lib._shape_base_impl.__all__ | |
| "column_stack", "dstack", "array_split", "split", "hsplit", "vsplit", "dsplit", | |
| "apply_over_axes", "expand_dims", "apply_along_axis", "kron", "tile", | |
| "take_along_axis", "put_along_axis", "row_stack", | |
| # lib._type_check_impl.__all__ | |
| "iscomplexobj", "isrealobj", "imag", "iscomplex", "isreal", "nan_to_num", "real", | |
| "real_if_close", "typename", "mintypecode", "common_type", | |
| # lib._arraysetops_impl.__all__ | |
| "ediff1d", "intersect1d", "isin", "setdiff1d", "setxor1d", "union1d", | |
| "unique", "unique_all", "unique_counts", "unique_inverse", "unique_values", | |
| # lib._ufunclike_impl.__all__ | |
| "fix", "isneginf", "isposinf", | |
| # lib._arraypad_impl.__all__ | |
| "pad", | |
| # lib._utils_impl.__all__ | |
| "get_include", "info", "show_runtime", | |
| # lib._stride_tricks_impl.__all__ | |
| "broadcast_to", "broadcast_arrays", "broadcast_shapes", | |
| # lib._polynomial_impl.__all__ | |
| "poly", "roots", "polyint", "polyder", "polyadd", "polysub", "polymul", "polydiv", | |
| "polyval", "poly1d", "polyfit", | |
| # lib._npyio_impl.__all__ | |
| "savetxt", "loadtxt", "genfromtxt", "load", "save", "savez", "savez_compressed", | |
| "packbits", "unpackbits", "fromregex", | |
| # lib._index_tricks_impl.__all__ | |
| "ravel_multi_index", "unravel_index", "mgrid", "ogrid", "r_", "c_", "s_", | |
| "index_exp", "ix_", "ndenumerate", "ndindex", "fill_diagonal", "diag_indices", | |
| "diag_indices_from", | |
| # __init__.__all__ | |
| "emath", "show_config", "__version__", "__array_namespace_info__", | |
| ] # fmt: skip | |
| ### Constrained types (for internal use only) | |
| # Only use these for functions; never as generic type parameter. | |
| _AnyStr = TypeVar("_AnyStr", LiteralString, str, bytes) | |
| _AnyShapeT = TypeVar( | |
| "_AnyShapeT", | |
| tuple[()], # 0-d | |
| tuple[int], # 1-d | |
| tuple[int, int], # 2-d | |
| tuple[int, int, int], # 3-d | |
| tuple[int, int, int, int], # 4-d | |
| tuple[int, int, int, int, int], # 5-d | |
| tuple[int, int, int, int, int, int], # 6-d | |
| tuple[int, int, int, int, int, int, int], # 7-d | |
| tuple[int, int, int, int, int, int, int, int], # 8-d | |
| tuple[int, ...], # N-d | |
| ) | |
| _AnyTD64Item = TypeVar("_AnyTD64Item", dt.timedelta, int, None, dt.timedelta | int | None) | |
| _AnyDT64Arg = TypeVar("_AnyDT64Arg", dt.datetime, dt.date, None) | |
| _AnyDT64Item = TypeVar("_AnyDT64Item", dt.datetime, dt.date, int, None, dt.date, int | None) | |
| _AnyDate = TypeVar("_AnyDate", dt.date, dt.datetime) | |
| _AnyDateOrTime = TypeVar("_AnyDateOrTime", dt.date, dt.datetime, dt.timedelta) | |
| ### Type parameters (for internal use only) | |
| _T = TypeVar("_T") | |
| _T_co = TypeVar("_T_co", covariant=True) | |
| _T_contra = TypeVar("_T_contra", contravariant=True) | |
| _RealT_co = TypeVar("_RealT_co", covariant=True) | |
| _ImagT_co = TypeVar("_ImagT_co", covariant=True) | |
| _DTypeT = TypeVar("_DTypeT", bound=dtype) | |
| _DTypeT_co = TypeVar("_DTypeT_co", bound=dtype, default=dtype, covariant=True) | |
| _FlexDTypeT = TypeVar("_FlexDTypeT", bound=dtype[flexible]) | |
| _ArrayT = TypeVar("_ArrayT", bound=ndarray) | |
| _ArrayT_co = TypeVar("_ArrayT_co", bound=ndarray, default=ndarray, covariant=True) | |
| _BoolArrayT = TypeVar("_BoolArrayT", bound=NDArray[np.bool]) | |
| _IntegerArrayT = TypeVar("_IntegerArrayT", bound=NDArray[integer]) | |
| _IntegralArrayT = TypeVar("_IntegralArrayT", bound=NDArray[np.bool | integer | object_]) | |
| _FloatingArrayT = TypeVar("_FloatingArrayT", bound=NDArray[floating]) | |
| _FloatingTimedeltaArrayT = TypeVar("_FloatingTimedeltaArrayT", bound=NDArray[floating | timedelta64]) | |
| _ComplexFloatingArrayT = TypeVar("_ComplexFloatingArrayT", bound=NDArray[complexfloating]) | |
| _InexactArrayT = TypeVar("_InexactArrayT", bound=NDArray[inexact]) | |
| _InexactTimedeltaArrayT = TypeVar("_InexactTimedeltaArrayT", bound=NDArray[inexact | timedelta64]) | |
| _NumberArrayT = TypeVar("_NumberArrayT", bound=NDArray[number]) | |
| _NumberCharacterArrayT = TypeVar("_NumberCharacterArrayT", bound=ndarray[Any, dtype[number | character] | dtypes.StringDType]) | |
| _TimedeltaArrayT = TypeVar("_TimedeltaArrayT", bound=NDArray[timedelta64]) | |
| _TimeArrayT = TypeVar("_TimeArrayT", bound=NDArray[datetime64 | timedelta64]) | |
| _ObjectArrayT = TypeVar("_ObjectArrayT", bound=NDArray[object_]) | |
| _BytesArrayT = TypeVar("_BytesArrayT", bound=NDArray[bytes_]) | |
| _StringArrayT = TypeVar("_StringArrayT", bound=ndarray[Any, dtype[str_] | dtypes.StringDType]) | |
| _RealArrayT = TypeVar("_RealArrayT", bound=NDArray[floating | integer | timedelta64 | np.bool | object_]) | |
| _NumericArrayT = TypeVar("_NumericArrayT", bound=NDArray[number | timedelta64 | object_]) | |
| _ShapeT = TypeVar("_ShapeT", bound=_Shape) | |
| _Shape1T = TypeVar("_Shape1T", bound=tuple[int, *tuple[int, ...]]) | |
| _ShapeT_co = TypeVar("_ShapeT_co", bound=_Shape, default=_AnyShape, covariant=True) | |
| _2DShapeT_co = TypeVar("_2DShapeT_co", bound=_2D, default=_2D, covariant=True) | |
| _1NShapeT = TypeVar("_1NShapeT", bound=tuple[L[1], *tuple[L[1], ...]]) # (1,) | (1, 1) | (1, 1, 1) | ... | |
| _ScalarT = TypeVar("_ScalarT", bound=generic) | |
| _ScalarT_co = TypeVar("_ScalarT_co", bound=generic, default=Any, covariant=True) | |
| _NumberT = TypeVar("_NumberT", bound=number) | |
| _InexactT = TypeVar("_InexactT", bound=inexact) | |
| _RealNumberT = TypeVar("_RealNumberT", bound=floating | integer) | |
| _IntegerT = TypeVar("_IntegerT", bound=integer) | |
| _NonObjectScalarT = TypeVar("_NonObjectScalarT", bound=np.bool | number | flexible | datetime64 | timedelta64) | |
| _NBit = TypeVar("_NBit", bound=NBitBase, default=Any) # pyright: ignore[reportDeprecated] | |
| _NBit1 = TypeVar("_NBit1", bound=NBitBase, default=Any) # pyright: ignore[reportDeprecated] | |
| _NBit2 = TypeVar("_NBit2", bound=NBitBase, default=_NBit1) # pyright: ignore[reportDeprecated] | |
| _ItemT_co = TypeVar("_ItemT_co", default=Any, covariant=True) | |
| _BoolItemT = TypeVar("_BoolItemT", bound=builtins.bool) | |
| _BoolItemT_co = TypeVar("_BoolItemT_co", bound=builtins.bool, default=builtins.bool, covariant=True) | |
| _NumberItemT_co = TypeVar("_NumberItemT_co", bound=complex, default=int | float | complex, covariant=True) | |
| _InexactItemT_co = TypeVar("_InexactItemT_co", bound=complex, default=float | complex, covariant=True) | |
| _FlexibleItemT_co = TypeVar( | |
| "_FlexibleItemT_co", | |
| bound=_CharLike_co | tuple[Any, ...], | |
| default=_CharLike_co | tuple[Any, ...], | |
| covariant=True, | |
| ) | |
| _CharacterItemT_co = TypeVar("_CharacterItemT_co", bound=_CharLike_co, default=_CharLike_co, covariant=True) | |
| _TD64ItemT_co = TypeVar("_TD64ItemT_co", bound=dt.timedelta | int | None, default=dt.timedelta | int | None, covariant=True) | |
| _DT64ItemT_co = TypeVar("_DT64ItemT_co", bound=dt.date | int | None, default=dt.date | int | None, covariant=True) | |
| _TD64UnitT = TypeVar("_TD64UnitT", bound=_TD64Unit, default=_TD64Unit) | |
| _BoolOrIntArrayT = TypeVar("_BoolOrIntArrayT", bound=NDArray[integer | np.bool]) | |
| ### Type Aliases (for internal use only) | |
| _Falsy: TypeAlias = L[False, 0] | np.bool[L[False]] | |
| _Truthy: TypeAlias = L[True, 1] | np.bool[L[True]] | |
| _1D: TypeAlias = tuple[int] | |
| _2D: TypeAlias = tuple[int, int] | |
| _2Tuple: TypeAlias = tuple[_T, _T] | |
| _ArrayUInt_co: TypeAlias = NDArray[unsignedinteger | np.bool] | |
| _ArrayInt_co: TypeAlias = NDArray[integer | np.bool] | |
| _ArrayFloat64_co: TypeAlias = NDArray[floating[_64Bit] | float32 | float16 | integer | np.bool] | |
| _ArrayFloat_co: TypeAlias = NDArray[floating | integer | np.bool] | |
| _ArrayComplex128_co: TypeAlias = NDArray[number[_64Bit] | number[_32Bit] | float16 | integer | np.bool] | |
| _ArrayComplex_co: TypeAlias = NDArray[inexact | integer | np.bool] | |
| _ArrayNumber_co: TypeAlias = NDArray[number | np.bool] | |
| _ArrayTD64_co: TypeAlias = NDArray[timedelta64 | integer | np.bool] | |
| _Float64_co: TypeAlias = float | floating[_64Bit] | float32 | float16 | integer | np.bool | |
| _Complex64_co: TypeAlias = number[_32Bit] | number[_16Bit] | number[_8Bit] | builtins.bool | np.bool | |
| _Complex128_co: TypeAlias = complex | number[_64Bit] | _Complex64_co | |
| _ToIndex: TypeAlias = SupportsIndex | slice | EllipsisType | _ArrayLikeInt_co | None | |
| _ToIndices: TypeAlias = _ToIndex | tuple[_ToIndex, ...] | |
| _UnsignedIntegerCType: TypeAlias = type[ | |
| ct.c_uint8 | ct.c_uint16 | ct.c_uint32 | ct.c_uint64 | |
| | ct.c_ushort | ct.c_uint | ct.c_ulong | ct.c_ulonglong | |
| | ct.c_size_t | ct.c_void_p | |
| ] # fmt: skip | |
| _SignedIntegerCType: TypeAlias = type[ | |
| ct.c_int8 | ct.c_int16 | ct.c_int32 | ct.c_int64 | |
| | ct.c_short | ct.c_int | ct.c_long | ct.c_longlong | |
| | ct.c_ssize_t | |
| ] # fmt: skip | |
| _FloatingCType: TypeAlias = type[ct.c_float | ct.c_double | ct.c_longdouble] | |
| _IntegerCType: TypeAlias = _UnsignedIntegerCType | _SignedIntegerCType | |
| # some commonly used builtin types that are known to result in a | |
| # `dtype[object_]`, when their *type* is passed to the `dtype` constructor | |
| # NOTE: `builtins.object` should not be included here | |
| _BuiltinObjectLike: TypeAlias = ( | |
| slice | Decimal | Fraction | UUID | |
| | dt.date | dt.time | dt.timedelta | dt.tzinfo | |
| | tuple[Any, ...] | list[Any] | set[Any] | frozenset[Any] | dict[Any, Any] | |
| ) # fmt: skip | |
| # Introduce an alias for `dtype` to avoid naming conflicts. | |
| _dtype: TypeAlias = dtype[_ScalarT] | |
| _ByteOrderChar: TypeAlias = L["<", ">", "=", "|"] | |
| # can be anything, is case-insensitive, and only the first character matters | |
| _ByteOrder: TypeAlias = L[ | |
| "S", # swap the current order (default) | |
| "<", "L", "little", # little-endian | |
| ">", "B", "big", # big endian | |
| "=", "N", "native", # native order | |
| "|", "I", # ignore | |
| ] # fmt: skip | |
| _DTypeKind: TypeAlias = L[ | |
| "b", # boolean | |
| "i", # signed integer | |
| "u", # unsigned integer | |
| "f", # floating-point | |
| "c", # complex floating-point | |
| "m", # timedelta64 | |
| "M", # datetime64 | |
| "O", # python object | |
| "S", # byte-string (fixed-width) | |
| "U", # unicode-string (fixed-width) | |
| "V", # void | |
| "T", # unicode-string (variable-width) | |
| ] | |
| _DTypeChar: TypeAlias = L[ | |
| "?", # bool | |
| "b", # byte | |
| "B", # ubyte | |
| "h", # short | |
| "H", # ushort | |
| "i", # intc | |
| "I", # uintc | |
| "l", # long | |
| "L", # ulong | |
| "q", # longlong | |
| "Q", # ulonglong | |
| "e", # half | |
| "f", # single | |
| "d", # double | |
| "g", # longdouble | |
| "F", # csingle | |
| "D", # cdouble | |
| "G", # clongdouble | |
| "O", # object | |
| "S", # bytes_ (S0) | |
| "a", # bytes_ (deprecated) | |
| "U", # str_ | |
| "V", # void | |
| "M", # datetime64 | |
| "m", # timedelta64 | |
| "c", # bytes_ (S1) | |
| "T", # StringDType | |
| ] | |
| _DTypeNum: TypeAlias = L[ | |
| 0, # bool | |
| 1, # byte | |
| 2, # ubyte | |
| 3, # short | |
| 4, # ushort | |
| 5, # intc | |
| 6, # uintc | |
| 7, # long | |
| 8, # ulong | |
| 9, # longlong | |
| 10, # ulonglong | |
| 23, # half | |
| 11, # single | |
| 12, # double | |
| 13, # longdouble | |
| 14, # csingle | |
| 15, # cdouble | |
| 16, # clongdouble | |
| 17, # object | |
| 18, # bytes_ | |
| 19, # str_ | |
| 20, # void | |
| 21, # datetime64 | |
| 22, # timedelta64 | |
| 25, # no type | |
| 256, # user-defined | |
| 2056, # StringDType | |
| ] | |
| _DTypeBuiltinKind: TypeAlias = L[0, 1, 2] | |
| _ArrayAPIVersion: TypeAlias = L["2021.12", "2022.12", "2023.12", "2024.12"] | |
| _CastingKind: TypeAlias = L["no", "equiv", "safe", "same_kind", "same_value", "unsafe"] | |
| _OrderKACF: TypeAlias = L["K", "A", "C", "F"] | None | |
| _OrderACF: TypeAlias = L["A", "C", "F"] | None | |
| _OrderCF: TypeAlias = L["C", "F"] | None # noqa: PYI047 | |
| _ModeKind: TypeAlias = L["raise", "wrap", "clip"] | |
| _PartitionKind: TypeAlias = L["introselect"] | |
| # in practice, only the first case-insensitive character is considered (so e.g. | |
| # "QuantumSort3000" will be interpreted as quicksort). | |
| _SortKind: TypeAlias = L[ | |
| "Q", "quick", "quicksort", | |
| "M", "merge", "mergesort", | |
| "H", "heap", "heapsort", | |
| "S", "stable", "stablesort", | |
| ] | |
| _SortSide: TypeAlias = L["left", "right"] | |
| _ConvertibleToInt: TypeAlias = SupportsInt | SupportsIndex | _CharLike_co | |
| _ConvertibleToFloat: TypeAlias = SupportsFloat | SupportsIndex | _CharLike_co | |
| _ConvertibleToComplex: TypeAlias = SupportsComplex | SupportsFloat | SupportsIndex | _CharLike_co | |
| _ConvertibleToTD64: TypeAlias = dt.timedelta | int | _CharLike_co | character | number | timedelta64 | np.bool | None | |
| _ConvertibleToDT64: TypeAlias = dt.date | int | _CharLike_co | character | number | datetime64 | np.bool | None | |
| _NDIterFlagsKind: TypeAlias = 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", | |
| ] | |
| _NDIterFlagsOp: TypeAlias = L[ | |
| "aligned", | |
| "allocate", | |
| "arraymask", | |
| "copy", | |
| "config", | |
| "nbo", | |
| "no_subtype", | |
| "no_broadcast", | |
| "overlap_assume_elementwise", | |
| "readonly", | |
| "readwrite", | |
| "updateifcopy", | |
| "virtual", | |
| "writeonly", | |
| "writemasked", | |
| ] | |
| _MemMapModeKind: TypeAlias = L[ | |
| "readonly", "r", | |
| "copyonwrite", "c", | |
| "readwrite", "r+", | |
| "write", "w+", | |
| ] | |
| _DT64Date: TypeAlias = _HasDateAttributes | L["TODAY", "today", b"TODAY", b"today"] | |
| _DT64Now: TypeAlias = L["NOW", "now", b"NOW", b"now"] | |
| _NaTValue: TypeAlias = L["NAT", "NaT", "nat", b"NAT", b"NaT", b"nat"] | |
| _MonthUnit: TypeAlias = L["Y", "M", b"Y", b"M"] | |
| _DayUnit: TypeAlias = L["W", "D", b"W", b"D"] | |
| _DateUnit: TypeAlias = L[_MonthUnit, _DayUnit] | |
| _NativeTimeUnit: TypeAlias = L["h", "m", "s", "ms", "us", "μs", b"h", b"m", b"s", b"ms", b"us"] | |
| _IntTimeUnit: TypeAlias = L["ns", "ps", "fs", "as", b"ns", b"ps", b"fs", b"as"] | |
| _TimeUnit: TypeAlias = L[_NativeTimeUnit, _IntTimeUnit] | |
| _NativeTD64Unit: TypeAlias = L[_DayUnit, _NativeTimeUnit] | |
| _IntTD64Unit: TypeAlias = L[_MonthUnit, _IntTimeUnit] | |
| _TD64Unit: TypeAlias = L[_DateUnit, _TimeUnit] | |
| _TimeUnitSpec: TypeAlias = _TD64UnitT | tuple[_TD64UnitT, SupportsIndex] | |
| ### TypedDict's (for internal use only) | |
| @type_check_only | |
| class _FormerAttrsDict(TypedDict): | |
| object: LiteralString | |
| float: LiteralString | |
| complex: LiteralString | |
| str: LiteralString | |
| int: LiteralString | |
| ### Protocols (for internal use only) | |
| @final | |
| @type_check_only | |
| class _SupportsLT(Protocol): | |
| def __lt__(self, other: Any, /) -> Any: ... | |
| @final | |
| @type_check_only | |
| class _SupportsLE(Protocol): | |
| def __le__(self, other: Any, /) -> Any: ... | |
| @final | |
| @type_check_only | |
| class _SupportsGT(Protocol): | |
| def __gt__(self, other: Any, /) -> Any: ... | |
| @final | |
| @type_check_only | |
| class _SupportsGE(Protocol): | |
| def __ge__(self, other: Any, /) -> Any: ... | |
| @type_check_only | |
| class _SupportsFileMethods(SupportsFlush, Protocol): | |
| # Protocol for representing file-like-objects accepted by `ndarray.tofile` and `fromfile` | |
| def fileno(self) -> SupportsIndex: ... | |
| def tell(self) -> SupportsIndex: ... | |
| def seek(self, offset: int, whence: int, /) -> object: ... | |
| @type_check_only | |
| class _SupportsFileMethodsRW(SupportsWrite[bytes], _SupportsFileMethods, Protocol): ... | |
| @type_check_only | |
| class _SupportsDLPack(Protocol[_T_contra]): | |
| def __dlpack__(self, /, *, stream: _T_contra | None = None) -> CapsuleType: ... | |
| @type_check_only | |
| class _HasDType(Protocol[_T_co]): | |
| @property | |
| def dtype(self, /) -> _T_co: ... | |
| @type_check_only | |
| class _HasRealAndImag(Protocol[_RealT_co, _ImagT_co]): | |
| @property | |
| def real(self, /) -> _RealT_co: ... | |
| @property | |
| def imag(self, /) -> _ImagT_co: ... | |
| @type_check_only | |
| class _HasTypeWithRealAndImag(Protocol[_RealT_co, _ImagT_co]): | |
| @property | |
| def type(self, /) -> type[_HasRealAndImag[_RealT_co, _ImagT_co]]: ... | |
| @type_check_only | |
| class _HasDTypeWithRealAndImag(Protocol[_RealT_co, _ImagT_co]): | |
| @property | |
| def dtype(self, /) -> _HasTypeWithRealAndImag[_RealT_co, _ImagT_co]: ... | |
| @type_check_only | |
| class _HasDateAttributes(Protocol): | |
| # The `datetime64` constructors requires an object with the three attributes below, | |
| # and thus supports datetime duck typing | |
| @property | |
| def day(self) -> int: ... | |
| @property | |
| def month(self) -> int: ... | |
| @property | |
| def year(self) -> int: ... | |
| ### Mixins (for internal use only) | |
| @type_check_only | |
| class _RealMixin: | |
| @property | |
| def real(self) -> Self: ... | |
| @property | |
| def imag(self) -> Self: ... | |
| @type_check_only | |
| class _RoundMixin: | |
| @overload | |
| def __round__(self, /, ndigits: None = None) -> int: ... | |
| @overload | |
| def __round__(self, /, ndigits: SupportsIndex) -> Self: ... | |
| @type_check_only | |
| class _IntegralMixin(_RealMixin): | |
| @property | |
| def numerator(self) -> Self: ... | |
| @property | |
| def denominator(self) -> L[1]: ... | |
| def is_integer(self, /) -> L[True]: ... | |
| ### Public API | |
| __version__: Final[LiteralString] = ... | |
| e: Final[float] = ... | |
| euler_gamma: Final[float] = ... | |
| pi: Final[float] = ... | |
| inf: Final[float] = ... | |
| nan: Final[float] = ... | |
| little_endian: Final[builtins.bool] = ... | |
| False_: Final[np.bool[L[False]]] = ... | |
| True_: Final[np.bool[L[True]]] = ... | |
| newaxis: Final[None] = None | |
| # not in __all__ | |
| __NUMPY_SETUP__: Final[L[False]] = False | |
| __numpy_submodules__: Final[set[LiteralString]] = ... | |
| __former_attrs__: Final[_FormerAttrsDict] = ... | |
| __future_scalars__: Final[set[L["bytes", "str", "object"]]] = ... | |
| __array_api_version__: Final[L["2024.12"]] = "2024.12" | |
| test: Final[PytestTester] = ... | |
| @type_check_only | |
| class _DTypeMeta(type): | |
| @property | |
| def type(cls, /) -> type[generic] | None: ... | |
| @property | |
| def _abstract(cls, /) -> bool: ... | |
| @property | |
| def _is_numeric(cls, /) -> bool: ... | |
| @property | |
| def _parametric(cls, /) -> bool: ... | |
| @property | |
| def _legacy(cls, /) -> bool: ... | |
| @final | |
| class dtype(Generic[_ScalarT_co], metaclass=_DTypeMeta): | |
| names: tuple[builtins.str, ...] | None | |
| def __hash__(self) -> int: ... | |
| # `None` results in the default dtype | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: type[float64 | ct.c_double] | _Float64Codes | _DoubleCodes | None, | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ... | |
| ) -> dtype[float64]: ... | |
| # Overload for `dtype` instances, scalar types, and instances that have a | |
| # `dtype: dtype[_ScalarT]` attribute | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _DTypeLike[_ScalarT], | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[_ScalarT]: ... | |
| # Builtin types | |
| # | |
| # NOTE: Typecheckers act as if `bool <: int <: float <: complex <: object`, | |
| # even though at runtime `int`, `float`, and `complex` aren't subtypes.. | |
| # This makes it impossible to express e.g. "a float that isn't an int", | |
| # since type checkers treat `_: float` like `_: float | int`. | |
| # | |
| # For more details, see: | |
| # - https://github.com/numpy/numpy/issues/27032#issuecomment-2278958251 | |
| # - https://typing.readthedocs.io/en/latest/spec/special-types.html#special-cases-for-float-and-complex | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: type[builtins.bool | np.bool | ct.c_bool] | _BoolCodes, | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[str, Any] = ..., | |
| ) -> dtype[np.bool]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: type[int], # also accepts `type[builtins.bool]` | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[str, Any] = ..., | |
| ) -> dtype[int_ | np.bool]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: type[float], # also accepts `type[int | bool]` | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[str, Any] = ..., | |
| ) -> dtype[float64 | int_ | np.bool]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: type[complex], # also accepts `type[float | int | bool]` | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[str, Any] = ..., | |
| ) -> dtype[complex128 | float64 | int_ | np.bool]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: type[bytes | ct.c_char] | _BytesCodes, | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[str, Any] = ..., | |
| ) -> dtype[bytes_]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: type[str] | _StrCodes, | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[str, Any] = ..., | |
| ) -> dtype[str_]: ... | |
| # NOTE: These `memoryview` overloads assume PEP 688, which requires mypy to | |
| # be run with the (undocumented) `--disable-memoryview-promotion` flag, | |
| # This will be the default in a future mypy release, see: | |
| # https://github.com/python/mypy/issues/15313 | |
| # Pyright / Pylance requires setting `disableBytesTypePromotions=true`, | |
| # which is the default in strict mode | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: type[void | memoryview] | _VoidDTypeLike | _VoidCodes, | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[str, Any] = ..., | |
| ) -> dtype[void]: ... | |
| # NOTE: `_: type[object]` would also accept e.g. `type[object | complex]`, | |
| # and is therefore not included here | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: type[object_ | _BuiltinObjectLike | ct.py_object[Any]] | _ObjectCodes, | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[str, Any] = ..., | |
| ) -> dtype[object_]: ... | |
| # `unsignedinteger` string-based representations and ctypes | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _UInt8Codes | _UByteCodes | type[ct.c_uint8 | ct.c_ubyte], | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[uint8]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _UInt16Codes | _UShortCodes | type[ct.c_uint16 | ct.c_ushort], | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[uint16]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _UInt32Codes | _UIntCCodes | type[ct.c_uint32 | ct.c_uint], | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[uint32]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _UInt64Codes | _ULongLongCodes | type[ct.c_uint64 | ct.c_ulonglong], | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[uint64]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _UIntPCodes | type[ct.c_void_p | ct.c_size_t], | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[uintp]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _ULongCodes | type[ct.c_ulong], | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[ulong]: ... | |
| # `signedinteger` string-based representations and ctypes | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _Int8Codes | _ByteCodes | type[ct.c_int8 | ct.c_byte], | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[int8]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _Int16Codes | _ShortCodes | type[ct.c_int16 | ct.c_short], | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[int16]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _Int32Codes | _IntCCodes | type[ct.c_int32 | ct.c_int], | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[int32]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _Int64Codes | _LongLongCodes | type[ct.c_int64 | ct.c_longlong], | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[int64]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _IntPCodes | type[intp | ct.c_ssize_t], | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[intp]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _LongCodes | type[ct.c_long], | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[long]: ... | |
| # `floating` string-based representations and ctypes | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _Float16Codes | _HalfCodes, | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[float16]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _Float32Codes | _SingleCodes, | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[float32]: ... | |
| # float64 codes are covered by overload 1 | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _LongDoubleCodes | type[ct.c_longdouble], | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[longdouble]: ... | |
| # `complexfloating` string-based representations | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _Complex64Codes | _CSingleCodes, | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[complex64]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _Complex128Codes | _CDoubleCodes, | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[complex128]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _CLongDoubleCodes, | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[clongdouble]: ... | |
| # Miscellaneous string-based representations and ctypes | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _TD64Codes, | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[timedelta64]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _DT64Codes, | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[datetime64]: ... | |
| # `StringDType` requires special treatment because it has no scalar type | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: dtypes.StringDType | _StringCodes, | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtypes.StringDType: ... | |
| # Combined char-codes and ctypes, analogous to the scalar-type hierarchy | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _UnsignedIntegerCodes | _UnsignedIntegerCType, | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[unsignedinteger]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _SignedIntegerCodes | _SignedIntegerCType, | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[signedinteger]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _IntegerCodes | _IntegerCType, | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[integer]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _FloatingCodes | _FloatingCType, | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[floating]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _ComplexFloatingCodes, | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[complexfloating]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _InexactCodes | _FloatingCType, | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[inexact]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: _CharacterCodes | type[bytes | builtins.str | ct.c_char], | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[str, Any] = ..., | |
| ) -> dtype[character]: ... | |
| # Handle strings that can't be expressed as literals; i.e. "S1", "S2", ... | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: builtins.str, | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype: ... | |
| # Catch-all overload for object-likes | |
| # NOTE: `object_ | Any` is NOT equivalent to `Any`. It is specified to behave | |
| # like a "sum type" (a.k.a. variant type, discriminated union, or tagged union). | |
| # So the union of a type and `Any` is not the same "union type" that all other | |
| # unions are (by definition). | |
| # https://typing.python.org/en/latest/spec/concepts.html#union-types | |
| @overload | |
| def __new__( | |
| cls, | |
| dtype: type[object], | |
| align: builtins.bool = False, | |
| copy: builtins.bool = False, | |
| *, | |
| metadata: dict[builtins.str, Any] = ..., | |
| ) -> dtype[object_ | Any]: ... | |
| def __class_getitem__(cls, 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: ... | |
| # NOTE: In the future 1-based multiplications will also yield `flexible` dtypes | |
| @overload | |
| def __mul__(self: _DTypeT, value: L[1], /) -> _DTypeT: ... | |
| @overload | |
| def __mul__(self: _FlexDTypeT, value: SupportsIndex, /) -> _FlexDTypeT: ... | |
| @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` for | |
| # now for non-flexible dtypes. | |
| @overload | |
| def __rmul__(self: _FlexDTypeT, value: SupportsIndex, /) -> _FlexDTypeT: ... | |
| @overload | |
| def __rmul__(self, value: SupportsIndex, /) -> dtype: ... | |
| def __gt__(self, other: DTypeLike | None, /) -> builtins.bool: ... | |
| def __ge__(self, other: DTypeLike | None, /) -> builtins.bool: ... | |
| def __lt__(self, other: DTypeLike | None, /) -> builtins.bool: ... | |
| def __le__(self, other: DTypeLike | None, /) -> builtins.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, /) -> builtins.bool: ... | |
| def __ne__(self, other: Any, /) -> builtins.bool: ... | |
| @property | |
| def alignment(self) -> int: ... | |
| @property | |
| def base(self) -> dtype: ... | |
| @property | |
| def byteorder(self) -> _ByteOrderChar: ... | |
| @property | |
| def char(self) -> _DTypeChar: ... | |
| @property | |
| def descr(self) -> list[tuple[LiteralString, LiteralString] | tuple[LiteralString, LiteralString, _Shape]]: ... | |
| @property | |
| def fields(self,) -> MappingProxyType[LiteralString, tuple[dtype, int] | tuple[dtype, int, Any]] | None: ... | |
| @property | |
| def flags(self) -> int: ... | |
| @property | |
| def hasobject(self) -> builtins.bool: ... | |
| @property | |
| def isbuiltin(self) -> _DTypeBuiltinKind: ... | |
| @property | |
| def isnative(self) -> builtins.bool: ... | |
| @property | |
| def isalignedstruct(self) -> builtins.bool: ... | |
| @property | |
| def itemsize(self) -> int: ... | |
| @property | |
| def kind(self) -> _DTypeKind: ... | |
| @property | |
| def metadata(self) -> MappingProxyType[builtins.str, Any] | None: ... | |
| @property | |
| def name(self) -> LiteralString: ... | |
| @property | |
| def num(self) -> _DTypeNum: ... | |
| @property | |
| def shape(self) -> _AnyShape: ... | |
| @property | |
| def ndim(self) -> int: ... | |
| @property | |
| def subdtype(self) -> tuple[dtype, _AnyShape] | None: ... | |
| def newbyteorder(self, new_order: _ByteOrder = ..., /) -> Self: ... | |
| @property | |
| def str(self) -> LiteralString: ... | |
| @property | |
| def type(self) -> type[_ScalarT_co]: ... | |
| @final | |
| class flatiter(Generic[_ArrayT_co]): | |
| __hash__: ClassVar[None] = None # type: ignore[assignment] # pyright: ignore[reportIncompatibleMethodOverride] | |
| @property | |
| def base(self, /) -> _ArrayT_co: ... | |
| @property | |
| def coords(self: flatiter[ndarray[_ShapeT]], /) -> _ShapeT: ... | |
| @property | |
| def index(self, /) -> int: ... | |
| # iteration | |
| def __len__(self, /) -> int: ... | |
| def __iter__(self, /) -> Self: ... | |
| def __next__(self: flatiter[NDArray[_ScalarT]], /) -> _ScalarT: ... | |
| # indexing | |
| @overload # nd: _[()] | |
| def __getitem__(self, key: tuple[()], /) -> _ArrayT_co: ... | |
| @overload # 0d; _[<integer>] | |
| def __getitem__(self: flatiter[NDArray[_ScalarT]], key: int | integer, /) -> _ScalarT: ... | |
| @overload # 1d; _[[*<int>]], _[:], _[...] | |
| def __getitem__( | |
| self: flatiter[ndarray[Any, _DTypeT]], | |
| key: list[int] | slice | EllipsisType | flatiter[NDArray[integer]], | |
| /, | |
| ) -> ndarray[tuple[int], _DTypeT]: ... | |
| @overload # 2d; _[[*[*<int>]]] | |
| def __getitem__( | |
| self: flatiter[ndarray[Any, _DTypeT]], | |
| key: list[list[int]], | |
| /, | |
| ) -> ndarray[tuple[int, int], _DTypeT]: ... | |
| @overload # ?d | |
| def __getitem__( | |
| self: flatiter[ndarray[Any, _DTypeT]], | |
| key: NDArray[integer] | _NestedSequence[int], | |
| /, | |
| ) -> ndarray[_AnyShape, _DTypeT]: ... | |
| # NOTE: `__setitem__` operates via `unsafe` casting rules, and can thus accept any | |
| # type accepted by the relevant underlying `np.generic` constructor, which isn't | |
| # known statically. So we cannot meaningfully annotate the value parameter. | |
| def __setitem__(self, key: slice | EllipsisType | _ArrayLikeInt, val: object, /) -> None: ... | |
| # NOTE: `dtype` and `copy` are no-ops at runtime, so we don't support them here to | |
| # avoid confusion | |
| def __array__( | |
| self: flatiter[ndarray[Any, _DTypeT]], | |
| dtype: None = None, | |
| /, | |
| *, | |
| copy: None = None, | |
| ) -> ndarray[tuple[int], _DTypeT]: ... | |
| # This returns a flat copy of the underlying array, not of the iterator itself | |
| def copy(self: flatiter[ndarray[Any, _DTypeT]], /) -> ndarray[tuple[int], _DTypeT]: ... | |
| @type_check_only | |
| class _ArrayOrScalarCommon: | |
| @property | |
| def real(self, /) -> Any: ... | |
| @property | |
| def imag(self, /) -> Any: ... | |
| @property | |
| def T(self) -> Self: ... | |
| @property | |
| def mT(self) -> Self: ... | |
| @property | |
| def data(self) -> memoryview: ... | |
| @property | |
| def flags(self) -> flagsobj: ... | |
| @property | |
| def itemsize(self) -> int: ... | |
| @property | |
| def nbytes(self) -> int: ... | |
| @property | |
| def device(self) -> L["cpu"]: ... | |
| def __bool__(self, /) -> builtins.bool: ... | |
| def __int__(self, /) -> int: ... | |
| def __float__(self, /) -> float: ... | |
| def __copy__(self) -> Self: ... | |
| def __deepcopy__(self, memo: dict[int, Any] | None, /) -> Self: ... | |
| # 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, order: _OrderKACF = ...) -> Self: ... | |
| def dump(self, file: StrOrBytesPath | SupportsWrite[bytes]) -> None: ... | |
| def dumps(self) -> bytes: ... | |
| def tobytes(self, order: _OrderKACF = ...) -> bytes: ... | |
| def tofile(self, fid: StrOrBytesPath | _SupportsFileMethods, /, sep: str = "", format: str = "%s") -> None: ... | |
| # generics and 0d arrays return builtin scalars | |
| def tolist(self) -> Any: ... | |
| def to_device(self, device: L["cpu"], /, *, stream: int | Any | None = ...) -> Self: ... | |
| # NOTE: for `generic`, these two methods don't do anything | |
| def fill(self, /, value: Incomplete) -> None: ... | |
| def put(self, indices: _ArrayLikeInt_co, values: ArrayLike, /, mode: _ModeKind = "raise") -> None: ... | |
| # NOTE: even on `generic` this seems to work | |
| def setflags( | |
| self, | |
| /, | |
| *, | |
| write: builtins.bool | None = None, | |
| align: builtins.bool | None = None, | |
| uic: builtins.bool | None = None, | |
| ) -> None: ... | |
| @property | |
| def __array_interface__(self) -> dict[str, Any]: ... | |
| @property | |
| def __array_priority__(self) -> float: ... | |
| @property | |
| def __array_struct__(self) -> CapsuleType: ... # builtins.PyCapsule | |
| def __array_namespace__(self, /, *, api_version: _ArrayAPIVersion | None = None) -> ModuleType: ... | |
| def __setstate__(self, state: tuple[ | |
| SupportsIndex, # version | |
| _ShapeLike, # Shape | |
| _DTypeT_co, # DType | |
| np.bool, # F-continuous | |
| bytes | list[Any], # Data | |
| ], /) -> None: ... | |
| def conj(self) -> Self: ... | |
| def conjugate(self) -> Self: ... | |
| def argsort( | |
| self, | |
| axis: SupportsIndex | None = ..., | |
| kind: _SortKind | None = ..., | |
| order: str | Sequence[str] | None = ..., | |
| *, | |
| stable: builtins.bool | None = ..., | |
| ) -> NDArray[intp]: ... | |
| @overload # axis=None (default), out=None (default), keepdims=False (default) | |
| def argmax(self, /, axis: None = None, out: None = None, *, keepdims: L[False] = False) -> intp: ... | |
| @overload # axis=index, out=None (default) | |
| def argmax(self, /, axis: SupportsIndex, out: None = None, *, keepdims: builtins.bool = False) -> Any: ... | |
| @overload # axis=index, out=ndarray | |
| def argmax(self, /, axis: SupportsIndex | None, out: _BoolOrIntArrayT, *, keepdims: builtins.bool = False) -> _BoolOrIntArrayT: ... | |
| @overload | |
| def argmax(self, /, axis: SupportsIndex | None = None, *, out: _BoolOrIntArrayT, keepdims: builtins.bool = False) -> _BoolOrIntArrayT: ... | |
| @overload # axis=None (default), out=None (default), keepdims=False (default) | |
| def argmin(self, /, axis: None = None, out: None = None, *, keepdims: L[False] = False) -> intp: ... | |
| @overload # axis=index, out=None (default) | |
| def argmin(self, /, axis: SupportsIndex, out: None = None, *, keepdims: builtins.bool = False) -> Any: ... | |
| @overload # axis=index, out=ndarray | |
| def argmin(self, /, axis: SupportsIndex | None, out: _BoolOrIntArrayT, *, keepdims: builtins.bool = False) -> _BoolOrIntArrayT: ... | |
| @overload | |
| def argmin(self, /, axis: SupportsIndex | None = None, *, out: _BoolOrIntArrayT, keepdims: builtins.bool = False) -> _BoolOrIntArrayT: ... | |
| # Keep in sync with `MaskedArray.round` | |
| @overload # out=None (default) | |
| def round(self, /, decimals: SupportsIndex = 0, out: None = None) -> Self: ... | |
| @overload # out=ndarray | |
| def round(self, /, decimals: SupportsIndex, out: _ArrayT) -> _ArrayT: ... | |
| @overload | |
| def round(self, /, decimals: SupportsIndex = 0, *, out: _ArrayT) -> _ArrayT: ... | |
| @overload # out=None (default) | |
| def choose(self, /, choices: ArrayLike, out: None = None, mode: _ModeKind = "raise") -> NDArray[Any]: ... | |
| @overload # out=ndarray | |
| def choose(self, /, choices: ArrayLike, out: _ArrayT, mode: _ModeKind = "raise") -> _ArrayT: ... | |
| # TODO: Annotate kwargs with an unpacked `TypedDict` | |
| @overload # out: None (default) | |
| def clip(self, /, min: ArrayLike, max: ArrayLike | None = None, out: None = None, **kwargs: Any) -> NDArray[Any]: ... | |
| @overload | |
| def clip(self, /, min: None, max: ArrayLike, out: None = None, **kwargs: Any) -> NDArray[Any]: ... | |
| @overload | |
| def clip(self, /, min: None = None, *, max: ArrayLike, out: None = None, **kwargs: Any) -> NDArray[Any]: ... | |
| @overload # out: ndarray | |
| def clip(self, /, min: ArrayLike, max: ArrayLike | None, out: _ArrayT, **kwargs: Any) -> _ArrayT: ... | |
| @overload | |
| def clip(self, /, min: ArrayLike, max: ArrayLike | None = None, *, out: _ArrayT, **kwargs: Any) -> _ArrayT: ... | |
| @overload | |
| def clip(self, /, min: None, max: ArrayLike, out: _ArrayT, **kwargs: Any) -> _ArrayT: ... | |
| @overload | |
| def clip(self, /, min: None = None, *, max: ArrayLike, out: _ArrayT, **kwargs: Any) -> _ArrayT: ... | |
| @overload | |
| def compress(self, /, condition: _ArrayLikeInt_co, axis: SupportsIndex | None = None, out: None = None) -> NDArray[Any]: ... | |
| @overload | |
| def compress(self, /, condition: _ArrayLikeInt_co, axis: SupportsIndex | None, out: _ArrayT) -> _ArrayT: ... | |
| @overload | |
| def compress(self, /, condition: _ArrayLikeInt_co, axis: SupportsIndex | None = None, *, out: _ArrayT) -> _ArrayT: ... | |
| # Keep in sync with `MaskedArray.cumprod` | |
| @overload # out: None (default) | |
| def cumprod(self, /, axis: SupportsIndex | None = None, dtype: DTypeLike | None = None, out: None = None) -> NDArray[Any]: ... | |
| @overload # out: ndarray | |
| def cumprod(self, /, axis: SupportsIndex | None, dtype: DTypeLike | None, out: _ArrayT) -> _ArrayT: ... | |
| @overload | |
| def cumprod(self, /, axis: SupportsIndex | None = None, dtype: DTypeLike | None = None, *, out: _ArrayT) -> _ArrayT: ... | |
| # Keep in sync with `MaskedArray.cumsum` | |
| @overload # out: None (default) | |
| def cumsum(self, /, axis: SupportsIndex | None = None, dtype: DTypeLike | None = None, out: None = None) -> NDArray[Any]: ... | |
| @overload # out: ndarray | |
| def cumsum(self, /, axis: SupportsIndex | None, dtype: DTypeLike | None, out: _ArrayT) -> _ArrayT: ... | |
| @overload | |
| def cumsum(self, /, axis: SupportsIndex | None = None, dtype: DTypeLike | None = None, *, out: _ArrayT) -> _ArrayT: ... | |
| @overload | |
| def max( | |
| self, | |
| /, | |
| axis: _ShapeLike | None = None, | |
| out: None = None, | |
| *, | |
| keepdims: builtins.bool | _NoValueType = ..., | |
| initial: _NumberLike_co | _NoValueType = ..., | |
| where: _ArrayLikeBool_co | _NoValueType = ..., | |
| ) -> Any: ... | |
| @overload | |
| def max( | |
| self, | |
| /, | |
| axis: _ShapeLike | None, | |
| out: _ArrayT, | |
| *, | |
| keepdims: builtins.bool | _NoValueType = ..., | |
| initial: _NumberLike_co | _NoValueType = ..., | |
| where: _ArrayLikeBool_co | _NoValueType = ..., | |
| ) -> _ArrayT: ... | |
| @overload | |
| def max( | |
| self, | |
| /, | |
| axis: _ShapeLike | None = None, | |
| *, | |
| out: _ArrayT, | |
| keepdims: builtins.bool | _NoValueType = ..., | |
| initial: _NumberLike_co | _NoValueType = ..., | |
| where: _ArrayLikeBool_co | _NoValueType = ..., | |
| ) -> _ArrayT: ... | |
| @overload | |
| def min( | |
| self, | |
| /, | |
| axis: _ShapeLike | None = None, | |
| out: None = None, | |
| *, | |
| keepdims: builtins.bool | _NoValueType = ..., | |
| initial: _NumberLike_co | _NoValueType = ..., | |
| where: _ArrayLikeBool_co | _NoValueType = ..., | |
| ) -> Any: ... | |
| @overload | |
| def min( | |
| self, | |
| /, | |
| axis: _ShapeLike | None, | |
| out: _ArrayT, | |
| *, | |
| keepdims: builtins.bool | _NoValueType = ..., | |
| initial: _NumberLike_co | _NoValueType = ..., | |
| where: _ArrayLikeBool_co | _NoValueType = ..., | |
| ) -> _ArrayT: ... | |
| @overload | |
| def min( | |
| self, | |
| /, | |
| axis: _ShapeLike | None = None, | |
| *, | |
| out: _ArrayT, | |
| keepdims: builtins.bool | _NoValueType = ..., | |
| initial: _NumberLike_co | _NoValueType = ..., | |
| where: _ArrayLikeBool_co | _NoValueType = ..., | |
| ) -> _ArrayT: ... | |
| @overload | |
| def sum( | |
| self, | |
| /, | |
| axis: _ShapeLike | None = None, | |
| dtype: DTypeLike | None = None, | |
| out: None = None, | |
| *, | |
| keepdims: builtins.bool | _NoValueType = ..., | |
| initial: _NumberLike_co | _NoValueType = ..., | |
| where: _ArrayLikeBool_co | _NoValueType = ..., | |
| ) -> Any: ... | |
| @overload | |
| def sum( | |
| self, | |
| /, | |
| axis: _ShapeLike | None, | |
| dtype: DTypeLike | None, | |
| out: _ArrayT, | |
| *, | |
| keepdims: builtins.bool | _NoValueType = ..., | |
| initial: _NumberLike_co | _NoValueType = ..., | |
| where: _ArrayLikeBool_co | _NoValueType = ..., | |
| ) -> _ArrayT: ... | |
| @overload | |
| def sum( | |
| self, | |
| /, | |
| axis: _ShapeLike | None = None, | |
| dtype: DTypeLike | None = None, | |
| *, | |
| out: _ArrayT, | |
| keepdims: builtins.bool | _NoValueType = ..., | |
| initial: _NumberLike_co | _NoValueType = ..., | |
| where: _ArrayLikeBool_co | _NoValueType = ..., | |
| ) -> _ArrayT: ... | |
| @overload | |
| def prod( | |
| self, | |
| /, | |
| axis: _ShapeLike | None = None, | |
| dtype: DTypeLike | None = None, | |
| out: None = None, | |
| *, | |
| keepdims: builtins.bool | _NoValueType = ..., | |
| initial: _NumberLike_co | _NoValueType = ..., | |
| where: _ArrayLikeBool_co | _NoValueType = ..., | |
| ) -> Any: ... | |
| @overload | |
| def prod( | |
| self, | |
| /, | |
| axis: _ShapeLike | None, | |
| dtype: DTypeLike | None, | |
| out: _ArrayT, | |
| *, | |
| keepdims: builtins.bool | _NoValueType = ..., | |
| initial: _NumberLike_co | _NoValueType = ..., | |
| where: _ArrayLikeBool_co | _NoValueType = ..., | |
| ) -> _ArrayT: ... | |
| @overload | |
| def prod( | |
| self, | |
| /, | |
| axis: _ShapeLike | None = None, | |
| dtype: DTypeLike | None = None, | |
| *, | |
| out: _ArrayT, | |
| keepdims: builtins.bool | _NoValueType = ..., | |
| initial: _NumberLike_co | _NoValueType = ..., | |
| where: _ArrayLikeBool_co | _NoValueType = ..., | |
| ) -> _ArrayT: ... | |
| @overload | |
| def mean( | |
| self, | |
| axis: _ShapeLike | None = None, | |
| dtype: DTypeLike | None = None, | |
| out: None = None, | |
| *, | |
| keepdims: builtins.bool | _NoValueType = ..., | |
| where: _ArrayLikeBool_co | _NoValueType = ..., | |
| ) -> Any: ... | |
| @overload | |
| def mean( | |
| self, | |
| /, | |
| axis: _ShapeLike | None, | |
| dtype: DTypeLike | None, | |
| out: _ArrayT, | |
| *, | |
| keepdims: builtins.bool | _NoValueType = ..., | |
| where: _ArrayLikeBool_co | _NoValueType = ..., | |
| ) -> _ArrayT: ... | |
| @overload | |
| def mean( | |
| self, | |
| /, | |
| axis: _ShapeLike | None = None, | |
| dtype: DTypeLike | None = None, | |
| *, | |
| out: _ArrayT, | |
| keepdims: builtins.bool | _NoValueType = ..., | |
| where: _ArrayLikeBool_co | _NoValueType = ..., | |
| ) -> _ArrayT: ... | |
| @overload | |
| def std( | |
| self, | |
| axis: _ShapeLike | None = None, | |
| dtype: DTypeLike | None = None, | |
| out: None = None, | |
| ddof: float = 0, | |
| *, | |
| keepdims: builtins.bool | _NoValueType = ..., | |
| where: _ArrayLikeBool_co | _NoValueType = ..., | |
| mean: _ArrayLikeNumber_co | _NoValueType = ..., | |
| correction: float | _NoValueType = ..., | |
| ) -> Any: ... | |
| @overload | |
| def std( | |
| self, | |
| axis: _ShapeLike | None, | |
| dtype: DTypeLike | None, | |
| out: _ArrayT, | |
| ddof: float = 0, | |
| *, | |
| keepdims: builtins.bool | _NoValueType = ..., | |
| where: _ArrayLikeBool_co | _NoValueType = ..., | |
| mean: _ArrayLikeNumber_co | _NoValueType = ..., | |
| correction: float | _NoValueType = ..., | |
| ) -> _ArrayT: ... | |
| @overload | |
| def std( | |
| self, | |
| axis: _ShapeLike | None = None, | |
| dtype: DTypeLike | None = None, | |
| *, | |
| out: _ArrayT, | |
| ddof: float = 0, | |
| keepdims: builtins.bool | _NoValueType = ..., | |
| where: _ArrayLikeBool_co | _NoValueType = ..., | |
| mean: _ArrayLikeNumber_co | _NoValueType = ..., | |
| correction: float | _NoValueType = ..., | |
| ) -> _ArrayT: ... | |
| @overload | |
| def var( | |
| self, | |
| axis: _ShapeLike | None = None, | |
| dtype: DTypeLike | None = None, | |
| out: None = None, | |
| ddof: float = 0, | |
| *, | |
| keepdims: builtins.bool | _NoValueType = ..., | |
| where: _ArrayLikeBool_co | _NoValueType = ..., | |
| mean: _ArrayLikeNumber_co | _NoValueType = ..., | |
| correction: float | _NoValueType = ..., | |
| ) -> Any: ... | |
| @overload | |
| def var( | |
| self, | |
| axis: _ShapeLike | None, | |
| dtype: DTypeLike | None, | |
| out: _ArrayT, | |
| ddof: float = 0, | |
| *, | |
| keepdims: builtins.bool | _NoValueType = ..., | |
| where: _ArrayLikeBool_co | _NoValueType = ..., | |
| mean: _ArrayLikeNumber_co | _NoValueType = ..., | |
| correction: float | _NoValueType = ..., | |
| ) -> _ArrayT: ... | |
| @overload | |
| def var( | |
| self, | |
| axis: _ShapeLike | None = None, | |
| dtype: DTypeLike | None = None, | |
| *, | |
| out: _ArrayT, | |
| ddof: float = 0, | |
| keepdims: builtins.bool | _NoValueType = ..., | |
| where: _ArrayLikeBool_co | _NoValueType = ..., | |
| mean: _ArrayLikeNumber_co | _NoValueType = ..., | |
| correction: float | _NoValueType = ..., | |
| ) -> _ArrayT: ... | |
| class ndarray(_ArrayOrScalarCommon, Generic[_ShapeT_co, _DTypeT_co]): | |
| __hash__: ClassVar[None] # type: ignore[assignment] # pyright: ignore[reportIncompatibleMethodOverride] | |
| @property | |
| def base(self) -> NDArray[Any] | None: ... | |
| @property | |
| def ndim(self) -> int: ... | |
| @property | |
| def size(self) -> int: ... | |
| @property | |
| def real(self: _HasDTypeWithRealAndImag[_ScalarT, object], /) -> ndarray[_ShapeT_co, dtype[_ScalarT]]: ... | |
| @real.setter | |
| def real(self, value: ArrayLike, /) -> None: ... | |
| @property | |
| def imag(self: _HasDTypeWithRealAndImag[object, _ScalarT], /) -> ndarray[_ShapeT_co, dtype[_ScalarT]]: ... | |
| @imag.setter | |
| def imag(self, value: ArrayLike, /) -> None: ... | |
| def __new__( | |
| cls, | |
| shape: _ShapeLike, | |
| dtype: DTypeLike | None = ..., | |
| buffer: _SupportsBuffer | None = ..., | |
| offset: SupportsIndex = ..., | |
| strides: _ShapeLike | None = ..., | |
| order: _OrderKACF = ..., | |
| ) -> Self: ... | |
| if sys.version_info >= (3, 12): | |
| def __buffer__(self, flags: int, /) -> memoryview: ... | |
| def __class_getitem__(cls, item: Any, /) -> GenericAlias: ... | |
| @overload | |
| def __array__(self, dtype: None = None, /, *, copy: builtins.bool | None = None) -> ndarray[_ShapeT_co, _DTypeT_co]: ... | |
| @overload | |
| def __array__(self, dtype: _DTypeT, /, *, copy: builtins.bool | None = None) -> ndarray[_ShapeT_co, _DTypeT]: ... | |
| def __array_ufunc__( | |
| self, | |
| ufunc: ufunc, | |
| method: L["__call__", "reduce", "reduceat", "accumulate", "outer", "at"], | |
| *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: NDArray[Any] | None, /) -> None: ... | |
| def __array_wrap__( | |
| self, | |
| array: ndarray[_ShapeT, _DTypeT], | |
| context: tuple[ufunc, tuple[Any, ...], int] | None = ..., | |
| return_scalar: builtins.bool = ..., | |
| /, | |
| ) -> ndarray[_ShapeT, _DTypeT]: ... | |
| # Keep in sync with `MaskedArray.__getitem__` | |
| @overload | |
| def __getitem__(self, key: _ArrayInt_co | tuple[_ArrayInt_co, ...], /) -> ndarray[_AnyShape, _DTypeT_co]: ... | |
| @overload | |
| def __getitem__(self, key: SupportsIndex | tuple[SupportsIndex, ...], /) -> Any: ... | |
| @overload | |
| def __getitem__(self, key: _ToIndices, /) -> ndarray[_AnyShape, _DTypeT_co]: ... | |
| @overload # can be of any shape | |
| def __getitem__(self: NDArray[void], key: str, /) -> ndarray[_ShapeT_co | _AnyShape]: ... | |
| @overload | |
| def __getitem__(self: NDArray[void], key: list[str], /) -> ndarray[_ShapeT_co | _AnyShape, dtype[void]]: ... | |
| @overload # flexible | object_ | bool | |
| def __setitem__( | |
| self: ndarray[Any, dtype[flexible | object_ | np.bool] | dtypes.StringDType], | |
| key: _ToIndices, | |
| value: object, | |
| /, | |
| ) -> None: ... | |
| @overload # integer | |
| def __setitem__( | |
| self: NDArray[integer], | |
| key: _ToIndices, | |
| value: _ConvertibleToInt | _NestedSequence[_ConvertibleToInt] | _ArrayLikeInt_co, | |
| /, | |
| ) -> None: ... | |
| @overload # floating | |
| def __setitem__( | |
| self: NDArray[floating], | |
| key: _ToIndices, | |
| value: _ConvertibleToFloat | _NestedSequence[_ConvertibleToFloat | None] | _ArrayLikeFloat_co | None, | |
| /, | |
| ) -> None: ... | |
| @overload # complexfloating | |
| def __setitem__( | |
| self: NDArray[complexfloating], | |
| key: _ToIndices, | |
| value: _ConvertibleToComplex | _NestedSequence[_ConvertibleToComplex | None] | _ArrayLikeNumber_co | None, | |
| /, | |
| ) -> None: ... | |
| @overload # timedelta64 | |
| def __setitem__( | |
| self: NDArray[timedelta64], | |
| key: _ToIndices, | |
| value: _ConvertibleToTD64 | _NestedSequence[_ConvertibleToTD64], | |
| /, | |
| ) -> None: ... | |
| @overload # datetime64 | |
| def __setitem__( | |
| self: NDArray[datetime64], | |
| key: _ToIndices, | |
| value: _ConvertibleToDT64 | _NestedSequence[_ConvertibleToDT64], | |
| /, | |
| ) -> None: ... | |
| @overload # void | |
| def __setitem__(self: NDArray[void], key: str | list[str], value: object, /) -> None: ... | |
| @overload # catch-all | |
| def __setitem__(self, key: _ToIndices, value: ArrayLike, /) -> None: ... | |
| @property | |
| def ctypes(self) -> _ctypes[int]: ... | |
| # | |
| @property | |
| def shape(self) -> _ShapeT_co: ... | |
| @shape.setter | |
| @deprecated("In-place shape modification will be deprecated in NumPy 2.5.", category=PendingDeprecationWarning) | |
| def shape(self, value: _ShapeLike) -> None: ... | |
| # | |
| @property | |
| def strides(self) -> _Shape: ... | |
| @strides.setter | |
| @deprecated("Setting the strides on a NumPy array has been deprecated in NumPy 2.4") | |
| def strides(self, value: _ShapeLike) -> None: ... | |
| # | |
| def byteswap(self, inplace: builtins.bool = ...) -> Self: ... | |
| @property | |
| def flat(self) -> flatiter[Self]: ... | |
| @overload # use the same output type as that of the underlying `generic` | |
| def item(self: NDArray[generic[_T]], i0: SupportsIndex | tuple[SupportsIndex, ...] = ..., /, *args: SupportsIndex) -> _T: ... | |
| @overload # special casing for `StringDType`, which has no scalar type | |
| def item( | |
| self: ndarray[Any, dtypes.StringDType], | |
| arg0: SupportsIndex | tuple[SupportsIndex, ...] = ..., | |
| /, | |
| *args: SupportsIndex, | |
| ) -> str: ... | |
| # keep in sync with `ma.MaskedArray.tolist` | |
| @overload # this first overload prevents mypy from over-eagerly selecting `tuple[()]` in case of `_AnyShape` | |
| def tolist(self: ndarray[tuple[Never], dtype[generic[_T]]], /) -> Any: ... | |
| @overload | |
| def tolist(self: ndarray[tuple[()], dtype[generic[_T]]], /) -> _T: ... | |
| @overload | |
| def tolist(self: ndarray[tuple[int], dtype[generic[_T]]], /) -> list[_T]: ... | |
| @overload | |
| def tolist(self: ndarray[tuple[int, int], dtype[generic[_T]]], /) -> list[list[_T]]: ... | |
| @overload | |
| def tolist(self: ndarray[tuple[int, int, int], dtype[generic[_T]]], /) -> list[list[list[_T]]]: ... | |
| @overload | |
| def tolist(self, /) -> Any: ... | |
| @overload | |
| def resize(self, new_shape: _ShapeLike, /, *, refcheck: builtins.bool = True) -> None: ... | |
| @overload | |
| def resize(self, /, *new_shape: SupportsIndex, refcheck: builtins.bool = True) -> None: ... | |
| # keep in sync with `ma.MaskedArray.squeeze` | |
| def squeeze( | |
| self, | |
| /, | |
| axis: SupportsIndex | tuple[SupportsIndex, ...] | None = ..., | |
| ) -> ndarray[_AnyShape, _DTypeT_co]: ... | |
| def swapaxes(self, axis1: SupportsIndex, axis2: SupportsIndex, /) -> Self: ... | |
| @overload | |
| def transpose(self, axes: _ShapeLike | None, /) -> Self: ... | |
| @overload | |
| def transpose(self, /, *axes: SupportsIndex) -> Self: ... | |
| @overload | |
| def all( | |
| self, | |
| axis: None = None, | |
| out: None = None, | |
| keepdims: L[False, 0] = False, | |
| *, | |
| where: _ArrayLikeBool_co = True | |
| ) -> np.bool: ... | |
| @overload | |
| def all( | |
| self, | |
| axis: int | tuple[int, ...] | None = None, | |
| out: None = None, | |
| keepdims: SupportsIndex = False, | |
| *, | |
| where: _ArrayLikeBool_co = True, | |
| ) -> np.bool | NDArray[np.bool]: ... | |
| @overload | |
| def all( | |
| self, | |
| axis: int | tuple[int, ...] | None, | |
| out: _ArrayT, | |
| keepdims: SupportsIndex = False, | |
| *, | |
| where: _ArrayLikeBool_co = True, | |
| ) -> _ArrayT: ... | |
| @overload | |
| def all( | |
| self, | |
| axis: int | tuple[int, ...] | None = None, | |
| *, | |
| out: _ArrayT, | |
| keepdims: SupportsIndex = False, | |
| where: _ArrayLikeBool_co = True, | |
| ) -> _ArrayT: ... | |
| @overload | |
| def any( | |
| self, | |
| axis: None = None, | |
| out: None = None, | |
| keepdims: L[False, 0] = False, | |
| *, | |
| where: _ArrayLikeBool_co = True | |
| ) -> np.bool: ... | |
| @overload | |
| def any( | |
| self, | |
| axis: int | tuple[int, ...] | None = None, | |
| out: None = None, | |
| keepdims: SupportsIndex = False, | |
| *, | |
| where: _ArrayLikeBool_co = True, | |
| ) -> np.bool | NDArray[np.bool]: ... | |
| @overload | |
| def any( | |
| self, | |
| axis: int | tuple[int, ...] | None, | |
| out: _ArrayT, | |
| keepdims: SupportsIndex = False, | |
| *, | |
| where: _ArrayLikeBool_co = True, | |
| ) -> _ArrayT: ... | |
| @overload | |
| def any( | |
| self, | |
| axis: int | tuple[int, ...] | None = None, | |
| *, | |
| out: _ArrayT, | |
| keepdims: SupportsIndex = False, | |
| where: _ArrayLikeBool_co = True, | |
| ) -> _ArrayT: ... | |
| # | |
| @overload | |
| def partition( | |
| self, | |
| kth: _ArrayLikeInt, | |
| /, | |
| axis: SupportsIndex = -1, | |
| kind: _PartitionKind = "introselect", | |
| order: None = None, | |
| ) -> None: ... | |
| @overload | |
| def partition( | |
| self: NDArray[void], | |
| kth: _ArrayLikeInt, | |
| /, | |
| axis: SupportsIndex = -1, | |
| kind: _PartitionKind = "introselect", | |
| order: str | Sequence[str] | None = None, | |
| ) -> None: ... | |
| # | |
| @overload | |
| def argpartition( | |
| self, | |
| kth: _ArrayLikeInt, | |
| /, | |
| axis: SupportsIndex | None = -1, | |
| kind: _PartitionKind = "introselect", | |
| order: None = None, | |
| ) -> NDArray[intp]: ... | |
| @overload | |
| def argpartition( | |
| self: NDArray[void], | |
| kth: _ArrayLikeInt, | |
| /, | |
| axis: SupportsIndex | None = -1, | |
| kind: _PartitionKind = "introselect", | |
| order: str | Sequence[str] | None = None, | |
| ) -> NDArray[intp]: ... | |
| # keep in sync with `ma.MaskedArray.diagonal` | |
| def diagonal( | |
| self, | |
| offset: SupportsIndex = 0, | |
| axis1: SupportsIndex = 0, | |
| axis2: SupportsIndex = 1, | |
| ) -> ndarray[_AnyShape, _DTypeT_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 = None) -> NDArray[Any]: ... | |
| @overload | |
| def dot(self, b: ArrayLike, /, out: None = None) -> Any: ... | |
| @overload | |
| def dot(self, b: ArrayLike, /, out: _ArrayT) -> _ArrayT: ... | |
| # `nonzero()` raises for 0d arrays/generics | |
| def nonzero(self) -> tuple[ndarray[tuple[int], np.dtype[intp]], ...]: ... | |
| @overload | |
| def searchsorted( | |
| self, # >= 1D array | |
| v: _ScalarLike_co, # 0D array-like | |
| /, | |
| side: _SortSide = "left", | |
| sorter: _ArrayLikeInt_co | None = None, | |
| ) -> intp: ... | |
| @overload | |
| def searchsorted( | |
| self, # >= 1D array | |
| v: ArrayLike, | |
| /, | |
| side: _SortSide = "left", | |
| sorter: _ArrayLikeInt_co | None = None, | |
| ) -> NDArray[intp]: ... | |
| def sort( | |
| self, | |
| /, | |
| axis: SupportsIndex = -1, | |
| kind: _SortKind | None = None, | |
| order: str | Sequence[str] | None = None, | |
| *, | |
| stable: builtins.bool | None = None, | |
| ) -> None: ... | |
| # Keep in sync with `MaskedArray.trace` | |
| @overload | |
| def trace( | |
| self, # >= 2D array | |
| /, | |
| offset: SupportsIndex = 0, | |
| axis1: SupportsIndex = 0, | |
| axis2: SupportsIndex = 1, | |
| dtype: DTypeLike | None = None, | |
| out: None = None, | |
| ) -> Any: ... | |
| @overload | |
| def trace( | |
| self, # >= 2D array | |
| /, | |
| offset: SupportsIndex = 0, | |
| axis1: SupportsIndex = 0, | |
| axis2: SupportsIndex = 1, | |
| dtype: DTypeLike | None = None, | |
| *, | |
| out: _ArrayT, | |
| ) -> _ArrayT: ... | |
| @overload | |
| def trace( | |
| self, # >= 2D array | |
| /, | |
| offset: SupportsIndex, | |
| axis1: SupportsIndex, | |
| axis2: SupportsIndex, | |
| dtype: DTypeLike | None, | |
| out: _ArrayT, | |
| ) -> _ArrayT: ... | |
| @overload | |
| def take( | |
| self: NDArray[_ScalarT], | |
| indices: _IntLike_co, | |
| /, | |
| axis: SupportsIndex | None = ..., | |
| out: None = None, | |
| mode: _ModeKind = ..., | |
| ) -> _ScalarT: ... | |
| @overload | |
| def take( | |
| self, | |
| indices: _ArrayLikeInt_co, | |
| /, | |
| axis: SupportsIndex | None = ..., | |
| out: None = None, | |
| mode: _ModeKind = ..., | |
| ) -> ndarray[_AnyShape, _DTypeT_co]: ... | |
| @overload | |
| def take( | |
| self, | |
| indices: _ArrayLikeInt_co, | |
| /, | |
| axis: SupportsIndex | None = ..., | |
| *, | |
| out: _ArrayT, | |
| mode: _ModeKind = ..., | |
| ) -> _ArrayT: ... | |
| @overload | |
| def take( | |
| self, | |
| indices: _ArrayLikeInt_co, | |
| /, | |
| axis: SupportsIndex | None, | |
| out: _ArrayT, | |
| mode: _ModeKind = ..., | |
| ) -> _ArrayT: ... | |
| # keep in sync with `ma.MaskedArray.repeat` | |
| @overload | |
| def repeat(self, repeats: _ArrayLikeInt_co, /, axis: None = None) -> ndarray[tuple[int], _DTypeT_co]: ... | |
| @overload | |
| def repeat(self, repeats: _ArrayLikeInt_co, /, axis: SupportsIndex) -> ndarray[_AnyShape, _DTypeT_co]: ... | |
| # keep in sync with `ma.MaskedArray.flatten` and `ma.MaskedArray.ravel` | |
| def flatten(self, /, order: _OrderKACF = "C") -> ndarray[tuple[int], _DTypeT_co]: ... | |
| def ravel(self, /, order: _OrderKACF = "C") -> ndarray[tuple[int], _DTypeT_co]: ... | |
| # Keep in sync with `MaskedArray.reshape` | |
| # NOTE: reshape also accepts negative integers, so we can't use integer literals | |
| @overload # (None) | |
| def reshape(self, shape: None, /, *, order: _OrderACF = "C", copy: builtins.bool | None = None) -> Self: ... | |
| @overload # (empty_sequence) | |
| def reshape( # type: ignore[overload-overlap] # mypy false positive | |
| self, | |
| shape: Sequence[Never], | |
| /, | |
| *, | |
| order: _OrderACF = "C", | |
| copy: builtins.bool | None = None, | |
| ) -> ndarray[tuple[()], _DTypeT_co]: ... | |
| @overload # (() | (int) | (int, int) | ....) # up to 8-d | |
| def reshape( | |
| self, | |
| shape: _AnyShapeT, | |
| /, | |
| *, | |
| order: _OrderACF = "C", | |
| copy: builtins.bool | None = None, | |
| ) -> ndarray[_AnyShapeT, _DTypeT_co]: ... | |
| @overload # (index) | |
| def reshape( | |
| self, | |
| size1: SupportsIndex, | |
| /, | |
| *, | |
| order: _OrderACF = "C", | |
| copy: builtins.bool | None = None, | |
| ) -> ndarray[tuple[int], _DTypeT_co]: ... | |
| @overload # (index, index) | |
| def reshape( | |
| self, | |
| size1: SupportsIndex, | |
| size2: SupportsIndex, | |
| /, | |
| *, | |
| order: _OrderACF = "C", | |
| copy: builtins.bool | None = None, | |
| ) -> ndarray[tuple[int, int], _DTypeT_co]: ... | |
| @overload # (index, index, index) | |
| def reshape( | |
| self, | |
| size1: SupportsIndex, | |
| size2: SupportsIndex, | |
| size3: SupportsIndex, | |
| /, | |
| *, | |
| order: _OrderACF = "C", | |
| copy: builtins.bool | None = None, | |
| ) -> ndarray[tuple[int, int, int], _DTypeT_co]: ... | |
| @overload # (index, index, index, index) | |
| def reshape( | |
| self, | |
| size1: SupportsIndex, | |
| size2: SupportsIndex, | |
| size3: SupportsIndex, | |
| size4: SupportsIndex, | |
| /, | |
| *, | |
| order: _OrderACF = "C", | |
| copy: builtins.bool | None = None, | |
| ) -> ndarray[tuple[int, int, int, int], _DTypeT_co]: ... | |
| @overload # (int, *(index, ...)) | |
| def reshape( | |
| self, | |
| size0: SupportsIndex, | |
| /, | |
| *shape: SupportsIndex, | |
| order: _OrderACF = "C", | |
| copy: builtins.bool | None = None, | |
| ) -> ndarray[_AnyShape, _DTypeT_co]: ... | |
| @overload # (sequence[index]) | |
| def reshape( | |
| self, | |
| shape: Sequence[SupportsIndex], | |
| /, | |
| *, | |
| order: _OrderACF = "C", | |
| copy: builtins.bool | None = None, | |
| ) -> ndarray[_AnyShape, _DTypeT_co]: ... | |
| @overload | |
| def astype( | |
| self, | |
| dtype: _DTypeLike[_ScalarT], | |
| order: _OrderKACF = ..., | |
| casting: _CastingKind = ..., | |
| subok: builtins.bool = ..., | |
| copy: builtins.bool | _CopyMode = ..., | |
| ) -> ndarray[_ShapeT_co, dtype[_ScalarT]]: ... | |
| @overload | |
| def astype( | |
| self, | |
| dtype: DTypeLike | None, | |
| order: _OrderKACF = ..., | |
| casting: _CastingKind = ..., | |
| subok: builtins.bool = ..., | |
| copy: builtins.bool | _CopyMode = ..., | |
| ) -> ndarray[_ShapeT_co, dtype]: ... | |
| # | |
| @overload # () | |
| def view(self, /) -> Self: ... | |
| @overload # (dtype: T) | |
| def view(self, /, dtype: _DTypeT | _HasDType[_DTypeT]) -> ndarray[_ShapeT_co, _DTypeT]: ... | |
| @overload # (dtype: dtype[T]) | |
| def view(self, /, dtype: _DTypeLike[_ScalarT]) -> ndarray[_ShapeT_co, dtype[_ScalarT]]: ... | |
| @overload # (type: T) | |
| def view(self, /, *, type: type[_ArrayT]) -> _ArrayT: ... | |
| @overload # (_: T) | |
| def view(self, /, dtype: type[_ArrayT]) -> _ArrayT: ... | |
| @overload # (dtype: ?) | |
| def view(self, /, dtype: DTypeLike) -> ndarray[_ShapeT_co, dtype]: ... | |
| @overload # (dtype: ?, type: T) | |
| def view(self, /, dtype: DTypeLike, type: type[_ArrayT]) -> _ArrayT: ... | |
| def setfield(self, val: ArrayLike, /, dtype: DTypeLike, offset: SupportsIndex = 0) -> None: ... | |
| @overload | |
| def getfield(self, /, dtype: _DTypeLike[_ScalarT], offset: SupportsIndex = 0) -> NDArray[_ScalarT]: ... | |
| @overload | |
| def getfield(self, /, dtype: DTypeLike, offset: SupportsIndex = 0) -> NDArray[Any]: ... | |
| def __index__(self: NDArray[integer], /) -> int: ... | |
| def __complex__(self: NDArray[number | np.bool | object_], /) -> complex: ... | |
| def __len__(self) -> int: ... | |
| def __contains__(self, value: object, /) -> builtins.bool: ... | |
| # NOTE: This weird `Never` tuple works around a strange mypy issue where it assigns | |
| # `tuple[int]` to `tuple[Never]` or `tuple[int, int]` to `tuple[Never, Never]`. | |
| # This way the bug only occurs for 9-D arrays, which are probably not very common. | |
| @overload | |
| def __iter__( | |
| self: ndarray[tuple[Never, Never, Never, Never, Never, Never, Never, Never, Never], Any], / | |
| ) -> Iterator[Any]: ... | |
| @overload # == 1-d & dtype[T \ object_] | |
| def __iter__(self: ndarray[tuple[int], dtype[_NonObjectScalarT]], /) -> Iterator[_NonObjectScalarT]: ... | |
| @overload # == 1-d & StringDType | |
| def __iter__(self: ndarray[tuple[int], dtypes.StringDType], /) -> Iterator[str]: ... | |
| @overload # >= 2-d | |
| def __iter__(self: ndarray[tuple[int, int, *tuple[int, ...]], _DTypeT], /) -> Iterator[ndarray[_AnyShape, _DTypeT]]: ... | |
| @overload # ?-d | |
| def __iter__(self, /) -> Iterator[Any]: ... | |
| # | |
| @overload | |
| def __lt__(self: _ArrayNumber_co, other: _ArrayLikeNumber_co, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __lt__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __lt__(self: NDArray[datetime64], other: _ArrayLikeDT64_co, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __lt__(self: NDArray[bytes_], other: _ArrayLikeBytes_co, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __lt__( | |
| self: ndarray[Any, dtype[str_] | dtypes.StringDType], other: _ArrayLikeStr_co | _ArrayLikeString_co, / | |
| ) -> NDArray[np.bool]: ... | |
| @overload | |
| def __lt__(self: NDArray[object_], other: object, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __lt__(self, other: _ArrayLikeObject_co, /) -> NDArray[np.bool]: ... | |
| # | |
| @overload | |
| def __le__(self: _ArrayNumber_co, other: _ArrayLikeNumber_co, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __le__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __le__(self: NDArray[datetime64], other: _ArrayLikeDT64_co, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __le__(self: NDArray[bytes_], other: _ArrayLikeBytes_co, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __le__( | |
| self: ndarray[Any, dtype[str_] | dtypes.StringDType], other: _ArrayLikeStr_co | _ArrayLikeString_co, / | |
| ) -> NDArray[np.bool]: ... | |
| @overload | |
| def __le__(self: NDArray[object_], other: object, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __le__(self, other: _ArrayLikeObject_co, /) -> NDArray[np.bool]: ... | |
| # | |
| @overload | |
| def __gt__(self: _ArrayNumber_co, other: _ArrayLikeNumber_co, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __gt__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __gt__(self: NDArray[datetime64], other: _ArrayLikeDT64_co, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __gt__(self: NDArray[bytes_], other: _ArrayLikeBytes_co, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __gt__( | |
| self: ndarray[Any, dtype[str_] | dtypes.StringDType], other: _ArrayLikeStr_co | _ArrayLikeString_co, / | |
| ) -> NDArray[np.bool]: ... | |
| @overload | |
| def __gt__(self: NDArray[object_], other: object, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __gt__(self, other: _ArrayLikeObject_co, /) -> NDArray[np.bool]: ... | |
| # | |
| @overload | |
| def __ge__(self: _ArrayNumber_co, other: _ArrayLikeNumber_co, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __ge__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __ge__(self: NDArray[datetime64], other: _ArrayLikeDT64_co, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __ge__(self: NDArray[bytes_], other: _ArrayLikeBytes_co, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __ge__( | |
| self: ndarray[Any, dtype[str_] | dtypes.StringDType], other: _ArrayLikeStr_co | _ArrayLikeString_co, / | |
| ) -> NDArray[np.bool]: ... | |
| @overload | |
| def __ge__(self: NDArray[object_], other: object, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __ge__(self, other: _ArrayLikeObject_co, /) -> NDArray[np.bool]: ... | |
| # Unary ops | |
| # TODO: Uncomment once https://github.com/python/mypy/issues/14070 is fixed | |
| # @overload | |
| # def __abs__(self: ndarray[_ShapeT, dtypes.Complex64DType], /) -> ndarray[_ShapeT, dtypes.Float32DType]: ... | |
| # @overload | |
| # def __abs__(self: ndarray[_ShapeT, dtypes.Complex128DType], /) -> ndarray[_ShapeT, dtypes.Float64DType]: ... | |
| # @overload | |
| # def __abs__(self: ndarray[_ShapeT, dtypes.CLongDoubleDType], /) -> ndarray[_ShapeT, dtypes.LongDoubleDType]: ... | |
| # @overload | |
| # def __abs__(self: ndarray[_ShapeT, dtype[complex128]], /) -> ndarray[_ShapeT, dtype[float64]]: ... | |
| @overload | |
| def __abs__(self: ndarray[_ShapeT, dtype[complexfloating[_NBit]]], /) -> ndarray[_ShapeT, dtype[floating[_NBit]]]: ... | |
| @overload | |
| def __abs__(self: _RealArrayT, /) -> _RealArrayT: ... | |
| def __invert__(self: _IntegralArrayT, /) -> _IntegralArrayT: ... # noqa: PYI019 | |
| def __neg__(self: _NumericArrayT, /) -> _NumericArrayT: ... # noqa: PYI019 | |
| def __pos__(self: _NumericArrayT, /) -> _NumericArrayT: ... # noqa: PYI019 | |
| # Binary ops | |
| # TODO: Support the "1d @ 1d -> scalar" case | |
| @overload | |
| def __matmul__(self: NDArray[_NumberT], other: _ArrayLikeBool_co, /) -> NDArray[_NumberT]: ... | |
| @overload | |
| def __matmul__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __matmul__(self: NDArray[np.bool], other: _ArrayLike[_NumberT], /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __matmul__(self: NDArray[floating[_64Bit]], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... | |
| @overload | |
| def __matmul__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... | |
| @overload | |
| def __matmul__(self: NDArray[complexfloating[_64Bit]], other: _ArrayLikeComplex128_co, /) -> NDArray[complex128]: ... | |
| @overload | |
| def __matmul__(self: _ArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> NDArray[complex128]: ... | |
| @overload | |
| def __matmul__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __matmul__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __matmul__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __matmul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating]: ... | |
| @overload | |
| def __matmul__(self: NDArray[number], other: _ArrayLikeNumber_co, /) -> NDArray[number]: ... | |
| @overload | |
| def __matmul__(self: NDArray[object_], other: Any, /) -> Any: ... | |
| @overload | |
| def __matmul__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... | |
| @overload # signature equivalent to __matmul__ | |
| def __rmatmul__(self: NDArray[_NumberT], other: _ArrayLikeBool_co, /) -> NDArray[_NumberT]: ... | |
| @overload | |
| def __rmatmul__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rmatmul__(self: NDArray[np.bool], other: _ArrayLike[_NumberT], /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rmatmul__(self: NDArray[floating[_64Bit]], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... | |
| @overload | |
| def __rmatmul__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... | |
| @overload | |
| def __rmatmul__(self: NDArray[complexfloating[_64Bit]], other: _ArrayLikeComplex128_co, /) -> NDArray[complex128]: ... | |
| @overload | |
| def __rmatmul__(self: _ArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> NDArray[complex128]: ... | |
| @overload | |
| def __rmatmul__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rmatmul__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rmatmul__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rmatmul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating]: ... | |
| @overload | |
| def __rmatmul__(self: NDArray[number], other: _ArrayLikeNumber_co, /) -> NDArray[number]: ... | |
| @overload | |
| def __rmatmul__(self: NDArray[object_], other: Any, /) -> Any: ... | |
| @overload | |
| def __rmatmul__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... | |
| @overload | |
| def __mod__(self: NDArray[_RealNumberT], other: int | np.bool, /) -> ndarray[_ShapeT_co, dtype[_RealNumberT]]: ... | |
| @overload | |
| def __mod__(self: NDArray[_RealNumberT], other: _ArrayLikeBool_co, /) -> NDArray[_RealNumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __mod__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __mod__(self: NDArray[np.bool], other: _ArrayLike[_RealNumberT], /) -> NDArray[_RealNumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __mod__(self: NDArray[float64], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... | |
| @overload | |
| def __mod__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... | |
| @overload | |
| def __mod__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __mod__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __mod__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... | |
| @overload | |
| def __mod__(self: NDArray[timedelta64], other: _ArrayLike[timedelta64], /) -> NDArray[timedelta64]: ... | |
| @overload | |
| def __mod__(self: NDArray[object_], other: Any, /) -> Any: ... | |
| @overload | |
| def __mod__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... | |
| @overload # signature equivalent to __mod__ | |
| def __rmod__(self: NDArray[_RealNumberT], other: int | np.bool, /) -> ndarray[_ShapeT_co, dtype[_RealNumberT]]: ... | |
| @overload | |
| def __rmod__(self: NDArray[_RealNumberT], other: _ArrayLikeBool_co, /) -> NDArray[_RealNumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rmod__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rmod__(self: NDArray[np.bool], other: _ArrayLike[_RealNumberT], /) -> NDArray[_RealNumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rmod__(self: NDArray[float64], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... | |
| @overload | |
| def __rmod__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... | |
| @overload | |
| def __rmod__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rmod__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rmod__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... | |
| @overload | |
| def __rmod__(self: NDArray[timedelta64], other: _ArrayLike[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[_RealNumberT], rhs: int | np.bool, /) -> _2Tuple[ndarray[_ShapeT_co, dtype[_RealNumberT]]]: ... | |
| @overload | |
| def __divmod__(self: NDArray[_RealNumberT], rhs: _ArrayLikeBool_co, /) -> _2Tuple[NDArray[_RealNumberT]]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __divmod__(self: NDArray[np.bool], rhs: _ArrayLikeBool_co, /) -> _2Tuple[NDArray[int8]]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __divmod__(self: NDArray[np.bool], rhs: _ArrayLike[_RealNumberT], /) -> _2Tuple[NDArray[_RealNumberT]]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __divmod__(self: NDArray[float64], rhs: _ArrayLikeFloat64_co, /) -> _2Tuple[NDArray[float64]]: ... | |
| @overload | |
| def __divmod__(self: _ArrayFloat64_co, rhs: _ArrayLike[floating[_64Bit]], /) -> _2Tuple[NDArray[float64]]: ... | |
| @overload | |
| def __divmod__(self: _ArrayUInt_co, rhs: _ArrayLikeUInt_co, /) -> _2Tuple[NDArray[unsignedinteger]]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __divmod__(self: _ArrayInt_co, rhs: _ArrayLikeInt_co, /) -> _2Tuple[NDArray[signedinteger]]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __divmod__(self: _ArrayFloat_co, rhs: _ArrayLikeFloat_co, /) -> _2Tuple[NDArray[floating]]: ... | |
| @overload | |
| def __divmod__(self: NDArray[timedelta64], rhs: _ArrayLike[timedelta64], /) -> tuple[NDArray[int64], NDArray[timedelta64]]: ... | |
| @overload # signature equivalent to __divmod__ | |
| def __rdivmod__(self: NDArray[_RealNumberT], lhs: int | np.bool, /) -> _2Tuple[ndarray[_ShapeT_co, dtype[_RealNumberT]]]: ... | |
| @overload | |
| def __rdivmod__(self: NDArray[_RealNumberT], lhs: _ArrayLikeBool_co, /) -> _2Tuple[NDArray[_RealNumberT]]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rdivmod__(self: NDArray[np.bool], lhs: _ArrayLikeBool_co, /) -> _2Tuple[NDArray[int8]]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rdivmod__(self: NDArray[np.bool], lhs: _ArrayLike[_RealNumberT], /) -> _2Tuple[NDArray[_RealNumberT]]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rdivmod__(self: NDArray[float64], lhs: _ArrayLikeFloat64_co, /) -> _2Tuple[NDArray[float64]]: ... | |
| @overload | |
| def __rdivmod__(self: _ArrayFloat64_co, lhs: _ArrayLike[floating[_64Bit]], /) -> _2Tuple[NDArray[float64]]: ... | |
| @overload | |
| def __rdivmod__(self: _ArrayUInt_co, lhs: _ArrayLikeUInt_co, /) -> _2Tuple[NDArray[unsignedinteger]]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rdivmod__(self: _ArrayInt_co, lhs: _ArrayLikeInt_co, /) -> _2Tuple[NDArray[signedinteger]]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rdivmod__(self: _ArrayFloat_co, lhs: _ArrayLikeFloat_co, /) -> _2Tuple[NDArray[floating]]: ... | |
| @overload | |
| def __rdivmod__(self: NDArray[timedelta64], lhs: _ArrayLike[timedelta64], /) -> tuple[NDArray[int64], NDArray[timedelta64]]: ... | |
| # Keep in sync with `MaskedArray.__add__` | |
| @overload | |
| def __add__(self: NDArray[_NumberT], other: int | np.bool, /) -> ndarray[_ShapeT_co, dtype[_NumberT]]: ... | |
| @overload | |
| def __add__(self: NDArray[_NumberT], other: _ArrayLikeBool_co, /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __add__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __add__(self: NDArray[np.bool], other: _ArrayLike[_NumberT], /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __add__(self: NDArray[float64], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... | |
| @overload | |
| def __add__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... | |
| @overload | |
| def __add__(self: NDArray[complex128], other: _ArrayLikeComplex128_co, /) -> NDArray[complex128]: ... | |
| @overload | |
| def __add__(self: _ArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> NDArray[complex128]: ... | |
| @overload | |
| def __add__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __add__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __add__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __add__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __add__(self: NDArray[number], other: _ArrayLikeNumber_co, /) -> NDArray[number]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __add__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... | |
| @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[bytes_], other: _ArrayLikeBytes_co, /) -> NDArray[bytes_]: ... | |
| @overload | |
| def __add__(self: NDArray[str_], other: _ArrayLikeStr_co, /) -> NDArray[str_]: ... | |
| @overload | |
| def __add__( | |
| self: ndarray[Any, dtypes.StringDType], | |
| other: _ArrayLikeStr_co | _ArrayLikeString_co, | |
| /, | |
| ) -> ndarray[tuple[Any, ...], dtypes.StringDType]: ... | |
| @overload | |
| def __add__(self: NDArray[object_], other: Any, /) -> Any: ... | |
| @overload | |
| def __add__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... | |
| # Keep in sync with `MaskedArray.__radd__` | |
| @overload # signature equivalent to __add__ | |
| def __radd__(self: NDArray[_NumberT], other: int | np.bool, /) -> ndarray[_ShapeT_co, dtype[_NumberT]]: ... | |
| @overload | |
| def __radd__(self: NDArray[_NumberT], other: _ArrayLikeBool_co, /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __radd__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __radd__(self: NDArray[np.bool], other: _ArrayLike[_NumberT], /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __radd__(self: NDArray[float64], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... | |
| @overload | |
| def __radd__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... | |
| @overload | |
| def __radd__(self: NDArray[complex128], other: _ArrayLikeComplex128_co, /) -> NDArray[complex128]: ... | |
| @overload | |
| def __radd__(self: _ArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> NDArray[complex128]: ... | |
| @overload | |
| def __radd__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __radd__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __radd__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __radd__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __radd__(self: NDArray[number], other: _ArrayLikeNumber_co, /) -> NDArray[number]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __radd__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... | |
| @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[bytes_], other: _ArrayLikeBytes_co, /) -> NDArray[bytes_]: ... | |
| @overload | |
| def __radd__(self: NDArray[str_], other: _ArrayLikeStr_co, /) -> NDArray[str_]: ... | |
| @overload | |
| def __radd__( | |
| self: ndarray[Any, dtypes.StringDType], | |
| other: _ArrayLikeStr_co | _ArrayLikeString_co, | |
| /, | |
| ) -> ndarray[tuple[Any, ...], dtypes.StringDType]: ... | |
| @overload | |
| def __radd__(self: NDArray[object_], other: Any, /) -> Any: ... | |
| @overload | |
| def __radd__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... | |
| # Keep in sync with `MaskedArray.__sub__` | |
| @overload | |
| def __sub__(self: NDArray[_NumberT], other: int | np.bool, /) -> ndarray[_ShapeT_co, dtype[_NumberT]]: ... | |
| @overload | |
| def __sub__(self: NDArray[_NumberT], other: _ArrayLikeBool_co, /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __sub__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NoReturn: ... | |
| @overload | |
| def __sub__(self: NDArray[np.bool], other: _ArrayLike[_NumberT], /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __sub__(self: NDArray[float64], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... | |
| @overload | |
| def __sub__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... | |
| @overload | |
| def __sub__(self: NDArray[complex128], other: _ArrayLikeComplex128_co, /) -> NDArray[complex128]: ... | |
| @overload | |
| def __sub__(self: _ArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> NDArray[complex128]: ... | |
| @overload | |
| def __sub__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __sub__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __sub__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __sub__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __sub__(self: NDArray[number], other: _ArrayLikeNumber_co, /) -> NDArray[number]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __sub__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... | |
| @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: ... | |
| # Keep in sync with `MaskedArray.__rsub__` | |
| @overload | |
| def __rsub__(self: NDArray[_NumberT], other: int | np.bool, /) -> ndarray[_ShapeT_co, dtype[_NumberT]]: ... | |
| @overload | |
| def __rsub__(self: NDArray[_NumberT], other: _ArrayLikeBool_co, /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rsub__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NoReturn: ... | |
| @overload | |
| def __rsub__(self: NDArray[np.bool], other: _ArrayLike[_NumberT], /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rsub__(self: NDArray[float64], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... | |
| @overload | |
| def __rsub__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... | |
| @overload | |
| def __rsub__(self: NDArray[complex128], other: _ArrayLikeComplex128_co, /) -> NDArray[complex128]: ... | |
| @overload | |
| def __rsub__(self: _ArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> NDArray[complex128]: ... | |
| @overload | |
| def __rsub__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rsub__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rsub__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rsub__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rsub__(self: NDArray[number], other: _ArrayLikeNumber_co, /) -> NDArray[number]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rsub__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... | |
| @overload | |
| def __rsub__(self: _ArrayTD64_co, other: _ArrayLikeDT64_co, /) -> NDArray[datetime64]: ... | |
| @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: ... | |
| # Keep in sync with `MaskedArray.__mul__` | |
| @overload | |
| def __mul__(self: NDArray[_NumberT], other: int | np.bool, /) -> ndarray[_ShapeT_co, dtype[_NumberT]]: ... | |
| @overload | |
| def __mul__(self: NDArray[_NumberT], other: _ArrayLikeBool_co, /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __mul__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __mul__(self: NDArray[np.bool], other: _ArrayLike[_NumberT], /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __mul__(self: NDArray[float64], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... | |
| @overload | |
| def __mul__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... | |
| @overload | |
| def __mul__(self: NDArray[complex128], other: _ArrayLikeComplex128_co, /) -> NDArray[complex128]: ... | |
| @overload | |
| def __mul__(self: _ArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> NDArray[complex128]: ... | |
| @overload | |
| def __mul__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __mul__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __mul__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __mul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating]: ... | |
| @overload | |
| def __mul__(self: NDArray[number], other: _ArrayLikeNumber_co, /) -> NDArray[number]: ... | |
| @overload | |
| def __mul__(self: NDArray[timedelta64], other: _ArrayLikeFloat_co, /) -> NDArray[timedelta64]: ... | |
| @overload | |
| def __mul__(self: _ArrayFloat_co, other: _ArrayLike[timedelta64], /) -> NDArray[timedelta64]: ... | |
| @overload | |
| def __mul__( | |
| self: ndarray[Any, dtype[character] | dtypes.StringDType], | |
| other: _ArrayLikeInt, | |
| /, | |
| ) -> ndarray[tuple[Any, ...], _DTypeT_co]: ... | |
| @overload | |
| def __mul__(self: NDArray[object_], other: Any, /) -> Any: ... | |
| @overload | |
| def __mul__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... | |
| # Keep in sync with `MaskedArray.__rmul__` | |
| @overload # signature equivalent to __mul__ | |
| def __rmul__(self: NDArray[_NumberT], other: int | np.bool, /) -> ndarray[_ShapeT_co, dtype[_NumberT]]: ... | |
| @overload | |
| def __rmul__(self: NDArray[_NumberT], other: _ArrayLikeBool_co, /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rmul__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rmul__(self: NDArray[np.bool], other: _ArrayLike[_NumberT], /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rmul__(self: NDArray[float64], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... | |
| @overload | |
| def __rmul__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... | |
| @overload | |
| def __rmul__(self: NDArray[complex128], other: _ArrayLikeComplex128_co, /) -> NDArray[complex128]: ... | |
| @overload | |
| def __rmul__(self: _ArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> NDArray[complex128]: ... | |
| @overload | |
| def __rmul__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rmul__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rmul__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rmul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating]: ... | |
| @overload | |
| def __rmul__(self: NDArray[number], other: _ArrayLikeNumber_co, /) -> NDArray[number]: ... | |
| @overload | |
| def __rmul__(self: NDArray[timedelta64], other: _ArrayLikeFloat_co, /) -> NDArray[timedelta64]: ... | |
| @overload | |
| def __rmul__(self: _ArrayFloat_co, other: _ArrayLike[timedelta64], /) -> NDArray[timedelta64]: ... | |
| @overload | |
| def __rmul__( | |
| self: ndarray[Any, dtype[character] | dtypes.StringDType], | |
| other: _ArrayLikeInt, | |
| /, | |
| ) -> ndarray[tuple[Any, ...], _DTypeT_co]: ... | |
| @overload | |
| def __rmul__(self: NDArray[object_], other: Any, /) -> Any: ... | |
| @overload | |
| def __rmul__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... | |
| # Keep in sync with `MaskedArray.__truediv__` | |
| @overload | |
| def __truediv__(self: _ArrayInt_co | NDArray[float64], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... | |
| @overload | |
| def __truediv__(self: _ArrayFloat64_co, other: _ArrayLikeInt_co | _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... | |
| @overload | |
| def __truediv__(self: NDArray[complex128], other: _ArrayLikeComplex128_co, /) -> NDArray[complex128]: ... | |
| @overload | |
| def __truediv__(self: _ArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> NDArray[complex128]: ... | |
| @overload | |
| def __truediv__(self: NDArray[floating], other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... | |
| @overload | |
| def __truediv__(self: _ArrayFloat_co, other: _ArrayLike[floating], /) -> NDArray[floating]: ... | |
| @overload | |
| def __truediv__(self: NDArray[complexfloating], other: _ArrayLikeNumber_co, /) -> NDArray[complexfloating]: ... | |
| @overload | |
| def __truediv__(self: _ArrayNumber_co, other: _ArrayLike[complexfloating], /) -> NDArray[complexfloating]: ... | |
| @overload | |
| def __truediv__(self: NDArray[inexact], other: _ArrayLikeNumber_co, /) -> NDArray[inexact]: ... | |
| @overload | |
| def __truediv__(self: NDArray[number], other: _ArrayLikeNumber_co, /) -> NDArray[number]: ... | |
| @overload | |
| def __truediv__(self: NDArray[timedelta64], other: _ArrayLike[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: ... | |
| # Keep in sync with `MaskedArray.__rtruediv__` | |
| @overload | |
| def __rtruediv__(self: _ArrayInt_co | NDArray[float64], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... | |
| @overload | |
| def __rtruediv__(self: _ArrayFloat64_co, other: _ArrayLikeInt_co | _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... | |
| @overload | |
| def __rtruediv__(self: NDArray[complex128], other: _ArrayLikeComplex128_co, /) -> NDArray[complex128]: ... | |
| @overload | |
| def __rtruediv__(self: _ArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> NDArray[complex128]: ... | |
| @overload | |
| def __rtruediv__(self: NDArray[floating], other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... | |
| @overload | |
| def __rtruediv__(self: _ArrayFloat_co, other: _ArrayLike[floating], /) -> NDArray[floating]: ... | |
| @overload | |
| def __rtruediv__(self: NDArray[complexfloating], other: _ArrayLikeNumber_co, /) -> NDArray[complexfloating]: ... | |
| @overload | |
| def __rtruediv__(self: _ArrayNumber_co, other: _ArrayLike[complexfloating], /) -> NDArray[complexfloating]: ... | |
| @overload | |
| def __rtruediv__(self: NDArray[inexact], other: _ArrayLikeNumber_co, /) -> NDArray[inexact]: ... | |
| @overload | |
| def __rtruediv__(self: NDArray[number], other: _ArrayLikeNumber_co, /) -> NDArray[number]: ... | |
| @overload | |
| def __rtruediv__(self: NDArray[timedelta64], other: _ArrayLike[timedelta64], /) -> NDArray[float64]: ... | |
| @overload | |
| def __rtruediv__(self: NDArray[integer | floating], other: _ArrayLike[timedelta64], /) -> NDArray[timedelta64]: ... | |
| @overload | |
| def __rtruediv__(self: NDArray[object_], other: Any, /) -> Any: ... | |
| @overload | |
| def __rtruediv__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... | |
| # Keep in sync with `MaskedArray.__floordiv__` | |
| @overload | |
| def __floordiv__(self: NDArray[_RealNumberT], other: int | np.bool, /) -> ndarray[_ShapeT_co, dtype[_RealNumberT]]: ... | |
| @overload | |
| def __floordiv__(self: NDArray[_RealNumberT], other: _ArrayLikeBool_co, /) -> NDArray[_RealNumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __floordiv__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __floordiv__(self: NDArray[np.bool], other: _ArrayLike[_RealNumberT], /) -> NDArray[_RealNumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __floordiv__(self: NDArray[float64], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... | |
| @overload | |
| def __floordiv__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... | |
| @overload | |
| def __floordiv__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __floordiv__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __floordiv__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... | |
| @overload | |
| def __floordiv__(self: NDArray[timedelta64], other: _ArrayLike[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: ... | |
| # Keep in sync with `MaskedArray.__rfloordiv__` | |
| @overload | |
| def __rfloordiv__(self: NDArray[_RealNumberT], other: int | np.bool, /) -> ndarray[_ShapeT_co, dtype[_RealNumberT]]: ... | |
| @overload | |
| def __rfloordiv__(self: NDArray[_RealNumberT], other: _ArrayLikeBool_co, /) -> NDArray[_RealNumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rfloordiv__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rfloordiv__(self: NDArray[np.bool], other: _ArrayLike[_RealNumberT], /) -> NDArray[_RealNumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rfloordiv__(self: NDArray[float64], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... | |
| @overload | |
| def __rfloordiv__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... | |
| @overload | |
| def __rfloordiv__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rfloordiv__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rfloordiv__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... | |
| @overload | |
| def __rfloordiv__(self: NDArray[timedelta64], other: _ArrayLike[timedelta64], /) -> NDArray[int64]: ... | |
| @overload | |
| def __rfloordiv__(self: NDArray[floating | integer], other: _ArrayLike[timedelta64], /) -> NDArray[timedelta64]: ... | |
| @overload | |
| def __rfloordiv__(self: NDArray[object_], other: Any, /) -> Any: ... | |
| @overload | |
| def __rfloordiv__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... | |
| # Keep in sync with `MaskedArray.__pow__` | |
| @overload | |
| def __pow__(self: NDArray[_NumberT], other: int | np.bool, mod: None = None, /) -> ndarray[_ShapeT_co, dtype[_NumberT]]: ... | |
| @overload | |
| def __pow__(self: NDArray[_NumberT], other: _ArrayLikeBool_co, mod: None = None, /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __pow__(self: NDArray[np.bool], other: _ArrayLikeBool_co, mod: None = None, /) -> NDArray[int8]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __pow__(self: NDArray[np.bool], other: _ArrayLike[_NumberT], mod: None = None, /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __pow__(self: NDArray[float64], other: _ArrayLikeFloat64_co, mod: None = None, /) -> NDArray[float64]: ... | |
| @overload | |
| def __pow__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], mod: None = None, /) -> NDArray[float64]: ... | |
| @overload | |
| def __pow__(self: NDArray[complex128], other: _ArrayLikeComplex128_co, mod: None = None, /) -> NDArray[complex128]: ... | |
| @overload | |
| def __pow__( | |
| self: _ArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], mod: None = None, / | |
| ) -> NDArray[complex128]: ... | |
| @overload | |
| def __pow__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, mod: None = None, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __pow__(self: _ArrayInt_co, other: _ArrayLikeInt_co, mod: None = None, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __pow__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, mod: None = None, /) -> NDArray[floating]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __pow__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, mod: None = None, /) -> NDArray[complexfloating]: ... | |
| @overload | |
| def __pow__(self: NDArray[number], other: _ArrayLikeNumber_co, mod: None = None, /) -> NDArray[number]: ... | |
| @overload | |
| def __pow__(self: NDArray[object_], other: Any, mod: None = None, /) -> Any: ... | |
| @overload | |
| def __pow__(self: NDArray[Any], other: _ArrayLikeObject_co, mod: None = None, /) -> Any: ... | |
| # Keep in sync with `MaskedArray.__rpow__` | |
| @overload | |
| def __rpow__(self: NDArray[_NumberT], other: int | np.bool, mod: None = None, /) -> ndarray[_ShapeT_co, dtype[_NumberT]]: ... | |
| @overload | |
| def __rpow__(self: NDArray[_NumberT], other: _ArrayLikeBool_co, mod: None = None, /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rpow__(self: NDArray[np.bool], other: _ArrayLikeBool_co, mod: None = None, /) -> NDArray[int8]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rpow__(self: NDArray[np.bool], other: _ArrayLike[_NumberT], mod: None = None, /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rpow__(self: NDArray[float64], other: _ArrayLikeFloat64_co, mod: None = None, /) -> NDArray[float64]: ... | |
| @overload | |
| def __rpow__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], mod: None = None, /) -> NDArray[float64]: ... | |
| @overload | |
| def __rpow__(self: NDArray[complex128], other: _ArrayLikeComplex128_co, mod: None = None, /) -> NDArray[complex128]: ... | |
| @overload | |
| def __rpow__( | |
| self: _ArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], mod: None = None, / | |
| ) -> NDArray[complex128]: ... | |
| @overload | |
| def __rpow__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, mod: None = None, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rpow__(self: _ArrayInt_co, other: _ArrayLikeInt_co, mod: None = None, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rpow__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, mod: None = None, /) -> NDArray[floating]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rpow__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, mod: None = None, /) -> NDArray[complexfloating]: ... | |
| @overload | |
| def __rpow__(self: NDArray[number], other: _ArrayLikeNumber_co, mod: None = None, /) -> NDArray[number]: ... | |
| @overload | |
| def __rpow__(self: NDArray[object_], other: Any, mod: None = None, /) -> Any: ... | |
| @overload | |
| def __rpow__(self: NDArray[Any], other: _ArrayLikeObject_co, mod: None = None, /) -> Any: ... | |
| @overload | |
| def __lshift__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... | |
| @overload | |
| def __lshift__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __lshift__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... | |
| @overload | |
| def __lshift__(self: NDArray[object_], other: Any, /) -> Any: ... | |
| @overload | |
| def __lshift__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... | |
| @overload | |
| def __rlshift__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... | |
| @overload | |
| def __rlshift__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rlshift__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... | |
| @overload | |
| def __rlshift__(self: NDArray[object_], other: Any, /) -> Any: ... | |
| @overload | |
| def __rlshift__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... | |
| @overload | |
| def __rshift__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... | |
| @overload | |
| def __rshift__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rshift__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... | |
| @overload | |
| def __rshift__(self: NDArray[object_], other: Any, /) -> Any: ... | |
| @overload | |
| def __rshift__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... | |
| @overload | |
| def __rrshift__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... | |
| @overload | |
| def __rrshift__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rrshift__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... | |
| @overload | |
| def __rrshift__(self: NDArray[object_], other: Any, /) -> Any: ... | |
| @overload | |
| def __rrshift__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... | |
| @overload | |
| def __and__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __and__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __and__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... | |
| @overload | |
| def __and__(self: NDArray[object_], other: Any, /) -> Any: ... | |
| @overload | |
| def __and__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... | |
| @overload | |
| def __rand__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __rand__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rand__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... | |
| @overload | |
| def __rand__(self: NDArray[object_], other: Any, /) -> Any: ... | |
| @overload | |
| def __rand__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... | |
| @overload | |
| def __xor__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __xor__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __xor__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... | |
| @overload | |
| def __xor__(self: NDArray[object_], other: Any, /) -> Any: ... | |
| @overload | |
| def __xor__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... | |
| @overload | |
| def __rxor__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __rxor__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __rxor__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... | |
| @overload | |
| def __rxor__(self: NDArray[object_], other: Any, /) -> Any: ... | |
| @overload | |
| def __rxor__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... | |
| @overload | |
| def __or__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __or__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __or__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... | |
| @overload | |
| def __or__(self: NDArray[object_], other: Any, /) -> Any: ... | |
| @overload | |
| def __or__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... | |
| @overload | |
| def __ror__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... | |
| @overload | |
| def __ror__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] | |
| @overload | |
| def __ror__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... | |
| @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 | |
| # NOTE: Due to a mypy bug, overloading on e.g. `self: NDArray[SCT_floating]` won't | |
| # work, as this will lead to `false negatives` when using these inplace ops. | |
| # += | |
| @overload # type: ignore[misc] | |
| def __iadd__(self: _BoolArrayT, other: _ArrayLikeBool_co, /) -> _BoolArrayT: ... | |
| @overload | |
| def __iadd__(self: _ComplexFloatingArrayT, other: _ArrayLikeComplex_co, /) -> _ComplexFloatingArrayT: ... | |
| @overload | |
| def __iadd__(self: _InexactArrayT, other: _ArrayLikeFloat_co, /) -> _InexactArrayT: ... | |
| @overload | |
| def __iadd__(self: _NumberArrayT, other: _ArrayLikeInt_co, /) -> _NumberArrayT: ... | |
| @overload | |
| def __iadd__(self: _TimeArrayT, other: _ArrayLikeTD64_co, /) -> _TimeArrayT: ... | |
| @overload | |
| def __iadd__(self: _BytesArrayT, other: _ArrayLikeBytes_co, /) -> _BytesArrayT: ... | |
| @overload | |
| def __iadd__(self: _StringArrayT, other: _ArrayLikeStr_co | _ArrayLikeString_co, /) -> _StringArrayT: ... | |
| @overload | |
| def __iadd__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... | |
| # -= | |
| @overload # type: ignore[misc] | |
| def __isub__(self: _ComplexFloatingArrayT, other: _ArrayLikeComplex_co, /) -> _ComplexFloatingArrayT: ... | |
| @overload | |
| def __isub__(self: _InexactArrayT, other: _ArrayLikeFloat_co, /) -> _InexactArrayT: ... | |
| @overload | |
| def __isub__(self: _NumberArrayT, other: _ArrayLikeInt_co, /) -> _NumberArrayT: ... | |
| @overload | |
| def __isub__(self: _TimeArrayT, other: _ArrayLikeTD64_co, /) -> _TimeArrayT: ... | |
| @overload | |
| def __isub__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... | |
| # *= | |
| @overload # type: ignore[misc] | |
| def __imul__(self: _BoolArrayT, other: _ArrayLikeBool_co, /) -> _BoolArrayT: ... | |
| @overload | |
| def __imul__(self: _ComplexFloatingArrayT, other: _ArrayLikeComplex_co, /) -> _ComplexFloatingArrayT: ... | |
| @overload | |
| def __imul__(self: _InexactTimedeltaArrayT, other: _ArrayLikeFloat_co, /) -> _InexactTimedeltaArrayT: ... | |
| @overload | |
| def __imul__(self: _NumberCharacterArrayT, other: _ArrayLikeInt_co, /) -> _NumberCharacterArrayT: ... | |
| @overload | |
| def __imul__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... | |
| # @= | |
| @overload # type: ignore[misc] | |
| def __imatmul__(self: _BoolArrayT, other: _ArrayLikeBool_co, /) -> _BoolArrayT: ... | |
| @overload | |
| def __imatmul__(self: _ComplexFloatingArrayT, other: _ArrayLikeComplex_co, /) -> _ComplexFloatingArrayT: ... | |
| @overload | |
| def __imatmul__(self: _InexactArrayT, other: _ArrayLikeFloat_co, /) -> _InexactArrayT: ... | |
| @overload | |
| def __imatmul__(self: _NumberArrayT, other: _ArrayLikeInt_co, /) -> _NumberArrayT: ... | |
| @overload | |
| def __imatmul__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... | |
| # **= | |
| @overload # type: ignore[misc] | |
| def __ipow__(self: _ComplexFloatingArrayT, other: _ArrayLikeComplex_co, /) -> _ComplexFloatingArrayT: ... | |
| @overload | |
| def __ipow__(self: _InexactArrayT, other: _ArrayLikeFloat_co, /) -> _InexactArrayT: ... | |
| @overload | |
| def __ipow__(self: _NumberArrayT, other: _ArrayLikeInt_co, /) -> _NumberArrayT: ... | |
| @overload | |
| def __ipow__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... | |
| # /= | |
| @overload # type: ignore[misc] | |
| def __itruediv__(self: _ComplexFloatingArrayT, other: _ArrayLikeComplex_co, /) -> _ComplexFloatingArrayT: ... | |
| @overload | |
| def __itruediv__(self: _InexactTimedeltaArrayT, other: _ArrayLikeFloat_co, /) -> _InexactTimedeltaArrayT: ... | |
| @overload | |
| def __itruediv__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... | |
| # //= | |
| # keep in sync with `__imod__` | |
| @overload # type: ignore[misc] | |
| def __ifloordiv__(self: _IntegerArrayT, other: _ArrayLikeInt_co, /) -> _IntegerArrayT: ... | |
| @overload | |
| def __ifloordiv__(self: _FloatingTimedeltaArrayT, other: _ArrayLikeFloat_co, /) -> _FloatingTimedeltaArrayT: ... | |
| @overload | |
| def __ifloordiv__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... | |
| # %= | |
| # keep in sync with `__ifloordiv__` | |
| @overload # type: ignore[misc] | |
| def __imod__(self: _IntegerArrayT, other: _ArrayLikeInt_co, /) -> _IntegerArrayT: ... | |
| @overload | |
| def __imod__(self: _FloatingArrayT, other: _ArrayLikeFloat_co, /) -> _FloatingArrayT: ... | |
| @overload | |
| def __imod__(self: _TimedeltaArrayT, other: _ArrayLike[timedelta64], /) -> _TimedeltaArrayT: ... | |
| @overload | |
| def __imod__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... | |
| # <<= | |
| # keep in sync with `__irshift__` | |
| @overload # type: ignore[misc] | |
| def __ilshift__(self: _IntegerArrayT, other: _ArrayLikeInt_co, /) -> _IntegerArrayT: ... | |
| @overload | |
| def __ilshift__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... | |
| # >>= | |
| # keep in sync with `__ilshift__` | |
| @overload # type: ignore[misc] | |
| def __irshift__(self: _IntegerArrayT, other: _ArrayLikeInt_co, /) -> _IntegerArrayT: ... | |
| @overload | |
| def __irshift__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... | |
| # &= | |
| # keep in sync with `__ixor__` and `__ior__` | |
| @overload # type: ignore[misc] | |
| def __iand__(self: _BoolArrayT, other: _ArrayLikeBool_co, /) -> _BoolArrayT: ... | |
| @overload | |
| def __iand__(self: _IntegerArrayT, other: _ArrayLikeInt_co, /) -> _IntegerArrayT: ... | |
| @overload | |
| def __iand__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... | |
| # ^= | |
| # keep in sync with `__iand__` and `__ior__` | |
| @overload # type: ignore[misc] | |
| def __ixor__(self: _BoolArrayT, other: _ArrayLikeBool_co, /) -> _BoolArrayT: ... | |
| @overload | |
| def __ixor__(self: _IntegerArrayT, other: _ArrayLikeInt_co, /) -> _IntegerArrayT: ... | |
| @overload | |
| def __ixor__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... | |
| # |= | |
| # keep in sync with `__iand__` and `__ixor__` | |
| @overload # type: ignore[misc] | |
| def __ior__(self: _BoolArrayT, other: _ArrayLikeBool_co, /) -> _BoolArrayT: ... | |
| @overload | |
| def __ior__(self: _IntegerArrayT, other: _ArrayLikeInt_co, /) -> _IntegerArrayT: ... | |
| @overload | |
| def __ior__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... | |
| # | |
| def __dlpack__( | |
| self: NDArray[number], | |
| /, | |
| *, | |
| stream: int | Any | None = None, | |
| max_version: tuple[int, int] | None = None, | |
| dl_device: tuple[int, int] | None = None, | |
| copy: builtins.bool | None = None, | |
| ) -> CapsuleType: ... | |
| def __dlpack_device__(self, /) -> tuple[L[1], L[0]]: ... | |
| # Keep `dtype` at the bottom to avoid name conflicts with `np.dtype` | |
| @property | |
| def dtype(self) -> _DTypeT_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. | |
| class generic(_ArrayOrScalarCommon, Generic[_ItemT_co]): | |
| @abstractmethod | |
| def __new__(cls, /, *args: Any, **kwargs: Any) -> Self: ... | |
| # NOTE: Technically this doesn't exist at runtime, but it is unlikely to lead to | |
| # type-unsafe situations (the abstract scalar types cannot be instantiated | |
| # themselves) and is convenient to have, so we include it regardless. See | |
| # https://github.com/numpy/numpy/issues/30445 for use-cases and discussion. | |
| def __hash__(self, /) -> int: ... | |
| if sys.version_info >= (3, 12): | |
| def __buffer__(self, flags: int, /) -> memoryview: ... | |
| @overload | |
| def __array__(self, dtype: None = None, /) -> ndarray[tuple[()], dtype[Self]]: ... | |
| @overload | |
| def __array__(self, dtype: _DTypeT, /) -> ndarray[tuple[()], _DTypeT]: ... | |
| @overload | |
| def __array_wrap__( | |
| self, | |
| array: ndarray[_ShapeT, _DTypeT], | |
| context: tuple[ufunc, tuple[object, ...], int] | None, | |
| return_scalar: L[False], | |
| /, | |
| ) -> ndarray[_ShapeT, _DTypeT]: ... | |
| @overload | |
| def __array_wrap__( | |
| self, | |
| array: ndarray[tuple[()], dtype[_ScalarT]], | |
| context: tuple[ufunc, tuple[object, ...], int] | None = None, | |
| return_scalar: L[True] = True, | |
| /, | |
| ) -> _ScalarT: ... | |
| @overload | |
| def __array_wrap__( | |
| self, | |
| array: ndarray[_Shape1T, _DTypeT], | |
| context: tuple[ufunc, tuple[object, ...], int] | None = None, | |
| return_scalar: L[True] = True, | |
| /, | |
| ) -> ndarray[_Shape1T, _DTypeT]: ... | |
| @overload | |
| def __array_wrap__( | |
| self, | |
| array: ndarray[_ShapeT, dtype[_ScalarT]], | |
| context: tuple[ufunc, tuple[object, ...], int] | None = None, | |
| return_scalar: L[True] = True, | |
| /, | |
| ) -> _ScalarT | ndarray[_ShapeT, dtype[_ScalarT]]: ... | |
| @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[()]: ... | |
| @property | |
| def flat(self) -> flatiter[ndarray[tuple[int], dtype[Self]]]: ... | |
| @overload | |
| def item(self, /) -> _ItemT_co: ... | |
| @overload | |
| def item(self, arg0: L[0, -1] | tuple[L[0, -1]] | tuple[()] = ..., /) -> _ItemT_co: ... | |
| @override | |
| def tolist(self, /) -> _ItemT_co: ... | |
| # NOTE: these technically exist, but will always raise when called | |
| def trace( # type: ignore[misc] | |
| self: Never, | |
| /, | |
| offset: L[0] = 0, | |
| axis1: L[0] = 0, | |
| axis2: L[1] = 1, | |
| dtype: None = None, | |
| out: None = None, | |
| ) -> Never: ... | |
| def diagonal(self: Never, /, offset: L[0] = 0, axis1: L[0] = 0, axis2: L[1] = 1) -> Never: ... # type: ignore[misc] | |
| def swapaxes(self: Never, axis1: Never, axis2: Never, /) -> Never: ... # type: ignore[misc] | |
| def sort(self: Never, /, axis: L[-1] = -1, kind: None = None, order: None = None, *, stable: None = None) -> Never: ... # type: ignore[misc] | |
| def nonzero(self: Never, /) -> Never: ... # type: ignore[misc] | |
| def setfield(self: Never, val: Never, /, dtype: Never, offset: L[0] = 0) -> None: ... # type: ignore[misc] | |
| def searchsorted(self: Never, v: Never, /, side: L["left"] = "left", sorter: None = None) -> Never: ... # type: ignore[misc] | |
| # NOTE: this wont't raise, but won't do anything either | |
| @overload | |
| def resize(self, /, *, refcheck: builtins.bool = True) -> None: ... | |
| @overload | |
| def resize(self, new_shape: L[0, -1] | tuple[L[0, -1]] | tuple[()], /, *, refcheck: builtins.bool = True) -> None: ... | |
| # | |
| def byteswap(self, /, inplace: L[False] = False) -> Self: ... | |
| # | |
| @overload | |
| def astype( | |
| self, | |
| /, | |
| dtype: _DTypeLike[_ScalarT], | |
| order: _OrderKACF = "K", | |
| casting: _CastingKind = "unsafe", | |
| subok: builtins.bool = True, | |
| copy: builtins.bool | _CopyMode = True, | |
| ) -> _ScalarT: ... | |
| @overload | |
| def astype( | |
| self, | |
| /, | |
| dtype: DTypeLike | None, | |
| order: _OrderKACF = "K", | |
| casting: _CastingKind = "unsafe", | |
| subok: builtins.bool = True, | |
| copy: builtins.bool | _CopyMode = True, | |
| ) -> Incomplete: ... | |
| # NOTE: `view` will perform a 0D->scalar cast, | |
| # thus the array `type` is irrelevant to the output type | |
| @overload | |
| def view(self, type: type[ndarray] = ...) -> Self: ... | |
| @overload | |
| def view(self, /, dtype: _DTypeLike[_ScalarT], type: type[ndarray] = ...) -> _ScalarT: ... | |
| @overload | |
| def view(self, /, dtype: DTypeLike, type: type[ndarray] = ...) -> Incomplete: ... | |
| @overload | |
| def getfield(self, /, dtype: _DTypeLike[_ScalarT], offset: SupportsIndex = 0) -> _ScalarT: ... | |
| @overload | |
| def getfield(self, /, dtype: DTypeLike, offset: SupportsIndex = 0) -> Incomplete: ... | |
| @overload | |
| def take( | |
| self, | |
| indices: _IntLike_co, | |
| /, | |
| axis: SupportsIndex | None = None, | |
| out: None = None, | |
| mode: _ModeKind = "raise", | |
| ) -> Self: ... | |
| @overload | |
| def take( | |
| self, | |
| indices: _ArrayLikeInt_co, | |
| /, | |
| axis: SupportsIndex | None = None, | |
| out: None = None, | |
| mode: _ModeKind = "raise", | |
| ) -> NDArray[Self]: ... | |
| @overload | |
| def take( | |
| self, | |
| indices: _ArrayLikeInt_co, | |
| /, | |
| axis: SupportsIndex | None = None, | |
| *, | |
| out: _ArrayT, | |
| mode: _ModeKind = "raise", | |
| ) -> _ArrayT: ... | |
| @overload | |
| def take( | |
| self, | |
| indices: _ArrayLikeInt_co, | |
| /, | |
| axis: SupportsIndex | None, | |
| out: _ArrayT, | |
| mode: _ModeKind = "raise", | |
| ) -> _ArrayT: ... | |
| def repeat(self, repeats: _ArrayLikeInt_co, /, axis: SupportsIndex | None = None) -> ndarray[tuple[int], dtype[Self]]: ... | |
| def flatten(self, /, order: _OrderKACF = "C") -> ndarray[tuple[int], dtype[Self]]: ... | |
| def ravel(self, /, order: _OrderKACF = "C") -> ndarray[tuple[int], dtype[Self]]: ... | |
| @overload # (() | []) | |
| def reshape( | |
| self, | |
| shape: tuple[()] | list[Never], | |
| /, | |
| *, | |
| order: _OrderACF = "C", | |
| copy: builtins.bool | None = None, | |
| ) -> Self: ... | |
| @overload # ((1, *(1, ...))@_ShapeT) | |
| def reshape( | |
| self, | |
| shape: _1NShapeT, | |
| /, | |
| *, | |
| order: _OrderACF = "C", | |
| copy: builtins.bool | None = None, | |
| ) -> ndarray[_1NShapeT, dtype[Self]]: ... | |
| @overload # (Sequence[index, ...]) # not recommended | |
| def reshape( | |
| self, | |
| shape: Sequence[SupportsIndex], | |
| /, | |
| *, | |
| order: _OrderACF = "C", | |
| copy: builtins.bool | None = None, | |
| ) -> Self | ndarray[tuple[L[1], ...], dtype[Self]]: ... | |
| @overload # _(index) | |
| def reshape( | |
| self, | |
| size1: SupportsIndex, | |
| /, | |
| *, | |
| order: _OrderACF = "C", | |
| copy: builtins.bool | None = None, | |
| ) -> ndarray[tuple[L[1]], dtype[Self]]: ... | |
| @overload # _(index, index) | |
| def reshape( | |
| self, | |
| size1: SupportsIndex, | |
| size2: SupportsIndex, | |
| /, | |
| *, | |
| order: _OrderACF = "C", | |
| copy: builtins.bool | None = None, | |
| ) -> ndarray[tuple[L[1], L[1]], dtype[Self]]: ... | |
| @overload # _(index, index, index) | |
| def reshape( | |
| self, | |
| size1: SupportsIndex, | |
| size2: SupportsIndex, | |
| size3: SupportsIndex, | |
| /, | |
| *, | |
| order: _OrderACF = "C", | |
| copy: builtins.bool | None = None, | |
| ) -> ndarray[tuple[L[1], L[1], L[1]], dtype[Self]]: ... | |
| @overload # _(index, index, index, index) | |
| def reshape( | |
| self, | |
| size1: SupportsIndex, | |
| size2: SupportsIndex, | |
| size3: SupportsIndex, | |
| size4: SupportsIndex, | |
| /, | |
| *, | |
| order: _OrderACF = "C", | |
| copy: builtins.bool | None = None, | |
| ) -> ndarray[tuple[L[1], L[1], L[1], L[1]], dtype[Self]]: ... | |
| @overload # _(index, index, index, index, index, *index) # ndim >= 5 | |
| def reshape( | |
| self, | |
| size1: SupportsIndex, | |
| size2: SupportsIndex, | |
| size3: SupportsIndex, | |
| size4: SupportsIndex, | |
| size5: SupportsIndex, | |
| /, | |
| *sizes6_: SupportsIndex, | |
| order: _OrderACF = "C", | |
| copy: builtins.bool | None = None, | |
| ) -> ndarray[tuple[L[1], L[1], L[1], L[1], L[1], *tuple[L[1], ...]], dtype[Self]]: ... | |
| def squeeze(self, axis: L[0] | tuple[()] | None = ...) -> Self: ... | |
| def transpose(self, axes: tuple[()] | None = ..., /) -> Self: ... | |
| @overload | |
| def all( | |
| self, | |
| /, | |
| axis: L[0, -1] | tuple[()] | None = None, | |
| out: None = None, | |
| keepdims: SupportsIndex = False, | |
| *, | |
| where: builtins.bool | np.bool | ndarray[tuple[()], dtype[np.bool]] = True | |
| ) -> np.bool: ... | |
| @overload | |
| def all( | |
| self, | |
| /, | |
| axis: L[0, -1] | tuple[()] | None, | |
| out: ndarray[tuple[()], dtype[_ScalarT]], | |
| keepdims: SupportsIndex = False, | |
| *, | |
| where: builtins.bool | np.bool | ndarray[tuple[()], dtype[np.bool]] = True, | |
| ) -> _ScalarT: ... | |
| @overload | |
| def all( | |
| self, | |
| /, | |
| axis: L[0, -1] | tuple[()] | None = None, | |
| *, | |
| out: ndarray[tuple[()], dtype[_ScalarT]], | |
| keepdims: SupportsIndex = False, | |
| where: builtins.bool | np.bool | ndarray[tuple[()], dtype[np.bool]] = True, | |
| ) -> _ScalarT: ... | |
| @overload | |
| def any( | |
| self, | |
| /, | |
| axis: L[0, -1] | tuple[()] | None = None, | |
| out: None = None, | |
| keepdims: SupportsIndex = False, | |
| *, | |
| where: builtins.bool | np.bool | ndarray[tuple[()], dtype[np.bool]] = True | |
| ) -> np.bool: ... | |
| @overload | |
| def any( | |
| self, | |
| /, | |
| axis: L[0, -1] | tuple[()] | None, | |
| out: ndarray[tuple[()], dtype[_ScalarT]], | |
| keepdims: SupportsIndex = False, | |
| *, | |
| where: builtins.bool | np.bool | ndarray[tuple[()], dtype[np.bool]] = True, | |
| ) -> _ScalarT: ... | |
| @overload | |
| def any( | |
| self, | |
| /, | |
| axis: L[0, -1] | tuple[()] | None = None, | |
| *, | |
| out: ndarray[tuple[()], dtype[_ScalarT]], | |
| keepdims: SupportsIndex = False, | |
| where: builtins.bool | np.bool | ndarray[tuple[()], dtype[np.bool]] = True, | |
| ) -> _ScalarT: ... | |
| # Keep `dtype` at the bottom to avoid name conflicts with `np.dtype` | |
| @property | |
| def dtype(self) -> _dtype[Self]: ... | |
| class number(generic[_NumberItemT_co], Generic[_NBit, _NumberItemT_co]): | |
| @abstractmethod # `SupportsIndex | str | bytes` equivs `_ConvertibleToInt & _ConvertibleToFloat` | |
| def __new__(cls, value: SupportsIndex | str | bytes = 0, /) -> Self: ... | |
| def __class_getitem__(cls, item: Any, /) -> GenericAlias: ... | |
| def __neg__(self) -> Self: ... | |
| def __pos__(self) -> Self: ... | |
| def __abs__(self) -> Self: ... | |
| def __add__(self, other: _NumberLike_co, /) -> Incomplete: ... | |
| def __radd__(self, other: _NumberLike_co, /) -> Incomplete: ... | |
| def __sub__(self, other: _NumberLike_co, /) -> Incomplete: ... | |
| def __rsub__(self, other: _NumberLike_co, /) -> Incomplete: ... | |
| def __mul__(self, other: _NumberLike_co, /) -> Incomplete: ... | |
| def __rmul__(self, other: _NumberLike_co, /) -> Incomplete: ... | |
| def __pow__(self, other: _NumberLike_co, mod: None = None, /) -> Incomplete: ... | |
| def __rpow__(self, other: _NumberLike_co, mod: None = None, /) -> Incomplete: ... | |
| def __truediv__(self, other: _NumberLike_co, /) -> Incomplete: ... | |
| def __rtruediv__(self, other: _NumberLike_co, /) -> Incomplete: ... | |
| @overload | |
| def __lt__(self, other: _NumberLike_co, /) -> bool_: ... | |
| @overload | |
| def __lt__(self, other: _ArrayLikeNumber_co | _NestedSequence[_SupportsGT], /) -> NDArray[bool_]: ... | |
| @overload | |
| def __lt__(self, other: _SupportsGT, /) -> bool_: ... | |
| @overload | |
| def __le__(self, other: _NumberLike_co, /) -> bool_: ... | |
| @overload | |
| def __le__(self, other: _ArrayLikeNumber_co | _NestedSequence[_SupportsGE], /) -> NDArray[bool_]: ... | |
| @overload | |
| def __le__(self, other: _SupportsGE, /) -> bool_: ... | |
| @overload | |
| def __gt__(self, other: _NumberLike_co, /) -> bool_: ... | |
| @overload | |
| def __gt__(self, other: _ArrayLikeNumber_co | _NestedSequence[_SupportsLT], /) -> NDArray[bool_]: ... | |
| @overload | |
| def __gt__(self, other: _SupportsLT, /) -> bool_: ... | |
| @overload | |
| def __ge__(self, other: _NumberLike_co, /) -> bool_: ... | |
| @overload | |
| def __ge__(self, other: _ArrayLikeNumber_co | _NestedSequence[_SupportsLE], /) -> NDArray[bool_]: ... | |
| @overload | |
| def __ge__(self, other: _SupportsLE, /) -> bool_: ... | |
| class bool(generic[_BoolItemT_co], Generic[_BoolItemT_co]): | |
| @property | |
| def itemsize(self) -> L[1]: ... | |
| @property | |
| def nbytes(self) -> L[1]: ... | |
| @property | |
| def real(self) -> Self: ... | |
| @property | |
| def imag(self) -> np.bool[L[False]]: ... | |
| @overload # mypy bug workaround: https://github.com/numpy/numpy/issues/29245 | |
| def __new__(cls, value: Never, /) -> np.bool[builtins.bool]: ... | |
| @overload | |
| def __new__(cls, value: _Falsy = ..., /) -> np.bool[L[False]]: ... | |
| @overload | |
| def __new__(cls, value: _Truthy, /) -> np.bool[L[True]]: ... | |
| @overload | |
| def __new__(cls, value: object, /) -> np.bool[builtins.bool]: ... | |
| def __class_getitem__(cls, type_arg: type | object, /) -> GenericAlias: ... | |
| def __bool__(self, /) -> _BoolItemT_co: ... | |
| @overload | |
| def __int__(self: np.bool[L[False]], /) -> L[0]: ... | |
| @overload | |
| def __int__(self: np.bool[L[True]], /) -> L[1]: ... | |
| @overload | |
| def __int__(self, /) -> L[0, 1]: ... | |
| def __abs__(self) -> Self: ... | |
| @overload | |
| def __invert__(self: np.bool[L[False]], /) -> np.bool[L[True]]: ... | |
| @overload | |
| def __invert__(self: np.bool[L[True]], /) -> np.bool[L[False]]: ... | |
| @overload | |
| def __invert__(self, /) -> np.bool: ... | |
| @overload | |
| def __add__(self, other: _NumberT, /) -> _NumberT: ... | |
| @overload | |
| def __add__(self, other: builtins.bool | bool_, /) -> bool_: ... | |
| @overload | |
| def __add__(self, other: int, /) -> int_: ... | |
| @overload | |
| def __add__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __add__(self, other: complex, /) -> complex128: ... | |
| @overload | |
| def __radd__(self, other: _NumberT, /) -> _NumberT: ... | |
| @overload | |
| def __radd__(self, other: builtins.bool, /) -> bool_: ... | |
| @overload | |
| def __radd__(self, other: int, /) -> int_: ... | |
| @overload | |
| def __radd__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __radd__(self, other: complex, /) -> complex128: ... | |
| @overload | |
| def __sub__(self, other: _NumberT, /) -> _NumberT: ... | |
| @overload | |
| def __sub__(self, other: int, /) -> int_: ... | |
| @overload | |
| def __sub__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __sub__(self, other: complex, /) -> complex128: ... | |
| @overload | |
| def __rsub__(self, other: _NumberT, /) -> _NumberT: ... | |
| @overload | |
| def __rsub__(self, other: int, /) -> int_: ... | |
| @overload | |
| def __rsub__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __rsub__(self, other: complex, /) -> complex128: ... | |
| @overload | |
| def __mul__(self, other: _NumberT, /) -> _NumberT: ... | |
| @overload | |
| def __mul__(self, other: builtins.bool | bool_, /) -> bool_: ... | |
| @overload | |
| def __mul__(self, other: int, /) -> int_: ... | |
| @overload | |
| def __mul__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __mul__(self, other: complex, /) -> complex128: ... | |
| @overload | |
| def __rmul__(self, other: _NumberT, /) -> _NumberT: ... | |
| @overload | |
| def __rmul__(self, other: builtins.bool, /) -> bool_: ... | |
| @overload | |
| def __rmul__(self, other: int, /) -> int_: ... | |
| @overload | |
| def __rmul__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __rmul__(self, other: complex, /) -> complex128: ... | |
| @overload | |
| def __pow__(self, other: _NumberT, mod: None = None, /) -> _NumberT: ... | |
| @overload | |
| def __pow__(self, other: builtins.bool | bool_, mod: None = None, /) -> int8: ... | |
| @overload | |
| def __pow__(self, other: int, mod: None = None, /) -> int_: ... | |
| @overload | |
| def __pow__(self, other: float, mod: None = None, /) -> float64: ... | |
| @overload | |
| def __pow__(self, other: complex, mod: None = None, /) -> complex128: ... | |
| @overload | |
| def __rpow__(self, other: _NumberT, mod: None = None, /) -> _NumberT: ... | |
| @overload | |
| def __rpow__(self, other: builtins.bool, mod: None = None, /) -> int8: ... | |
| @overload | |
| def __rpow__(self, other: int, mod: None = None, /) -> int_: ... | |
| @overload | |
| def __rpow__(self, other: float, mod: None = None, /) -> float64: ... | |
| @overload | |
| def __rpow__(self, other: complex, mod: None = None, /) -> complex128: ... | |
| @overload | |
| def __truediv__(self, other: _InexactT, /) -> _InexactT: ... | |
| @overload | |
| def __truediv__(self, other: float | integer | bool_, /) -> float64: ... | |
| @overload | |
| def __truediv__(self, other: complex, /) -> complex128: ... | |
| @overload | |
| def __rtruediv__(self, other: _InexactT, /) -> _InexactT: ... | |
| @overload | |
| def __rtruediv__(self, other: float | integer, /) -> float64: ... | |
| @overload | |
| def __rtruediv__(self, other: complex, /) -> complex128: ... | |
| @overload | |
| def __floordiv__(self, other: _RealNumberT, /) -> _RealNumberT: ... | |
| @overload | |
| def __floordiv__(self, other: builtins.bool | bool_, /) -> int8: ... | |
| @overload | |
| def __floordiv__(self, other: int, /) -> int_: ... | |
| @overload | |
| def __floordiv__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __rfloordiv__(self, other: _RealNumberT, /) -> _RealNumberT: ... | |
| @overload | |
| def __rfloordiv__(self, other: builtins.bool, /) -> int8: ... | |
| @overload | |
| def __rfloordiv__(self, other: int, /) -> int_: ... | |
| @overload | |
| def __rfloordiv__(self, other: float, /) -> float64: ... | |
| # keep in sync with __floordiv__ | |
| @overload | |
| def __mod__(self, other: _RealNumberT, /) -> _RealNumberT: ... | |
| @overload | |
| def __mod__(self, other: builtins.bool | bool_, /) -> int8: ... | |
| @overload | |
| def __mod__(self, other: int, /) -> int_: ... | |
| @overload | |
| def __mod__(self, other: float, /) -> float64: ... | |
| # keep in sync with __rfloordiv__ | |
| @overload | |
| def __rmod__(self, other: _RealNumberT, /) -> _RealNumberT: ... | |
| @overload | |
| def __rmod__(self, other: builtins.bool, /) -> int8: ... | |
| @overload | |
| def __rmod__(self, other: int, /) -> int_: ... | |
| @overload | |
| def __rmod__(self, other: float, /) -> float64: ... | |
| # keep in sync with __mod__ | |
| @overload | |
| def __divmod__(self, other: _RealNumberT, /) -> _2Tuple[_RealNumberT]: ... | |
| @overload | |
| def __divmod__(self, other: builtins.bool | bool_, /) -> _2Tuple[int8]: ... | |
| @overload | |
| def __divmod__(self, other: int, /) -> _2Tuple[int_]: ... | |
| @overload | |
| def __divmod__(self, other: float, /) -> _2Tuple[float64]: ... | |
| # keep in sync with __rmod__ | |
| @overload | |
| def __rdivmod__(self, other: _RealNumberT, /) -> _2Tuple[_RealNumberT]: ... | |
| @overload | |
| def __rdivmod__(self, other: builtins.bool, /) -> _2Tuple[int8]: ... | |
| @overload | |
| def __rdivmod__(self, other: int, /) -> _2Tuple[int_]: ... | |
| @overload | |
| def __rdivmod__(self, other: float, /) -> _2Tuple[float64]: ... | |
| @overload | |
| def __lshift__(self, other: _IntegerT, /) -> _IntegerT: ... | |
| @overload | |
| def __lshift__(self, other: builtins.bool | bool_, /) -> int8: ... | |
| @overload | |
| def __lshift__(self, other: int, /) -> int_: ... | |
| @overload | |
| def __rlshift__(self, other: _IntegerT, /) -> _IntegerT: ... | |
| @overload | |
| def __rlshift__(self, other: builtins.bool, /) -> int8: ... | |
| @overload | |
| def __rlshift__(self, other: int, /) -> int_: ... | |
| # keep in sync with __lshift__ | |
| @overload | |
| def __rshift__(self, other: _IntegerT, /) -> _IntegerT: ... | |
| @overload | |
| def __rshift__(self, other: builtins.bool | bool_, /) -> int8: ... | |
| @overload | |
| def __rshift__(self, other: int, /) -> int_: ... | |
| # keep in sync with __rlshift__ | |
| @overload | |
| def __rrshift__(self, other: _IntegerT, /) -> _IntegerT: ... | |
| @overload | |
| def __rrshift__(self, other: builtins.bool, /) -> int8: ... | |
| @overload | |
| def __rrshift__(self, other: int, /) -> int_: ... | |
| @overload | |
| def __and__(self: np.bool[L[False]], other: builtins.bool | np.bool, /) -> np.bool[L[False]]: ... | |
| @overload | |
| def __and__(self, other: L[False] | np.bool[L[False]], /) -> np.bool[L[False]]: ... | |
| @overload | |
| def __and__(self, other: L[True] | np.bool[L[True]], /) -> Self: ... | |
| @overload | |
| def __and__(self, other: builtins.bool | np.bool, /) -> np.bool: ... | |
| @overload | |
| def __and__(self, other: _IntegerT, /) -> _IntegerT: ... | |
| @overload | |
| def __and__(self, other: int, /) -> np.bool | intp: ... | |
| __rand__ = __and__ | |
| @overload | |
| def __xor__(self: np.bool[L[False]], other: _BoolItemT | np.bool[_BoolItemT], /) -> np.bool[_BoolItemT]: ... | |
| @overload | |
| def __xor__(self: np.bool[L[True]], other: L[True] | np.bool[L[True]], /) -> np.bool[L[False]]: ... | |
| @overload | |
| def __xor__(self, other: L[False] | np.bool[L[False]], /) -> Self: ... | |
| @overload | |
| def __xor__(self, other: builtins.bool | np.bool, /) -> np.bool: ... | |
| @overload | |
| def __xor__(self, other: _IntegerT, /) -> _IntegerT: ... | |
| @overload | |
| def __xor__(self, other: int, /) -> np.bool | intp: ... | |
| __rxor__ = __xor__ | |
| @overload | |
| def __or__(self: np.bool[L[True]], other: builtins.bool | np.bool, /) -> np.bool[L[True]]: ... | |
| @overload | |
| def __or__(self, other: L[False] | np.bool[L[False]], /) -> Self: ... | |
| @overload | |
| def __or__(self, other: L[True] | np.bool[L[True]], /) -> np.bool[L[True]]: ... | |
| @overload | |
| def __or__(self, other: builtins.bool | np.bool, /) -> np.bool: ... | |
| @overload | |
| def __or__(self, other: _IntegerT, /) -> _IntegerT: ... | |
| @overload | |
| def __or__(self, other: int, /) -> np.bool | intp: ... | |
| __ror__ = __or__ | |
| @overload | |
| def __lt__(self, other: _NumberLike_co, /) -> bool_: ... | |
| @overload | |
| def __lt__(self, other: _ArrayLikeNumber_co | _NestedSequence[_SupportsGT], /) -> NDArray[bool_]: ... | |
| @overload | |
| def __lt__(self, other: _SupportsGT, /) -> bool_: ... | |
| @overload | |
| def __le__(self, other: _NumberLike_co, /) -> bool_: ... | |
| @overload | |
| def __le__(self, other: _ArrayLikeNumber_co | _NestedSequence[_SupportsGE], /) -> NDArray[bool_]: ... | |
| @overload | |
| def __le__(self, other: _SupportsGE, /) -> bool_: ... | |
| @overload | |
| def __gt__(self, other: _NumberLike_co, /) -> bool_: ... | |
| @overload | |
| def __gt__(self, other: _ArrayLikeNumber_co | _NestedSequence[_SupportsLT], /) -> NDArray[bool_]: ... | |
| @overload | |
| def __gt__(self, other: _SupportsLT, /) -> bool_: ... | |
| @overload | |
| def __ge__(self, other: _NumberLike_co, /) -> bool_: ... | |
| @overload | |
| def __ge__(self, other: _ArrayLikeNumber_co | _NestedSequence[_SupportsLE], /) -> NDArray[bool_]: ... | |
| @overload | |
| def __ge__(self, other: _SupportsLE, /) -> bool_: ... | |
| # NOTE: This should _not_ be `Final` or a `TypeAlias` | |
| bool_ = bool | |
| # NOTE: The `object_` constructor returns the passed object, so instances with type | |
| # `object_` cannot exists (at runtime). | |
| # NOTE: Because mypy has some long-standing bugs related to `__new__`, `object_` can't | |
| # be made generic. | |
| @final | |
| class object_(_RealMixin, generic): | |
| @overload | |
| def __new__(cls, value: None = None, /) -> None: ... # type: ignore[misc] | |
| @overload | |
| def __new__(cls, value: _AnyStr, /) -> _AnyStr: ... # type: ignore[misc] | |
| @overload | |
| def __new__(cls, value: ndarray[_ShapeT, Any], /) -> ndarray[_ShapeT, dtype[Self]]: ... # type: ignore[misc] | |
| @overload | |
| def __new__(cls, value: SupportsLenAndGetItem[object], /) -> NDArray[Self]: ... # type: ignore[misc] | |
| @overload | |
| def __new__(cls, value: _T, /) -> _T: ... # type: ignore[misc] | |
| @overload # catch-all | |
| def __new__(cls, value: Any = ..., /) -> object | NDArray[Self]: ... # type: ignore[misc] | |
| def __hash__(self, /) -> int: ... | |
| def __abs__(self, /) -> object_: ... # this affects NDArray[object_].__abs__ | |
| def __call__(self, /, *args: object, **kwargs: object) -> Any: ... | |
| if sys.version_info >= (3, 12): | |
| def __release_buffer__(self, buffer: memoryview, /) -> None: ... | |
| class integer(_IntegralMixin, _RoundMixin, number[_NBit, int]): | |
| @abstractmethod | |
| def __new__(cls, value: _ConvertibleToInt = 0, /) -> Self: ... | |
| # NOTE: `bit_count` and `__index__` are technically defined in the concrete subtypes | |
| def bit_count(self, /) -> int: ... | |
| def __index__(self, /) -> int: ... | |
| def __invert__(self, /) -> Self: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __truediv__(self, other: float | integer, /) -> float64: ... | |
| @overload | |
| def __truediv__(self, other: complex, /) -> complex128: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rtruediv__(self, other: float | integer, /) -> float64: ... | |
| @overload | |
| def __rtruediv__(self, other: complex, /) -> complex128: ... | |
| def __floordiv__(self, value: _IntLike_co, /) -> integer: ... | |
| def __rfloordiv__(self, value: _IntLike_co, /) -> integer: ... | |
| def __mod__(self, value: _IntLike_co, /) -> integer: ... | |
| def __rmod__(self, value: _IntLike_co, /) -> integer: ... | |
| def __divmod__(self, value: _IntLike_co, /) -> _2Tuple[integer]: ... | |
| def __rdivmod__(self, value: _IntLike_co, /) -> _2Tuple[integer]: ... | |
| # Ensure that objects annotated as `integer` support bit-wise operations | |
| def __lshift__(self, other: _IntLike_co, /) -> integer: ... | |
| def __rlshift__(self, other: _IntLike_co, /) -> integer: ... | |
| def __rshift__(self, other: _IntLike_co, /) -> integer: ... | |
| def __rrshift__(self, other: _IntLike_co, /) -> integer: ... | |
| def __and__(self, other: _IntLike_co, /) -> integer: ... | |
| def __rand__(self, other: _IntLike_co, /) -> integer: ... | |
| def __or__(self, other: _IntLike_co, /) -> integer: ... | |
| def __ror__(self, other: _IntLike_co, /) -> integer: ... | |
| def __xor__(self, other: _IntLike_co, /) -> integer: ... | |
| def __rxor__(self, other: _IntLike_co, /) -> integer: ... | |
| class signedinteger(integer[_NBit]): | |
| def __new__(cls, value: _ConvertibleToInt = 0, /) -> Self: ... | |
| # arithmetic ops | |
| @override # type: ignore[override] | |
| @overload | |
| def __add__(self, other: int | int8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __add__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __add__(self, other: complex, /) -> complex128: ... | |
| @overload | |
| def __add__(self, other: signedinteger, /) -> signedinteger: ... | |
| @overload | |
| def __add__(self, other: integer, /) -> Incomplete: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __radd__(self, other: int | int8 | bool_, /) -> Self: ... | |
| @overload | |
| def __radd__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __radd__(self, other: complex, /) -> complex128: ... | |
| @overload | |
| def __radd__(self, other: signedinteger, /) -> signedinteger: ... | |
| @overload | |
| def __radd__(self, other: integer, /) -> Incomplete: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __sub__(self, other: int | int8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __sub__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __sub__(self, other: complex, /) -> complex128: ... | |
| @overload | |
| def __sub__(self, other: signedinteger, /) -> signedinteger: ... | |
| @overload | |
| def __sub__(self, other: integer, /) -> Incomplete: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rsub__(self, other: int | int8 | bool_, /) -> Self: ... | |
| @overload | |
| def __rsub__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __rsub__(self, other: complex, /) -> complex128: ... | |
| @overload | |
| def __rsub__(self, other: signedinteger, /) -> signedinteger: ... | |
| @overload | |
| def __rsub__(self, other: integer, /) -> Incomplete: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __mul__(self, other: int | int8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __mul__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __mul__(self, other: complex, /) -> complex128: ... | |
| @overload | |
| def __mul__(self, other: signedinteger, /) -> signedinteger: ... | |
| @overload | |
| def __mul__(self, other: integer, /) -> Incomplete: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rmul__(self, other: int | int8 | bool_, /) -> Self: ... | |
| @overload | |
| def __rmul__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __rmul__(self, other: complex, /) -> complex128: ... | |
| @overload | |
| def __rmul__(self, other: signedinteger, /) -> signedinteger: ... | |
| @overload | |
| def __rmul__(self, other: integer, /) -> Incomplete: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __pow__(self, other: int | int8 | bool_ | Self, mod: None = None, /) -> Self: ... | |
| @overload | |
| def __pow__(self, other: float, mod: None = None, /) -> float64: ... | |
| @overload | |
| def __pow__(self, other: complex, mod: None = None, /) -> complex128: ... | |
| @overload | |
| def __pow__(self, other: signedinteger, mod: None = None, /) -> signedinteger: ... | |
| @overload | |
| def __pow__(self, other: integer, mod: None = None, /) -> Incomplete: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rpow__(self, other: int | int8 | bool_, mod: None = None, /) -> Self: ... | |
| @overload | |
| def __rpow__(self, other: float, mod: None = None, /) -> float64: ... | |
| @overload | |
| def __rpow__(self, other: complex, mod: None = None, /) -> complex128: ... | |
| @overload | |
| def __rpow__(self, other: signedinteger, mod: None = None, /) -> signedinteger: ... | |
| @overload | |
| def __rpow__(self, other: integer, mod: None = None, /) -> Incomplete: ... | |
| # modular division ops | |
| @override # type: ignore[override] | |
| @overload | |
| def __floordiv__(self, other: int | int8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __floordiv__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __floordiv__(self, other: signedinteger, /) -> signedinteger: ... | |
| @overload | |
| def __floordiv__(self, other: integer, /) -> Incomplete: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rfloordiv__(self, other: int | int8 | bool_, /) -> Self: ... | |
| @overload | |
| def __rfloordiv__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __rfloordiv__(self, other: signedinteger, /) -> signedinteger: ... | |
| @overload | |
| def __rfloordiv__(self, other: integer, /) -> Incomplete: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __mod__(self, other: int | int8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __mod__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __mod__(self, other: signedinteger, /) -> signedinteger: ... | |
| @overload | |
| def __mod__(self, other: integer, /) -> Incomplete: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rmod__(self, other: int | int8 | bool_, /) -> Self: ... | |
| @overload | |
| def __rmod__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __rmod__(self, other: signedinteger, /) -> signedinteger: ... | |
| @overload | |
| def __rmod__(self, other: integer, /) -> Incomplete: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __divmod__(self, other: int | int8 | bool_ | Self, /) -> _2Tuple[Self]: ... | |
| @overload | |
| def __divmod__(self, other: float, /) -> _2Tuple[float64]: ... | |
| @overload | |
| def __divmod__(self, other: signedinteger, /) -> _2Tuple[signedinteger]: ... | |
| @overload | |
| def __divmod__(self, other: integer, /) -> _2Tuple[Incomplete]: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rdivmod__(self, other: int | int8 | bool_, /) -> _2Tuple[Self]: ... | |
| @overload | |
| def __rdivmod__(self, other: float, /) -> _2Tuple[float64]: ... | |
| @overload | |
| def __rdivmod__(self, other: signedinteger, /) -> _2Tuple[signedinteger]: ... | |
| @overload | |
| def __rdivmod__(self, other: integer, /) -> _2Tuple[Incomplete]: ... | |
| # bitwise ops | |
| @override # type: ignore[override] | |
| @overload | |
| def __lshift__(self, other: int | int8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __lshift__(self, other: integer, /) -> signedinteger: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rlshift__(self, other: int | int8 | bool_, /) -> Self: ... | |
| @overload | |
| def __rlshift__(self, other: integer, /) -> signedinteger: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rshift__(self, other: int | int8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __rshift__(self, other: integer, /) -> signedinteger: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rrshift__(self, other: int | int8 | bool_, /) -> Self: ... | |
| @overload | |
| def __rrshift__(self, other: integer, /) -> signedinteger: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __and__(self, other: int | int8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __and__(self, other: integer, /) -> signedinteger: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rand__(self, other: int | int8 | bool_, /) -> Self: ... | |
| @overload | |
| def __rand__(self, other: integer, /) -> signedinteger: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __xor__(self, other: int | int8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __xor__(self, other: integer, /) -> signedinteger: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rxor__(self, other: int | int8 | bool_, /) -> Self: ... | |
| @overload | |
| def __rxor__(self, other: integer, /) -> signedinteger: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __or__(self, other: int | int8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __or__(self, other: integer, /) -> signedinteger: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __ror__(self, other: int | int8 | bool_, /) -> Self: ... | |
| @overload | |
| def __ror__(self, other: integer, /) -> signedinteger: ... | |
| 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_ = intp | |
| long = signedinteger[_NBitLong] | |
| longlong = signedinteger[_NBitLongLong] | |
| class unsignedinteger(integer[_NBit1]): | |
| def __new__(cls, value: _ConvertibleToInt = 0, /) -> Self: ... | |
| # arithmetic ops | |
| @override # type: ignore[override] | |
| @overload | |
| def __add__(self, other: int | uint8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __add__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __add__(self, other: complex, /) -> complex128: ... | |
| @overload | |
| def __add__(self, other: unsignedinteger, /) -> unsignedinteger: ... | |
| @overload | |
| def __add__(self, other: integer, /) -> Incomplete: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __radd__(self, other: int | uint8 | bool_, /) -> Self: ... | |
| @overload | |
| def __radd__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __radd__(self, other: complex, /) -> complex128: ... | |
| @overload | |
| def __radd__(self, other: unsignedinteger, /) -> unsignedinteger: ... | |
| @overload | |
| def __radd__(self, other: integer, /) -> Incomplete: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __sub__(self, other: int | uint8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __sub__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __sub__(self, other: complex, /) -> complex128: ... | |
| @overload | |
| def __sub__(self, other: unsignedinteger, /) -> unsignedinteger: ... | |
| @overload | |
| def __sub__(self, other: integer, /) -> Incomplete: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rsub__(self, other: int | uint8 | bool_, /) -> Self: ... | |
| @overload | |
| def __rsub__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __rsub__(self, other: complex, /) -> complex128: ... | |
| @overload | |
| def __rsub__(self, other: unsignedinteger, /) -> unsignedinteger: ... | |
| @overload | |
| def __rsub__(self, other: integer, /) -> Incomplete: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __mul__(self, other: int | uint8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __mul__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __mul__(self, other: complex, /) -> complex128: ... | |
| @overload | |
| def __mul__(self, other: unsignedinteger, /) -> unsignedinteger: ... | |
| @overload | |
| def __mul__(self, other: integer, /) -> Incomplete: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rmul__(self, other: int | uint8 | bool_, /) -> Self: ... | |
| @overload | |
| def __rmul__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __rmul__(self, other: complex, /) -> complex128: ... | |
| @overload | |
| def __rmul__(self, other: unsignedinteger, /) -> unsignedinteger: ... | |
| @overload | |
| def __rmul__(self, other: integer, /) -> Incomplete: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __pow__(self, other: int | uint8 | bool_ | Self, mod: None = None, /) -> Self: ... | |
| @overload | |
| def __pow__(self, other: float, mod: None = None, /) -> float64: ... | |
| @overload | |
| def __pow__(self, other: complex, mod: None = None, /) -> complex128: ... | |
| @overload | |
| def __pow__(self, other: unsignedinteger, mod: None = None, /) -> unsignedinteger: ... | |
| @overload | |
| def __pow__(self, other: integer, mod: None = None, /) -> Incomplete: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rpow__(self, other: int | uint8 | bool_, mod: None = None, /) -> Self: ... | |
| @overload | |
| def __rpow__(self, other: float, mod: None = None, /) -> float64: ... | |
| @overload | |
| def __rpow__(self, other: complex, mod: None = None, /) -> complex128: ... | |
| @overload | |
| def __rpow__(self, other: unsignedinteger, mod: None = None, /) -> unsignedinteger: ... | |
| @overload | |
| def __rpow__(self, other: integer, mod: None = None, /) -> Incomplete: ... | |
| # modular division ops | |
| @override # type: ignore[override] | |
| @overload | |
| def __floordiv__(self, other: int | uint8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __floordiv__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __floordiv__(self, other: unsignedinteger, /) -> unsignedinteger: ... | |
| @overload | |
| def __floordiv__(self, other: integer, /) -> Incomplete: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rfloordiv__(self, other: int | uint8 | bool_, /) -> Self: ... | |
| @overload | |
| def __rfloordiv__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __rfloordiv__(self, other: unsignedinteger, /) -> unsignedinteger: ... | |
| @overload | |
| def __rfloordiv__(self, other: integer, /) -> Incomplete: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __mod__(self, other: int | uint8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __mod__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __mod__(self, other: unsignedinteger, /) -> unsignedinteger: ... | |
| @overload | |
| def __mod__(self, other: integer, /) -> Incomplete: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rmod__(self, other: int | uint8 | bool_, /) -> Self: ... | |
| @overload | |
| def __rmod__(self, other: float, /) -> float64: ... | |
| @overload | |
| def __rmod__(self, other: unsignedinteger, /) -> unsignedinteger: ... | |
| @overload | |
| def __rmod__(self, other: integer, /) -> Incomplete: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __divmod__(self, other: int | uint8 | bool_ | Self, /) -> _2Tuple[Self]: ... | |
| @overload | |
| def __divmod__(self, other: float, /) -> _2Tuple[float64]: ... | |
| @overload | |
| def __divmod__(self, other: unsignedinteger, /) -> _2Tuple[unsignedinteger]: ... | |
| @overload | |
| def __divmod__(self, other: integer, /) -> _2Tuple[Incomplete]: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rdivmod__(self, other: int | uint8 | bool_, /) -> _2Tuple[Self]: ... | |
| @overload | |
| def __rdivmod__(self, other: float, /) -> _2Tuple[float64]: ... | |
| @overload | |
| def __rdivmod__(self, other: unsignedinteger, /) -> _2Tuple[unsignedinteger]: ... | |
| @overload | |
| def __rdivmod__(self, other: integer, /) -> _2Tuple[Incomplete]: ... | |
| # bitwise ops | |
| @override # type: ignore[override] | |
| @overload | |
| def __lshift__(self, other: int | int8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __lshift__(self, other: unsignedinteger, /) -> unsignedinteger: ... | |
| @overload | |
| def __lshift__(self, other: signedinteger, /) -> signedinteger: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rlshift__(self, other: int | int8 | bool_, /) -> Self: ... | |
| @overload | |
| def __rlshift__(self, other: unsignedinteger, /) -> unsignedinteger: ... | |
| @overload | |
| def __rlshift__(self, other: signedinteger, /) -> signedinteger: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rshift__(self, other: int | int8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __rshift__(self, other: unsignedinteger, /) -> unsignedinteger: ... | |
| @overload | |
| def __rshift__(self, other: signedinteger, /) -> signedinteger: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rrshift__(self, other: int | int8 | bool_, /) -> Self: ... | |
| @overload | |
| def __rrshift__(self, other: unsignedinteger, /) -> unsignedinteger: ... | |
| @overload | |
| def __rrshift__(self, other: signedinteger, /) -> signedinteger: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __and__(self, other: int | int8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __and__(self, other: unsignedinteger, /) -> unsignedinteger: ... | |
| @overload | |
| def __and__(self, other: signedinteger, /) -> signedinteger: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rand__(self, other: int | int8 | bool_, /) -> Self: ... | |
| @overload | |
| def __rand__(self, other: unsignedinteger, /) -> unsignedinteger: ... | |
| @overload | |
| def __rand__(self, other: signedinteger, /) -> signedinteger: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __xor__(self, other: int | int8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __xor__(self, other: unsignedinteger, /) -> unsignedinteger: ... | |
| @overload | |
| def __xor__(self, other: signedinteger, /) -> signedinteger: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rxor__(self, other: int | int8 | bool_, /) -> Self: ... | |
| @overload | |
| def __rxor__(self, other: unsignedinteger, /) -> unsignedinteger: ... | |
| @overload | |
| def __rxor__(self, other: signedinteger, /) -> signedinteger: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __or__(self, other: int | int8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __or__(self, other: unsignedinteger, /) -> unsignedinteger: ... | |
| @overload | |
| def __or__(self, other: signedinteger, /) -> signedinteger: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __ror__(self, other: int | int8 | bool_, /) -> Self: ... | |
| @overload | |
| def __ror__(self, other: unsignedinteger, /) -> unsignedinteger: ... | |
| @overload | |
| def __ror__(self, other: signedinteger, /) -> signedinteger: ... | |
| uint8: TypeAlias = unsignedinteger[_8Bit] | |
| uint16: TypeAlias = unsignedinteger[_16Bit] | |
| uint32: TypeAlias = unsignedinteger[_32Bit] | |
| uint64: TypeAlias = unsignedinteger[_64Bit] | |
| ubyte: TypeAlias = unsignedinteger[_NBitByte] | |
| ushort: TypeAlias = unsignedinteger[_NBitShort] | |
| uintc: TypeAlias = unsignedinteger[_NBitIntC] | |
| uintp: TypeAlias = unsignedinteger[_NBitIntP] | |
| uint: TypeAlias = uintp | |
| ulong: TypeAlias = unsignedinteger[_NBitLong] | |
| ulonglong: TypeAlias = unsignedinteger[_NBitLongLong] | |
| class inexact(number[_NBit, _InexactItemT_co], Generic[_NBit, _InexactItemT_co]): | |
| @abstractmethod | |
| def __new__(cls, value: _ConvertibleToFloat | None = 0, /) -> Self: ... | |
| class floating(_RealMixin, _RoundMixin, inexact[_NBit1, float]): | |
| def __new__(cls, value: _ConvertibleToFloat | None = 0, /) -> Self: ... | |
| # arithmetic ops | |
| @override # type: ignore[override] | |
| @overload | |
| def __add__(self, other: int | float16 | uint8 | int8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __add__(self, other: integer | floating, /) -> floating: ... | |
| @overload | |
| def __add__(self, other: float, /) -> Self: ... | |
| @overload | |
| def __add__(self, other: complex, /) -> complexfloating: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __radd__(self, other: int | float16 | uint8 | int8 | bool_, /) -> Self: ... | |
| @overload | |
| def __radd__(self, other: integer | floating, /) -> floating: ... | |
| @overload | |
| def __radd__(self, other: float, /) -> Self: ... | |
| @overload | |
| def __radd__(self, other: complex, /) -> complexfloating: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __sub__(self, other: int | float16 | uint8 | int8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __sub__(self, other: integer | floating, /) -> floating: ... | |
| @overload | |
| def __sub__(self, other: float, /) -> Self: ... | |
| @overload | |
| def __sub__(self, other: complex, /) -> complexfloating: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rsub__(self, other: int | float16 | uint8 | int8 | bool_, /) -> Self: ... | |
| @overload | |
| def __rsub__(self, other: integer | floating, /) -> floating: ... | |
| @overload | |
| def __rsub__(self, other: float, /) -> Self: ... | |
| @overload | |
| def __rsub__(self, other: complex, /) -> complexfloating: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __mul__(self, other: int | float16 | uint8 | int8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __mul__(self, other: integer | floating, /) -> floating: ... | |
| @overload | |
| def __mul__(self, other: float, /) -> Self: ... | |
| @overload | |
| def __mul__(self, other: complex, /) -> complexfloating: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rmul__(self, other: int | float16 | uint8 | int8 | bool_, /) -> Self: ... | |
| @overload | |
| def __rmul__(self, other: integer | floating, /) -> floating: ... | |
| @overload | |
| def __rmul__(self, other: float, /) -> Self: ... | |
| @overload | |
| def __rmul__(self, other: complex, /) -> complexfloating: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __pow__(self, other: int | float16 | uint8 | int8 | bool_ | Self, mod: None = None, /) -> Self: ... | |
| @overload | |
| def __pow__(self, other: integer | floating, mod: None = None, /) -> floating: ... | |
| @overload | |
| def __pow__(self, other: float, mod: None = None, /) -> Self: ... | |
| @overload | |
| def __pow__(self, other: complex, mod: None = None, /) -> complexfloating: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rpow__(self, other: int | float16 | uint8 | int8 | bool_, mod: None = None, /) -> Self: ... | |
| @overload | |
| def __rpow__(self, other: integer | floating, mod: None = None, /) -> floating: ... | |
| @overload | |
| def __rpow__(self, other: float, mod: None = None, /) -> Self: ... | |
| @overload | |
| def __rpow__(self, other: complex, mod: None = None, /) -> complexfloating: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __truediv__(self, other: int | float16 | uint8 | int8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __truediv__(self, other: integer | floating, /) -> floating: ... | |
| @overload | |
| def __truediv__(self, other: float, /) -> Self: ... | |
| @overload | |
| def __truediv__(self, other: complex, /) -> complexfloating: ... | |
| @override # type: ignore[override] | |
| @overload | |
| def __rtruediv__(self, other: int | float16 | uint8 | int8 | bool_, /) -> Self: ... | |
| @overload | |
| def __rtruediv__(self, other: integer | floating, /) -> floating: ... | |
| @overload | |
| def __rtruediv__(self, other: float, /) -> Self: ... | |
| @overload | |
| def __rtruediv__(self, other: complex, /) -> complexfloating: ... | |
| # modular division ops | |
| @overload | |
| def __floordiv__(self, other: int | float16 | uint8 | int8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __floordiv__(self, other: integer | floating, /) -> floating: ... | |
| @overload | |
| def __floordiv__(self, other: float, /) -> Self: ... | |
| @overload | |
| def __rfloordiv__(self, other: int | float16 | uint8 | int8 | bool_, /) -> Self: ... | |
| @overload | |
| def __rfloordiv__(self, other: integer | floating, /) -> floating: ... | |
| @overload | |
| def __rfloordiv__(self, other: float, /) -> Self: ... | |
| @overload | |
| def __mod__(self, other: int | float16 | uint8 | int8 | bool_ | Self, /) -> Self: ... | |
| @overload | |
| def __mod__(self, other: integer | floating, /) -> floating: ... | |
| @overload | |
| def __mod__(self, other: float, /) -> Self: ... | |
| @overload | |
| def __rmod__(self, other: int | float16 | uint8 | int8 | bool_, /) -> Self: ... | |
| @overload | |
| def __rmod__(self, other: integer | floating, /) -> floating: ... | |
| @overload | |
| def __rmod__(self, other: float, /) -> Self: ... | |
| @overload | |
| def __divmod__(self, other: int | float16 | uint8 | int8 | bool_ | Self, /) -> _2Tuple[Self]: ... | |
| @overload | |
| def __divmod__(self, other: integer | floating, /) -> _2Tuple[floating]: ... | |
| @overload | |
| def __divmod__(self, other: float, /) -> _2Tuple[Self]: ... | |
| @overload | |
| def __rdivmod__(self, other: int | float16 | uint8 | int8 | bool_, /) -> _2Tuple[Self]: ... | |
| @overload | |
| def __rdivmod__(self, other: integer | floating, /) -> _2Tuple[floating]: ... | |
| @overload | |
| def __rdivmod__(self, other: float, /) -> _2Tuple[Self]: ... | |
| # NOTE: `is_integer` and `as_integer_ratio` are technically defined in the concrete subtypes | |
| def is_integer(self, /) -> builtins.bool: ... | |
| def as_integer_ratio(self, /) -> tuple[int, int]: ... | |
| float16: TypeAlias = floating[_16Bit] | |
| float32: TypeAlias = floating[_32Bit] | |
| # either a C `double`, `float`, or `longdouble` | |
| class float64(floating[_64Bit], float): # type: ignore[misc] | |
| @property | |
| def itemsize(self) -> L[8]: ... | |
| @property | |
| def nbytes(self) -> L[8]: ... | |
| # overrides for `floating` and `builtins.float` compatibility (`_RealMixin` doesn't work) | |
| @property | |
| def real(self) -> Self: ... | |
| @property | |
| def imag(self) -> Self: ... | |
| def conjugate(self) -> Self: ... | |
| def __getnewargs__(self, /) -> tuple[float]: ... | |
| @classmethod | |
| def __getformat__(cls, typestr: L["double", "float"], /) -> str: ... # undocumented | |
| # float64-specific operator overrides | |
| # NOTE: Mypy reports [misc] errors about "unsafely overlapping signatures" for the | |
| # reflected methods. But since they are identical to the non-reflected versions, | |
| # these errors appear to be false positives. | |
| @overload # type: ignore[override] | |
| def __add__(self, other: _Float64_co, /) -> float64: ... | |
| @overload | |
| def __add__(self, other: complexfloating[_64Bit, _64Bit], /) -> complex128: ... | |
| @overload | |
| def __add__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... | |
| @overload | |
| def __add__(self, other: complex, /) -> float64 | complex128: ... | |
| @overload # type: ignore[override] | |
| def __radd__(self, other: _Float64_co, /) -> float64: ... # type: ignore[misc] | |
| @overload | |
| def __radd__(self, other: complexfloating[_64Bit, _64Bit], /) -> complex128: ... # type: ignore[misc] | |
| @overload | |
| def __radd__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... | |
| @overload | |
| def __radd__(self, other: complex, /) -> float64 | complex128: ... | |
| @overload # type: ignore[override] | |
| def __sub__(self, other: _Float64_co, /) -> float64: ... | |
| @overload | |
| def __sub__(self, other: complexfloating[_64Bit, _64Bit], /) -> complex128: ... | |
| @overload | |
| def __sub__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... | |
| @overload | |
| def __sub__(self, other: complex, /) -> float64 | complex128: ... | |
| @overload # type: ignore[override] | |
| def __rsub__(self, other: _Float64_co, /) -> float64: ... # type: ignore[misc] | |
| @overload | |
| def __rsub__(self, other: complexfloating[_64Bit, _64Bit], /) -> complex128: ... # type: ignore[misc] | |
| @overload | |
| def __rsub__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... | |
| @overload | |
| def __rsub__(self, other: complex, /) -> float64 | complex128: ... | |
| @overload # type: ignore[override] | |
| def __mul__(self, other: _Float64_co, /) -> float64: ... | |
| @overload | |
| def __mul__(self, other: complexfloating[_64Bit, _64Bit], /) -> complex128: ... | |
| @overload | |
| def __mul__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... | |
| @overload | |
| def __mul__(self, other: complex, /) -> float64 | complex128: ... | |
| @overload # type: ignore[override] | |
| def __rmul__(self, other: _Float64_co, /) -> float64: ... # type: ignore[misc] | |
| @overload | |
| def __rmul__(self, other: complexfloating[_64Bit, _64Bit], /) -> complex128: ... # type: ignore[misc] | |
| @overload | |
| def __rmul__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... | |
| @overload | |
| def __rmul__(self, other: complex, /) -> float64 | complex128: ... | |
| @overload # type: ignore[override] | |
| def __truediv__(self, other: _Float64_co, /) -> float64: ... | |
| @overload | |
| def __truediv__(self, other: complexfloating[_64Bit, _64Bit], /) -> complex128: ... | |
| @overload | |
| def __truediv__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... | |
| @overload | |
| def __truediv__(self, other: complex, /) -> float64 | complex128: ... | |
| @overload # type: ignore[override] | |
| def __rtruediv__(self, other: _Float64_co, /) -> float64: ... # type: ignore[misc] | |
| @overload | |
| def __rtruediv__(self, other: complexfloating[_64Bit, _64Bit], /) -> complex128: ... # type: ignore[misc] | |
| @overload | |
| def __rtruediv__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... | |
| @overload | |
| def __rtruediv__(self, other: complex, /) -> float64 | complex128: ... | |
| @overload # type: ignore[override] | |
| def __floordiv__(self, other: _Float64_co, /) -> float64: ... | |
| @overload | |
| def __floordiv__(self, other: complexfloating[_64Bit, _64Bit], /) -> complex128: ... | |
| @overload | |
| def __floordiv__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... | |
| @overload | |
| def __floordiv__(self, other: complex, /) -> float64 | complex128: ... | |
| @overload | |
| def __rfloordiv__(self, other: _Float64_co, /) -> float64: ... # type: ignore[misc] | |
| @overload | |
| def __rfloordiv__(self, other: complexfloating[_64Bit, _64Bit], /) -> complex128: ... | |
| @overload | |
| def __rfloordiv__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... | |
| @overload | |
| def __rfloordiv__(self, other: complex, /) -> float64 | complex128: ... | |
| @overload # type: ignore[override] | |
| def __pow__(self, other: _Float64_co, mod: None = None, /) -> float64: ... | |
| @overload | |
| def __pow__(self, other: complexfloating[_64Bit, _64Bit], mod: None = None, /) -> complex128: ... | |
| @overload | |
| def __pow__( | |
| self, other: complexfloating[_NBit1, _NBit2], mod: None = None, / | |
| ) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... | |
| @overload | |
| def __pow__(self, other: complex, mod: None = None, /) -> float64 | complex128: ... | |
| @overload # type: ignore[override] | |
| def __rpow__(self, other: _Float64_co, mod: None = None, /) -> float64: ... # type: ignore[misc] | |
| @overload | |
| def __rpow__(self, other: complexfloating[_64Bit, _64Bit], mod: None = None, /) -> complex128: ... # type: ignore[misc] | |
| @overload | |
| def __rpow__( | |
| self, other: complexfloating[_NBit1, _NBit2], mod: None = None, / | |
| ) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... | |
| @overload | |
| def __rpow__(self, other: complex, mod: None = None, /) -> float64 | complex128: ... | |
| def __mod__(self, other: _Float64_co, /) -> float64: ... | |
| def __rmod__(self, other: _Float64_co, /) -> float64: ... # type: ignore[misc] | |
| def __divmod__(self, other: _Float64_co, /) -> _2Tuple[float64]: ... | |
| def __rdivmod__(self, other: _Float64_co, /) -> _2Tuple[float64]: ... # type: ignore[misc] | |
| half: TypeAlias = float16 | |
| single: TypeAlias = float32 | |
| double: TypeAlias = float64 | |
| longdouble: TypeAlias = 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, complex], Generic[_NBit1, _NBit2]): | |
| @overload | |
| def __new__( | |
| cls, | |
| real: complex | SupportsComplex | SupportsFloat | SupportsIndex = 0, | |
| imag: complex | SupportsFloat | SupportsIndex = 0, | |
| /, | |
| ) -> Self: ... | |
| @overload | |
| def __new__(cls, real: _ConvertibleToComplex | None = 0, /) -> Self: ... | |
| @property | |
| def real(self) -> floating[_NBit1]: ... | |
| @property | |
| def imag(self) -> floating[_NBit2]: ... | |
| # NOTE: `__complex__` is technically defined in the concrete subtypes | |
| def __complex__(self, /) -> complex: ... | |
| def __abs__(self, /) -> floating[_NBit1 | _NBit2]: ... # type: ignore[override] | |
| @overload # type: ignore[override] | |
| def __add__(self, other: _Complex64_co, /) -> complexfloating[_NBit1, _NBit2]: ... | |
| @overload | |
| def __add__(self, other: complex | float64 | complex128, /) -> complexfloating[_NBit1, _NBit2] | complex128: ... | |
| @overload | |
| def __add__(self, other: number[_NBit], /) -> complexfloating[_NBit1, _NBit2] | complexfloating[_NBit, _NBit]: ... | |
| @overload # type: ignore[override] | |
| def __radd__(self, other: _Complex64_co, /) -> complexfloating[_NBit1, _NBit2]: ... | |
| @overload | |
| def __radd__(self, other: complex, /) -> complexfloating[_NBit1, _NBit2] | complex128: ... | |
| @overload | |
| def __radd__(self, other: number[_NBit], /) -> complexfloating[_NBit1, _NBit2] | complexfloating[_NBit, _NBit]: ... | |
| @overload # type: ignore[override] | |
| def __sub__(self, other: _Complex64_co, /) -> complexfloating[_NBit1, _NBit2]: ... | |
| @overload | |
| def __sub__(self, other: complex | float64 | complex128, /) -> complexfloating[_NBit1, _NBit2] | complex128: ... | |
| @overload | |
| def __sub__(self, other: number[_NBit], /) -> complexfloating[_NBit1, _NBit2] | complexfloating[_NBit, _NBit]: ... | |
| @overload # type: ignore[override] | |
| def __rsub__(self, other: _Complex64_co, /) -> complexfloating[_NBit1, _NBit2]: ... | |
| @overload | |
| def __rsub__(self, other: complex, /) -> complexfloating[_NBit1, _NBit2] | complex128: ... | |
| @overload | |
| def __rsub__(self, other: number[_NBit], /) -> complexfloating[_NBit1, _NBit2] | complexfloating[_NBit, _NBit]: ... | |
| @overload # type: ignore[override] | |
| def __mul__(self, other: _Complex64_co, /) -> complexfloating[_NBit1, _NBit2]: ... | |
| @overload | |
| def __mul__(self, other: complex | float64 | complex128, /) -> complexfloating[_NBit1, _NBit2] | complex128: ... | |
| @overload | |
| def __mul__(self, other: number[_NBit], /) -> complexfloating[_NBit1, _NBit2] | complexfloating[_NBit, _NBit]: ... | |
| @overload # type: ignore[override] | |
| def __rmul__(self, other: _Complex64_co, /) -> complexfloating[_NBit1, _NBit2]: ... | |
| @overload | |
| def __rmul__(self, other: complex, /) -> complexfloating[_NBit1, _NBit2] | complex128: ... | |
| @overload | |
| def __rmul__(self, other: number[_NBit], /) -> complexfloating[_NBit1, _NBit2] | complexfloating[_NBit, _NBit]: ... | |
| @overload # type: ignore[override] | |
| def __truediv__(self, other: _Complex64_co, /) -> complexfloating[_NBit1, _NBit2]: ... | |
| @overload | |
| def __truediv__(self, other: complex | float64 | complex128, /) -> complexfloating[_NBit1, _NBit2] | complex128: ... | |
| @overload | |
| def __truediv__(self, other: number[_NBit], /) -> complexfloating[_NBit1, _NBit2] | complexfloating[_NBit, _NBit]: ... | |
| @overload # type: ignore[override] | |
| def __rtruediv__(self, other: _Complex64_co, /) -> complexfloating[_NBit1, _NBit2]: ... | |
| @overload | |
| def __rtruediv__(self, other: complex, /) -> complexfloating[_NBit1, _NBit2] | complex128: ... | |
| @overload | |
| def __rtruediv__(self, other: number[_NBit], /) -> complexfloating[_NBit1, _NBit2] | complexfloating[_NBit, _NBit]: ... | |
| @overload # type: ignore[override] | |
| def __pow__(self, other: _Complex64_co, mod: None = None, /) -> complexfloating[_NBit1, _NBit2]: ... | |
| @overload | |
| def __pow__( | |
| self, other: complex | float64 | complex128, mod: None = None, / | |
| ) -> complexfloating[_NBit1, _NBit2] | complex128: ... | |
| @overload | |
| def __pow__( | |
| self, other: number[_NBit], mod: None = None, / | |
| ) -> complexfloating[_NBit1, _NBit2] | complexfloating[_NBit, _NBit]: ... | |
| @overload # type: ignore[override] | |
| def __rpow__(self, other: _Complex64_co, mod: None = None, /) -> complexfloating[_NBit1, _NBit2]: ... | |
| @overload | |
| def __rpow__(self, other: complex, mod: None = None, /) -> complexfloating[_NBit1, _NBit2] | complex128: ... | |
| @overload | |
| def __rpow__( | |
| self, other: number[_NBit], mod: None = None, / | |
| ) -> complexfloating[_NBit1, _NBit2] | complexfloating[_NBit, _NBit]: ... | |
| complex64: TypeAlias = complexfloating[_32Bit] | |
| class complex128(complexfloating[_64Bit, _64Bit], complex): | |
| @property | |
| def itemsize(self) -> L[16]: ... | |
| @property | |
| def nbytes(self) -> L[16]: ... | |
| # overrides for `floating` and `builtins.float` compatibility | |
| @property | |
| def real(self) -> float64: ... | |
| @property | |
| def imag(self) -> float64: ... | |
| def conjugate(self) -> Self: ... | |
| def __abs__(self) -> float64: ... # type: ignore[override] | |
| def __getnewargs__(self, /) -> tuple[float, float]: ... | |
| # complex128-specific operator overrides | |
| @overload # type: ignore[override] | |
| def __add__(self, other: _Complex128_co, /) -> complex128: ... | |
| @overload | |
| def __add__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... | |
| def __radd__(self, other: _Complex128_co, /) -> complex128: ... # type: ignore[override] | |
| @overload # type: ignore[override] | |
| def __sub__(self, other: _Complex128_co, /) -> complex128: ... | |
| @overload | |
| def __sub__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... | |
| def __rsub__(self, other: _Complex128_co, /) -> complex128: ... # type: ignore[override] | |
| @overload # type: ignore[override] | |
| def __mul__(self, other: _Complex128_co, /) -> complex128: ... | |
| @overload | |
| def __mul__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... | |
| def __rmul__(self, other: _Complex128_co, /) -> complex128: ... # type: ignore[override] | |
| @overload # type: ignore[override] | |
| def __truediv__(self, other: _Complex128_co, /) -> complex128: ... | |
| @overload | |
| def __truediv__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... | |
| def __rtruediv__(self, other: _Complex128_co, /) -> complex128: ... # type: ignore[override] | |
| @overload # type: ignore[override] | |
| def __pow__(self, other: _Complex128_co, mod: None = None, /) -> complex128: ... | |
| @overload | |
| def __pow__( | |
| self, other: complexfloating[_NBit1, _NBit2], mod: None = None, / | |
| ) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... | |
| def __rpow__(self, other: _Complex128_co, mod: None = None, /) -> complex128: ... # type: ignore[override] | |
| csingle: TypeAlias = complex64 | |
| cdouble: TypeAlias = complex128 | |
| clongdouble: TypeAlias = complexfloating[_NBitLongDouble] | |
| class timedelta64(_IntegralMixin, generic[_TD64ItemT_co], Generic[_TD64ItemT_co]): | |
| @property | |
| def itemsize(self) -> L[8]: ... | |
| @property | |
| def nbytes(self) -> L[8]: ... | |
| @overload | |
| def __new__(cls, value: _TD64ItemT_co | timedelta64[_TD64ItemT_co], /) -> Self: ... | |
| @overload | |
| def __new__(cls, /) -> timedelta64[L[0]]: ... | |
| @overload | |
| def __new__(cls, value: _NaTValue | None, format: _TimeUnitSpec, /) -> timedelta64[None]: ... | |
| @overload | |
| def __new__(cls, value: L[0], format: _TimeUnitSpec[_IntTD64Unit] = ..., /) -> timedelta64[L[0]]: ... | |
| @overload | |
| def __new__(cls, value: _IntLike_co, format: _TimeUnitSpec[_IntTD64Unit] = ..., /) -> timedelta64[int]: ... | |
| @overload | |
| def __new__(cls, value: dt.timedelta, format: _TimeUnitSpec[_IntTimeUnit], /) -> timedelta64[int]: ... | |
| @overload | |
| def __new__( | |
| cls, | |
| value: dt.timedelta | _IntLike_co, | |
| format: _TimeUnitSpec[_NativeTD64Unit] = ..., | |
| /, | |
| ) -> timedelta64[dt.timedelta]: ... | |
| @overload | |
| def __new__(cls, value: _ConvertibleToTD64, format: _TimeUnitSpec = ..., /) -> Self: ... | |
| # inherited at runtime from `signedinteger` | |
| def __class_getitem__(cls, type_arg: type | object, /) -> GenericAlias: ... | |
| # NOTE: Only a limited number of units support conversion | |
| # to builtin scalar types: `Y`, `M`, `ns`, `ps`, `fs`, `as` | |
| def __int__(self: timedelta64[int], /) -> int: ... | |
| def __float__(self: timedelta64[int], /) -> float: ... | |
| def __neg__(self, /) -> Self: ... | |
| def __pos__(self, /) -> Self: ... | |
| def __abs__(self, /) -> Self: ... | |
| @overload | |
| def __add__(self: timedelta64[None], x: _TD64Like_co, /) -> timedelta64[None]: ... | |
| @overload | |
| def __add__(self: timedelta64[int], x: timedelta64[int | dt.timedelta], /) -> timedelta64[int]: ... | |
| @overload | |
| def __add__(self: timedelta64[int], x: timedelta64, /) -> timedelta64[int | None]: ... | |
| @overload | |
| def __add__(self: timedelta64[dt.timedelta], x: _AnyDateOrTime, /) -> _AnyDateOrTime: ... | |
| @overload | |
| def __add__(self: timedelta64[_AnyTD64Item], x: timedelta64[_AnyTD64Item] | _IntLike_co, /) -> timedelta64[_AnyTD64Item]: ... | |
| @overload | |
| def __add__(self, x: timedelta64[None], /) -> timedelta64[None]: ... # type: ignore[overload-cannot-match] | |
| __radd__ = __add__ | |
| @overload | |
| def __mul__(self: timedelta64[_AnyTD64Item], x: int | np.integer | np.bool, /) -> timedelta64[_AnyTD64Item]: ... | |
| @overload | |
| def __mul__(self: timedelta64[_AnyTD64Item], x: float | np.floating, /) -> timedelta64[_AnyTD64Item | None]: ... | |
| @overload | |
| def __mul__(self, x: float | np.floating | np.integer | np.bool, /) -> timedelta64: ... | |
| __rmul__ = __mul__ | |
| @overload | |
| def __mod__(self, x: timedelta64[L[0] | None], /) -> timedelta64[None]: ... | |
| @overload | |
| def __mod__(self: timedelta64[None], x: timedelta64, /) -> timedelta64[None]: ... | |
| @overload | |
| def __mod__(self: timedelta64[int], x: timedelta64[int | dt.timedelta], /) -> timedelta64[int | None]: ... | |
| @overload | |
| def __mod__(self: timedelta64[dt.timedelta], x: timedelta64[_AnyTD64Item], /) -> timedelta64[_AnyTD64Item | None]: ... | |
| @overload | |
| def __mod__(self: timedelta64[dt.timedelta], x: dt.timedelta, /) -> dt.timedelta: ... | |
| @overload | |
| def __mod__(self, x: timedelta64[int], /) -> timedelta64[int | None]: ... | |
| @overload | |
| def __mod__(self, x: timedelta64, /) -> timedelta64: ... | |
| # NOTE: The L[0] makes __mod__ non-commutative, which the first two overloads | |
| # reflect. However, mypy does not seem to like this, so we ignore the errors. | |
| @overload | |
| def __rmod__(self, x: timedelta64[None], /) -> timedelta64[None]: ... # type: ignore[misc] | |
| @overload | |
| def __rmod__(self: timedelta64[L[0] | None], x: timedelta64, /) -> timedelta64[None]: ... | |
| @overload | |
| def __rmod__(self: timedelta64[int], x: timedelta64[int | dt.timedelta], /) -> timedelta64[int | None]: ... # type: ignore[misc] | |
| @overload | |
| def __rmod__(self: timedelta64[dt.timedelta], x: timedelta64[_AnyTD64Item], /) -> timedelta64[_AnyTD64Item | None]: ... # type: ignore[misc] | |
| @overload | |
| def __rmod__(self: timedelta64[dt.timedelta], x: dt.timedelta, /) -> dt.timedelta: ... | |
| @overload | |
| def __rmod__(self, x: timedelta64[int], /) -> timedelta64[int | None]: ... # type: ignore[misc] | |
| @overload | |
| def __rmod__(self, x: timedelta64, /) -> timedelta64: ... # type: ignore[misc] | |
| # keep in sync with __mod__ | |
| @overload | |
| def __divmod__(self, x: timedelta64[L[0] | None], /) -> tuple[int64, timedelta64[None]]: ... | |
| @overload | |
| def __divmod__(self: timedelta64[None], x: timedelta64, /) -> tuple[int64, timedelta64[None]]: ... | |
| @overload | |
| def __divmod__(self: timedelta64[int], x: timedelta64[int | dt.timedelta], /) -> tuple[int64, timedelta64[int | None]]: ... | |
| @overload | |
| def __divmod__( | |
| self: timedelta64[dt.timedelta], x: timedelta64[_AnyTD64Item], / | |
| ) -> tuple[int64, timedelta64[_AnyTD64Item | None]]: ... | |
| @overload | |
| def __divmod__(self: timedelta64[dt.timedelta], x: dt.timedelta, /) -> tuple[int, dt.timedelta]: ... | |
| @overload | |
| def __divmod__(self, x: timedelta64[int], /) -> tuple[int64, timedelta64[int | None]]: ... | |
| @overload | |
| def __divmod__(self, x: timedelta64, /) -> tuple[int64, timedelta64]: ... | |
| # keep in sync with __rmod__ | |
| @overload | |
| def __rdivmod__(self, x: timedelta64[None], /) -> tuple[int64, timedelta64[None]]: ... # type: ignore[misc] | |
| @overload | |
| def __rdivmod__(self: timedelta64[L[0] | None], x: timedelta64, /) -> tuple[int64, timedelta64[None]]: ... # type: ignore[misc] | |
| @overload | |
| def __rdivmod__(self: timedelta64[int], x: timedelta64[int | dt.timedelta], /) -> tuple[int64, timedelta64[int | None]]: ... # type: ignore[misc] | |
| @overload | |
| def __rdivmod__( # type: ignore[misc] | |
| self: timedelta64[dt.timedelta], x: timedelta64[_AnyTD64Item], / | |
| ) -> tuple[int64, timedelta64[_AnyTD64Item | None]]: ... | |
| @overload | |
| def __rdivmod__(self: timedelta64[dt.timedelta], x: dt.timedelta, /) -> tuple[int, dt.timedelta]: ... | |
| @overload | |
| def __rdivmod__(self, x: timedelta64[int], /) -> tuple[int64, timedelta64[int | None]]: ... # type: ignore[misc] | |
| @overload | |
| def __rdivmod__(self, x: timedelta64, /) -> tuple[int64, timedelta64]: ... # type: ignore[misc] | |
| @overload | |
| def __sub__(self: timedelta64[None], b: _TD64Like_co, /) -> timedelta64[None]: ... | |
| @overload | |
| def __sub__(self: timedelta64[int], b: timedelta64[int | dt.timedelta], /) -> timedelta64[int]: ... | |
| @overload | |
| def __sub__(self: timedelta64[int], b: timedelta64, /) -> timedelta64[int | None]: ... | |
| @overload | |
| def __sub__(self: timedelta64[dt.timedelta], b: dt.timedelta, /) -> dt.timedelta: ... | |
| @overload | |
| def __sub__(self: timedelta64[_AnyTD64Item], b: timedelta64[_AnyTD64Item] | _IntLike_co, /) -> timedelta64[_AnyTD64Item]: ... | |
| @overload | |
| def __sub__(self, b: timedelta64[None], /) -> timedelta64[None]: ... # type: ignore[overload-cannot-match] | |
| # NOTE: subtraction is not commutative, so __rsub__ differs from __sub__. | |
| # This confuses mypy, so we ignore the [misc] errors it reports. | |
| @overload | |
| def __rsub__(self: timedelta64[None], a: _TD64Like_co, /) -> timedelta64[None]: ... | |
| @overload | |
| def __rsub__(self: timedelta64[dt.timedelta], a: _AnyDateOrTime, /) -> _AnyDateOrTime: ... | |
| @overload | |
| def __rsub__(self: timedelta64[dt.timedelta], a: timedelta64[_AnyTD64Item], /) -> timedelta64[_AnyTD64Item]: ... # type: ignore[misc] | |
| @overload | |
| def __rsub__(self: timedelta64[_AnyTD64Item], a: timedelta64[_AnyTD64Item] | _IntLike_co, /) -> timedelta64[_AnyTD64Item]: ... # type: ignore[misc] | |
| @overload | |
| def __rsub__(self, a: timedelta64[None], /) -> timedelta64[None]: ... # type: ignore[overload-cannot-match] | |
| @overload | |
| def __rsub__(self, a: datetime64[None], /) -> datetime64[None]: ... # type: ignore[misc] | |
| @overload | |
| def __truediv__(self: timedelta64[dt.timedelta], b: dt.timedelta, /) -> float: ... | |
| @overload | |
| def __truediv__(self, b: timedelta64, /) -> float64: ... | |
| @overload | |
| def __truediv__(self: timedelta64[_AnyTD64Item], b: int | integer, /) -> timedelta64[_AnyTD64Item]: ... | |
| @overload | |
| def __truediv__(self: timedelta64[_AnyTD64Item], b: float | floating, /) -> timedelta64[_AnyTD64Item | None]: ... | |
| @overload | |
| def __truediv__(self, b: float | floating | integer, /) -> timedelta64: ... | |
| @overload | |
| def __rtruediv__(self: timedelta64[dt.timedelta], a: dt.timedelta, /) -> float: ... | |
| @overload | |
| def __rtruediv__(self, a: timedelta64, /) -> float64: ... | |
| @overload | |
| def __floordiv__(self: timedelta64[dt.timedelta], b: dt.timedelta, /) -> int: ... | |
| @overload | |
| def __floordiv__(self, b: timedelta64, /) -> int64: ... | |
| @overload | |
| def __floordiv__(self: timedelta64[_AnyTD64Item], b: int | integer, /) -> timedelta64[_AnyTD64Item]: ... | |
| @overload | |
| def __floordiv__(self: timedelta64[_AnyTD64Item], b: float | floating, /) -> timedelta64[_AnyTD64Item | None]: ... | |
| @overload | |
| def __rfloordiv__(self: timedelta64[dt.timedelta], a: dt.timedelta, /) -> int: ... | |
| @overload | |
| def __rfloordiv__(self, a: timedelta64, /) -> int64: ... | |
| # comparison ops | |
| @overload | |
| def __lt__(self, other: _TD64Like_co, /) -> bool_: ... | |
| @overload | |
| def __lt__(self, other: _ArrayLikeTD64_co | _NestedSequence[_SupportsGT], /) -> NDArray[bool_]: ... | |
| @overload | |
| def __lt__(self, other: _SupportsGT, /) -> bool_: ... | |
| @overload | |
| def __le__(self, other: _TD64Like_co, /) -> bool_: ... | |
| @overload | |
| def __le__(self, other: _ArrayLikeTD64_co | _NestedSequence[_SupportsGE], /) -> NDArray[bool_]: ... | |
| @overload | |
| def __le__(self, other: _SupportsGT, /) -> bool_: ... | |
| @overload | |
| def __gt__(self, other: _TD64Like_co, /) -> bool_: ... | |
| @overload | |
| def __gt__(self, other: _ArrayLikeTD64_co | _NestedSequence[_SupportsLT], /) -> NDArray[bool_]: ... | |
| @overload | |
| def __gt__(self, other: _SupportsGT, /) -> bool_: ... | |
| @overload | |
| def __ge__(self, other: _TD64Like_co, /) -> bool_: ... | |
| @overload | |
| def __ge__(self, other: _ArrayLikeTD64_co | _NestedSequence[_SupportsLE], /) -> NDArray[bool_]: ... | |
| @overload | |
| def __ge__(self, other: _SupportsGT, /) -> bool_: ... | |
| class datetime64(_RealMixin, generic[_DT64ItemT_co], Generic[_DT64ItemT_co]): | |
| @property | |
| def itemsize(self) -> L[8]: ... | |
| @property | |
| def nbytes(self) -> L[8]: ... | |
| @overload | |
| def __new__(cls, value: datetime64[_DT64ItemT_co], /) -> Self: ... | |
| @overload | |
| def __new__(cls, value: _AnyDT64Arg, /) -> datetime64[_AnyDT64Arg]: ... | |
| @overload | |
| def __new__(cls, value: _NaTValue | None = ..., format: _TimeUnitSpec = ..., /) -> datetime64[None]: ... | |
| @overload | |
| def __new__(cls, value: _DT64Now, format: _TimeUnitSpec[_NativeTimeUnit] = ..., /) -> datetime64[dt.datetime]: ... | |
| @overload | |
| def __new__(cls, value: _DT64Date, format: _TimeUnitSpec[_DateUnit] = ..., /) -> datetime64[dt.date]: ... | |
| @overload | |
| def __new__(cls, value: int | bytes | str | dt.date, format: _TimeUnitSpec[_IntTimeUnit], /) -> datetime64[int]: ... | |
| @overload | |
| def __new__( | |
| cls, value: int | bytes | str | dt.date, format: _TimeUnitSpec[_NativeTimeUnit], / | |
| ) -> datetime64[dt.datetime]: ... | |
| @overload | |
| def __new__(cls, value: int | bytes | str | dt.date, format: _TimeUnitSpec[_DateUnit], /) -> datetime64[dt.date]: ... | |
| @overload | |
| def __new__(cls, value: bytes | str | dt.date | None, format: _TimeUnitSpec = ..., /) -> Self: ... | |
| def __class_getitem__(cls, type_arg: type | object, /) -> GenericAlias: ... | |
| @overload | |
| def __add__(self: datetime64[_AnyDT64Item], x: int | integer | np.bool, /) -> datetime64[_AnyDT64Item]: ... | |
| @overload | |
| def __add__(self: datetime64[None], x: _TD64Like_co, /) -> datetime64[None]: ... | |
| @overload | |
| def __add__(self: datetime64[int], x: timedelta64[int | dt.timedelta], /) -> datetime64[int]: ... | |
| @overload | |
| def __add__(self: datetime64[dt.datetime], x: timedelta64[dt.timedelta], /) -> datetime64[dt.datetime]: ... | |
| @overload | |
| def __add__(self: datetime64[dt.date], x: timedelta64[dt.timedelta], /) -> datetime64[dt.date]: ... | |
| @overload | |
| def __add__(self: datetime64[dt.date], x: timedelta64[int], /) -> datetime64[int]: ... | |
| @overload | |
| def __add__(self, x: datetime64[None], /) -> datetime64[None]: ... | |
| @overload | |
| def __add__(self, x: _TD64Like_co, /) -> datetime64: ... | |
| __radd__ = __add__ | |
| @overload | |
| def __sub__(self: datetime64[_AnyDT64Item], x: int | integer | np.bool, /) -> datetime64[_AnyDT64Item]: ... | |
| @overload | |
| def __sub__(self: datetime64[_AnyDate], x: _AnyDate, /) -> dt.timedelta: ... | |
| @overload | |
| def __sub__(self: datetime64[None], x: timedelta64, /) -> datetime64[None]: ... | |
| @overload | |
| def __sub__(self: datetime64[None], x: datetime64, /) -> timedelta64[None]: ... | |
| @overload | |
| def __sub__(self: datetime64[int], x: timedelta64, /) -> datetime64[int]: ... | |
| @overload | |
| def __sub__(self: datetime64[int], x: datetime64, /) -> timedelta64[int]: ... | |
| @overload | |
| def __sub__(self: datetime64[dt.datetime], x: timedelta64[int], /) -> datetime64[int]: ... | |
| @overload | |
| def __sub__(self: datetime64[dt.datetime], x: timedelta64[dt.timedelta], /) -> datetime64[dt.datetime]: ... | |
| @overload | |
| def __sub__(self: datetime64[dt.datetime], x: datetime64[int], /) -> timedelta64[int]: ... | |
| @overload | |
| def __sub__(self: datetime64[dt.date], x: timedelta64[int], /) -> datetime64[dt.date | int]: ... | |
| @overload | |
| def __sub__(self: datetime64[dt.date], x: timedelta64[dt.timedelta], /) -> datetime64[dt.date]: ... | |
| @overload | |
| def __sub__(self: datetime64[dt.date], x: datetime64[dt.date], /) -> timedelta64[dt.timedelta]: ... | |
| @overload | |
| def __sub__(self, x: timedelta64[None], /) -> datetime64[None]: ... | |
| @overload | |
| def __sub__(self, x: datetime64[None], /) -> timedelta64[None]: ... | |
| @overload | |
| def __sub__(self, x: _TD64Like_co, /) -> datetime64: ... | |
| @overload | |
| def __sub__(self, x: datetime64, /) -> timedelta64: ... | |
| # NOTE: mypy gets confused by the non-commutativity of subtraction here | |
| @overload | |
| def __rsub__(self: datetime64[_AnyDT64Item], x: int | integer | np.bool, /) -> datetime64[_AnyDT64Item]: ... | |
| @overload | |
| def __rsub__(self: datetime64[_AnyDate], x: _AnyDate, /) -> dt.timedelta: ... | |
| @overload | |
| def __rsub__(self: datetime64[None], x: datetime64, /) -> timedelta64[None]: ... | |
| @overload | |
| def __rsub__(self: datetime64[int], x: datetime64, /) -> timedelta64[int]: ... | |
| @overload | |
| def __rsub__(self: datetime64[dt.datetime], x: datetime64[int], /) -> timedelta64[int]: ... # type: ignore[misc] | |
| @overload | |
| def __rsub__(self: datetime64[dt.datetime], x: datetime64[dt.date], /) -> timedelta64[dt.timedelta]: ... # type: ignore[misc] | |
| @overload | |
| def __rsub__(self, x: datetime64[None], /) -> timedelta64[None]: ... # type: ignore[misc] | |
| @overload | |
| def __rsub__(self, x: datetime64, /) -> timedelta64: ... # type: ignore[misc] | |
| @overload | |
| def __lt__(self, other: datetime64, /) -> bool_: ... | |
| @overload | |
| def __lt__(self, other: _ArrayLikeDT64_co | _NestedSequence[_SupportsGT], /) -> NDArray[bool_]: ... | |
| @overload | |
| def __lt__(self, other: _SupportsGT, /) -> bool_: ... | |
| @overload | |
| def __le__(self, other: datetime64, /) -> bool_: ... | |
| @overload | |
| def __le__(self, other: _ArrayLikeDT64_co | _NestedSequence[_SupportsGE], /) -> NDArray[bool_]: ... | |
| @overload | |
| def __le__(self, other: _SupportsGT, /) -> bool_: ... | |
| @overload | |
| def __gt__(self, other: datetime64, /) -> bool_: ... | |
| @overload | |
| def __gt__(self, other: _ArrayLikeDT64_co | _NestedSequence[_SupportsLT], /) -> NDArray[bool_]: ... | |
| @overload | |
| def __gt__(self, other: _SupportsGT, /) -> bool_: ... | |
| @overload | |
| def __ge__(self, other: datetime64, /) -> bool_: ... | |
| @overload | |
| def __ge__(self, other: _ArrayLikeDT64_co | _NestedSequence[_SupportsLE], /) -> NDArray[bool_]: ... | |
| @overload | |
| def __ge__(self, other: _SupportsGT, /) -> bool_: ... | |
| @final # cannot be subclassed at runtime | |
| class flexible(_RealMixin, generic[_FlexibleItemT_co], Generic[_FlexibleItemT_co]): ... # type: ignore[misc] | |
| class void(flexible[bytes | tuple[Any, ...]]): # type: ignore[misc] | |
| @overload | |
| def __new__(cls, length_or_data: _IntLike_co | bytes, /, dtype: None = None) -> Self: ... | |
| @overload | |
| def __new__(cls, length_or_data: object, /, dtype: _DTypeLikeVoid) -> Self: ... | |
| @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: ... | |
| def setfield(self, val: ArrayLike, dtype: DTypeLike, offset: int = ...) -> None: ... | |
| class character(flexible[_CharacterItemT_co], Generic[_CharacterItemT_co]): # type: ignore[misc] | |
| @abstractmethod | |
| def __new__(cls, value: object = ..., /) -> Self: ... | |
| # NOTE: Most `np.bytes_` / `np.str_` methods return their builtin `bytes` / `str` counterpart | |
| class bytes_(character[bytes], bytes): # type: ignore[misc] | |
| @overload | |
| def __new__(cls, value: object = b"", /) -> Self: ... | |
| @overload | |
| def __new__(cls, value: str, /, encoding: str, errors: str = "strict") -> Self: ... | |
| # | |
| @override | |
| def __hash__(self, /) -> int: ... | |
| # | |
| def __bytes__(self, /) -> bytes: ... | |
| class str_(character[str], str): # type: ignore[misc] | |
| @overload | |
| def __new__(cls, value: object = "", /) -> Self: ... | |
| @overload | |
| def __new__(cls, value: bytes, /, encoding: str, errors: str = "strict") -> Self: ... | |
| # | |
| @override | |
| def __hash__(self, /) -> int: ... | |
| # See `numpy._typing._ufunc` for more concrete nin-/nout-specific stubs | |
| @final | |
| class ufunc: | |
| __signature__: Final[inspect.Signature] | |
| @property | |
| def __name__(self) -> LiteralString: ... | |
| @property | |
| def __qualname__(self) -> LiteralString: ... # pyright: ignore[reportIncompatibleVariableOverride] | |
| @property | |
| def __doc__(self) -> str: ... # type: ignore[override] | |
| @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[LiteralString]: ... | |
| # 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) -> LiteralString | None: ... | |
| def __call__(self, /, *args: Any, **kwargs: Any) -> Any: ... | |
| # 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. | |
| def accumulate( | |
| self, | |
| array: ArrayLike, | |
| /, | |
| axis: SupportsIndex = 0, | |
| dtype: DTypeLike | None = None, | |
| out: ndarray | EllipsisType | None = None, | |
| ) -> NDArray[Incomplete]: ... | |
| def reduce( | |
| self, | |
| array: ArrayLike, | |
| /, | |
| axis: _ShapeLike | None = 0, | |
| dtype: DTypeLike | None = None, | |
| out: ndarray | EllipsisType | None = None, | |
| **kwargs: Incomplete, | |
| ) -> Incomplete: ... | |
| def reduceat( | |
| self, | |
| array: ArrayLike, | |
| /, | |
| indices: _ArrayLikeInt_co, | |
| axis: SupportsIndex = 0, | |
| dtype: DTypeLike | None = None, | |
| out: ndarray | EllipsisType | None = None, | |
| ) -> NDArray[Incomplete]: ... | |
| def outer(self, A: ArrayLike, B: ArrayLike, /, **kwargs: Incomplete) -> NDArray[Incomplete]: ... | |
| # Similarly `at` won't be defined for ufuncs that return multiple | |
| # outputs, so we can't type it very precisely. | |
| def at(self, a: ndarray, indices: _ArrayLikeInt_co, b: ArrayLike | None = None, /) -> None: ... | |
| # | |
| def resolve_dtypes( | |
| self, | |
| /, | |
| dtypes: tuple[dtype | type | None, ...], | |
| *, | |
| signature: tuple[dtype | None, ...] | None = None, | |
| casting: _CastingKind | None = None, | |
| reduction: builtins.bool = False, | |
| ) -> tuple[dtype, ...]: ... | |
| # 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_count: _UFunc_Nin1_Nout1[L["bitwise_count"], L[11], 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] | |
| 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["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, L["(n?,k),(k,m?)->(n?,m?)"]] | |
| matvec: _GUFunc_Nin2_Nout1[L["matvec"], L[19], None, L["(m,n),(n)->(m)"]] | |
| maximum: _UFunc_Nin2_Nout1[L["maximum"], L[21], None] | |
| minimum: _UFunc_Nin2_Nout1[L["minimum"], L[21], 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] | |
| trunc: _UFunc_Nin1_Nout1[L["trunc"], L[7], None] | |
| vecdot: _GUFunc_Nin2_Nout1[L["vecdot"], L[19], None, L["(n),(n)->()"]] | |
| vecmat: _GUFunc_Nin2_Nout1[L["vecmat"], L[19], None, L["(n),(n,m)->(m)"]] | |
| abs = absolute | |
| acos = arccos | |
| acosh = arccosh | |
| asin = arcsin | |
| asinh = arcsinh | |
| atan = arctan | |
| atanh = arctanh | |
| atan2 = arctan2 | |
| concat = concatenate | |
| bitwise_left_shift = left_shift | |
| bitwise_not = invert | |
| bitwise_invert = invert | |
| bitwise_right_shift = right_shift | |
| conj = conjugate | |
| mod = remainder | |
| permute_dims = transpose | |
| pow = power | |
| true_divide = divide | |
| # 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) -> _AnyShape: ... | |
| @property | |
| def size(self) -> int: ... | |
| def __next__(self) -> tuple[Any, ...]: ... | |
| def __iter__(self) -> Self: ... | |
| def reset(self) -> None: ... | |
| @final | |
| class busdaycalendar: | |
| def __init__( | |
| self, | |
| /, | |
| weekmask: str | Sequence[int | bool_ | integer] | _SupportsArray[dtype[bool_ | integer]] = "1111100", | |
| holidays: Sequence[dt.date | datetime64] | _SupportsArray[dtype[datetime64]] | None = None, | |
| ) -> None: ... | |
| @property | |
| def weekmask(self) -> ndarray[tuple[int], dtype[bool_]]: ... | |
| @property | |
| def holidays(self) -> ndarray[tuple[int], dtype[datetime64[dt.date]]]: ... | |
| @final | |
| class nditer: | |
| @overload | |
| def __init__( | |
| self, | |
| /, | |
| op: ArrayLike, | |
| flags: Sequence[_NDIterFlagsKind] | None = None, | |
| op_flags: Sequence[_NDIterFlagsOp] | None = None, | |
| op_dtypes: DTypeLike | None = None, | |
| order: _OrderKACF = "K", | |
| casting: _CastingKind = "safe", | |
| op_axes: Sequence[SupportsIndex] | None = None, | |
| itershape: _ShapeLike | None = None, | |
| buffersize: SupportsIndex = 0, | |
| ) -> None: ... | |
| @overload | |
| def __init__( | |
| self, | |
| /, | |
| op: Sequence[ArrayLike | None], | |
| flags: Sequence[_NDIterFlagsKind] | None = None, | |
| op_flags: Sequence[Sequence[_NDIterFlagsOp]] | None = None, | |
| op_dtypes: Sequence[DTypeLike | None] | None = None, | |
| order: _OrderKACF = "K", | |
| casting: _CastingKind = "safe", | |
| op_axes: Sequence[Sequence[SupportsIndex]] | None = None, | |
| itershape: _ShapeLike | None = None, | |
| buffersize: SupportsIndex = 0, | |
| ) -> None: ... | |
| def __enter__(self) -> nditer: ... | |
| def __exit__( | |
| self, | |
| exc_type: type[BaseException] | None, | |
| exc_value: BaseException | None, | |
| traceback: TracebackType | None, | |
| ) -> 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) -> builtins.bool: ... | |
| def remove_axis(self, i: SupportsIndex, /) -> None: ... | |
| def remove_multi_index(self) -> None: ... | |
| def reset(self) -> None: ... | |
| @property | |
| def dtypes(self) -> tuple[dtype, ...]: ... | |
| @property | |
| def finished(self) -> builtins.bool: ... | |
| @property | |
| def has_delayed_bufalloc(self) -> builtins.bool: ... | |
| @property | |
| def has_index(self) -> builtins.bool: ... | |
| @property | |
| def has_multi_index(self) -> builtins.bool: ... | |
| @property | |
| def index(self) -> int: ... | |
| @property | |
| def iterationneedsapi(self) -> builtins.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], ...]: ... | |
| class memmap(ndarray[_ShapeT_co, _DTypeT_co]): | |
| __array_priority__: ClassVar[float] | |
| filename: str | None | |
| offset: int | |
| mode: str | |
| @overload | |
| def __new__( | |
| subtype, | |
| filename: StrOrBytesPath | _SupportsFileMethodsRW, | |
| dtype: type[uint8] = ..., | |
| mode: _MemMapModeKind = "r+", | |
| offset: int = 0, | |
| shape: int | tuple[int, ...] | None = None, | |
| order: _OrderKACF = "C", | |
| ) -> memmap[Any, dtype[uint8]]: ... | |
| @overload | |
| def __new__( | |
| subtype, | |
| filename: StrOrBytesPath | _SupportsFileMethodsRW, | |
| dtype: _DTypeLike[_ScalarT], | |
| mode: _MemMapModeKind = "r+", | |
| offset: int = 0, | |
| shape: int | tuple[int, ...] | None = None, | |
| order: _OrderKACF = "C", | |
| ) -> memmap[Any, dtype[_ScalarT]]: ... | |
| @overload | |
| def __new__( | |
| subtype, | |
| filename: StrOrBytesPath | _SupportsFileMethodsRW, | |
| dtype: DTypeLike, | |
| mode: _MemMapModeKind = "r+", | |
| offset: int = 0, | |
| shape: int | tuple[int, ...] | None = None, | |
| order: _OrderKACF = "C", | |
| ) -> memmap[Any, dtype]: ... | |
| def __array_finalize__(self, obj: object) -> None: ... | |
| def __array_wrap__( | |
| self, | |
| array: memmap[_ShapeT_co, _DTypeT_co], # type: ignore[override] | |
| context: tuple[ufunc, tuple[Any, ...], int] | None = None, | |
| return_scalar: builtins.bool = False, | |
| ) -> Any: ... | |
| def flush(self) -> None: ... | |
| class poly1d: | |
| @property | |
| def variable(self) -> LiteralString: ... | |
| @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[assignment] # pyright: ignore[reportIncompatibleMethodOverride] | |
| @overload | |
| def __array__(self, /, t: None = None, copy: builtins.bool | None = None) -> ndarray[tuple[int], dtype]: ... | |
| @overload | |
| def __array__(self, /, t: _DTypeT, copy: builtins.bool | None = None) -> ndarray[tuple[int], _DTypeT]: ... | |
| @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: builtins.bool = False, | |
| variable: str | None = None, | |
| ) -> 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 __truediv__(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 = 1) -> poly1d: ... | |
| def integ( | |
| self, | |
| m: SupportsInt | SupportsIndex = 1, | |
| k: _ArrayLikeComplex_co | _ArrayLikeObject_co | None = 0, | |
| ) -> poly1d: ... | |
| def from_dlpack( | |
| x: _SupportsDLPack[None], | |
| /, | |
| *, | |
| device: L["cpu"] | None = None, | |
| copy: builtins.bool | None = None, | |
| ) -> NDArray[number | np.bool]: ... | |
Xet Storage Details
- Size:
- 236 kB
- Xet hash:
- aad3b93305b43f1d2350d7e13fe09898f474d6d2d1589419a6ea24078f2e7029
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.