use crate::rng::GameRng;
pub const QUARTER_SESSIONS: i64 = 63;
pub const REAL_NAME_OFFSETS: [f64; 39] = [
8.0, 9.0, 9.0, 10.0, 10.0, 10.0, 11.0, 11.0, 12.0, 14.0, 14.0, 14.0, 15.0,
16.0, 16.0, 16.5, 17.0, 17.0, 17.5, 18.0, 18.0, 18.0, 18.0, 18.5, 19.0,
19.0, 19.0, 19.0, 19.5, 20.0, 20.0, 20.0, 20.0, 21.0, 32.0, 32.5, 33.0,
43.5, 58.0,
];
pub const JITTER: i64 = 3;
const SLOT_OFFSET: u64 = 0;
const SLOT_JITTER: u64 = 1;
const SLOT_SURPRISE: u64 = 2;
const SLOT_SESSION: u64 = 3;
const SLOT_FOLLOWTHROUGH: u64 = 4;
const SLOT_CYCLE: u64 = 5;
pub fn id_hash(id: &str) -> u64 {
let mut h: u64 = 0xcbf2_9ce4_8422_2325;
for b in id.as_bytes() {
h ^= *b as u64;
h = h.wrapping_mul(0x0000_0100_0000_01b3);
}
h
}
fn word(quarter: i64, slot: u64) -> u64 {
((quarter as u64) << 8) | slot
}
fn keyed(key: u64, name: u64, quarter: i64, slot: u64) -> GameRng {
GameRng::keyed(key, name, word(quarter, slot))
}
pub fn name_offset(key: u64, name: u64) -> i64 {
let mut g = GameRng::keyed(key, name, word(-1, SLOT_OFFSET));
let u = g.next_f64();
let n = REAL_NAME_OFFSETS.len();
let i = std::cmp::min((u * n as f64) as usize, n - 1);
(REAL_NAME_OFFSETS[i] + 0.5) as i64
}
pub fn reaction_session(key: u64, name: u64, quarter: i64) -> i64 {
let mut g = keyed(key, name, quarter, SLOT_JITTER);
let u = g.next_f64();
let j = std::cmp::min((u * (2 * JITTER + 1) as f64) as i64, 2 * JITTER) - JITTER;
let o = (name_offset(key, name) + j).clamp(1, QUARTER_SESSIONS - 1);
QUARTER_SESSIONS * quarter + o
}
pub fn reacts_on(key: u64, name: u64, day: i64) -> Option<i64> {
if day < 0 {
return None;
}
let q = day.div_euclid(QUARTER_SESSIONS);
(reaction_session(key, name, q) == day).then_some(q)
}
fn unit_t(g: &mut GameRng, df: f64) -> f64 {
let z = g.next_normal();
if df == 0.0 {
return z;
}
let k = df as usize;
let mut chi2 = 0.0;
for _ in 0..k {
let n = g.next_normal();
chi2 += n * n;
}
if !(chi2 > 0.0) {
return z;
}
z * crate::mathx::sqrt((df - 2.0) / chi2)
}
pub fn surprise_unit(key: u64, name: u64, quarter: i64, df: f64) -> f64 {
unit_t(&mut keyed(key, name, quarter, SLOT_SURPRISE), df)
}
fn minute_word(quarter: i64, slot: u64, minute: i64) -> u64 {
word(quarter, slot) ^ (((minute as u64) + 1) << 40)
}
pub fn session_unit(key: u64, name: u64, quarter: i64, minute: i64) -> f64 {
GameRng::keyed(key, name, minute_word(quarter, SLOT_SESSION, minute)).next_normal()
}
pub fn followthrough_unit(key: u64, name: u64, quarter: i64, minute: i64) -> f64 {
GameRng::keyed(key, name, minute_word(quarter, SLOT_FOLLOWTHROUGH, minute)).next_normal()
}
#[allow(dead_code)]
pub(crate) fn cycle_unit(key: u64, name: u64, quarter: i64) -> f64 {
keyed(key, name, quarter, SLOT_CYCLE).next_normal()
}
pub fn mean_one(sigma: f64, unit: f64) -> f64 {
sigma * unit - 0.5 * sigma * sigma
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn one_report_a_quarter_inside_the_quarter() {
for key in [1u64, 42, 0xdead_beef] {
for id in ["AAA", "BBB", "C0", "technology-7"] {
let h = id_hash(id);
for q in 0..40 {
let d = reaction_session(key, h, q);
assert!(d > 63 * q && d < 63 * (q + 1), "{d} outside quarter {q}");
assert_eq!(reacts_on(key, h, d), Some(q));
let hits = (63 * q..63 * (q + 1)).filter(|&x| reacts_on(key, h, x).is_some()).count();
assert_eq!(hits, 1);
}
}
}
}
#[test]
fn the_surprise_has_unit_variance() {
for df in [0.0, 4.0] {
let n = 40_000;
let (mut s, mut s2) = (0.0, 0.0);
for q in 0..n {
let x = surprise_unit(7, id_hash("X"), q, df);
s += x;
s2 += x * x;
}
let m = s / n as f64;
let v = s2 / n as f64 - m * m;
assert!(m.abs() < 0.03, "mean {m}");
assert!((v - 1.0).abs() < 0.08, "df {df} variance {v}");
}
}
#[test]
fn the_minute_walks_are_independent_unit_normals() {
let h = id_hash("X");
assert_ne!(session_unit(7, h, 3, 0), session_unit(7, h, 3, 1));
assert_ne!(session_unit(7, h, 3, 5), followthrough_unit(7, h, 3, 5));
assert_ne!(session_unit(7, h, 3, 5), session_unit(7, h, 4, 5));
let n = 400;
let mut s2 = 0.0;
for q in 0..n {
let day: f64 = (0..390).map(|m| session_unit(11, h, q, m)).sum();
s2 += day * day / 390.0;
}
let v = s2 / n as f64;
assert!((v - 1.0).abs() < 0.2, "variance of a session's walk {v}");
}
#[test]
fn offsets_follow_the_real_table() {
let mut offs: Vec<i64> = (0..4000).map(|i| name_offset(9, id_hash(&format!("N{i}")))).collect();
offs.sort();
let median = offs[offs.len() / 2];
assert!((17..=19).contains(&median), "median offset {median}");
assert!(*offs.first().unwrap() >= 8 && *offs.last().unwrap() <= 58);
}
}