You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
652 lines
22 KiB
652 lines
22 KiB
import sys
|
|
from typing import Any, Callable, Dict, Optional, Tuple, Type, Union, overload, TypeVar
|
|
|
|
from numpy import (
|
|
bool_,
|
|
dtype,
|
|
float32,
|
|
float64,
|
|
int8,
|
|
int16,
|
|
int32,
|
|
int64,
|
|
int_,
|
|
ndarray,
|
|
uint,
|
|
uint8,
|
|
uint16,
|
|
uint32,
|
|
uint64,
|
|
)
|
|
from numpy.random import BitGenerator, SeedSequence
|
|
from numpy.typing import (
|
|
ArrayLike,
|
|
_ArrayLikeFloat_co,
|
|
_ArrayLikeInt_co,
|
|
_DoubleCodes,
|
|
_DTypeLikeBool,
|
|
_DTypeLikeInt,
|
|
_DTypeLikeUInt,
|
|
_Float32Codes,
|
|
_Float64Codes,
|
|
_Int8Codes,
|
|
_Int16Codes,
|
|
_Int32Codes,
|
|
_Int64Codes,
|
|
_IntCodes,
|
|
_ShapeLike,
|
|
_SingleCodes,
|
|
_SupportsDType,
|
|
_UInt8Codes,
|
|
_UInt16Codes,
|
|
_UInt32Codes,
|
|
_UInt64Codes,
|
|
_UIntCodes,
|
|
)
|
|
|
|
if sys.version_info >= (3, 8):
|
|
from typing import Literal
|
|
else:
|
|
from typing_extensions import Literal
|
|
|
|
_ArrayType = TypeVar("_ArrayType", bound=ndarray[Any, Any])
|
|
|
|
_DTypeLikeFloat32 = Union[
|
|
dtype[float32],
|
|
_SupportsDType[dtype[float32]],
|
|
Type[float32],
|
|
_Float32Codes,
|
|
_SingleCodes,
|
|
]
|
|
|
|
_DTypeLikeFloat64 = Union[
|
|
dtype[float64],
|
|
_SupportsDType[dtype[float64]],
|
|
Type[float],
|
|
Type[float64],
|
|
_Float64Codes,
|
|
_DoubleCodes,
|
|
]
|
|
|
|
class Generator:
|
|
def __init__(self, bit_generator: BitGenerator) -> None: ...
|
|
def __repr__(self) -> str: ...
|
|
def __str__(self) -> str: ...
|
|
def __getstate__(self) -> Dict[str, Any]: ...
|
|
def __setstate__(self, state: Dict[str, Any]) -> None: ...
|
|
def __reduce__(self) -> Tuple[Callable[[str], Generator], Tuple[str], Dict[str, Any]]: ...
|
|
@property
|
|
def bit_generator(self) -> BitGenerator: ...
|
|
def bytes(self, length: int) -> bytes: ...
|
|
@overload
|
|
def standard_normal( # type: ignore[misc]
|
|
self,
|
|
size: None = ...,
|
|
dtype: Union[_DTypeLikeFloat32, _DTypeLikeFloat64] = ...,
|
|
out: None = ...,
|
|
) -> float: ...
|
|
@overload
|
|
def standard_normal( # type: ignore[misc]
|
|
self,
|
|
size: _ShapeLike = ...,
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def standard_normal( # type: ignore[misc]
|
|
self,
|
|
*,
|
|
out: ndarray[Any, dtype[float64]] = ...,
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def standard_normal( # type: ignore[misc]
|
|
self,
|
|
size: _ShapeLike = ...,
|
|
dtype: _DTypeLikeFloat32 = ...,
|
|
out: Optional[ndarray[Any, dtype[float32]]] = ...,
|
|
) -> ndarray[Any, dtype[float32]]: ...
|
|
@overload
|
|
def standard_normal( # type: ignore[misc]
|
|
self,
|
|
size: _ShapeLike = ...,
|
|
dtype: _DTypeLikeFloat64 = ...,
|
|
out: Optional[ndarray[Any, dtype[float64]]] = ...,
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def permutation(self, x: int, axis: int = ...) -> ndarray[Any, dtype[int64]]: ...
|
|
@overload
|
|
def permutation(self, x: ArrayLike, axis: int = ...) -> ndarray[Any, Any]: ...
|
|
@overload
|
|
def standard_exponential( # type: ignore[misc]
|
|
self,
|
|
size: None = ...,
|
|
dtype: Union[_DTypeLikeFloat32, _DTypeLikeFloat64] = ...,
|
|
method: Literal["zig", "inv"] = ...,
|
|
out: None = ...,
|
|
) -> float: ...
|
|
@overload
|
|
def standard_exponential(
|
|
self,
|
|
size: _ShapeLike = ...,
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def standard_exponential(
|
|
self,
|
|
*,
|
|
out: ndarray[Any, dtype[float64]] = ...,
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def standard_exponential(
|
|
self,
|
|
size: _ShapeLike = ...,
|
|
*,
|
|
method: Literal["zig", "inv"] = ...,
|
|
out: Optional[ndarray[Any, dtype[float64]]] = ...,
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def standard_exponential(
|
|
self,
|
|
size: _ShapeLike = ...,
|
|
dtype: _DTypeLikeFloat32 = ...,
|
|
method: Literal["zig", "inv"] = ...,
|
|
out: Optional[ndarray[Any, dtype[float32]]] = ...,
|
|
) -> ndarray[Any, dtype[float32]]: ...
|
|
@overload
|
|
def standard_exponential(
|
|
self,
|
|
size: _ShapeLike = ...,
|
|
dtype: _DTypeLikeFloat64 = ...,
|
|
method: Literal["zig", "inv"] = ...,
|
|
out: Optional[ndarray[Any, dtype[float64]]] = ...,
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def random( # type: ignore[misc]
|
|
self,
|
|
size: None = ...,
|
|
dtype: Union[_DTypeLikeFloat32, _DTypeLikeFloat64] = ...,
|
|
out: None = ...,
|
|
) -> float: ...
|
|
@overload
|
|
def random(
|
|
self,
|
|
*,
|
|
out: ndarray[Any, dtype[float64]] = ...,
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def random(
|
|
self,
|
|
size: _ShapeLike = ...,
|
|
*,
|
|
out: Optional[ndarray[Any, dtype[float64]]] = ...,
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def random(
|
|
self,
|
|
size: _ShapeLike = ...,
|
|
dtype: _DTypeLikeFloat32 = ...,
|
|
out: Optional[ndarray[Any, dtype[float32]]] = ...,
|
|
) -> ndarray[Any, dtype[float32]]: ...
|
|
@overload
|
|
def random(
|
|
self,
|
|
size: _ShapeLike = ...,
|
|
dtype: _DTypeLikeFloat64 = ...,
|
|
out: Optional[ndarray[Any, dtype[float64]]] = ...,
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def beta(self, a: float, b: float, size: None = ...) -> float: ... # type: ignore[misc]
|
|
@overload
|
|
def beta(
|
|
self, a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def exponential(self, scale: float = ..., size: None = ...) -> float: ... # type: ignore[misc]
|
|
@overload
|
|
def exponential(
|
|
self, scale: _ArrayLikeFloat_co = ..., size: Optional[_ShapeLike] = ...
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def integers( # type: ignore[misc]
|
|
self,
|
|
low: int,
|
|
high: Optional[int] = ...,
|
|
) -> int: ...
|
|
@overload
|
|
def integers( # type: ignore[misc]
|
|
self,
|
|
low: int,
|
|
high: Optional[int] = ...,
|
|
size: None = ...,
|
|
dtype: _DTypeLikeBool = ...,
|
|
endpoint: bool = ...,
|
|
) -> bool: ...
|
|
@overload
|
|
def integers( # type: ignore[misc]
|
|
self,
|
|
low: int,
|
|
high: Optional[int] = ...,
|
|
size: None = ...,
|
|
dtype: Union[_DTypeLikeInt, _DTypeLikeUInt] = ...,
|
|
endpoint: bool = ...,
|
|
) -> int: ...
|
|
@overload
|
|
def integers( # type: ignore[misc]
|
|
self,
|
|
low: _ArrayLikeInt_co,
|
|
high: Optional[_ArrayLikeInt_co] = ...,
|
|
size: Optional[_ShapeLike] = ...,
|
|
) -> ndarray[Any, dtype[int64]]: ...
|
|
@overload
|
|
def integers( # type: ignore[misc]
|
|
self,
|
|
low: _ArrayLikeInt_co,
|
|
high: Optional[_ArrayLikeInt_co] = ...,
|
|
size: Optional[_ShapeLike] = ...,
|
|
dtype: _DTypeLikeBool = ...,
|
|
endpoint: bool = ...,
|
|
) -> ndarray[Any, dtype[bool_]]: ...
|
|
@overload
|
|
def integers( # type: ignore[misc]
|
|
self,
|
|
low: _ArrayLikeInt_co,
|
|
high: Optional[_ArrayLikeInt_co] = ...,
|
|
size: Optional[_ShapeLike] = ...,
|
|
dtype: Union[dtype[int8], Type[int8], _Int8Codes, _SupportsDType[dtype[int8]]] = ...,
|
|
endpoint: bool = ...,
|
|
) -> ndarray[Any, dtype[int8]]: ...
|
|
@overload
|
|
def integers( # type: ignore[misc]
|
|
self,
|
|
low: _ArrayLikeInt_co,
|
|
high: Optional[_ArrayLikeInt_co] = ...,
|
|
size: Optional[_ShapeLike] = ...,
|
|
dtype: Union[dtype[int16], Type[int16], _Int16Codes, _SupportsDType[dtype[int16]]] = ...,
|
|
endpoint: bool = ...,
|
|
) -> ndarray[Any, dtype[int16]]: ...
|
|
@overload
|
|
def integers( # type: ignore[misc]
|
|
self,
|
|
low: _ArrayLikeInt_co,
|
|
high: Optional[_ArrayLikeInt_co] = ...,
|
|
size: Optional[_ShapeLike] = ...,
|
|
dtype: Union[dtype[int32], Type[int32], _Int32Codes, _SupportsDType[dtype[int32]]] = ...,
|
|
endpoint: bool = ...,
|
|
) -> ndarray[Any, dtype[Union[int32]]]: ...
|
|
@overload
|
|
def integers( # type: ignore[misc]
|
|
self,
|
|
low: _ArrayLikeInt_co,
|
|
high: Optional[_ArrayLikeInt_co] = ...,
|
|
size: Optional[_ShapeLike] = ...,
|
|
dtype: Optional[
|
|
Union[dtype[int64], Type[int64], _Int64Codes, _SupportsDType[dtype[int64]]]
|
|
] = ...,
|
|
endpoint: bool = ...,
|
|
) -> ndarray[Any, dtype[int64]]: ...
|
|
@overload
|
|
def integers( # type: ignore[misc]
|
|
self,
|
|
low: _ArrayLikeInt_co,
|
|
high: Optional[_ArrayLikeInt_co] = ...,
|
|
size: Optional[_ShapeLike] = ...,
|
|
dtype: Union[dtype[uint8], Type[uint8], _UInt8Codes, _SupportsDType[dtype[uint8]]] = ...,
|
|
endpoint: bool = ...,
|
|
) -> ndarray[Any, dtype[uint8]]: ...
|
|
@overload
|
|
def integers( # type: ignore[misc]
|
|
self,
|
|
low: _ArrayLikeInt_co,
|
|
high: Optional[_ArrayLikeInt_co] = ...,
|
|
size: Optional[_ShapeLike] = ...,
|
|
dtype: Union[
|
|
dtype[uint16], Type[uint16], _UInt16Codes, _SupportsDType[dtype[uint16]]
|
|
] = ...,
|
|
endpoint: bool = ...,
|
|
) -> ndarray[Any, dtype[Union[uint16]]]: ...
|
|
@overload
|
|
def integers( # type: ignore[misc]
|
|
self,
|
|
low: _ArrayLikeInt_co,
|
|
high: Optional[_ArrayLikeInt_co] = ...,
|
|
size: Optional[_ShapeLike] = ...,
|
|
dtype: Union[
|
|
dtype[uint32], Type[uint32], _UInt32Codes, _SupportsDType[dtype[uint32]]
|
|
] = ...,
|
|
endpoint: bool = ...,
|
|
) -> ndarray[Any, dtype[uint32]]: ...
|
|
@overload
|
|
def integers( # type: ignore[misc]
|
|
self,
|
|
low: _ArrayLikeInt_co,
|
|
high: Optional[_ArrayLikeInt_co] = ...,
|
|
size: Optional[_ShapeLike] = ...,
|
|
dtype: Union[
|
|
dtype[uint64], Type[uint64], _UInt64Codes, _SupportsDType[dtype[uint64]]
|
|
] = ...,
|
|
endpoint: bool = ...,
|
|
) -> ndarray[Any, dtype[uint64]]: ...
|
|
@overload
|
|
def integers( # type: ignore[misc]
|
|
self,
|
|
low: _ArrayLikeInt_co,
|
|
high: Optional[_ArrayLikeInt_co] = ...,
|
|
size: Optional[_ShapeLike] = ...,
|
|
dtype: Union[
|
|
dtype[int_], Type[int], Type[int_], _IntCodes, _SupportsDType[dtype[int_]]
|
|
] = ...,
|
|
endpoint: bool = ...,
|
|
) -> ndarray[Any, dtype[int_]]: ...
|
|
@overload
|
|
def integers( # type: ignore[misc]
|
|
self,
|
|
low: _ArrayLikeInt_co,
|
|
high: Optional[_ArrayLikeInt_co] = ...,
|
|
size: Optional[_ShapeLike] = ...,
|
|
dtype: Union[dtype[uint], Type[uint], _UIntCodes, _SupportsDType[dtype[uint]]] = ...,
|
|
endpoint: bool = ...,
|
|
) -> ndarray[Any, dtype[uint]]: ...
|
|
# TODO: Use a TypeVar _T here to get away from Any output? Should be int->ndarray[Any,dtype[int64]], ArrayLike[_T] -> Union[_T, ndarray[Any,Any]]
|
|
@overload
|
|
def choice(
|
|
self,
|
|
a: int,
|
|
size: None = ...,
|
|
replace: bool = ...,
|
|
p: Optional[_ArrayLikeFloat_co] = ...,
|
|
axis: int = ...,
|
|
shuffle: bool = ...,
|
|
) -> int: ...
|
|
@overload
|
|
def choice(
|
|
self,
|
|
a: int,
|
|
size: _ShapeLike = ...,
|
|
replace: bool = ...,
|
|
p: Optional[_ArrayLikeFloat_co] = ...,
|
|
axis: int = ...,
|
|
shuffle: bool = ...,
|
|
) -> ndarray[Any, dtype[int64]]: ...
|
|
@overload
|
|
def choice(
|
|
self,
|
|
a: ArrayLike,
|
|
size: None = ...,
|
|
replace: bool = ...,
|
|
p: Optional[_ArrayLikeFloat_co] = ...,
|
|
axis: int = ...,
|
|
shuffle: bool = ...,
|
|
) -> Any: ...
|
|
@overload
|
|
def choice(
|
|
self,
|
|
a: ArrayLike,
|
|
size: _ShapeLike = ...,
|
|
replace: bool = ...,
|
|
p: Optional[_ArrayLikeFloat_co] = ...,
|
|
axis: int = ...,
|
|
shuffle: bool = ...,
|
|
) -> ndarray[Any, Any]: ...
|
|
@overload
|
|
def uniform(self, low: float = ..., high: float = ..., size: None = ...) -> float: ... # type: ignore[misc]
|
|
@overload
|
|
def uniform(
|
|
self,
|
|
low: _ArrayLikeFloat_co = ...,
|
|
high: _ArrayLikeFloat_co = ...,
|
|
size: Optional[_ShapeLike] = ...,
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def normal(self, loc: float = ..., scale: float = ..., size: None = ...) -> float: ... # type: ignore[misc]
|
|
@overload
|
|
def normal(
|
|
self,
|
|
loc: _ArrayLikeFloat_co = ...,
|
|
scale: _ArrayLikeFloat_co = ...,
|
|
size: Optional[_ShapeLike] = ...,
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def standard_gamma( # type: ignore[misc]
|
|
self,
|
|
shape: float,
|
|
size: None = ...,
|
|
dtype: Union[_DTypeLikeFloat32, _DTypeLikeFloat64] = ...,
|
|
out: None = ...,
|
|
) -> float: ...
|
|
@overload
|
|
def standard_gamma(
|
|
self,
|
|
shape: _ArrayLikeFloat_co,
|
|
size: Optional[_ShapeLike] = ...,
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def standard_gamma(
|
|
self,
|
|
shape: _ArrayLikeFloat_co,
|
|
*,
|
|
out: ndarray[Any, dtype[float64]] = ...,
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def standard_gamma(
|
|
self,
|
|
shape: _ArrayLikeFloat_co,
|
|
size: Optional[_ShapeLike] = ...,
|
|
dtype: _DTypeLikeFloat32 = ...,
|
|
out: Optional[ndarray[Any, dtype[float32]]] = ...,
|
|
) -> ndarray[Any, dtype[float32]]: ...
|
|
@overload
|
|
def standard_gamma(
|
|
self,
|
|
shape: _ArrayLikeFloat_co,
|
|
size: Optional[_ShapeLike] = ...,
|
|
dtype: _DTypeLikeFloat64 = ...,
|
|
out: Optional[ndarray[Any, dtype[float64]]] = ...,
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def gamma(self, shape: float, scale: float = ..., size: None = ...) -> float: ... # type: ignore[misc]
|
|
@overload
|
|
def gamma(
|
|
self,
|
|
shape: _ArrayLikeFloat_co,
|
|
scale: _ArrayLikeFloat_co = ...,
|
|
size: Optional[_ShapeLike] = ...,
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def f(self, dfnum: float, dfden: float, size: None = ...) -> float: ... # type: ignore[misc]
|
|
@overload
|
|
def f(
|
|
self, dfnum: _ArrayLikeFloat_co, dfden: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def noncentral_f(self, dfnum: float, dfden: float, nonc: float, size: None = ...) -> float: ... # type: ignore[misc]
|
|
@overload
|
|
def noncentral_f(
|
|
self,
|
|
dfnum: _ArrayLikeFloat_co,
|
|
dfden: _ArrayLikeFloat_co,
|
|
nonc: _ArrayLikeFloat_co,
|
|
size: Optional[_ShapeLike] = ...,
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def chisquare(self, df: float, size: None = ...) -> float: ... # type: ignore[misc]
|
|
@overload
|
|
def chisquare(
|
|
self, df: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def noncentral_chisquare(self, df: float, nonc: float, size: None = ...) -> float: ... # type: ignore[misc]
|
|
@overload
|
|
def noncentral_chisquare(
|
|
self, df: _ArrayLikeFloat_co, nonc: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def standard_t(self, df: float, size: None = ...) -> float: ... # type: ignore[misc]
|
|
@overload
|
|
def standard_t(
|
|
self, df: _ArrayLikeFloat_co, size: None = ...
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def standard_t(
|
|
self, df: _ArrayLikeFloat_co, size: _ShapeLike = ...
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def vonmises(self, mu: float, kappa: float, size: None = ...) -> float: ... # type: ignore[misc]
|
|
@overload
|
|
def vonmises(
|
|
self, mu: _ArrayLikeFloat_co, kappa: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def pareto(self, a: float, size: None = ...) -> float: ... # type: ignore[misc]
|
|
@overload
|
|
def pareto(
|
|
self, a: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def weibull(self, a: float, size: None = ...) -> float: ... # type: ignore[misc]
|
|
@overload
|
|
def weibull(
|
|
self, a: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def power(self, a: float, size: None = ...) -> float: ... # type: ignore[misc]
|
|
@overload
|
|
def power(
|
|
self, a: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def standard_cauchy(self, size: None = ...) -> float: ... # type: ignore[misc]
|
|
@overload
|
|
def standard_cauchy(self, size: _ShapeLike = ...) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def laplace(self, loc: float = ..., scale: float = ..., size: None = ...) -> float: ... # type: ignore[misc]
|
|
@overload
|
|
def laplace(
|
|
self,
|
|
loc: _ArrayLikeFloat_co = ...,
|
|
scale: _ArrayLikeFloat_co = ...,
|
|
size: Optional[_ShapeLike] = ...,
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def gumbel(self, loc: float = ..., scale: float = ..., size: None = ...) -> float: ... # type: ignore[misc]
|
|
@overload
|
|
def gumbel(
|
|
self,
|
|
loc: _ArrayLikeFloat_co = ...,
|
|
scale: _ArrayLikeFloat_co = ...,
|
|
size: Optional[_ShapeLike] = ...,
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def logistic(self, loc: float = ..., scale: float = ..., size: None = ...) -> float: ... # type: ignore[misc]
|
|
@overload
|
|
def logistic(
|
|
self,
|
|
loc: _ArrayLikeFloat_co = ...,
|
|
scale: _ArrayLikeFloat_co = ...,
|
|
size: Optional[_ShapeLike] = ...,
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def lognormal(self, mean: float = ..., sigma: float = ..., size: None = ...) -> float: ... # type: ignore[misc]
|
|
@overload
|
|
def lognormal(
|
|
self,
|
|
mean: _ArrayLikeFloat_co = ...,
|
|
sigma: _ArrayLikeFloat_co = ...,
|
|
size: Optional[_ShapeLike] = ...,
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def rayleigh(self, scale: float = ..., size: None = ...) -> float: ... # type: ignore[misc]
|
|
@overload
|
|
def rayleigh(
|
|
self, scale: _ArrayLikeFloat_co = ..., size: Optional[_ShapeLike] = ...
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def wald(self, mean: float, scale: float, size: None = ...) -> float: ... # type: ignore[misc]
|
|
@overload
|
|
def wald(
|
|
self, mean: _ArrayLikeFloat_co, scale: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def triangular(self, left: float, mode: float, right: float, size: None = ...) -> float: ... # type: ignore[misc]
|
|
@overload
|
|
def triangular(
|
|
self,
|
|
left: _ArrayLikeFloat_co,
|
|
mode: _ArrayLikeFloat_co,
|
|
right: _ArrayLikeFloat_co,
|
|
size: Optional[_ShapeLike] = ...,
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
@overload
|
|
def binomial(self, n: int, p: float, size: None = ...) -> int: ... # type: ignore[misc]
|
|
@overload
|
|
def binomial(
|
|
self, n: _ArrayLikeInt_co, p: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
|
|
) -> ndarray[Any, dtype[int64]]: ...
|
|
@overload
|
|
def negative_binomial(self, n: float, p: float, size: None = ...) -> int: ... # type: ignore[misc]
|
|
@overload
|
|
def negative_binomial(
|
|
self, n: _ArrayLikeFloat_co, p: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
|
|
) -> ndarray[Any, dtype[int64]]: ...
|
|
@overload
|
|
def poisson(self, lam: float = ..., size: None = ...) -> int: ... # type: ignore[misc]
|
|
@overload
|
|
def poisson(
|
|
self, lam: _ArrayLikeFloat_co = ..., size: Optional[_ShapeLike] = ...
|
|
) -> ndarray[Any, dtype[int64]]: ...
|
|
@overload
|
|
def zipf(self, a: float, size: None = ...) -> int: ... # type: ignore[misc]
|
|
@overload
|
|
def zipf(
|
|
self, a: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
|
|
) -> ndarray[Any, dtype[int64]]: ...
|
|
@overload
|
|
def geometric(self, p: float, size: None = ...) -> int: ... # type: ignore[misc]
|
|
@overload
|
|
def geometric(
|
|
self, p: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
|
|
) -> ndarray[Any, dtype[int64]]: ...
|
|
@overload
|
|
def hypergeometric(self, ngood: int, nbad: int, nsample: int, size: None = ...) -> int: ... # type: ignore[misc]
|
|
@overload
|
|
def hypergeometric(
|
|
self,
|
|
ngood: _ArrayLikeInt_co,
|
|
nbad: _ArrayLikeInt_co,
|
|
nsample: _ArrayLikeInt_co,
|
|
size: Optional[_ShapeLike] = ...,
|
|
) -> ndarray[Any, dtype[int64]]: ...
|
|
@overload
|
|
def logseries(self, p: float, size: None = ...) -> int: ... # type: ignore[misc]
|
|
@overload
|
|
def logseries(
|
|
self, p: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
|
|
) -> ndarray[Any, dtype[int64]]: ...
|
|
def multivariate_normal(
|
|
self,
|
|
mean: _ArrayLikeFloat_co,
|
|
cov: _ArrayLikeFloat_co,
|
|
size: Optional[_ShapeLike] = ...,
|
|
check_valid: Literal["warn", "raise", "ignore"] = ...,
|
|
tol: float = ...,
|
|
*,
|
|
method: Literal["svd", "eigh", "cholesky"] = ...,
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
def multinomial(
|
|
self, n: _ArrayLikeInt_co, pvals: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
|
|
) -> ndarray[Any, dtype[int64]]: ...
|
|
def multivariate_hypergeometric(
|
|
self,
|
|
colors: _ArrayLikeInt_co,
|
|
nsample: int,
|
|
size: Optional[_ShapeLike] = ...,
|
|
method: Literal["marginals", "count"] = ...,
|
|
) -> ndarray[Any, dtype[int64]]: ...
|
|
def dirichlet(
|
|
self, alpha: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
|
|
) -> ndarray[Any, dtype[float64]]: ...
|
|
def permuted(
|
|
self, x: ArrayLike, *, axis: Optional[int] = ..., out: Optional[ndarray[Any, Any]] = ...
|
|
) -> ndarray[Any, Any]: ...
|
|
def shuffle(self, x: ArrayLike, axis: int = ...) -> None: ...
|
|
|
|
def default_rng(
|
|
seed: Union[None, _ArrayLikeInt_co, SeedSequence, BitGenerator, Generator] = ...
|
|
) -> Generator: ...
|