use super::tick::TickCompany;
use crate::mathx;
const AVG_VOLUME_EMA_DAYS: f64 = 20.0;
const INTRADAY_VOLUME_MEAN: f64 = 1.45;
const VOLUME_SCALE_MEAN: f64 = 1.4;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[non_exhaustive]
pub enum AvgVolumePolicy {
#[default]
Hold,
ReferenceEma,
}
pub fn reset_daily_prices(companies: &mut [TickCompany]) {
for company in companies.iter_mut() {
let s = &mut company.stock;
s.previous_close = s.price;
s.open = s.price;
s.high = s.price;
s.low = s.price;
s.volume = 0.0;
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
#[non_exhaustive]
pub struct CloseInputs {
pub daily_innovation: Option<f64>,
pub sector_base_daily_variance: f64,
pub vix: f64,
pub vix_anchor: f64,
pub avg_volume: AvgVolumePolicy,
}
impl CloseInputs {
pub fn new(
daily_innovation: Option<f64>,
sector_base_daily_variance: f64,
vix: f64,
vix_anchor: f64,
) -> Self {
CloseInputs {
daily_innovation,
sector_base_daily_variance,
vix,
vix_anchor,
avg_volume: AvgVolumePolicy::Hold,
}
}
}
pub fn close_day(company: &mut TickCompany, inputs: &CloseInputs) {
close_day_with(&crate::params::PT_V1, company, inputs);
}
pub fn close_day_with(
params: &crate::params::ModelParams,
company: &mut TickCompany,
inputs: &CloseInputs,
) {
let market_cap = company.stock.market_cap;
let stock = &mut company.stock;
let daily_return = if stock.previous_close > 0.0 {
(stock.price - stock.previous_close) / stock.previous_close
} else {
0.0
};
let innovation = match inputs.daily_innovation {
Some(noise) if noise.is_finite() => noise,
_ => daily_return,
};
let beta = super::garch::garch_beta_for(params, market_cap);
let base_variance = if params.garch_vix_coupling == 0.0 {
inputs.sector_base_daily_variance
} else {
let ratio = inputs.vix / inputs.vix_anchor;
let c = params.garch_vix_coupling;
inputs.sector_base_daily_variance
* (1.0 - c + super::garch::vix_coupled_response(params, c, ratio))
};
stock.garch_variance = if params.garch_cascade_components >= 1.0 {
super::garch::update_garch_cascade(
params,
beta,
&mut stock.garch_cascade,
innovation,
base_variance,
)
} else {
super::garch::update_garch_variance_for(
params,
beta,
stock.garch_variance,
innovation,
base_variance,
)
};
stock.last_daily_return = Some(daily_return);
if let Some(s) = stock.mispricing_s {
let prev_close_s = stock.mispricing_s_prev_close.unwrap_or(s);
stock.mispricing_momentum = Some(s - prev_close_s);
stock.mispricing_s_prev_close = Some(s);
}
if inputs.avg_volume == AvgVolumePolicy::ReferenceEma {
let alpha = 2.0 / (AVG_VOLUME_EMA_DAYS + 1.0);
let normalised_daily_vol = stock.volume / (INTRADAY_VOLUME_MEAN * VOLUME_SCALE_MEAN);
if normalised_daily_vol > 0.0 {
stock.avg_volume =
mathx::js_round(stock.avg_volume * (1.0 - alpha) + normalised_daily_vol * alpha);
}
}
}
pub fn close_day_all(companies: &mut [TickCompany], inputs: &[CloseInputs]) {
assert_eq!(
companies.len(),
inputs.len(),
"close_day_all needs one CloseInputs per company"
);
for (company, input) in companies.iter_mut().zip(inputs) {
close_day(company, input);
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::market::tick::TickStock;
fn stock() -> TickStock {
TickStock {
price: 110.0,
previous_close: 100.0,
previous_tick_price: Some(109.0),
open: 100.0,
high: 112.0,
low: 99.0,
volume: 2_030_000.0,
avg_volume: 1_000_000.0,
shares_outstanding: 1e8,
market_cap: 110.0 * 1e8,
mispricing_s: Some(0.10),
mispricing_s_prev_close: Some(0.04),
mispricing_momentum: Some(0.0),
fair_value_offset: None,
buyback_log_shares: None,
dividend: None,
maker_inventory: Some(0.0),
garch_variance: 0.015 * 0.015,
garch_cascade: [0.015 * 0.015; crate::market::garch::CASCADE_MAX],
last_daily_return: None,
beta: Some(1.0),
short_interest: 0.0,
float: 1e8,
}
}
fn company() -> TickCompany {
TickCompany {
id: "ACME".into(),
ticker: "ACME".into(),
sector: "technology".into(),
is_bankrupt: false,
is_public: true,
stock: stock(),
sector_volatility: Some(1.0),
sector_avg_pe: Some(32.0),
eps: Some(4.0),
book_value_per_share: Some(20.0),
revenue_growth: Some(0.1),
}
}
const BASE: f64 = 0.015 * 0.015;
fn inputs(innovation: Option<f64>) -> CloseInputs {
CloseInputs {
daily_innovation: innovation,
sector_base_daily_variance: BASE,
vix: 15.0,
vix_anchor: crate::params::PT_V1.market_vol_vix_anchor,
avg_volume: AvgVolumePolicy::Hold,
}
}
fn reference_inputs(innovation: Option<f64>) -> CloseInputs {
CloseInputs {
avg_volume: AvgVolumePolicy::ReferenceEma,
..inputs(innovation)
}
}
#[test]
fn the_momentum_roll_carries_yesterdays_re_rating_into_today() {
let mut c = company();
close_day(&mut c, &inputs(None));
assert!((c.stock.mispricing_momentum.unwrap() - 0.06).abs() < 1e-15);
assert_eq!(c.stock.mispricing_s_prev_close, Some(0.10));
}
#[test]
fn a_second_close_with_no_movement_reports_zero_momentum() {
let mut c = company();
close_day(&mut c, &inputs(None));
close_day(&mut c, &inputs(None));
assert_eq!(c.stock.mispricing_momentum, Some(0.0));
}
#[test]
fn a_company_that_has_never_ticked_gets_no_momentum_written() {
let mut c = company();
c.stock.mispricing_s = None;
c.stock.mispricing_momentum = None;
close_day(&mut c, &inputs(None));
assert_eq!(
c.stock.mispricing_momentum, None,
"writing a zero here would assert something the original does not"
);
assert_eq!(c.stock.mispricing_s_prev_close, Some(0.04));
}
#[test]
fn the_first_close_measures_against_s_itself() {
let mut c = company();
c.stock.mispricing_s_prev_close = None;
close_day(&mut c, &inputs(None));
assert_eq!(c.stock.mispricing_momentum, Some(0.0));
}
#[test]
fn the_variance_is_fed_the_days_noise_not_its_return() {
let mut on_noise = company();
close_day(&mut on_noise, &inputs(Some(0.001)));
let mut on_return = company();
close_day(&mut on_return, &inputs(None));
assert!(
on_noise.stock.garch_variance < on_return.stock.garch_variance,
"a quiet re-rating must not raise variance like a violent day: {} vs {}",
on_noise.stock.garch_variance,
on_return.stock.garch_variance
);
}
#[test]
fn a_non_finite_innovation_falls_back_to_the_return() {
for bad in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {
let mut c = company();
close_day(&mut c, &inputs(Some(bad)));
let mut fallback = company();
close_day(&mut fallback, &inputs(None));
assert_eq!(
c.stock.garch_variance, fallback.stock.garch_variance,
"innovation {bad} should have fallen back"
);
assert!(c.stock.garch_variance.is_finite());
}
}
#[test]
fn a_newly_listed_company_reports_a_flat_day_rather_than_dividing_by_zero() {
let mut c = company();
c.stock.previous_close = 0.0;
close_day(&mut c, &inputs(None));
assert_eq!(c.stock.last_daily_return, Some(0.0));
assert!(c.stock.garch_variance.is_finite());
}
#[test]
fn the_stored_daily_return_is_what_tomorrows_forced_flow_reads() {
let mut c = company();
close_day(&mut c, &inputs(None));
assert!((c.stock.last_daily_return.unwrap() - 0.10).abs() < 1e-15);
}
#[test]
fn the_shipped_close_never_moves_average_volume() {
for daily_volume in [0.0, 1.0, 2_030_000.0, 4.2e15] {
let mut c = company();
c.stock.avg_volume = 1_000_000.0;
c.stock.volume = daily_volume;
close_day(&mut c, &inputs(None));
assert_eq!(
c.stock.avg_volume, 1_000_000.0,
"a day of volume {daily_volume} must leave the average alone"
);
}
}
#[test]
fn the_reference_ema_is_preserved_for_tape_replay() {
let mut c = company();
c.stock.avg_volume = 1_000_000.0;
c.stock.volume = 1_000_000.0 * INTRADAY_VOLUME_MEAN * VOLUME_SCALE_MEAN;
close_day(&mut c, &reference_inputs(None));
assert_eq!(c.stock.avg_volume, 1_000_000.0);
let mut c = company();
c.stock.avg_volume = 1_000_000.0;
c.stock.volume = 5_000_000.0 * INTRADAY_VOLUME_MEAN * VOLUME_SCALE_MEAN;
close_day(&mut c, &reference_inputs(None));
let alpha = 2.0 / 21.0;
let expected = mathx::js_round(1_000_000.0 * (1.0 - alpha) + 5_000_000.0 * alpha);
assert_eq!(c.stock.avg_volume, expected);
}
#[test]
fn an_untraded_day_leaves_the_reference_average_alone() {
let mut c = company();
c.stock.avg_volume = 1_000_000.0;
c.stock.volume = 0.0;
close_day(&mut c, &reference_inputs(None));
assert_eq!(
c.stock.avg_volume, 1_000_000.0,
"a zero-volume day must not decay the average toward zero"
);
}
#[test]
fn the_open_reset_anchors_the_breaker_band_to_todays_open() {
let mut roster = vec![company()];
roster[0].stock.price = 137.0;
roster[0].stock.volume = 999.0;
reset_daily_prices(&mut roster);
let s = &roster[0].stock;
assert_eq!(s.previous_close, 137.0);
assert_eq!(s.open, 137.0);
assert_eq!(s.high, 137.0);
assert_eq!(s.low, 137.0);
assert_eq!(s.volume, 0.0);
}
#[test]
fn the_close_touches_nothing_it_should_not() {
let before = company();
let mut after = company();
close_day(&mut after, &inputs(Some(0.001)));
assert_eq!(after.stock.price, before.stock.price);
assert_eq!(after.stock.previous_close, before.stock.previous_close);
assert_eq!(
after.stock.shares_outstanding,
before.stock.shares_outstanding
);
assert_eq!(after.stock.maker_inventory, before.stock.maker_inventory);
assert_eq!(after.stock.mispricing_s, before.stock.mispricing_s);
}
}