quant-opts 0.1.0

High-performance Rust library for option pricing and risk
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

use super::{
    BlackScholes,
    math::{nd1_nd2, nprimed1},
};
use crate::{
    DAYS_PER_YEAR, OptionType,
    core::{Greeks, MarketData, VanillaOption},
};

impl BlackScholes {
    /// Compute the Black–Scholes delta.
    pub fn delta(option: &VanillaOption, market: &MarketData, vol: f64) -> Result<f64, String> {
        let (nd1, _) = nd1_nd2(option, market, vol)?;
        let q = market.dividend_yield;
        let t = option.maturity;

        let sign = match option.kind {
            OptionType::Call => 1.0,
            OptionType::Put => -1.0,
        };

        let delta = sign * (-q * t).exp() * nd1;
        Ok(delta)
    }

    /// Compute the Black–Scholes gamma.
    pub fn gamma(option: &VanillaOption, market: &MarketData, vol: f64) -> Result<f64, String> {
        let sigma = vol;
        let nprimed1 = nprimed1(option, market, sigma)?;

        let s = market.spot;
        let q = market.dividend_yield;
        let t = option.maturity;

        let gamma = (-q * t).exp() * nprimed1 / (s * sigma * t.sqrt());
        Ok(gamma)
    }

    /// Compute the Black–Scholes theta (per day).
    pub fn theta(option: &VanillaOption, market: &MarketData, vol: f64) -> Result<f64, String> {
        let sigma = vol;
        let nprimed1 = nprimed1(option, market, sigma)?;
        let (nd1, nd2) = nd1_nd2(option, market, sigma)?;

        let s = market.spot;
        let k = option.strike;
        let r = market.rate;
        let q = market.dividend_yield;
        let t = option.maturity;

        let sign = match option.kind {
            OptionType::Call => 1.0,
            OptionType::Put => -1.0,
        };

        let term1 = -(s * sigma * (-q * t).exp() * nprimed1 / (2.0 * t.sqrt()));
        let term2 = -r * k * (-r * t).exp() * nd2 * sign;
        let term3 = q * s * (-q * t).exp() * nd1 * sign;

        let theta = (term1 + term2 + term3) / DAYS_PER_YEAR;
        Ok(theta)
    }

    /// Compute the Black–Scholes vega.
    pub fn vega(option: &VanillaOption, market: &MarketData, vol: f64) -> Result<f64, String> {
        let nprimed1 = nprimed1(option, market, vol)?;

        let s = market.spot;
        let q = market.dividend_yield;
        let t = option.maturity;

        let vega = 0.01 * s * (-q * t).exp() * t.sqrt() * nprimed1;
        Ok(vega)
    }

    /// Compute the Black–Scholes rho.
    pub fn rho(option: &VanillaOption, market: &MarketData, vol: f64) -> Result<f64, String> {
        let (_, nd2) = nd1_nd2(option, market, vol)?;

        let k = option.strike;
        let r = market.rate;
        let t = option.maturity;

        let sign = match option.kind {
            OptionType::Call => 1.0,
            OptionType::Put => -1.0,
        };

        let rho = sign * k * t * (-r * t).exp() * nd2 / 100.0;
        Ok(rho)
    }

    /// Compute a full set of Greeks using the core `Greeks` struct.
    ///
    /// This mirrors the existing Greeks implementation but returns a structured
    /// value instead of a map.
    pub fn greeks(option: &VanillaOption, market: &MarketData, vol: f64) -> Result<Greeks, String> {
        let delta = Self::delta(option, market, vol)?;
        let gamma = Self::gamma(option, market, vol)?;
        let theta = Self::theta(option, market, vol)?;
        let vega = Self::vega(option, market, vol)?;
        let rho = Self::rho(option, market, vol)?;

        // Higher-order Greeks are not yet re-expressed here; they can
        // be added as needed by porting the formulas from the original
        // implementation.
        Ok(Greeks {
            delta,
            gamma,
            theta,
            vega,
            rho,
            ..Greeks::default()
        })
    }
}