package core:math/rand
Source

⌘K

Ctrl+K

Filter Results

Overview

Random number generators.

Index

Types (5)

Default_Random_State
Generator
Generator_Query_Info
PCG_Random_State
Xoshiro256_Random_State

Constants (0)

This section is empty.

Variables (0)

This section is empty.

Procedures (71)

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
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
int128_range
int31
int31_max
int32_range
int63
int63_max
int64_range
int_max
int_range
norm_float64
pcg_random_generator
pcg_random_generator_proc
perm
query_info
read
reset_bytes
reset_u64
shuffle
uint128
uint128_max
uint128_range
uint32
uint32_max
uint32_range
uint64
uint64_max
uint64_range
uint_max
uint_range
xoshiro256_random_generator
xoshiro256_random_generator_proc

Procedure Groups (2)

create
reset

Types

Default_Random_State ¶
Source

Default_Random_State :: runtime.Default_Random_State

Related Procedures With Returns

create_bytes
create_u64
create (procedure groups)

Generator ¶
Source

Generator :: runtime.Random_Generator

Related Procedures With Parameters

Related Procedures With Returns

PCG_Random_State ¶
Source

PCG_Random_State :: struct {
	state: u64,
	inc:   u64,
}

The state for a PCG64 RXS-M-XS pseudorandom generator.

Related Procedures With Parameters

pcg_random_generator

Xoshiro256_Random_State ¶
Source

Xoshiro256_Random_State :: struct {
	s: [4]u64,
}

The state for a xoshiro256** pseudorandom generator.

Related Procedures With Parameters

xoshiro256_random_generator

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 {…}

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 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
500

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

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 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
500

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

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 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
500

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

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

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

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

pcg_random_generator ¶
Source

pcg_random_generator :: proc "contextless" (state: ^PCG_Random_State = nil) -> runtime.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.

pcg_random_generator_proc ¶
Source

pcg_random_generator_proc :: proc(data: rawptr, mode: runtime.Random_Generator_Mode, p: []u8) {…}

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

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

Related Procedure Groups

reset

reset_u64 ¶
Source

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

Related Procedure Groups

reset

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

uint128_max ¶
Source

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

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

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

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

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

uint_max ¶
Source

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

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

xoshiro256_random_generator ¶
Source

xoshiro256_random_generator :: proc "contextless" (state: ^Xoshiro256_Random_State = nil) -> runtime.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.

xoshiro256_random_generator_proc ¶
Source

xoshiro256_random_generator_proc :: proc(data: rawptr, mode: runtime.Random_Generator_Mode, p: []u8) {…}

Procedure Groups

create ¶
Source

create :: proc{
	create_u64,
	create_bytes,
}

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:

Source Files

Generation Information

Generated with odin version dev-2025-12 (vendor "odin") Windows_amd64 @ 2025-12-01 21:12:41.108774800 +0000 UTC

package core:math/randSource

Overview

Index

Types

Related Procedures With Returns

Related Procedures With Parameters

Related Procedures With Returns

Related Procedures With Returns

Related Procedures With Parameters

Related Procedures With Parameters

Constants

Variables

Procedures

Related Procedure Groups

Related Procedure Groups

Related Procedure Groups

Related Procedure Groups

Procedure Groups

Source Files

Generation Information

package core:math/rand
Source