surface-lib 0.1.0

High-performance Rust library for volatility surface calibration and option pricing (SVI, linear IV, temporal interpolation).
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

use surface_lib::{build_linear_iv_from_market_data, LinearIvConfig, MarketDataRow};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Linear IV Interpolation Demo");
    println!("============================");

    // Create sample market data for a BTC option chain
    let forward = 100000.0; // $100k BTC
    let tte = 30.0 / 365.0; // 30 days to expiration

    let market_data = vec![
        MarketDataRow {
            option_type: "put".to_string(),
            strike_price: 85000.0,
            underlying_price: forward,
            years_to_exp: tte,
            market_iv: 0.65,
            vega: 10.0,
            expiration: 0,
        },
        MarketDataRow {
            option_type: "put".to_string(),
            strike_price: 90000.0,
            underlying_price: forward,
            years_to_exp: tte,
            market_iv: 0.55,
            vega: 15.0,
            expiration: 0,
        },
        MarketDataRow {
            option_type: "put".to_string(),
            strike_price: 95000.0,
            underlying_price: forward,
            years_to_exp: tte,
            market_iv: 0.48,
            vega: 20.0,
            expiration: 0,
        },
        MarketDataRow {
            option_type: "call".to_string(),
            strike_price: 100000.0,
            underlying_price: forward,
            years_to_exp: tte,
            market_iv: 0.45,
            vega: 25.0,
            expiration: 0,
        },
        MarketDataRow {
            option_type: "call".to_string(),
            strike_price: 105000.0,
            underlying_price: forward,
            years_to_exp: tte,
            market_iv: 0.47,
            vega: 20.0,
            expiration: 0,
        },
        MarketDataRow {
            option_type: "call".to_string(),
            strike_price: 110000.0,
            underlying_price: forward,
            years_to_exp: tte,
            market_iv: 0.52,
            vega: 15.0,
            expiration: 0,
        },
        MarketDataRow {
            option_type: "call".to_string(),
            strike_price: 115000.0,
            underlying_price: forward,
            years_to_exp: tte,
            market_iv: 0.58,
            vega: 10.0,
            expiration: 0,
        },
    ];

    let config = LinearIvConfig::default();

    println!("Market data:");
    for (i, point) in market_data.iter().enumerate() {
        println!(
            "  {}. Strike: ${}, IV: {:.1}%, Type: {}",
            i + 1,
            point.strike_price,
            point.market_iv * 100.0,
            point.option_type
        );
    }
    println!("Forward: ${:.0}", forward);
    println!("Time to expiration: {:.0} days", tte * 365.0);
    println!();

    // Perform linear IV interpolation (uses forward and tte from market data)
    let result = build_linear_iv_from_market_data(&market_data, &config)?;

    println!("Results:");
    println!("--------");
    println!("ATM IV: {:.2}%", result.atm_iv * 100.0);
    println!();

    println!("Delta IVs:");
    for delta_iv in &result.delta_ivs {
        println!(
            "  {}δ: {:.2}%",
            if delta_iv.delta > 0.0 {
                format!("+{:.0}", delta_iv.delta * 100.0)
            } else {
                format!("{:.0}", delta_iv.delta * 100.0)
            },
            delta_iv.iv * 100.0
        );
    }
    println!();

    if let Some(rr) = result.rr_25 {
        println!("25δ Risk Reversal: {:.2}%", rr * 100.0);
    }

    if let Some(bf) = result.bf_25 {
        println!("25δ Butterfly: {:.2}%", bf * 100.0);
    }

    println!();
    println!("Demo completed successfully!");

    Ok(())
}