numpy.random.bitgen

Standard library module View source

variable u128

u128 = UInt[128]

class Binomial

class Binomial

View complete class API →

Fields 16

psave float

nsave int

r float

q float

fm float

m int

p1 float

xm float

xl float

xr float

c float

laml float

lamr float

p2 float

p3 float

p4 float

Constructors 1

__init__

__init__(self)

class BitGenerator

class BitGenerator[G]

View complete class API →

Fields 5

state G

binomial Optional[Binomial]

uinteger u32

has_uint32 bool

G type

Constructors 1

__init__

__init__(self, state: G)

Properties 1

seed_seq

@property

seed_seq(self)

Methods 97

next64

next64(self)

next32

next32(self)

next_double

next_double(self)

next_float

next_float(self)

jumped

jumped(self, jumps: int)

standard_uniform

standard_uniform(self)

standard_uniform_f

standard_uniform_f(self)

random_standard_uniform_fill

random_standard_uniform_fill(self, cnt: int, out: Ptr[float])

random_standard_uniform_fill_f

random_standard_uniform_fill_f(self, cnt: int, out: Ptr[float32])

standard_exponential_unlikely

standard_exponential_unlikely(self, idx: int, x: float)

random_standard_exponential

random_standard_exponential(self)

random_standard_exponential_fill

random_standard_exponential_fill(self, cnt: int, out: Ptr[float])

standard_exponential_unlikely_f

standard_exponential_unlikely_f(self, idx: int, x: float32)

random_standard_exponential_f

random_standard_exponential_f(self)

random_standard_exponential_fill_f

random_standard_exponential_fill_f(self, cnt: int, out: Ptr[float32])

random_standard_exponential_inv_fill

random_standard_exponential_inv_fill(self, cnt: int, out: Ptr[float])

random_standard_exponential_inv_fill_f

random_standard_exponential_inv_fill_f(self, cnt: int, out: Ptr[float32])

random_standard_normal

random_standard_normal(self)

random_standard_normal_fill

random_standard_normal_fill(self, cnt: int, out: Ptr[float])

random_standard_normal_f

random_standard_normal_f(self)

random_standard_normal_fill_f

random_standard_normal_fill_f(self, cnt: int, out: Ptr[float32])

random_standard_gamma

random_standard_gamma(self, shape: float)

random_standard_gamma_f

random_standard_gamma_f(self, shape: float32)

random_positive_int64

random_positive_int64(self)

random_positive_int32

random_positive_int32(self)

random_positive_int

random_positive_int(self)

random_uint

random_uint(self)

random_loggam

random_loggam(x: float)

random_normal

random_normal(self, loc: float, scale: float)

random_exponential

random_exponential(self, scale: float)

random_uniform

random_uniform(self, off: float, rng: float)

random_gamma

random_gamma(self, shape: float, scale: float)

random_gamma_f

random_gamma_f(self, shape: float32, scale: float32)

random_beta

random_beta(self, a: float, b: float)

random_chisquare

random_chisquare(self, df: float)

random_f

random_f(self, dfnum: float, dfden: float)

random_standard_cauchy

random_standard_cauchy(self)

random_pareto

random_pareto(self, a: float)

random_weibull

random_weibull(self, a: float)

random_power

random_power(self, a: float)

random_laplace

random_laplace(self, loc: float, scale: float)

random_gumbel

random_gumbel(self, loc: float, scale: float)

random_logistic

random_logistic(self, loc: float, scale: float)

random_lognormal

random_lognormal(self, mean: float, sigma: float)

random_rayleigh

random_rayleigh(self, mode: float)

random_standard_t

random_standard_t(self, df: float)

random_poisson_mult

random_poisson_mult(self, lam: float)

random_poisson_ptrs

random_poisson_ptrs(self, lam: float)

random_poisson

random_poisson(self, lam: float)

random_negative_binomial

random_negative_binomial(self, n: float, p: float)

random_binomial_btpe

random_binomial_btpe(self, n: int, p: float)

random_binomial_inversion

random_binomial_inversion(self, n: int, p: float)

random_binomial

random_binomial(self, p: float, n: int)

random_noncentral_chisquare

random_noncentral_chisquare(self, df: float, nonc: float)

random_noncentral_f

random_noncentral_f(self, dfnum: float, dfden: float, nonc: float)

random_wald

random_wald(self, mean: float, scale: float)

random_vonmises

random_vonmises(self, mu: float, kappa: float)

random_logseries

random_logseries(self, p: float)

random_geometric_search

random_geometric_search(self, p: float)

random_geometric_inversion

random_geometric_inversion(self, p: float)

random_geometric

random_geometric(self, p: float)

random_zipf

random_zipf(self, a: float)

random_triangular

random_triangular(self, left: float, mode: float, right: float)

random_interval

random_interval(self, max: u64)

gen_mask

gen_mask(max: u64)

buffered_uint16

buffered_uint16(self, bcnt: int, buf: u32)

buffered_uint8

buffered_uint8(self, bcnt: int, buf: u32)

bounded_masked_uint64

bounded_masked_uint64(self, rng: u64, mask: u64)

buffered_bounded_masked_uint32

buffered_bounded_masked_uint32(self, rng: u32, mask: u32, bcnt: int, buf: u32)

buffered_bounded_masked_uint16

buffered_bounded_masked_uint16(self, rng: u16, mask: u16, bcnt: int, buf: u32)

buffered_bounded_masked_uint8

buffered_bounded_masked_uint8(self, rng: u8, mask: u8, bcnt: int, buf: u32)

buffered_bounded_bool

buffered_bounded_bool(self, off: bool, rng: bool, mask: bool, bcnt: int, buf: u32)

bounded_lemire_uint64

bounded_lemire_uint64(self, rng: u64)

buffered_bounded_lemire_uint32

buffered_bounded_lemire_uint32(self, rng: u32, bcnt: int, buf: u32)

buffered_bounded_lemire_uint16

buffered_bounded_lemire_uint16(self, rng: u16, bcnt: int, buf: u32)

buffered_bounded_lemire_uint8

buffered_bounded_lemire_uint8(self, rng: u8, bcnt: int, buf: u32)

random_bounded_uint64

random_bounded_uint64(self, off: u64, rng: u64, mask: u64, use_masked: bool)

random_buffered_bounded_uint32

random_buffered_bounded_uint32(self, off: u32, rng: u32, mask: u32, use_masked: bool, bcnt: int, buf: u32)

random_buffered_bounded_uint16

random_buffered_bounded_uint16(self, off: u16, rng: u16, mask: u16, use_masked: bool, bcnt: int, buf: u32)

random_buffered_bounded_uint8

random_buffered_bounded_uint8(self, off: u8, rng: u8, mask: u8, use_masked: bool, bcnt: int, buf: u32)

random_buffered_bounded_bool

random_buffered_bounded_bool(self, off: bool, rng: bool, mask: bool, use_masked_bool, bcnt: int, buf: u32)

random_bounded_uint64_fill

random_bounded_uint64_fill(self, off: u64, rng: u64, cnt: int, use_masked: bool, out: Ptr[u64])

random_bounded_uint32_fill

random_bounded_uint32_fill(self, off: u32, rng: u32, cnt: int, use_masked: bool, out: Ptr[u32])

random_bounded_uint16_fill

random_bounded_uint16_fill(self, off: u16, rng: u16, cnt: int, use_masked: bool, out: Ptr[u16])

random_bounded_uint8_fill

random_bounded_uint8_fill(self, off: u8, rng: u8, cnt: int, use_masked: bool, out: Ptr[u8])

random_bounded_bool_fill

random_bounded_bool_fill(self, off: bool, rng: bool, cnt: int, use_masked: bool, out: Ptr[bool])

random_multinomial

random_multinomial(self, n: int, mnix: Ptr[int], pix: Ptr[float], d: int)

hypergeometric_sample

hypergeometric_sample(self, good: int, bad: int, sample: int)

hypergeometric_hrua

hypergeometric_hrua(self, good: int, bad: int, sample: int)

random_hypergeometric

random_hypergeometric(self, good: int, bad: int, sample: int)

random_multivariate_hypergeometric_count

random_multivariate_hypergeometric_count(self, total: int, num_colors: int, colors: Ptr[int], nsample: int, num_variates: int, variates: Ptr[int])

random_multivariate_hypergeometric_marginals

random_multivariate_hypergeometric_marginals(self, total: int, num_colors: int, colors: Ptr[int], nsample: int, num_variates: int, variates: Ptr[int])

next_raw

next_raw(self)

random_raw

random_raw(self, lock, size, output)

random_raw(self, size = None)

shuffle_raw

shuffle_raw(self, n: int, first: int, itemsize: int, stride: int, data: cobj, buf: cobj)

shuffle_int

shuffle_int(self, n: int, first: int, data: Ptr[int])

shuffle_raw_wrap

shuffle_raw_wrap(self, n: int, first: int, itemsize: int, stride: int, data: cobj, buf: cobj)

function validate_output_shape

validate_output_shape(iter_shape, output: ndarray)

function check_output

check_output(out, dtype: type, size, require_c_array: bool)

function double_fill

double_fill(func, size, lock, out)

function float_fill

float_fill(func, size, lock, out)

function float_fill_from_double

float_fill_from_double(func, size, lock, out)

variable CONS_NONE

CONS_NONE: Literal[int] = 0

variable CONS_NON_NEGATIVE

CONS_NON_NEGATIVE: Literal[int] = 1

variable CONS_POSITIVE

CONS_POSITIVE: Literal[int] = 2

variable CONS_POSITIVE_NOT_NAN

CONS_POSITIVE_NOT_NAN: Literal[int] = 3

variable CONS_BOUNDED_0_1

CONS_BOUNDED_0_1: Literal[int] = 4

variable CONS_BOUNDED_GT_0_1

CONS_BOUNDED_GT_0_1: Literal[int] = 5

variable CONS_BOUNDED_LT_0_1

CONS_BOUNDED_LT_0_1: Literal[int] = 6

variable CONS_GT_1

CONS_GT_1: Literal[int] = 7

variable CONS_GTE_1

CONS_GTE_1: Literal[int] = 8

variable CONS_POISSON

CONS_POISSON: Literal[int] = 9

variable MAX_INT

MAX_INT: Literal[int] = 0x7FFFFFFFFFFFFFFF

variable MAXSIZE

MAXSIZE: Literal[int] = MAX_INT

variable POISSON_LAM_MAX

POISSON_LAM_MAX = (MAX_INT - (sqrt(float(MAX_INT)) * 10))

function check_array_constraint

check_array_constraint(val, name: str, const: int)

function convert_array_like

convert_array_like(a)

function gather_arrays

gather_arrays(t)

function cont

cont(fn, size, lock, arrays, names, constraints, out = None, dtype: type = float)

function kahan_sum

kahan_sum(darr: Ptr[float], n: int)

class Generator

@tuple

class Generator[G]

View complete class API →

Fields 3

lock Lock

bit_generator BitGenerator[G]

G type

Constructors 1

__new__

__new__(g: G)

Methods 44

spawn

spawn(self, n_children: int)

random

random(self, size = None, dtype: type = float, out = None)

beta

beta(self, a, b, size = None)

exponential

exponential(self, scale = 1.0, size = None)

standard_exponential

standard_exponential(self, size = None, dtype: type = float, method: str = "zig", out = None)

integers

integers(self, low, high = None, size = None, dtype: type = int, endpoint: bool = False)

bytes

bytes(self, length: int)

choice

choice(self, a, size = None, replace: bool = True, p = None, axis: int = 0, shuffle: bool = True)

uniform

uniform(self, low = 0.0, high = 1.0, size = None)

standard_normal

standard_normal(self, size = None, dtype: type = float, out = None)

normal

normal(self, loc = 0.0, scale = 1.0, size = None)

standard_gamma

standard_gamma(self, shape, size = None, dtype: type = float, out = None)

gamma

gamma(self, shape, scale = 1.0, size = None)

f

f(self, dfnum, dfden, size = None)

noncentral_f

noncentral_f(self, dfnum, dfden, nonc, size = None)

chisquare

chisquare(self, df, size = None)

noncentral_chisquare

noncentral_chisquare(self, df, nonc, size = None)

standard_cauchy

standard_cauchy(self, size = None)

standard_t

standard_t(self, df, size = None)

vonmises

vonmises(self, mu, kappa, size = None)

pareto

pareto(self, a, size = None)

weibull

weibull(self, a, size = None)

power

power(self, a, size = None)

laplace

laplace(self, loc = 0.0, scale = 1.0, size = None)

gumbel

gumbel(self, loc = 0.0, scale = 1.0, size = None)

logistic

logistic(self, loc = 0.0, scale = 1.0, size = None)

lognormal

lognormal(self, mean = 0.0, sigma = 1.0, size = None)

rayleigh

rayleigh(self, scale = 1.0, size = None)

wald

wald(self, mean, scale, size = None)

triangular

triangular(self, left, mode, right, size = None)

binomial

binomial(self, n, p, size = None)

negative_binomial

negative_binomial(self, n, p, size = None)

poisson

poisson(self, lam = 1.0, size = None)

zipf

zipf(self, a, size = None)

geometric

geometric(self, p, size = None)

hypergeometric

hypergeometric(self, ngood, nbad, nsample, size = None)

logseries

logseries(self, p, size = None)

multivariate_normal

multivariate_normal(self, mean, cov, size = None, check_valid: Literal[str] = "warn", tol: float = 1e-8, method: Literal[str] = "svd")

multinomial

multinomial(self, n, pvals, size = None)

multivariate_hypergeometric

multivariate_hypergeometric(self, colors, nsample: int, size = None, method: str = "marginals")

dirichlet

dirichlet(self, alpha, size = None)

permuted

permuted(self, x, axis = None, out = None)

shuffle

shuffle(self, x, axis: int = 0)

permutation

permutation(self, x, axis: int = 0)

Special methods 1

__str__

__str__(self)