peacock-data-public-datasets-idc-cronscript
/
venv
/lib
/python3.10
/site-packages
/numpy
/random
/_generator.pyi
| from collections.abc import Callable | |
| from typing import Any, Union, overload, TypeVar, Literal | |
| 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, | |
| _FloatLike_co, | |
| _Int8Codes, | |
| _Int16Codes, | |
| _Int32Codes, | |
| _Int64Codes, | |
| _IntCodes, | |
| _ShapeLike, | |
| _SingleCodes, | |
| _SupportsDType, | |
| _UInt8Codes, | |
| _UInt16Codes, | |
| _UInt32Codes, | |
| _UInt64Codes, | |
| _UIntCodes, | |
| ) | |
| _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]]: ... | |
| def bit_generator(self) -> BitGenerator: ... | |
| def spawn(self, n_children: int) -> list[Generator]: ... | |
| def bytes(self, length: int) -> bytes: ... | |
| def standard_normal( # type: ignore[misc] | |
| self, | |
| size: None = ..., | |
| dtype: _DTypeLikeFloat32 | _DTypeLikeFloat64 = ..., | |
| out: None = ..., | |
| ) -> float: ... | |
| def standard_normal( # type: ignore[misc] | |
| self, | |
| size: _ShapeLike = ..., | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def standard_normal( # type: ignore[misc] | |
| self, | |
| *, | |
| out: ndarray[Any, dtype[float64]] = ..., | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def standard_normal( # type: ignore[misc] | |
| self, | |
| size: _ShapeLike = ..., | |
| dtype: _DTypeLikeFloat32 = ..., | |
| out: None | ndarray[Any, dtype[float32]] = ..., | |
| ) -> ndarray[Any, dtype[float32]]: ... | |
| def standard_normal( # type: ignore[misc] | |
| self, | |
| size: _ShapeLike = ..., | |
| dtype: _DTypeLikeFloat64 = ..., | |
| out: None | ndarray[Any, dtype[float64]] = ..., | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def permutation(self, x: int, axis: int = ...) -> ndarray[Any, dtype[int64]]: ... | |
| def permutation(self, x: ArrayLike, axis: int = ...) -> ndarray[Any, Any]: ... | |
| def standard_exponential( # type: ignore[misc] | |
| self, | |
| size: None = ..., | |
| dtype: _DTypeLikeFloat32 | _DTypeLikeFloat64 = ..., | |
| method: Literal["zig", "inv"] = ..., | |
| out: None = ..., | |
| ) -> float: ... | |
| def standard_exponential( | |
| self, | |
| size: _ShapeLike = ..., | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def standard_exponential( | |
| self, | |
| *, | |
| out: ndarray[Any, dtype[float64]] = ..., | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def standard_exponential( | |
| self, | |
| size: _ShapeLike = ..., | |
| *, | |
| method: Literal["zig", "inv"] = ..., | |
| out: None | ndarray[Any, dtype[float64]] = ..., | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def standard_exponential( | |
| self, | |
| size: _ShapeLike = ..., | |
| dtype: _DTypeLikeFloat32 = ..., | |
| method: Literal["zig", "inv"] = ..., | |
| out: None | ndarray[Any, dtype[float32]] = ..., | |
| ) -> ndarray[Any, dtype[float32]]: ... | |
| def standard_exponential( | |
| self, | |
| size: _ShapeLike = ..., | |
| dtype: _DTypeLikeFloat64 = ..., | |
| method: Literal["zig", "inv"] = ..., | |
| out: None | ndarray[Any, dtype[float64]] = ..., | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def random( # type: ignore[misc] | |
| self, | |
| size: None = ..., | |
| dtype: _DTypeLikeFloat32 | _DTypeLikeFloat64 = ..., | |
| out: None = ..., | |
| ) -> float: ... | |
| def random( | |
| self, | |
| *, | |
| out: ndarray[Any, dtype[float64]] = ..., | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def random( | |
| self, | |
| size: _ShapeLike = ..., | |
| *, | |
| out: None | ndarray[Any, dtype[float64]] = ..., | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def random( | |
| self, | |
| size: _ShapeLike = ..., | |
| dtype: _DTypeLikeFloat32 = ..., | |
| out: None | ndarray[Any, dtype[float32]] = ..., | |
| ) -> ndarray[Any, dtype[float32]]: ... | |
| def random( | |
| self, | |
| size: _ShapeLike = ..., | |
| dtype: _DTypeLikeFloat64 = ..., | |
| out: None | ndarray[Any, dtype[float64]] = ..., | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def beta( | |
| self, | |
| a: _FloatLike_co, | |
| b: _FloatLike_co, | |
| size: None = ..., | |
| ) -> float: ... # type: ignore[misc] | |
| def beta( | |
| self, a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co, size: None | _ShapeLike = ... | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def exponential(self, scale: _FloatLike_co = ..., size: None = ...) -> float: ... # type: ignore[misc] | |
| def exponential( | |
| self, scale: _ArrayLikeFloat_co = ..., size: None | _ShapeLike = ... | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def integers( # type: ignore[misc] | |
| self, | |
| low: int, | |
| high: None | int = ..., | |
| ) -> int: ... | |
| def integers( # type: ignore[misc] | |
| self, | |
| low: int, | |
| high: None | int = ..., | |
| size: None = ..., | |
| dtype: _DTypeLikeBool = ..., | |
| endpoint: bool = ..., | |
| ) -> bool: ... | |
| def integers( # type: ignore[misc] | |
| self, | |
| low: int, | |
| high: None | int = ..., | |
| size: None = ..., | |
| dtype: _DTypeLikeInt | _DTypeLikeUInt = ..., | |
| endpoint: bool = ..., | |
| ) -> int: ... | |
| def integers( # type: ignore[misc] | |
| self, | |
| low: _ArrayLikeInt_co, | |
| high: None | _ArrayLikeInt_co = ..., | |
| size: None | _ShapeLike = ..., | |
| ) -> ndarray[Any, dtype[int64]]: ... | |
| def integers( # type: ignore[misc] | |
| self, | |
| low: _ArrayLikeInt_co, | |
| high: None | _ArrayLikeInt_co = ..., | |
| size: None | _ShapeLike = ..., | |
| dtype: _DTypeLikeBool = ..., | |
| endpoint: bool = ..., | |
| ) -> ndarray[Any, dtype[bool_]]: ... | |
| def integers( # type: ignore[misc] | |
| self, | |
| low: _ArrayLikeInt_co, | |
| high: None | _ArrayLikeInt_co = ..., | |
| size: None | _ShapeLike = ..., | |
| dtype: dtype[int8] | type[int8] | _Int8Codes | _SupportsDType[dtype[int8]] = ..., | |
| endpoint: bool = ..., | |
| ) -> ndarray[Any, dtype[int8]]: ... | |
| def integers( # type: ignore[misc] | |
| self, | |
| low: _ArrayLikeInt_co, | |
| high: None | _ArrayLikeInt_co = ..., | |
| size: None | _ShapeLike = ..., | |
| dtype: dtype[int16] | type[int16] | _Int16Codes | _SupportsDType[dtype[int16]] = ..., | |
| endpoint: bool = ..., | |
| ) -> ndarray[Any, dtype[int16]]: ... | |
| def integers( # type: ignore[misc] | |
| self, | |
| low: _ArrayLikeInt_co, | |
| high: None | _ArrayLikeInt_co = ..., | |
| size: None | _ShapeLike = ..., | |
| dtype: dtype[int32] | type[int32] | _Int32Codes | _SupportsDType[dtype[int32]] = ..., | |
| endpoint: bool = ..., | |
| ) -> ndarray[Any, dtype[int32]]: ... | |
| def integers( # type: ignore[misc] | |
| self, | |
| low: _ArrayLikeInt_co, | |
| high: None | _ArrayLikeInt_co = ..., | |
| size: None | _ShapeLike = ..., | |
| dtype: None | dtype[int64] | type[int64] | _Int64Codes | _SupportsDType[dtype[int64]] = ..., | |
| endpoint: bool = ..., | |
| ) -> ndarray[Any, dtype[int64]]: ... | |
| def integers( # type: ignore[misc] | |
| self, | |
| low: _ArrayLikeInt_co, | |
| high: None | _ArrayLikeInt_co = ..., | |
| size: None | _ShapeLike = ..., | |
| dtype: dtype[uint8] | type[uint8] | _UInt8Codes | _SupportsDType[dtype[uint8]] = ..., | |
| endpoint: bool = ..., | |
| ) -> ndarray[Any, dtype[uint8]]: ... | |
| def integers( # type: ignore[misc] | |
| self, | |
| low: _ArrayLikeInt_co, | |
| high: None | _ArrayLikeInt_co = ..., | |
| size: None | _ShapeLike = ..., | |
| dtype: dtype[uint16] | type[uint16] | _UInt16Codes | _SupportsDType[dtype[uint16]] = ..., | |
| endpoint: bool = ..., | |
| ) -> ndarray[Any, dtype[uint16]]: ... | |
| def integers( # type: ignore[misc] | |
| self, | |
| low: _ArrayLikeInt_co, | |
| high: None | _ArrayLikeInt_co = ..., | |
| size: None | _ShapeLike = ..., | |
| dtype: dtype[uint32] | type[uint32] | _UInt32Codes | _SupportsDType[dtype[uint32]] = ..., | |
| endpoint: bool = ..., | |
| ) -> ndarray[Any, dtype[uint32]]: ... | |
| def integers( # type: ignore[misc] | |
| self, | |
| low: _ArrayLikeInt_co, | |
| high: None | _ArrayLikeInt_co = ..., | |
| size: None | _ShapeLike = ..., | |
| dtype: dtype[uint64] | type[uint64] | _UInt64Codes | _SupportsDType[dtype[uint64]] = ..., | |
| endpoint: bool = ..., | |
| ) -> ndarray[Any, dtype[uint64]]: ... | |
| def integers( # type: ignore[misc] | |
| self, | |
| low: _ArrayLikeInt_co, | |
| high: None | _ArrayLikeInt_co = ..., | |
| size: None | _ShapeLike = ..., | |
| dtype: dtype[int_] | type[int] | type[int_] | _IntCodes | _SupportsDType[dtype[int_]] = ..., | |
| endpoint: bool = ..., | |
| ) -> ndarray[Any, dtype[int_]]: ... | |
| def integers( # type: ignore[misc] | |
| self, | |
| low: _ArrayLikeInt_co, | |
| high: None | _ArrayLikeInt_co = ..., | |
| size: None | _ShapeLike = ..., | |
| dtype: 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] -> _T | ndarray[Any,Any] | |
| def choice( | |
| self, | |
| a: int, | |
| size: None = ..., | |
| replace: bool = ..., | |
| p: None | _ArrayLikeFloat_co = ..., | |
| axis: int = ..., | |
| shuffle: bool = ..., | |
| ) -> int: ... | |
| def choice( | |
| self, | |
| a: int, | |
| size: _ShapeLike = ..., | |
| replace: bool = ..., | |
| p: None | _ArrayLikeFloat_co = ..., | |
| axis: int = ..., | |
| shuffle: bool = ..., | |
| ) -> ndarray[Any, dtype[int64]]: ... | |
| def choice( | |
| self, | |
| a: ArrayLike, | |
| size: None = ..., | |
| replace: bool = ..., | |
| p: None | _ArrayLikeFloat_co = ..., | |
| axis: int = ..., | |
| shuffle: bool = ..., | |
| ) -> Any: ... | |
| def choice( | |
| self, | |
| a: ArrayLike, | |
| size: _ShapeLike = ..., | |
| replace: bool = ..., | |
| p: None | _ArrayLikeFloat_co = ..., | |
| axis: int = ..., | |
| shuffle: bool = ..., | |
| ) -> ndarray[Any, Any]: ... | |
| def uniform( | |
| self, | |
| low: _FloatLike_co = ..., | |
| high: _FloatLike_co = ..., | |
| size: None = ..., | |
| ) -> float: ... # type: ignore[misc] | |
| def uniform( | |
| self, | |
| low: _ArrayLikeFloat_co = ..., | |
| high: _ArrayLikeFloat_co = ..., | |
| size: None | _ShapeLike = ..., | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def normal( | |
| self, | |
| loc: _FloatLike_co = ..., | |
| scale: _FloatLike_co = ..., | |
| size: None = ..., | |
| ) -> float: ... # type: ignore[misc] | |
| def normal( | |
| self, | |
| loc: _ArrayLikeFloat_co = ..., | |
| scale: _ArrayLikeFloat_co = ..., | |
| size: None | _ShapeLike = ..., | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def standard_gamma( # type: ignore[misc] | |
| self, | |
| shape: _FloatLike_co, | |
| size: None = ..., | |
| dtype: _DTypeLikeFloat32 | _DTypeLikeFloat64 = ..., | |
| out: None = ..., | |
| ) -> float: ... | |
| def standard_gamma( | |
| self, | |
| shape: _ArrayLikeFloat_co, | |
| size: None | _ShapeLike = ..., | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def standard_gamma( | |
| self, | |
| shape: _ArrayLikeFloat_co, | |
| *, | |
| out: ndarray[Any, dtype[float64]] = ..., | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def standard_gamma( | |
| self, | |
| shape: _ArrayLikeFloat_co, | |
| size: None | _ShapeLike = ..., | |
| dtype: _DTypeLikeFloat32 = ..., | |
| out: None | ndarray[Any, dtype[float32]] = ..., | |
| ) -> ndarray[Any, dtype[float32]]: ... | |
| def standard_gamma( | |
| self, | |
| shape: _ArrayLikeFloat_co, | |
| size: None | _ShapeLike = ..., | |
| dtype: _DTypeLikeFloat64 = ..., | |
| out: None | ndarray[Any, dtype[float64]] = ..., | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def gamma(self, shape: _FloatLike_co, scale: _FloatLike_co = ..., size: None = ...) -> float: ... # type: ignore[misc] | |
| def gamma( | |
| self, | |
| shape: _ArrayLikeFloat_co, | |
| scale: _ArrayLikeFloat_co = ..., | |
| size: None | _ShapeLike = ..., | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def f(self, dfnum: _FloatLike_co, dfden: _FloatLike_co, size: None = ...) -> float: ... # type: ignore[misc] | |
| def f( | |
| self, dfnum: _ArrayLikeFloat_co, dfden: _ArrayLikeFloat_co, size: None | _ShapeLike = ... | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def noncentral_f(self, dfnum: _FloatLike_co, dfden: _FloatLike_co, nonc: _FloatLike_co, size: None = ...) -> float: ... # type: ignore[misc] | |
| def noncentral_f( | |
| self, | |
| dfnum: _ArrayLikeFloat_co, | |
| dfden: _ArrayLikeFloat_co, | |
| nonc: _ArrayLikeFloat_co, | |
| size: None | _ShapeLike = ..., | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def chisquare(self, df: _FloatLike_co, size: None = ...) -> float: ... # type: ignore[misc] | |
| def chisquare( | |
| self, df: _ArrayLikeFloat_co, size: None | _ShapeLike = ... | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def noncentral_chisquare(self, df: _FloatLike_co, nonc: _FloatLike_co, size: None = ...) -> float: ... # type: ignore[misc] | |
| def noncentral_chisquare( | |
| self, df: _ArrayLikeFloat_co, nonc: _ArrayLikeFloat_co, size: None | _ShapeLike = ... | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def standard_t(self, df: _FloatLike_co, size: None = ...) -> float: ... # type: ignore[misc] | |
| def standard_t( | |
| self, df: _ArrayLikeFloat_co, size: None = ... | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def standard_t( | |
| self, df: _ArrayLikeFloat_co, size: _ShapeLike = ... | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def vonmises(self, mu: _FloatLike_co, kappa: _FloatLike_co, size: None = ...) -> float: ... # type: ignore[misc] | |
| def vonmises( | |
| self, mu: _ArrayLikeFloat_co, kappa: _ArrayLikeFloat_co, size: None | _ShapeLike = ... | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def pareto(self, a: _FloatLike_co, size: None = ...) -> float: ... # type: ignore[misc] | |
| def pareto( | |
| self, a: _ArrayLikeFloat_co, size: None | _ShapeLike = ... | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def weibull(self, a: _FloatLike_co, size: None = ...) -> float: ... # type: ignore[misc] | |
| def weibull( | |
| self, a: _ArrayLikeFloat_co, size: None | _ShapeLike = ... | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def power(self, a: _FloatLike_co, size: None = ...) -> float: ... # type: ignore[misc] | |
| def power( | |
| self, a: _ArrayLikeFloat_co, size: None | _ShapeLike = ... | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def standard_cauchy(self, size: None = ...) -> float: ... # type: ignore[misc] | |
| def standard_cauchy(self, size: _ShapeLike = ...) -> ndarray[Any, dtype[float64]]: ... | |
| def laplace( | |
| self, | |
| loc: _FloatLike_co = ..., | |
| scale: _FloatLike_co = ..., | |
| size: None = ..., | |
| ) -> float: ... # type: ignore[misc] | |
| def laplace( | |
| self, | |
| loc: _ArrayLikeFloat_co = ..., | |
| scale: _ArrayLikeFloat_co = ..., | |
| size: None | _ShapeLike = ..., | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def gumbel( | |
| self, | |
| loc: _FloatLike_co = ..., | |
| scale: _FloatLike_co = ..., | |
| size: None = ..., | |
| ) -> float: ... # type: ignore[misc] | |
| def gumbel( | |
| self, | |
| loc: _ArrayLikeFloat_co = ..., | |
| scale: _ArrayLikeFloat_co = ..., | |
| size: None | _ShapeLike = ..., | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def logistic( | |
| self, | |
| loc: _FloatLike_co = ..., | |
| scale: _FloatLike_co = ..., | |
| size: None = ..., | |
| ) -> float: ... # type: ignore[misc] | |
| def logistic( | |
| self, | |
| loc: _ArrayLikeFloat_co = ..., | |
| scale: _ArrayLikeFloat_co = ..., | |
| size: None | _ShapeLike = ..., | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def lognormal( | |
| self, | |
| mean: _FloatLike_co = ..., | |
| sigma: _FloatLike_co = ..., | |
| size: None = ..., | |
| ) -> float: ... # type: ignore[misc] | |
| def lognormal( | |
| self, | |
| mean: _ArrayLikeFloat_co = ..., | |
| sigma: _ArrayLikeFloat_co = ..., | |
| size: None | _ShapeLike = ..., | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def rayleigh(self, scale: _FloatLike_co = ..., size: None = ...) -> float: ... # type: ignore[misc] | |
| def rayleigh( | |
| self, scale: _ArrayLikeFloat_co = ..., size: None | _ShapeLike = ... | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def wald(self, mean: _FloatLike_co, scale: _FloatLike_co, size: None = ...) -> float: ... # type: ignore[misc] | |
| def wald( | |
| self, mean: _ArrayLikeFloat_co, scale: _ArrayLikeFloat_co, size: None | _ShapeLike = ... | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def triangular( | |
| self, | |
| left: _FloatLike_co, | |
| mode: _FloatLike_co, | |
| right: _FloatLike_co, | |
| size: None = ..., | |
| ) -> float: ... # type: ignore[misc] | |
| def triangular( | |
| self, | |
| left: _ArrayLikeFloat_co, | |
| mode: _ArrayLikeFloat_co, | |
| right: _ArrayLikeFloat_co, | |
| size: None | _ShapeLike = ..., | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def binomial(self, n: int, p: _FloatLike_co, size: None = ...) -> int: ... # type: ignore[misc] | |
| def binomial( | |
| self, n: _ArrayLikeInt_co, p: _ArrayLikeFloat_co, size: None | _ShapeLike = ... | |
| ) -> ndarray[Any, dtype[int64]]: ... | |
| def negative_binomial(self, n: _FloatLike_co, p: _FloatLike_co, size: None = ...) -> int: ... # type: ignore[misc] | |
| def negative_binomial( | |
| self, n: _ArrayLikeFloat_co, p: _ArrayLikeFloat_co, size: None | _ShapeLike = ... | |
| ) -> ndarray[Any, dtype[int64]]: ... | |
| def poisson(self, lam: _FloatLike_co = ..., size: None = ...) -> int: ... # type: ignore[misc] | |
| def poisson( | |
| self, lam: _ArrayLikeFloat_co = ..., size: None | _ShapeLike = ... | |
| ) -> ndarray[Any, dtype[int64]]: ... | |
| def zipf(self, a: _FloatLike_co, size: None = ...) -> int: ... # type: ignore[misc] | |
| def zipf( | |
| self, a: _ArrayLikeFloat_co, size: None | _ShapeLike = ... | |
| ) -> ndarray[Any, dtype[int64]]: ... | |
| def geometric(self, p: _FloatLike_co, size: None = ...) -> int: ... # type: ignore[misc] | |
| def geometric( | |
| self, p: _ArrayLikeFloat_co, size: None | _ShapeLike = ... | |
| ) -> ndarray[Any, dtype[int64]]: ... | |
| def hypergeometric(self, ngood: int, nbad: int, nsample: int, size: None = ...) -> int: ... # type: ignore[misc] | |
| def hypergeometric( | |
| self, | |
| ngood: _ArrayLikeInt_co, | |
| nbad: _ArrayLikeInt_co, | |
| nsample: _ArrayLikeInt_co, | |
| size: None | _ShapeLike = ..., | |
| ) -> ndarray[Any, dtype[int64]]: ... | |
| def logseries(self, p: _FloatLike_co, size: None = ...) -> int: ... # type: ignore[misc] | |
| def logseries( | |
| self, p: _ArrayLikeFloat_co, size: None | _ShapeLike = ... | |
| ) -> ndarray[Any, dtype[int64]]: ... | |
| def multivariate_normal( | |
| self, | |
| mean: _ArrayLikeFloat_co, | |
| cov: _ArrayLikeFloat_co, | |
| size: None | _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: None | _ShapeLike = ... | |
| ) -> ndarray[Any, dtype[int64]]: ... | |
| def multivariate_hypergeometric( | |
| self, | |
| colors: _ArrayLikeInt_co, | |
| nsample: int, | |
| size: None | _ShapeLike = ..., | |
| method: Literal["marginals", "count"] = ..., | |
| ) -> ndarray[Any, dtype[int64]]: ... | |
| def dirichlet( | |
| self, alpha: _ArrayLikeFloat_co, size: None | _ShapeLike = ... | |
| ) -> ndarray[Any, dtype[float64]]: ... | |
| def permuted( | |
| self, x: ArrayLike, *, axis: None | int = ..., out: None | ndarray[Any, Any] = ... | |
| ) -> ndarray[Any, Any]: ... | |
| def shuffle(self, x: ArrayLike, axis: int = ...) -> None: ... | |
| def default_rng( | |
| seed: None | _ArrayLikeInt_co | SeedSequence | BitGenerator | Generator = ... | |
| ) -> Generator: ... | |