use super::source::{JavaRandom, RandomSource};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum RandomMode {
Tlc,
Dive,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct Streams {
seed: i64,
mode: RandomMode,
}
impl Streams {
#[must_use]
pub const fn new(seed: i64, mode: RandomMode) -> Self {
Self { seed, mode }
}
#[must_use]
pub const fn seed(&self) -> i64 {
self.seed
}
#[must_use]
pub const fn mode(&self) -> RandomMode {
self.mode
}
#[must_use]
pub const fn startup(&self) -> Stream {
match self.mode {
RandomMode::Tlc => Stream::Java(JavaRandom::new(self.seed)),
RandomMode::Dive => Stream::Dive(DiveStream::new(self.seed, Domain::Startup, 0)),
}
}
#[must_use]
pub const fn state(&self, fp: u64) -> Stream {
match self.mode {
#[allow(clippy::cast_possible_wrap, reason = "Java's long: same bits")]
RandomMode::Tlc => Stream::Java(JavaRandom::new(fp as i64 ^ self.seed)),
RandomMode::Dive => Stream::Dive(DiveStream::new(self.seed, Domain::State, fp)),
}
}
#[must_use]
pub fn tlc_simulation_worker_seeds(&self, aril: u64, workers: usize) -> Vec<i64> {
let mut rng = JavaRandom::new(self.seed);
rng.set_seed_aril(self.seed, aril);
(0..workers).map(|_| rng.next_long()).collect()
}
#[must_use]
pub const fn tlc_simulation_values(&self) -> JavaRandom {
JavaRandom::new(self.seed)
}
#[must_use]
pub const fn simulation_trace(&self, trace: u64) -> Stream {
Stream::Dive(DiveStream::new(self.seed, Domain::Simulation, trace))
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Stream {
Java(JavaRandom),
Dive(DiveStream),
}
impl RandomSource for Stream {
fn next_bits(&mut self, bits: u32) -> i32 {
match self {
Self::Java(r) => r.next_bits(bits),
Self::Dive(r) => r.next_bits(bits),
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
enum Domain {
Startup,
State,
Simulation,
}
impl Domain {
const fn tag(self) -> u64 {
match self {
Self::Startup => 0x5354_4152_5455_5021, Self::State => 0x5354_4154_4521_2121, Self::Simulation => 0x5349_4d55_4c41_5445, }
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct DiveStream {
key: u64,
counter: u64,
}
const GOLDEN_GAMMA: u64 = 0x9e37_79b9_7f4a_7c15;
const fn mix64(mut z: u64) -> u64 {
z = (z ^ (z >> 30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);
z = (z ^ (z >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb);
z ^ (z >> 31)
}
impl DiveStream {
#[allow(clippy::cast_sign_loss, reason = "the seed's bits")]
const fn new(seed: i64, domain: Domain, key: u64) -> Self {
let k = mix64(mix64(seed as u64 ^ domain.tag()) ^ key);
Self { key: k, counter: 0 }
}
#[must_use]
pub const fn position(&self) -> u64 {
self.counter
}
}
impl RandomSource for DiveStream {
fn next_bits(&mut self, bits: u32) -> i32 {
debug_assert!((1..=32).contains(&bits));
self.counter = self.counter.wrapping_add(1);
let word = mix64(
self.key
.wrapping_add(self.counter.wrapping_mul(GOLDEN_GAMMA)),
);
#[allow(clippy::cast_possible_truncation, reason = "the top `bits` bits")]
let v = (word >> (64 - bits)) as u32;
v.cast_signed()
}
}
#[must_use]
pub fn parse_seed(text: &str) -> Option<i64> {
let digits = text
.strip_prefix('+')
.or_else(|| text.strip_prefix('-'))
.unwrap_or(text);
if digits.is_empty() || !digits.bytes().all(|b| b.is_ascii_digit()) {
return None;
}
text.parse().ok()
}
#[must_use]
pub fn fresh_seed() -> i64 {
use std::hash::{BuildHasher, Hasher};
let mut h = std::collections::hash_map::RandomState::new().build_hasher();
if let Ok(d) = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH) {
h.write_u128(d.as_nanos());
}
h.write_u32(std::process::id());
h.finish().cast_signed()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn seeds_parse_like_long_parse_long() {
assert_eq!(parse_seed("7"), Some(7));
assert_eq!(parse_seed("+7"), Some(7));
assert_eq!(parse_seed("-0"), Some(0));
assert_eq!(parse_seed("-9223372036854775808"), Some(i64::MIN));
assert_eq!(parse_seed("9223372036854775808"), None);
for bad in ["", "+", "-", " 7", "7 ", "0x10", "1e3", "--1", "+-1", "٧"] {
assert_eq!(parse_seed(bad), None, "{bad:?}");
}
}
#[test]
fn dive_streams_are_keyed() {
let s = Streams::new(42, RandomMode::Dive);
let draws = |mut st: Stream| (0..4).map(|_| st.next_long()).collect::<Vec<_>>();
assert_eq!(draws(s.state(5)), draws(s.state(5)));
assert_ne!(draws(s.state(5)), draws(s.state(6)));
assert_ne!(draws(s.state(0)), draws(s.startup()));
assert_ne!(draws(s.state(0)), draws(s.simulation_trace(0)));
assert_ne!(
draws(s.state(5)),
draws(Streams::new(43, RandomMode::Dive).state(5))
);
}
#[test]
fn tlc_state_stream_is_fp_xor_seed() {
let s = Streams::new(7, RandomMode::Tlc);
assert_eq!(s.state(0x10), Stream::Java(JavaRandom::new(0x17)));
assert_eq!(s.startup(), Stream::Java(JavaRandom::new(7)));
}
}