|
|
|
|
|
|
|
|
|
|
|
from typing import Any, SupportsIndex, TypeVar |
|
|
|
|
|
from _typeshed import Incomplete |
|
|
from typing_extensions import deprecated |
|
|
|
|
|
from numpy import _OrderKACF, amax, amin, bool_, dtype, expand_dims, float64, ndarray |
|
|
from numpy._typing import ArrayLike, _DTypeLikeBool |
|
|
|
|
|
__all__ = [ |
|
|
"MAError", |
|
|
"MaskError", |
|
|
"MaskType", |
|
|
"MaskedArray", |
|
|
"abs", |
|
|
"absolute", |
|
|
"add", |
|
|
"all", |
|
|
"allclose", |
|
|
"allequal", |
|
|
"alltrue", |
|
|
"amax", |
|
|
"amin", |
|
|
"angle", |
|
|
"anom", |
|
|
"anomalies", |
|
|
"any", |
|
|
"append", |
|
|
"arange", |
|
|
"arccos", |
|
|
"arccosh", |
|
|
"arcsin", |
|
|
"arcsinh", |
|
|
"arctan", |
|
|
"arctan2", |
|
|
"arctanh", |
|
|
"argmax", |
|
|
"argmin", |
|
|
"argsort", |
|
|
"around", |
|
|
"array", |
|
|
"asanyarray", |
|
|
"asarray", |
|
|
"bitwise_and", |
|
|
"bitwise_or", |
|
|
"bitwise_xor", |
|
|
"bool_", |
|
|
"ceil", |
|
|
"choose", |
|
|
"clip", |
|
|
"common_fill_value", |
|
|
"compress", |
|
|
"compressed", |
|
|
"concatenate", |
|
|
"conjugate", |
|
|
"convolve", |
|
|
"copy", |
|
|
"correlate", |
|
|
"cos", |
|
|
"cosh", |
|
|
"count", |
|
|
"cumprod", |
|
|
"cumsum", |
|
|
"default_fill_value", |
|
|
"diag", |
|
|
"diagonal", |
|
|
"diff", |
|
|
"divide", |
|
|
"empty", |
|
|
"empty_like", |
|
|
"equal", |
|
|
"exp", |
|
|
"expand_dims", |
|
|
"fabs", |
|
|
"filled", |
|
|
"fix_invalid", |
|
|
"flatten_mask", |
|
|
"flatten_structured_array", |
|
|
"floor", |
|
|
"floor_divide", |
|
|
"fmod", |
|
|
"frombuffer", |
|
|
"fromflex", |
|
|
"fromfunction", |
|
|
"getdata", |
|
|
"getmask", |
|
|
"getmaskarray", |
|
|
"greater", |
|
|
"greater_equal", |
|
|
"harden_mask", |
|
|
"hypot", |
|
|
"identity", |
|
|
"ids", |
|
|
"indices", |
|
|
"inner", |
|
|
"innerproduct", |
|
|
"isMA", |
|
|
"isMaskedArray", |
|
|
"is_mask", |
|
|
"is_masked", |
|
|
"isarray", |
|
|
"left_shift", |
|
|
"less", |
|
|
"less_equal", |
|
|
"log", |
|
|
"log2", |
|
|
"log10", |
|
|
"logical_and", |
|
|
"logical_not", |
|
|
"logical_or", |
|
|
"logical_xor", |
|
|
"make_mask", |
|
|
"make_mask_descr", |
|
|
"make_mask_none", |
|
|
"mask_or", |
|
|
"masked", |
|
|
"masked_array", |
|
|
"masked_equal", |
|
|
"masked_greater", |
|
|
"masked_greater_equal", |
|
|
"masked_inside", |
|
|
"masked_invalid", |
|
|
"masked_less", |
|
|
"masked_less_equal", |
|
|
"masked_not_equal", |
|
|
"masked_object", |
|
|
"masked_outside", |
|
|
"masked_print_option", |
|
|
"masked_singleton", |
|
|
"masked_values", |
|
|
"masked_where", |
|
|
"max", |
|
|
"maximum", |
|
|
"maximum_fill_value", |
|
|
"mean", |
|
|
"min", |
|
|
"minimum", |
|
|
"minimum_fill_value", |
|
|
"mod", |
|
|
"multiply", |
|
|
"mvoid", |
|
|
"ndim", |
|
|
"negative", |
|
|
"nomask", |
|
|
"nonzero", |
|
|
"not_equal", |
|
|
"ones", |
|
|
"ones_like", |
|
|
"outer", |
|
|
"outerproduct", |
|
|
"power", |
|
|
"prod", |
|
|
"product", |
|
|
"ptp", |
|
|
"put", |
|
|
"putmask", |
|
|
"ravel", |
|
|
"remainder", |
|
|
"repeat", |
|
|
"reshape", |
|
|
"resize", |
|
|
"right_shift", |
|
|
"round", |
|
|
"round_", |
|
|
"set_fill_value", |
|
|
"shape", |
|
|
"sin", |
|
|
"sinh", |
|
|
"size", |
|
|
"soften_mask", |
|
|
"sometrue", |
|
|
"sort", |
|
|
"sqrt", |
|
|
"squeeze", |
|
|
"std", |
|
|
"subtract", |
|
|
"sum", |
|
|
"swapaxes", |
|
|
"take", |
|
|
"tan", |
|
|
"tanh", |
|
|
"trace", |
|
|
"transpose", |
|
|
"true_divide", |
|
|
"var", |
|
|
"where", |
|
|
"zeros", |
|
|
"zeros_like", |
|
|
] |
|
|
|
|
|
_ShapeType_co = TypeVar("_ShapeType_co", bound=tuple[int, ...], covariant=True) |
|
|
_DType_co = TypeVar("_DType_co", bound=dtype[Any], covariant=True) |
|
|
|
|
|
|
|
|
MaskType = bool |
|
|
nomask: bool |
|
|
|
|
|
class MaskedArrayFutureWarning(FutureWarning): ... |
|
|
class MAError(Exception): ... |
|
|
class MaskError(MAError): ... |
|
|
|
|
|
def default_fill_value(obj): ... |
|
|
def minimum_fill_value(obj): ... |
|
|
def maximum_fill_value(obj): ... |
|
|
def set_fill_value(a, fill_value): ... |
|
|
def common_fill_value(a, b): ... |
|
|
def filled(a, fill_value=...): ... |
|
|
def getdata(a, subok=...): ... |
|
|
get_data = getdata |
|
|
|
|
|
def fix_invalid(a, mask=..., copy=..., fill_value=...): ... |
|
|
|
|
|
class _MaskedUFunc: |
|
|
f: Any |
|
|
__doc__: Any |
|
|
__name__: Any |
|
|
def __init__(self, ufunc): ... |
|
|
|
|
|
class _MaskedUnaryOperation(_MaskedUFunc): |
|
|
fill: Any |
|
|
domain: Any |
|
|
def __init__(self, mufunc, fill=..., domain=...): ... |
|
|
def __call__(self, a, *args, **kwargs): ... |
|
|
|
|
|
class _MaskedBinaryOperation(_MaskedUFunc): |
|
|
fillx: Any |
|
|
filly: Any |
|
|
def __init__(self, mbfunc, fillx=..., filly=...): ... |
|
|
def __call__(self, a, b, *args, **kwargs): ... |
|
|
def reduce(self, target, axis=..., dtype=...): ... |
|
|
def outer(self, a, b): ... |
|
|
def accumulate(self, target, axis=...): ... |
|
|
|
|
|
class _DomainedBinaryOperation(_MaskedUFunc): |
|
|
domain: Any |
|
|
fillx: Any |
|
|
filly: Any |
|
|
def __init__(self, dbfunc, domain, fillx=..., filly=...): ... |
|
|
def __call__(self, a, b, *args, **kwargs): ... |
|
|
|
|
|
exp: _MaskedUnaryOperation |
|
|
conjugate: _MaskedUnaryOperation |
|
|
sin: _MaskedUnaryOperation |
|
|
cos: _MaskedUnaryOperation |
|
|
arctan: _MaskedUnaryOperation |
|
|
arcsinh: _MaskedUnaryOperation |
|
|
sinh: _MaskedUnaryOperation |
|
|
cosh: _MaskedUnaryOperation |
|
|
tanh: _MaskedUnaryOperation |
|
|
abs: _MaskedUnaryOperation |
|
|
absolute: _MaskedUnaryOperation |
|
|
angle: _MaskedUnaryOperation |
|
|
fabs: _MaskedUnaryOperation |
|
|
negative: _MaskedUnaryOperation |
|
|
floor: _MaskedUnaryOperation |
|
|
ceil: _MaskedUnaryOperation |
|
|
around: _MaskedUnaryOperation |
|
|
logical_not: _MaskedUnaryOperation |
|
|
sqrt: _MaskedUnaryOperation |
|
|
log: _MaskedUnaryOperation |
|
|
log2: _MaskedUnaryOperation |
|
|
log10: _MaskedUnaryOperation |
|
|
tan: _MaskedUnaryOperation |
|
|
arcsin: _MaskedUnaryOperation |
|
|
arccos: _MaskedUnaryOperation |
|
|
arccosh: _MaskedUnaryOperation |
|
|
arctanh: _MaskedUnaryOperation |
|
|
|
|
|
add: _MaskedBinaryOperation |
|
|
subtract: _MaskedBinaryOperation |
|
|
multiply: _MaskedBinaryOperation |
|
|
arctan2: _MaskedBinaryOperation |
|
|
equal: _MaskedBinaryOperation |
|
|
not_equal: _MaskedBinaryOperation |
|
|
less_equal: _MaskedBinaryOperation |
|
|
greater_equal: _MaskedBinaryOperation |
|
|
less: _MaskedBinaryOperation |
|
|
greater: _MaskedBinaryOperation |
|
|
logical_and: _MaskedBinaryOperation |
|
|
def alltrue(target: ArrayLike, axis: SupportsIndex | None = 0, dtype: _DTypeLikeBool | None = None) -> Incomplete: ... |
|
|
logical_or: _MaskedBinaryOperation |
|
|
def sometrue(target: ArrayLike, axis: SupportsIndex | None = 0, dtype: _DTypeLikeBool | None = None) -> Incomplete: ... |
|
|
logical_xor: _MaskedBinaryOperation |
|
|
bitwise_and: _MaskedBinaryOperation |
|
|
bitwise_or: _MaskedBinaryOperation |
|
|
bitwise_xor: _MaskedBinaryOperation |
|
|
hypot: _MaskedBinaryOperation |
|
|
|
|
|
divide: _DomainedBinaryOperation |
|
|
true_divide: _DomainedBinaryOperation |
|
|
floor_divide: _DomainedBinaryOperation |
|
|
remainder: _DomainedBinaryOperation |
|
|
fmod: _DomainedBinaryOperation |
|
|
mod: _DomainedBinaryOperation |
|
|
|
|
|
def make_mask_descr(ndtype): ... |
|
|
def getmask(a): ... |
|
|
get_mask = getmask |
|
|
|
|
|
def getmaskarray(arr): ... |
|
|
def is_mask(m): ... |
|
|
def make_mask(m, copy=..., shrink=..., dtype=...): ... |
|
|
def make_mask_none(newshape, dtype=...): ... |
|
|
def mask_or(m1, m2, copy=..., shrink=...): ... |
|
|
def flatten_mask(mask): ... |
|
|
def masked_where(condition, a, copy=...): ... |
|
|
def masked_greater(x, value, copy=...): ... |
|
|
def masked_greater_equal(x, value, copy=...): ... |
|
|
def masked_less(x, value, copy=...): ... |
|
|
def masked_less_equal(x, value, copy=...): ... |
|
|
def masked_not_equal(x, value, copy=...): ... |
|
|
def masked_equal(x, value, copy=...): ... |
|
|
def masked_inside(x, v1, v2, copy=...): ... |
|
|
def masked_outside(x, v1, v2, copy=...): ... |
|
|
def masked_object(x, value, copy=..., shrink=...): ... |
|
|
def masked_values(x, value, rtol=..., atol=..., copy=..., shrink=...): ... |
|
|
def masked_invalid(a, copy=...): ... |
|
|
|
|
|
class _MaskedPrintOption: |
|
|
def __init__(self, display): ... |
|
|
def display(self): ... |
|
|
def set_display(self, s): ... |
|
|
def enabled(self): ... |
|
|
def enable(self, shrink=...): ... |
|
|
|
|
|
masked_print_option: _MaskedPrintOption |
|
|
|
|
|
def flatten_structured_array(a): ... |
|
|
|
|
|
class MaskedIterator: |
|
|
ma: Any |
|
|
dataiter: Any |
|
|
maskiter: Any |
|
|
def __init__(self, ma): ... |
|
|
def __iter__(self): ... |
|
|
def __getitem__(self, indx): ... |
|
|
def __setitem__(self, index, value): ... |
|
|
def __next__(self): ... |
|
|
|
|
|
class MaskedArray(ndarray[_ShapeType_co, _DType_co]): |
|
|
__array_priority__: Any |
|
|
def __new__(cls, data=..., mask=..., dtype=..., copy=..., subok=..., ndmin=..., fill_value=..., keep_mask=..., hard_mask=..., shrink=..., order=...): ... |
|
|
def __array_finalize__(self, obj): ... |
|
|
def __array_wrap__(self, obj, context=..., return_scalar=...): ... |
|
|
def view(self, dtype=..., type=..., fill_value=...): ... |
|
|
def __getitem__(self, indx): ... |
|
|
def __setitem__(self, indx, value): ... |
|
|
@property |
|
|
def dtype(self): ... |
|
|
@dtype.setter |
|
|
def dtype(self, dtype): ... |
|
|
@property |
|
|
def shape(self): ... |
|
|
@shape.setter |
|
|
def shape(self, shape): ... |
|
|
def __setmask__(self, mask, copy=...): ... |
|
|
@property |
|
|
def mask(self): ... |
|
|
@mask.setter |
|
|
def mask(self, value): ... |
|
|
@property |
|
|
def recordmask(self): ... |
|
|
@recordmask.setter |
|
|
def recordmask(self, mask): ... |
|
|
def harden_mask(self): ... |
|
|
def soften_mask(self): ... |
|
|
@property |
|
|
def hardmask(self): ... |
|
|
def unshare_mask(self): ... |
|
|
@property |
|
|
def sharedmask(self): ... |
|
|
def shrink_mask(self): ... |
|
|
@property |
|
|
def baseclass(self): ... |
|
|
data: Any |
|
|
@property |
|
|
def flat(self): ... |
|
|
@flat.setter |
|
|
def flat(self, value): ... |
|
|
@property |
|
|
def fill_value(self): ... |
|
|
@fill_value.setter |
|
|
def fill_value(self, value=...): ... |
|
|
get_fill_value: Any |
|
|
set_fill_value: Any |
|
|
def filled(self, fill_value=...): ... |
|
|
def compressed(self): ... |
|
|
def compress(self, condition, axis=..., out=...): ... |
|
|
def __eq__(self, other): ... |
|
|
def __ne__(self, other): ... |
|
|
def __ge__(self, other): ... |
|
|
def __gt__(self, other): ... |
|
|
def __le__(self, other): ... |
|
|
def __lt__(self, other): ... |
|
|
def __add__(self, other): ... |
|
|
def __radd__(self, other): ... |
|
|
def __sub__(self, other): ... |
|
|
def __rsub__(self, other): ... |
|
|
def __mul__(self, other): ... |
|
|
def __rmul__(self, other): ... |
|
|
def __div__(self, other): ... |
|
|
def __truediv__(self, other): ... |
|
|
def __rtruediv__(self, other): ... |
|
|
def __floordiv__(self, other): ... |
|
|
def __rfloordiv__(self, other): ... |
|
|
def __pow__(self, other): ... |
|
|
def __rpow__(self, other): ... |
|
|
def __iadd__(self, other): ... |
|
|
def __isub__(self, other): ... |
|
|
def __imul__(self, other): ... |
|
|
def __idiv__(self, other): ... |
|
|
def __ifloordiv__(self, other): ... |
|
|
def __itruediv__(self, other): ... |
|
|
def __ipow__(self, other): ... |
|
|
def __float__(self): ... |
|
|
def __int__(self): ... |
|
|
@property |
|
|
def imag(self): ... |
|
|
get_imag: Any |
|
|
@property |
|
|
def real(self): ... |
|
|
get_real: Any |
|
|
def count(self, axis=..., keepdims=...): ... |
|
|
def ravel(self, order=...): ... |
|
|
def reshape(self, *s, **kwargs): ... |
|
|
def resize(self, newshape, refcheck=..., order=...): ... |
|
|
def put(self, indices, values, mode=...): ... |
|
|
def ids(self): ... |
|
|
def iscontiguous(self): ... |
|
|
def all(self, axis=..., out=..., keepdims=...): ... |
|
|
def any(self, axis=..., out=..., keepdims=...): ... |
|
|
def nonzero(self): ... |
|
|
def trace(self, offset=..., axis1=..., axis2=..., dtype=..., out=...): ... |
|
|
def dot(self, b, out=..., strict=...): ... |
|
|
def sum(self, axis=..., dtype=..., out=..., keepdims=...): ... |
|
|
def cumsum(self, axis=..., dtype=..., out=...): ... |
|
|
def prod(self, axis=..., dtype=..., out=..., keepdims=...): ... |
|
|
product: Any |
|
|
def cumprod(self, axis=..., dtype=..., out=...): ... |
|
|
def mean(self, axis=..., dtype=..., out=..., keepdims=...): ... |
|
|
def anom(self, axis=..., dtype=...): ... |
|
|
def var(self, axis=..., dtype=..., out=..., ddof=..., keepdims=...): ... |
|
|
def std(self, axis=..., dtype=..., out=..., ddof=..., keepdims=...): ... |
|
|
def round(self, decimals=..., out=...): ... |
|
|
def argsort(self, axis=..., kind=..., order=..., endwith=..., fill_value=..., *, stable=...): ... |
|
|
def argmin(self, axis=..., fill_value=..., out=..., *, keepdims=...): ... |
|
|
def argmax(self, axis=..., fill_value=..., out=..., *, keepdims=...): ... |
|
|
def sort(self, axis=..., kind=..., order=..., endwith=..., fill_value=..., *, stable=...): ... |
|
|
def min(self, axis=..., out=..., fill_value=..., keepdims=...): ... |
|
|
|
|
|
|
|
|
def max(self, axis=..., out=..., fill_value=..., keepdims=...): ... |
|
|
def ptp(self, axis=..., out=..., fill_value=..., keepdims=...): ... |
|
|
def partition(self, *args, **kwargs): ... |
|
|
def argpartition(self, *args, **kwargs): ... |
|
|
def take(self, indices, axis=..., out=..., mode=...): ... |
|
|
|
|
|
copy: Any |
|
|
diagonal: Any |
|
|
flatten: Any |
|
|
repeat: Any |
|
|
squeeze: Any |
|
|
swapaxes: Any |
|
|
T: Any |
|
|
transpose: Any |
|
|
|
|
|
@property |
|
|
def mT(self): ... |
|
|
|
|
|
|
|
|
def toflex(self) -> Incomplete: ... |
|
|
def torecords(self) -> Incomplete: ... |
|
|
def tolist(self, fill_value: Incomplete | None = None) -> Incomplete: ... |
|
|
@deprecated("tostring() is deprecated. Use tobytes() instead.") |
|
|
def tostring(self, /, fill_value: Incomplete | None = None, order: _OrderKACF = "C") -> bytes: ... |
|
|
def tobytes(self, /, fill_value: Incomplete | None = None, order: _OrderKACF = "C") -> bytes: ... |
|
|
def tofile(self, /, fid: Incomplete, sep: str = "", format: str = "%s") -> Incomplete: ... |
|
|
|
|
|
|
|
|
def __reduce__(self): ... |
|
|
def __deepcopy__(self, memo=...): ... |
|
|
|
|
|
class mvoid(MaskedArray[_ShapeType_co, _DType_co]): |
|
|
def __new__( |
|
|
self, |
|
|
data, |
|
|
mask=..., |
|
|
dtype=..., |
|
|
fill_value=..., |
|
|
hardmask=..., |
|
|
copy=..., |
|
|
subok=..., |
|
|
): ... |
|
|
def __getitem__(self, indx): ... |
|
|
def __setitem__(self, indx, value): ... |
|
|
def __iter__(self): ... |
|
|
def __len__(self): ... |
|
|
def filled(self, fill_value=...): ... |
|
|
def tolist(self): ... |
|
|
|
|
|
def isMaskedArray(x): ... |
|
|
isarray = isMaskedArray |
|
|
isMA = isMaskedArray |
|
|
|
|
|
|
|
|
class MaskedConstant(MaskedArray[Any, dtype[float64]]): |
|
|
def __new__(cls): ... |
|
|
__class__: Any |
|
|
def __array_finalize__(self, obj): ... |
|
|
def __array_wrap__(self, obj, context=..., return_scalar=...): ... |
|
|
def __format__(self, format_spec): ... |
|
|
def __reduce__(self): ... |
|
|
def __iop__(self, other): ... |
|
|
__iadd__: Any |
|
|
__isub__: Any |
|
|
__imul__: Any |
|
|
__ifloordiv__: Any |
|
|
__itruediv__: Any |
|
|
__ipow__: Any |
|
|
def copy(self, *args, **kwargs): ... |
|
|
def __copy__(self): ... |
|
|
def __deepcopy__(self, memo): ... |
|
|
def __setattr__(self, attr, value): ... |
|
|
|
|
|
masked: MaskedConstant |
|
|
masked_singleton: MaskedConstant |
|
|
masked_array = MaskedArray |
|
|
|
|
|
def array( |
|
|
data, |
|
|
dtype=..., |
|
|
copy=..., |
|
|
order=..., |
|
|
mask=..., |
|
|
fill_value=..., |
|
|
keep_mask=..., |
|
|
hard_mask=..., |
|
|
shrink=..., |
|
|
subok=..., |
|
|
ndmin=..., |
|
|
): ... |
|
|
def is_masked(x): ... |
|
|
|
|
|
class _extrema_operation(_MaskedUFunc): |
|
|
compare: Any |
|
|
fill_value_func: Any |
|
|
def __init__(self, ufunc, compare, fill_value): ... |
|
|
|
|
|
|
|
|
def __call__(self, a, b): ... |
|
|
def reduce(self, target, axis=...): ... |
|
|
def outer(self, a, b): ... |
|
|
|
|
|
def min(obj, axis=..., out=..., fill_value=..., keepdims=...): ... |
|
|
def max(obj, axis=..., out=..., fill_value=..., keepdims=...): ... |
|
|
def ptp(obj, axis=..., out=..., fill_value=..., keepdims=...): ... |
|
|
|
|
|
class _frommethod: |
|
|
__name__: Any |
|
|
__doc__: Any |
|
|
reversed: Any |
|
|
def __init__(self, methodname, reversed=...): ... |
|
|
def getdoc(self): ... |
|
|
def __call__(self, a, *args, **params): ... |
|
|
|
|
|
all: _frommethod |
|
|
anomalies: _frommethod |
|
|
anom: _frommethod |
|
|
any: _frommethod |
|
|
compress: _frommethod |
|
|
cumprod: _frommethod |
|
|
cumsum: _frommethod |
|
|
copy: _frommethod |
|
|
diagonal: _frommethod |
|
|
harden_mask: _frommethod |
|
|
ids: _frommethod |
|
|
mean: _frommethod |
|
|
nonzero: _frommethod |
|
|
prod: _frommethod |
|
|
product: _frommethod |
|
|
ravel: _frommethod |
|
|
repeat: _frommethod |
|
|
soften_mask: _frommethod |
|
|
std: _frommethod |
|
|
sum: _frommethod |
|
|
swapaxes: _frommethod |
|
|
trace: _frommethod |
|
|
var: _frommethod |
|
|
count: _frommethod |
|
|
argmin: _frommethod |
|
|
argmax: _frommethod |
|
|
|
|
|
minimum: _extrema_operation |
|
|
maximum: _extrema_operation |
|
|
|
|
|
def take(a, indices, axis=..., out=..., mode=...): ... |
|
|
def power(a, b, third=...): ... |
|
|
def argsort(a, axis=..., kind=..., order=..., endwith=..., fill_value=..., *, stable=...): ... |
|
|
def sort(a, axis=..., kind=..., order=..., endwith=..., fill_value=..., *, stable=...): ... |
|
|
def compressed(x): ... |
|
|
def concatenate(arrays, axis=...): ... |
|
|
def diag(v, k=...): ... |
|
|
def left_shift(a, n): ... |
|
|
def right_shift(a, n): ... |
|
|
def put(a, indices, values, mode=...): ... |
|
|
def putmask(a, mask, values): ... |
|
|
def transpose(a, axes=...): ... |
|
|
def reshape(a, new_shape, order=...): ... |
|
|
def resize(x, new_shape): ... |
|
|
def ndim(obj): ... |
|
|
def shape(obj): ... |
|
|
def size(obj, axis=...): ... |
|
|
def diff(a, /, n=..., axis=..., prepend=..., append=...): ... |
|
|
def where(condition, x=..., y=...): ... |
|
|
def choose(indices, choices, out=..., mode=...): ... |
|
|
def round_(a, decimals=..., out=...): ... |
|
|
round = round_ |
|
|
|
|
|
def inner(a, b): ... |
|
|
innerproduct = inner |
|
|
|
|
|
def outer(a, b): ... |
|
|
outerproduct = outer |
|
|
|
|
|
def correlate(a, v, mode=..., propagate_mask=...): ... |
|
|
def convolve(a, v, mode=..., propagate_mask=...): ... |
|
|
def allequal(a, b, fill_value=...): ... |
|
|
def allclose(a, b, masked_equal=..., rtol=..., atol=...): ... |
|
|
def asarray(a, dtype=..., order=...): ... |
|
|
def asanyarray(a, dtype=...): ... |
|
|
def fromflex(fxarray): ... |
|
|
|
|
|
class _convert2ma: |
|
|
def __init__(self, /, funcname: str, np_ret: str, np_ma_ret: str, params: dict[str, Any] | None = None) -> None: ... |
|
|
def __call__(self, /, *args: object, **params: object) -> Any: ... |
|
|
def getdoc(self, /, np_ret: str, np_ma_ret: str) -> str | None: ... |
|
|
|
|
|
arange: _convert2ma |
|
|
clip: _convert2ma |
|
|
empty: _convert2ma |
|
|
empty_like: _convert2ma |
|
|
frombuffer: _convert2ma |
|
|
fromfunction: _convert2ma |
|
|
identity: _convert2ma |
|
|
indices: _convert2ma |
|
|
ones: _convert2ma |
|
|
ones_like: _convert2ma |
|
|
squeeze: _convert2ma |
|
|
zeros: _convert2ma |
|
|
zeros_like: _convert2ma |
|
|
|
|
|
def append(a, b, axis=...): ... |
|
|
def dot(a, b, strict=..., out=...): ... |
|
|
def mask_rowcols(a, axis=...): ... |
|
|
|
