diff --git a/numpy/__init__.pyi b/numpy/__init__.pyi index c1ea3af3cad2..a72c7172c6dc 100644 --- a/numpy/__init__.pyi +++ b/numpy/__init__.pyi @@ -2484,6 +2484,376 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeT_co, _DTypeT_co]): where: _ArrayLikeBool_co | _NoValueType = ..., ) -> ndarray[_ShapeT_co]: ... + # keep in sync with `ndarray.mean` above + @override # type: ignore[override] + @overload # +integer | ~object_ + def std( + self: NDArray[integer | bool_ | object_], + axis: None = None, + dtype: None = None, + out: None = None, + ddof: float = 0, + *, + keepdims: L[False] | _NoValueType = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> float64: ... + @overload # +integer, axis: + def std( + self: NDArray[integer | bool_], + axis: int | tuple[int, ...], + dtype: None = None, + out: None = None, + ddof: float = 0, + *, + keepdims: L[False] | _NoValueType = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> NDArray[float64]: ... + @overload # +integer, keepdims=True + def std( + self: NDArray[integer | bool_], + axis: int | tuple[int, ...] | None = None, + dtype: None = None, + out: None = None, + ddof: float = 0, + *, + keepdims: L[True], + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> ndarray[_ShapeT_co, dtype[float64]]: ... + @overload # ~inexact | timedelta64 + def std[ScalarT: inexact | timedelta64]( + self: NDArray[ScalarT], + axis: None = None, + dtype: None = None, + out: None = None, + ddof: float = 0, + *, + keepdims: L[False] | _NoValueType = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> ScalarT: ... + @overload # ~inexact | timedelta64, axis: + def std[ScalarT: inexact | timedelta64 | object_]( + self: NDArray[ScalarT], + axis: int | tuple[int, ...], + dtype: None = None, + out: None = None, + ddof: float = 0, + *, + keepdims: L[False] | _NoValueType = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> NDArray[ScalarT]: ... + @overload # ~inexact | timedelta64 | object_, keepdims=True + def std[ArrayT: NDArray[inexact | timedelta64 | object_]]( + self: ArrayT, + axis: int | tuple[int, ...] | None = None, + dtype: None = None, + out: None = None, + ddof: float = 0, + *, + keepdims: L[True], + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> ArrayT: ... + @overload # dtype: ScalarT + def std[ScalarT: generic]( + self: NDArray[number | bool_ | timedelta64 | object_], + axis: None = None, + *, + dtype: _DTypeLike[ScalarT], + out: None = None, + ddof: float = 0, + keepdims: L[False] | _NoValueType = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> ScalarT: ... + @overload # dtype: ScalarT (keyword), keepdims=True + def std[ScalarT: generic]( + self: NDArray[number | bool_ | timedelta64 | object_], + axis: int | tuple[int, ...] | None = None, + *, + dtype: _DTypeLike[ScalarT], + out: None = None, + ddof: float = 0, + keepdims: L[True], + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> ndarray[_ShapeT_co, dtype[ScalarT]]: ... + @overload # dtype: ScalarT (positional), keepdims=True + def std[ScalarT: generic]( + self: NDArray[number | bool_ | timedelta64 | object_], + axis: int | tuple[int, ...] | None, + dtype: _DTypeLike[ScalarT], + out: None = None, + ddof: float = 0, + *, + keepdims: L[True], + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> ndarray[_ShapeT_co, dtype[ScalarT]]: ... + @overload # axis: , dtype: ScalarT + def std[ScalarT: generic]( + self: NDArray[number | bool_ | timedelta64 | object_], + axis: int | tuple[int, ...], + dtype: _DTypeLike[ScalarT], + out: None = None, + ddof: float = 0, + *, + keepdims: L[False] | _NoValueType = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> NDArray[ScalarT]: ... + @overload # out: ArrayT + def std[ArrayT: ndarray]( + self: NDArray[number | bool_ | timedelta64 | object_], + axis: int | tuple[int, ...] | None = None, + dtype: DTypeLike | None = None, + *, + out: ArrayT, + ddof: float = 0, + keepdims: py_bool | _NoValueType = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> ArrayT: ... + @overload # fallback + def std( + self: NDArray[number | bool_ | timedelta64 | object_], + axis: None = None, + dtype: DTypeLike | None = None, + out: None = None, + ddof: float = 0, + *, + keepdims: L[False] | _NoValueType = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> Any: ... + @overload # fallback, axis: + def std( + self: NDArray[number | bool_ | timedelta64 | object_], + axis: int | tuple[int, ...], + dtype: DTypeLike | None = None, + out: None = None, + ddof: float = 0, + *, + keepdims: L[False] | _NoValueType = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> ndarray: ... + @overload # fallback, keepdims=True + def std( # pyright: ignore[reportIncompatibleMethodOverride] + self: NDArray[number | bool_ | timedelta64 | object_], + axis: int | tuple[int, ...] | None = None, + dtype: DTypeLike | None = None, + out: None = None, + ddof: float = 0, + *, + keepdims: L[True], + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> ndarray[_ShapeT_co]: ... + + # keep in sync with `ndarray.std` above + @override # type: ignore[override] + @overload # +integer | ~object_ + def var( + self: NDArray[integer | bool_ | object_], + axis: None = None, + dtype: None = None, + out: None = None, + ddof: float = 0, + *, + keepdims: L[False] | _NoValueType = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> float64: ... + @overload # +integer, axis: + def var( + self: NDArray[integer | bool_], + axis: int | tuple[int, ...], + dtype: None = None, + out: None = None, + ddof: float = 0, + *, + keepdims: L[False] | _NoValueType = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> NDArray[float64]: ... + @overload # +integer, keepdims=True + def var( + self: NDArray[integer | bool_], + axis: int | tuple[int, ...] | None = None, + dtype: None = None, + out: None = None, + ddof: float = 0, + *, + keepdims: L[True], + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> ndarray[_ShapeT_co, dtype[float64]]: ... + @overload # ~inexact | timedelta64 + def var[ScalarT: inexact | timedelta64]( + self: NDArray[ScalarT], + axis: None = None, + dtype: None = None, + out: None = None, + ddof: float = 0, + *, + keepdims: L[False] | _NoValueType = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> ScalarT: ... + @overload # ~inexact | timedelta64, axis: + def var[ScalarT: inexact | timedelta64 | object_]( + self: NDArray[ScalarT], + axis: int | tuple[int, ...], + dtype: None = None, + out: None = None, + ddof: float = 0, + *, + keepdims: L[False] | _NoValueType = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> NDArray[ScalarT]: ... + @overload # ~inexact | timedelta64 | object_, keepdims=True + def var[ArrayT: NDArray[inexact | timedelta64 | object_]]( + self: ArrayT, + axis: int | tuple[int, ...] | None = None, + dtype: None = None, + out: None = None, + ddof: float = 0, + *, + keepdims: L[True], + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> ArrayT: ... + @overload # dtype: ScalarT + def var[ScalarT: generic]( + self: NDArray[number | bool_ | timedelta64 | object_], + axis: None = None, + *, + dtype: _DTypeLike[ScalarT], + out: None = None, + ddof: float = 0, + keepdims: L[False] | _NoValueType = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> ScalarT: ... + @overload # dtype: ScalarT (keyword), keepdims=True + def var[ScalarT: generic]( + self: NDArray[number | bool_ | timedelta64 | object_], + axis: int | tuple[int, ...] | None = None, + *, + dtype: _DTypeLike[ScalarT], + out: None = None, + ddof: float = 0, + keepdims: L[True], + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> ndarray[_ShapeT_co, dtype[ScalarT]]: ... + @overload # dtype: ScalarT (positional), keepdims=True + def var[ScalarT: generic]( + self: NDArray[number | bool_ | timedelta64 | object_], + axis: int | tuple[int, ...] | None, + dtype: _DTypeLike[ScalarT], + out: None = None, + ddof: float = 0, + *, + keepdims: L[True], + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> ndarray[_ShapeT_co, dtype[ScalarT]]: ... + @overload # axis: , dtype: ScalarT + def var[ScalarT: generic]( + self: NDArray[number | bool_ | timedelta64 | object_], + axis: int | tuple[int, ...], + dtype: _DTypeLike[ScalarT], + out: None = None, + ddof: float = 0, + *, + keepdims: L[False] | _NoValueType = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> NDArray[ScalarT]: ... + @overload # out: ArrayT + def var[ArrayT: ndarray]( + self: NDArray[number | bool_ | timedelta64 | object_], + axis: int | tuple[int, ...] | None = None, + dtype: DTypeLike | None = None, + *, + out: ArrayT, + ddof: float = 0, + keepdims: py_bool | _NoValueType = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> ArrayT: ... + @overload # fallback + def var( + self: NDArray[number | bool_ | timedelta64 | object_], + axis: None = None, + dtype: DTypeLike | None = None, + out: None = None, + ddof: float = 0, + *, + keepdims: L[False] | _NoValueType = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> Any: ... + @overload # fallback, axis: + def var( + self: NDArray[number | bool_ | timedelta64 | object_], + axis: int | tuple[int, ...], + dtype: DTypeLike | None = None, + out: None = None, + ddof: float = 0, + *, + keepdims: L[False] | _NoValueType = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> ndarray: ... + @overload # fallback, keepdims=True + def var( # pyright: ignore[reportIncompatibleMethodOverride] + self: NDArray[number | bool_ | timedelta64 | object_], + axis: int | tuple[int, ...] | None = None, + dtype: DTypeLike | None = None, + out: None = None, + ddof: float = 0, + *, + keepdims: L[True], + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeNumber_co | _NoValueType = ..., + correction: float | _NoValueType = ..., + ) -> ndarray[_ShapeT_co]: ... + # @overload def partition( diff --git a/numpy/_core/fromnumeric.pyi b/numpy/_core/fromnumeric.pyi index 85532a6cbc8b..5457cd571185 100644 --- a/numpy/_core/fromnumeric.pyi +++ b/numpy/_core/fromnumeric.pyi @@ -1809,10 +1809,10 @@ def mean( where: _ArrayLikeBool_co | _NoValueType = ..., ) -> NDArray[Any]: ... -# -@overload +# keep in sync with `mean` above +@overload # +integer | ~object_ | +builtins.float def std( - a: _ArrayLikeComplex_co, + a: _DualArrayLike[np.dtype[np.integer | np.bool | np.object_], float], axis: None = None, dtype: None = None, out: None = None, @@ -1820,38 +1820,90 @@ def std( keepdims: Literal[False] | _NoValueType = ..., *, where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeFloat_co | _NoValueType = ..., + correction: float | _NoValueType = ..., +) -> np.float64: ... +@overload # +integer | +builtins.float, axis: +def std( + a: _DualArrayLike[np.dtype[np.integer | np.bool], float], + axis: int | tuple[int, ...], + dtype: None = None, + out: None = None, + ddof: float = 0, + keepdims: Literal[False] | _NoValueType = ..., + *, + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeFloat_co | _NoValueType = ..., + correction: float | _NoValueType = ..., +) -> NDArray[np.float64]: ... +@overload # +integer, keepdims=True +def std[ShapeT: _Shape]( + a: np.ndarray[ShapeT, np.dtype[np.integer | np.bool]], + axis: int | tuple[int, ...] | None = None, + dtype: None = None, + out: None = None, + ddof: float = 0, + *, + keepdims: Literal[True], + where: _ArrayLikeBool_co | _NoValueType = ..., mean: _ArrayLikeComplex_co | _NoValueType = ..., correction: float | _NoValueType = ..., -) -> floating: ... -@overload +) -> np.ndarray[ShapeT, np.dtype[np.float64]]: ... +@overload # ~complex (`list` ensures invariance to avoid overlap with the previous overload) def std( - a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: _ShapeLike | None = None, + a: _NestedSequence[list[complex]] | list[complex], + axis: None = None, dtype: None = None, out: None = None, ddof: float = 0, - keepdims: bool | _NoValueType = ..., + keepdims: Literal[False] | _NoValueType = ..., *, where: _ArrayLikeBool_co | _NoValueType = ..., - mean: _ArrayLikeComplex_co | _ArrayLikeObject_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., correction: float | _NoValueType = ..., -) -> Any: ... -@overload -def std[ScalarT: np.generic]( - a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: None, - dtype: _DTypeLike[ScalarT], +) -> np.complex128: ... +@overload # ~inexact | timedelta64 +def std[ScalarT: np.inexact | np.timedelta64]( + a: _ArrayLike[ScalarT], + axis: None = None, + dtype: None = None, out: None = None, ddof: float = 0, keepdims: Literal[False] | _NoValueType = ..., *, where: _ArrayLikeBool_co | _NoValueType = ..., - mean: _ArrayLikeComplex_co | _ArrayLikeObject_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., correction: float | _NoValueType = ..., ) -> ScalarT: ... -@overload +@overload # ~inexact | timedelta64 | object_, axis: +def std[ScalarT: np.inexact | np.timedelta64 | np.object_]( + a: _ArrayLike[ScalarT], + axis: int | tuple[int, ...], + dtype: None = None, + out: None = None, + ddof: float = 0, + keepdims: Literal[False] | _NoValueType = ..., + *, + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., + correction: float | _NoValueType = ..., +) -> NDArray[ScalarT]: ... +@overload # ~inexact | timedelta64 | object_, keepdims=True +def std[ArrayT: NDArray[np.inexact | np.timedelta64 | np.object_]]( + a: ArrayT, + axis: int | tuple[int, ...] | None = None, + dtype: None = None, + out: None = None, + *, + ddof: float = 0, + keepdims: Literal[True], + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., + correction: float | _NoValueType = ..., +) -> ArrayT: ... +@overload # dtype: ScalarT def std[ScalarT: np.generic]( - a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + a: _ArrayLikeNumeric_co, axis: None = None, *, dtype: _DTypeLike[ScalarT], @@ -1859,52 +1911,118 @@ def std[ScalarT: np.generic]( ddof: float = 0, keepdims: Literal[False] | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., - mean: _ArrayLikeComplex_co | _ArrayLikeObject_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., correction: float | _NoValueType = ..., ) -> ScalarT: ... -@overload -def std( - a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: _ShapeLike | None = None, - dtype: DTypeLike | None = None, +@overload # dtype: ScalarT (keyword), keepdims=True +def std[ShapeT: _Shape, ScalarT: np.generic]( + a: np.ndarray[ShapeT, np.dtype[np.number | np.bool | np.timedelta64 | np.object_]], + axis: int | tuple[int, ...] | None = None, + *, + dtype: _DTypeLike[ScalarT], + out: None = None, + ddof: float = 0, + keepdims: Literal[True], + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., + correction: float | _NoValueType = ..., +) -> np.ndarray[ShapeT, np.dtype[ScalarT]]: ... +@overload # dtype: ScalarT (positional), keepdims=True +def std[ShapeT: _Shape, ScalarT: np.generic]( + a: np.ndarray[ShapeT, np.dtype[np.number | np.bool | np.timedelta64 | np.object_]], + axis: int | tuple[int, ...] | None, + dtype: _DTypeLike[ScalarT], out: None = None, ddof: float = 0, - keepdims: bool | _NoValueType = ..., *, + keepdims: Literal[True], where: _ArrayLikeBool_co | _NoValueType = ..., - mean: _ArrayLikeComplex_co | _ArrayLikeObject_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., correction: float | _NoValueType = ..., -) -> Any: ... -@overload -def std[ArrayT: np.ndarray]( - a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: _ShapeLike | None, - dtype: DTypeLike | None, - out: ArrayT, +) -> np.ndarray[ShapeT, np.dtype[ScalarT]]: ... +@overload # dtype: ScalarT (keyword), keepdims=True +def std[ScalarT: np.generic]( + a: _ArrayLikeNumeric_co, + axis: int | tuple[int, ...] | None = None, + *, + dtype: _DTypeLike[ScalarT], + out: None = None, ddof: float = 0, - keepdims: bool | _NoValueType = ..., + keepdims: Literal[True], + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., + correction: float | _NoValueType = ..., +) -> NDArray[ScalarT]: ... +@overload # axis: , dtype: ScalarT +def std[ScalarT: np.generic]( + a: _ArrayLikeNumeric_co, + axis: int | tuple[int, ...], + dtype: _DTypeLike[ScalarT], + out: None = None, + ddof: float = 0, + keepdims: Literal[False] | _NoValueType = ..., *, where: _ArrayLikeBool_co | _NoValueType = ..., - mean: _ArrayLikeComplex_co | _ArrayLikeObject_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., correction: float | _NoValueType = ..., -) -> ArrayT: ... -@overload +) -> NDArray[ScalarT]: ... +@overload # out: ArrayT def std[ArrayT: np.ndarray]( - a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: _ShapeLike | None = None, + a: _ArrayLikeNumeric_co, + axis: int | tuple[int, ...] | None = None, dtype: DTypeLike | None = None, *, out: ArrayT, ddof: float = 0, keepdims: bool | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., - mean: _ArrayLikeComplex_co | _ArrayLikeObject_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., correction: float | _NoValueType = ..., ) -> ArrayT: ... +@overload # fallback +def std( + a: _ArrayLikeNumeric_co, + axis: None = None, + dtype: DTypeLike | None = None, + out: None = None, + ddof: float = 0, + keepdims: Literal[False] | _NoValueType = ..., + *, + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., + correction: float | _NoValueType = ..., +) -> Any: ... +@overload # fallback, axis: +def std( + a: _ArrayLikeNumeric_co, + axis: int | tuple[int, ...], + dtype: DTypeLike | None = None, + out: None = None, + ddof: float = 0, + keepdims: Literal[False] | _NoValueType = ..., + *, + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., + correction: float | _NoValueType = ..., +) -> NDArray[Any]: ... +@overload # fallback, keepdims=True +def std( + a: _ArrayLikeNumeric_co, + axis: int | tuple[int, ...] | None = None, + dtype: DTypeLike | None = None, + out: None = None, + ddof: float = 0, + *, + keepdims: Literal[True], + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., + correction: float | _NoValueType = ..., +) -> NDArray[Any]: ... -@overload +# keep in sync with `std` above +@overload # +integer | ~object_ | +builtins.float def var( - a: _ArrayLikeComplex_co, + a: _DualArrayLike[np.dtype[np.integer | np.bool | np.object_], float], axis: None = None, dtype: None = None, out: None = None, @@ -1912,38 +2030,90 @@ def var( keepdims: Literal[False] | _NoValueType = ..., *, where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeFloat_co | _NoValueType = ..., + correction: float | _NoValueType = ..., +) -> np.float64: ... +@overload # +integer | +builtins.float, axis: +def var( + a: _DualArrayLike[np.dtype[np.integer | np.bool], float], + axis: int | tuple[int, ...], + dtype: None = None, + out: None = None, + ddof: float = 0, + keepdims: Literal[False] | _NoValueType = ..., + *, + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeFloat_co | _NoValueType = ..., + correction: float | _NoValueType = ..., +) -> NDArray[np.float64]: ... +@overload # +integer, keepdims=True +def var[ShapeT: _Shape]( + a: np.ndarray[ShapeT, np.dtype[np.integer | np.bool]], + axis: int | tuple[int, ...] | None = None, + dtype: None = None, + out: None = None, + ddof: float = 0, + *, + keepdims: Literal[True], + where: _ArrayLikeBool_co | _NoValueType = ..., mean: _ArrayLikeComplex_co | _NoValueType = ..., correction: float | _NoValueType = ..., -) -> floating: ... -@overload +) -> np.ndarray[ShapeT, np.dtype[np.float64]]: ... +@overload # ~complex (`list` ensures invariance to avoid overlap with the previous overload) def var( - a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: _ShapeLike | None = None, + a: _NestedSequence[list[complex]] | list[complex], + axis: None = None, dtype: None = None, out: None = None, ddof: float = 0, - keepdims: bool | _NoValueType = ..., + keepdims: Literal[False] | _NoValueType = ..., *, where: _ArrayLikeBool_co | _NoValueType = ..., - mean: _ArrayLikeComplex_co | _ArrayLikeObject_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., correction: float | _NoValueType = ..., -) -> Any: ... -@overload -def var[ScalarT: np.generic]( - a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: None, - dtype: _DTypeLike[ScalarT], +) -> np.complex128: ... +@overload # ~inexact | timedelta64 +def var[ScalarT: np.inexact | np.timedelta64]( + a: _ArrayLike[ScalarT], + axis: None = None, + dtype: None = None, out: None = None, ddof: float = 0, keepdims: Literal[False] | _NoValueType = ..., *, where: _ArrayLikeBool_co | _NoValueType = ..., - mean: _ArrayLikeComplex_co | _ArrayLikeObject_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., correction: float | _NoValueType = ..., ) -> ScalarT: ... -@overload +@overload # ~inexact | timedelta64 | object_, axis: +def var[ScalarT: np.inexact | np.timedelta64 | np.object_]( + a: _ArrayLike[ScalarT], + axis: int | tuple[int, ...], + dtype: None = None, + out: None = None, + ddof: float = 0, + keepdims: Literal[False] | _NoValueType = ..., + *, + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., + correction: float | _NoValueType = ..., +) -> NDArray[ScalarT]: ... +@overload # ~inexact | timedelta64 | object_, keepdims=True +def var[ArrayT: NDArray[np.inexact | np.timedelta64 | np.object_]]( + a: ArrayT, + axis: int | tuple[int, ...] | None = None, + dtype: None = None, + out: None = None, + *, + ddof: float = 0, + keepdims: Literal[True], + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., + correction: float | _NoValueType = ..., +) -> ArrayT: ... +@overload # dtype: ScalarT def var[ScalarT: np.generic]( - a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + a: _ArrayLikeNumeric_co, axis: None = None, *, dtype: _DTypeLike[ScalarT], @@ -1951,48 +2121,113 @@ def var[ScalarT: np.generic]( ddof: float = 0, keepdims: Literal[False] | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., - mean: _ArrayLikeComplex_co | _ArrayLikeObject_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., correction: float | _NoValueType = ..., ) -> ScalarT: ... -@overload -def var( - a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: _ShapeLike | None = None, - dtype: DTypeLike | None = None, +@overload # dtype: ScalarT (keyword), keepdims=True +def var[ShapeT: _Shape, ScalarT: np.generic]( + a: np.ndarray[ShapeT, np.dtype[np.number | np.bool | np.timedelta64 | np.object_]], + axis: int | tuple[int, ...] | None = None, + *, + dtype: _DTypeLike[ScalarT], + out: None = None, + ddof: float = 0, + keepdims: Literal[True], + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., + correction: float | _NoValueType = ..., +) -> np.ndarray[ShapeT, np.dtype[ScalarT]]: ... +@overload # dtype: ScalarT (positional), keepdims=True +def var[ShapeT: _Shape, ScalarT: np.generic]( + a: np.ndarray[ShapeT, np.dtype[np.number | np.bool | np.timedelta64 | np.object_]], + axis: int | tuple[int, ...] | None, + dtype: _DTypeLike[ScalarT], out: None = None, ddof: float = 0, - keepdims: bool | _NoValueType = ..., *, + keepdims: Literal[True], where: _ArrayLikeBool_co | _NoValueType = ..., - mean: _ArrayLikeComplex_co | _ArrayLikeObject_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., correction: float | _NoValueType = ..., -) -> Any: ... -@overload -def var[ArrayT: np.ndarray]( - a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: _ShapeLike | None, - dtype: DTypeLike | None, - out: ArrayT, +) -> np.ndarray[ShapeT, np.dtype[ScalarT]]: ... +@overload # dtype: ScalarT (keyword), keepdims=True +def var[ScalarT: np.generic]( + a: _ArrayLikeNumeric_co, + axis: int | tuple[int, ...] | None = None, + *, + dtype: _DTypeLike[ScalarT], + out: None = None, ddof: float = 0, - keepdims: bool | _NoValueType = ..., + keepdims: Literal[True], + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., + correction: float | _NoValueType = ..., +) -> NDArray[ScalarT]: ... +@overload # axis: , dtype: ScalarT +def var[ScalarT: np.generic]( + a: _ArrayLikeNumeric_co, + axis: int | tuple[int, ...], + dtype: _DTypeLike[ScalarT], + out: None = None, + ddof: float = 0, + keepdims: Literal[False] | _NoValueType = ..., *, where: _ArrayLikeBool_co | _NoValueType = ..., - mean: _ArrayLikeComplex_co | _ArrayLikeObject_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., correction: float | _NoValueType = ..., -) -> ArrayT: ... -@overload +) -> NDArray[ScalarT]: ... +@overload # out: ArrayT def var[ArrayT: np.ndarray]( - a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: _ShapeLike | None = None, + a: _ArrayLikeNumeric_co, + axis: int | tuple[int, ...] | None = None, dtype: DTypeLike | None = None, *, out: ArrayT, ddof: float = 0, keepdims: bool | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., - mean: _ArrayLikeComplex_co | _ArrayLikeObject_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., correction: float | _NoValueType = ..., ) -> ArrayT: ... +@overload # fallback +def var( + a: _ArrayLikeNumeric_co, + axis: None = None, + dtype: DTypeLike | None = None, + out: None = None, + ddof: float = 0, + keepdims: Literal[False] | _NoValueType = ..., + *, + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., + correction: float | _NoValueType = ..., +) -> Any: ... +@overload # fallback, axis: +def var( + a: _ArrayLikeNumeric_co, + axis: int | tuple[int, ...], + dtype: DTypeLike | None = None, + out: None = None, + ddof: float = 0, + keepdims: Literal[False] | _NoValueType = ..., + *, + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., + correction: float | _NoValueType = ..., +) -> NDArray[Any]: ... +@overload # fallback, keepdims=True +def var( + a: _ArrayLikeNumeric_co, + axis: int | tuple[int, ...] | None = None, + dtype: DTypeLike | None = None, + out: None = None, + ddof: float = 0, + *, + keepdims: Literal[True], + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., + correction: float | _NoValueType = ..., +) -> NDArray[Any]: ... max = amax min = amin diff --git a/numpy/typing/tests/data/reveal/fromnumeric.pyi b/numpy/typing/tests/data/reveal/fromnumeric.pyi index 525826a9dc53..a995bce2d6f2 100644 --- a/numpy/typing/tests/data/reveal/fromnumeric.pyi +++ b/numpy/typing/tests/data/reveal/fromnumeric.pyi @@ -372,24 +372,64 @@ assert_type(np.mean(AR_f4_1d, dtype=np.float64, keepdims=True), np.ndarray[tuple assert_type(np.mean(AR_f4_2d, dtype=np.float64, keepdims=True), np.ndarray[tuple[int, int], np.dtype[np.float64]]) assert_type(np.mean(AR_f4, out=AR_subclass), NDArraySubclass) -assert_type(np.std(AR_b), np.floating) -assert_type(np.std(AR_i8), np.floating) -assert_type(np.std(AR_f4), np.floating) -assert_type(np.std(AR_c16), np.floating) -assert_type(np.std(AR_O), Any) -assert_type(np.std(AR_f4, axis=0), Any) -assert_type(np.std(AR_f4, keepdims=True), Any) +# same as above +assert_type(np.std(AR_b), np.float64) +assert_type(np.std(AR_i8), np.float64) +assert_type(np.std(AR_i8, axis=0), npt.NDArray[np.float64]) +assert_type(np.std(AR_i8, keepdims=True), npt.NDArray[np.float64]) +assert_type(np.std(AR_i8, axis=0, keepdims=True), npt.NDArray[np.float64]) +assert_type(np.std(AR_f4), np.float32) +assert_type(np.std(AR_c16), np.complex128) +assert_type(np.std(AR_O), np.float64) +assert_type(np.std(AR_O, axis=0), npt.NDArray[np.object_]) +assert_type(np.std(AR_O, keepdims=True), npt.NDArray[np.object_]) +assert_type(np.std(AR_O, axis=0, keepdims=True), npt.NDArray[np.object_]) +assert_type(np.std(AR_m_ns), np.timedelta64[int]) +assert_type(np.std(AR_m_s), np.timedelta64[dt.timedelta]) +assert_type(np.std(AR_m_nat), np.timedelta64[None]) +assert_type(np.std(AR_f4, axis=0), npt.NDArray[np.float32]) +assert_type(np.std(AR_f4, keepdims=True), npt.NDArray[np.float32]) +assert_type(np.std(AR_f4_1d, keepdims=True), np.ndarray[tuple[int], np.dtype[np.float32]]) +assert_type(np.std(AR_f4_2d, keepdims=True), np.ndarray[tuple[int, int], np.dtype[np.float32]]) assert_type(np.std(AR_f4, dtype=float), Any) +assert_type(np.std(AR_f4, dtype=float, axis=1), np.ndarray) +assert_type(np.std(AR_f4, dtype=float, keepdims=True), np.ndarray) +assert_type(np.std(AR_f4, dtype=float, axis=1, keepdims=True), np.ndarray) assert_type(np.std(AR_f4, dtype=np.float64), np.float64) +assert_type(np.std(AR_f4, dtype=np.float64), np.float64) +assert_type(np.std(AR_f4, dtype=np.float64, keepdims=False), np.float64) +assert_type(np.std(AR_f4, dtype=np.float64, keepdims=True), npt.NDArray[np.float64]) +assert_type(np.std(AR_f4_1d, dtype=np.float64, keepdims=True), np.ndarray[tuple[int], np.dtype[np.float64]]) +assert_type(np.std(AR_f4_2d, dtype=np.float64, keepdims=True), np.ndarray[tuple[int, int], np.dtype[np.float64]]) assert_type(np.std(AR_f4, out=AR_subclass), NDArraySubclass) -assert_type(np.var(AR_b), np.floating) -assert_type(np.var(AR_i8), np.floating) -assert_type(np.var(AR_f4), np.floating) -assert_type(np.var(AR_c16), np.floating) -assert_type(np.var(AR_O), Any) -assert_type(np.var(AR_f4, axis=0), Any) -assert_type(np.var(AR_f4, keepdims=True), Any) +# same as above +assert_type(np.var(AR_b), np.float64) +assert_type(np.var(AR_i8), np.float64) +assert_type(np.var(AR_i8, axis=0), npt.NDArray[np.float64]) +assert_type(np.var(AR_i8, keepdims=True), npt.NDArray[np.float64]) +assert_type(np.var(AR_i8, axis=0, keepdims=True), npt.NDArray[np.float64]) +assert_type(np.var(AR_f4), np.float32) +assert_type(np.var(AR_c16), np.complex128) +assert_type(np.var(AR_O), np.float64) +assert_type(np.var(AR_O, axis=0), npt.NDArray[np.object_]) +assert_type(np.var(AR_O, keepdims=True), npt.NDArray[np.object_]) +assert_type(np.var(AR_O, axis=0, keepdims=True), npt.NDArray[np.object_]) +assert_type(np.var(AR_m_ns), np.timedelta64[int]) +assert_type(np.var(AR_m_s), np.timedelta64[dt.timedelta]) +assert_type(np.var(AR_m_nat), np.timedelta64[None]) +assert_type(np.var(AR_f4, axis=0), npt.NDArray[np.float32]) +assert_type(np.var(AR_f4, keepdims=True), npt.NDArray[np.float32]) +assert_type(np.var(AR_f4_1d, keepdims=True), np.ndarray[tuple[int], np.dtype[np.float32]]) +assert_type(np.var(AR_f4_2d, keepdims=True), np.ndarray[tuple[int, int], np.dtype[np.float32]]) assert_type(np.var(AR_f4, dtype=float), Any) +assert_type(np.var(AR_f4, dtype=float, axis=1), np.ndarray) +assert_type(np.var(AR_f4, dtype=float, keepdims=True), np.ndarray) +assert_type(np.var(AR_f4, dtype=float, axis=1, keepdims=True), np.ndarray) +assert_type(np.var(AR_f4, dtype=np.float64), np.float64) assert_type(np.var(AR_f4, dtype=np.float64), np.float64) +assert_type(np.var(AR_f4, dtype=np.float64, keepdims=False), np.float64) +assert_type(np.var(AR_f4, dtype=np.float64, keepdims=True), npt.NDArray[np.float64]) +assert_type(np.var(AR_f4_1d, dtype=np.float64, keepdims=True), np.ndarray[tuple[int], np.dtype[np.float64]]) +assert_type(np.var(AR_f4_2d, dtype=np.float64, keepdims=True), np.ndarray[tuple[int, int], np.dtype[np.float64]]) assert_type(np.var(AR_f4, out=AR_subclass), NDArraySubclass) diff --git a/numpy/typing/tests/data/reveal/ndarray_misc.pyi b/numpy/typing/tests/data/reveal/ndarray_misc.pyi index 89560d5d74db..6d0563f0c3cb 100644 --- a/numpy/typing/tests/data/reveal/ndarray_misc.pyi +++ b/numpy/typing/tests/data/reveal/ndarray_misc.pyi @@ -127,6 +127,46 @@ assert_type(AR_f8_2d.mean(dtype=np.float32, axis=0), npt.NDArray[np.float32]) assert_type(AR_f8_2d.mean(dtype=np.float32, keepdims=True), np.ndarray[tuple[int, int], np.dtype[np.float32]]) assert_type(AR_f8_2d.mean(dtype=np.float32, axis=0, keepdims=True), np.ndarray[tuple[int, int], np.dtype[np.float32]]) +# same as above +assert_type(f8.std(), Any) +assert_type(AR_f8.std(), np.float64) +assert_type(AR_f8.std(keepdims=True), npt.NDArray[np.float64]) +assert_type(AR_f8.std(axis=0), npt.NDArray[np.float64]) +assert_type(AR_f8.std(axis=0, keepdims=True), npt.NDArray[np.float64]) +assert_type(AR_f8.std(dtype=np.float32), np.float32) +assert_type(AR_f8.std(dtype=np.float32, axis=0), npt.NDArray[np.float32]) +assert_type(AR_f8.std(dtype=np.float32, keepdims=True), npt.NDArray[np.float32]) +assert_type(AR_f8.std(dtype=np.float32, axis=0, keepdims=True), npt.NDArray[np.float32]) +assert_type(AR_f8.std(out=B), SubClass) +assert_type(AR_f8_2d.std(), np.float64) +assert_type(AR_f8_2d.std(keepdims=True), np.ndarray[tuple[int, int], np.dtype[np.float64]]) +assert_type(AR_f8_2d.std(axis=0), npt.NDArray[np.float64]) +assert_type(AR_f8_2d.std(axis=0, keepdims=True), np.ndarray[tuple[int, int], np.dtype[np.float64]]) +assert_type(AR_f8_2d.std(dtype=np.float32), np.float32) +assert_type(AR_f8_2d.std(dtype=np.float32, axis=0), npt.NDArray[np.float32]) +assert_type(AR_f8_2d.std(dtype=np.float32, keepdims=True), np.ndarray[tuple[int, int], np.dtype[np.float32]]) +assert_type(AR_f8_2d.std(dtype=np.float32, axis=0, keepdims=True), np.ndarray[tuple[int, int], np.dtype[np.float32]]) + +# same as above +assert_type(f8.var(), Any) +assert_type(AR_f8.var(), np.float64) +assert_type(AR_f8.var(keepdims=True), npt.NDArray[np.float64]) +assert_type(AR_f8.var(axis=0), npt.NDArray[np.float64]) +assert_type(AR_f8.var(axis=0, keepdims=True), npt.NDArray[np.float64]) +assert_type(AR_f8.var(dtype=np.float32), np.float32) +assert_type(AR_f8.var(dtype=np.float32, axis=0), npt.NDArray[np.float32]) +assert_type(AR_f8.var(dtype=np.float32, keepdims=True), npt.NDArray[np.float32]) +assert_type(AR_f8.var(dtype=np.float32, axis=0, keepdims=True), npt.NDArray[np.float32]) +assert_type(AR_f8.var(out=B), SubClass) +assert_type(AR_f8_2d.var(), np.float64) +assert_type(AR_f8_2d.var(keepdims=True), np.ndarray[tuple[int, int], np.dtype[np.float64]]) +assert_type(AR_f8_2d.var(axis=0), npt.NDArray[np.float64]) +assert_type(AR_f8_2d.var(axis=0, keepdims=True), np.ndarray[tuple[int, int], np.dtype[np.float64]]) +assert_type(AR_f8_2d.var(dtype=np.float32), np.float32) +assert_type(AR_f8_2d.var(dtype=np.float32, axis=0), npt.NDArray[np.float32]) +assert_type(AR_f8_2d.var(dtype=np.float32, keepdims=True), np.ndarray[tuple[int, int], np.dtype[np.float32]]) +assert_type(AR_f8_2d.var(dtype=np.float32, axis=0, keepdims=True), np.ndarray[tuple[int, int], np.dtype[np.float32]]) + assert_type(f8.min(), Any) assert_type(AR_f8.min(), Any) assert_type(AR_f8.min(axis=0), Any) @@ -149,13 +189,6 @@ assert_type(AR_f8.repeat(1), np.ndarray[tuple[int], np.dtype[np.float64]]) assert_type(AR_f8.repeat(1, axis=0), npt.NDArray[np.float64]) assert_type(B.repeat(1), np.ndarray[tuple[int], np.dtype[np.object_]]) assert_type(B.repeat(1, axis=0), npt.NDArray[np.object_]) - -assert_type(f8.std(), Any) -assert_type(AR_f8.std(), Any) -assert_type(AR_f8.std(axis=0), Any) -assert_type(AR_f8.std(keepdims=True), Any) -assert_type(AR_f8.std(out=B), SubClass) - assert_type(f8.sum(), Any) assert_type(AR_f8.sum(), Any) assert_type(AR_f8.sum(axis=0), Any) @@ -168,12 +201,6 @@ assert_type(AR_f8.take([0]), npt.NDArray[np.float64]) assert_type(AR_f8.take(0, out=B), SubClass) assert_type(AR_f8.take([0], out=B), SubClass) -assert_type(f8.var(), Any) -assert_type(AR_f8.var(), Any) -assert_type(AR_f8.var(axis=0), Any) -assert_type(AR_f8.var(keepdims=True), Any) -assert_type(AR_f8.var(out=B), SubClass) - assert_type(AR_f8.argpartition(0), npt.NDArray[np.intp]) assert_type(AR_f8.argpartition([0]), npt.NDArray[np.intp]) assert_type(AR_f8.argpartition(0, axis=None), np.ndarray[tuple[int], np.dtype[np.intp]])