diff --git a/numpy-stubs/__init__.pyi b/numpy-stubs/__init__.pyi index 49a085a..3300a16 100644 --- a/numpy-stubs/__init__.pyi +++ b/numpy-stubs/__init__.pyi @@ -35,6 +35,11 @@ if sys.version_info[0] < 3: else: from typing import SupportsBytes +if sys.version_info >= (3, 8): + from typing import Literal, Protocol +else: + from typing_extensions import Literal, Protocol + # TODO: remove when the full numpy namespace is defined def __getattr__(name: str) -> Any: ... @@ -85,10 +90,39 @@ _DtypeLike = Union[ Tuple[_DtypeLikeNested, _DtypeLikeNested], ] +# Can be used as such `Union[Sequence[T], _ArrayLikeSeq]` as ndarray +# is not a proper Sequence +# TODO: Specify the to-be returned array type once ndarray is a Generic +class _ArrayLikeSeq(Protocol): + shape: Tuple[int, ...] + def __array__(self, dtype: _DtypeLike = ...) -> ndarray: ... + _NdArraySubClass = TypeVar("_NdArraySubClass", bound=ndarray) _ArrayLike = TypeVar("_ArrayLike") +_Generic = TypeVar("_Generic", bound=generic) +_Number = TypeVar("_Number", bound=number) + +# In principle the SupportsInt, SupportsFloat, etc. protocols +# would be more suited here but they have one significant disadvatange: +# all these methods are also defined available in ndarray, +# which has no guarantee of being scalar-esque (i.e. a 0D array) +_ScalarNumeric = Union[int, float, complex, bool, bool_, number] + +# Any scalar besides object, as the latter may or may not be a scalar +_ScalarAny = Union[_ScalarNumeric, str, bytes, dt.datetime, flexible, datetime64] + +# TODO: Refine the _ArrayLikeSeq type once ndarray is a Generic +_ArrayLikeInt = TypeVar( + "_ArrayLikeInt", + bound=Union[int, integer, Sequence[Union[int, integer]], _ArrayLikeSeq], +) +_ArrayLikeBool = TypeVar( + "_ArrayLikeBool", + bound=Union[bool, bool_, Sequence[Union[bool, bool_]], _ArrayLikeSeq], +) + class dtype: names: Optional[Tuple[str, ...]] def __init__( @@ -212,6 +246,7 @@ class _ArrayOrScalarCommon( def shape(self) -> _Shape: ... @property def strides(self) -> _Shape: ... + def __array__(self, dtype: _DtypeLike = ...) -> ndarray: ... def __int__(self) -> int: ... def __float__(self) -> float: ... def __complex__(self) -> complex: ... @@ -792,3 +827,501 @@ class AxisError(ValueError, IndexError): def __init__( self, axis: int, ndim: Optional[int] = ..., msg_prefix: Optional[str] = ... ) -> None: ... + +# Functions from np.core.fromnumeric +_Mode = Literal["raise", "wrap", "clip"] +_Order = Literal["C", "F", "A"] +_PartitionKind = Literal["introselect"] +_SortKind = Literal["quicksort", "mergesort", "heapsort", "stable"] +_Side = Literal["left", "right"] + +# The actual functions +@overload +def take( + a: _Generic, + indices: int, + axis: Optional[int] = ..., + out: Optional[ndarray] = ..., + mode: _Mode = ..., +) -> _Generic: ... +@overload +def take( + a: _ScalarAny, + indices: int, + axis: Optional[int] = ..., + out: Optional[ndarray] = ..., + mode: _Mode = ..., +) -> generic: ... +@overload +def take( + a: _ArrayLike, + indices: int, + axis: Optional[int] = ..., + out: Optional[ndarray] = ..., + mode: _Mode = ..., +) -> generic: ... +@overload +def take( + a: _ArrayLike, + indices: _ArrayLikeInt, + axis: Optional[int] = ..., + out: Optional[ndarray] = ..., + mode: _Mode = ..., +) -> Union[generic, ndarray]: ... +def reshape(a: _ArrayLike, newshape: _ShapeLike, order: _Order = ...) -> ndarray: ... +@overload +def choose( + a: _Generic, + choices: Union[Sequence[_ArrayLike], _ArrayLikeSeq], + out: Optional[ndarray] = ..., + mode: _Mode = ..., +) -> _Generic: ... +@overload +def choose( + a: _ScalarAny, + choices: Union[Sequence[_ArrayLike], _ArrayLikeSeq], + out: Optional[ndarray] = ..., + mode: _Mode = ..., +) -> generic: ... +@overload +def choose( + a: _ArrayLike, + choices: Union[Sequence[_ArrayLike], _ArrayLikeSeq], + out: Optional[ndarray] = ..., + mode: _Mode = ..., +) -> ndarray: ... +def repeat( + a: _ArrayLike, repeats: _ArrayLikeInt, axis: Optional[int] = ... +) -> ndarray: ... +def put(a: ndarray, ind: _ArrayLikeInt, v: _ArrayLike, mode: _Mode = ...) -> None: ... +def swapaxes( + a: Union[Sequence[_ArrayLike], _ArrayLikeSeq], axis1: int, axis2: int +) -> ndarray: ... +def transpose( + a: _ArrayLike, axes: Union[None, Sequence[int], _ArrayLikeSeq] = ..., +) -> ndarray: ... +def partition( + a: _ArrayLike, + kth: _ArrayLikeInt, + axis: Optional[int] = ..., + kind: _PartitionKind = ..., + order: Union[None, str, Sequence[str], _ArrayLikeSeq] = ..., +) -> ndarray: ... +def argpartition( + a: _ArrayLike, + kth: _ArrayLikeInt, + axis: Optional[int] = ..., + kind: _PartitionKind = ..., + order: Union[None, str, Sequence[str], _ArrayLikeSeq] = ..., +) -> ndarray: ... +def sort( + a: Union[Sequence[_ArrayLike], _ArrayLikeSeq], + axis: Optional[int] = ..., + kind: Optional[_SortKind] = ..., + order: Union[None, str, Sequence[str], _ArrayLikeSeq] = ..., +) -> ndarray: ... +def argsort( + a: Union[Sequence[_ArrayLike], _ArrayLikeSeq], + axis: Optional[int] = ..., + kind: Optional[_SortKind] = ..., + order: Union[None, str, Sequence[str], _ArrayLikeSeq] = ..., +) -> ndarray: ... +@overload +def argmax( + a: Union[Sequence[_ArrayLike], _ArrayLikeSeq], + axis: None = ..., + out: Optional[ndarray] = ..., +) -> integer: ... +@overload +def argmax( + a: Union[Sequence[_ArrayLike], _ArrayLikeSeq], + axis: int = ..., + out: Optional[ndarray] = ..., +) -> Union[integer, ndarray]: ... +@overload +def argmin( + a: Union[Sequence[_ArrayLike], _ArrayLikeSeq], + axis: None = ..., + out: Optional[ndarray] = ..., +) -> integer: ... +@overload +def argmin( + a: Union[Sequence[_ArrayLike], _ArrayLikeSeq], + axis: int = ..., + out: Optional[ndarray] = ..., +) -> Union[integer, ndarray]: ... +@overload +def searchsorted( + a: Union[Sequence[_ArrayLike], _ArrayLikeSeq], + v: _ScalarAny, + side: _Side = ..., + sorter: Optional[_ArrayLikeInt] = ..., +) -> integer: ... +@overload +def searchsorted( + a: Union[Sequence[_ArrayLike], _ArrayLikeSeq], + v: _ArrayLike, + side: _Side = ..., + sorter: Optional[_ArrayLikeInt] = ..., +) -> ndarray: ... +def resize(a: _ArrayLike, new_shape: _ShapeLike) -> ndarray: ... +def squeeze(a: _ArrayLike, axis: Optional[_ShapeLike] = ...) -> ndarray: ... +def diagonal( + a: Union[ + Sequence[Sequence[_ArrayLike]], _ArrayLikeSeq + ], # TODO: requires a >= 2D array + offset: int = ..., + axis1: int = ..., + axis2: int = ..., +) -> ndarray: ... +def trace( + a: Union[ + Sequence[Sequence[_ArrayLike]], _ArrayLikeSeq + ], # TODO: requires a >= 2D array + offset: int = ..., + axis1: int = ..., + axis2: int = ..., + dtype: _DtypeLike = ..., + out: Optional[ndarray] = ..., +) -> Union[number, ndarray]: ... +def ravel(a: _ArrayLike, order: _Order = ...) -> ndarray: ... +def nonzero(a: _ArrayLike) -> Tuple[ndarray, ...]: ... +def shape(a: _ArrayLike) -> _Shape: ... +def compress( + condition: Union[Sequence[_ArrayLikeBool], _ArrayLikeSeq], + a: _ArrayLike, + axis: Optional[int] = ..., + out: Optional[ndarray] = ..., +) -> ndarray: ... +@overload +def clip( + a: _Number, + a_min: _ScalarNumeric, + a_max: _ScalarNumeric, + out: Optional[ndarray] = ..., + **kwargs: Any, +) -> _Number: ... +@overload +def clip( + a: _ScalarNumeric, + a_min: _ScalarNumeric, + a_max: _ScalarNumeric, + out: Optional[ndarray] = ..., + **kwargs: Any, +) -> number: ... +@overload +def clip( + a: _ArrayLike, + a_min: _ArrayLike, + a_max: _ArrayLike, + out: Optional[ndarray] = ..., + **kwargs: Any, +) -> Union[number, ndarray]: ... +@overload +def sum( + a: _Number, + axis: Optional[_ShapeLike] = ..., + dtype: _DtypeLike = ..., + out: Optional[ndarray] = ..., + keepdims: bool = ..., + initial: _ScalarNumeric = ..., + where: _ArrayLikeBool = ..., +) -> _Number: ... +@overload +def sum( + a: _ScalarNumeric, + axis: Optional[_ShapeLike] = ..., + dtype: _DtypeLike = ..., + out: Optional[ndarray] = ..., + keepdims: bool = ..., + initial: _ScalarNumeric = ..., + where: _ArrayLikeBool = ..., +) -> number: ... +@overload +def sum( + a: _ArrayLike, + axis: None = ..., + dtype: _DtypeLike = ..., + out: Optional[ndarray] = ..., + keepdims: bool = ..., + initial: _ScalarNumeric = ..., + where: _ArrayLikeBool = ..., +) -> number: ... +@overload +def sum( + a: _ArrayLike, + axis: _ShapeLike = ..., + dtype: _DtypeLike = ..., + out: Optional[ndarray] = ..., + keepdims: bool = ..., + initial: _ScalarNumeric = ..., + where: _ArrayLikeBool = ..., +) -> Union[number, ndarray]: ... +@overload +def all( + a: _ScalarNumeric, + axis: Optional[_ShapeLike] = ..., + out: Optional[ndarray] = ..., + keepdims: bool = ..., +) -> bool_: ... +@overload +def all( + a: _ArrayLike, + axis: None = ..., + out: Optional[ndarray] = ..., + keepdims: Literal[False] = ..., +) -> bool_: ... +@overload +def all( + a: _ArrayLike, + axis: Optional[_ShapeLike] = ..., + out: Optional[ndarray] = ..., + keepdims: bool = ..., +) -> Union[bool_, ndarray]: ... +@overload +def any( + a: _ScalarNumeric, + axis: Optional[_ShapeLike] = ..., + out: Optional[ndarray] = ..., + keepdims: bool = ..., +) -> bool_: ... +@overload +def any( + a: _ArrayLike, + axis: None = ..., + out: Optional[ndarray] = ..., + keepdims: Literal[False] = ..., +) -> bool_: ... +@overload +def any( + a: _ArrayLike, + axis: Optional[_ShapeLike] = ..., + out: Optional[ndarray] = ..., + keepdims: bool = ..., +) -> Union[bool_, ndarray]: ... +def cumsum( + a: _ArrayLike, + axis: Optional[int] = ..., + dtype: _DtypeLike = ..., + out: Optional[ndarray] = ..., +) -> ndarray: ... +@overload +def ptp( + a: _Number, + axis: Optional[_ShapeLike] = ..., + out: Optional[ndarray] = ..., + keepdims: bool = ..., +) -> _Number: ... +@overload +def ptp( + a: _ScalarNumeric, + axis: Optional[_ShapeLike] = ..., + out: Optional[ndarray] = ..., + keepdims: bool = ..., +) -> number: ... +@overload +def ptp( + a: _ArrayLike, + axis: Optional[_ShapeLike] = ..., + out: Optional[ndarray] = ..., + keepdims: bool = ..., +) -> Union[number, ndarray]: ... +@overload +def amax( + a: _ScalarNumeric, + axis: Optional[int] = ..., + out: Optional[ndarray] = ..., + keepdims: bool = ..., + initial: _ScalarNumeric = ..., + where: _ArrayLikeBool = ..., +) -> integer: ... +@overload +def amax( + a: _ArrayLike, + axis: None = ..., + out: Optional[ndarray] = ..., + keepdims: Literal[False] = ..., + initial: _ScalarNumeric = ..., + where: _ArrayLikeBool = ..., +) -> integer: ... +@overload +def amax( + a: _ArrayLike, + axis: Optional[_ShapeLike] = ..., + out: Optional[ndarray] = ..., + keepdims: bool = ..., + initial: _ScalarNumeric = ..., + where: _ArrayLikeBool = ..., +) -> Union[integer, ndarray]: ... +@overload +def amin( + a: _ScalarNumeric, + axis: Optional[_ShapeLike] = ..., + out: Optional[ndarray] = ..., + keepdims: bool = ..., + initial: _ScalarNumeric = ..., + where: _ArrayLikeBool = ..., +) -> integer: ... +@overload +def amin( + a: _ArrayLike, + axis: None = ..., + out: Optional[ndarray] = ..., + keepdims: Literal[False] = ..., + initial: _ScalarNumeric = ..., + where: _ArrayLikeBool = ..., +) -> integer: ... +@overload +def amin( + a: _ArrayLike, + axis: Optional[_ShapeLike] = ..., + out: Optional[ndarray] = ..., + keepdims: bool = ..., + initial: _ScalarNumeric = ..., + where: _ArrayLikeBool = ..., +) -> Union[integer, ndarray]: ... +def alen(a: _ArrayLike) -> int: ... +@overload +def prod( + a: _Number, + axis: Optional[_ShapeLike] = ..., + dtype: _DtypeLike = ..., + out: Optional[ndarray] = ..., + keepdims: bool = ..., + initial: _ScalarNumeric = ..., + where: _ArrayLikeBool = ..., +) -> _Number: ... +@overload +def prod( + a: _ScalarNumeric, + axis: Optional[_ShapeLike] = ..., + dtype: _DtypeLike = ..., + out: Optional[ndarray] = ..., + keepdims: bool = ..., + initial: _ScalarNumeric = ..., + where: _ArrayLikeBool = ..., +) -> number: ... +@overload +def prod( + a: _ArrayLike, + axis: None = ..., + dtype: _DtypeLike = ..., + out: Optional[ndarray] = ..., + keepdims: Literal[False] = ..., + initial: _ScalarNumeric = ..., + where: _ArrayLikeBool = ..., +) -> number: ... +@overload +def prod( + a: _ArrayLike, + axis: Optional[_ShapeLike] = ..., + dtype: _DtypeLike = ..., + out: Optional[ndarray] = ..., + keepdims: bool = ..., + initial: _ScalarNumeric = ..., + where: _ArrayLikeBool = ..., +) -> Union[number, ndarray]: ... +def cumprod( + a: _ArrayLike, + axis: Optional[int] = ..., + dtype: _DtypeLike = ..., + out: Optional[ndarray] = ..., +) -> ndarray: ... +def ndim(a: _ArrayLike) -> int: ... +def size(a: _ArrayLike, axis: Optional[int] = ...) -> int: ... +@overload +def around( + a: _Number, decimals: int = ..., out: Optional[ndarray] = ... +) -> _Number: ... +@overload +def around( + a: _ScalarNumeric, decimals: int = ..., out: Optional[ndarray] = ... +) -> number: ... +@overload +def around( + a: _ArrayLike, decimals: int = ..., out: Optional[ndarray] = ... +) -> ndarray: ... +@overload +def mean( + a: _ScalarNumeric, + axis: None = ..., + dtype: _DtypeLike = ..., + out: Optional[ndarray] = ..., + keepdims: Literal[False] = ..., +) -> number: ... # TODO: The type of the output is determined by *dtype* +@overload +def mean( + a: _ArrayLike, + axis: None = ..., + dtype: _DtypeLike = ..., + out: Optional[ndarray] = ..., + keepdims: Literal[False] = ..., +) -> number: ... +@overload +def mean( + a: _ArrayLike, + axis: Optional[_ShapeLike] = ..., + dtype: _DtypeLike = ..., + out: Optional[ndarray] = ..., + keepdims: bool = ..., +) -> Union[number, ndarray]: ... +@overload +def std( + a: _ScalarNumeric, + axis: None = ..., + dtype: _DtypeLike = ..., + out: Optional[ndarray] = ..., + ddof: int = ..., + keepdims: Literal[False] = ..., +) -> number: ... # TODO: The type of the output is determined by *dtype* +@overload +def std( + a: _ArrayLike, + axis: None = ..., + dtype: _DtypeLike = ..., + out: Optional[ndarray] = ..., + ddof: int = ..., + keepdims: Literal[False] = ..., +) -> number: ... +@overload +def std( + a: _ArrayLike, + axis: Optional[_ShapeLike] = ..., + dtype: _DtypeLike = ..., + out: Optional[ndarray] = ..., + ddof: int = ..., + keepdims: bool = ..., +) -> Union[number, ndarray]: ... +@overload +def var( + a: _ScalarNumeric, + axis: None = ..., + dtype: _DtypeLike = ..., + out: Optional[ndarray] = ..., + ddof: int = ..., + keepdims: bool = ..., +) -> number: ... +@overload +def var( + a: _ArrayLike, + axis: None = ..., + dtype: _DtypeLike = ..., + out: Optional[ndarray] = ..., + ddof: int = ..., + keepdims: Literal[False] = ..., +) -> number: ... # TODO: The type of the output is determined by *dtype* +@overload +def var( + a: _ArrayLike, + axis: Optional[_ShapeLike] = ..., + dtype: _DtypeLike = ..., + out: Optional[ndarray] = ..., + ddof: int = ..., + keepdims: bool = ..., +) -> Union[number, ndarray]: ... + +round_ = around +product = prod +cumproduct = cumprod +sometrue = any +alltrue = all diff --git a/tests/reveal/fromnumeric.py b/tests/reveal/fromnumeric.py new file mode 100644 index 0000000..0c00888 --- /dev/null +++ b/tests/reveal/fromnumeric.py @@ -0,0 +1,251 @@ +import numpy as np + +A = np.array([True], dtype=bool) +A_ = np.array([[True]], dtype=bool) +B = np.array([1.0], dtype='float32') +B_ = np.array([[1.0]], dtype='float32') + +A.setflags(write=False) +A_.setflags(write=False) +B.setflags(write=False) +B_.setflags(write=False) + +a = np.bool_(True) +b = np.float32(1.0) +c = 1.0 + +reveal_type(np.take(a, 0)) # E: numpy.bool_ +reveal_type(np.take(b, 0)) # E: numpy.float32 +reveal_type(np.take(c, 0)) # E: numpy.generic +reveal_type(np.take(A, 0)) # E: numpy.generic +reveal_type(np.take(B, 0)) # E: numpy.generic +reveal_type(np.take(A, [0])) # E: Union[numpy.generic, numpy.ndarray] +reveal_type(np.take(B, [0])) # E: Union[numpy.generic, numpy.ndarray] + +reveal_type(np.reshape(a, 1)) # E: numpy.ndarray +reveal_type(np.reshape(b, 1)) # E: numpy.ndarray +reveal_type(np.reshape(c, 1)) # E: numpy.ndarray +reveal_type(np.reshape(A, 1)) # E: numpy.ndarray +reveal_type(np.reshape(B, 1)) # E: numpy.ndarray + +reveal_type(np.choose(a, [True])) # E: numpy.bool_ +reveal_type(np.choose(b, [1.0])) # E: numpy.float32 +reveal_type(np.choose(c, [1.0])) # E: numpy.generic +reveal_type(np.choose(A, [True])) # E: numpy.ndarray +reveal_type(np.choose(B, [1.0])) # E: numpy.ndarray + +reveal_type(np.repeat(a, 1)) # E: numpy.ndarray +reveal_type(np.repeat(b, 1)) # E: numpy.ndarray +reveal_type(np.repeat(c, 1)) # E: numpy.ndarray +reveal_type(np.repeat(A, 1)) # E: numpy.ndarray +reveal_type(np.repeat(B, 1)) # E: numpy.ndarray + +# TODO: Add tests for np.put() + +reveal_type(np.swapaxes(A, 0, 0)) # E: numpy.ndarray +reveal_type(np.swapaxes(B, 0, 0)) # E: numpy.ndarray + +reveal_type(np.transpose(a)) # E: numpy.ndarray +reveal_type(np.transpose(b)) # E: numpy.ndarray +reveal_type(np.transpose(c)) # E: numpy.ndarray +reveal_type(np.transpose(A)) # E: numpy.ndarray +reveal_type(np.transpose(B)) # E: numpy.ndarray + +reveal_type(np.partition(a, 0)) # E: numpy.ndarray +reveal_type(np.partition(b, 0)) # E: numpy.ndarray +reveal_type(np.partition(c, 0)) # E: numpy.ndarray +reveal_type(np.partition(A, 0)) # E: numpy.ndarray +reveal_type(np.partition(B, 0)) # E: numpy.ndarray + +reveal_type(np.argpartition(a, 0)) # E: numpy.ndarray +reveal_type(np.argpartition(b, 0)) # E: numpy.ndarray +reveal_type(np.argpartition(c, 0)) # E: numpy.ndarray +reveal_type(np.argpartition(A, 0)) # E: numpy.ndarray +reveal_type(np.argpartition(B, 0)) # E: numpy.ndarray + +reveal_type(np.sort(A, 0)) # E: numpy.ndarray +reveal_type(np.sort(B, 0)) # E: numpy.ndarray + +reveal_type(np.argsort(A, 0)) # E: numpy.ndarray +reveal_type(np.argsort(B, 0)) # E: numpy.ndarray + +reveal_type(np.argmin(A)) # E: numpy.integer +reveal_type(np.argmin(B)) # E: numpy.integer +reveal_type(np.argmin(A, axis=0)) # E: Union[numpy.integer, numpy.ndarray] +reveal_type(np.argmin(B, axis=0)) # E: Union[numpy.integer, numpy.ndarray] + +reveal_type(np.argmax(A)) # E: numpy.integer +reveal_type(np.argmax(B)) # E: numpy.integer +reveal_type(np.argmax(A, axis=0)) # E: Union[numpy.integer, numpy.ndarray] +reveal_type(np.argmax(B, axis=0)) # E: Union[numpy.integer, numpy.ndarray] + +reveal_type(np.searchsorted(A, 0)) # E: numpy.integer +reveal_type(np.searchsorted(B, 0)) # E: numpy.integer +reveal_type(np.searchsorted(A, [0])) # E: numpy.ndarray +reveal_type(np.searchsorted(B, [0])) # E: numpy.ndarray + +reveal_type(np.resize(a, (1,))) # E: numpy.ndarray +reveal_type(np.resize(b, (1,))) # E: numpy.ndarray +reveal_type(np.resize(c, (1,))) # E: numpy.ndarray +reveal_type(np.resize(A, (1,))) # E: numpy.ndarray +reveal_type(np.resize(B, (1,))) # E: numpy.ndarray + +reveal_type(np.squeeze(a)) # E: numpy.ndarray +reveal_type(np.squeeze(b)) # E: numpy.ndarray +reveal_type(np.squeeze(c)) # E: numpy.ndarray +reveal_type(np.squeeze(A)) # E: numpy.ndarray +reveal_type(np.squeeze(B)) # E: numpy.ndarray + +reveal_type(np.diagonal(A_)) # E: numpy.ndarray +reveal_type(np.diagonal(B_)) # E: numpy.ndarray + +reveal_type(np.trace(A_)) # E: Union[numpy.number, numpy.ndarray] +reveal_type(np.trace(B_)) # E: Union[numpy.number, numpy.ndarray] + +reveal_type(np.ravel(a)) # E: numpy.ndarray +reveal_type(np.ravel(b)) # E: numpy.ndarray +reveal_type(np.ravel(c)) # E: numpy.ndarray +reveal_type(np.ravel(A)) # E: numpy.ndarray +reveal_type(np.ravel(B)) # E: numpy.ndarray + +reveal_type(np.nonzero(a)) # E: builtins.tuple[numpy.ndarray] +reveal_type(np.nonzero(b)) # E: builtins.tuple[numpy.ndarray] +reveal_type(np.nonzero(c)) # E: builtins.tuple[numpy.ndarray] +reveal_type(np.nonzero(A)) # E: builtins.tuple[numpy.ndarray] +reveal_type(np.nonzero(B)) # E: builtins.tuple[numpy.ndarray] + +reveal_type(np.shape(a)) # E: builtins.tuple[builtins.int] +reveal_type(np.shape(b)) # E: builtins.tuple[builtins.int] +reveal_type(np.shape(c)) # E: builtins.tuple[builtins.int] +reveal_type(np.shape(A)) # E: builtins.tuple[builtins.int] +reveal_type(np.shape(B)) # E: builtins.tuple[builtins.int] + +reveal_type(np.compress([True], a)) # E: numpy.ndarray +reveal_type(np.compress([True], b)) # E: numpy.ndarray +reveal_type(np.compress([True], c)) # E: numpy.ndarray +reveal_type(np.compress([True], A)) # E: numpy.ndarray +reveal_type(np.compress([True], B)) # E: numpy.ndarray + +reveal_type(np.clip(a, 0, 2)) # E: numpy.number +reveal_type(np.clip(b, 0, 2)) # E: numpy.float32 +reveal_type(np.clip(c, 0, 2)) # E: numpy.number +reveal_type(np.clip(A, 0, 2)) # E: numpy.ndarray +reveal_type(np.clip(B, 0, 2)) # E: numpy.ndarray + +reveal_type(np.sum(a)) # E: numpy.number +reveal_type(np.sum(b)) # E: numpy.float32 +reveal_type(np.sum(c)) # E: numpy.number +reveal_type(np.sum(A)) # E: numpy.number +reveal_type(np.sum(B)) # E: numpy.number +reveal_type(np.sum(A, axis=0)) # E: Union[numpy.number, numpy.ndarray] +reveal_type(np.sum(B, axis=0)) # E: Union[numpy.number, numpy.ndarray] + +reveal_type(np.all(A)) # E: numpy.bool_ +reveal_type(np.all(B)) # E: numpy.bool_ +reveal_type(np.all(a)) # E: numpy.bool_ +reveal_type(np.all(b)) # E: numpy.bool_ +reveal_type(np.all(c)) # E: numpy.bool_ +reveal_type(np.all(A, keepdims=True)) # E: Union[numpy.bool_, numpy.ndarray] +reveal_type(np.all(A, keepdims=False)) # E: numpy.bool_ +reveal_type(np.all(A, axis=0)) # E: Union[numpy.bool_, numpy.ndarray] + +reveal_type(np.any(A)) # E: numpy.bool_ +reveal_type(np.any(B)) # E: numpy.bool_ +reveal_type(np.any(a)) # E: numpy.bool_ +reveal_type(np.any(b)) # E: numpy.bool_ +reveal_type(np.any(c)) # E: numpy.bool_ +reveal_type(np.any(A, keepdims=True)) # E: Union[numpy.bool_, numpy.ndarray] +reveal_type(np.any(A, keepdims=False)) # E: numpy.bool_ +reveal_type(np.any(A, axis=0)) # E: Union[numpy.bool_, numpy.ndarray] + +reveal_type(np.cumsum(a)) # E: numpy.ndarray +reveal_type(np.cumsum(b)) # E: numpy.ndarray +reveal_type(np.cumsum(c)) # E: numpy.ndarray +reveal_type(np.cumsum(A)) # E: numpy.ndarray +reveal_type(np.cumsum(B)) # E: numpy.ndarray + +reveal_type(np.ptp(a)) # E: numpy.number +reveal_type(np.ptp(b)) # E: numpy.float32 +reveal_type(np.ptp(c)) # E: numpy.number +reveal_type(np.ptp(A)) # E: numpy.number +reveal_type(np.ptp(B)) # E: numpy.number +reveal_type(np.ptp(A, axis=0)) # E: Union[numpy.number, numpy.ndarray] +reveal_type(np.ptp(B, axis=0)) # E: Union[numpy.number, numpy.ndarray] + +reveal_type(np.amax(a)) # E: numpy.integer +reveal_type(np.amax(b)) # E: numpy.integer +reveal_type(np.amax(c)) # E: numpy.integer +reveal_type(np.amax(A)) # E: numpy.integer +reveal_type(np.amax(B)) # E: numpy.integer +reveal_type(np.amax(A, axis=0)) # E: Union[numpy.integer, numpy.ndarray] +reveal_type(np.amax(B, axis=0)) # E: Union[numpy.integer, numpy.ndarray] + +reveal_type(np.amin(a)) # E: numpy.integer +reveal_type(np.amin(b)) # E: numpy.integer +reveal_type(np.amin(c)) # E: numpy.integer +reveal_type(np.amin(A)) # E: numpy.integer +reveal_type(np.amin(B)) # E: numpy.integer +reveal_type(np.amin(A, axis=0)) # E: Union[numpy.integer, numpy.ndarray] +reveal_type(np.amin(B, axis=0)) # E: Union[numpy.integer, numpy.ndarray] + +reveal_type(np.alen(a)) # E: builtins.int +reveal_type(np.alen(b)) # E: builtins.int +reveal_type(np.alen(c)) # E: builtins.int +reveal_type(np.alen(A)) # E: builtins.int +reveal_type(np.alen(B)) # E: builtins.int + +reveal_type(np.prod(a)) # E: numpy.number +reveal_type(np.prod(b)) # E: numpy.float32 +reveal_type(np.prod(c)) # E: numpy.number +reveal_type(np.prod(A)) # E: numpy.number +reveal_type(np.prod(B)) # E: numpy.number +reveal_type(np.prod(A, axis=0)) # E: Union[numpy.number, numpy.ndarray] +reveal_type(np.prod(B, axis=0)) # E: Union[numpy.number, numpy.ndarray] + +reveal_type(np.cumprod(a)) # E: numpy.ndarray +reveal_type(np.cumprod(b)) # E: numpy.ndarray +reveal_type(np.cumprod(c)) # E: numpy.ndarray +reveal_type(np.cumprod(A)) # E: numpy.ndarray +reveal_type(np.cumprod(B)) # E: numpy.ndarray + +reveal_type(np.ndim(a)) # E: builtins.int +reveal_type(np.ndim(b)) # E: builtins.int +reveal_type(np.ndim(c)) # E: builtins.int +reveal_type(np.ndim(A)) # E: builtins.int +reveal_type(np.ndim(B)) # E: builtins.int + +reveal_type(np.size(a)) # E: builtins.int +reveal_type(np.size(b)) # E: builtins.int +reveal_type(np.size(c)) # E: builtins.int +reveal_type(np.size(A)) # E: builtins.int +reveal_type(np.size(B)) # E: builtins.int + +reveal_type(np.around(a)) # E: numpy.number +reveal_type(np.around(b)) # E: numpy.float32 +reveal_type(np.around(c)) # E: numpy.number +reveal_type(np.around(A)) # E: numpy.ndarray +reveal_type(np.around(B)) # E: numpy.ndarray + +reveal_type(np.mean(a)) # E: numpy.number +reveal_type(np.mean(b)) # E: numpy.number +reveal_type(np.mean(c)) # E: numpy.number +reveal_type(np.mean(A)) # E: numpy.number +reveal_type(np.mean(B)) # E: numpy.number +reveal_type(np.mean(A, axis=0)) # E: Union[numpy.number, numpy.ndarray] +reveal_type(np.mean(B, axis=0)) # E: Union[numpy.number, numpy.ndarray] + +reveal_type(np.std(a)) # E: numpy.number +reveal_type(np.std(b)) # E: numpy.number +reveal_type(np.std(c)) # E: numpy.number +reveal_type(np.std(A)) # E: numpy.number +reveal_type(np.std(B)) # E: numpy.number +reveal_type(np.std(A, axis=0)) # E: Union[numpy.number, numpy.ndarray] +reveal_type(np.std(B, axis=0)) # E: Union[numpy.number, numpy.ndarray] + +reveal_type(np.var(a)) # E: numpy.number +reveal_type(np.var(b)) # E: numpy.number +reveal_type(np.var(c)) # E: numpy.number +reveal_type(np.var(A)) # E: numpy.number +reveal_type(np.var(B)) # E: numpy.number +reveal_type(np.var(A, axis=0)) # E: Union[numpy.number, numpy.ndarray] +reveal_type(np.var(B, axis=0)) # E: Union[numpy.number, numpy.ndarray]