use super::pricing::black_price;
use super::symbol::Right;
use crate::mathx;
pub const STRIP_POINTS: usize = 400;
pub const STRIP_WIDTH: f64 = 8.0;
pub const VIX_SESSIONS: f64 = 21.0;
pub const TERM_PREMIUM_TENORS: (f64, f64) = (6.0, 252.0);
pub const NAME_TERM_ANCHOR: f64 = 63.0;
const YEAR: f64 = 252.0;
#[derive(Debug, Clone, Copy, PartialEq)]
#[non_exhaustive]
pub struct Ssvi {
pub rho: f64,
pub eta: f64,
pub gamma: f64,
pub shift: f64,
pub anchor: f64,
pub tenor: f64,
}
impl Ssvi {
pub fn new(rho: f64, eta: f64, gamma: f64) -> Self {
Ssvi { rho, eta, gamma, shift: 0.0, anchor: 0.0, tenor: 0.0 }
}
pub fn with_shift(self, shift: f64) -> Self {
Ssvi { shift, ..self }
}
pub fn with_tenor(self, anchor: f64, tenor: f64) -> Self {
if tenor == 0.0 {
return self;
}
Ssvi { anchor, tenor, ..self }
}
fn power_law(&self, theta: f64) -> f64 {
self.eta * mathx::pow(theta, -self.gamma) * mathx::pow(1.0 + theta, self.gamma - 1.0)
}
pub fn phi(&self, theta: f64) -> f64 {
if self.eta == 0.0 {
return 0.0;
}
if self.anchor > 0.0 {
return self.power_law(self.anchor) * mathx::pow(theta / self.anchor, -self.tenor);
}
self.power_law(theta)
}
pub fn total_variance(&self, k: f64, theta: f64) -> f64 {
let p = self.phi(theta);
let r = self.rho;
let k = if self.shift == 0.0 || p == 0.0 { k } else { k - self.shift * r / p };
let x = p * k + r;
0.5 * theta * (1.0 + r * p * k + mathx::sqrt(x * x + 1.0 - r * r))
}
pub fn check_durrleman(&self, theta: f64) -> Result<(), String> {
let width = 8.0 * mathx::sqrt(theta);
let h = 1e-5 * mathx::max(width, 1e-3);
for i in 0..=400 {
let k = -width + 2.0 * width * f64::from(i) / 400.0;
let w = self.total_variance(k, theta);
let w1 = (self.total_variance(k + h, theta) - self.total_variance(k - h, theta)) / (2.0 * h);
let w2 = (self.total_variance(k + h, theta) + self.total_variance(k - h, theta) - 2.0 * w) / (h * h);
let g = (1.0 - k * w1 / (2.0 * w)) * (1.0 - k * w1 / (2.0 * w)) - 0.25 * w1 * w1 * (1.0 / w + 0.25) + 0.5 * w2;
if !(w > 0.0 && g >= -1e-9) {
return Err(format!("butterfly: Durrleman's g is {g} at k {k}, theta {theta}"));
}
}
Ok(())
}
pub fn rho_bound(eta: f64) -> f64 {
if eta <= 1.0 {
0.999
} else {
mathx::max(0.0, mathx::min(0.999, 2.0 / eta - 1.0))
}
}
pub fn check(&self, theta: f64) -> Result<(), String> {
if self.shift != 0.0 {
return self.check_durrleman(theta);
}
let (r, e, g) = (self.rho, self.eta, self.gamma);
if !(theta > 0.0 && theta.is_finite()) {
return Err(format!("theta is {theta}; it is finite and positive"));
}
if !(r.abs() < 1.0 && (0.0..=1.0).contains(&g) && e >= 0.0 && e.is_finite() && (0.0..1.0).contains(&self.tenor)) {
return Err(format!("rho {r}, eta {e}, gamma {g}: |rho| < 1, eta >= 0, gamma in [0, 1]"));
}
let p = self.phi(theta);
let a = 1.0 + r.abs();
if !(theta * p * a < 4.0) {
return Err(format!("butterfly: theta phi (1 + |rho|) is {} at theta {theta}, not below 4", theta * p * a));
}
if !(theta * p * p * a <= 4.0) {
return Err(format!("butterfly: theta phi^2 (1 + |rho|) is {} at theta {theta}, above 4", theta * p * p * a));
}
let slope = if self.anchor > 0.0 { p * (1.0 - self.tenor) } else { p * (1.0 - g) / (1.0 + theta) };
if slope < 0.0 {
return Err(format!("calendar: d(theta phi)/d theta is {slope} at theta {theta}, below 0"));
}
if r != 0.0 {
let cap = (1.0 + mathx::sqrt(1.0 - r * r)) * p / (r * r);
if slope > cap {
return Err(format!("calendar: d(theta phi)/d theta is {slope} at theta {theta}, above {cap}"));
}
}
Ok(())
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
#[non_exhaustive]
pub struct StripMoments {
pub vix: f64,
pub skewness: f64,
}
impl StripMoments {
pub fn skew_index(&self) -> f64 {
100.0 - 10.0 * self.skewness
}
}
pub fn strip_moments(iv: impl Fn(f64) -> f64, years: f64) -> Option<StripMoments> {
let s0 = iv(0.0) * mathx::sqrt(years);
if !(years > 0.0 && s0 > 0.0 && s0.is_finite()) {
return None;
}
let n = STRIP_POINTS;
let start = -STRIP_WIDTH * s0;
let step = 2.0 * STRIP_WIDTH * s0 / (n - 1) as f64;
let ks: Vec<f64> = (0..n).map(|i| if i == n - 1 { STRIP_WIDTH * s0 } else { start + i as f64 * step }).collect();
let strikes: Vec<f64> = ks.iter().map(|k| mathx::exp(*k)).collect();
let (mut s1, mut p2, mut p3) = (0.0, 0.0, 0.0);
for i in 0..n {
let k = strikes[i];
let dk = if i == 0 {
strikes[1] - strikes[0]
} else if i == n - 1 {
strikes[n - 1] - strikes[n - 2]
} else {
0.5 * (strikes[i + 1] - strikes[i - 1])
};
let right = if k >= 1.0 { Right::Call } else { Right::Put };
let q = black_price(right, 1.0, k, years, iv(ks[i]), 1.0);
let lk = ks[i];
let w = dk / (k * k) * q;
s1 += w;
p2 += 2.0 * (1.0 - lk) * w;
p3 += 3.0 * (2.0 * lk - lk * lk) * w;
}
let p1 = -s1;
let var = p2 - p1 * p1;
if !(s1 > 0.0 && var > 0.0) {
return None;
}
let vix = 100.0 * mathx::sqrt(2.0 / years * s1);
let skewness = (p3 - 3.0 * p1 * p2 + 2.0 * p1 * p1 * p1) / (var * mathx::sqrt(var));
Some(StripMoments { vix, skewness })
}
pub fn smile_moments(ssvi: &Ssvi, theta: f64, years: f64) -> Option<StripMoments> {
strip_moments(|k| mathx::sqrt(ssvi.total_variance(k, theta) / years), years)
}
#[derive(Debug, Clone, Copy, PartialEq)]
#[non_exhaustive]
pub struct SmileFit {
pub theta: f64,
pub rho: f64,
pub moments: StripMoments,
pub reached: bool,
}
fn theta_for_vix(
rho: f64,
eta: f64,
gamma: f64,
shift: f64,
target_vix: f64,
years: f64,
start: f64,
) -> Option<(f64, StripMoments)> {
let ssvi = Ssvi::new(rho, eta, gamma).with_shift(shift);
let mut theta = start;
let mut last = None;
for _ in 0..100 {
let m = smile_moments(&ssvi, theta, years)?;
let ratio = target_vix / m.vix;
last = Some((theta, m));
if (ratio - 1.0).abs() <= 1e-13 {
break;
}
theta *= ratio * ratio;
if !(theta > 0.0 && theta.is_finite()) {
return None;
}
}
last
}
pub fn fit_smile(target_vix: f64, target_skewness: Option<f64>, years: f64, eta: f64, gamma: f64) -> Option<SmileFit> {
fit_smile_shifted(target_vix, target_skewness, years, eta, gamma, 0.0)
}
pub fn fit_smile_shifted(
target_vix: f64,
target_skewness: Option<f64>,
years: f64,
eta: f64,
gamma: f64,
shift: f64,
) -> Option<SmileFit> {
if !(target_vix > 0.0 && target_vix.is_finite() && years > 0.0) {
return None;
}
let start = (target_vix / 100.0) * (target_vix / 100.0) * years;
let target = match target_skewness {
Some(s) if eta > 0.0 && s.is_finite() => s,
_ => {
let (theta, moments) = theta_for_vix(0.0, eta, gamma, shift, target_vix, years, start)?;
return Some(SmileFit { theta, rho: 0.0, moments, reached: target_skewness.is_none() || eta == 0.0 });
}
};
let bound = Ssvi::rho_bound(eta);
let mut theta_hint = start;
let mut eval = |rho: f64| -> Option<(f64, StripMoments)> {
let r = theta_for_vix(rho, eta, gamma, shift, target_vix, years, theta_hint)?;
theta_hint = r.0;
Some(r)
};
let (mut a, mut b) = (-bound, bound);
let (ta, ma) = eval(a)?;
let (tb, mb) = eval(b)?;
let (mut fa, mut fb) = (ma.skewness - target, mb.skewness - target);
if fa >= 0.0 {
return Some(SmileFit { theta: ta, rho: a, moments: ma, reached: fa == 0.0 });
}
if fb <= 0.0 {
return Some(SmileFit { theta: tb, rho: b, moments: mb, reached: fb == 0.0 });
}
let mut best = (tb, b, mb);
let mut side = 0i8;
for _ in 0..200 {
let c = (a * fb - b * fa) / (fb - fa);
let (tc, mc) = eval(c)?;
let fc = mc.skewness - target;
best = (tc, c, mc);
if fc.abs() <= 1e-10 || (b - a) <= 1e-13 {
break;
}
if fc < 0.0 {
a = c;
fa = fc;
if side == -1 {
fb *= 0.5;
}
side = -1;
} else {
b = c;
fb = fc;
if side == 1 {
fa *= 0.5;
}
side = 1;
}
}
Some(SmileFit { theta: best.0, rho: best.1, moments: best.2, reached: true })
}
#[derive(Debug, Clone, Copy)]
#[non_exhaustive]
pub struct TermInputs<'a> {
pub variance: &'a [f64],
pub elapsed: f64,
pub premium_short: f64,
pub premium_long: f64,
pub events: &'a [(usize, f64)],
pub event_weight: f64,
pub name_slope: f64,
}
impl<'a> TermInputs<'a> {
pub fn new(
variance: &'a [f64],
elapsed: f64,
premium_short: f64,
premium_long: f64,
events: &'a [(usize, f64)],
event_weight: f64,
) -> Self {
TermInputs { variance, elapsed, premium_short, premium_long, events, event_weight, name_slope: 0.0 }
}
pub fn with_name_slope(self, name_slope: f64) -> Self {
TermInputs { name_slope, ..self }
}
}
pub fn term_premium(t: f64, short: f64, long: f64) -> f64 {
let t = mathx::max(1.0, t);
let (lo, hi) = TERM_PREMIUM_TENORS;
if t >= VIX_SESSIONS {
if long == 0.0 {
0.0
} else {
long * mathx::log(t / VIX_SESSIONS) / mathx::log(hi / VIX_SESSIONS)
}
} else if short == 0.0 {
0.0
} else {
short * mathx::log(VIX_SESSIONS / t) / mathx::log(VIX_SESSIONS / lo)
}
}
pub fn term_shape(inputs: &TermInputs<'_>, n_max: usize) -> Vec<f64> {
let v = |h: usize| -> f64 {
if inputs.variance.is_empty() {
1.0
} else {
inputs.variance[std::cmp::min(h, inputs.variance.len()) - 1]
}
};
let mut out = Vec::with_capacity(n_max);
let mut cumulative = -inputs.elapsed * v(1);
let mut events = 0.0;
for n in 1..=n_max {
cumulative += v(n);
for &(at, x) in inputs.events {
if at == n {
events += x;
}
}
let t = n as f64 - inputs.elapsed;
let premium = term_premium(t, inputs.premium_short, inputs.premium_long);
let premium = if inputs.name_slope == 0.0 {
premium
} else {
premium + inputs.name_slope * mathx::log(mathx::max(1.0, t) / NAME_TERM_ANCHOR)
};
let scaled = if premium == 0.0 { cumulative } else { cumulative * mathx::exp(premium) };
out.push(if inputs.event_weight == 0.0 { scaled } else { scaled + inputs.event_weight * events });
}
out
}
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub struct ThetaCurve {
pub elapsed: f64,
pub knots: Vec<f64>,
}
impl ThetaCurve {
pub fn new(shape: &[f64], elapsed: f64, theta_vix: f64) -> Option<Self> {
if shape.len() < 2 || !(theta_vix > 0.0) {
return None;
}
let mut knots = Vec::with_capacity(shape.len());
let mut top = 0.0;
for &x in shape {
if !(x.is_finite()) {
return None;
}
top = mathx::max(top, x);
knots.push(top);
}
let unit = ThetaCurve { elapsed, knots };
let at = unit.at(VIX_SESSIONS);
if !(at > 0.0) {
return None;
}
let scale = theta_vix / at;
Some(ThetaCurve { elapsed, knots: unit.knots.iter().map(|x| x * scale).collect() })
}
pub fn from_shape(shape: &[f64], elapsed: f64, factor: f64) -> Option<Self> {
if shape.len() < 2 || !(factor > 0.0 && factor.is_finite()) {
return None;
}
let mut knots = Vec::with_capacity(shape.len());
let mut top = 0.0;
for &x in shape {
if !(x.is_finite()) {
return None;
}
top = mathx::max(top, x);
knots.push(if factor == 1.0 { top } else { top * factor });
}
if !(knots[0] > 0.0) {
return None;
}
Some(ThetaCurve { elapsed, knots })
}
pub fn at(&self, t: f64) -> f64 {
if !(t > 0.0) {
return 0.0;
}
let x = t + self.elapsed;
let first = 1.0 - self.elapsed;
if t <= first {
return self.knots[0] * t / first;
}
let n = self.knots.len();
let i = x.floor() as usize;
if i >= n {
let slope = self.knots[n - 1] - self.knots[n - 2];
return self.knots[n - 1] + slope * (x - n as f64);
}
let frac = x - i as f64;
if frac == 0.0 {
return self.knots[i - 1];
}
self.knots[i - 1] + frac * (self.knots[i] - self.knots[i - 1])
}
}
const HOLD_LO: f64 = -6.0;
const HOLD_STEP: f64 = 0.5;
const HOLD_NODES: usize = 23;
fn strip_variance(ssvi: &Ssvi, theta: f64) -> Option<f64> {
smile_moments(ssvi, theta, 1.0).map(|m| (m.vix / 100.0) * (m.vix / 100.0))
}
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub struct StripHold {
pub anchor: f64,
pub logs: Vec<f64>,
}
impl StripHold {
pub fn new(scaled: &Ssvi) -> Option<Self> {
if scaled.tenor == 0.0 || !(scaled.anchor > 0.0) {
return None;
}
let base = Ssvi { anchor: 0.0, tenor: 0.0, ..*scaled };
let node = |theta: f64| -> Option<f64> {
let target = strip_variance(&base, theta)?;
let mut held = theta;
for _ in 0..100 {
let ratio = target / strip_variance(scaled, held)?;
if (ratio - 1.0).abs() <= 1e-12 {
break;
}
held *= ratio;
if !(held > 0.0 && held.is_finite()) {
return None;
}
}
Some(mathx::log(held / theta))
};
let zero = (-HOLD_LO / HOLD_STEP).round() as usize;
let mut logs = vec![0.0; HOLD_NODES];
for i in (zero + 1)..HOLD_NODES {
let theta = scaled.anchor * mathx::exp(HOLD_LO + HOLD_STEP * i as f64);
logs[i] = node(theta).unwrap_or(logs[i - 1]);
}
for i in (0..zero).rev() {
let theta = scaled.anchor * mathx::exp(HOLD_LO + HOLD_STEP * i as f64);
logs[i] = node(theta).unwrap_or(logs[i + 1]);
}
Some(StripHold { anchor: scaled.anchor, logs })
}
pub fn at(&self, theta: f64) -> f64 {
if !(theta > 0.0) {
return theta;
}
let u = (mathx::log(theta / self.anchor) - HOLD_LO) / HOLD_STEP;
let n = self.logs.len();
let l = if u <= 0.0 {
self.logs[0]
} else if u >= (n - 1) as f64 {
self.logs[n - 1]
} else {
let i = u.floor() as usize;
let f = u - i as f64;
if f == 0.0 { self.logs[i] } else { self.logs[i] + f * (self.logs[i + 1] - self.logs[i]) }
};
if l == 0.0 { theta } else { theta * mathx::exp(l) }
}
}
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub struct Surface {
pub root: String,
pub ssvi: Ssvi,
pub curve: ThetaCurve,
pub vix: f64,
pub skewness_target: Option<f64>,
pub fit: SmileFit,
pub hold: Option<StripHold>,
}
impl Surface {
pub fn theta(&self, t: f64) -> f64 {
let theta = self.curve.at(t);
match &self.hold {
Some(hold) => hold.at(theta),
None => theta,
}
}
pub fn total_variance(&self, k: f64, t: f64) -> f64 {
let theta = self.theta(t);
if !(theta > 0.0) {
return 0.0;
}
self.ssvi.total_variance(k, theta)
}
pub fn iv(&self, k: f64, t: f64) -> f64 {
if !(t > 0.0) {
return 0.0;
}
mathx::sqrt(self.total_variance(k, t) * YEAR / t)
}
pub fn strip(&self, t: f64) -> Option<StripMoments> {
strip_moments(|k| self.iv(k, t), t / YEAR)
}
pub fn check(&self) -> Result<(), String> {
let mut last = 0.0;
for (i, &knot) in self.curve.knots.iter().enumerate() {
let theta = self.hold.as_ref().map_or(knot, |h| h.at(knot));
if theta < last {
return Err(format!("calendar: theta falls from {last} to {theta} at knot {}", i + 1));
}
last = theta;
self.ssvi.check(theta)?;
}
if self.ssvi.shift != 0.0 {
for pair in self.curve.knots.windows(2) {
let pair = self.hold.as_ref().map_or([pair[0], pair[1]], |h| [h.at(pair[0]), h.at(pair[1])]);
let width = 8.0 * mathx::sqrt(pair[1]);
for i in 0..=200 {
let k = -width + 2.0 * width * f64::from(i) / 200.0;
let (a, b) = (self.ssvi.total_variance(k, pair[0]), self.ssvi.total_variance(k, pair[1]));
if b < a - 1e-12 {
return Err(format!("calendar: total variance falls from {a} to {b} at k {k}"));
}
}
}
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
const T21: f64 = 21.0 / 252.0;
#[test]
fn the_strip_hold_is_built_and_rises_at_every_level() {
for &rho in &[-0.999, -0.9, -0.4, 0.0, 0.8, 0.999] {
for &a in &[0.00005, 0.001, 0.01, 0.06, 0.4, 1.0] {
let s = Ssvi::new(rho, 1.0, 0.5).with_tenor(a, 0.4);
let h = StripHold::new(&s).unwrap();
assert_eq!(h.at(a), a);
let mut last = 0.0;
for i in 0..400 {
let t = a * mathx::exp(-8.0 + 0.035 * f64::from(i));
let held = h.at(t);
assert!(held > last && held.is_finite(), "rho {rho} anchor {a} theta {t}");
last = held;
}
}
}
}
#[test]
fn a_flat_smile_reads_vix_100_sigma_and_skew_100() {
for sigma in [0.08, 0.15, 0.3, 0.8] {
let m = strip_moments(|_| sigma, T21).unwrap();
assert!((m.vix - 100.0 * sigma).abs() < 2e-4 * 100.0 * sigma, "{sigma}: {}", m.vix);
assert!(m.skewness.abs() < 1e-3, "{sigma}: {}", m.skewness);
assert!((m.skew_index() - 100.0).abs() < 1e-2);
}
}
#[test]
fn a_put_skew_raises_skew() {
let flat = smile_moments(&Ssvi::new(0.0, 0.0, 0.5), 0.04 * T21, T21).unwrap();
let skewed = smile_moments(&Ssvi::new(-0.7, 1.0, 0.5), 0.04 * T21, T21).unwrap();
assert!(skewed.skew_index() > flat.skew_index() + 5.0, "{} {}", skewed.skew_index(), flat.skew_index());
let mut last = f64::NEG_INFINITY;
for rho in [0.6, 0.3, 0.0, -0.3, -0.6, -0.9] {
let m = smile_moments(&Ssvi::new(rho, 1.0, 0.5), 0.04 * T21, T21).unwrap();
assert!(m.skew_index() > last, "{rho}");
last = m.skew_index();
}
}
#[test]
fn the_fit_prices_the_vix_and_the_skewness_asked() {
for vix in [11.0, 18.0, 30.0, 65.0] {
for skew in [-0.5, -1.5, -2.5] {
let fit = fit_smile(vix, Some(skew), T21, 1.0, 0.5).unwrap();
assert!(fit.reached);
assert!((fit.moments.vix - vix).abs() < 1e-9 * vix, "{vix} {skew}: {}", fit.moments.vix);
assert!((fit.moments.skewness - skew).abs() < 1e-8, "{vix} {skew}: {}", fit.moments.skewness);
let again = smile_moments(&Ssvi::new(fit.rho, 1.0, 0.5), fit.theta, T21).unwrap();
assert!((again.vix - vix).abs() < 1e-9 * vix);
assert!(fit.rho.abs() < Ssvi::rho_bound(1.0));
Ssvi::new(fit.rho, 1.0, 0.5).check(fit.theta).unwrap();
}
}
let flat = fit_smile(20.0, None, T21, 1.2, 0.4).unwrap();
assert_eq!(flat.rho, 0.0);
assert!((flat.moments.vix - 20.0).abs() < 1e-9 * 20.0);
let far = fit_smile(20.0, Some(-40.0), T21, 1.2, 0.4).unwrap();
assert!(!far.reached);
assert_eq!(far.rho, -Ssvi::rho_bound(1.2));
assert!((far.moments.vix - 20.0).abs() < 1e-9 * 20.0);
}
#[test]
fn the_conditions_hold_inside_the_remark_and_fail_outside() {
for eta in [0.2, 1.0, 1.5, 1.99] {
let bound = Ssvi::rho_bound(eta);
assert!(eta * (1.0 + bound) <= 2.0 + 1e-12 || eta <= 1.0);
for gamma in [0.0, 0.25, 0.5] {
for rho in [-bound, -0.5 * bound, 0.0, bound] {
let s = Ssvi::new(rho, eta, gamma);
for theta in [1e-6, 1e-4, 0.003, 0.05, 1.0, 50.0] {
s.check(theta).unwrap_or_else(|e| panic!("{eta} {gamma} {rho} {theta}: {e}"));
}
}
}
}
assert!(Ssvi::new(-0.9, 3.0, 0.5).check(10.0).is_err());
assert!(Ssvi::new(-0.9, 1.0, 0.5).check(0.0).is_err());
assert!(Ssvi::new(1.0, 1.0, 0.5).check(0.1).is_err());
}
#[test]
fn surface_prices_have_no_butterfly_or_calendar_arbitrage() {
let variance: Vec<f64> = (0..300).map(|h| 1.2e-4 * (1.0 + 0.6 * mathx::exp(-(h as f64) / 30.0))).collect();
let events = [(10usize, 4e-5), (40, 4e-5)];
let inputs = TermInputs {
variance: &variance,
elapsed: 0.3,
premium_short: -0.05,
premium_long: 0.15,
events: &events,
event_weight: 1.0,
name_slope: 0.0,
};
let shape = term_shape(&inputs, 270);
let fit = fit_smile(24.0, Some(-2.0), T21, 1.3, 0.45).unwrap();
let surface = Surface {
root: "IDX".into(),
ssvi: Ssvi::new(fit.rho, 1.3, 0.45),
curve: ThetaCurve::new(&shape, 0.3, fit.theta).unwrap(),
vix: 24.0,
skewness_target: Some(-2.0),
fit,
hold: None,
};
surface.check().unwrap();
assert!((surface.theta(21.0) - fit.theta).abs() <= 1e-14 * fit.theta);
assert!((surface.strip(21.0).unwrap().vix - 24.0).abs() < 1e-9 * 24.0);
let ks: Vec<f64> = (-120..=120).map(|i| i as f64 * 0.005).collect();
let tenors = [0.4, 0.7, 1.0, 5.0, 9.7, 10.0, 10.7, 21.0, 63.0, 126.5, 252.0, 280.0];
for &t in &tenors {
let years = t / 252.0;
let calls: Vec<f64> = ks
.iter()
.map(|k| black_price(Right::Call, 1.0, mathx::exp(*k), years, surface.iv(*k, t), 1.0))
.collect();
for i in 1..calls.len() {
assert!(calls[i] <= calls[i - 1] + 1e-15, "{t}: calls rise at {}", ks[i]);
}
for i in 1..calls.len() - 1 {
let (k0, k1, k2) = (mathx::exp(ks[i - 1]), mathx::exp(ks[i]), mathx::exp(ks[i + 1]));
let left = (calls[i] - calls[i - 1]) / (k1 - k0);
let right = (calls[i + 1] - calls[i]) / (k2 - k1);
assert!(right >= left - 1e-12, "{t}: a butterfly at {} is negative", ks[i]);
}
}
for w in tenors.windows(2) {
for k in &ks {
assert!(surface.total_variance(*k, w[1]) >= surface.total_variance(*k, w[0]), "{w:?} {k}");
}
}
}
#[test]
fn the_term_shape_reads_the_forecast_the_premia_and_the_reports() {
let flat = TermInputs { variance: &[], elapsed: 0.0, premium_short: 0.0, premium_long: 0.0, events: &[], event_weight: 0.0, name_slope: 0.0 };
let shape = term_shape(&flat, 252);
for (i, x) in shape.iter().enumerate() {
assert_eq!(*x, (i + 1) as f64);
}
let v: Vec<f64> = (1..=100).map(|h| if h <= 21 { 1e-4 } else { 2e-4 }).collect();
let fc = TermInputs { variance: &v, ..flat };
let curve = ThetaCurve::new(&term_shape(&fc, 100), 0.0, 0.003).unwrap();
assert!((curve.at(21.0) - 0.003).abs() < 1e-18);
assert!((curve.at(42.0) - 0.009).abs() < 1e-15);
let prem = TermInputs { premium_long: 0.2, ..flat };
let s = term_shape(&prem, 252);
assert!((s[251] / 252.0 - mathx::exp(0.2)).abs() < 1e-12);
assert_eq!(s[20], 21.0);
let events = [(5usize, 3.0)];
let ev = TermInputs { events: &events, event_weight: 0.5, ..flat };
let s = term_shape(&ev, 10);
assert_eq!(s[3], 4.0);
assert_eq!(s[4], 5.0 + 1.5);
assert_eq!(s[9], 10.0 + 1.5);
let part = TermInputs { elapsed: 0.25, ..flat };
let c = ThetaCurve::new(&term_shape(&part, 30), 0.25, 21.0).unwrap();
assert!((c.at(0.75) - 0.75).abs() < 1e-12);
assert!((c.at(21.0) - 21.0).abs() < 1e-12);
assert!((c.at(40.0) - 40.0).abs() < 1e-12, "{}", c.at(40.0));
assert!((c.at(35.0) - 35.0).abs() < 1e-12);
}
#[test]
fn a_falling_shape_is_held_at_its_running_maximum() {
let c = ThetaCurve::new(&[1.0, 3.0, 2.0, 4.0], 0.0, 3.0);
let c = c.unwrap();
assert_eq!(c.knots[1], c.knots[2]);
for w in c.knots.windows(2) {
assert!(w[1] >= w[0]);
}
}
}