pub use crate::agent_book::TAKEN_WIDTH;
pub use crate::market::factors::{COMPONENT_COUNT, TICK_COMPONENT_COUNT};
pub const NOISE_PART_COUNT: usize = 3;
pub const RNG_STREAM_WIDTH: usize = 5;
pub const ENGINE_RNG_STREAMS: usize = crate::rng::stream::COUNT;
pub const ENGINE_RNG_STATE_WIDTH: usize = ENGINE_RNG_STREAMS * RNG_STREAM_WIDTH;
pub const MARKET_VARIANCE_STATE_WIDTH: usize = 6;
pub const SECTOR_COUNT: usize = crate::sectors::SECTORS.len();
#[cfg(test)]
mod tests {
use super::*;
use crate::engine::EngineRngState;
use crate::rng::RngState;
const PINNED: &[(&str, usize)] = &[
("COMPONENT_COUNT", 12),
("TICK_COMPONENT_COUNT", 9),
("NOISE_PART_COUNT", 3),
("RNG_STREAM_WIDTH", 5),
("ENGINE_RNG_STREAMS", 10),
("ENGINE_RNG_STATE_WIDTH", 50),
("MARKET_VARIANCE_STATE_WIDTH", 6),
("TAKEN_WIDTH", 5),
("SECTOR_COUNT", 12),
];
fn actual() -> Vec<(&'static str, usize)> {
vec![
("COMPONENT_COUNT", COMPONENT_COUNT),
("TICK_COMPONENT_COUNT", TICK_COMPONENT_COUNT),
("NOISE_PART_COUNT", NOISE_PART_COUNT),
("RNG_STREAM_WIDTH", RNG_STREAM_WIDTH),
("ENGINE_RNG_STREAMS", ENGINE_RNG_STREAMS),
("ENGINE_RNG_STATE_WIDTH", ENGINE_RNG_STATE_WIDTH),
("MARKET_VARIANCE_STATE_WIDTH", MARKET_VARIANCE_STATE_WIDTH),
("TAKEN_WIDTH", TAKEN_WIDTH),
("SECTOR_COUNT", SECTOR_COUNT),
]
}
#[test]
fn a_state_width_changes_only_on_purpose() {
assert_eq!(
actual(),
PINNED.to_vec(),
"a state width moved. Every host that saves state into buffers of \
these sizes breaks, and code that derived the width still \
compiles. Update PINNED only together with a CHANGELOG line \
giving the old and new width, in a release that may break the \
API (RELEASING.md, \"State shapes and widths\")"
);
}
#[test]
fn the_constants_describe_the_types() {
let RngState { state, increment, spare, uniforms, normals } = RngState {
state: 0,
increment: 0,
spare: None,
uniforms: 0,
normals: 0,
};
let fields = [
state as f64,
increment as f64,
spare.unwrap_or(f64::NAN),
uniforms as f64,
normals as f64,
];
assert_eq!(fields.len(), RNG_STREAM_WIDTH);
let s = RngState { state: 0, increment: 0, spare: None, uniforms: 0, normals: 0 };
let EngineRngState {
market,
economy,
external,
jumps,
volume,
volume_idio,
news,
overnight,
market_vol_level,
crisis_epicentre,
} = EngineRngState {
market: s,
economy: s,
external: s,
jumps: s,
volume: s,
volume_idio: s,
news: s,
overnight: s,
market_vol_level: s,
crisis_epicentre: s,
};
let streams = [
market, economy, external, jumps, volume, volume_idio, news,
overnight, market_vol_level, crisis_epicentre,
];
assert_eq!(streams.len(), ENGINE_RNG_STREAMS);
assert_eq!(streams.len() * RNG_STREAM_WIDTH, ENGINE_RNG_STATE_WIDTH);
let companies = crate::universe::random_universe(4, 1)
.iter()
.enumerate()
.map(|(i, g)| g.to_init().to_tick_company(i))
.collect();
let engine = crate::engine::Engine::with_params_keeping_opening(
1,
companies,
crate::economy::create_initial_economy_state(&Default::default()),
crate::economy::create_initial_central_bank_state(0),
crate::sectors::keys().iter().map(|s| s.to_string()).collect(),
crate::params::ModelParams::preset("pt-v20").unwrap(),
);
let _: &[[f64; COMPONENT_COUNT]] = engine.attribution();
let _: &[[f64; TICK_COMPONENT_COUNT]] = engine.tick_components();
let _: &[[f64; NOISE_PART_COUNT]] = engine.noise_parts();
let (a, b, c, d, e, f) = engine.market_variance_state();
assert_eq!([a, b, c, d, e, f].len(), MARKET_VARIANCE_STATE_WIDTH);
assert_eq!(crate::sectors::keys().len(), SECTOR_COUNT);
let book = crate::agent_book::BookState::default();
let _: &[[f64; TAKEN_WIDTH]] = &book.taken;
}
#[test]
fn rng_words_round_trip_at_the_published_widths() {
use crate::engine::{SessionBuffer, SessionRequest};
use crate::rng::stream;
let companies = crate::universe::random_universe(4, 3)
.iter()
.enumerate()
.map(|(i, g)| g.to_init().to_tick_company(i))
.collect();
let mut engine = crate::engine::Engine::new(
3,
companies,
crate::economy::create_initial_economy_state(&Default::default()),
crate::economy::create_initial_central_bank_state(0),
crate::sectors::keys().iter().map(|s| s.to_string()).collect(),
);
engine.open_market();
let bell = crate::market::GameTime::new(9, 30, 3);
engine.run_session(&SessionRequest::new(bell, 7), &mut SessionBuffer::new());
let state = engine.rng_state();
let words = state.to_words();
assert_eq!(words.len(), ENGINE_RNG_STATE_WIDTH);
assert_eq!(EngineRngState::from_words(&words), Ok(state));
assert!(
[state.market, state.economy].iter().any(|s| s.spare.is_some()),
"the test should cover a stream holding a spare"
);
let w = RNG_STREAM_WIDTH;
for (id, s) in [
(stream::MARKET, state.market),
(stream::NEWS, state.news),
(stream::VOLUME_IDIO, state.volume_idio),
(stream::CRISIS_EPICENTRE, state.crisis_epicentre),
] {
let k = id as usize;
let got: Vec<u64> = words[k * w..(k + 1) * w].iter().map(|x| x.to_bits()).collect();
let want: Vec<u64> = s.to_words().iter().map(|x| x.to_bits()).collect();
assert_eq!(got, want, "stream {id}");
}
let mut restored = engine.clone();
restored.set_rng_state(EngineRngState::from_words(&words).unwrap());
for _ in 0..5 {
assert_eq!(engine.draw_normal().to_bits(), restored.draw_normal().to_bits());
}
assert!(EngineRngState::from_words(&words[1..]).is_err());
assert!(RngState::from_words(&words[..w + 1]).is_err());
let mut even = state.market.to_words();
even[1] = f64::NAN; assert!(RngState::from_words(&even).unwrap_err().contains("even"));
let mut spare = state.market.to_words();
spare[2] = f64::INFINITY;
assert!(RngState::from_words(&spare).is_err());
let mut count = state.market.to_words();
count[3] = 1.5;
assert!(RngState::from_words(&count).is_err());
count[3] = -1.0;
assert!(RngState::from_words(&count).is_err());
}
#[test]
fn rng_streams_read_back_by_name_in_any_order() {
use crate::engine::{SessionBuffer, SessionRequest};
use crate::rng::stream;
let companies = crate::universe::random_universe(4, 5)
.iter()
.enumerate()
.map(|(i, g)| g.to_init().to_tick_company(i))
.collect();
let mut engine = crate::engine::Engine::new(
5,
companies,
crate::economy::create_initial_economy_state(&Default::default()),
crate::economy::create_initial_central_bank_state(0),
crate::sectors::keys().iter().map(|s| s.to_string()).collect(),
);
engine.open_market();
let bell = crate::market::GameTime::new(9, 30, 3);
engine.run_session(&SessionRequest::new(bell, 7), &mut SessionBuffer::new());
engine.close_day(1);
let state = engine.rng_state();
let ids = [
("market", stream::MARKET),
("economy", stream::ECONOMY),
("external", stream::EXTERNAL),
("jumps", stream::JUMPS),
("volume", stream::VOLUME),
("news", stream::NEWS),
("volume_idio", stream::VOLUME_IDIO),
("overnight", stream::OVERNIGHT),
("market_vol_level", stream::MARKET_VOL_LEVEL),
("crisis_epicentre", stream::CRISIS_EPICENTRE),
];
assert_eq!(ids.len(), ENGINE_RNG_STREAMS);
for (name, id) in ids {
assert_eq!(EngineRngState::STREAM_NAMES[id as usize], name);
}
let named = state.to_named_words();
let words = state.to_words();
let w = RNG_STREAM_WIDTH;
for (k, (name, block)) in named.iter().enumerate() {
assert_eq!(*name, EngineRngState::STREAM_NAMES[k]);
let a: Vec<u64> = block.iter().map(|x| x.to_bits()).collect();
let b: Vec<u64> = words[k * w..(k + 1) * w].iter().map(|x| x.to_bits()).collect();
assert_eq!(a, b, "{name}");
}
let field = |name: &str| match name {
"news" => state.news,
"volume_idio" => state.volume_idio,
"market" => state.market,
_ => unreachable!(),
};
for name in ["news", "volume_idio", "market"] {
let k = EngineRngState::STREAM_NAMES.iter().position(|n| *n == name).unwrap();
assert_eq!(named[k].1.map(f64::to_bits), field(name).to_words().map(f64::to_bits));
}
assert_ne!(state.news, state.volume_idio, "the test needs the two to differ");
let mut pairs: Vec<(&str, &[f64])> =
named.iter().map(|(n, b)| (*n, b.as_slice())).collect();
pairs.reverse();
assert_eq!(EngineRngState::from_named_words(&pairs), Ok(state));
let mut unknown = pairs.clone();
unknown[0].0 = "volume-idio";
assert!(EngineRngState::from_named_words(&unknown).unwrap_err().contains("unknown"));
let mut twice = pairs.clone();
twice[1] = twice[0];
assert!(EngineRngState::from_named_words(&twice).unwrap_err().contains("twice"));
assert!(EngineRngState::from_named_words(&pairs[1..]).unwrap_err().contains("missing"));
}
}