const RAND16_MULTIPLIER: u16 = 2053;
const RAND16_INCREMENT: u16 = 13849;
pub const DEFAULT_SEED: u16 = 1337;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Rng16 {
pub seed: u16,
}
impl Default for Rng16 {
#[inline]
fn default() -> Self {
Self::new(DEFAULT_SEED)
}
}
impl Rng16 {
#[inline]
pub const fn new(seed: u16) -> Self {
Self { seed }
}
#[inline]
pub fn add_entropy(&mut self, entropy: u16) {
self.seed = self.seed.wrapping_add(entropy);
}
#[inline]
fn next_state(&mut self) -> u16 {
self.seed = self
.seed
.wrapping_mul(RAND16_MULTIPLIER)
.wrapping_add(RAND16_INCREMENT);
self.seed
}
#[inline]
pub fn random8(&mut self) -> u8 {
let s = self.next_state();
(s as u8).wrapping_add((s >> 8) as u8)
}
#[inline]
pub fn random16(&mut self) -> u16 {
self.next_state()
}
#[inline]
pub fn gen_range<T: RangeSample>(&mut self, range: core::ops::Range<T>) -> T {
T::sample_range(self, range)
}
}
pub trait RangeSample: Sized + Copy {
#[doc(hidden)]
fn sample_range(rng: &mut Rng16, range: core::ops::Range<Self>) -> Self;
}
impl RangeSample for u8 {
#[inline]
fn sample_range(rng: &mut Rng16, range: core::ops::Range<u8>) -> u8 {
let span = range.end.wrapping_sub(range.start);
let r = rng.random8();
let scaled = ((r as u16 * span as u16) >> 8) as u8;
scaled.wrapping_add(range.start)
}
}
impl RangeSample for u16 {
#[inline]
fn sample_range(rng: &mut Rng16, range: core::ops::Range<u16>) -> u16 {
let span = range.end.wrapping_sub(range.start);
let r = rng.random16();
let scaled = ((span as u32 * r as u32) >> 16) as u16;
scaled.wrapping_add(range.start)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn deterministic_for_a_given_seed() {
let mut a = Rng16::new(1);
let mut b = Rng16::new(1);
for _ in 0..64 {
assert_eq!(a.random8(), b.random8());
assert_eq!(a.random16(), b.random16());
}
}
#[test]
fn different_seeds_diverge() {
let mut a = Rng16::new(1);
let mut b = Rng16::new(2);
let seq_a: [u16; 8] = core::array::from_fn(|_| a.random16());
let seq_b: [u16; 8] = core::array::from_fn(|_| b.random16());
assert_ne!(seq_a, seq_b);
}
#[test]
fn bounded_generation_stays_in_range() {
let mut rng = Rng16::new(42);
for _ in 0..2048 {
let a: u8 = rng.gen_range(0..10);
let b: u8 = rng.gen_range(5..15);
let c: u16 = rng.gen_range(0..1000);
let d: u16 = rng.gen_range(100..200);
assert!(a < 10);
assert!((5..15).contains(&b));
assert!(c < 1000);
assert!((100..200).contains(&d));
}
assert_eq!(rng.gen_range(0u8..0), 0);
assert_eq!(rng.gen_range(0u16..0), 0);
}
#[test]
fn entropy_perturbs_state() {
let mut a = Rng16::new(7);
let mut b = a;
b.add_entropy(0x1234);
assert_ne!(a.seed, b.seed);
assert_ne!(a.random16(), b.random16());
}
#[test]
fn seed_field_can_be_read_and_overwritten_directly() {
let mut rng = Rng16::new(0);
rng.seed = 0xBEEF;
assert_eq!(rng.seed, 0xBEEF);
}
}