Struct Rng 

pub struct Rng { /* private fields */ }

A fast, high-quality pseudo-random number generator.

Uses the xoshiro256** algorithm (Blackman & Vigna), which has a period of 2^256 − 1 and passes all BigCrush tests.

Examples

use scivex_core::random::Rng;

let mut rng = Rng::new(42);
let value = rng.next_f64(); // uniform in [0, 1)
assert!((0.0..1.0).contains(&value));

Implementations

impl Rng

pub fn new(seed: u64) -> Self

Create a new PRNG seeded from a single u64.

The seed is expanded into the 4-word internal state via SplitMix64.

pub fn seed(&mut self, seed: u64)

Re-seed the generator, discarding all previous state.

Examples

use scivex_core::random::Rng;
let mut rng = Rng::new(1);
let first = rng.next_u64();
rng.seed(1);
assert_eq!(rng.next_u64(), first);

pub fn fork(&mut self, n: usize) -> Vec<Self>

Create n independent child RNGs by advancing the state.

Each child receives a unique seed derived from the parent’s state. This is useful for parallel workloads where each thread needs its own RNG to avoid contention.

Examples

use scivex_core::random::Rng;
let mut rng = Rng::new(42);
let children = rng.fork(4);
assert_eq!(children.len(), 4);

pub fn next_u64(&mut self) -> u64

Generate the next random u64.

Examples

use scivex_core::random::Rng;
let mut rng = Rng::new(1);
let v = rng.next_u64(); // some pseudo-random u64
let _ = v; // value is deterministic but not checked here

pub fn next_f64(&mut self) -> f64

Generate a random f64 uniformly distributed in [0, 1).

Uses the upper 53 bits of next_u64 divided by 2^53.

pub fn next_normal_f64(&mut self) -> f64

Generate a standard normal (N(0,1)) f64 via the Ziggurat algorithm.

~97% of samples require only a multiply and comparison (no transcendentals), making this much faster than Box-Muller.

Examples

use scivex_core::random::Rng;
let mut rng = Rng::new(0);
// Draw 1000 samples and verify mean is near 0
let mean: f64 = (0..1000).map(|_| rng.next_normal_f64()).sum::<f64>() / 1000.0;
assert!(mean.abs() < 0.2);