module numpy.random.bitgen

Source: stdlib/numpy/random/bitgen.codon

---

u128 = UInt[128]

---

Binomial

Fields

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

Magic methods

__init__(self)

---

BitGenerator[G]

Fields

state: G

binomial: Optional[Binomial]

uinteger: u32

has_uint32: bool

G: type

Properties

seed_seq @property Method is a class property

Magic methods

__init__(self, state: G)

Methods

next64(self)

next32(self)

next_double(self)

next_float(self)

jumped(self, jumps: int)

standard_uniform(self)

standard_uniform_f(self)

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

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

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

random_standard_exponential(self)

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

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

random_standard_exponential_f(self)

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

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

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

random_standard_normal(self)

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

random_standard_normal_f(self)

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

random_standard_gamma(self, shape: float)

random_standard_gamma_f(self, shape: float32)

random_positive_int64(self)

random_positive_int32(self)

random_positive_int(self)

random_uint(self)

random_loggam(x: float)

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

random_exponential(self, scale: float)

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

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

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

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

random_chisquare(self, df: float)

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

random_standard_cauchy(self)

random_pareto(self, a: float)

random_weibull(self, a: float)

random_power(self, a: float)

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

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

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

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

random_rayleigh(self, mode: float)

random_standard_t(self, df: float)

random_poisson_mult(self, lam: float)

random_poisson_ptrs(self, lam: float)

random_poisson(self, lam: float)

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

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

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

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

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

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

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

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

random_logseries(self, p: float)

random_geometric_search(self, p: float)

random_geometric_inversion(self, p: float)

random_geometric(self, p: float)

random_zipf(self, a: float)

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

random_interval(self, max: u64)

gen_mask(max: u64)

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

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

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

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

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

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

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

bounded_lemire_uint64(self, rng: u64)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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(self, total: int, num_colors: int, colors: Ptr[int], nsample: int, num_variates: int, variates: Ptr[int])

next_raw(self)

random_raw(self, lock, size, output)

random_raw(self, size = None)

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

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

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

---

validate_output_shape(iter_shape, output: ndarray)

---

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

---

double_fill(func, size, lock, out)

---

float_fill(func, size, lock, out)

---

float_fill_from_double(func, size, lock, out)

---

CONS_NONE: Literal[int] = 0

---

CONS_NON_NEGATIVE: Literal[int] = 1

---

CONS_POSITIVE: Literal[int] = 2

---

CONS_POSITIVE_NOT_NAN: Literal[int] = 3

---

CONS_BOUNDED_0_1: Literal[int] = 4

---

CONS_BOUNDED_GT_0_1: Literal[int] = 5

---

CONS_BOUNDED_LT_0_1: Literal[int] = 6

---

CONS_GT_1: Literal[int] = 7

---

CONS_GTE_1: Literal[int] = 8

---

CONS_POISSON: Literal[int] = 9

---

MAX_INT = 0x7FFFFFFFFFFFFFFF

---

MAXSIZE = MAX_INT

---

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

---

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

---

convert_array_like(a)

---

gather_arrays(t)

---

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

---

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

---

Generator[G] @tuple Class is named tuple (cannot write fields)

Fields

lock: Lock

bit_generator: BitGenerator[G]

G: type

Magic methods

__new__(g: G)

__str__(self)

Methods

spawn(self, n_children: int)

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

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

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

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

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

bytes(self, length: int)

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

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

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

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

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

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

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

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

chisquare(self, df, size = None)

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

standard_cauchy(self, size = None)

standard_t(self, df, size = None)

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

pareto(self, a, size = None)

weibull(self, a, size = None)

power(self, a, size = None)

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

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

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

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

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

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

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

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

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

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

zipf(self, a, size = None)

geometric(self, p, size = None)

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

logseries(self, p, size = None)

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

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

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

dirichlet(self, alpha, size = None)

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

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

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