stochastic-rs-quant 2.6.0

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

use crate::traits::FloatExt;

/// Payoff types supported by the M-T engine.
#[derive(Clone, Debug)]
pub enum MtPayoff<T: FloatExt> {
  /// Vanilla call `(S^{asset}_T − K)₊`.
  Call { asset: usize, strike: T },
  /// Vanilla put `(K − S^{asset}_T)₊`.
  Put { asset: usize, strike: T },
  /// Digital put on 2 assets: `1(0≤S₁≤K₁)·1(0≤S₂≤K₂)`.
  DigitalPut2D { strikes: [T; 2] },
  /// Basket call `(Σ wᵢ Sᵢ − K)₊`.
  BasketCall { weights: Vec<T>, strike: T },
  /// Worst-of put `(K − min Sᵢ)₊`.
  WorstOfPut { strike: T },
}

impl<T: FloatExt> MtPayoff<T> {
  pub fn evaluate(&self, st: &[T]) -> T {
    match self {
      Self::Call { asset, strike } => (st[*asset] - *strike).max(T::zero()),
      Self::Put { asset, strike } => (*strike - st[*asset]).max(T::zero()),
      Self::DigitalPut2D { strikes } => {
        assert_eq!(st.len(), 2, "DigitalPut2D requires exactly two assets");
        if st[0] >= T::zero() && st[0] <= strikes[0] && st[1] >= T::zero() && st[1] <= strikes[1] {
          T::one()
        } else {
          T::zero()
        }
      }
      Self::BasketCall { weights, strike } => {
        let basket = weights
          .iter()
          .zip(st)
          .map(|(&w, &s)| w * s)
          .fold(T::zero(), |a, b| a + b);
        (basket - *strike).max(T::zero())
      }
      Self::WorstOfPut { strike } => {
        let worst = st.iter().copied().fold(T::infinity(), |a, b| a.min(b));
        (*strike - worst).max(T::zero())
      }
    }
  }
}

#[cfg(test)]
mod tests {
  use super::*;
  use crate::pricing::malliavin_thalmaier::kernel::g_digital_put_2d;

  #[test]
  fn digital_put_support_is_closed_and_nonnegative() {
    let payoff = MtPayoff::DigitalPut2D {
      strikes: [100.0_f64, 100.0],
    };

    assert_eq!(payoff.evaluate(&[0.0, 0.0]), 1.0);
    assert_eq!(payoff.evaluate(&[100.0, 100.0]), 1.0);
    assert_eq!(payoff.evaluate(&[-1e-12, 50.0]), 0.0);
    assert_eq!(payoff.evaluate(&[50.0, -1e-12]), 0.0);
    assert_eq!(payoff.evaluate(&[100.0 + 1e-12, 50.0]), 0.0);
  }

  #[test]
  fn digital_put_support_matches_closed_form_kernel_trace() {
    let strikes = [100.0_f64, 80.0];
    let payoff = MtPayoff::DigitalPut2D { strikes };
    let points = [
      [0.0, 0.0],
      [100.0, 80.0],
      [0.0, 40.0],
      [50.0, 80.0],
      [-1e-12, 40.0],
      [50.0, 80.0 + 1e-12],
    ];

    for point in points {
      let kernel = g_digital_put_2d(point, strikes);
      let trace = kernel[0][0] + kernel[1][1];
      assert_eq!(trace, payoff.evaluate(&point), "point={point:?}");
    }
  }

  #[test]
  #[should_panic(expected = "DigitalPut2D requires exactly two assets")]
  fn digital_put_rejects_wrong_dimension() {
    let payoff = MtPayoff::DigitalPut2D {
      strikes: [100.0_f64, 100.0],
    };
    let _ = payoff.evaluate(&[50.0]);
  }
}