package core:math/rand

Source

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 r: The random number generator to use, or nil for the global generator

Returns:
res: A random element from array

import "core:math/rand"
import "core:fmt"

choice_example :: proc() {
	// Using the global random number generator
	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[:]))
}

3
2
2
4

Creates a new random number generator.

Inputs:
seed: The seed value to create the random number generator with

Returns:
res: The created random number generator

import "core:math/rand"
import "core:fmt"

create_example :: proc() {
	my_rand := rand.create(1)
	fmt.println(rand.uint64(&my_rand))
}

10

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]

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.

Inputs:
r: The random number generator to use, or nil for the global generator

Returns:
val: A random single floating point value in the range [0, 1)

import "core:math/rand"
import "core:fmt"

float32_example :: proc() {
	// Using the global random number generator
	fmt.println(rand.float32())
	// Using local random number generator
	my_rand := rand.create(1)
	fmt.println(rand.float32(&my_rand))
}

0.043
0.511

Beta Distribution

Required: alpha > 0 and beta > 0

Return values range between 0 and 1

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

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

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)

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

Laplace Distribution b is the scale where b > 0

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

Log Normal Distribution

Normal/Gaussian Distribution

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

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 r: The random number generator to use, or nil for the global generator

Returns:
val: A random single floating point value in the range [low, high)

WARNING: Panics if high < low

import "core:math/rand"
import "core:fmt"

float32_range_example :: proc() {
	// Using the global random number generator
	fmt.println(rand.float32_range(-10, 300))
	// Using local random number generator
	my_rand := rand.create(1)
	fmt.println(rand.float32_range(600, 900, &my_rand))
}

15.312
673.130

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

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 r: The random number generator to use, or nil for the global generator

Returns:
val: A random single floating point value in the range [low, high)

WARNING: Panics if high < low

import "core:math/rand"
import "core:fmt"

float32_range_example :: proc() {
	// Using the global random number generator
	fmt.println(rand.float32_range(-10, 300))
	// Using local random number generator
	my_rand := rand.create(1)
	fmt.println(rand.float32_range(600, 900, &my_rand))
}

15.312
673.130

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

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

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.

Inputs:
r: The random number generator to use, or nil for the global generator

Returns:
val: A random double floating point value in the range [0, 1)

import "core:math/rand"
import "core:fmt"

float64_example :: proc() {
	// Using the global random number generator
	fmt.println(rand.float64())
	// Using local random number generator
	my_rand := rand.create(1)
	fmt.println(rand.float64(&my_rand))
}

0.043
0.511

Beta Distribution

Required: alpha > 0 and beta > 0

Return values range between 0 and 1

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

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

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)

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

Laplace Distribution b is the scale where b > 0

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

Log Normal Distribution

Normal/Gaussian Distribution

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

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 r: The random number generator to use, or nil for the global generator

Returns:
val: A random double floating point value in the range [low, high)

import "core:math/rand"
import "core:fmt"

float64_range_example :: proc() {
	// Using the global random number generator
	fmt.println(rand.float64_range(-10, 300))
	// Using local random number generator
	my_rand := rand.create(1)
	fmt.println(rand.float64_range(600, 900, &my_rand))
}

15.312
673.130

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

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 r: The random number generator to use, or nil for the global generator

Returns:
val: A random double floating point value in the range [low, high)

import "core:math/rand"
import "core:fmt"

float64_range_example :: proc() {
	// Using the global random number generator
	fmt.println(rand.float64_range(-10, 300))
	// Using local random number generator
	my_rand := rand.create(1)
	fmt.println(rand.float64_range(600, 900, &my_rand))
}

15.312
673.130

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

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

Initialises a random number generator.

Inputs:
r: The random number generator to initialise seed: The seed value to initialise this random number generator

import "core:math/rand"
import "core:fmt"

init_example :: proc() {
	my_rand: rand.Rand
	rand.init(&my_rand, 1)
	fmt.println(rand.uint64(&my_rand))
}

10

Initialises a random number generator to use the system random number generator.
The system random number generator is platform specific.
On linux refer to the getrandom syscall.
On darwin refer to getentropy.
On windows refer to BCryptGenRandom.

All other platforms are not supported

Inputs:
r: The random number generator to use the system random number generator

WARNING: Panics if the system is not either windows, darwin or linux

import "core:math/rand"
import "core:fmt"

init_as_system_example :: proc() {
	my_rand: rand.Rand
	rand.init_as_system(&my_rand)
	fmt.println(rand.uint64(&my_rand))
}

10

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.

Inputs:
r: The random number generator to use, or nil for the global generator

Returns:
val: A random 127 bit value

import "core:math/rand"
import "core:fmt"

int127_example :: proc() {
	// Using the global random number generator
	fmt.println(rand.int127())
	// Using local random number generator
	my_rand := rand.create(1)
	fmt.println(rand.int127(&my_rand))
}

10
389

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 r: The random number generator to use, or nil for the global generator

Returns:
val: A random 127 bit value in the range [0, n)

WARNING: Panics if n is less than 0

import "core:math/rand"
import "core:fmt"

int127_max_example :: proc() {
	// Using the global random number generator
	fmt.println(rand.int127_max(16))
	// Using local random number generator
	my_rand := rand.create(1)
	fmt.println(rand.int127_max(1024, &my_rand))
}

6
500

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.

Inputs:
r: The random number generator to use, or nil for the global generator

Returns:
val: A random 31 bit value

import "core:math/rand"
import "core:fmt"

int31_example :: proc() {
	// Using the global random number generator
	fmt.println(rand.int31())
	// Using local random number generator
	my_rand := rand.create(1)
	fmt.println(rand.int31(&my_rand))
}

10
389

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 r: The random number generator to use, or nil for the global generator

Returns:
val: A random 31 bit value in the range [0, n)

WARNING: Panics if n is less than 0

import "core:math/rand"
import "core:fmt"

int31_max_example :: proc() {
	// Using the global random number generator
	fmt.println(rand.int31_max(16))
	// Using local random number generator
	my_rand := rand.create(1)
	fmt.println(rand.int31_max(1024, &my_rand))
}

6
500

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.

Inputs:
r: The random number generator to use, or nil for the global generator

Returns:
val: A random 63 bit value

import "core:math/rand"
import "core:fmt"

int63_example :: proc() {
	// Using the global random number generator
	fmt.println(rand.int63())
	// Using local random number generator
	my_rand := rand.create(1)
	fmt.println(rand.int63(&my_rand))
}

10
389

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 r: The random number generator to use, or nil for the global generator

Returns:
val: A random 63 bit value in the range [0, n)

WARNING: Panics if n is less than 0

import "core:math/rand"
import "core:fmt"

int63_max_example :: proc() {
	// Using the global random number generator
	fmt.println(rand.int63_max(16))
	// Using local random number generator
	my_rand := rand.create(1)
	fmt.println(rand.int63_max(1024, &my_rand))
}

6
500

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 r: The random number generator to use, or nil for the global generator

Returns:
val: A random integer value in the range [0, n)

WARNING: Panics if n is less than 0

import "core:math/rand"
import "core:fmt"

int_max_example :: proc() {
	// Using the global random number generator
	fmt.println(rand.int_max(16))
	// Using local random number generator
	my_rand := rand.create(1)
	fmt.println(rand.int_max(1024, &my_rand))
}

6
500

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]

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 r: The random number generator to use, or nil for the global generator allocator: (default: context.allocator)

Returns:
res: A slice filled with random values err: An allocator error if one occured, nil otherwise

import "core:math/rand"
import "core:mem"
import "core:fmt"

perm_example :: proc() -> (err: mem.Allocator_Error) {
	// Using the global random number generator and using the context allocator
	data := rand.perm(4) or_return
	fmt.println(data)
	defer delete(data, context.allocator)

	// Using local random number generator and temp allocator
	my_rand := rand.create(1)
	data_tmp := rand.perm(4, &my_rand, context.temp_allocator) or_return
	fmt.println(data_tmp)

	return
}

[7201011, 3, 9123, 231131]
[19578, 910081, 131, 7]

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 r: The random number generator to use, or nil for the global generator

Returns:
n: The number of bytes generated

import "core:math/rand"
import "core:fmt"

read_example :: proc() {
	// Using the global random number generator
	data: [8]byte
	n := rand.read(data[:])
	fmt.println(n)
	fmt.println(data)
}

8
[32, 4, 59, 7, 1, 2, 2, 119]

Sets the seed used by the global random number generator.

Inputs:
seed: The seed value

import "core:math/rand"
import "core:fmt"

set_global_seed_example :: proc() {
	rand.set_global_seed(1)
	fmt.println(rand.uint64())
}

10

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 r: The random number generator to use, or nil for the global generator

import "core:math/rand"
import "core:fmt"

shuffle_example :: proc() {
	// Using the global random number generator
	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
}

[1, 2, 3, 4]
[2, 4, 3, 1]

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.

Inputs:
r: The random number generator to use, or nil for the global generator

Returns:
val: A random unsigned 128 bit value

import "core:math/rand"
import "core:fmt"

uint128_example :: proc() {
	// Using the global random number generator
	fmt.println(rand.uint128())
	// Using local random number generator
	my_rand := rand.create(1)
	fmt.println(rand.uint128(&my_rand))
}

10
389

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.

Inputs:
r: The random number generator to use, or nil for the global generator

Returns:
val: A random unsigned 32 bit value

import "core:math/rand"
import "core:fmt"

uint32_example :: proc() {
	// Using the global random number generator
	fmt.println(rand.uint32())
	// Using local random number generator
	my_rand := rand.create(1)
	fmt.println(rand.uint32(&my_rand))
}

10
389

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.

Inputs:
r: The random number generator to use, or nil for the global generator

Returns:
val: A random unsigned 64 bit value

import "core:math/rand"
import "core:fmt"

uint64_example :: proc() {
	// Using the global random number generator
	fmt.println(rand.uint64())
	// Using local random number generator
	my_rand := rand.create(1)
	fmt.println(rand.uint64(&my_rand))
}

10
389