use crate::mathx;
#[cfg(test)]
use super::tick::MARKET_FACTOR_SIGMA;
pub const MARKET_VOL_ALPHA: f64 = 0.45;
pub const MARKET_VOL_BETA: f64 = 0.5;
pub const MARKET_VOL_CEILING_MULTIPLE: f64 = 8.0;
pub const MARKET_VOL_FLOOR_MULTIPLE: f64 = 0.05;
pub const MARKET_VOL_VIX_COUPLING: f64 = 1.0;
pub const MARKET_VOL_VIX_ANCHOR: f64 = 15.0;
pub const IDIO_SIGMA_SCALE: f64 = 0.84;
pub fn update_market_variance(current_variance: f64, day_factor: f64, vix: f64) -> f64 {
update_market_variance_with(&crate::params::PT_V1, current_variance, day_factor, vix)
}
pub fn update_market_variance_with(
params: &crate::params::ModelParams,
current_variance: f64,
day_factor: f64,
vix: f64,
) -> f64 {
update_market_variance_at(
params, params.market_vol_vix_anchor, current_variance, day_factor, vix)
}
pub fn update_market_variance_at(
params: &crate::params::ModelParams,
vix_anchor: f64,
current_variance: f64,
day_factor: f64,
vix: f64,
) -> f64 {
let base = params.market_factor_sigma * params.market_factor_sigma;
let vix_ratio = vix / vix_anchor;
let target = base
* (1.0 - params.market_vol_vix_coupling
+ params.market_vol_vix_coupling * vix_response(params, vix_ratio));
update_toward_with(params, current_variance, day_factor, target)
}
#[cfg(test)]
fn update_toward(current_variance: f64, day_factor: f64, target_variance: f64) -> f64 {
update_toward_with(
&crate::params::PT_V1,
current_variance,
day_factor,
target_variance,
)
}
fn component_step(
current: f64,
day_factor: f64,
target: f64,
alpha: f64,
beta: f64,
gamma: f64,
) -> f64 {
let leverage = if day_factor < 0.0 { gamma } else { 0.0 };
(1.0 - alpha - beta - 0.5 * gamma) * target
+ (alpha + leverage) * day_factor * day_factor
+ beta * current
}
fn slow_alpha_beta(params: &crate::params::ModelParams) -> (f64, f64) {
let rho = params.market_vol_slow_persistence;
let share = params.market_vol_slow_gain;
(share * rho, (1.0 - share) * rho)
}
fn slow_step(
params: &crate::params::ModelParams,
current: f64,
day_factor: f64,
target: f64,
) -> f64 {
let (sa, sb) = slow_alpha_beta(params);
let g = params.market_vol_slow_gamma;
if g == 0.0 {
clamp_variance(params, component_step(current, day_factor, target, sa, sb, 0.0))
} else {
clamp_variance(params, component_step(current, day_factor, target, sa, sb - 0.5 * g, g))
}
}
fn leverage_phi(params: &crate::params::ModelParams) -> f64 {
mathx::pow(0.5, 1.0 / params.market_vol_leverage_half_life)
}
fn leverage_fast_phi(params: &crate::params::ModelParams) -> f64 {
mathx::pow(0.5, 1.0 / params.market_vol_leverage_fast_half_life)
}
fn leverage_input_variance(params: &crate::params::ModelParams) -> f64 {
let a = params.market_vol_leverage_down;
0.5 * (1.0 + (1.0 - a) * (1.0 - a)) - a * a / (2.0 * std::f64::consts::PI)
}
fn leverage_fast_input_variance(params: &crate::params::ModelParams) -> f64 {
let b = params.market_vol_leverage_fast_up;
if b == 0.0 {
return leverage_input_variance(params);
}
0.5 * (1.0 + (1.0 - b) * (1.0 - b)) - b * b / (2.0 * std::f64::consts::PI)
}
pub const VIX_WINDOW_SESSIONS: usize = 21;
fn clamp_variance(params: &crate::params::ModelParams, v: f64) -> f64 {
let base = params.market_factor_sigma * params.market_factor_sigma;
mathx::max(
mathx::min(v, base * params.market_vol_ceiling_multiple),
base * params.market_vol_floor_multiple,
)
}
pub(crate) fn vix_response(params: &crate::params::ModelParams, vix_ratio: f64) -> f64 {
let below = params.market_vol_vix_exponent_below;
if below != 0.0 && vix_ratio < 1.0 {
return if below == 2.0 {
vix_ratio * vix_ratio
} else {
mathx::pow(vix_ratio, below)
};
}
if params.market_vol_vix_exponent == 2.0 {
vix_ratio * vix_ratio
} else {
mathx::pow(vix_ratio, params.market_vol_vix_exponent)
}
}
fn alpha_beta_at(
params: &crate::params::ModelParams,
current_variance: f64,
target_variance: f64,
) -> (f64, f64) {
let alpha = params.market_vol_alpha;
let beta = params.market_vol_beta;
let k = params.market_vol_alpha_excursion;
if k == 0.0 || target_variance <= 0.0 || current_variance <= 0.0 {
return (alpha, beta);
}
let delta = k * mathx::log(current_variance / target_variance);
let g = params.market_vol_gamma;
let m4 = |d: f64| {
let (a, b) = (alpha + d, beta - d);
3.0 * a * a + 3.0 * a * g + 1.5 * g * g + 2.0 * a * b + b * g + b * b
};
let (mut lo, mut hi) = (0.0_f64, 0.5_f64);
if m4(0.0) >= 0.999 {
return (alpha, beta);
}
for _ in 0..60 {
let mid = 0.5 * (lo + hi);
if m4(mid) < 0.999 {
lo = mid;
} else {
hi = mid;
}
}
let bound = lo;
let d = mathx::max(-bound, mathx::min(delta, bound));
(alpha + d, beta - d)
}
fn update_toward_with(
params: &crate::params::ModelParams,
current_variance: f64,
day_factor: f64,
target_variance: f64,
) -> f64 {
let base = params.market_factor_sigma * params.market_factor_sigma;
let gamma = params.market_vol_gamma;
let leverage = if day_factor < 0.0 { gamma } else { 0.0 };
let (alpha, beta) = alpha_beta_at(params, current_variance, target_variance);
let omega = (1.0 - alpha - beta - 0.5 * gamma) * target_variance;
let new_var = omega
+ (alpha + leverage) * day_factor * day_factor
+ beta * current_variance;
mathx::max(
mathx::min(new_var, base * params.market_vol_ceiling_multiple),
base * params.market_vol_floor_multiple,
)
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct MarketVarianceState {
variance: f64,
day_factor: f64,
fast_variance: f64,
slow_variance: f64,
smoothed_vix: Option<f64>,
prev_day_factor: f64,
leverage_memory: f64,
leverage_fast_memory: f64,
}
impl Default for MarketVarianceState {
fn default() -> Self {
Self::new()
}
}
impl MarketVarianceState {
pub fn new() -> Self {
Self::new_with(&crate::params::PT_V1)
}
pub fn new_with(params: &crate::params::ModelParams) -> Self {
let base = params.market_factor_sigma * params.market_factor_sigma;
Self {
variance: base,
day_factor: 0.0,
fast_variance: base,
slow_variance: base,
smoothed_vix: None,
prev_day_factor: 0.0,
leverage_memory: 0.0,
leverage_fast_memory: 0.0,
}
}
pub fn with_day_factor(mut self, day_factor: f64) -> Self {
self.day_factor = day_factor;
self
}
pub fn prev_day_down(&self) -> bool {
self.prev_day_factor < 0.0
}
pub fn prev_day_factor(&self) -> f64 {
self.prev_day_factor
}
pub fn day_factor(&self) -> f64 {
self.day_factor
}
pub fn leverage_memory(&self) -> f64 {
self.leverage_memory
}
pub fn set_leverage_memory(&mut self, value: f64) {
self.leverage_memory = value;
}
pub fn leverage_fast_memory(&self) -> f64 {
self.leverage_fast_memory
}
pub fn set_leverage_fast_memory(&mut self, value: f64) {
self.leverage_fast_memory = value;
}
pub(crate) fn leverage_fast_s2(params: &crate::params::ModelParams) -> f64 {
let phi = leverage_fast_phi(params);
(1.0 - phi) / (1.0 + phi) * leverage_fast_input_variance(params)
}
fn leverage_fast_multiplier(params: &crate::params::ModelParams, l: f64) -> f64 {
let k = params.market_vol_leverage_fast;
mathx::exp(k * l - 0.5 * k * k * Self::leverage_fast_s2(params))
}
pub fn leverage_fast_window_multiplier(params: &crate::params::ModelParams, l: f64) -> f64 {
let k = params.market_vol_leverage_fast;
let phi = leverage_fast_phi(params);
let s2 = Self::leverage_fast_s2(params);
let mut sum = 0.0;
let mut d = 1.0;
for _ in 0..VIX_WINDOW_SESSIONS {
sum += mathx::exp(k * d * l - 0.5 * k * k * s2 * d * d);
d *= phi;
}
sum / VIX_WINDOW_SESSIONS as f64
}
pub fn vix_window_ratio(&self, params: &crate::params::ModelParams) -> f64 {
if params.market_vol_leverage_fast == 0.0 {
return 1.0;
}
let l = self.leverage_fast_memory;
let now = Self::leverage_fast_multiplier(params, l);
if !(now > 0.0) {
return 1.0;
}
Self::leverage_fast_window_multiplier(params, l) / now
}
pub fn vix_window_variance(&self, params: &crate::params::ModelParams) -> f64 {
if params.market_vol_leverage_fast == 0.0 {
return self.variance;
}
let l = self.leverage_fast_memory;
let now = Self::leverage_fast_multiplier(params, l);
if !(now > 0.0) {
return self.variance;
}
clamp_variance(
params, self.variance / now * Self::leverage_fast_window_multiplier(params, l))
}
fn leverage_multiplier(params: &crate::params::ModelParams, l: f64) -> f64 {
let k = params.market_vol_leverage;
let phi = leverage_phi(params);
let a = params.market_vol_leverage_down;
let var_u = 0.5 * (1.0 + (1.0 - a) * (1.0 - a))
- a * a / (2.0 * std::f64::consts::PI);
let s2 = (1.0 - phi) / (1.0 + phi) * var_u;
mathx::exp(k * l - 0.5 * k * k * s2)
}
fn mixture(&self, params: &crate::params::ModelParams) -> f64 {
let w = params.market_vol_slow_weight;
if w == 0.0 {
self.fast_variance
} else {
clamp_variance(params, (1.0 - w) * self.fast_variance + w * self.slow_variance)
}
}
fn component_shock(&self, params: &crate::params::ModelParams) -> f64 {
let mix = self.mixture(params);
if self.variance > 0.0 && mix > 0.0 {
self.day_factor * mathx::sqrt(mix / self.variance)
} else {
self.day_factor
}
}
#[cfg(test)]
fn day_factor_scaled_for_test(&self, params: &crate::params::ModelParams, f: f64) -> f64 {
let mut s = *self;
s.day_factor = f;
s.component_shock(params)
}
fn step_leverage_memory(&mut self, params: &crate::params::ModelParams) {
let x = self.leverage_input(params);
let phi = leverage_phi(params);
self.leverage_memory = phi * self.leverage_memory + (1.0 - phi) * x;
}
fn step_leverage_fast_memory(&mut self, params: &crate::params::ModelParams) {
let x = if params.market_vol_leverage_fast_up == 0.0 {
self.leverage_input(params)
} else {
self.leverage_fast_rise_input(params)
};
let phi = leverage_fast_phi(params);
self.leverage_fast_memory = phi * self.leverage_fast_memory + (1.0 - phi) * x;
}
fn leverage_fast_rise_input(&self, params: &crate::params::ModelParams) -> f64 {
let base = params.market_factor_sigma * params.market_factor_sigma;
let b = params.market_vol_leverage_fast_up;
let f = self.day_factor;
let s = params.market_vol_leverage_standardise;
let unit = if s == 0.0 {
mathx::sqrt(base)
} else {
mathx::pow(base, 0.5 * (1.0 - s)) * mathx::pow(self.variance, 0.5 * s)
};
let u = if f > 0.0 { -f / unit } else { -(1.0 - b) * f / unit };
let centre = -b * mathx::sqrt(self.variance) / unit / mathx::sqrt(2.0 * std::f64::consts::PI);
u - centre
}
fn leverage_input(&self, params: &crate::params::ModelParams) -> f64 {
let b = params.market_factor_sigma * params.market_factor_sigma;
let a = params.market_vol_leverage_down;
let f = self.day_factor;
let s = params.market_vol_leverage_standardise;
let unit = if s == 0.0 {
mathx::sqrt(b)
} else {
mathx::pow(b, 0.5 * (1.0 - s)) * mathx::pow(self.variance, 0.5 * s)
};
let u = if f < 0.0 { -f / unit } else { -(1.0 - a) * f / unit };
let centre = if a == 0.0 {
0.0
} else if s == 0.0 {
a * mathx::sqrt(self.variance / b) / mathx::sqrt(2.0 * std::f64::consts::PI)
} else {
a * mathx::sqrt(self.variance) / unit / mathx::sqrt(2.0 * std::f64::consts::PI)
};
u - centre
}
pub fn sigma_daily(&self) -> f64 {
mathx::sqrt(self.variance)
}
pub fn variance(&self) -> f64 {
self.variance
}
pub fn accumulate(&mut self, market_factor: f64) {
self.day_factor += market_factor;
}
pub fn open_day(&mut self) {
self.day_factor = 0.0;
}
pub fn close_day(&mut self, vix: f64) -> (f64, Option<f64>) {
self.close_day_with(&crate::params::PT_V1, vix)
}
pub fn close_day_with(
&mut self, params: &crate::params::ModelParams, vix: f64,
) -> (f64, Option<f64>) {
self.close_day_at(params, params.market_vol_vix_anchor, vix)
}
pub fn close_day_at(
&mut self,
params: &crate::params::ModelParams,
vix_ratio_denominator: f64,
vix: f64,
) -> (f64, Option<f64>) {
self.close_day_scaled(params, vix_ratio_denominator, vix, 1.0)
}
pub fn close_day_scaled(
&mut self,
params: &crate::params::ModelParams,
vix_ratio_denominator: f64,
vix: f64,
level: f64,
) -> (f64, Option<f64>) {
let vix = if params.market_vol_vix_smooth == 0.0 {
vix
} else {
let alpha = 2.0 / (params.market_vol_vix_smooth + 1.0);
let prev = self.smoothed_vix.unwrap_or(vix);
let sm = prev + alpha * (vix - prev);
self.smoothed_vix = Some(sm);
sm
};
let base = params.market_factor_sigma * params.market_factor_sigma;
let base = if level == 1.0 { base } else { base * level };
let vix_ratio = vix / vix_ratio_denominator;
let target = base
* (1.0 - params.market_vol_vix_coupling
+ params.market_vol_vix_coupling * vix_response(params, vix_ratio));
let w = params.market_vol_slow_weight;
if params.market_vol_leverage != 0.0 || params.market_vol_leverage_fast != 0.0 {
return self.close_with_leverage_memory(params, target, base, vix_ratio);
}
if w == 0.0 {
self.variance = if level == 1.0 {
update_market_variance_at(
params, vix_ratio_denominator, self.variance, self.day_factor, vix)
} else {
update_toward_with(params, self.variance, self.day_factor, target)
};
self.fast_variance = self.variance;
self.prev_day_factor = self.day_factor;
self.day_factor = 0.0;
return (target, None);
}
let (fast_alpha, fast_beta) = alpha_beta_at(params, self.fast_variance, target);
let fast = clamp_variance(
params,
component_step(self.fast_variance, self.day_factor, target,
fast_alpha, fast_beta,
params.market_vol_gamma),
);
let slow_target = if params.market_vol_slow_vix_damp == 0.0 {
target
} else {
let c = params.market_vol_vix_coupling
* (1.0 - params.market_vol_slow_vix_damp);
base * (1.0 - c + c * vix_response(params, vix_ratio))
};
let slow = slow_step(params, self.slow_variance, self.day_factor, slow_target);
self.fast_variance = fast;
self.slow_variance = slow;
self.variance = clamp_variance(params, (1.0 - w) * fast + w * slow);
self.prev_day_factor = self.day_factor;
self.day_factor = 0.0;
(target, Some(slow_target))
}
fn close_with_leverage_memory(
&mut self,
params: &crate::params::ModelParams,
target: f64,
base: f64,
vix_ratio: f64,
) -> (f64, Option<f64>) {
let shock = self.component_shock(params);
let w = params.market_vol_slow_weight;
let slow_target = if w == 0.0 {
None
} else if params.market_vol_slow_vix_damp == 0.0 {
Some(target)
} else {
let c = params.market_vol_vix_coupling * (1.0 - params.market_vol_slow_vix_damp);
Some(base * (1.0 - c + c * vix_response(params, vix_ratio)))
};
if w == 0.0 {
self.fast_variance = update_toward_with(params, self.fast_variance, shock, target);
} else {
let (fast_alpha, fast_beta) = alpha_beta_at(params, self.fast_variance, target);
self.fast_variance = clamp_variance(
params,
component_step(self.fast_variance, shock, target,
fast_alpha, fast_beta, params.market_vol_gamma),
);
self.slow_variance = slow_step(
params, self.slow_variance, shock, slow_target.unwrap_or(target));
}
if params.market_vol_leverage != 0.0 {
self.step_leverage_memory(params);
}
if params.market_vol_leverage_fast != 0.0 {
self.step_leverage_fast_memory(params);
}
let mix = self.mixture(params);
let m = if params.market_vol_leverage != 0.0 {
Self::leverage_multiplier(params, self.leverage_memory)
} else {
1.0
};
let m = if params.market_vol_leverage_fast != 0.0 {
m * Self::leverage_fast_multiplier(params, self.leverage_fast_memory)
} else {
m
};
self.variance = clamp_variance(params, mix * m);
self.prev_day_factor = self.day_factor;
self.day_factor = 0.0;
(target, slow_target)
}
fn forced_targets(
params: &crate::params::ModelParams,
vix_ratio_denominator: f64,
vix: f64,
level: f64,
) -> (f64, f64) {
let base = params.market_factor_sigma * params.market_factor_sigma;
let base = if level == 1.0 { base } else { base * level };
let vix_ratio = vix / vix_ratio_denominator;
let response = vix_response(params, vix_ratio);
let target = base
* (1.0 - params.market_vol_vix_coupling
+ params.market_vol_vix_coupling * response);
let slow_target = if params.market_vol_slow_vix_damp == 0.0 {
target
} else {
let c = params.market_vol_vix_coupling
* (1.0 - params.market_vol_slow_vix_damp);
base * (1.0 - c + c * response)
};
(target, slow_target)
}
pub fn forced_level(
params: &crate::params::ModelParams,
vix_ratio_denominator: f64,
vix: f64,
level: f64,
) -> f64 {
let (target, slow_target) =
Self::forced_targets(params, vix_ratio_denominator, vix, level);
let w = params.market_vol_slow_weight;
if w == 0.0 {
return clamp_variance(params, target);
}
let fast = clamp_variance(params, target);
let slow = clamp_variance(params, slow_target);
clamp_variance(params, (1.0 - w) * fast + w * slow)
}
pub fn close_day_forced(
&mut self,
params: &crate::params::ModelParams,
vix_ratio_denominator: f64,
vix: f64,
level: f64,
) -> (f64, Option<f64>) {
if params.market_vol_vix_smooth != 0.0 {
let alpha = 2.0 / (params.market_vol_vix_smooth + 1.0);
let prev = self.smoothed_vix.unwrap_or(vix);
self.smoothed_vix = Some(prev + alpha * (vix - prev));
}
let (target, slow_target) =
Self::forced_targets(params, vix_ratio_denominator, vix, level);
let w = params.market_vol_slow_weight;
if params.market_vol_leverage != 0.0 {
self.step_leverage_memory(params);
}
if params.market_vol_leverage_fast != 0.0 {
self.step_leverage_fast_memory(params);
}
self.prev_day_factor = self.day_factor;
self.day_factor = 0.0;
if w == 0.0 {
self.variance = clamp_variance(params, target);
self.fast_variance = self.variance;
return (target, None);
}
let fast = clamp_variance(params, target);
let slow = clamp_variance(params, slow_target);
self.fast_variance = fast;
self.slow_variance = slow;
self.variance = clamp_variance(params, (1.0 - w) * fast + w * slow);
(target, Some(slow_target))
}
pub fn warm_to_level(
&mut self,
params: &crate::params::ModelParams,
vix_ratio_denominator: f64,
vix: f64,
log_level: f64,
stationary_var: f64,
sessions: i64,
) {
if sessions <= 0 {
return;
}
let base0 = params.market_factor_sigma * params.market_factor_sigma;
let c = params.market_vol_vix_coupling;
let response = vix_response(params, vix / vix_ratio_denominator);
let coupled = 1.0 - c + c * response;
let damped = if params.market_vol_slow_vix_damp == 0.0 {
coupled
} else {
let cd = c * (1.0 - params.market_vol_slow_vix_damp);
1.0 - cd + cd * response
};
let phi = params.market_vol_level_persistence;
let p_fast =
params.market_vol_alpha + params.market_vol_beta + 0.5 * params.market_vol_gamma;
let (sa, sb) = slow_alpha_beta(params);
let p_slow = sa + sb;
let w = params.market_vol_slow_weight;
let mut fast = self.fast_variance;
let mut slow = self.slow_variance;
for step in 0..sessions {
let k = (sessions - 1 - step) as f64;
let log_l = mathx::pow(phi, k) * log_level;
let base = base0 * mathx::exp(log_l - 0.25 * stationary_var);
fast = clamp_variance(params, (1.0 - p_fast) * (base * coupled) + p_fast * fast);
if w != 0.0 {
slow = clamp_variance(params, (1.0 - p_slow) * (base * damped) + p_slow * slow);
}
}
self.fast_variance = fast;
if w == 0.0 {
self.variance = fast;
} else {
self.slow_variance = slow;
self.variance = clamp_variance(params, (1.0 - w) * fast + w * slow);
}
if params.market_vol_leverage != 0.0 {
self.variance = clamp_variance(
params, self.variance * Self::leverage_multiplier(params, self.leverage_memory));
}
}
pub fn snapshot(&self) -> (f64, f64, f64, f64, f64, f64) {
(self.variance, self.day_factor, self.fast_variance,
self.slow_variance, self.prev_day_factor,
self.smoothed_vix.unwrap_or(-1.0))
}
pub fn restore(variance: f64, day_factor: f64) -> Self {
Self {
variance,
day_factor,
fast_variance: variance,
slow_variance: variance,
smoothed_vix: None,
prev_day_factor: 0.0,
leverage_memory: 0.0,
leverage_fast_memory: 0.0,
}
}
pub fn restore_with_components(
variance: f64,
day_factor: f64,
fast_variance: f64,
slow_variance: f64,
prev_day_factor: f64,
smoothed_vix: f64,
) -> Self {
Self {
variance, day_factor, fast_variance, slow_variance,
smoothed_vix: if smoothed_vix < 0.0 { None } else { Some(smoothed_vix) },
prev_day_factor,
leverage_memory: 0.0,
leverage_fast_memory: 0.0,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
const BASE: f64 = MARKET_FACTOR_SIGMA * MARKET_FACTOR_SIGMA;
#[test]
fn the_recursion_reverts_and_the_clamp_carries_the_fourth_moment() {
let persistence = MARKET_VOL_ALPHA + MARKET_VOL_BETA;
assert!(
persistence < 1.0,
"alpha + beta = {persistence}: at or above 1 the factor variance is non-stationary"
);
let fourth = persistence * persistence + 2.0 * MARKET_VOL_ALPHA * MARKET_VOL_ALPHA;
assert!(
fourth > 1.0,
"(a+b)^2 + 2a^2 = {fourth}: the shipped shape trades the unclamped fourth-moment \
condition for in-window tails; if this now holds, the ceiling's role changed"
);
const { assert!(MARKET_VOL_FLOOR_MULTIPLE < MARKET_VOL_CEILING_MULTIPLE) };
let quiet_fixed_point = (1.0 - persistence) / (1.0 - MARKET_VOL_BETA);
assert!(
quiet_fixed_point > MARKET_VOL_FLOOR_MULTIPLE,
"quiet fixed point {quiet_fixed_point} at or below the floor pins calm periods \
and destroys the variance dispersion kurtosis is made of (measured; see module doc)"
);
}
#[test]
fn a_violent_market_day_raises_tomorrows_factor_variance() {
let calm = update_market_variance(BASE, 0.0005, 15.0);
let shocked = update_market_variance(BASE, 0.04, 15.0);
assert!(
shocked > calm,
"a 4% market day must raise factor variance above a 0.05% day: {shocked} vs {calm}"
);
}
#[test]
fn factor_variance_clusters_rather_than_resetting() {
let mut shocked = update_market_variance(BASE, 0.04, 15.0);
for _ in 0..3 {
shocked = update_market_variance(shocked, 0.0, 15.0);
}
let mut never = BASE;
for _ in 0..4 {
never = update_market_variance(never, 0.0, 15.0);
}
assert!(
shocked > never * 1.2,
"three days after a 4% market day the factor variance must still be elevated: \
{shocked} vs {never}"
);
}
#[test]
fn a_quiet_run_settles_at_the_fixed_point_above_the_floor() {
let mut v = update_market_variance(BASE, 0.06, 15.0);
for _ in 0..400 {
v = update_market_variance(v, 0.0, 15.0);
}
let fixed_point =
BASE * (1.0 - MARKET_VOL_ALPHA - MARKET_VOL_BETA) / (1.0 - MARKET_VOL_BETA);
assert!(
(v - fixed_point).abs() < fixed_point * 1e-9,
"400 quiet days should settle at the fixed point {fixed_point}, got {v}"
);
assert!(v > BASE * MARKET_VOL_FLOOR_MULTIPLE);
}
#[test]
fn the_variance_stays_inside_its_bounds_however_hard_it_is_driven() {
let mut v = BASE;
for day in 0..1000 {
let eps = if day % 2 == 0 { 0.5 } else { 0.0 };
v = update_market_variance(v, eps, 15.0);
assert!(
v <= BASE * MARKET_VOL_CEILING_MULTIPLE * 1.000001,
"day {day}: variance {v} escaped the ceiling"
);
assert!(
v >= BASE * MARKET_VOL_FLOOR_MULTIPLE * 0.999999,
"day {day}: variance {v} fell through the floor"
);
}
}
#[test]
fn the_ceiling_is_reachable_in_a_burst_so_it_is_a_bound_and_not_a_prop() {
let mut v = BASE * 2.0;
v = update_market_variance(v, 2.0 * mathx::sqrt(v), 15.0); v = update_market_variance(v, 2.0 * mathx::sqrt(v), 15.0); assert!(
v >= BASE * MARKET_VOL_CEILING_MULTIPLE * 0.999999,
"two 2-sigma days from twice-baseline variance should reach the ceiling, got \
{} x base",
v / BASE
);
}
#[test]
fn the_shipped_coupling_is_on_so_vix_moves_the_variance_target() {
assert_eq!(MARKET_VOL_VIX_COUPLING, 1.0);
for eps in [0.0, 0.01, 0.04] {
let calm = update_market_variance(BASE * 2.0, eps, 5.0);
let crisis = update_market_variance(BASE * 2.0, eps, 65.0);
assert!(
crisis > calm,
"eps {eps}: VIX 65 must raise the variance target above VIX 5, \
got {crisis} vs {calm}"
);
}
}
#[test]
fn an_anchor_level_vix_reproduces_the_autonomous_update_to_the_bit() {
for (v, eps) in [(BASE, 0.0), (BASE * 2.0, 0.01), (BASE * 0.5, 0.04)] {
let coupled = update_market_variance(v, eps, MARKET_VOL_VIX_ANCHOR);
let autonomous = update_toward(v, eps, BASE);
assert_eq!(coupled.to_bits(), autonomous.to_bits(), "v {v} eps {eps}");
}
}
#[test]
fn a_held_crisis_pin_saturates_at_the_ceiling_so_the_response_is_flat_above_it() {
let saturation_vix = MARKET_VOL_VIX_ANCHOR * mathx::sqrt(MARKET_VOL_CEILING_MULTIPLE);
assert!(
saturation_vix < 45.0,
"saturation at VIX {saturation_vix}: a held VIX 45 no longer pins the \
ceiling, so the held-pin volatility argument needs re-measuring"
);
let mut v = BASE;
for _ in 0..300 {
v = update_market_variance(v, 3.0 * mathx::sqrt(v), 100.0);
assert!(v <= BASE * MARKET_VOL_CEILING_MULTIPLE * 1.000001);
}
assert!(
v >= BASE * MARKET_VOL_CEILING_MULTIPLE * 0.999999,
"a relentless VIX-100 pin should hold the state at the ceiling, got {} x base",
v / BASE
);
}
#[test]
fn a_coupled_target_scales_with_vix_squared_and_stays_clamped() {
let anchored = update_toward(BASE, 0.0, BASE);
let doubled = update_toward(BASE, 0.0, BASE * 4.0);
assert!(doubled > anchored);
let extreme = update_toward(BASE * MARKET_VOL_CEILING_MULTIPLE, 0.06, BASE * 20.0);
assert!(extreme <= BASE * MARKET_VOL_CEILING_MULTIPLE * 1.000001);
}
#[test]
fn the_calm_exponent_reshapes_only_below_the_anchor() {
let mut p = crate::params::PT_V1.clone();
p.market_vol_vix_exponent = 4.0;
let at_zero: Vec<f64> = [0.3, 0.7, 1.0, 1.6].iter().map(|&r| vix_response(&p, r)).collect();
p.market_vol_vix_exponent_below = 2.0;
assert_eq!(vix_response(&p, 0.5), 0.25);
assert_eq!(vix_response(&p, 1.0), at_zero[2]);
assert_eq!(vix_response(&p, 1.6), at_zero[3], "the crisis side must not move");
assert!(vix_response(&p, 0.7) > at_zero[1]);
p.market_vol_vix_exponent_below = 2.5;
assert!((vix_response(&p, 0.49) - 0.49f64.powf(2.5)).abs() < 1e-12);
}
#[test]
fn the_state_accumulates_a_day_and_consumes_it_exactly_once() {
let mut state = MarketVarianceState::new();
state.accumulate(0.02);
state.accumulate(0.02);
state.close_day(15.0);
let after_shock = state.snapshot().0;
assert!(
after_shock > BASE,
"a 4% accumulated day must raise the variance: {after_shock}"
);
let mut again = state;
again.close_day(15.0);
assert!(again.snapshot().0 < after_shock);
}
#[test]
fn an_abandoned_day_does_not_leak_into_the_next_innovation() {
let mut state = MarketVarianceState::new();
state.accumulate(0.05);
state.open_day(); state.close_day(15.0);
let mut clean = MarketVarianceState::new();
clean.close_day(15.0);
assert_eq!(state.snapshot().0.to_bits(), clean.snapshot().0.to_bits());
}
#[test]
fn a_fresh_state_draws_at_exactly_the_baseline_sigma() {
assert_eq!(
MarketVarianceState::new().sigma_daily().to_bits(),
MARKET_FACTOR_SIGMA.to_bits()
);
}
#[test]
fn snapshot_and_restore_round_trip_exactly() {
let mut state = MarketVarianceState::new();
state.accumulate(0.007);
state.close_day(22.0);
state.accumulate(-0.003);
let (v, df, fast, slow, pdf, sv) = state.snapshot();
let restored = MarketVarianceState::restore_with_components(v, df, fast, slow, pdf, sv);
assert_eq!(state, restored);
}
#[test]
fn a_two_value_checkpoint_still_replays_under_a_legacy_preset() {
let params = &crate::params::PT_V1;
assert_eq!(params.market_vol_slow_weight, 0.0);
let mut original = MarketVarianceState::new_with(params);
original.accumulate(0.011);
original.close_day_with(params, 31.0);
original.accumulate(-0.004);
let (v, df, _fast, _slow, _pdf, _sv) = original.snapshot();
let mut restored = MarketVarianceState::restore(v, df);
for day in 0..12 {
let vix = 15.0 + day as f64;
let mut a = original;
let mut b = restored;
a.close_day_with(params, vix);
b.close_day_with(params, vix);
assert_eq!(a.sigma_daily(), b.sigma_daily(), "day {day}");
original = a;
restored = b;
}
}
#[test]
fn the_slow_component_is_inert_at_its_legacy_values() {
let params = &crate::params::PT_V1;
let mut composed = MarketVarianceState::new_with(params);
let mut variance = params.market_factor_sigma * params.market_factor_sigma;
for day in 0..40 {
let innovation = 0.004 * ((day % 7) as f64 - 3.0);
let vix = 12.0 + (day % 11) as f64;
composed.accumulate(innovation);
composed.close_day_with(params, vix);
variance = update_market_variance_with(params, variance, innovation, vix);
assert_eq!(composed.sigma_daily(), mathx::sqrt(variance), "day {day}");
}
}
}
#[cfg(test)]
mod gjr_tests {
use super::*;
#[test]
fn gamma_zero_is_the_symmetric_step_bit_for_bit() {
for d in [-0.02, -0.001, 0.0, 0.001, 0.02] {
let sym = (1.0 - 0.28 - 0.69) * 4e-4 + 0.28 * d * d + 0.69 * 3e-4;
let gjr = component_step(3e-4, d, 4e-4, 0.28, 0.69, 0.0);
assert_eq!(sym.to_bits(), gjr.to_bits(), "day_factor {d}");
}
}
#[test]
fn gamma_redistributes_between_down_and_up_without_adding() {
let (a, b, g, v, t) = (0.28, 0.69, 0.10, 3e-4, 4e-4);
let at_target = crate::mathx::sqrt(t);
let down = component_step(v, -at_target, t, a, b, g);
let up = component_step(v, at_target, t, a, b, g);
let sym = component_step(v, at_target, t, a, b, 0.0);
assert!(down > up, "leverage must load the down side");
let two_sided = 0.5 * (down + up);
assert!(
(two_sided - sym).abs() < 1e-18,
"at the stationary point the rebate is exact: {two_sided} vs {sym}"
);
let d = 0.015;
let gap = 0.5
* (component_step(v, -d, t, a, b, g) + component_step(v, d, t, a, b, g))
- component_step(v, d, t, a, b, 0.0);
assert!(
(gap - 0.5 * g * (d * d - t)).abs() < 1e-18,
"gap {gap} must be (gamma/2)(d^2 - t)"
);
}
}
#[cfg(test)]
mod close_day_targets {
use super::*;
use crate::params::ModelParams;
#[test]
fn the_first_target_does_not_depend_on_whether_a_slow_component_exists() {
for &damp in &[0.0, 0.5] {
for &vix in &[12.0, 19.5, 34.0] {
let mut none = ModelParams::pt_v1();
none.market_vol_slow_weight = 0.0;
none.market_vol_slow_vix_damp = damp;
let mut some = none.clone();
some.market_vol_slow_weight = 0.35;
let a = MarketVarianceState::new_with(&none)
.close_day_at(&none, none.market_vol_vix_anchor, vix);
let b = MarketVarianceState::new_with(&some)
.close_day_at(&some, some.market_vol_vix_anchor, vix);
assert_eq!(a.0.to_bits(), b.0.to_bits(),
"the fast target moved with the slow weight at damp {damp}, vix {vix}");
}
}
}
#[test]
fn the_slow_target_is_present_exactly_when_the_component_is() {
for &w in &[0.0, 0.35] {
let mut p = ModelParams::pt_v1();
p.market_vol_slow_weight = w;
let got = MarketVarianceState::new_with(&p)
.close_day_at(&p, p.market_vol_vix_anchor, 20.0);
assert_eq!(got.1.is_some(), w != 0.0,
"slow weight {w} reported slow target {:?}", got.1);
}
}
#[test]
fn the_excursion_form_makes_the_target_fall_as_the_read_back_rises() {
let mut p = ModelParams::pt_v19();
p.market_vol_slow_weight = 0.0; let base = p.market_factor_sigma * p.market_factor_sigma;
let vix = 80.0;
let denominators = [
p.market_vol_vix_anchor,
2.0 * p.market_vol_vix_anchor,
4.0 * p.market_vol_vix_anchor,
8.0 * p.market_vol_vix_anchor,
];
let mut previous = f64::INFINITY;
for &d in denominators.iter() {
let (target, _) = MarketVarianceState::new_with(&p).close_day_at(&p, d, vix);
assert!(
target < previous,
"the target did not fall when the read-back rose to {d}: {target} \
against {previous}. Without this sign the excursion switch is not \
a stability result, it is a relabelling."
);
previous = target;
}
let floor = base * (1.0 - p.market_vol_vix_coupling);
assert!(
previous > floor,
"the target fell to {previous}, at or under the uncoupled floor {floor}"
);
let a = MarketVarianceState::new_with(&p)
.close_day_at(&p, p.market_vol_vix_anchor, vix).0;
let b = MarketVarianceState::new_with(&p)
.close_day_at(&p, p.market_vol_vix_anchor, vix).0;
assert_eq!(a.to_bits(), b.to_bits());
}
#[test]
fn a_vix_at_its_own_read_back_targets_the_baseline_exactly() {
let base_params = ModelParams::pt_v19();
let base = base_params.market_factor_sigma * base_params.market_factor_sigma;
for &coupling in &[0.0, 0.5, 0.9540498202999739, 1.0] {
for &vix in &[10.0, 19.53, 23.7212, 55.0, 80.0] {
let mut p = base_params.clone();
p.market_vol_vix_coupling = coupling;
p.market_vol_slow_weight = 0.0;
let (target, _) = MarketVarianceState::new_with(&p).close_day_at(&p, vix, vix);
assert_eq!(
target.to_bits(),
base.to_bits(),
"at coupling {coupling} and vix {vix} a zero excursion targeted \
{target} rather than the baseline {base}"
);
}
}
}
#[test]
fn the_warm_up_lands_on_the_target_and_not_on_the_zero_shock_rest_point() {
let p = ModelParams::pt_v19();
let base = p.market_factor_sigma * p.market_factor_sigma;
let vix = p.market_vol_vix_anchor;
let mut s = MarketVarianceState::new_with(&p);
s.warm_to_level(&p, p.market_vol_vix_anchor, vix, 0.0, 0.0, 2000);
let (v, _, f, sl, ..) = s.snapshot();
for (name, got) in [("mixture", v), ("fast", f), ("slow", sl)] {
assert!(
(got / base - 1.0).abs() < 1e-9,
"the {name} warmed to {got} against a target of {base}"
);
}
let a = p.market_vol_alpha;
let b = p.market_vol_beta;
let g = p.market_vol_gamma;
let zero_shock = (1.0 - a - b - 0.5 * g) * base / (1.0 - b);
assert!(zero_shock < 0.5 * base,
"the contrast has gone: {zero_shock} against {base}");
}
#[test]
fn the_warmed_components_carry_their_own_share_of_the_opening_level() {
let p = ModelParams::pt_v19();
let base = p.market_factor_sigma * p.market_factor_sigma;
let vix = p.market_vol_vix_anchor;
let log_level = 0.01;
let mut s = MarketVarianceState::new_with(&p);
s.warm_to_level(&p, p.market_vol_vix_anchor, vix, log_level, 0.0, 4000);
let (_, _, fast, slow, ..) = s.snapshot();
let phi = p.market_vol_level_persistence;
let p_fast = p.market_vol_alpha + p.market_vol_beta + 0.5 * p.market_vol_gamma;
let (sa, sb) = slow_alpha_beta(&p);
let p_slow = sa + sb;
for (name, got, pers) in [
("fast", fast, p_fast),
("slow", slow, p_slow),
] {
let want = (1.0 - pers) / (1.0 - pers * phi);
let read = (got / base).ln() / log_level;
assert!(
(read - want).abs() < 0.01,
"the {name} component carried {read} of the opening level \
where (1-p)/(1-p phi) says {want}"
);
}
}
#[test]
fn a_warm_up_of_no_sessions_is_the_state_that_stood_before_it() {
let p = ModelParams::pt_v19();
let before = MarketVarianceState::new_with(&p);
let mut after = MarketVarianceState::new_with(&p);
after.warm_to_level(&p, p.market_vol_vix_anchor, 20.0, 1.5, 1.57, 0);
assert_eq!(before, after);
}
fn forced_params() -> ModelParams {
let mut p = ModelParams::pt_v19();
p.market_vol_vix_excursion = 0.0;
p.market_vol_vix_exponent = 4.0;
p
}
#[test]
fn a_forced_close_sets_each_component_to_its_own_target() {
let p = forced_params();
let base = p.market_factor_sigma * p.market_factor_sigma;
let anchor = p.market_vol_vix_anchor;
for start in [0.2 * base, base, 5.0 * base] {
let mut s = MarketVarianceState::new_with(&p);
s.fast_variance = start;
s.slow_variance = start;
s.variance = start;
s.accumulate(0.03);
let (t, ts) = s.close_day_forced(&p, anchor, 30.0, 1.0);
let ts = ts.expect("pt-v19 has a slow component");
let w = p.market_vol_slow_weight;
assert_eq!(s.fast_variance, clamp_variance(&p, t));
assert_eq!(s.slow_variance, clamp_variance(&p, ts));
assert_eq!(
s.variance,
clamp_variance(&p, (1.0 - w) * s.fast_variance + w * s.slow_variance)
);
let mut free = MarketVarianceState::new_with(&p);
let (ft, fts) = free.close_day_scaled(&p, anchor, 30.0, 1.0);
assert_eq!((t, Some(ts)), (ft, fts));
assert_eq!(MarketVarianceState::forced_level(&p, anchor, 30.0, 1.0), s.variance);
}
}
#[test]
fn the_first_free_close_after_a_forced_one_expects_no_step() {
let p = forced_params();
let anchor = p.market_vol_vix_anchor;
let mut forced = MarketVarianceState::new_with(&p);
forced.close_day_forced(&p, anchor, 30.0, 1.0);
let ceiling = p.market_factor_sigma * p.market_factor_sigma * p.market_vol_ceiling_multiple;
assert!(forced.fast_variance < ceiling && forced.slow_variance < ceiling);
let mut up = forced;
let mut down = forced;
up.accumulate(forced.fast_variance.sqrt());
down.accumulate(-forced.fast_variance.sqrt());
up.close_day_scaled(&p, anchor, 30.0, 1.0);
down.close_day_scaled(&p, anchor, 30.0, 1.0);
let mean_fast = 0.5 * (up.fast_variance + down.fast_variance);
assert!(
(mean_fast / forced.fast_variance - 1.0).abs() < 1e-12,
"fast: forced {} -> expected free step to {}", forced.fast_variance, mean_fast
);
let mut slow_up = forced;
slow_up.accumulate(forced.slow_variance.sqrt());
slow_up.close_day_scaled(&p, anchor, 30.0, 1.0);
assert!(
(slow_up.slow_variance / forced.slow_variance - 1.0).abs() < 1e-12,
"slow: forced {} -> free step to {}", forced.slow_variance, slow_up.slow_variance
);
}
#[test]
fn a_held_vix_run_free_arrives_where_the_forced_close_starts() {
let p = forced_params();
let anchor = p.market_vol_vix_anchor;
let mut forced = MarketVarianceState::new_with(&p);
forced.close_day_forced(&p, anchor, 30.0, 1.0);
let mut free = MarketVarianceState::new_with(&p);
free.warm_to_level(&p, anchor, 30.0, 0.0, 0.0, 20_000);
for (name, a, b) in [
("fast", free.fast_variance, forced.fast_variance),
("slow", free.slow_variance, forced.slow_variance),
("mixture", free.variance, forced.variance),
] {
assert!((a / b - 1.0).abs() < 1e-9, "{name}: free run settles at {a}, forced close sets {b}");
}
}
#[test]
fn a_forced_close_rolls_the_day_like_a_free_one() {
let p = forced_params();
let mut s = MarketVarianceState::new_with(&p);
s.accumulate(-0.02);
s.close_day_forced(&p, p.market_vol_vix_anchor, 45.0, 1.0);
assert_eq!(s.day_factor(), 0.0);
assert_eq!(s.prev_day_factor(), -0.02);
assert!(s.prev_day_down());
}
#[test]
fn a_forced_close_is_clamped_like_a_free_one() {
let p = forced_params();
let base = p.market_factor_sigma * p.market_factor_sigma;
let mut s = MarketVarianceState::new_with(&p);
s.close_day_forced(&p, p.market_vol_vix_anchor, 200.0, 1.0);
assert_eq!(s.fast_variance, base * p.market_vol_ceiling_multiple);
assert!(s.variance <= base * p.market_vol_ceiling_multiple);
let mut t = MarketVarianceState::new_with(&p);
t.close_day_forced(&p, p.market_vol_vix_anchor, 0.5, 1.0);
assert!(t.variance >= base * p.market_vol_floor_multiple);
}
#[test]
fn a_forced_close_on_one_component_leaves_the_slow_level_alone() {
let p = crate::params::PT_V1;
let mut s = MarketVarianceState::new_with(&p);
let slow_before = s.slow_variance;
let (t, ts) = s.close_day_forced(&p, p.market_vol_vix_anchor, 30.0, 1.0);
assert_eq!(ts, None);
assert_eq!(s.variance, clamp_variance(&p, t));
assert_eq!(s.fast_variance, s.variance);
assert_eq!(s.slow_variance, slow_before);
}
}
#[cfg(test)]
mod crash_vol_state {
use super::*;
use crate::params::ModelParams;
fn pt_v20() -> ModelParams {
crate::params::PT_V20
}
fn with_memory(k: f64, h: f64, down: f64) -> ModelParams {
let mut p = pt_v20();
p.market_vol_leverage = k;
p.market_vol_leverage_half_life = h;
p.market_vol_leverage_down = down;
p
}
fn close_after(p: &ModelParams, state: &MarketVarianceState, f: f64) -> MarketVarianceState {
let mut s = *state;
s.accumulate(f);
s.close_day_scaled(p, p.market_vol_vix_anchor, 19.0, 1.0);
s
}
#[test]
fn slow_gamma_zero_is_the_symmetric_call() {
let p = pt_v20();
assert_eq!(p.market_vol_slow_gamma, 0.0);
let (sa, sb) = slow_alpha_beta(&p);
for &f in &[-0.03, -0.004, 0.0, 0.004, 0.03] {
let direct = clamp_variance(&p, component_step(4e-5, f, 5e-5, sa, sb, 0.0));
assert_eq!(slow_step(&p, 4e-5, f, 5e-5).to_bits(), direct.to_bits());
}
}
#[test]
fn slow_gamma_loads_only_down_days_and_keeps_persistence() {
let mut p = pt_v20();
p.market_vol_slow_gamma = 0.6;
let q = pt_v20();
let (v, t) = (4e-5, 5e-5);
let d = 0.009;
let down = slow_step(&p, v, -d, t);
let up = slow_step(&p, v, d, t);
assert!(down > up, "a fall must load the slow component: {down} vs {up}");
assert!(up < slow_step(&q, v, d, t));
let at_level = crate::mathx::sqrt(v);
let two_sided = 0.5 * (slow_step(&p, v, -at_level, t) + slow_step(&p, v, at_level, t));
let (sa, sb) = slow_alpha_beta(&p);
let persistence = sa + sb;
let expected = (1.0 - persistence) * t + persistence * v;
assert!((two_sided - expected).abs() < 1e-18, "{two_sided} vs {expected}");
let s0 = MarketVarianceState::new_with(&p);
assert!(close_after(&p, &s0, -0.02).variance() > close_after(&q, &s0, -0.02).variance());
assert!(close_after(&p, &s0, 0.02).variance() < close_after(&q, &s0, 0.02).variance());
}
#[test]
fn slow_gamma_is_unread_on_a_single_component_model() {
let mut q = pt_v20();
q.market_vol_slow_weight = 0.0;
let mut p = q.clone();
p.market_vol_slow_gamma = 0.6;
let s0 = MarketVarianceState::new_with(&q);
for &f in &[-0.02, 0.02] {
assert_eq!(close_after(&p, &s0, f), close_after(&q, &s0, f));
}
}
#[test]
fn the_memory_is_never_written_while_off() {
let p = pt_v20();
let mut s = MarketVarianceState::new_with(&p);
for &f in &[-0.05, 0.03, -0.02] {
s = close_after(&p, &s, f);
assert_eq!(s.leverage_memory().to_bits(), 0.0_f64.to_bits());
}
}
#[test]
fn a_fall_raises_and_a_rise_lowers_the_next_session_variance() {
let p = with_memory(3.0, 40.0, 0.0);
let s0 = MarketVarianceState::new_with(&p);
let quiet = close_after(&p, &s0, 0.0);
let fell = close_after(&p, &s0, -0.01);
let rose = close_after(&p, &s0, 0.01);
assert!(fell.leverage_memory() > 0.0 && rose.leverage_memory() < 0.0);
assert!(fell.variance() > quiet.variance(), "{} vs {}", fell.variance(), quiet.variance());
assert!(rose.variance() < fell.variance());
assert!((fell.leverage_memory() + rose.leverage_memory()).abs() < 1e-15);
}
#[test]
fn the_memory_decays_at_its_half_life_with_zero_shocks() {
for &h in &[10.0, 40.0] {
let p = with_memory(3.0, h, 0.0);
let mut s = close_after(&p, &MarketVarianceState::new_with(&p), -0.02);
let l0 = s.leverage_memory();
for _ in 0..(h as usize) {
s = close_after(&p, &s, 0.0);
}
let ratio = s.leverage_memory() / l0;
assert!((ratio - 0.5).abs() < 1e-12, "half-life {h}: ratio {ratio}");
}
}
#[test]
fn down_one_counts_falls_only_and_is_centred() {
let p = with_memory(3.0, 40.0, 1.0);
let s0 = MarketVarianceState::new_with(&p);
let fell = close_after(&p, &s0, -0.01);
let rose = close_after(&p, &s0, 0.01);
let quiet = close_after(&p, &s0, 0.0);
assert_eq!(rose.leverage_memory().to_bits(), quiet.leverage_memory().to_bits());
assert!(quiet.leverage_memory() < 0.0 && fell.leverage_memory() > 0.0);
}
struct Normals(u64);
impl Normals {
fn uniform(&mut self) -> f64 {
self.0 = self.0.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
((self.0 >> 11) as f64 + 0.5) / (1u64 << 53) as f64
}
fn next(&mut self) -> f64 {
let (u1, u2) = (self.uniform(), self.uniform());
crate::mathx::sqrt(-2.0 * u1.ln()) * (2.0 * std::f64::consts::PI * u2).cos()
}
}
#[test]
fn the_multiplier_averages_about_one_under_its_own_shocks() {
for &(k, h, down) in &[(3.0, 40.0, 0.0), (4.0, 10.0, 1.0), (2.0, 20.0, 0.5)] {
let p = with_memory(k, h, down);
let b = p.market_factor_sigma * p.market_factor_sigma;
let mut s = MarketVarianceState::new_with(&p);
s.variance = b;
let mut z = Normals(20260926);
let (mut sum, mut n) = (0.0, 0u32);
for i in 0..400_000 {
s.day_factor = crate::mathx::sqrt(b) * z.next();
s.step_leverage_memory(&p);
if i >= 2_000 {
sum += MarketVarianceState::leverage_multiplier(&p, s.leverage_memory);
n += 1;
}
}
let mean = sum / n as f64;
assert!((mean - 1.0).abs() < 0.02, "k {k}, H {h}, down {down}: E[m] {mean}");
}
}
#[test]
fn the_components_are_fed_the_shock_in_their_own_units() {
let p = with_memory(3.0, 40.0, 0.0);
let mut s = MarketVarianceState::new_with(&p);
let mix = s.mixture(&p);
s.variance = 2.0 * mix;
let f = -0.02;
let fed = s.day_factor_scaled_for_test(&p, f);
assert!((fed - f / crate::mathx::sqrt(2.0)).abs() < 1e-15);
}
#[test]
fn a_forced_close_moves_the_memory_but_not_the_forced_level() {
let p = with_memory(3.0, 40.0, 0.0);
let anchor = p.market_vol_vix_anchor;
let mut forced = MarketVarianceState::new_with(&p);
forced.accumulate(-0.03);
forced.close_day_forced(&p, anchor, 30.0, 1.0);
assert!(forced.leverage_memory() > 0.0);
let level = MarketVarianceState::forced_level(&p, anchor, 30.0, 1.0);
assert_eq!(forced.variance().to_bits(), level.to_bits());
let q = pt_v20();
let mut plain = MarketVarianceState::new_with(&q);
plain.accumulate(-0.03);
plain.close_day_forced(&q, anchor, 30.0, 1.0);
assert_eq!(plain.leverage_memory(), 0.0);
assert_eq!(plain.variance().to_bits(),
MarketVarianceState::forced_level(&q, anchor, 30.0, 1.0).to_bits());
}
#[test]
fn standardise_zero_is_the_baseline_unit_to_the_bit() {
let p = with_memory(3.0, 40.0, 0.5);
assert_eq!(p.market_vol_leverage_standardise, 0.0);
let b = p.market_factor_sigma * p.market_factor_sigma;
let mut s = MarketVarianceState::new_with(&p);
s.variance = 3.0 * b;
s.day_factor = -0.017;
s.step_leverage_memory(&p);
let phi = leverage_phi(&p);
let sd_b = crate::mathx::sqrt(b);
let u = 0.017 / sd_b
- 0.5 * crate::mathx::sqrt(3.0 * b / b) / crate::mathx::sqrt(2.0 * std::f64::consts::PI);
assert_eq!(s.leverage_memory().to_bits(), ((1.0 - phi) * u).to_bits());
}
#[test]
fn standardised_memory_counts_a_day_in_its_own_sd() {
let mut p = with_memory(3.0, 40.0, 0.0);
p.market_vol_leverage_standardise = 1.0;
let b = p.market_factor_sigma * p.market_factor_sigma;
let mut storm = MarketVarianceState::new_with(&p);
storm.variance = 4.0 * b;
storm.day_factor = -0.02;
storm.step_leverage_memory(&p);
let mut calm = MarketVarianceState::new_with(&p);
calm.variance = b;
calm.day_factor = -0.01;
calm.step_leverage_memory(&p);
assert!((storm.leverage_memory() - calm.leverage_memory()).abs() < 1e-15);
p.market_vol_leverage_down = 1.0;
let mut up_storm = MarketVarianceState::new_with(&p);
up_storm.variance = 9.0 * b;
up_storm.day_factor = 0.03;
up_storm.step_leverage_memory(&p);
let mut up_calm = MarketVarianceState::new_with(&p);
up_calm.variance = b;
up_calm.day_factor = 0.001;
up_calm.step_leverage_memory(&p);
assert!((up_storm.leverage_memory() - up_calm.leverage_memory()).abs() < 1e-15);
}
#[test]
fn the_standardised_multiplier_averages_one_in_a_storm_too() {
for &(std, over) in &[(0.0, true), (1.0, false)] {
let mut p = with_memory(3.0, 15.0, 0.0);
p.market_vol_leverage_standardise = std;
let b = p.market_factor_sigma * p.market_factor_sigma;
let mut s = MarketVarianceState::new_with(&p);
s.variance = 4.0 * b;
let mut z = Normals(20260927);
let (mut sum, mut n) = (0.0, 0u32);
for i in 0..200_000 {
s.day_factor = 2.0 * crate::mathx::sqrt(b) * z.next();
s.step_leverage_memory(&p);
if i >= 2_000 {
sum += MarketVarianceState::leverage_multiplier(&p, s.leverage_memory);
n += 1;
}
}
let mean = sum / n as f64;
if over {
assert!(mean > 1.2, "baseline units in a storm: E[m] {mean}");
} else {
assert!((mean - 1.0).abs() < 0.02, "z-score units in a storm: E[m] {mean}");
}
}
}
#[test]
fn the_single_component_model_runs_the_memory_too() {
let mut p = with_memory(3.0, 40.0, 0.0);
p.market_vol_slow_weight = 0.0;
let s0 = MarketVarianceState::new_with(&p);
let fell = close_after(&p, &s0, -0.01);
let rose = close_after(&p, &s0, 0.01);
assert!(fell.leverage_memory() > 0.0);
assert!(fell.variance() > rose.variance());
}
}
#[cfg(test)]
mod fast_leverage {
use super::*;
use crate::params::ModelParams;
fn base() -> ModelParams {
let mut p = crate::params::PT_V20;
p.market_vol_leverage = 2.25;
p.market_vol_leverage_half_life = 15.0;
p.market_vol_leverage_standardise = 1.0;
p
}
fn with_fast(k: f64, h: f64) -> ModelParams {
let mut p = base();
p.market_vol_leverage_fast = k;
p.market_vol_leverage_fast_half_life = h;
p
}
fn close_after(p: &ModelParams, state: &MarketVarianceState, f: f64) -> MarketVarianceState {
let mut s = *state;
s.accumulate(f);
s.close_day_scaled(p, p.market_vol_vix_anchor, 19.0, 1.0);
s
}
#[test]
fn off_is_the_slower_memory_alone_to_the_bit() {
let p = base();
let mut q = base();
q.market_vol_leverage_fast_half_life = 5.0; let mut a = MarketVarianceState::new_with(&p);
let mut b = a;
for &f in &[-0.03, 0.01, -0.004, 0.02, 0.0, -0.05] {
a = close_after(&p, &a, f);
b = close_after(&q, &b, f);
assert_eq!(a, b);
assert_eq!(a.leverage_fast_memory().to_bits(), 0.0_f64.to_bits());
assert_eq!(a.vix_window_variance(&p).to_bits(), a.variance().to_bits());
assert_eq!(a.vix_window_ratio(&p), 1.0);
}
}
#[test]
fn a_fall_raises_and_a_rise_lowers_the_next_session_more_with_it() {
let p = with_fast(2.0, 5.0);
let q = base();
let s0 = MarketVarianceState::new_with(&p);
let fell = close_after(&p, &s0, -0.01);
let rose = close_after(&p, &s0, 0.01);
assert!(fell.leverage_fast_memory() > 0.0 && rose.leverage_fast_memory() < 0.0);
assert!(fell.variance() > close_after(&q, &s0, -0.01).variance());
assert!(rose.variance() < close_after(&q, &s0, 0.01).variance());
assert_eq!(fell.leverage_memory().to_bits(), close_after(&q, &s0, -0.01).leverage_memory().to_bits());
}
#[test]
fn the_memory_decays_at_its_half_life() {
let p = with_fast(2.0, 5.0);
let mut s = close_after(&p, &MarketVarianceState::new_with(&p), -0.02);
let l0 = s.leverage_fast_memory();
for _ in 0..5 {
s = close_after(&p, &s, 0.0);
}
assert!((s.leverage_fast_memory() / l0 - 0.5).abs() < 1e-12);
}
#[test]
fn the_vix_window_takes_a_burst_at_part_of_its_size() {
let p = with_fast(2.0, 5.0);
let s = close_after(&p, &MarketVarianceState::new_with(&p), -0.02);
let l = s.leverage_fast_memory();
let now = MarketVarianceState::leverage_fast_multiplier(&p, l);
let window = MarketVarianceState::leverage_fast_window_multiplier(&p, l);
assert!(now > 1.0 && window > 1.0 && window < now, "now {now}, window {window}");
assert!(s.vix_window_variance(&p) < s.variance());
let phi = leverage_fast_phi(&p);
let s2 = MarketVarianceState::leverage_fast_s2(&p);
let k = p.market_vol_leverage_fast;
let direct: f64 = (0..VIX_WINDOW_SESSIONS)
.map(|j| {
let d = phi.powi(j as i32);
(k * d * l - 0.5 * k * k * s2 * d * d).exp()
})
.sum::<f64>()
/ VIX_WINDOW_SESSIONS as f64;
assert!((window / direct - 1.0).abs() < 1e-12);
}
#[test]
fn a_forced_close_moves_the_memory_and_not_the_variance() {
let p = with_fast(2.0, 5.0);
let q = base();
let mut a = MarketVarianceState::new_with(&p);
let mut b = a;
a.accumulate(-0.02);
b.accumulate(-0.02);
a.close_day_forced(&p, p.market_vol_vix_anchor, 30.0, 1.0);
b.close_day_forced(&q, q.market_vol_vix_anchor, 30.0, 1.0);
assert!(a.leverage_fast_memory() > 0.0);
assert_eq!(a.variance().to_bits(), b.variance().to_bits());
}
}
#[cfg(test)]
mod fast_leverage_rises {
use super::*;
use crate::params::ModelParams;
fn with_fast(k: f64, h: f64, up: f64) -> ModelParams {
let mut p = crate::params::PT_V20;
p.market_vol_leverage = 2.25;
p.market_vol_leverage_half_life = 15.0;
p.market_vol_leverage_standardise = 1.0;
p.market_vol_leverage_fast = k;
p.market_vol_leverage_fast_half_life = h;
p.market_vol_leverage_fast_up = up;
p
}
fn close_after(p: &ModelParams, state: &MarketVarianceState, f: f64) -> MarketVarianceState {
let mut s = *state;
s.accumulate(f);
s.close_day_scaled(p, p.market_vol_vix_anchor, 19.0, 1.0);
s
}
#[test]
fn a_rise_lowers_it_and_a_fall_moves_it_by_the_centre_alone() {
let p = with_fast(2.0, 3.0, 1.0);
let s0 = MarketVarianceState::new_with(&p);
let rose = close_after(&p, &s0, 0.01);
let fell = close_after(&p, &s0, -0.01);
let fell_more = close_after(&p, &s0, -0.03);
assert!(rose.leverage_fast_memory() < 0.0);
assert!(fell.leverage_fast_memory() > 0.0);
assert_eq!(fell.leverage_fast_memory().to_bits(), fell_more.leverage_fast_memory().to_bits());
let sd = s0.variance().sqrt();
let up = close_after(&p, &s0, sd).leverage_fast_memory();
let dn = close_after(&p, &s0, -sd).leverage_fast_memory();
let phi = leverage_fast_phi(&p);
let x = sd * (2.0 / std::f64::consts::PI).sqrt();
let up_mean = close_after(&p, &s0, x).leverage_fast_memory();
assert!(((up_mean + dn) / (1.0 - phi)).abs() < 1e-12, "{up_mean} {dn}");
assert!(up < 0.0 && dn > 0.0);
}
#[test]
fn at_zero_it_is_the_both_signs_memory_to_the_bit() {
let p = with_fast(2.0, 5.0, 0.0);
let mut a = MarketVarianceState::new_with(&p);
let mut b = a;
for &f in &[-0.03, 0.01, -0.004, 0.02] {
a = close_after(&p, &a, f);
let mut s = b;
s.accumulate(f);
let x = s.leverage_input(&p);
let phi = leverage_fast_phi(&p);
let expected = phi * b.leverage_fast_memory() + (1.0 - phi) * x;
b = close_after(&p, &b, f);
assert_eq!(a.leverage_fast_memory().to_bits(), expected.to_bits());
}
}
}