Random number generators.

Collection Info

View Source
Collection
core
Path
math/rand
Entries
78
Constants 0
Types 5
Jump to Types
Default_Random_State Generator Generator_Query_Info PCG_Random_State Xoshiro256_Random_State
Procedures 71
Jump to Procedures
choice choice_bit_set choice_enum create_bytes create_u64 exp_float64 float32 float32_beta float32_cauchy_lorentz float32_exponential float32_gamma float32_gompertz float32_laplace float32_log_cauchy_lorentz float32_log_normal float32_normal +55 more
Procedure Groups 2
Jump to Procedure Groups
create reset
Variables 0

Source Files

Types

5

Procedures

71

choice #

Source 
@(require_results)
choice :: proc(array: $T/[]$E, gen := context.random_generator) -> (res: $$deferred_return) {…}

Returns a random element from the provided slice. If no generator is provided the global random number generator will be used. Inputs: - array: The slice to choose an element from Returns: - res: A random element from `array` Example: import "core:math/rand" import "core:fmt" choice_example :: proc() { data: [4]int = { 1, 2, 3, 4 } fmt.println(rand.choice(data[:])) fmt.println(rand.choice(data[:])) fmt.println(rand.choice(data[:])) fmt.println(rand.choice(data[:])) } Possible Output: 3 2 2 4

choice_bit_set #

Source 
@(require_results)
choice_bit_set :: proc(set: $T/bit_set[$E], gen := context.random_generator) -> (res: $$deferred_return, ok: bool) {…}

Returns a random *set* bit from the provided `bit_set`. Inputs: - set: The `bit_set` to choose a random set bit from Returns: - res: The randomly selected bit, or the zero value if `ok` is `false` - ok: Whether the bit_set was not empty and thus `res` is actually a random set bit Example: import "core:math/rand" import "core:fmt" choice_bit_set_example :: proc() { Flags :: enum { A, B = 10, C, } fmt.println(rand.choice_bit_set(bit_set[Flags]{})) fmt.println(rand.choice_bit_set(bit_set[Flags]{.B})) fmt.println(rand.choice_bit_set(bit_set[Flags]{.B, .C})) fmt.println(rand.choice_bit_set(bit_set[0..<15]{5, 1, 4})) } Possible Output: A false B true C true 5 true

exp_float64 #

Source 
@(require_results)
exp_float64 :: proc(gen := context.random_generator) -> f64 {…}

exp_float64 returns a exponential distribution in the range (0, max(f64)], with an exponential distribution who rate parameter is 1 (lambda) and whose mean is 1 (1/lambda). To produce a distribution with a differetn rate parameter, divide the result by the desired rate parameter "The Ziggurat Method for Generating Random Variables" Authors: George Marsaglia, Wai Wan Tsang Submitted: 2000-04-15. Published: 2000-10-02. https://www.jstatsoft.org/index.php/jss/article/view/v005i08/ziggurat.pdf [pdf] https://www.jstatsoft.org/article/view/v005i08 [web page]

float32 #

Source 
@(require_results)
float32 :: proc(gen := context.random_generator) -> (val: f32) {…}

Generates a random single floating point value in the range `[0, 1)` using the provided random number generator. If no generator is provided the global random number generator will be used. Returns: - val: A random single floating point value in the range `[0, 1)` Example: import "core:math/rand" import "core:fmt" float32_example :: proc() { fmt.println(rand.float32()) } Possible Output: 0.043 0.511

float32_beta #

Source 
@(require_results)
float32_beta :: proc(alpha, beta: f32, gen := context.random_generator) -> f32 {…}

Beta Distribution Required: alpha > 0 and beta > 0 Return values range between 0 and 1

float32_cauchy_lorentz #

Source 
@(require_results)
float32_cauchy_lorentz :: proc(x_0, gamma: f32, gen := context.random_generator) -> f32 {…}

Cauchy-Lorentz Distribution `x_0` is the location, `gamma` is the scale where `gamma` > 0

float32_exponential #

Source 
@(require_results)
float32_exponential :: proc(lambda: f32, gen := context.random_generator) -> f32 {…}

Exponential Distribution `lambda` is 1.0/(desired mean). It should be non-zero. Return values range from 0 to positive infinity if lambda > 0 negative infinity to 0 if lambda <= 0

float32_gamma #

Source 
@(require_results)
float32_gamma :: proc(alpha, beta: f32, gen := context.random_generator) -> f32 {…}

Gamma Distribution (NOT THE GAMMA FUNCTION) Required: alpha > 0 and beta > 0 math.pow(x, alpha-1) * math.exp(-x / beta) pdf(x) = -------------------------------------------- math.gamma(alpha) * math.pow(beta, alpha) mean is alpha*beta, variance is math.pow(alpha*beta, 2)

float32_gompertz #

Source 
@(require_results)
float32_gompertz :: proc(eta, b: f32, gen := context.random_generator) -> f32 {…}

Gompertz Distribution `eta` is the shape, `b` is the scale Both `eta` and `b` must be > 0

float32_laplace #

Source 
@(require_results)
float32_laplace :: proc(mean, b: f32, gen := context.random_generator) -> f32 {…}

Laplace Distribution `b` is the scale where `b` > 0

float32_log_cauchy_lorentz #

Source 
@(require_results)
float32_log_cauchy_lorentz :: proc(x_0, gamma: f32, gen := context.random_generator) -> f32 {…}

Log Cauchy-Lorentz Distribution `x_0` is the location, `gamma` is the scale where `gamma` > 0

float32_log_normal #

Source 
@(require_results)
float32_log_normal :: proc(mean, stddev: f32, gen := context.random_generator) -> f32 {…}

Log Normal Distribution

float32_normal #

Source 
@(require_results)
float32_normal :: proc(mean, stddev: f32, gen := context.random_generator) -> f32 {…}

Normal/Gaussian Distribution

float32_pareto #

Source 
@(require_results)
float32_pareto :: proc(alpha, beta: f32, gen := context.random_generator) -> f32 {…}

Pareto distribution, `alpha` is the shape parameter. https://wikipedia.org/wiki/Pareto_distribution

float32_range #

Source 
@(require_results)
float32_range :: proc(low, high: f32, gen := context.random_generator) -> (val: f32) {…}

Generates a random single floating point value in the range `[low, high)` using the provided random number generator. If no generator is provided the global random number generator will be used. Inputs: - low: The lower bounds of the value, this value is inclusive - high: The upper bounds of the value, this value is exclusive Returns: - val: A random single floating point value in the range [low, high) WARNING: Panics if `high < low` Example: import "core:math/rand" import "core:fmt" float32_range_example :: proc() { fmt.println(rand.float32_range(-10, 300)) } Possible Output: 15.312 273.15

float32_triangular #

Source 
@(require_results)
float32_triangular :: proc(lo, hi: f32, mode: Maybe($T=f32), gen := context.random_generator) -> f32 {…}

Triangular Distribution See: http://wikipedia.org/wiki/Triangular_distribution

float32_uniform #

Source 
@(require_results)
float32_uniform :: proc(low, high: f32, gen := context.random_generator) -> (val: f32) {…}

Generates a random single floating point value in the range `[low, high)` using the provided random number generator. If no generator is provided the global random number generator will be used. Inputs: - low: The lower bounds of the value, this value is inclusive - high: The upper bounds of the value, this value is exclusive Returns: - val: A random single floating point value in the range [low, high) WARNING: Panics if `high < low` Example: import "core:math/rand" import "core:fmt" float32_range_example :: proc() { fmt.println(rand.float32_range(-10, 300)) } Possible Output: 15.312 273.15

float32_von_mises #

Source 
@(require_results)
float32_von_mises :: proc(mean_angle, kappa: f32, gen := context.random_generator) -> f32 {…}

Circular Data (von Mises) Distribution `mean_angle` is the in mean angle between 0 and 2pi radians `kappa` is the concentration parameter which must be >= 0 When `kappa` is zero, the Distribution is a uniform Distribution over the range 0 to 2pi

float32_weibull #

Source 
@(require_results)
float32_weibull :: proc(alpha, beta: f32, gen := context.random_generator) -> f32 {…}

Weibull distribution, `alpha` is the scale parameter, `beta` is the shape parameter.

float64 #

Source 
@(require_results)
float64 :: proc(gen := context.random_generator) -> (val: f64) {…}

Generates a random double floating point value in the range `[0, 1)` using the provided random number generator. If no generator is provided the global random number generator will be used. Returns: - val: A random double floating point value in the range `[0, 1)` Example: import "core:math/rand" import "core:fmt" float64_example :: proc() { fmt.println(rand.float64()) } Possible Output: 0.043 0.511

float64_beta #

Source 
@(require_results)
float64_beta :: proc(alpha, beta: f64, gen := context.random_generator) -> f64 {…}

Beta Distribution Required: alpha > 0 and beta > 0 Return values range between 0 and 1

float64_cauchy_lorentz #

Source 
@(require_results)
float64_cauchy_lorentz :: proc(x_0, gamma: f64, gen := context.random_generator) -> f64 {…}

Cauchy-Lorentz Distribution `x_0` is the location, `gamma` is the scale where `gamma` > 0

float64_exponential #

Source 
@(require_results)
float64_exponential :: proc(lambda: f64, gen := context.random_generator) -> f64 {…}

Exponential Distribution `lambda` is 1.0/(desired mean). It should be non-zero. Return values range from 0 to positive infinity if lambda > 0 negative infinity to 0 if lambda <= 0

float64_gamma #

Source 
@(require_results)
float64_gamma :: proc(alpha, beta: f64, gen := context.random_generator) -> f64 {…}

Gamma Distribution (NOT THE GAMMA FUNCTION) Required: alpha > 0 and beta > 0 math.pow(x, alpha-1) * math.exp(-x / beta) pdf(x) = -------------------------------------------- math.gamma(alpha) * math.pow(beta, alpha) mean is alpha*beta, variance is math.pow(alpha*beta, 2)

float64_gompertz #

Source 
@(require_results)
float64_gompertz :: proc(eta, b: f64, gen := context.random_generator) -> f64 {…}

Gompertz Distribution `eta` is the shape, `b` is the scale Both `eta` and `b` must be > 0

float64_laplace #

Source 
@(require_results)
float64_laplace :: proc(mean, b: f64, gen := context.random_generator) -> f64 {…}

Laplace Distribution `b` is the scale where `b` > 0

float64_log_cauchy_lorentz #

Source 
@(require_results)
float64_log_cauchy_lorentz :: proc(x_0, gamma: f64, gen := context.random_generator) -> f64 {…}

Log Cauchy-Lorentz Distribution `x_0` is the location, `gamma` is the scale where `gamma` > 0

float64_log_normal #

Source 
@(require_results)
float64_log_normal :: proc(mean, stddev: f64, gen := context.random_generator) -> f64 {…}

Log Normal Distribution

float64_normal #

Source 
@(require_results)
float64_normal :: proc(mean, stddev: f64, gen := context.random_generator) -> f64 {…}

Normal/Gaussian Distribution

float64_pareto #

Source 
@(require_results)
float64_pareto :: proc(alpha: f64, gen := context.random_generator) -> f64 {…}

Pareto distribution, `alpha` is the shape parameter. https://wikipedia.org/wiki/Pareto_distribution

float64_range #

Source 
@(require_results)
float64_range :: proc(low, high: f64, gen := context.random_generator) -> (val: f64) {…}

Generates a random double floating point value in the range `[low, high)` using the provided random number generator. If no generator is provided the global random number generator will be used. WARNING: Panics if `high < low` Inputs: - low: The lower bounds of the value, this value is inclusive - high: The upper bounds of the value, this value is exclusive Returns: - val: A random double floating point value in the range [low, high) Example: import "core:math/rand" import "core:fmt" float64_range_example :: proc() { fmt.println(rand.float64_range(-10, 300)) } Possible Output: 15.312 273.15

float64_triangular #

Source 
@(require_results)
float64_triangular :: proc(lo, hi: f64, mode: Maybe($T=f64), gen := context.random_generator) -> f64 {…}

Triangular Distribution See: http://wikipedia.org/wiki/Triangular_distribution

float64_uniform #

Source 
@(require_results)
float64_uniform :: proc(low, high: f64, gen := context.random_generator) -> (val: f64) {…}

Generates a random double floating point value in the range `[low, high)` using the provided random number generator. If no generator is provided the global random number generator will be used. WARNING: Panics if `high < low` Inputs: - low: The lower bounds of the value, this value is inclusive - high: The upper bounds of the value, this value is exclusive Returns: - val: A random double floating point value in the range [low, high) Example: import "core:math/rand" import "core:fmt" float64_range_example :: proc() { fmt.println(rand.float64_range(-10, 300)) } Possible Output: 15.312 273.15

float64_von_mises #

Source 
@(require_results)
float64_von_mises :: proc(mean_angle, kappa: f64, gen := context.random_generator) -> f64 {…}

Circular Data (von Mises) Distribution `mean_angle` is the in mean angle between 0 and 2pi radians `kappa` is the concentration parameter which must be >= 0 When `kappa` is zero, the Distribution is a uniform Distribution over the range 0 to 2pi

float64_weibull #

Source 
@(require_results)
float64_weibull :: proc(alpha, beta: f64, gen := context.random_generator) -> f64 {…}

Weibull distribution, `alpha` is the scale parameter, `beta` is the shape parameter.

int_max #

Source 
@(require_results)
int_max :: proc(n: int, gen := context.random_generator) -> (val: int) {…}

Generates a random integer value in the range `[0, n)` using the provided random number generator. If no generator is provided the global random number generator will be used. Inputs: - n: The upper bound of the generated number, this value is exclusive Returns: - val: A random integer value in the range `[0, n)` WARNING: Panics if n is less than or equal to 0 Example: import "core:math/rand" import "core:fmt" int_max_example :: proc() { fmt.println(rand.int_max(16)) } Possible Output: 6 13

int_range #

Source 
@(require_results)
int_range :: proc(lo, hi: int, gen := context.random_generator) -> (val: int) {…}

Generates a random signed integer value in the range `[lo, hi)` using the provided random number generator. If no generator is provided the global random number generator will be used. Inputs: - lo: The lower bound of the generated number, this value is inclusice - hi: The upper bound of the generated number, this value is exclusive Returns: - val: A random integer value in the range `[lo, hi)` WARNING: Panics if `lo` is greater or equal to `hi` Example: import "core:math/rand" import "core:fmt" int_range_example :: proc() { fmt.println(rand.int_range(-10,10)) } Possible Output: 6 -9

int127 #

Source 
@(require_results)
int127 :: proc(gen := context.random_generator) -> (val: i128) {…}

Generates a random 127 bit value using the provided random number generator. If no generator is provided the global random number generator will be used. The sign bit will always be set to 0, thus all generated numbers will be positive. Returns: - val: A random 127 bit value Example: import "core:math/rand" import "core:fmt" int127_example :: proc() { fmt.println(rand.int127()) } Possible Output: 10 389

int127_max #

Source 
@(require_results)
int127_max :: proc(n: i128, gen := context.random_generator) -> (val: i128) {…}

Generates a random 127 bit value in the range `[0, n)` using the provided random number generator. If no generator is provided the global random number generator will be used. Inputs: - n: The upper bound of the generated number, this value is exclusive Returns: - val: A random 127 bit value in the range `[0, n)` WARNING: Panics if n is less than or equal to 0 Example: import "core:math/rand" import "core:fmt" int127_max_example :: proc() { fmt.println(rand.int127_max(16)) } Possible Output: 6 13

int128_range #

Source 
int128_range :: proc(lo, hi: i128, gen := context.random_generator) -> (val: i128) {…}

Generates a random signed 128 bit value in the range `[lo, hi)` using the provided random number generator. If no generator is provided the global random number generator will be used. Inputs: - lo: The lower bound of the generated number, this value is inclusice - hi: The upper bound of the generated number, this value is exclusive Returns: - val: A random 128 bit value in the range `[lo, hi)` WARNING: Panics if `lo` is greater or equal to `hi` Example: import "core:math/rand" import "core:fmt" int128_range_example :: proc() { fmt.println(rand.int128_range(-10,10)) } Possible Output: 6 -9

int31 #

Source 
@(require_results)
int31 :: proc(gen := context.random_generator) -> (val: i32) {…}

Generates a random 31 bit value using the provided random number generator. If no generator is provided the global random number generator will be used. The sign bit will always be set to 0, thus all generated numbers will be positive. Returns: - val: A random 31 bit value Example: import "core:math/rand" import "core:fmt" int31_example :: proc() { fmt.println(rand.int31()) } Possible Output: 10 389

int31_max #

Source 
@(require_results)
int31_max :: proc(n: i32, gen := context.random_generator) -> (val: i32) {…}

Generates a random 31 bit value in the range `[0, n)` using the provided random number generator. If no generator is provided the global random number generator will be used. Inputs: - n: The upper bound of the generated number, this value is exclusive Returns: - val: A random 31 bit value in the range `[0, n)` WARNING: Panics if n is less than or equal to 0 Example: import "core:math/rand" import "core:fmt" int31_max_example :: proc() { fmt.println(rand.int31_max(16)) } Possible Output: 6 13

int32_range #

Source 
int32_range :: proc(lo, hi: i32, gen := context.random_generator) -> (val: i32) {…}

Generates a random signed 32 bit value in the range `[lo, hi)` using the provided random number generator. If no generator is provided the global random number generator will be used. Inputs: - lo: The lower bound of the generated number, this value is inclusice - hi: The upper bound of the generated number, this value is exclusive Returns: - val: A random 32 bit value in the range `[lo, hi)` WARNING: Panics if `lo` is greater or equal to `hi` Example: import "core:math/rand" import "core:fmt" int32_range_example :: proc() { fmt.println(rand.int32_range(-10,10)) } Possible Output: 6 -9

int63 #

Source 
@(require_results)
int63 :: proc(gen := context.random_generator) -> (val: i64) {…}

Generates a random 63 bit value using the provided random number generator. If no generator is provided the global random number generator will be used. The sign bit will always be set to 0, thus all generated numbers will be positive. Returns: - val: A random 63 bit value Example: import "core:math/rand" import "core:fmt" int63_example :: proc() { fmt.println(rand.int63()) } Possible Output: 10 389

int63_max #

Source 
@(require_results)
int63_max :: proc(n: i64, gen := context.random_generator) -> (val: i64) {…}

Generates a random 63 bit value in the range `[0, n)` using the provided random number generator. If no generator is provided the global random number generator will be used. Inputs: - n: The upper bound of the generated number, this value is exclusive Returns: - val: A random 63 bit value in the range `[0, n)` WARNING: Panics if n is less than or equal to 0 Example: import "core:math/rand" import "core:fmt" int63_max_example :: proc() { fmt.println(rand.int63_max(16)) } Possible Output: 6 13

int64_range #

Source 
int64_range :: proc(lo, hi: i64, gen := context.random_generator) -> (val: i64) {…}

Generates a random signed 64 bit value in the range `[lo, hi)` using the provided random number generator. If no generator is provided the global random number generator will be used. Inputs: - lo: The lower bound of the generated number, this value is inclusice - hi: The upper bound of the generated number, this value is exclusive Returns: - val: A random 64 bit value in the range `[lo, hi)` WARNING: Panics if `lo` is greater or equal to `hi` Example: import "core:math/rand" import "core:fmt" int64_range_example :: proc() { fmt.println(rand.int64_range(-10,10)) } Possible Output: 6 -9

norm_float64 #

Source 
@(require_results)
norm_float64 :: proc(gen := context.random_generator) -> f64 {…}

norm_float64 returns a normally distributed f64 in the range -max(f64) through +max(f64) inclusive, with a standard normal distribution with a mean of 0 and standard deviation of 1. sample = norm_float64() * std_dev + mean Normal distribution "The Ziggurat Method for Generating Random Variables" Authors: George Marsaglia, Wai Wan Tsang Submitted: 2000-04-15. Published: 2000-10-02. https://www.jstatsoft.org/index.php/jss/article/view/v005i08/ziggurat.pdf [pdf] https://www.jstatsoft.org/article/view/v005i08 [web page]

pcg_random_generator #

Source 
@(require_results)
pcg_random_generator :: proc "contextless" (state: ^PCG_Random_State = nil) -> Random_Generator {…}

Returns an instance of the PGC64 RXS-M-XS pseudorandom generator. If no initial state is provided, the PRNG will be lazily initialized with the system timestamp counter on first-use. WARNING: This random number generator is NOT cryptographically secure, and is additionally known to be flawed. It is only included for backward compatibility with historical releases of Odin. See: https://github.com/odin-lang/Odin/issues/5881 Inputs: - state: Optional initial PRNG state. Returns: - A `Generator` instance.

perm #

Source 
@(require_results)
perm :: proc(n: int, allocator := context.allocator, gen := context.random_generator) -> (res: []int, err: Allocator_Error) #optional_ok {…}

Creates a slice of `int` filled with random values using the provided random number generator. If no generator is provided the global random number generator will be used. *Allocates Using Provided Allocator* Inputs: - n: The size of the created slice - allocator: (default: context.allocator) Returns: - res: A slice filled with random values - err: An allocator error if one occured, `nil` otherwise Example: import "base:runtime" import "core:math/rand" import "core:fmt" perm_example :: proc() -> (err: runtime.Allocator_Error) { data := rand.perm(4) or_return fmt.println(data) defer delete(data, context.allocator) return } Possible Output: [7201011, 3, 9123, 231131] [19578, 910081, 131, 7]

read #

Source 
@(require_results)
read :: proc(p: []u8, gen := context.random_generator) -> (n: int) {…}

Fills a byte slice with random values using the provided random number generator. If no generator is provided the global random number generator will be used. Due to floating point precision there is no guarantee if the upper and lower bounds are inclusive/exclusive with the exact floating point value. Inputs: - p: The byte slice to fill Returns: - n: The number of bytes generated Example: import "core:math/rand" import "core:fmt" read_example :: proc() { data: [8]byte n := rand.read(data[:]) fmt.println(n) fmt.println(data) } Possible Output: 8 [32, 4, 59, 7, 1, 2, 2, 119]

reset_bytes #

Source 
reset_bytes :: proc(bytes: []u8, gen := context.random_generator) {…}

reset_u64 #

Source 
reset_u64 :: proc(seed: u64, gen := context.random_generator) {…}

shuffle #

Source 
shuffle :: proc(array: $T/[]$E, gen := context.random_generator) {…}

Randomizes the ordering of elements for the provided slice. If no generator is provided the global random number generator will be used. Inputs: - array: The slice to randomize Example: import "core:math/rand" import "core:fmt" shuffle_example :: proc() { data: [4]int = { 1, 2, 3, 4 } fmt.println(data) // the contents are in order rand.shuffle(data[:]) fmt.println(data) // the contents have been shuffled } Possible Output: [1, 2, 3, 4] [2, 4, 3, 1]

uint_max #

Source 
@(require_results)
uint_max :: proc(n: uint, gen := context.random_generator) -> (val: uint) {…}

Generates a random integer value in the range `[0, n)` using the provided random number generator. If no generator is provided the global random number generator will be used. Inputs: - n: The upper bound of the generated number, this value is exclusive Returns: - val: A random integer value in the range `[0, n)` WARNING: Panics if n is equal to 0 Example: import "core:math/rand" import "core:fmt" uint_max_example :: proc() { fmt.println(rand.uint_max(16)) } Possible Output: 6 13

uint_range #

Source 
@(require_results)
uint_range :: proc(lo, hi: uint, gen := context.random_generator) -> (val: uint) {…}

Generates a random unsigned integer value in the range `[lo, hi)` using the provided random number generator. If no generator is provided the global random number generator will be used. Inputs: - lo: The lower bound of the generated number, this value is inclusice - hi: The upper bound of the generated number, this value is exclusive Returns: - val: A random integer value in the range `[lo, hi)` WARNING: Panics if `lo` is greater or equal to `hi` Example: import "core:math/rand" import "core:fmt" uint_range_example :: proc() { fmt.println(rand.uint_range(5,15)) } Possible Output: 6 13

uint128 #

Source 
@(require_results)
uint128 :: proc(gen := context.random_generator) -> (val: u128) {…}

Generates a random 128 bit value using the provided random number generator. If no generator is provided the global random number generator will be used. Returns: - val: A random unsigned 128 bit value Example: import "core:math/rand" import "core:fmt" uint128_example :: proc() { fmt.println(rand.uint128()) } Possible Output: 10 389

uint128_max #

Source 
@(require_results)
uint128_max :: proc(n: u128, gen := context.random_generator) -> (val: u128) {…}

Generates a random 128 bit value in the range `[0, n)` using the provided random number generator. If no generator is provided the global random number generator will be used. Inputs: - n: The upper bound of the generated number, this value is exclusive Returns: - val: A random 128 bit value in the range `[0, n)` WARNING: Panics if n is equal to 0 Example: import "core:math/rand" import "core:fmt" uint128_max_example :: proc() { fmt.println(rand.uint128_max(16)) } Possible Output: 6 13

uint128_range #

Source 
uint128_range :: proc(lo, hi: u128, gen := context.random_generator) -> (val: u128) {…}

Generates a random unsigned 128 bit value in the range `[lo, hi)` using the provided random number generator. If no generator is provided the global random number generator will be used. Inputs: - lo: The lower bound of the generated number, this value is inclusice - hi: The upper bound of the generated number, this value is exclusive Returns: - val: A random 128 bit value in the range `[lo, hi)` WARNING: Panics if `lo` is greater or equal to `hi` Example: import "core:math/rand" import "core:fmt" uint128_range_example :: proc() { fmt.println(rand.uint128_range(5,15)) } Possible Output: 6 13

uint32 #

Source 
@(require_results)
uint32 :: proc(gen := context.random_generator) -> (val: u32) {…}

Generates a random 32 bit value using the provided random number generator. If no generator is provided the global random number generator will be used. Returns: - val: A random unsigned 32 bit value Example: import "core:math/rand" import "core:fmt" uint32_example :: proc() { fmt.println(rand.uint32()) } Possible Output: 10 389

uint32_max #

Source 
@(require_results)
uint32_max :: proc(n: u32, gen := context.random_generator) -> (val: u32) {…}

Generates a random 32 bit value in the range `[0, n)` using the provided random number generator. If no generator is provided the global random number generator will be used. Inputs: - n: The upper bound of the generated number, this value is exclusive Returns: - val: A random 32 bit value in the range `[0, n)` WARNING: Panics if n is equal to 0 Example: import "core:math/rand" import "core:fmt" uint32_max_example :: proc() { fmt.println(rand.uint32_max(16)) } Possible Output: 6 13

uint32_range #

Source 
uint32_range :: proc(lo, hi: u32, gen := context.random_generator) -> (val: u32) {…}

Generates a random unsigned 32 bit value in the range `[lo, hi)` using the provided random number generator. If no generator is provided the global random number generator will be used. Inputs: - lo: The lower bound of the generated number, this value is inclusice - hi: The upper bound of the generated number, this value is exclusive Returns: - val: A random 32 bit value in the range `[lo, hi)` WARNING: Panics if `lo` is greater or equal to `hi` Example: import "core:math/rand" import "core:fmt" uint32_range_example :: proc() { fmt.println(rand.uint32_range(5,15)) } Possible Output: 6 13

uint64 #

Source 
@(require_results)
uint64 :: proc(gen := context.random_generator) -> (val: u64) {…}

Generates a random 64 bit value using the provided random number generator. If no generator is provided the global random number generator will be used. Returns: - val: A random unsigned 64 bit value Example: import "core:math/rand" import "core:fmt" uint64_example :: proc() { fmt.println(rand.uint64()) } Possible Output: 10 389

uint64_max #

Source 
@(require_results)
uint64_max :: proc(n: u64, gen := context.random_generator) -> (val: u64) {…}

Generates a random 64 bit value in the range `[0, n)` using the provided random number generator. If no generator is provided the global random number generator will be used. Inputs: - n: The upper bound of the generated number, this value is exclusive Returns: - val: A random 64 bit value in the range `[0, n)` WARNING: Panics if n is equal to 0 Example: import "core:math/rand" import "core:fmt" uint64_max_example :: proc() { fmt.println(rand.uint64_max(16)) } Possible Output: 6 13

uint64_range #

Source 
uint64_range :: proc(lo, hi: u64, gen := context.random_generator) -> (val: u64) {…}

Generates a random unsigned 64 bit value in the range `[lo, hi)` using the provided random number generator. If no generator is provided the global random number generator will be used. Inputs: - lo: The lower bound of the generated number, this value is inclusice - hi: The upper bound of the generated number, this value is exclusive Returns: - val: A random 64 bit value in the range `[lo, hi)` WARNING: Panics if `lo` is greater or equal to `hi` Example: import "core:math/rand" import "core:fmt" uint64_range_example :: proc() { fmt.println(rand.uint64_range(5,15)) } Possible Output: 6 13

xoshiro256_random_generator #

Source 
@(require_results)
xoshiro256_random_generator :: proc "contextless" (state: ^Xoshiro256_Random_State = nil) -> Random_Generator {…}

Returns an instance of the xoshiro256** pseudorandom generator. If no initial state is provided, the PRNG will be lazily initialized with the system timestamp counter on first-use. WARNING: This random number generator is NOT cryptographically secure. Inputs: - state: Optional initial PRNG state. Returns: - A `Generator` instance.

Procedure Groups

2

reset #

Source 
reset :: proc{
	reset_u64,
	reset_bytes,
}

Reset the seed used by the context.random_generator. Inputs: - seed: The seed value Example: import "core:math/rand" import "core:fmt" reset_example :: proc() { rand.reset(1) fmt.println(rand.uint64()) } Possible Output: 10