std.rand

xorshift64* prng; same seed, same sequence; not for crypto

Rng

pub Rng :: struct {
    state: u64,
}

seed

pub seed :: fn(s: u64) -> Rng

generator from a seed; 0 is remapped to a valid state

next_u64

pub next_u64 :: fn(self: *Rng) -> u64

next raw u64; advances the state

next_u32

pub next_u32 :: fn(self: *Rng) -> u32

next_f32

pub next_f32 :: fn(self: *Rng) -> f32

float in [0, 1), 24-bit mantissa

range_i32

pub range_i32 :: fn(self: *Rng, lo: i32, hi: i32) -> i32

uniform int in [lo, hi); lo if empty

range_f32

pub range_f32 :: fn(self: *Rng, lo: f32, hi: f32) -> f32

float in [lo, hi)

chance

pub chance :: fn(self: *Rng, p: f32) -> bool

true with probability p, clamped to 0..1

sign

pub sign :: fn(self: *Rng) -> f32

-1 or +1

below

pub below :: fn(self: *Rng, n: u64) -> u64

uniform int in [0, n), unbiased (rejection); 0 if n is 0

range_u64

pub range_u64 :: fn(self: *Rng, lo: u64, hi: u64) -> u64

uniform int in [lo, hi); lo if empty

next_f64

pub next_f64 :: fn(self: *Rng) -> f64

float in [0, 1), 53-bit mantissa

fill_bytes

pub fill_bytes :: fn(self: *Rng, out: []u8)

shuffle

pub shuffle :: fn($T: type, self: *Rng, xs: []T)

uniform shuffle, fisher-yates

choose

pub choose :: fn($T: type, self: *Rng, xs: []const T) -> ?T

uniform pick; null if empty