package core:math/rand
Source

Types

Rand ¶
Source

Rand :: struct {
	state:     u64,
	inc:       u64,
	is_system: bool,
}

Constants

This section is empty.

Variables

This section is empty.

Procedures

choice ¶
Source

choice :: proc "odin" (array: $T/[]$T, r: ^Rand = nil) -> (res: $T) {…}
 

Returns a random element from the given slice

create ¶
Source

create :: proc "odin" (seed: u64) -> Rand {…}

exp_float64 ¶
Source

exp_float64 :: proc "odin" (r: ^Rand = nil) -> 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

float32 :: proc "odin" (r: ^Rand = nil) -> f32 {…}
 

Uniform random distribution [0, 1)

float32_beta ¶
Source

float32_beta :: proc "odin" (alpha, beta: f32, r: ^Rand = nil) -> f32 {…}
 

Beta Distribution

Required: alpha > 0 and beta > 0

Return values range between 0 and 1

float32_cauchy_lorentz ¶
Source

float32_cauchy_lorentz :: proc "odin" (x_0, gamma: f32, r: ^Rand = nil) -> f32 {…}
 

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

float32_exponential ¶
Source

float32_exponential :: proc "odin" (lambda: f32, r: ^Rand = nil) -> 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

float32_gamma :: proc "odin" (alpha, beta: f32, r: ^Rand = nil) -> 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 alphabeta, variance is math.pow(alphabeta, 2)

float32_gompertz ¶
Source

float32_gompertz :: proc "odin" (eta, b: f32, r: ^Rand = nil) -> f32 {…}
 

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

float32_laplace ¶
Source

float32_laplace :: proc "odin" (mean, b: f32, r: ^Rand = nil) -> f32 {…}
 

Laplace Distribution b is the scale where b > 0

float32_log_cauchy_lorentz ¶
Source

float32_log_cauchy_lorentz :: proc "odin" (x_0, gamma: f32, r: ^Rand = nil) -> f32 {…}
 

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

float32_log_normal ¶
Source

float32_log_normal :: proc "odin" (mean, stddev: f32, r: ^Rand = nil) -> f32 {…}
 

Log Normal Distribution

float32_normal ¶
Source

float32_normal :: proc "odin" (mean, stddev: f32, r: ^Rand = nil) -> f32 {…}
 

Normal/Gaussian Distribution

float32_pareto ¶
Source

float32_pareto :: proc "odin" (alpha, beta: f32, r: ^Rand = nil) -> f32 {…}
 

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

float32_range ¶
Source

float32_range :: proc "odin" (lo, hi: f32, r: ^Rand = nil) -> f32 {…}

float32_triangular ¶
Source

float32_triangular :: proc "odin" (lo, hi: f32, mode: runtime.Maybe(f32), r: ^Rand = nil) -> f32 {…}
 

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

float32_uniform ¶
Source

float32_uniform :: float32_range

float32_von_mises ¶
Source

float32_von_mises :: proc "odin" (mean_angle, kappa: f32, r: ^Rand = nil) -> 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

float32_weibull :: proc "odin" (alpha, beta: f32, r: ^Rand = nil) -> f32 {…}
 

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

float64 ¶
Source

float64 :: proc "odin" (r: ^Rand = nil) -> f64 {…}
 

Uniform random distribution [0, 1)

float64_beta ¶
Source

float64_beta :: proc "odin" (alpha, beta: f64, r: ^Rand = nil) -> f64 {…}
 

Beta Distribution

Required: alpha > 0 and beta > 0

Return values range between 0 and 1

float64_cauchy_lorentz ¶
Source

float64_cauchy_lorentz :: proc "odin" (x_0, gamma: f64, r: ^Rand = nil) -> f64 {…}
 

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

float64_exponential ¶
Source

float64_exponential :: proc "odin" (lambda: f64, r: ^Rand = nil) -> 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

float64_gamma :: proc "odin" (alpha, beta: f64, r: ^Rand = nil) -> 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 alphabeta, variance is math.pow(alphabeta, 2)

float64_gompertz ¶
Source

float64_gompertz :: proc "odin" (eta, b: f64, r: ^Rand = nil) -> f64 {…}
 

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

float64_laplace ¶
Source

float64_laplace :: proc "odin" (mean, b: f64, r: ^Rand = nil) -> f64 {…}
 

Laplace Distribution b is the scale where b > 0

float64_log_cauchy_lorentz ¶
Source

float64_log_cauchy_lorentz :: proc "odin" (x_0, gamma: f64, r: ^Rand = nil) -> f64 {…}
 

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

float64_log_normal ¶
Source

float64_log_normal :: proc "odin" (mean, stddev: f64, r: ^Rand = nil) -> f64 {…}
 

Log Normal Distribution

float64_normal ¶
Source

float64_normal :: proc "odin" (mean, stddev: f64, r: ^Rand = nil) -> f64 {…}
 

Normal/Gaussian Distribution

float64_pareto ¶
Source

float64_pareto :: proc "odin" (alpha: f64, r: ^Rand = nil) -> f64 {…}
 

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

float64_range ¶
Source

float64_range :: proc "odin" (lo, hi: f64, r: ^Rand = nil) -> f64 {…}

float64_triangular ¶
Source

float64_triangular :: proc "odin" (lo, hi: f64, mode: runtime.Maybe(f64), r: ^Rand = nil) -> f64 {…}
 

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

float64_uniform ¶
Source

float64_uniform :: float64_range

float64_von_mises ¶
Source

float64_von_mises :: proc "odin" (mean_angle, kappa: f64, r: ^Rand = nil) -> 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

float64_weibull :: proc "odin" (alpha, beta: f64, r: ^Rand = nil) -> f64 {…}
 

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

init ¶
Source

init :: proc "odin" (r: ^Rand, seed: u64) {…}

init_as_system ¶
Source

init_as_system :: proc "odin" (r: ^Rand = nil) {…}

int127 ¶
Source

int127 :: proc "odin" (r: ^Rand = nil) -> i128 {…}

int127_max ¶
Source

int127_max :: proc "odin" (n: i128, r: ^Rand = nil) -> i128 {…}

int31 ¶
Source

int31 :: proc "odin" (r: ^Rand = nil) -> i32 {…}

int31_max ¶
Source

int31_max :: proc "odin" (n: i32, r: ^Rand = nil) -> i32 {…}

int63 ¶
Source

int63 :: proc "odin" (r: ^Rand = nil) -> i64 {…}

int63_max ¶
Source

int63_max :: proc "odin" (n: i64, r: ^Rand = nil) -> i64 {…}

int_max ¶
Source

int_max :: proc "odin" (n: int, r: ^Rand = nil) -> int {…}

norm_float64 ¶
Source

norm_float64 :: proc "odin" (r: ^Rand = nil) -> 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]

perm ¶
Source

perm :: proc "odin" (n: int, r: ^Rand = nil, allocator := context.allocator) -> []int {…}
 

perm returns a slice of n ints in a pseudo-random permutation of integers in the range [0, n)

read ¶
Source

read :: proc "odin" (p: []u8, r: ^Rand = nil) -> (n: int) {…}

set_global_seed ¶
Source

set_global_seed :: proc "odin" (seed: u64) {…}

shuffle ¶
Source

shuffle :: proc "odin" (array: $T/[]$T, r: ^Rand = nil) {…}

uint128 ¶
Source

uint128 :: proc "odin" (r: ^Rand = nil) -> u128 {…}

uint32 ¶
Source

uint32 :: proc "odin" (r: ^Rand = nil) -> u32 {…}

uint64 ¶
Source

uint64 :: proc "odin" (r: ^Rand = nil) -> u64 {…}

Procedure Groups

This section is empty.

Source Files

Generation Information

Generated with odin version dev-2023-03 (vendor "odin") Windows_amd64 @ 2023-03-29 21:09:05.377726500 +0000 UTC