mirror of
https://github.com/ROCm/jax.git
synced 2025-04-18 21:06:06 +00:00
Run pyupgrade --py310-plus on .pyi files.
Manually fix import orders.
This commit is contained in:
Peter Hawkins
parent
9842bdbc6d
commit
e7e1ddcf1c
@ -12,7 +12,8 @@
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
import abc
|
||||
from typing import Any, Callable, Optional, Sequence, Union
|
||||
from collections.abc import Callable, Sequence
|
||||
from typing import Any, Union
|
||||
import numpy as np
|
||||
|
||||
from jax._src.sharding import Sharding
|
||||
@ -113,24 +114,24 @@ class Array(abc.ABC):
|
||||
def __release_buffer__(self, view: memoryview) -> None: ...
|
||||
|
||||
# np.ndarray methods:
|
||||
def all(self, axis: Optional[Union[int, Sequence[int]]] = None, out=None,
|
||||
keepdims=None, *, where: Optional[ArrayLike] = ...) -> Array: ...
|
||||
def any(self, axis: Optional[Union[int, Sequence[int]]] = None, out=None,
|
||||
keepdims=None, *, where: Optional[ArrayLike] = ...) -> Array: ...
|
||||
def argmax(self, axis: Optional[int] = None, out=None, keepdims=None) -> Array: ...
|
||||
def argmin(self, axis: Optional[int] = None, out=None, keepdims=None) -> Array: ...
|
||||
def all(self, axis: int | Sequence[int] | None = None, out=None,
|
||||
keepdims=None, *, where: ArrayLike | None = ...) -> Array: ...
|
||||
def any(self, axis: int | Sequence[int] | None = None, out=None,
|
||||
keepdims=None, *, where: ArrayLike | None = ...) -> Array: ...
|
||||
def argmax(self, axis: int | None = None, out=None, keepdims=None) -> Array: ...
|
||||
def argmin(self, axis: int | None = None, out=None, keepdims=None) -> Array: ...
|
||||
def argpartition(self, kth, axis=-1, kind='introselect', order=None) -> Array: ...
|
||||
def argsort(self, axis: Optional[int] = -1, kind='quicksort', order=None) -> Array: ...
|
||||
def argsort(self, axis: int | None = -1, kind='quicksort', order=None) -> Array: ...
|
||||
def astype(self, dtype) -> Array: ...
|
||||
def choose(self, choices, out=None, mode='raise') -> Array: ...
|
||||
def clip(self, min=None, max=None, out=None) -> Array: ...
|
||||
def compress(self, condition, axis: Optional[int] = None, out=None) -> Array: ...
|
||||
def compress(self, condition, axis: int | None = None, out=None) -> Array: ...
|
||||
def conj(self) -> Array: ...
|
||||
def conjugate(self) -> Array: ...
|
||||
def copy(self) -> Array: ...
|
||||
def cumprod(self, axis: Optional[Union[int, Sequence[int]]] = None,
|
||||
def cumprod(self, axis: int | Sequence[int] | None = None,
|
||||
dtype=None, out=None) -> Array: ...
|
||||
def cumsum(self, axis: Optional[Union[int, Sequence[int]]] = None,
|
||||
def cumsum(self, axis: int | Sequence[int] | None = None,
|
||||
dtype=None, out=None) -> Array: ...
|
||||
def diagonal(self, offset=0, axis1: int = 0, axis2: int = 1) -> Array: ...
|
||||
def dot(self, b, *, precision=None) -> Array: ...
|
||||
@ -138,35 +139,35 @@ class Array(abc.ABC):
|
||||
@property
|
||||
def imag(self) -> Array: ...
|
||||
def item(self, *args) -> Any: ...
|
||||
def max(self, axis: Optional[Union[int, Sequence[int]]] = None, out=None,
|
||||
def max(self, axis: int | Sequence[int] | None = None, out=None,
|
||||
keepdims=None, initial=None, where=None) -> Array: ...
|
||||
def mean(self, axis: Optional[Union[int, Sequence[int]]] = None, dtype=None,
|
||||
def mean(self, axis: int | Sequence[int] | None = None, dtype=None,
|
||||
out=None, keepdims=False, *, where=None,) -> Array: ...
|
||||
def min(self, axis: Optional[Union[int, Sequence[int]]] = None, out=None,
|
||||
def min(self, axis: int | Sequence[int] | None = None, out=None,
|
||||
keepdims=None, initial=None, where=None) -> Array: ...
|
||||
@property
|
||||
def nbytes(self) -> int: ...
|
||||
def nonzero(self, *, size=None, fill_value=None) -> Array: ...
|
||||
def prod(self, axis: Optional[Union[int, Sequence[int]]] = None, dtype=None,
|
||||
def prod(self, axis: int | Sequence[int] | None = None, dtype=None,
|
||||
out=None, keepdims=None, initial=None, where=None) -> Array: ...
|
||||
def ptp(self, axis: Optional[Union[int, Sequence[int]]] = None, out=None,
|
||||
def ptp(self, axis: int | Sequence[int] | None = None, out=None,
|
||||
keepdims=False,) -> Array: ...
|
||||
def ravel(self, order='C') -> Array: ...
|
||||
@property
|
||||
def real(self) -> Array: ...
|
||||
def repeat(self, repeats, axis: Optional[int] = None, *,
|
||||
def repeat(self, repeats, axis: int | None = None, *,
|
||||
total_repeat_length=None) -> Array: ...
|
||||
def reshape(self, *args, order='C') -> Array: ...
|
||||
def round(self, decimals=0, out=None) -> Array: ...
|
||||
def searchsorted(self, v, side='left', sorter=None) -> Array: ...
|
||||
def sort(self, axis: Optional[int] = -1, kind='quicksort', order=None) -> Array: ...
|
||||
def squeeze(self, axis: Optional[Union[int, Sequence[int]]] = None) -> Array: ...
|
||||
def std(self, axis: Optional[Union[int, Sequence[int]]] = None,
|
||||
def sort(self, axis: int | None = -1, kind='quicksort', order=None) -> Array: ...
|
||||
def squeeze(self, axis: int | Sequence[int] | None = None) -> Array: ...
|
||||
def std(self, axis: int | Sequence[int] | None = None,
|
||||
dtype=None, out=None, ddof=0, keepdims=False, *, where=None) -> Array: ...
|
||||
def sum(self, axis: Optional[Union[int, Sequence[int]]] = None, dtype=None,
|
||||
def sum(self, axis: int | Sequence[int] | None = None, dtype=None,
|
||||
out=None, keepdims=None, initial=None, where=None) -> Array: ...
|
||||
def swapaxes(self, axis1: int, axis2: int) -> Array: ...
|
||||
def take(self, indices, axis: Optional[int] = None, out=None,
|
||||
def take(self, indices, axis: int | None = None, out=None,
|
||||
mode=None) -> Array: ...
|
||||
def tobytes(self, order='C') -> bytes: ...
|
||||
def tolist(self) -> list[Any]: ...
|
||||
@ -177,15 +178,15 @@ class Array(abc.ABC):
|
||||
def T(self) -> Array: ...
|
||||
@property
|
||||
def mT(self) -> Array: ...
|
||||
def var(self, axis: Optional[Union[int, Sequence[int]]] = None,
|
||||
def var(self, axis: int | Sequence[int] | None = None,
|
||||
dtype=None, out=None, ddof=0, keepdims=False, *, where=None) -> Array: ...
|
||||
def view(self, dtype=None, type=None) -> Array: ...
|
||||
|
||||
# Even though we don't always support the NumPy array protocol, e.g., for
|
||||
# tracer types, for type checking purposes we must declare support so we
|
||||
# implement the NumPy ArrayLike protocol.
|
||||
def __array__(self, dtype: Optional[np.dtype] = ...,
|
||||
copy: Optional[bool] = ...) -> np.ndarray: ...
|
||||
def __array__(self, dtype: np.dtype | None = ...,
|
||||
copy: bool | None = ...) -> np.ndarray: ...
|
||||
def __dlpack__(self) -> Any: ...
|
||||
|
||||
# JAX extensions
|
||||
@ -237,23 +238,23 @@ class _IndexUpdateHelper:
|
||||
|
||||
class _IndexUpdateRef:
|
||||
def get(self, indices_are_sorted: bool = False, unique_indices: bool = False,
|
||||
mode: Optional[str] = None, fill_value: Optional[StaticScalar] = None) -> Array: ...
|
||||
mode: str | None = None, fill_value: StaticScalar | None = None) -> Array: ...
|
||||
def set(self, values: Any,
|
||||
indices_are_sorted: bool = False, unique_indices: bool = False,
|
||||
mode: Optional[str] = None, fill_value: Optional[StaticScalar] = None) -> Array: ...
|
||||
mode: str | None = None, fill_value: StaticScalar | None = None) -> Array: ...
|
||||
def add(self, values: Any, indices_are_sorted: bool = False,
|
||||
unique_indices: bool = False, mode: Optional[str] = None) -> Array: ...
|
||||
unique_indices: bool = False, mode: str | None = None) -> Array: ...
|
||||
def mul(self, values: Any, indices_are_sorted: bool = False,
|
||||
unique_indices: bool = False, mode: Optional[str] = None) -> Array: ...
|
||||
unique_indices: bool = False, mode: str | None = None) -> Array: ...
|
||||
def multiply(self, values: Any, indices_are_sorted: bool = False,
|
||||
unique_indices: bool = False, mode: Optional[str] = None) -> Array: ...
|
||||
unique_indices: bool = False, mode: str | None = None) -> Array: ...
|
||||
def divide(self, values: Any, indices_are_sorted: bool = False,
|
||||
unique_indices: bool = False, mode: Optional[str] = None) -> Array: ...
|
||||
unique_indices: bool = False, mode: str | None = None) -> Array: ...
|
||||
def power(self, values: Any, indices_are_sorted: bool = False,
|
||||
unique_indices: bool = False, mode: Optional[str] = None) -> Array: ...
|
||||
unique_indices: bool = False, mode: str | None = None) -> Array: ...
|
||||
def min(self, values: Any, indices_are_sorted: bool = False,
|
||||
unique_indices: bool = False, mode: Optional[str] = None) -> Array: ...
|
||||
unique_indices: bool = False, mode: str | None = None) -> Array: ...
|
||||
def max(self, values: Any, indices_are_sorted: bool = False,
|
||||
unique_indices: bool = False, mode: Optional[str] = None) -> Array: ...
|
||||
unique_indices: bool = False, mode: str | None = None) -> Array: ...
|
||||
def apply(self, func: Callable[[ArrayLike], ArrayLike], indices_are_sorted: bool = False,
|
||||
unique_indices: bool = False, mode: Optional[str] = None) -> Array: ...
|
||||
unique_indices: bool = False, mode: str | None = None) -> Array: ...
|
||||
|
||||
@ -2,7 +2,8 @@ from __future__ import annotations
|
||||
|
||||
|
||||
import builtins
|
||||
from typing import Any, Callable, Literal, NamedTuple, Optional, Sequence, TypeVar, Union, overload
|
||||
from collections.abc import Callable, Sequence
|
||||
from typing import Any, Literal, NamedTuple, TypeVar, Union, overload
|
||||
|
||||
from jax._src import core as _core
|
||||
from jax._src import dtypes as _dtypes
|
||||
@ -33,21 +34,21 @@ def acos(x: ArrayLike, /) -> Array: ...
|
||||
def acosh(x: ArrayLike, /) -> Array: ...
|
||||
def add(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
def amax(a: ArrayLike, axis: _Axis = ..., out: None = ...,
|
||||
keepdims: builtins.bool = ..., initial: Optional[ArrayLike] = ...,
|
||||
where: Optional[ArrayLike] = ...) -> Array: ...
|
||||
keepdims: builtins.bool = ..., initial: ArrayLike | None = ...,
|
||||
where: ArrayLike | None = ...) -> Array: ...
|
||||
def amin(a: ArrayLike, axis: _Axis = ..., out: None = ...,
|
||||
keepdims: builtins.bool = ..., initial: Optional[ArrayLike] = ...,
|
||||
where: Optional[ArrayLike] = ...) -> Array: ...
|
||||
keepdims: builtins.bool = ..., initial: ArrayLike | None = ...,
|
||||
where: ArrayLike | None = ...) -> Array: ...
|
||||
def all(a: ArrayLike, axis: _Axis = ..., out: None = ...,
|
||||
keepdims: builtins.bool = ..., *, where: Optional[ArrayLike] = ...) -> Array: ...
|
||||
keepdims: builtins.bool = ..., *, where: ArrayLike | None = ...) -> Array: ...
|
||||
def allclose(a: ArrayLike, b: ArrayLike, rtol: ArrayLike = ...,
|
||||
atol: ArrayLike = ..., equal_nan: builtins.bool = ...) -> Array: ...
|
||||
alltrue = all
|
||||
def angle(z: ArrayLike, deg: builtins.bool = ...) -> Array: ...
|
||||
def any(a: ArrayLike, axis: _Axis = ..., out: None = ...,
|
||||
keepdims: builtins.bool = ..., *, where: Optional[ArrayLike] = ...) -> Array: ...
|
||||
keepdims: builtins.bool = ..., *, where: ArrayLike | None = ...) -> Array: ...
|
||||
def append(
|
||||
arr: ArrayLike, values: ArrayLike, axis: Optional[int] = ...
|
||||
arr: ArrayLike, values: ArrayLike, axis: int | None = ...
|
||||
) -> Array: ...
|
||||
def apply_along_axis(func1d: Callable, axis: int, arr: ArrayLike, *args,
|
||||
**kwargs) -> Array: ...
|
||||
@ -56,9 +57,9 @@ def apply_over_axes(
|
||||
) -> Array: ...
|
||||
def arange(
|
||||
start: DimSize,
|
||||
stop: Optional[DimSize] = ...,
|
||||
step: Optional[DimSize] = ...,
|
||||
dtype: Optional[DTypeLike] = ...,
|
||||
stop: DimSize | None = ...,
|
||||
step: DimSize | None = ...,
|
||||
dtype: DTypeLike | None = ...,
|
||||
) -> Array: ...
|
||||
def arccos(x: ArrayLike, /) -> Array: ...
|
||||
def arccosh(x: ArrayLike, /) -> Array: ...
|
||||
@ -69,20 +70,20 @@ def arctan2(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
def arctanh(x: ArrayLike, /) -> Array: ...
|
||||
def argmax(
|
||||
a: ArrayLike,
|
||||
axis: Optional[int] = ...,
|
||||
axis: int | None = ...,
|
||||
out: None = ...,
|
||||
keepdims: Optional[builtins.bool] = ...,
|
||||
keepdims: builtins.bool | None = ...,
|
||||
) -> Array: ...
|
||||
def argmin(
|
||||
a: ArrayLike,
|
||||
axis: Optional[int] = ...,
|
||||
axis: int | None = ...,
|
||||
out: None = ...,
|
||||
keepdims: Optional[builtins.bool] = ...,
|
||||
keepdims: builtins.bool | None = ...,
|
||||
) -> Array: ...
|
||||
def argpartition(a: ArrayLike, kth: int, axis: int = ...) -> Array: ...
|
||||
def argsort(
|
||||
a: ArrayLike,
|
||||
axis: Optional[int] = ...,
|
||||
axis: int | None = ...,
|
||||
*,
|
||||
stable: builtins.bool = ...,
|
||||
descending: builtins.bool = ...,
|
||||
@ -92,8 +93,8 @@ def argsort(
|
||||
def argwhere(
|
||||
a: ArrayLike,
|
||||
*,
|
||||
size: Optional[int] = ...,
|
||||
fill_value: Optional[ArrayLike] = ...,
|
||||
size: int | None = ...,
|
||||
fill_value: ArrayLike | None = ...,
|
||||
) -> Array: ...
|
||||
around = round
|
||||
def array(object: Any, dtype: DTypeLike | None = ..., copy: builtins.bool = True,
|
||||
@ -105,17 +106,17 @@ def array_equiv(a1: ArrayLike, a2: ArrayLike) -> Array: ...
|
||||
array_repr = _np.array_repr
|
||||
def array_split(
|
||||
ary: ArrayLike,
|
||||
indices_or_sections: Union[int, Sequence[int], ArrayLike],
|
||||
indices_or_sections: int | Sequence[int] | ArrayLike,
|
||||
axis: int = ...,
|
||||
) -> list[Array]: ...
|
||||
array_str = _np.array_str
|
||||
def asarray(
|
||||
a: Any, dtype: Optional[DTypeLike] = ..., order: Optional[str] = ...,
|
||||
*, copy: Optional[builtins.bool] = ...
|
||||
a: Any, dtype: DTypeLike | None = ..., order: str | None = ...,
|
||||
*, copy: builtins.bool | None = ...
|
||||
) -> Array: ...
|
||||
def asin(x: ArrayLike, /) -> Array: ...
|
||||
def asinh(x: ArrayLike, /) -> Array: ...
|
||||
def astype(a: ArrayLike, dtype: Optional[DTypeLike], /, *, copy: builtins.bool = ..., device: _Device | _Sharding | None = ...) -> Array: ...
|
||||
def astype(a: ArrayLike, dtype: DTypeLike | None, /, *, copy: builtins.bool = ..., device: _Device | _Sharding | None = ...) -> Array: ...
|
||||
def atan(x: ArrayLike, /) -> Array: ...
|
||||
def atan2(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
def atanh(x: ArrayLike, /) -> Array: ...
|
||||
@ -141,19 +142,19 @@ def atleast_3d(x: ArrayLike, /) -> Array: ...
|
||||
def atleast_3d(x: ArrayLike, y: ArrayLike, /, *arys: ArrayLike) -> list[Array]: ...
|
||||
|
||||
@overload
|
||||
def average(a: ArrayLike, axis: _Axis = ..., weights: Optional[ArrayLike] = ...,
|
||||
def average(a: ArrayLike, axis: _Axis = ..., weights: ArrayLike | None = ...,
|
||||
returned: Literal[False] = False, keepdims: builtins.bool = False) -> Array: ...
|
||||
@overload
|
||||
def average(a: ArrayLike, axis: _Axis = ..., weights: Optional[ArrayLike] = ..., *,
|
||||
def average(a: ArrayLike, axis: _Axis = ..., weights: ArrayLike | None = ..., *,
|
||||
returned: Literal[True], keepdims: builtins.bool = False) -> tuple[Array, Array]: ...
|
||||
@overload
|
||||
def average(a: ArrayLike, axis: _Axis = ..., weights: Optional[ArrayLike] = ...,
|
||||
returned: builtins.bool = False, keepdims: builtins.bool = False) -> Union[Array, tuple[Array, Array]]: ...
|
||||
def average(a: ArrayLike, axis: _Axis = ..., weights: ArrayLike | None = ...,
|
||||
returned: builtins.bool = False, keepdims: builtins.bool = False) -> Array | tuple[Array, Array]: ...
|
||||
|
||||
def bartlett(M: int) -> Array: ...
|
||||
bfloat16: Any
|
||||
def bincount(x: ArrayLike, weights: Optional[ArrayLike] = ...,
|
||||
minlength: int = ..., *, length: Optional[int] = ...) -> Array: ...
|
||||
def bincount(x: ArrayLike, weights: ArrayLike | None = ...,
|
||||
minlength: int = ..., *, length: int | None = ...) -> Array: ...
|
||||
def bitwise_and(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
def bitwise_count(x: ArrayLike, /) -> Array: ...
|
||||
def bitwise_invert(x: ArrayLike, /) -> Array: ...
|
||||
@ -163,7 +164,7 @@ def bitwise_or(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
def bitwise_right_shift(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
def bitwise_xor(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
def blackman(M: int) -> Array: ...
|
||||
def block(arrays: Union[ArrayLike, Sequence[ArrayLike], Sequence[Sequence[ArrayLike]]]) -> Array: ...
|
||||
def block(arrays: ArrayLike | Sequence[ArrayLike] | Sequence[Sequence[ArrayLike]]) -> Array: ...
|
||||
bool: Any
|
||||
bool_: Any
|
||||
def broadcast_arrays(*args: ArrayLike) -> list[Array]: ...
|
||||
@ -172,8 +173,8 @@ def broadcast_arrays(*args: ArrayLike) -> list[Array]: ...
|
||||
def broadcast_shapes(*shapes: Sequence[int]) -> tuple[int, ...]: ...
|
||||
|
||||
@overload
|
||||
def broadcast_shapes(*shapes: Sequence[Union[int, _core.Tracer]]
|
||||
) -> tuple[Union[int, _core.Tracer], ...]: ...
|
||||
def broadcast_shapes(*shapes: Sequence[int | _core.Tracer]
|
||||
) -> tuple[int | _core.Tracer, ...]: ...
|
||||
|
||||
def broadcast_to(array: ArrayLike, shape: DimSize | Shape) -> Array: ...
|
||||
c_: _CClass
|
||||
@ -187,53 +188,53 @@ def choose(a: ArrayLike, choices: Sequence[ArrayLike],
|
||||
def clip(
|
||||
x: ArrayLike | None = ...,
|
||||
/,
|
||||
min: Optional[ArrayLike] = ...,
|
||||
max: Optional[ArrayLike] = ...,
|
||||
min: ArrayLike | None = ...,
|
||||
max: ArrayLike | None = ...,
|
||||
a: ArrayLike | DeprecatedArg | None = ...,
|
||||
a_min: ArrayLike | DeprecatedArg | None = ...,
|
||||
a_max: ArrayLike | DeprecatedArg | None = ...
|
||||
) -> Array: ...
|
||||
def column_stack(
|
||||
tup: Union[_np.ndarray, Array, Sequence[ArrayLike]]
|
||||
tup: _np.ndarray | Array | Sequence[ArrayLike]
|
||||
) -> Array: ...
|
||||
complex128: Any
|
||||
complex64: Any
|
||||
complex_: Any
|
||||
complexfloating = _np.complexfloating
|
||||
def compress(condition: ArrayLike, a: ArrayLike, axis: Optional[int] = ...,
|
||||
def compress(condition: ArrayLike, a: ArrayLike, axis: int | None = ...,
|
||||
out: None = ...) -> Array: ...
|
||||
def concat(arrays: Sequence[ArrayLike], /, *, axis: int | None = 0) -> Array: ...
|
||||
def concatenate(
|
||||
arrays: Union[_np.ndarray, Array, Sequence[ArrayLike]],
|
||||
axis: Optional[int] = ...,
|
||||
dtype: Optional[DTypeLike] = ...,
|
||||
arrays: _np.ndarray | Array | Sequence[ArrayLike],
|
||||
axis: int | None = ...,
|
||||
dtype: DTypeLike | None = ...,
|
||||
) -> Array: ...
|
||||
def conjugate(x: ArrayLike, /) -> Array: ...
|
||||
conj = conjugate
|
||||
def convolve(a: ArrayLike, v: ArrayLike, mode: str = ..., *,
|
||||
precision: PrecisionLike = ...,
|
||||
preferred_element_type: Optional[DTypeLike] = ...) -> Array: ...
|
||||
def copy(a: ArrayLike, order: Optional[str] = ...) -> Array: ...
|
||||
preferred_element_type: DTypeLike | None = ...) -> Array: ...
|
||||
def copy(a: ArrayLike, order: str | None = ...) -> Array: ...
|
||||
def copysign(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
def corrcoef(x: ArrayLike, y: Optional[ArrayLike] = ..., rowvar: builtins.bool = ...) -> Array: ...
|
||||
def corrcoef(x: ArrayLike, y: ArrayLike | None = ..., rowvar: builtins.bool = ...) -> Array: ...
|
||||
def correlate(a: ArrayLike, v: ArrayLike, mode: str = ..., *,
|
||||
precision: PrecisionLike = ...,
|
||||
preferred_element_type: Optional[DTypeLike] = ...) -> Array: ...
|
||||
preferred_element_type: DTypeLike | None = ...) -> Array: ...
|
||||
def cos(x: ArrayLike, /) -> Array: ...
|
||||
def cosh(x: ArrayLike, /) -> Array: ...
|
||||
def count_nonzero(a: ArrayLike, axis: _Axis = ...,
|
||||
keepdims: builtins.bool = ...) -> Array: ...
|
||||
def cov(m: ArrayLike, y: Optional[ArrayLike] = ..., rowvar: builtins.bool = ...,
|
||||
bias: builtins.bool = ..., ddof: Optional[int] = ...,
|
||||
fweights: Optional[ArrayLike] = ...,
|
||||
aweights: Optional[ArrayLike] = ...) -> Array: ...
|
||||
def cov(m: ArrayLike, y: ArrayLike | None = ..., rowvar: builtins.bool = ...,
|
||||
bias: builtins.bool = ..., ddof: int | None = ...,
|
||||
fweights: ArrayLike | None = ...,
|
||||
aweights: ArrayLike | None = ...) -> Array: ...
|
||||
def cross(
|
||||
a: ArrayLike,
|
||||
b: ArrayLike,
|
||||
axisa: int = -1,
|
||||
axisb: int = -1,
|
||||
axisc: int = -1,
|
||||
axis: Optional[int] = ...,
|
||||
axis: int | None = ...,
|
||||
) -> Array: ...
|
||||
csingle: Any
|
||||
def cumprod(a: ArrayLike, axis: _Axis = ..., dtype: DTypeLike = ...,
|
||||
@ -249,8 +250,8 @@ def deg2rad(x: ArrayLike, /) -> Array: ...
|
||||
degrees = rad2deg
|
||||
def delete(
|
||||
arr: ArrayLike,
|
||||
obj: Union[ArrayLike, slice],
|
||||
axis: Optional[int] = ...,
|
||||
obj: ArrayLike | slice,
|
||||
axis: int | None = ...,
|
||||
*,
|
||||
assume_unique_indices: builtins.bool = ...,
|
||||
) -> Array: ...
|
||||
@ -262,33 +263,33 @@ def diagonal(
|
||||
a: ArrayLike, offset: ArrayLike = ..., axis1: int = ..., axis2: int = ...
|
||||
): ...
|
||||
def diff(a: ArrayLike, n: int = ..., axis: int = ...,
|
||||
prepend: Optional[ArrayLike] = ...,
|
||||
append: Optional[ArrayLike] = ...) -> Array: ...
|
||||
prepend: ArrayLike | None = ...,
|
||||
append: ArrayLike | None = ...) -> Array: ...
|
||||
def digitize(x: ArrayLike, bins: ArrayLike, right: builtins.bool = ...) -> Array: ...
|
||||
divide = true_divide
|
||||
def divmod(x: ArrayLike, y: ArrayLike, /) -> tuple[Array, Array]: ...
|
||||
def dot(
|
||||
a: ArrayLike, b: ArrayLike, *, precision: PrecisionLike = ...,
|
||||
preferred_element_type: Optional[DTypeLike] = ...) -> Array: ...
|
||||
preferred_element_type: DTypeLike | None = ...) -> Array: ...
|
||||
double: Any
|
||||
def dsplit(
|
||||
ary: ArrayLike, indices_or_sections: Union[int, ArrayLike]
|
||||
ary: ArrayLike, indices_or_sections: int | ArrayLike
|
||||
) -> list[Array]: ...
|
||||
|
||||
def dstack(tup: Union[_np.ndarray, Array, Sequence[ArrayLike]],
|
||||
dtype: Optional[DTypeLike] = ...) -> Array: ...
|
||||
def dstack(tup: _np.ndarray | Array | Sequence[ArrayLike],
|
||||
dtype: DTypeLike | None = ...) -> Array: ...
|
||||
dtype = _np.dtype
|
||||
e: float
|
||||
def ediff1d(ary: ArrayLike, to_end: Optional[ArrayLike] = ...,
|
||||
to_begin: Optional[ArrayLike] = ...) -> Array: ...
|
||||
def ediff1d(ary: ArrayLike, to_end: ArrayLike | None = ...,
|
||||
to_begin: ArrayLike | None = ...) -> Array: ...
|
||||
@overload
|
||||
def einsum(
|
||||
subscript: str, /,
|
||||
*operands: ArrayLike,
|
||||
out: None = ...,
|
||||
optimize: Union[str, builtins.bool, list[tuple[int, ...]]] = ...,
|
||||
optimize: str | builtins.bool | list[tuple[int, ...]] = ...,
|
||||
precision: PrecisionLike = ...,
|
||||
preferred_element_type: Optional[DTypeLike] = ...,
|
||||
preferred_element_type: DTypeLike | None = ...,
|
||||
_use_xeinsum: builtins.bool = False,
|
||||
_dot_general: Callable[..., Array] = ...,
|
||||
) -> Array: ...
|
||||
@ -297,11 +298,11 @@ def einsum(
|
||||
def einsum(
|
||||
arr: ArrayLike,
|
||||
axes: Sequence[Any], /,
|
||||
*operands: Union[ArrayLike, Sequence[Any]],
|
||||
*operands: ArrayLike | Sequence[Any],
|
||||
out: None = ...,
|
||||
optimize: Union[str, builtins.bool, list[tuple[int, ...]]] = ...,
|
||||
optimize: str | builtins.bool | list[tuple[int, ...]] = ...,
|
||||
precision: PrecisionLike = ...,
|
||||
preferred_element_type: Optional[DTypeLike] = ...,
|
||||
preferred_element_type: DTypeLike | None = ...,
|
||||
_use_xeinsum: builtins.bool = False,
|
||||
_dot_general: Callable[..., Array] = ...,
|
||||
) -> Array: ...
|
||||
@ -310,9 +311,9 @@ def einsum(
|
||||
subscripts, /,
|
||||
*operands,
|
||||
out: None = ...,
|
||||
optimize: Union[str, builtins.bool, list[tuple[int, ...]]] = ...,
|
||||
optimize: str | builtins.bool | list[tuple[int, ...]] = ...,
|
||||
precision: PrecisionLike = ...,
|
||||
preferred_element_type: Optional[DTypeLike] = ...,
|
||||
preferred_element_type: DTypeLike | None = ...,
|
||||
_use_xeinsum: builtins.bool = ...,
|
||||
_dot_general: Callable[..., Array] = ...,
|
||||
) -> Array: ...
|
||||
@ -321,50 +322,50 @@ def einsum(
|
||||
def einsum_path(
|
||||
subscripts: str, /,
|
||||
*operands: ArrayLike,
|
||||
optimize: Union[str, builtins.bool, list[tuple[int, ...]]] = ...,
|
||||
optimize: str | builtins.bool | list[tuple[int, ...]] = ...,
|
||||
) -> tuple[list[tuple[int, ...]], Any]: ...
|
||||
@overload
|
||||
def einsum_path(
|
||||
arr: ArrayLike,
|
||||
axes: Sequence[Any], /,
|
||||
*operands: Union[ArrayLike, Sequence[Any]],
|
||||
optimize: Union[str, builtins.bool, list[tuple[int, ...]]] = ...,
|
||||
*operands: ArrayLike | Sequence[Any],
|
||||
optimize: str | builtins.bool | list[tuple[int, ...]] = ...,
|
||||
) -> tuple[list[tuple[int, ...]], Any]: ...
|
||||
@overload
|
||||
def einsum_path(
|
||||
subscripts, /,
|
||||
*operands: ArrayLike,
|
||||
optimize: Union[str, builtins.bool, list[tuple[int, ...]]] = ...,
|
||||
optimize: str | builtins.bool | list[tuple[int, ...]] = ...,
|
||||
) -> tuple[list[tuple[int, ...]], Any]: ...
|
||||
|
||||
def empty(shape: Any, dtype: Optional[DTypeLike] = ...,
|
||||
device: Optional[Union[_Device, _Sharding]] = ...) -> Array: ...
|
||||
def empty_like(prototype: Union[ArrayLike, DuckTypedArray],
|
||||
dtype: Optional[DTypeLike] = ...,
|
||||
def empty(shape: Any, dtype: DTypeLike | None = ...,
|
||||
device: _Device | _Sharding | None = ...) -> Array: ...
|
||||
def empty_like(prototype: ArrayLike | DuckTypedArray,
|
||||
dtype: DTypeLike | None = ...,
|
||||
shape: Any = ..., *,
|
||||
device: Optional[Union[_Device, _Sharding]] = ...) -> Array: ...
|
||||
device: _Device | _Sharding | None = ...) -> Array: ...
|
||||
def equal(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
euler_gamma: float
|
||||
def exp(x: ArrayLike, /) -> Array: ...
|
||||
def exp2(x: ArrayLike, /) -> Array: ...
|
||||
def expand_dims(a: ArrayLike, axis: Union[int, Sequence[int]]) -> Array: ...
|
||||
def expand_dims(a: ArrayLike, axis: int | Sequence[int]) -> Array: ...
|
||||
def expm1(x: ArrayLike, /) -> Array: ...
|
||||
def extract(condition: ArrayLike, arr: ArrayLike, *,
|
||||
size: int | None = None, fill_value: ArrayLike = 0) -> Array: ...
|
||||
def eye(N: DimSize, M: Optional[DimSize] = ..., k: int | ArrayLike = ...,
|
||||
dtype: Optional[DTypeLike] = ...) -> Array: ...
|
||||
def eye(N: DimSize, M: DimSize | None = ..., k: int | ArrayLike = ...,
|
||||
dtype: DTypeLike | None = ...) -> Array: ...
|
||||
def fabs(x: ArrayLike, /) -> Array: ...
|
||||
finfo = _dtypes.finfo
|
||||
def fix(x: ArrayLike, out: None = ...) -> Array: ...
|
||||
def flatnonzero(
|
||||
a: ArrayLike,
|
||||
*,
|
||||
size: Optional[int] = ...,
|
||||
fill_value: Union[None, ArrayLike, tuple[ArrayLike]] = ...,
|
||||
size: int | None = ...,
|
||||
fill_value: None | ArrayLike | tuple[ArrayLike] = ...,
|
||||
) -> Array: ...
|
||||
flexible = _np.flexible
|
||||
def flip(
|
||||
m: ArrayLike, axis: Optional[Union[int, Sequence[int]]] = ...
|
||||
m: ArrayLike, axis: int | Sequence[int] | None = ...
|
||||
) -> Array: ...
|
||||
|
||||
def fliplr(m: ArrayLike) -> Array: ...
|
||||
@ -388,7 +389,7 @@ def fmod(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
def frexp(x: ArrayLike, /) -> tuple[Array, Array]: ...
|
||||
def from_dlpack(x: Any, /, *, device: _Device | _Sharding | None = None,
|
||||
copy: builtins.bool | None = None) -> Array: ...
|
||||
def frombuffer(buffer: Union[bytes, Any], dtype: DTypeLike = ...,
|
||||
def frombuffer(buffer: bytes | Any, dtype: DTypeLike = ...,
|
||||
count: int = ..., offset: int = ...) -> Array: ...
|
||||
def fromfile(*args, **kwargs): ...
|
||||
def fromfunction(function: Callable[..., Array], shape: Any,
|
||||
@ -398,12 +399,12 @@ def fromstring(
|
||||
string: str, dtype: DTypeLike = ..., count: int = ..., *, sep: str
|
||||
) -> Array: ...
|
||||
def full(shape: Any, fill_value: ArrayLike,
|
||||
dtype: Optional[DTypeLike] = ..., *,
|
||||
device: Optional[Union[_Device, _Sharding]] = ...) -> Array: ...
|
||||
def full_like(a: Union[ArrayLike, DuckTypedArray],
|
||||
fill_value: ArrayLike, dtype: Optional[DTypeLike] = ...,
|
||||
dtype: DTypeLike | None = ..., *,
|
||||
device: _Device | _Sharding | None = ...) -> Array: ...
|
||||
def full_like(a: ArrayLike | DuckTypedArray,
|
||||
fill_value: ArrayLike, dtype: DTypeLike | None = ...,
|
||||
shape: Any = ..., *,
|
||||
device: Optional[Union[_Device, _Sharding]] = ...) -> Array: ...
|
||||
device: _Device | _Sharding | None = ...) -> Array: ...
|
||||
def gcd(x1: ArrayLike, x2: ArrayLike) -> Array: ...
|
||||
generic = _np.generic
|
||||
def geomspace(
|
||||
@ -411,48 +412,48 @@ def geomspace(
|
||||
stop: ArrayLike,
|
||||
num: int = ...,
|
||||
endpoint: builtins.bool = ...,
|
||||
dtype: Optional[DTypeLike] = ...,
|
||||
dtype: DTypeLike | None = ...,
|
||||
axis: int = ...,
|
||||
) -> Array: ...
|
||||
get_printoptions = _np.get_printoptions
|
||||
def gradient(f: ArrayLike, *varargs: ArrayLike,
|
||||
axis: Optional[Union[int, Sequence[int]]] = ...,
|
||||
edge_order: Optional[int] = ...) -> Union[Array, list[Array]]: ...
|
||||
axis: int | Sequence[int] | None = ...,
|
||||
edge_order: int | None = ...) -> Array | list[Array]: ...
|
||||
def greater(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
def greater_equal(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
def hamming(M: int) -> Array: ...
|
||||
def hanning(M: int) -> Array: ...
|
||||
def heaviside(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
def histogram(a: ArrayLike, bins: ArrayLike = ...,
|
||||
range: Optional[Sequence[ArrayLike]] = ...,
|
||||
weights: Optional[ArrayLike] = ...,
|
||||
density: Optional[builtins.bool] = ...) -> tuple[Array, Array]: ...
|
||||
range: Sequence[ArrayLike] | None = ...,
|
||||
weights: ArrayLike | None = ...,
|
||||
density: builtins.bool | None = ...) -> tuple[Array, Array]: ...
|
||||
def histogram2d(
|
||||
x: ArrayLike,
|
||||
y: ArrayLike,
|
||||
bins: Union[ArrayLike, Sequence[ArrayLike]] = ...,
|
||||
range: Optional[Sequence[Union[None, Array, Sequence[ArrayLike]]]] = ...,
|
||||
weights: Optional[ArrayLike] = ...,
|
||||
density: Optional[builtins.bool] = ...,
|
||||
bins: ArrayLike | Sequence[ArrayLike] = ...,
|
||||
range: Sequence[None | Array | Sequence[ArrayLike]] | None = ...,
|
||||
weights: ArrayLike | None = ...,
|
||||
density: builtins.bool | None = ...,
|
||||
) -> tuple[Array, Array, Array]: ...
|
||||
def histogram_bin_edges(a: ArrayLike, bins: ArrayLike = ...,
|
||||
range: Union[None, Array, Sequence[ArrayLike]] = ...,
|
||||
weights: Optional[ArrayLike] = ...) -> Array: ...
|
||||
range: None | Array | Sequence[ArrayLike] = ...,
|
||||
weights: ArrayLike | None = ...) -> Array: ...
|
||||
def histogramdd(
|
||||
sample: ArrayLike,
|
||||
bins: Union[ArrayLike, Sequence[ArrayLike]] = ...,
|
||||
range: Optional[Sequence[Union[None, Array, Sequence[ArrayLike]]]] = ...,
|
||||
weights: Optional[ArrayLike] = ...,
|
||||
density: Optional[builtins.bool] = ...,
|
||||
bins: ArrayLike | Sequence[ArrayLike] = ...,
|
||||
range: Sequence[None | Array | Sequence[ArrayLike]] | None = ...,
|
||||
weights: ArrayLike | None = ...,
|
||||
density: builtins.bool | None = ...,
|
||||
) -> tuple[Array, list[Array]]: ...
|
||||
def hsplit(
|
||||
ary: ArrayLike, indices_or_sections: Union[int, ArrayLike]
|
||||
ary: ArrayLike, indices_or_sections: int | ArrayLike
|
||||
) -> list[Array]: ...
|
||||
def hstack(tup: Union[_np.ndarray, Array, Sequence[ArrayLike]],
|
||||
dtype: Optional[DTypeLike] = ...) -> Array: ...
|
||||
def hstack(tup: _np.ndarray | Array | Sequence[ArrayLike],
|
||||
dtype: DTypeLike | None = ...) -> Array: ...
|
||||
def hypot(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
def i0(x: ArrayLike) -> Array: ...
|
||||
def identity(n: DimSize, dtype: Optional[DTypeLike] = ...) -> Array: ...
|
||||
def identity(n: DimSize, dtype: DTypeLike | None = ...) -> Array: ...
|
||||
iinfo = _dtypes.iinfo
|
||||
def imag(x: ArrayLike, /) -> Array: ...
|
||||
index_exp = _np.index_exp
|
||||
@ -465,15 +466,15 @@ def indices(dimensions: Sequence[int], dtype: DTypeLike = int32,
|
||||
*, sparse: Literal[True]) -> tuple[Array, ...]: ...
|
||||
@overload
|
||||
def indices(dimensions: Sequence[int], dtype: DTypeLike = int32,
|
||||
sparse: builtins.bool = False) -> Union[Array, tuple[Array, ...]]: ...
|
||||
sparse: builtins.bool = False) -> Array | tuple[Array, ...]: ...
|
||||
|
||||
inexact = _np.inexact
|
||||
inf: float
|
||||
def inner(
|
||||
a: ArrayLike, b: ArrayLike, *, precision: PrecisionLike = ...,
|
||||
preferred_element_type: Optional[DTypeLike] = ...) -> Array: ...
|
||||
def insert(arr: ArrayLike, obj: Union[ArrayLike, slice], values: ArrayLike,
|
||||
axis: Optional[int] = ...) -> Array: ...
|
||||
preferred_element_type: DTypeLike | None = ...) -> Array: ...
|
||||
def insert(arr: ArrayLike, obj: ArrayLike | slice, values: ArrayLike,
|
||||
axis: int | None = ...) -> Array: ...
|
||||
int16: Any
|
||||
int32: Any
|
||||
int4: Any
|
||||
@ -482,17 +483,17 @@ int8: Any
|
||||
int_: Any
|
||||
integer = _np.integer
|
||||
def interp(x: ArrayLike, xp: ArrayLike, fp: ArrayLike,
|
||||
left: Union[ArrayLike, str, None] = ...,
|
||||
right: Union[ArrayLike, str, None] = ...,
|
||||
period: Optional[ArrayLike] = ...) -> Array: ...
|
||||
left: ArrayLike | str | None = ...,
|
||||
right: ArrayLike | str | None = ...,
|
||||
period: ArrayLike | None = ...) -> Array: ...
|
||||
def intersect1d(ar1: ArrayLike, ar2: ArrayLike, assume_unique: builtins.bool = ...,
|
||||
return_indices: builtins.bool = ...) -> Union[Array, tuple[Array, Array, Array]]: ...
|
||||
return_indices: builtins.bool = ...) -> Array | tuple[Array, Array, Array]: ...
|
||||
def invert(x: ArrayLike, /) -> Array: ...
|
||||
def isclose(a: ArrayLike, b: ArrayLike, rtol: ArrayLike = ...,
|
||||
atol: ArrayLike = ..., equal_nan: builtins.bool = ...) -> Array: ...
|
||||
def iscomplex(m: ArrayLike) -> Array: ...
|
||||
def iscomplexobj(x: Any) -> builtins.bool: ...
|
||||
def isdtype(dtype: DTypeLike, kind: Union[DType, str, tuple[Union[DType, str], ...]]) -> builtins.bool: ...
|
||||
def isdtype(dtype: DTypeLike, kind: DType | str | tuple[DType | str, ...]) -> builtins.bool: ...
|
||||
def isfinite(x: ArrayLike, /) -> Array: ...
|
||||
def isin(element: ArrayLike, test_elements: ArrayLike,
|
||||
assume_unique: builtins.bool = ..., invert: builtins.bool = ...) -> Array: ...
|
||||
@ -518,23 +519,23 @@ def lexsort(keys: Sequence[ArrayLike], axis: int = ...) -> Array: ...
|
||||
@overload
|
||||
def linspace(start: ArrayLike, stop: ArrayLike, num: int = 50,
|
||||
endpoint: builtins.bool = True, retstep: Literal[False] = False,
|
||||
dtype: Optional[DTypeLike] = ...,
|
||||
dtype: DTypeLike | None = ...,
|
||||
axis: int = 0) -> Array: ...
|
||||
@overload
|
||||
def linspace(start: ArrayLike, stop: ArrayLike, num: int,
|
||||
endpoint: builtins.bool, retstep: Literal[True],
|
||||
dtype: Optional[DTypeLike] = ...,
|
||||
dtype: DTypeLike | None = ...,
|
||||
axis: int = 0) -> tuple[Array, Array]: ...
|
||||
@overload
|
||||
def linspace(start: ArrayLike, stop: ArrayLike, num: int = 50,
|
||||
endpoint: builtins.bool = True, *, retstep: Literal[True],
|
||||
dtype: Optional[DTypeLike] = ...,
|
||||
dtype: DTypeLike | None = ...,
|
||||
axis: int = 0) -> tuple[Array, Array]: ...
|
||||
@overload
|
||||
def linspace(start: ArrayLike, stop: ArrayLike, num: int = 50,
|
||||
endpoint: builtins.bool = True, retstep: builtins.bool = False,
|
||||
dtype: Optional[DTypeLike] = ...,
|
||||
axis: int = 0) -> Union[Array, tuple[Array, Array]]: ...
|
||||
dtype: DTypeLike | None = ...,
|
||||
axis: int = 0) -> Array | tuple[Array, Array]: ...
|
||||
|
||||
def load(*args: Any, **kwargs: Any) -> Array: ...
|
||||
def log(x: ArrayLike, /) -> Array: ...
|
||||
@ -549,20 +550,20 @@ def logical_or(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
def logical_xor(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
def logspace(start: ArrayLike, stop: ArrayLike, num: int = ...,
|
||||
endpoint: builtins.bool = ..., base: ArrayLike = ...,
|
||||
dtype: Optional[DTypeLike] = ..., axis: int = ...) -> Array: ...
|
||||
dtype: DTypeLike | None = ..., axis: int = ...) -> Array: ...
|
||||
def mask_indices(
|
||||
n: int, mask_func: Callable, k: int = ...
|
||||
) -> tuple[Array, ...]: ...
|
||||
def matmul(
|
||||
a: ArrayLike, b: ArrayLike, *, precision: PrecisionLike = ...,
|
||||
preferred_element_type: Optional[DTypeLike] = ...) -> Array: ...
|
||||
preferred_element_type: DTypeLike | None = ...) -> Array: ...
|
||||
def matrix_transpose(x: ArrayLike, /) -> Array: ...
|
||||
max = amax
|
||||
def maximum(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
def mean(a: ArrayLike, axis: _Axis = ..., dtype: DTypeLike = ...,
|
||||
out: None = ..., keepdims: builtins.bool = ..., *,
|
||||
where: Optional[ArrayLike] = ...) -> Array: ...
|
||||
def median(a: ArrayLike, axis: Optional[Union[int, tuple[int, ...]]] = ...,
|
||||
where: ArrayLike | None = ...) -> Array: ...
|
||||
def median(a: ArrayLike, axis: int | tuple[int, ...] | None = ...,
|
||||
out: None = ..., overwrite_input: builtins.bool = ...,
|
||||
keepdims: builtins.bool = ...) -> Array: ...
|
||||
def meshgrid(*xi: ArrayLike, copy: builtins.bool = ..., sparse: builtins.bool = ...,
|
||||
@ -572,100 +573,100 @@ min = amin
|
||||
def minimum(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
def mod(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
def modf(x: ArrayLike, /, out=None) -> tuple[Array, Array]: ...
|
||||
def moveaxis(a: ArrayLike, source: Union[int, Sequence[int]],
|
||||
destination: Union[int, Sequence[int]]) -> Array: ...
|
||||
def moveaxis(a: ArrayLike, source: int | Sequence[int],
|
||||
destination: int | Sequence[int]) -> Array: ...
|
||||
def multiply(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
nan: float
|
||||
def nan_to_num(x: ArrayLike, copy: builtins.bool = ..., nan: ArrayLike = ...,
|
||||
posinf: Optional[ArrayLike] = ...,
|
||||
neginf: Optional[ArrayLike] = ...) -> Array: ...
|
||||
posinf: ArrayLike | None = ...,
|
||||
neginf: ArrayLike | None = ...) -> Array: ...
|
||||
def nanargmax(
|
||||
a: ArrayLike,
|
||||
axis: Optional[int] = ...,
|
||||
axis: int | None = ...,
|
||||
out: None = ...,
|
||||
keepdims: Optional[builtins.bool] = ...,
|
||||
keepdims: builtins.bool | None = ...,
|
||||
) -> Array: ...
|
||||
def nanargmin(
|
||||
a: ArrayLike,
|
||||
axis: Optional[int] = ...,
|
||||
axis: int | None = ...,
|
||||
out: None = ...,
|
||||
keepdims: Optional[builtins.bool] = ...,
|
||||
keepdims: builtins.bool | None = ...,
|
||||
) -> Array: ...
|
||||
def nancumprod(a: ArrayLike, axis: _Axis = ..., dtype: DTypeLike = ...,
|
||||
out: None = ...) -> Array: ...
|
||||
def nancumsum(a: ArrayLike, axis: _Axis = ..., dtype: DTypeLike = ...,
|
||||
out: None = ...) -> Array: ...
|
||||
def nanmax(a: ArrayLike, axis: _Axis = ..., out: None = ...,
|
||||
keepdims: builtins.bool = ..., initial: Optional[ArrayLike] = ...,
|
||||
where: Optional[ArrayLike] = ...) -> Array: ...
|
||||
keepdims: builtins.bool = ..., initial: ArrayLike | None = ...,
|
||||
where: ArrayLike | None = ...) -> Array: ...
|
||||
def nanmean(a: ArrayLike, axis: _Axis = ..., dtype: DTypeLike = ...,
|
||||
out: None = ...,
|
||||
keepdims: builtins.bool = ...,
|
||||
where: Optional[ArrayLike] = ...) -> Array: ...
|
||||
def nanmedian(a: ArrayLike, axis: Optional[Union[int, tuple[int, ...]]] = ...,
|
||||
where: ArrayLike | None = ...) -> Array: ...
|
||||
def nanmedian(a: ArrayLike, axis: int | tuple[int, ...] | None = ...,
|
||||
out: None = ..., overwrite_input: builtins.bool = ...,
|
||||
keepdims: builtins.bool = ...) -> Array: ...
|
||||
def nanmin(a: ArrayLike, axis: _Axis = ..., out: None = ...,
|
||||
keepdims: builtins.bool = ..., initial: Optional[ArrayLike] = ...,
|
||||
where: Optional[ArrayLike] = ...) -> Array: ...
|
||||
keepdims: builtins.bool = ..., initial: ArrayLike | None = ...,
|
||||
where: ArrayLike | None = ...) -> Array: ...
|
||||
def nanpercentile(a: ArrayLike, q: ArrayLike,
|
||||
axis: Optional[Union[int, tuple[int, ...]]] = ...,
|
||||
axis: int | tuple[int, ...] | None = ...,
|
||||
out: None = ..., overwrite_input: builtins.bool = ..., method: str = ...,
|
||||
keepdims: builtins.bool = ..., *, interpolation: DeprecatedArg | str = ...) -> Array: ...
|
||||
def nanprod(a: ArrayLike, axis: _Axis = ..., dtype: DTypeLike = ...,
|
||||
out: None = ...,
|
||||
keepdims: builtins.bool = ..., initial: Optional[ArrayLike] = ...,
|
||||
where: Optional[ArrayLike] = ...) -> Array: ...
|
||||
def nanquantile(a: ArrayLike, q: ArrayLike, axis: Optional[Union[int, tuple[int, ...]]] = ...,
|
||||
keepdims: builtins.bool = ..., initial: ArrayLike | None = ...,
|
||||
where: ArrayLike | None = ...) -> Array: ...
|
||||
def nanquantile(a: ArrayLike, q: ArrayLike, axis: int | tuple[int, ...] | None = ...,
|
||||
out: None = ..., overwrite_input: builtins.bool = ..., method: str = ...,
|
||||
keepdims: builtins.bool = ..., *, interpolation: DeprecatedArg | str = ...) -> Array: ...
|
||||
def nanstd(a: ArrayLike, axis: _Axis = ..., dtype: DTypeLike = ..., out: None = ...,
|
||||
ddof: int = ..., keepdims: builtins.bool = ...,
|
||||
where: Optional[ArrayLike] = ...) -> Array: ...
|
||||
where: ArrayLike | None = ...) -> Array: ...
|
||||
def nansum(a: ArrayLike, axis: _Axis = ..., dtype: DTypeLike = ...,
|
||||
out: None = ..., keepdims: builtins.bool = ...,
|
||||
initial: Optional[ArrayLike] = ...,
|
||||
where: Optional[ArrayLike] = ...) -> Array: ...
|
||||
initial: ArrayLike | None = ...,
|
||||
where: ArrayLike | None = ...) -> Array: ...
|
||||
def nanvar(a: ArrayLike, axis: _Axis = ..., dtype: DTypeLike = ...,
|
||||
out: None = ...,
|
||||
ddof: int = 0, keepdims: builtins.bool = False,
|
||||
where: Optional[ArrayLike] = ...) -> Array: ...
|
||||
where: ArrayLike | None = ...) -> Array: ...
|
||||
ndarray = Array
|
||||
ndim = _np.ndim
|
||||
def negative(x: ArrayLike, /) -> Array: ...
|
||||
newaxis = ...
|
||||
def nextafter(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
def nonzero(a: ArrayLike, *, size: Optional[int] = ...,
|
||||
fill_value: Union[None, ArrayLike, tuple[ArrayLike, ...]] = ...
|
||||
def nonzero(a: ArrayLike, *, size: int | None = ...,
|
||||
fill_value: None | ArrayLike | tuple[ArrayLike, ...] = ...
|
||||
) -> tuple[Array, ...]: ...
|
||||
def not_equal(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
number = _np.number
|
||||
object_ = _np.object_
|
||||
ogrid: _Ogrid
|
||||
def ones(shape: Any, dtype: Optional[DTypeLike] = ...,
|
||||
device: Optional[Union[_Device, _Sharding]] = ...) -> Array: ...
|
||||
def ones_like(a: Union[ArrayLike, DuckTypedArray],
|
||||
dtype: Optional[DTypeLike] = ...,
|
||||
def ones(shape: Any, dtype: DTypeLike | None = ...,
|
||||
device: _Device | _Sharding | None = ...) -> Array: ...
|
||||
def ones_like(a: ArrayLike | DuckTypedArray,
|
||||
dtype: DTypeLike | None = ...,
|
||||
shape: Any = ..., *,
|
||||
device: Optional[Union[_Device, _Sharding]] = ...) -> Array: ...
|
||||
device: _Device | _Sharding | None = ...) -> Array: ...
|
||||
def outer(a: ArrayLike, b: Array, out: None = ...) -> Array: ...
|
||||
def packbits(
|
||||
a: ArrayLike, axis: Optional[int] = ..., bitorder: str = ...
|
||||
a: ArrayLike, axis: int | None = ..., bitorder: str = ...
|
||||
) -> Array: ...
|
||||
|
||||
PadValueLike = Union[_T, Sequence[_T], Sequence[Sequence[_T]]]
|
||||
def pad(array: ArrayLike, pad_width: PadValueLike[int | Array | _np.ndarray],
|
||||
mode: Union[str, Callable[..., Any]] = ..., **kwargs) -> Array: ...
|
||||
mode: str | Callable[..., Any] = ..., **kwargs) -> Array: ...
|
||||
|
||||
def partition(a: ArrayLike, kth: int, axis: int = ...) -> Array: ...
|
||||
def percentile(a: ArrayLike, q: ArrayLike,
|
||||
axis: Optional[Union[int, tuple[int, ...]]] = ...,
|
||||
axis: int | tuple[int, ...] | None = ...,
|
||||
out: None = ..., overwrite_input: builtins.bool = ..., method: str = ...,
|
||||
keepdims: builtins.bool = ..., *, interpolation: DeprecatedArg | str = ...) -> Array: ...
|
||||
def permute_dims(x: ArrayLike, /, axes: tuple[int, ...]) -> Array: ...
|
||||
pi: float
|
||||
def piecewise(x: ArrayLike, condlist: Union[Array, Sequence[ArrayLike]],
|
||||
funclist: Sequence[Union[ArrayLike, Callable[..., Array]]],
|
||||
def piecewise(x: ArrayLike, condlist: Array | Sequence[ArrayLike],
|
||||
funclist: Sequence[ArrayLike | Callable[..., Array]],
|
||||
*args, **kw) -> Array: ...
|
||||
def place(arr: ArrayLike, mask: ArrayLike, vals: ArrayLike, *,
|
||||
inplace: builtins.bool = ...) -> Array: ...
|
||||
@ -673,10 +674,10 @@ def poly(seq_of_zeros: ArrayLike) -> Array: ...
|
||||
def polyadd(a1: ArrayLike, a2: ArrayLike) -> Array: ...
|
||||
def polyder(p: ArrayLike, m: int = ...) -> Array: ...
|
||||
def polydiv(u: ArrayLike, v: ArrayLike, *, trim_leading_zeros: builtins.bool = ...) -> tuple[Array, Array]: ...
|
||||
def polyfit(x: ArrayLike, y: ArrayLike, deg: int, rcond: Optional[float] = ...,
|
||||
full: builtins.bool = ..., w: Optional[ArrayLike] = ..., cov: builtins.bool = ...
|
||||
) -> Union[Array, tuple[Array, ...]]: ...
|
||||
def polyint(p: ArrayLike, m: int = ..., k: Union[int, ArrayLike, None] = ...) -> Array: ...
|
||||
def polyfit(x: ArrayLike, y: ArrayLike, deg: int, rcond: float | None = ...,
|
||||
full: builtins.bool = ..., w: ArrayLike | None = ..., cov: builtins.bool = ...
|
||||
) -> Array | tuple[Array, ...]: ...
|
||||
def polyint(p: ArrayLike, m: int = ..., k: int | ArrayLike | None = ...) -> Array: ...
|
||||
def polymul(a1: ArrayLike, a2: ArrayLike, *, trim_leading_zeros: builtins.bool = ...) -> Array: ...
|
||||
def polysub(a1: ArrayLike, a2: ArrayLike) -> Array: ...
|
||||
def polyval(p: ArrayLike, x: ArrayLike, *, unroll: int = ...) -> Array: ...
|
||||
@ -686,7 +687,7 @@ def power(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
printoptions = _np.printoptions
|
||||
def prod(a: ArrayLike, axis: _Axis = ..., dtype: DTypeLike = ...,
|
||||
out: None = ..., keepdims: builtins.bool = ...,
|
||||
initial: Optional[ArrayLike] = ..., where: Optional[ArrayLike] = ...,
|
||||
initial: ArrayLike | None = ..., where: ArrayLike | None = ...,
|
||||
promote_integers: builtins.bool = ...) -> Array: ...
|
||||
product = prod
|
||||
promote_types = _np.promote_types
|
||||
@ -694,7 +695,7 @@ def ptp(a: ArrayLike, axis: _Axis = ..., out: None = ...,
|
||||
keepdims: builtins.bool = ...) -> Array: ...
|
||||
def put(a: ArrayLike, ind: ArrayLike, v: ArrayLike,
|
||||
mode: str | None = ..., *, inplace: builtins.bool = ...) -> Array: ...
|
||||
def quantile(a: ArrayLike, q: ArrayLike, axis: Optional[Union[int, tuple[int, ...]]] = ...,
|
||||
def quantile(a: ArrayLike, q: ArrayLike, axis: int | tuple[int, ...] | None = ...,
|
||||
out: None = ..., overwrite_input: builtins.bool = ..., method: str = ...,
|
||||
keepdims: builtins.bool = ..., *, interpolation: DeprecatedArg | str = ...) -> Array: ...
|
||||
r_: _RClass
|
||||
@ -707,19 +708,19 @@ def real(x: ArrayLike, /) -> Array: ...
|
||||
def reciprocal(x: ArrayLike, /) -> Array: ...
|
||||
register_jax_array_methods: Any
|
||||
def remainder(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
def repeat(a: ArrayLike, repeats: ArrayLike, axis: Optional[int] = ..., *,
|
||||
total_repeat_length: Optional[int] = ...) -> Array: ...
|
||||
def repeat(a: ArrayLike, repeats: ArrayLike, axis: int | None = ..., *,
|
||||
total_repeat_length: int | None = ...) -> Array: ...
|
||||
def reshape(
|
||||
a: ArrayLike, shape: Union[DimSize, Shape] = ...,
|
||||
newshape: Union[DimSize, Shape] | None = ..., order: str = ...
|
||||
a: ArrayLike, shape: DimSize | Shape = ...,
|
||||
newshape: DimSize | Shape | None = ..., order: str = ...
|
||||
) -> Array: ...
|
||||
|
||||
def resize(a: ArrayLike, new_shape: Shape) -> Array: ...
|
||||
def result_type(*args: Any) -> DType: ...
|
||||
def right_shift(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
def rint(x: ArrayLike, /) -> Array: ...
|
||||
def roll(a: ArrayLike, shift: Union[ArrayLike, Sequence[int]],
|
||||
axis: Optional[Union[int, Sequence[int]]] = ...) -> Array: ...
|
||||
def roll(a: ArrayLike, shift: ArrayLike | Sequence[int],
|
||||
axis: int | Sequence[int] | None = ...) -> Array: ...
|
||||
def rollaxis(a: ArrayLike, axis: int, start: int = 0) -> Array: ...
|
||||
def roots(p: ArrayLike, *, strip_zeros: builtins.bool = ...) -> Array: ...
|
||||
def rot90(m: ArrayLike, k: int = ..., axes: tuple[int, int] = ...) -> Array: ...
|
||||
@ -741,8 +742,8 @@ def setdiff1d(
|
||||
ar2: ArrayLike,
|
||||
assume_unique: builtins.bool = ...,
|
||||
*,
|
||||
size: Optional[int] = ...,
|
||||
fill_value: Optional[ArrayLike] = ...,
|
||||
size: int | None = ...,
|
||||
fill_value: ArrayLike | None = ...,
|
||||
) -> Array: ...
|
||||
def setxor1d(ar1: ArrayLike, ar2: ArrayLike, assume_unique: builtins.bool = ...) -> Array: ...
|
||||
shape = _np.shape
|
||||
@ -757,7 +758,7 @@ size = _np.size
|
||||
sometrue = any
|
||||
def sort(
|
||||
a: ArrayLike,
|
||||
axis: Optional[int] = ...,
|
||||
axis: int | None = ...,
|
||||
*,
|
||||
stable: builtins.bool = ...,
|
||||
descending: builtins.bool = ...,
|
||||
@ -767,24 +768,24 @@ def sort(
|
||||
def sort_complex(a: ArrayLike) -> Array: ...
|
||||
def split(
|
||||
ary: ArrayLike,
|
||||
indices_or_sections: Union[int, Sequence[int], ArrayLike],
|
||||
indices_or_sections: int | Sequence[int] | ArrayLike,
|
||||
axis: int = ...,
|
||||
) -> list[Array]: ...
|
||||
|
||||
def sqrt(x: ArrayLike, /) -> Array: ...
|
||||
def square(x: ArrayLike, /) -> Array: ...
|
||||
def squeeze(
|
||||
a: ArrayLike, axis: Optional[Union[int, Sequence[int]]] = ...
|
||||
a: ArrayLike, axis: int | Sequence[int] | None = ...
|
||||
) -> Array: ...
|
||||
def stack(
|
||||
arrays: Union[_np.ndarray, Array, Sequence[ArrayLike]],
|
||||
arrays: _np.ndarray | Array | Sequence[ArrayLike],
|
||||
axis: int = ...,
|
||||
out: None = ...,
|
||||
dtype: Optional[DTypeLike] = ...,
|
||||
dtype: DTypeLike | None = ...,
|
||||
) -> Array: ...
|
||||
def std(a: ArrayLike, axis: _Axis = ..., dtype: DTypeLike = ...,
|
||||
out: None = ..., ddof: int = ..., keepdims: builtins.bool = ..., *,
|
||||
where: Optional[ArrayLike] = ..., correction: int | float | None = ...) -> Array: ...
|
||||
where: ArrayLike | None = ..., correction: int | float | None = ...) -> Array: ...
|
||||
def subtract(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
def sum(
|
||||
a: ArrayLike,
|
||||
@ -792,53 +793,53 @@ def sum(
|
||||
dtype: DTypeLike = ...,
|
||||
out: None = ...,
|
||||
keepdims: builtins.bool = ...,
|
||||
initial: Optional[ArrayLike] = ...,
|
||||
where: Optional[ArrayLike] = ...,
|
||||
initial: ArrayLike | None = ...,
|
||||
where: ArrayLike | None = ...,
|
||||
promote_integers: builtins.bool = ...,
|
||||
) -> Array: ...
|
||||
def swapaxes(a: ArrayLike, axis1: int, axis2: int) -> Array: ...
|
||||
def take(
|
||||
a: ArrayLike,
|
||||
indices: ArrayLike,
|
||||
axis: Optional[int] = ...,
|
||||
axis: int | None = ...,
|
||||
out: None = ...,
|
||||
mode: Optional[str] = ...,
|
||||
mode: str | None = ...,
|
||||
unique_indices: builtins.bool = ...,
|
||||
indices_are_sorted: builtins.bool = ...,
|
||||
fill_value: Optional[StaticScalar] = ...,
|
||||
fill_value: StaticScalar | None = ...,
|
||||
) -> Array: ...
|
||||
def take_along_axis(
|
||||
arr: ArrayLike,
|
||||
indices: ArrayLike,
|
||||
axis: Optional[int],
|
||||
mode: Optional[Union[str, GatherScatterMode]] = ...,
|
||||
fill_value: Optional[StaticScalar] = None,
|
||||
axis: int | None,
|
||||
mode: str | GatherScatterMode | None = ...,
|
||||
fill_value: StaticScalar | None = None,
|
||||
) -> Array: ...
|
||||
def tan(x: ArrayLike, /) -> Array: ...
|
||||
def tanh(x: ArrayLike, /) -> Array: ...
|
||||
def tensordot(a: ArrayLike, b: ArrayLike,
|
||||
axes: Union[int, Sequence[int], Sequence[Sequence[int]]] = ...,
|
||||
axes: int | Sequence[int] | Sequence[Sequence[int]] = ...,
|
||||
*, precision: PrecisionLike = ...,
|
||||
preferred_element_type: Optional[DTypeLike] = ...) -> Array: ...
|
||||
def tile(A: ArrayLike, reps: Union[DimSize, Sequence[DimSize]]) -> Array: ...
|
||||
preferred_element_type: DTypeLike | None = ...) -> Array: ...
|
||||
def tile(A: ArrayLike, reps: DimSize | Sequence[DimSize]) -> Array: ...
|
||||
def trace(a: ArrayLike, offset: int | ArrayLike = ..., axis1: int = ..., axis2: int = ...,
|
||||
dtype: Optional[DTypeLike] = ..., out: None = ...) -> Array: ...
|
||||
def transpose(a: ArrayLike, axes: Optional[Sequence[int]] = ...) -> Array: ...
|
||||
dtype: DTypeLike | None = ..., out: None = ...) -> Array: ...
|
||||
def transpose(a: ArrayLike, axes: Sequence[int] | None = ...) -> Array: ...
|
||||
def trapezoid(y: ArrayLike, x: ArrayLike | None = None, dx: ArrayLike = ...,
|
||||
axis: int = ...) -> Array: ...
|
||||
def tri(
|
||||
N: int, M: Optional[int] = ..., k: int = ..., dtype: DTypeLike = ...
|
||||
N: int, M: int | None = ..., k: int = ..., dtype: DTypeLike = ...
|
||||
) -> Array: ...
|
||||
def tril(m: ArrayLike, k: int = ...) -> Array: ...
|
||||
def tril_indices(
|
||||
n: int, k: int = ..., m: Optional[int] = ...
|
||||
n: int, k: int = ..., m: int | None = ...
|
||||
) -> tuple[Array, Array]: ...
|
||||
def tril_indices_from(arr: ArrayLike, k: int = ...) -> tuple[Array, Array]: ...
|
||||
def fill_diagonal(a: ArrayLike, val: ArrayLike, wrap: builtins.bool = ..., *, inplace: builtins.bool = ...) -> Array: ...
|
||||
def trim_zeros(filt: ArrayLike, trim: str = ...) -> Array: ...
|
||||
def triu(m: ArrayLike, k: int = ...) -> Array: ...
|
||||
def triu_indices(
|
||||
n: int, k: int = ..., m: Optional[int] = ...
|
||||
n: int, k: int = ..., m: int | None = ...
|
||||
) -> tuple[Array, Array]: ...
|
||||
def triu_indices_from(arr: ArrayLike, k: int = ...) -> tuple[Array, Array]: ...
|
||||
def true_divide(x: ArrayLike, y: ArrayLike, /) -> Array: ...
|
||||
@ -853,8 +854,8 @@ def union1d(
|
||||
ar1: ArrayLike,
|
||||
ar2: ArrayLike,
|
||||
*,
|
||||
size: Optional[int] = ...,
|
||||
fill_value: Optional[ArrayLike] = ...,
|
||||
size: int | None = ...,
|
||||
fill_value: ArrayLike | None = ...,
|
||||
) -> Array: ...
|
||||
class _UniqueAllResult(NamedTuple):
|
||||
values: Array
|
||||
@ -868,71 +869,71 @@ class _UniqueInverseResult(NamedTuple):
|
||||
values: Array
|
||||
inverse_indices: Array
|
||||
def unique(ar: ArrayLike, return_index: builtins.bool = ..., return_inverse: builtins.bool = ...,
|
||||
return_counts: builtins.bool = ..., axis: Optional[int] = ...,
|
||||
*, equal_nan: builtins.bool = ..., size: Optional[int] = ...,
|
||||
fill_value: Optional[ArrayLike] = ...
|
||||
return_counts: builtins.bool = ..., axis: int | None = ...,
|
||||
*, equal_nan: builtins.bool = ..., size: int | None = ...,
|
||||
fill_value: ArrayLike | None = ...
|
||||
): ...
|
||||
def unique_all(x: ArrayLike, /, *, size: Optional[int] = ...,
|
||||
fill_value: Optional[ArrayLike] = ...) -> _UniqueAllResult: ...
|
||||
def unique_counts(x: ArrayLike, /, *, size: Optional[int] = ...,
|
||||
fill_value: Optional[ArrayLike] = ...) -> _UniqueCountsResult: ...
|
||||
def unique_inverse(x: ArrayLike, /, *, size: Optional[int] = ...,
|
||||
fill_value: Optional[ArrayLike] = ...) -> _UniqueInverseResult: ...
|
||||
def unique_values(x: ArrayLike, /, *, size: Optional[int] = ...,
|
||||
fill_value: Optional[ArrayLike] = ...) -> Array: ...
|
||||
def unique_all(x: ArrayLike, /, *, size: int | None = ...,
|
||||
fill_value: ArrayLike | None = ...) -> _UniqueAllResult: ...
|
||||
def unique_counts(x: ArrayLike, /, *, size: int | None = ...,
|
||||
fill_value: ArrayLike | None = ...) -> _UniqueCountsResult: ...
|
||||
def unique_inverse(x: ArrayLike, /, *, size: int | None = ...,
|
||||
fill_value: ArrayLike | None = ...) -> _UniqueInverseResult: ...
|
||||
def unique_values(x: ArrayLike, /, *, size: int | None = ...,
|
||||
fill_value: ArrayLike | None = ...) -> Array: ...
|
||||
def unpackbits(
|
||||
a: ArrayLike,
|
||||
axis: Optional[int] = ...,
|
||||
count: Optional[ArrayLike] = ...,
|
||||
axis: int | None = ...,
|
||||
count: ArrayLike | None = ...,
|
||||
bitorder: str = ...,
|
||||
) -> Array: ...
|
||||
def unravel_index(indices: ArrayLike, shape: Shape) -> tuple[Array, ...]: ...
|
||||
unsignedinteger = _np.unsignedinteger
|
||||
def unstack(x: ArrayLike , /, *, axis: int = ...) -> tuple[Array, ...]: ...
|
||||
def unwrap(p: ArrayLike, discont: Optional[ArrayLike] = ...,
|
||||
def unwrap(p: ArrayLike, discont: ArrayLike | None = ...,
|
||||
axis: int = ..., period: ArrayLike = ...) -> Array: ...
|
||||
def vander(
|
||||
x: ArrayLike, N: Optional[int] = ..., increasing: builtins.bool = ...
|
||||
x: ArrayLike, N: int | None = ..., increasing: builtins.bool = ...
|
||||
) -> Array: ...
|
||||
def var(a: ArrayLike, axis: _Axis = ..., dtype: DTypeLike = ...,
|
||||
out: None = ..., ddof: int = ..., keepdims: builtins.bool = ..., *,
|
||||
where: Optional[ArrayLike] = ..., correction: int | float | None = ...) -> Array: ...
|
||||
where: ArrayLike | None = ..., correction: int | float | None = ...) -> Array: ...
|
||||
def vdot(
|
||||
a: ArrayLike, b: ArrayLike, *, precision: PrecisionLike = ...,
|
||||
preferred_element_type: Optional[DTypeLike] = ...) -> Array: ...
|
||||
preferred_element_type: DTypeLike | None = ...) -> Array: ...
|
||||
def vecdot(x1: ArrayLike, x2: ArrayLike, /, *, axis: int = ...,
|
||||
precision: PrecisionLike = ...,
|
||||
preferred_element_type: Optional[DTypeLike] = ...) -> Array: ...
|
||||
preferred_element_type: DTypeLike | None = ...) -> Array: ...
|
||||
def vsplit(
|
||||
ary: ArrayLike, indices_or_sections: Union[int, ArrayLike]
|
||||
ary: ArrayLike, indices_or_sections: int | ArrayLike
|
||||
) -> list[Array]: ...
|
||||
|
||||
def vstack(tup: Union[_np.ndarray, Array, Sequence[ArrayLike]],
|
||||
dtype: Optional[DTypeLike] = ...) -> Array: ...
|
||||
def vstack(tup: _np.ndarray | Array | Sequence[ArrayLike],
|
||||
dtype: DTypeLike | None = ...) -> Array: ...
|
||||
|
||||
@overload
|
||||
def where(condition: ArrayLike, x: Literal[None] = ..., y: Literal[None] = ...,
|
||||
/, *, size: Optional[int] = ...,
|
||||
fill_value: Union[None, ArrayLike, tuple[ArrayLike, ...]] = ...
|
||||
/, *, size: int | None = ...,
|
||||
fill_value: None | ArrayLike | tuple[ArrayLike, ...] = ...
|
||||
) -> tuple[Array, ...]: ...
|
||||
|
||||
@overload
|
||||
def where(condition: ArrayLike, x: ArrayLike, y: ArrayLike, /, *,
|
||||
size: Optional[int] = ...,
|
||||
fill_value: Union[None, ArrayLike, tuple[ArrayLike, ...]] = ...
|
||||
size: int | None = ...,
|
||||
fill_value: None | ArrayLike | tuple[ArrayLike, ...] = ...
|
||||
) -> Array: ...
|
||||
|
||||
@overload
|
||||
def where(condition: ArrayLike, x: Optional[ArrayLike] = ...,
|
||||
y: Optional[ArrayLike] = ..., /, *, size: Optional[int] = ...,
|
||||
fill_value: Union[None, ArrayLike, tuple[ArrayLike, ...]] = ...
|
||||
) -> Union[Array, tuple[Array, ...]]: ...
|
||||
def where(condition: ArrayLike, x: ArrayLike | None = ...,
|
||||
y: ArrayLike | None = ..., /, *, size: int | None = ...,
|
||||
fill_value: None | ArrayLike | tuple[ArrayLike, ...] = ...
|
||||
) -> Array | tuple[Array, ...]: ...
|
||||
|
||||
def zeros(shape: Any, dtype: Optional[DTypeLike] = ...,
|
||||
device: Optional[Union[_Device, _Sharding]] = ...) -> Array: ...
|
||||
def zeros_like(a: Union[ArrayLike, DuckTypedArray],
|
||||
dtype: Optional[DTypeLike] = ...,
|
||||
def zeros(shape: Any, dtype: DTypeLike | None = ...,
|
||||
device: _Device | _Sharding | None = ...) -> Array: ...
|
||||
def zeros_like(a: ArrayLike | DuckTypedArray,
|
||||
dtype: DTypeLike | None = ...,
|
||||
shape: Any = ..., *,
|
||||
device: Optional[Union[_Device, _Sharding]] = ...) -> Array: ...
|
||||
device: _Device | _Sharding | None = ...) -> Array: ...
|
||||
|
||||
def vectorize(pyfunc, *, excluded = ..., signature = ...) -> Callable: ...
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user