use std::sync::atomic::{AtomicU32, Ordering};
#[derive(Debug, Clone, Copy)]
pub struct Rng {
state: u32,
}
impl Rng {
#[must_use]
pub const fn new(seed: u64) -> Self {
Self {
state: (seed & 0xffff_ffff) as u32,
}
}
#[must_use]
pub fn from_entropy() -> Self {
static COUNTER: AtomicU32 = AtomicU32::new(0);
let nanos = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos() as u64)
.unwrap_or(0x9e37_79b9);
let n = u64::from(COUNTER.fetch_add(1, Ordering::Relaxed));
Self::new(nanos ^ (n << 32) ^ (nanos >> 17))
}
fn next_u32(&mut self) -> u32 {
self.state = self.state.wrapping_add(0x6d2b_79f5);
let mut t = self.state;
t = (t ^ (t >> 15)).wrapping_mul(t | 1);
t ^= t.wrapping_add(t ^ (t >> 7)).wrapping_mul(t | 61);
t ^ (t >> 14)
}
pub fn next_f64(&mut self) -> f64 {
f64::from(self.next_u32()) / (f64::from(u32::MAX) + 1.0)
}
pub fn range(&mut self, lo: f64, hi: f64) -> f64 {
lo + (hi - lo) * self.next_f64()
}
pub fn offset(&mut self, x: f64, roughness: f64, gain: f64) -> f64 {
roughness * gain * self.range(-x, x)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn same_seed_yields_identical_stream() {
let mut a = Rng::new(42);
let mut b = Rng::new(42);
let va: Vec<f64> = (0..32).map(|_| a.next_f64()).collect();
let vb: Vec<f64> = (0..32).map(|_| b.next_f64()).collect();
assert_eq!(va, vb, "同种子必须逐点相同");
}
#[test]
fn different_seeds_diverge() {
let mut a = Rng::new(1);
let mut b = Rng::new(2);
let n = (0..16)
.filter(|_| (a.next_f64() - b.next_f64()).abs() > 0.1)
.count();
assert!(n > 4, "不同种子的序列应明显不同,got {n}/16");
}
#[test]
fn output_stays_in_unit_range() {
let mut r = Rng::new(7);
for _ in 0..10_000 {
let v = r.next_f64();
assert!((0.0..1.0).contains(&v), "got {v}");
}
}
#[test]
fn range_respects_bounds() {
let mut r = Rng::new(9);
for _ in 0..1000 {
let v = r.range(-3.0, 5.0);
assert!((-3.0..5.0).contains(&v), "got {v}");
}
}
#[test]
fn zero_roughness_means_no_jitter() {
let mut r = Rng::new(3);
for _ in 0..100 {
assert_eq!(r.offset(2.0, 0.0, 1.0), 0.0);
}
}
#[test]
fn entropy_seeds_differ_within_one_process() {
let mut a = Rng::from_entropy();
let mut b = Rng::from_entropy();
assert_ne!(a.next_u32(), b.next_u32());
}
}