stochastic-rs-quant 2.5.4

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

//! # Loss
//!
//! $$
//! L=\frac1n\sum_{i=1}^n \ell(y_i,\hat y_i)
//! $$
//!
/// Mean Absolute Error: MAE = (1/N) Σ|market_i - model_i|
pub fn mae(market: &[f64], model: &[f64]) -> f64 {
  market
    .iter()
    .zip(model.iter())
    .map(|(m, d)| (m - d).abs())
    .sum::<f64>()
    / market.len() as f64
}

/// Mean Squared Error: MSE = (1/N) Σ(market_i - model_i)²
pub fn mse(market: &[f64], model: &[f64]) -> f64 {
  market
    .iter()
    .zip(model.iter())
    .map(|(m, d)| (m - d).powi(2))
    .sum::<f64>()
    / market.len() as f64
}

/// Root Mean Squared Error: RMSE = √MSE
pub fn rmse(market: &[f64], model: &[f64]) -> f64 {
  mse(market, model).sqrt()
}

/// Mean Percentage Error (in %): MPE = (100/N) Σ[(market_i - model_i) / market_i]
///
/// Returns `f64::NAN` when any `market_i` is approximately zero — this
/// previously returned `0.0` for that term, which silently masked
/// zero-strike inputs (typical of malformed option chains). Filter or
/// clip near-zero markets at the caller side if you want a finite
/// result on degenerate inputs.
pub fn mpe(market: &[f64], model: &[f64]) -> f64 {
  let sum: f64 = market
    .iter()
    .zip(model.iter())
    .map(|(m, d)| {
      if m.abs() < f64::EPSILON {
        f64::NAN
      } else {
        (m - d) / m
      }
    })
    .sum();
  (sum / market.len() as f64) * 100.0
}

/// Mean Relative Error: MRE = (1/N) Σ[(model_i - market_i) / market_i]
///
/// Returns `f64::NAN` when any `market_i` is approximately zero. See
/// [`mpe`] for the rationale.
pub fn mre(market: &[f64], model: &[f64]) -> f64 {
  let sum: f64 = market
    .iter()
    .zip(model.iter())
    .map(|(m, d)| {
      if m.abs() < f64::EPSILON {
        f64::NAN
      } else {
        (d - m) / m
      }
    })
    .sum();
  sum / market.len() as f64
}

/// Mean Relative Percentage Error (in %): MRPE = MRE × 100. Returns
/// NaN when any `market_i` ≈ 0 (see [`mre`]).
pub fn mrpe(market: &[f64], model: &[f64]) -> f64 {
  mre(market, model) * 100.0
}

/// Mean Absolute Percentage Error (in %): MAPE = (100/N) Σ[|market_i - model_i| / |market_i|]
///
/// Returns `f64::NAN` when any `market_i` is approximately zero. See
/// [`mpe`] for the rationale.
pub fn mape(market: &[f64], model: &[f64]) -> f64 {
  let sum: f64 = market
    .iter()
    .zip(model.iter())
    .map(|(m, d)| {
      if m.abs() < f64::EPSILON {
        f64::NAN
      } else {
        (m - d).abs() / m.abs()
      }
    })
    .sum();
  (sum / market.len() as f64) * 100.0
}

/// Mean Squared Percentage Error (in %): MSPE = (100/N) Σ[((market_i - model_i) / market_i)²]
///
/// Returns `f64::NAN` when any `market_i` is approximately zero. See
/// [`mpe`] for the rationale.
pub fn mspe(market: &[f64], model: &[f64]) -> f64 {
  let sum: f64 = market
    .iter()
    .zip(model.iter())
    .map(|(m, d)| {
      if m.abs() < f64::EPSILON {
        f64::NAN
      } else {
        ((m - d) / m).powi(2)
      }
    })
    .sum();
  (sum / market.len() as f64) * 100.0
}

/// Root Mean Squared Percentage Error (in %): RMSPE = √MSPE
pub fn rmspe(market: &[f64], model: &[f64]) -> f64 {
  mspe(market, model).sqrt()
}