package core:math/rand
Source

⌘K

Ctrl+K

Filter Results

Overview

Package core:math/rand implements various random number generators

Index

Types (3)

Default_Random_State
Generator
Generator_Query_Info

Constants (0)

This section is empty.

Variables (0)

This section is empty.

Procedures (54)

choice
choice_bit_set
choice_enum
create
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
float32_pareto
float32_range
float32_triangular
float32_uniform
float32_von_mises
float32_weibull
float64
float64_beta
float64_cauchy_lorentz
float64_exponential
float64_gamma
float64_gompertz
float64_laplace
float64_log_cauchy_lorentz
float64_log_normal
float64_normal
float64_pareto
float64_range
float64_triangular
float64_uniform
float64_von_mises
float64_weibull
int127
int127_max
int31
int31_max
int63
int63_max
int_max
norm_float64
perm
query_info
read
reset
reset_bytes
shuffle
uint128
uint32
uint64

Procedure Groups (0)

This section is empty.

Types

Default_Random_State ¶
Source

Default_Random_State :: runtime.Default_Random_State

Generator ¶
Source

Generator :: runtime.Random_Generator

Generator_Query_Info ¶
Source

Generator_Query_Info :: runtime.Random_Generator_Query_Info

Constants

This section is empty.

Variables

This section is empty.

Procedures

choice ¶
Source

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

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:

choice_bit_set ¶
Source

choice_bit_set :: proc(set: $T/bit_set[$E], gen := context.random_generator) -> (res: $E, 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

choice_enum ¶
Source

choice_enum :: proc($T: typeid, gen := context.random_generator) -> typeid {…}

create ¶
Source

create :: proc(seed: u64) -> (state: runtime.Default_Random_State) {…}

exp_float64 ¶
Source

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

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

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

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

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

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 alphabeta, variance is math.pow(alphabeta, 2)

float32_gompertz ¶
Source

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

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

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

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

Log Normal Distribution

float32_normal ¶
Source

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

Normal/Gaussian Distribution

float32_pareto ¶
Source

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

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

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

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

float32_uniform ¶
Source

float32_uniform :: float32_range

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

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

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

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

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

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

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

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 alphabeta, variance is math.pow(alphabeta, 2)

float64_gompertz ¶
Source

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

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

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

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

Log Normal Distribution

float64_normal ¶
Source

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

Normal/Gaussian Distribution

float64_pareto ¶
Source

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

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

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

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

float64_uniform ¶
Source

float64_uniform :: float64_range

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

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

float64_weibull ¶
Source

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

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

int127 ¶
Source

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

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 0

Example:

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

int127_max_example :: proc() {
	fmt.println(rand.int127_max(16))
}

Possible Output:

6
500

int31 ¶
Source

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

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 0

Example:

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

int31_max_example :: proc() {
	fmt.println(rand.int31_max(16))
}

Possible Output:

6
500

int63 ¶
Source

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

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 0

Example:

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

int63_max_example :: proc() {
	fmt.println(rand.int63_max(16))
}

Possible Output:

6
500

int_max ¶
Source

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 0

Example:

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

int_max_example :: proc() {
	fmt.println(rand.int_max(16))
}

Possible Output:

6
500

norm_float64 ¶
Source

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

perm ¶
Source

perm :: proc(n: int, allocator := context.allocator, gen := context.random_generator) -> (res: []int, err: runtime.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 "core:math/rand"
import "core:mem"
import "core:fmt"

perm_example :: proc() -> (err: mem.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]

query_info ¶
Source

query_info :: proc(gen := context.random_generator) -> runtime.Random_Generator_Query_Info {…}

read ¶
Source

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 ¶
Source

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

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:

reset_bytes ¶
Source

reset_bytes :: proc(bytes: []u8, 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]

uint128 ¶
Source

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

uint32 ¶
Source

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

uint64 ¶
Source

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

Procedure Groups

This section is empty.

Source Files

Generation Information

Generated with odin version dev-2025-04 (vendor "odin") Windows_amd64 @ 2025-04-28 21:11:26.360321100 +0000 UTC

package core:math/randSource

Overview

Index

Types

Constants

Variables

Procedures

Procedure Groups

Source Files

Generation Information

package core:math/rand
Source