stochastic-rs-quant 2.5.3

Quantitative finance: pricing, calibration, vol surfaces, instruments.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

//! Deterministic regressions for spot Fourier-Malliavin estimators.

use ndarray::Array1;

use super::fixtures::HESTON_RHO;
use super::fixtures::HESTON_SIGMA_V;
use super::fixtures::heston_paths;
use crate::fourier_malliavin::FMVol;

#[test]
fn spot_variance_tracks_heston_path() {
  let (log_prices, variance, _) = heston_paths();
  let engine = FMVol::new_uniform(log_prices.as_slice().unwrap(), 1.0);
  let count = 21usize;
  let tau = Array1::linspace(0.0, 1.0, count);
  let spot = engine.spot_variance(tau.as_slice().unwrap(), None);
  let step = (log_prices.len() - 1) / (count - 1);
  let mae = (0..count)
    .map(|index| (spot[index] - variance[index * step]).abs())
    .sum::<f64>()
    / count as f64;

  assert!(mae < 0.25, "mae={mae:.4}");
}

#[test]
fn spot_self_covariance_tracks_spot_variance() {
  let (log_prices, _, _) = heston_paths();
  let engine = FMVol::new_uniform(log_prices.as_slice().unwrap(), 1.0);
  let tau = Array1::linspace(0.0, 1.0, 11);
  let variance = engine.spot_variance(tau.as_slice().unwrap(), None);
  let covariance = engine.spot_covariance(&engine, tau.as_slice().unwrap(), None);
  let max_difference = variance
    .iter()
    .zip(covariance.iter())
    .map(|(left, right)| (left - right).abs())
    .fold(0.0_f64, f64::max);

  assert!(max_difference < 0.05, "max_difference={max_difference:.6}");
}

#[test]
fn spot_leverage_mean_tracks_heston_reference() {
  let (log_prices, variance, _) = heston_paths();
  let engine = FMVol::new_uniform(log_prices.as_slice().unwrap(), 1.0);
  let count = 11usize;
  let tau = Array1::linspace(0.0, 1.0, count);
  let spot = engine.spot_leverage(tau.as_slice().unwrap(), None, None);
  let step = (log_prices.len() - 1) / (count - 1);
  let expected_mean = (0..count)
    .map(|index| HESTON_SIGMA_V * HESTON_RHO * variance[index * step])
    .sum::<f64>()
    / count as f64;
  let actual_mean = spot.sum() / count as f64;
  let relative_error = (actual_mean - expected_mean).abs() / expected_mean.abs();

  assert!(actual_mean < 0.0);
  assert!(relative_error < 0.30, "relative_error={relative_error:.4}");
}

#[test]
fn raw_spot_volvol_mean_is_within_finite_sample_envelope() {
  let (log_prices, variance, _) = heston_paths();
  let engine = FMVol::new_uniform(log_prices.as_slice().unwrap(), 1.0);
  let count = 11usize;
  let tau = Array1::linspace(0.0, 1.0, count);
  let spot = engine.spot_volvol(tau.as_slice().unwrap(), None, None);
  let step = (log_prices.len() - 1) / (count - 1);
  let expected_mean = (0..count)
    .map(|index| HESTON_SIGMA_V.powi(2) * variance[index * step])
    .sum::<f64>()
    / count as f64;
  let actual_mean = spot.sum() / count as f64;

  assert!(actual_mean > 0.3 * expected_mean && actual_mean < 3.0 * expected_mean);
}

#[test]
fn corrected_spot_volvol_mean_tracks_heston_reference() {
  let (log_prices, variance, _) = heston_paths();
  let engine = FMVol::new_uniform(log_prices.as_slice().unwrap(), 1.0);
  let count = 11usize;
  let tau = Array1::linspace(0.0, 1.0, count);
  let spot = engine.spot_volvol_bias_corrected(tau.as_slice().unwrap(), None, None);
  let step = (log_prices.len() - 1) / (count - 1);
  let expected_mean = (0..count)
    .map(|index| HESTON_SIGMA_V.powi(2) * variance[index * step])
    .sum::<f64>()
    / count as f64;
  let actual_mean = spot.sum() / count as f64;
  let relative_error = (actual_mean - expected_mean).abs() / expected_mean;

  assert!(actual_mean > 0.0);
  assert!(relative_error < 0.40, "relative_error={relative_error:.4}");
}

#[test]
fn spot_quarticity_mean_is_positive() {
  let (log_prices, _, _) = heston_paths();
  let engine = FMVol::new_uniform(log_prices.as_slice().unwrap(), 1.0);
  let tau = Array1::linspace(0.0, 1.0, 11);
  let spot = engine.spot_quarticity(tau.as_slice().unwrap(), None, None);

  assert!(spot.sum() / spot.len() as f64 > 0.0);
}

#[test]
fn spot_variance_supports_f32() {
  let (prices_f64, _, _) = heston_paths();
  let prices = prices_f64.mapv(|value| value as f32);
  let tau = Array1::linspace(0.0_f32, 1.0, 11);
  let engine = FMVol::new_uniform(prices.as_slice().unwrap(), 1.0_f32);
  let spot = engine.spot_variance(tau.as_slice().unwrap(), None);
  let mean = spot.sum() / spot.len() as f32;

  assert!(mean > 0.1 && mean < 0.8, "mean={mean}");
}

#[test]
fn fe_and_fm_spot_windows_track_heston_path() {
  let (log_prices, variance, _) = heston_paths();
  let engine = FMVol::new_uniform(log_prices.as_slice().unwrap(), 1.0);
  let tau = Array1::linspace(0.0, 1.0, 11);
  let fm = engine.spot_variance(tau.as_slice().unwrap(), None);
  let fe = engine.spot_variance_fe(tau.as_slice().unwrap(), None);
  let step = (log_prices.len() - 1) / (tau.len() - 1);
  let fm_mae = (0..tau.len())
    .map(|index| (fm[index] - variance[index * step]).abs())
    .sum::<f64>()
    / tau.len() as f64;
  let fe_mae = (0..tau.len())
    .map(|index| (fe[index] - variance[index * step]).abs())
    .sum::<f64>()
    / tau.len() as f64;

  assert!(fm_mae < 0.30, "fm_mae={fm_mae:.4}");
  assert!(fe_mae < 0.30, "fe_mae={fe_mae:.4}");
}