Struct Rng 

pub struct Rng<B: RandomBackend> { /* private fields */ }

A random number generator that works with any backend implementing RandomBackend.

This struct provides a consistent interface for random number generation, regardless of the underlying algorithm used.

Type Parameters

• B - The backend type that implements RandomBackend

Examples

use aporia::{Rng, backend::XorShift};

let backend = XorShift::new(12345);
let mut rng = Rng::new(backend);

let random_number = rng.next_u64();
let random_float = rng.next_f64();

Iterators and helpers:

use aporia::{Rng, backend::XorShift};
let mut rng = Rng::new(XorShift::new(1));
 
// Take 3 u64 values
let count = rng.iter_u64().take(3).count();
assert_eq!(count, 3);
 
// Use for-loop via IntoIterator for &mut Rng to consume a few values
let mut n = 0usize;
for _ in &mut rng {
    n += 1;
    if n == 4 { break; }
}
assert_eq!(n, 4);

Implementations

impl<B: RandomBackend> Rng<B>

pub fn new(backend: B) -> Self

Creates a new RNG with the specified backend.

Arguments

• backend - The RNG backend to use

Examples found in repository

examples/lcg.rs (line 5)

fn main() {
    let backend = LCG::new(12345);
    let mut rng = Rng::new(backend);
    println!("Random number: {}", rng.next_u64());
}

examples/pcg.rs (line 5)

fn main() {
    let backend = PCG::new(12345, 1);
    let mut rng = Rng::new(backend);
    println!("Random number: {}", rng.next_u64());
}

examples/xorshift.rs (line 5)

fn main() {
    let backend = XorShift::new(12345);
    let mut rng = Rng::new(backend);
    println!("Random number: {}", rng.next_u64());
}

examples/total.rs (line 9)

fn main() {
    // Using PCG
    let pcg = PCG::new(12345, 67890);
    let mut rng1 = Rng::new(pcg);

    // Using XorShift
    let xorshift = XorShift::new(12345);
    let mut rng2 = Rng::new(xorshift);

    // Using LCG
    let lcg = LCG::new(12345);
    let mut rng3 = Rng::new(lcg);

    // Using MT19937_64
    let mt19937_64 = MT19937_64::new(12345);
    let mut rng4 = Rng::new(mt19937_64);

    // Using SplitMix64
    let splitmix64 = SplitMix64::new(12345);
    let mut rng5 = Rng::new(splitmix64);

    // Using Xoshiro256StarStar
    let xoshiro256starstar = Xoshiro256StarStar::new(12345);
    let mut rng6 = Rng::new(xoshiro256starstar);

    println!("PCG: {}", rng1.next_u64());
    println!("XorShift: {}", rng2.next_u64());
    println!("LCG: {}", rng3.next_u64());
    println!("MT19937_64: {}", rng4.next_u64());
    println!("SplitMix64: {}", rng5.next_u64());
    println!("Xoshiro256StarStar: {}", rng6.next_u64());
}

pub fn next_u64(&mut self) -> u64

Generates the next 64-bit unsigned integer.

Returns

A randomly generated u64 value

Examples found in repository

examples/lcg.rs (line 6)

fn main() {
    let backend = LCG::new(12345);
    let mut rng = Rng::new(backend);
    println!("Random number: {}", rng.next_u64());
}

examples/pcg.rs (line 6)

fn main() {
    let backend = PCG::new(12345, 1);
    let mut rng = Rng::new(backend);
    println!("Random number: {}", rng.next_u64());
}

examples/xorshift.rs (line 6)

fn main() {
    let backend = XorShift::new(12345);
    let mut rng = Rng::new(backend);
    println!("Random number: {}", rng.next_u64());
}

examples/total.rs (line 31)

fn main() {
    // Using PCG
    let pcg = PCG::new(12345, 67890);
    let mut rng1 = Rng::new(pcg);

    // Using XorShift
    let xorshift = XorShift::new(12345);
    let mut rng2 = Rng::new(xorshift);

    // Using LCG
    let lcg = LCG::new(12345);
    let mut rng3 = Rng::new(lcg);

    // Using MT19937_64
    let mt19937_64 = MT19937_64::new(12345);
    let mut rng4 = Rng::new(mt19937_64);

    // Using SplitMix64
    let splitmix64 = SplitMix64::new(12345);
    let mut rng5 = Rng::new(splitmix64);

    // Using Xoshiro256StarStar
    let xoshiro256starstar = Xoshiro256StarStar::new(12345);
    let mut rng6 = Rng::new(xoshiro256starstar);

    println!("PCG: {}", rng1.next_u64());
    println!("XorShift: {}", rng2.next_u64());
    println!("LCG: {}", rng3.next_u64());
    println!("MT19937_64: {}", rng4.next_u64());
    println!("SplitMix64: {}", rng5.next_u64());
    println!("Xoshiro256StarStar: {}", rng6.next_u64());
}

pub fn next_f64(&mut self) -> f64

Generates the next floating-point number in the range [0, 1).

Returns

A randomly generated f64 value between 0 (inclusive) and 1 (exclusive)

pub fn next_u32(&mut self) -> u32

Generates the next 32-bit unsigned integer.

pub fn next_f32(&mut self) -> f32

Generates the next 32-bit floating point number in [0, 1).

Uses the upper 24 bits of a u64 sample to match f32 mantissa width.

pub fn next_bool(&mut self) -> bool

Generates a random boolean with p=0.5.

pub fn gen_range(&mut self, min: u64, max: u64) -> Result<u64, AporiaError>

Generates a random number within the given range.

Arguments

• min - The inclusive lower bound
• max - The exclusive upper bound

Returns

A randomly generated number within the range [min, max)

Panics

Panics if min >= max

Notes

Uses the unbiased “zone” rejection method to avoid modulo bias. Let range = max - min. Compute zone = u64::MAX - (u64::MAX % range), which is the largest multiple of range that fits in a u64. Draw 64-bit values until v < zone, then return min + (v % range). Because zone is an exact multiple of range, the modulo is uniform.

pub fn gen_range_f64(&mut self, min: f64, max: f64) -> Result<f64, AporiaError>

Generates a random floating-point number within the given range.

Arguments

• min - The inclusive lower bound
• max - The exclusive upper bound

Returns

A randomly generated f64 value within the range [min, max)

Panics

Panics if min >= max

pub fn fill_bytes(&mut self, buf: &mut [u8])

Fills buf with random bytes from the backend.

This is a convenience wrapper around RandomBackend::fill_bytes.

use aporia::{Rng, backend::XorShift};
let mut rng = Rng::new(XorShift::new(1));
let mut bytes = [0u8; 16];
rng.fill_bytes(&mut bytes);
// `bytes` now contains pseudorandom data

impl<B: RandomBackend> Rng<B>

pub fn iter_u64(&mut self) -> U64Iter<'_, B>

Returns an iterator that yields u64 values indefinitely.

pub fn iter_f64(&mut self) -> F64Iter<'_, B>

Returns an iterator that yields f64 values in [0, 1) indefinitely.

Trait Implementations

impl<B> Clone for Rng<B>

where B: RandomBackend + Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<B> Debug for Rng<B>

where B: RandomBackend + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, B: RandomBackend> IntoIterator for &'a mut Rng<B>

type Item = u64

The type of the elements being iterated over.

type IntoIter = U64Iter<'a, B>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.