#![allow(clippy::cast_precision_loss)]
#[derive(Debug, Clone)]
pub struct Rng {
state: [u64; 4],
spare_normal: Option<f64>,
}
impl Rng {
#[must_use]
pub const fn new(seed: u64) -> Self {
let mut z = seed;
let mut state = [0u64; 4];
let mut i = 0;
while i < 4 {
z = z.wrapping_add(0x9e37_79b9_7f4a_7c15);
let mut x = z;
x = (x ^ (x >> 30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);
x = (x ^ (x >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb);
state[i] = x ^ (x >> 31);
i += 1;
}
Self {
state,
spare_normal: None,
}
}
pub fn next_u64(&mut self) -> u64 {
let result = self.state[0]
.wrapping_add(self.state[3])
.rotate_left(23)
.wrapping_add(self.state[0]);
let t = self.state[1] << 17;
self.state[2] ^= self.state[0];
self.state[3] ^= self.state[1];
self.state[1] ^= self.state[2];
self.state[0] ^= self.state[3];
self.state[2] ^= t;
self.state[3] = self.state[3].rotate_left(45);
result
}
pub fn unit(&mut self) -> f64 {
(self.next_u64() >> 11) as f64 * (1.0 / 9_007_199_254_740_992.0)
}
fn open_unit(&mut self) -> f64 {
open_unit_from_bits(self.next_u64() >> 11)
}
pub fn standard_normal(&mut self) -> f64 {
if let Some(spare) = self.spare_normal.take() {
return spare;
}
let radius = libm::sqrt(-2.0 * libm::log(self.open_unit()));
let angle = core::f64::consts::TAU * self.unit();
self.spare_normal = Some(radius * libm::sin(angle));
radius * libm::cos(angle)
}
pub fn correlated_normal<const N: usize>(
&mut self,
covariance_sqrt: &[[f64; N]; N],
) -> [f64; N] {
let mut xi = [0.0; N];
for value in &mut xi {
*value = self.standard_normal();
}
let mut out = [0.0; N];
for i in 0..N {
let mut acc = 0.0;
for j in 0..N {
acc += covariance_sqrt[i][j] * xi[j];
}
out[i] = acc;
}
out
}
}
const fn open_unit_from_bits(bits: u64) -> f64 {
(bits + 1) as f64 * (1.0 / 9_007_199_254_740_992.0)
}
#[cfg(test)]
mod tests {
#![allow(
clippy::float_cmp,
clippy::many_single_char_names,
clippy::items_after_statements
)]
use super::*;
#[test]
fn the_generator_is_reproducible_and_seed_dependent() {
let mut a = Rng::new(20_260_814);
let mut b = Rng::new(20_260_814);
let mut c = Rng::new(20_260_815);
let (mut same, mut differ) = (0, 0);
for _ in 0..1000 {
let (x, y, z) = (a.next_u64(), b.next_u64(), c.next_u64());
if x == y {
same += 1;
}
if x != z {
differ += 1;
}
}
assert_eq!(same, 1000, "the same seed must replay exactly");
assert_eq!(
differ, 1000,
"1000 collisions between two seeds is not chance"
);
}
#[test]
fn the_generator_reproduces_the_published_xoshiro256pp_stream() {
const STREAM: [(u64, [u64; 4]); 3] = [
(
0,
[
0x5317_5d61_490b_23df,
0x61da_6f3d_c380_d507,
0x5c0f_df91_ec9a_7bfc,
0x02ee_bf8c_3bbe_5e1a,
],
),
(
1,
[
0xcfc5_d07f_6f03_c29b,
0xbf42_4132_963f_e08d,
0x19a3_7d57_57aa_f520,
0xbf08_119f_05cd_56d6,
],
),
(
42,
[
0xd076_4d4f_4476_689f,
0x519e_4174_576f_3791,
0xfbe0_7cfb_0c24_ed8c,
0xb37d_9f60_0cd8_35b8,
],
),
];
for (seed, want) in STREAM {
let mut rng = Rng::new(seed);
for (i, w) in want.into_iter().enumerate() {
assert_eq!(rng.next_u64(), w, "seed {seed}, draw {i}");
}
}
}
#[test]
fn the_open_unit_mapping_excludes_zero_and_includes_one() {
assert_eq!(open_unit_from_bits(0), 1.0 / 9_007_199_254_740_992.0);
assert_eq!(open_unit_from_bits((1 << 53) - 1), 1.0);
assert!(libm::log(open_unit_from_bits(0)).is_finite());
}
#[test]
fn the_uniform_draws_respect_their_intervals() {
let mut rng = Rng::new(7);
for _ in 0..100_000 {
let u = rng.unit();
assert!((0.0..1.0).contains(&u), "unit() returned {u}");
let o = rng.open_unit();
assert!(o > 0.0 && o <= 1.0, "open_unit() returned {o}");
}
}
#[test]
fn the_normal_draw_has_the_right_moments() {
let mut rng = Rng::new(1_234_567);
const COUNT: usize = 200_000;
let (mut m1, mut m2, mut m3, mut m4) = (0.0, 0.0, 0.0, 0.0);
for _ in 0..COUNT {
let x = rng.standard_normal();
m1 += x;
m2 += x * x;
m3 += x * x * x;
m4 += x * x * x * x;
}
let n = COUNT as f64;
let (mean, var) = (m1 / n, m2 / n);
let (skew, kurt) = (m3 / n, m4 / n);
assert!(mean.abs() < 0.01, "mean {mean}");
assert!((var - 1.0).abs() < 0.02, "variance {var}");
assert!(skew.abs() < 0.03, "skewness {skew}");
assert!((kurt - 3.0).abs() < 0.10, "kurtosis {kurt}");
}
#[test]
fn the_correlated_draw_is_the_factor_times_the_standard_draws() {
let l = [[2.0, 0.0], [1.0, 2.0]];
let mut applied = Rng::new(4242);
let got = applied.correlated_normal(&l);
let mut direct = Rng::new(4242);
let xi = [direct.standard_normal(), direct.standard_normal()];
assert_eq!(got, [2.0 * xi[0], xi[0] + 2.0 * xi[1]]);
}
#[test]
fn the_correlated_draw_reproduces_its_covariance() {
let l = [[2.0, 0.0], [1.0, 2.0]];
let mut rng = Rng::new(99);
const COUNT: usize = 200_000;
let mut sum = [0.0; 2];
let mut cov = [[0.0; 2]; 2];
for _ in 0..COUNT {
let x = rng.correlated_normal(&l);
for i in 0..2 {
sum[i] += x[i];
for j in 0..2 {
cov[i][j] += x[i] * x[j];
}
}
}
let n = COUNT as f64;
let want = [[4.0, 2.0], [2.0, 5.0]];
for i in 0..2 {
assert!(
(sum[i] / n).abs() < 0.03,
"component {i} mean {}",
sum[i] / n
);
for j in 0..2 {
let got = cov[i][j] / n;
assert!(
(got - want[i][j]).abs() < 0.08,
"cov[{i}][{j}] = {got}, want {}",
want[i][j]
);
}
}
}
}