rustyqlib/equity/
forward_start_option.rs

1//! Forward-start options: the strike is fixed at a future date `t_f` as a
2//! fraction `k` of the then-prevailing spot; the payoff at expiry `T` is
3//! `(S_T - k * S_{t_f})^+` (call) or the mirrored put.
4//!
5//! - **Black-Scholes closed form** (Rubinstein 1991) via homogeneity:
6//!   `price = S_0 e^{-q t_f} * BS(1, k, r, q, sigma, T - t_f)`.
7//! - **Monte Carlo** through [`Payoff::path_payoff`]: the payoff reads
8//!   `S_{t_f}` off the simulated path, so the option prices under GBM,
9//!   local vol and — the reason this product exists — **Heston stochastic
10//!   vol**, whose forward smile differs materially from Black-Scholes.
11
12use crate::core::trade::PutOrCall;
13use crate::core::utils::ContractStyle;
14use crate::equity::blackscholes::bs_price;
15use crate::equity::utils::{Payoff, PayoffType};
16
17#[derive(Debug)]
18pub struct ForwardStartPayoff {
19    pub put_or_call: PutOrCall,
20    pub exercise_style: ContractStyle,
21    /// Strike as a fraction of the spot on the fixing date (1.0 = at the money).
22    pub strike_fraction: f64,
23    /// Fixing time as a fraction of the option life, in (0, 1).
24    pub start_fraction: f64,
25}
26
27impl Payoff for ForwardStartPayoff {
28    /// Degenerate single-point value (strike not yet fixed): zero.
29    fn payoff(&self, _spot: f64, _strike: f64) -> f64 {
30        0.0
31    }
32    fn path_payoff(&self, path: &[f64], _strike: f64) -> f64 {
33        let n = path.len();
34        // step i covers time (i+1) * T/n: the fixing index for t_f
35        let idx = ((self.start_fraction * n as f64).round() as usize).clamp(1, n - 1) - 1;
36        let strike = self.strike_fraction * path[idx];
37        let terminal = path[n - 1];
38        match self.put_or_call {
39            PutOrCall::Call => (terminal - strike).max(0.0),
40            PutOrCall::Put => (strike - terminal).max(0.0),
41        }
42    }
43    fn is_path_dependent(&self) -> bool {
44        true
45    }
46    fn payoff_kind(&self) -> PayoffType {
47        PayoffType::ForwardStart
48    }
49    fn put_or_call(&self) -> &PutOrCall {
50        &self.put_or_call
51    }
52    fn exercise_style(&self) -> &ContractStyle {
53        &self.exercise_style
54    }
55    fn as_any(&self) -> &dyn std::any::Any {
56        self
57    }
58}
59
60/// Rubinstein closed form under Black-Scholes: by homogeneity the value at
61/// the fixing date is `S_{t_f} * BS(1, k, r, q, sigma, T - t_f)`, so the
62/// time-0 value replaces `S_{t_f}` by its dividend-discounted spot.
63#[allow(clippy::too_many_arguments)]
64pub fn forward_start_price(
65    s: f64,
66    strike_fraction: f64,
67    r: f64,
68    q: f64,
69    sigma: f64,
70    start_t: f64,
71    t: f64,
72    put_or_call: PutOrCall,
73) -> f64 {
74    assert!(start_t > 0.0 && start_t < t, "fixing must lie inside the option life");
75    s * (-q * start_t).exp() * bs_price(1.0, strike_fraction, r, q, sigma, t - start_t, put_or_call)
76}
77
78#[cfg(test)]
79mod tests {
80    use super::*;
81
82    #[test]
83    fn reduces_to_vanilla_when_fixing_is_immediate() {
84        // t_f -> 0: strike ~= k * S_0, so the price approaches a vanilla
85        // struck at k * S_0
86        let fs = forward_start_price(100.0, 1.0, 0.05, 0.02, 0.3, 1e-6, 1.0, PutOrCall::Call);
87        let vanilla = bs_price(100.0, 100.0, 0.05, 0.02, 0.3, 1.0, PutOrCall::Call);
88        assert!((fs - vanilla).abs() < 1e-3, "{fs} vs {vanilla}");
89    }
90
91    #[test]
92    fn price_is_homogeneous_in_spot() {
93        let p1 = forward_start_price(100.0, 1.0, 0.05, 0.02, 0.3, 0.5, 1.0, PutOrCall::Call);
94        let p2 = forward_start_price(200.0, 1.0, 0.05, 0.02, 0.3, 0.5, 1.0, PutOrCall::Call);
95        assert!((p2 - 2.0 * p1).abs() < 1e-12);
96    }
97
98    #[test]
99    fn path_payoff_reads_fixing_off_the_path() {
100        let payoff = ForwardStartPayoff {
101            put_or_call: PutOrCall::Call,
102            exercise_style: ContractStyle::European,
103            strike_fraction: 1.0,
104            start_fraction: 0.5,
105        };
106        // 4-step path: fixing at step index 1 (time 0.5T), terminal 120
107        let path = [100.0, 90.0, 110.0, 120.0];
108        assert!((payoff.path_payoff(&path, 0.0) - 30.0).abs() < 1e-12); // 120 - 90
109    }
110}
rustyqlib/equity/forward_start_option.rs

rustyqlib/equity/
forward_start_option.rs
