stochastic-rs-quant 2.0.0-rc.1

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

//! Equity vanilla / digital options as first-class [`Instrument`]s.
//!
//! These types describe the payoff only — strike, exercise, type. Pair
//! with an engine from [`crate::pricing::engines`] (analytic Black-Scholes,
//! analytic Heston, …) to obtain a price.
//!
//! ```ignore
//! use stochastic_rs_quant::instruments::equity::EuropeanOption;
//! use stochastic_rs_quant::pricing::engines::AnalyticBSEngine;
//! use stochastic_rs_quant::OptionType;
//!
//! let opt = EuropeanOption::new_tau(100.0, OptionType::Call, 0.5);
//! let engine = AnalyticBSEngine::with_constants(100.0, 0.20, 0.05, 0.0);
//! let r = engine.calculate(&opt);
//! ```

use crate::OptionType;
use crate::traits::Instrument;

/// European-exercise vanilla equity option.
///
/// Maturity may be specified either in years (`tau`) or as a calendar
/// date pair (`eval`/`expiry`); engines pick whichever is provided.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct EuropeanOption {
  pub strike: f64,
  pub option_type: OptionType,
  pub tau: Option<f64>,
  pub eval: Option<chrono::NaiveDate>,
  pub expiry: Option<chrono::NaiveDate>,
}

impl EuropeanOption {
  /// European option with maturity in years.
  pub const fn new_tau(strike: f64, option_type: OptionType, tau: f64) -> Self {
    Self {
      strike,
      option_type,
      tau: Some(tau),
      eval: None,
      expiry: None,
    }
  }

  /// European option with calendar dates.
  pub const fn new_dates(
    strike: f64,
    option_type: OptionType,
    eval: chrono::NaiveDate,
    expiry: chrono::NaiveDate,
  ) -> Self {
    Self {
      strike,
      option_type,
      tau: None,
      eval: Some(eval),
      expiry: Some(expiry),
    }
  }
}

impl Instrument for EuropeanOption {
  fn instrument_kind(&self) -> &'static str {
    match self.option_type {
      OptionType::Call => "EuropeanCall",
      OptionType::Put => "EuropeanPut",
    }
  }
}

/// Cash-or-nothing or asset-or-nothing digital option.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct DigitalOption {
  pub strike: f64,
  pub option_type: OptionType,
  pub kind: DigitalKind,
  pub tau: Option<f64>,
  pub eval: Option<chrono::NaiveDate>,
  pub expiry: Option<chrono::NaiveDate>,
}

/// Digital option payoff style.
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum DigitalKind {
  /// Pays fixed cash amount if in-the-money at expiry.
  CashOrNothing { cash: f64 },
  /// Pays underlying asset value if in-the-money at expiry.
  AssetOrNothing,
}

impl DigitalOption {
  pub const fn cash_or_nothing(strike: f64, option_type: OptionType, cash: f64, tau: f64) -> Self {
    Self {
      strike,
      option_type,
      kind: DigitalKind::CashOrNothing { cash },
      tau: Some(tau),
      eval: None,
      expiry: None,
    }
  }

  pub const fn asset_or_nothing(strike: f64, option_type: OptionType, tau: f64) -> Self {
    Self {
      strike,
      option_type,
      kind: DigitalKind::AssetOrNothing,
      tau: Some(tau),
      eval: None,
      expiry: None,
    }
  }
}

impl Instrument for DigitalOption {
  fn instrument_kind(&self) -> &'static str {
    "DigitalOption"
  }
}

#[cfg(test)]
mod tests {
  use super::*;

  #[test]
  fn european_option_kind() {
    let call = EuropeanOption::new_tau(100.0, OptionType::Call, 0.5);
    let put = EuropeanOption::new_tau(100.0, OptionType::Put, 0.5);
    assert_eq!(call.instrument_kind(), "EuropeanCall");
    assert_eq!(put.instrument_kind(), "EuropeanPut");
  }

  #[test]
  fn digital_option_kind() {
    let opt = DigitalOption::cash_or_nothing(100.0, OptionType::Call, 1.0, 0.5);
    assert_eq!(opt.instrument_kind(), "DigitalOption");
  }
}