Skip to content

module random

module `random`¶

Source: stdlib/random.codon

`N` = `624`¶

`M` = `397`¶

`LOG4` = `_log(4.0)`¶

`NV_MAGICCONST` = `((4 * _exp(-0.5)) / _sqrt(2.0))`¶

`SG_MAGICCONST` = `(1.0 + _log(4.5))`¶

`TWOPI` = `(2.0 * _pi)`¶

`MATRIX_A` = `u32(0x9908b0df)`¶

`UPPER_MASK` = `u32(0x80000000)`¶

`LOWER_MASK` = `u32(0x7fffffff)`¶

`RandomGenerator` @tuple Class is named tuple (cannot write fields) ¶

Fields¶

`data`: `Ptr[u32]`¶

Properties¶

`index` @property Method is a class property ¶

`state` @property Method is a class property ¶

Magic methods¶

`new()`¶

Methods¶

`getstate(self)`¶

`setstate(self, state)`¶

`genrand_int32(self)`¶

`genrand_res53(self)`¶

`random(self)`¶

`init_u32(self, s: u32)`¶

`init_array(self, init_key: Ptr[u32], key_length: int)`¶

`init_int(self, s: int)`¶

`random_seed_time_pid(self)`¶

`seed(self, s: int)`¶

`seed(self)`¶

`Random`¶

Fields¶

`gen`: `RandomGenerator`¶

`gauss_next`: `Optional[float]`¶

Magic methods¶

`init(self, seed: Optional[int] = None)`¶

Methods¶

`seed(self, a: Optional[int])`¶

`getstate(self)`¶

`setstate(self, state)`¶

`getrandbits(self, k: int)`¶

`bit_length(self, n: int)`¶

`randrange(self, start: int, stop: int, step: int = 1)`¶

`randint(self, a: int, b: int)`¶

`random(self)`¶

`choice(self, sequence: Generator[T], T: type)`¶

`choice(self, sequence: List[T], T: type)` @overload Function is overloaded ¶

`shuffle(self, x)`¶

`uniform(self, a, b)`¶

`triangular(self, low: float, high: float, mode: float)`¶

`gammavariate(self, alpha: float, beta: float)`¶

`betavariate(self, alpha: float, beta: float)`¶

`expovariate(self, lambd: float)`¶

`gauss(self, mu: float = 0.0, sigma: float = 1.0)`¶

`paretovariate(self, alpha: float)`¶

`weibullvariate(self, alpha: float, beta: float)`¶

`normalvariate(self, mu: float = 0.0, sigma: float = 1.0)`¶

`lognormvariate(self, mu: float, sigma: float)`¶

`vonmisesvariate(self, mu: float, kappa: float)`¶

`sample(self, population, k: int)`¶

`choices(self, population, weights: Optional[List[int]], cum_weights: Optional[List[int]], k: int)`¶

`seed(a: int)`¶

`getrandbits(k: int)`¶

`randrange(start: int, stop: Optional[int] = None, step: int = 1)`¶

`randint(a: int, b: int)`¶

`choice(s)`¶

`choices(population, weights: Optional[List[int]] = None, cum_weights: Optional[List[int]] = None, k: int = 1)`¶

`shuffle(s)`¶

`sample(population, k: int)`¶

`random()`¶

`uniform(a, b)`¶

`triangular(low: float = 0.0, high: float = 1.0, mode: Optional[float] = None)`¶

`betavariate(alpha: float, beta: float)`¶

`expovariate(lambd: float)`¶

`gammavariate(alpha: float, beta: float)`¶

`gauss(mu: float, sigma: float)`¶

`lognormvariate(mu: float, sigma: float)`¶

`normalvariate(mu: float, sigma: float)`¶

`vonmisesvariate(mu: float, kappa: float)`¶

`paretovariate(alpha: float)`¶

`weibullvariate(alpha: float, beta: float)`¶