random

Standard library module View source

variable N

N = 624

variable M

M = 397

variable LOG4

LOG4 = _log(4.0)

variable NV_MAGICCONST

NV_MAGICCONST = (4 * _exp(-0.5)).cdiv(_sqrt(2.0))

variable SG_MAGICCONST

SG_MAGICCONST = (1.0 + _log(4.5))

variable TWOPI

TWOPI = (2.0 * _pi)

variable MATRIX_A

MATRIX_A = u32(0x9908b0df)

variable UPPER_MASK

UPPER_MASK = u32(0x80000000)

variable LOWER_MASK

LOWER_MASK = u32(0x7fffffff)

class RandomGenerator

@tuple

class RandomGenerator

View complete class API →

Fields 1

data Ptr[u32]

Constructors 1

__new__

__new__()

Properties 2

index

@property

index(self)

state

@property

state(self)

Methods 10

getstate

getstate(self)

setstate

setstate(self, state)

genrand_int32

genrand_int32(self)

genrand_res53

genrand_res53(self)

random

random(self)

init_u32

init_u32(self, s: u32)

init_array

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

init_int

init_int(self, s: int)

random_seed_time_pid

random_seed_time_pid(self)

seed

seed(self, s: int)

seed(self)

class Random

class Random

View complete class API →

Fields 2

gen RandomGenerator

gauss_next Optional[float]

Constructors 1

__init__

__init__(self, seed: Optional[int] = None)

Methods 23

seed

seed(self, a: Optional[int])

getstate

getstate(self)

setstate

setstate(self, state)

getrandbits

getrandbits(self, k: int)

bit_length

bit_length(self, n: int)

randrange

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

randint

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

random

random(self)

choice

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

@overload

choice(self, sequence: List[T], T: type)

shuffle

shuffle(self, x)

uniform

uniform(self, a, b)

triangular

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

gammavariate

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

betavariate

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

expovariate

expovariate(self, lambd: float)

gauss

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

paretovariate

paretovariate(self, alpha: float)

weibullvariate

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

normalvariate

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

lognormvariate

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

vonmisesvariate

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

sample

sample(self, population, k: int)

choices

choices(self, population, weights: Optional[List[T]], cum_weights: Optional[List[T]], k: int, T: type)

function seed

seed(a: int)

function getrandbits

getrandbits(k: int)

function randrange

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

function randint

randint(a: int, b: int)

function choice

choice(s)

function choices

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

function shuffle

shuffle(s)

function sample

sample(population, k: int)

function random

random()

function uniform

uniform(a, b)

function triangular

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

function betavariate

betavariate(alpha: float, beta: float)

function expovariate

expovariate(lambd: float)

function gammavariate

gammavariate(alpha: float, beta: float)

function gauss

gauss(mu: float, sigma: float)

function lognormvariate

lognormvariate(mu: float, sigma: float)

function normalvariate

normalvariate(mu: float, sigma: float)

function vonmisesvariate

vonmisesvariate(mu: float, kappa: float)

function paretovariate

paretovariate(alpha: float)

function weibullvariate

weibullvariate(alpha: float, beta: float)