Rate volatility surfaces

use chrono::NaiveDate;
use helixrs::{Currency, MarketContext, RateVolSurface, StrikeAxis, VolConvention};

type Outcome<T> = Result<T, Box<dyn std::error::Error>>;

fn main() -> Outcome<()> {
    let expiries = vec![1.0, 2.0, 5.0];
    let tenors = vec![2.0, 5.0, 10.0];
    // Normal (basis-point) vols, one row per expiry, in tenor order.
    let rows = vec![
        vec![0.0090, 0.0085, 0.0080],
        vec![0.0095, 0.0090, 0.0084],
        vec![0.0100, 0.0094, 0.0088],
    ];
    let atm = RateVolSurface::new(expiries.clone(), tenors.clone(), &rows, VolConvention::Normal)?;
    let view = atm.view::<f64>();

    // At a node the read is the quote itself. The same numbers under a
    // lognormal convention are a different surface: the convention picks the
    // pricing formula.
    let node = view.vol(2.0, 5.0);
    let lognormal =
        RateVolSurface::new(expiries.clone(), tenors.clone(), &rows, VolConvention::Lognormal)?;
    println!("expiries {:?}   tenors {:?}", atm.expiries(), atm.tenors());
    println!("2Y x 5Y node          {:6.2} bp", node * 10_000.0);
    println!("convention            {}", atm.convention().code());
    println!("same grid, relabelled {}", lognormal.convention().code());

    // Between nodes: linear in vol across tenor, then linear in total variance
    // across expiry.
    let between = view.vol(3.0, 7.0);
    println!("3Y x 7Y               {:6.2} bp", between * 10_000.0);

    // Short of the first expiry, past the last, and outside the tenor axis, the
    // read is the edge node's vol.
    let probes = [(0.25, 5.0), (10.0, 5.0), (2.0, 1.0), (2.0, 30.0), (0.25, 30.0)];
    let edges: Vec<f64> = probes.iter().map(|&(expiry, tenor)| view.vol(expiry, tenor)).collect();
    for ((expiry, tenor), vol) in probes.iter().zip(&edges) {
        println!("{expiry:5.2}Y x {tenor:4.1}Y   {:6.2} bp", vol * 10_000.0);
    }

    // A cap smile: one index tenor, absolute strikes, one row per expiry. A
    // strike is read linearly in vol, flat beyond both edges.
    let strikes = vec![0.02, 0.03, 0.04];
    let smile_rows = vec![vec![0.0110, 0.0100, 0.0105], vec![0.0105, 0.0098, 0.0102]];
    let smile =
        RateVolSurface::smile(vec![1.0, 3.0], 0.25, strikes.clone(), &smile_rows, VolConvention::Normal)?;
    let smiled = smile.view::<f64>();
    let mut smile_reads = Vec::new();
    for strike in [0.01, 0.025, 0.035, 0.06] {
        let vol = smiled.vol_at_strike(1.0, 0.25, strike)?;
        smile_reads.push((strike, vol));
        println!("1Y at {:4.2}%   {:6.2} bp", strike * 100.0, vol * 10_000.0);
    }
    let at_2y = smiled.vol_at_strike(2.0, 0.25, 0.035)?;
    println!("2Y at 3.50%   {:6.2} bp", at_2y * 10_000.0);

    // A swaption cube is quoted at spreads to the at-the-money forward. The
    // surface records its strike axis, because the numbers alone can't tell a
    // 1% strike from a 100 bp spread. Rust reads a spread with `vol_at_spread`
    // and refuses an absolute-strike read on a spread axis.
    let spreads = vec![-0.01, 0.0, 0.01];
    let cube_tenors = vec![2.0, 10.0];
    let cells = vec![
        vec![vec![0.0100, 0.0090, 0.0096], vec![0.0092, 0.0084, 0.0089]],
        vec![vec![0.0104, 0.0095, 0.0099], vec![0.0096, 0.0088, 0.0092]],
    ];
    let cube = RateVolSurface::cube(
        vec![1.0, 5.0],
        cube_tenors.clone(),
        spreads.clone(),
        &cells,
        VolConvention::Normal,
    )?
    .over_the_forward();
    let cube_view = cube.view::<f64>();
    let at_spread = cube_view.vol_at_spread(1.0, 6.0, 0.005)?;
    let wrong_axis = if cube_view.vol_at_strike(1.0, 6.0, 0.035).is_err() { "refused" } else { "read" };
    println!("strike axis                 {}", cube.strike_axis().code());
    println!("1Y x 6Y at +50 bp           {:6.2} bp", at_spread * 10_000.0);
    println!("a read the axis can't take  {wrong_axis}");

    // A currency carries a swaption surface and a cap surface side by side;
    // each product reads its own.
    let usd = Currency::new("USD")?;
    let reference = NaiveDate::from_ymd_opt(2026, 5, 21).expect("a real calendar date");
    let market = MarketContext::as_of(reference)
        .with_swaption_vols(usd, atm.clone())
        .with_cap_vols(usd, smile.clone());
    let swaption_read = market.swaption_vols(usd).expect("a pinned swaption surface").view::<f64>().vol(3.0, 7.0);
    let cap_read = market.cap_vols(usd).expect("a pinned cap surface").view::<f64>().vol_at_strike(2.0, 0.25, 0.035)?;
    println!("swaption surface, 3Y x 7Y   {:6.2} bp", swaption_read * 10_000.0);
    println!("cap surface, 2Y at 3.50%    {:6.2} bp", cap_read * 10_000.0);

    Ok(())
}

import datetime as dt

import helixio as hlx

EXPIRIES = [1.0, 2.0, 5.0]
TENORS = [2.0, 5.0, 10.0]
# Normal (basis-point) vols, one row per expiry, in tenor order.
ROWS = [
    [0.0090, 0.0085, 0.0080],
    [0.0095, 0.0090, 0.0084],
    [0.0100, 0.0094, 0.0088],
]
atm = hlx.vols.RateVolSurface(EXPIRIES, TENORS, ROWS, hlx.vols.VolConvention.Normal)

# At a node the read is the quote itself. The same numbers under a lognormal
# convention are a different surface: the convention picks the pricing formula.
node = atm.vol(2.0, 5.0)
lognormal = hlx.vols.RateVolSurface(EXPIRIES, TENORS, ROWS, "lognormal")
print(f"expiries {atm.expiries()}   tenors {atm.tenors()}")
print(f"2Y x 5Y node          {node * 10_000.0:6.2f} bp")
print(f"convention            {atm.vol_convention()}")
print(f"same grid, relabelled {lognormal.vol_convention()}")

# Between nodes: linear in vol across tenor, then linear in total variance
# across expiry.
between = atm.vol(3.0, 7.0)
print(f"3Y x 7Y               {between * 10_000.0:6.2f} bp")

# Short of the first expiry, past the last, and outside the tenor axis, the
# read is the edge node's vol.
PROBES = [(0.25, 5.0), (10.0, 5.0), (2.0, 1.0), (2.0, 30.0), (0.25, 30.0)]
edges = [atm.vol(expiry, tenor) for expiry, tenor in PROBES]
for (expiry, tenor), vol in zip(PROBES, edges):
    print(f"{expiry:5.2f}Y x {tenor:4.1f}Y   {vol * 10_000.0:6.2f} bp")

# A cap smile: one index tenor, absolute strikes, one row per expiry. A strike
# is read linearly in vol, flat beyond both edges.
STRIKES = [0.02, 0.03, 0.04]
SMILE_ROWS = [[0.0110, 0.0100, 0.0105], [0.0105, 0.0098, 0.0102]]
smile = hlx.vols.RateVolSurface.smile([1.0, 3.0], 0.25, STRIKES, SMILE_ROWS, "normal")
smile_reads = {strike: smile.vol(1.0, 0.25, strike) for strike in (0.01, 0.025, 0.035, 0.06)}
for strike, vol in smile_reads.items():
    print(f"1Y at {strike * 100.0:4.2f}%   {vol * 10_000.0:6.2f} bp")
at_2y = smile.vol(2.0, 0.25, 0.035)
print(f"2Y at 3.50%   {at_2y * 10_000.0:6.2f} bp")

# A swaption cube is quoted at spreads to the at-the-money forward. The surface
# records its strike axis, because the numbers alone can't tell a 1% strike
# from a 100 bp spread. Python reads the one strike coordinate on the axis the
# surface carries, and refuses a read that names no strike at all.
SPREADS = [-0.01, 0.0, 0.01]
CUBE_TENORS = [2.0, 10.0]
CELLS = [
    [[0.0100, 0.0090, 0.0096], [0.0092, 0.0084, 0.0089]],
    [[0.0104, 0.0095, 0.0099], [0.0096, 0.0088, 0.0092]],
]
cube = hlx.vols.RateVolSurface.cube(
    [1.0, 5.0], CUBE_TENORS, SPREADS, CELLS, "normal", hlx.vols.StrikeAxis.SpreadToAtm
)
at_spread = cube.vol(1.0, 6.0, 0.005)
try:
    cube.vol(1.0, 6.0)
    no_strike = "read"
except ValueError:
    no_strike = "refused"
print(f"strike axis                 {cube.strike_axis()}")
print(f"1Y x 6Y at +50 bp           {at_spread * 10_000.0:6.2f} bp")
print(f"a read the axis can't take  {no_strike}")

# A currency carries a swaption surface and a cap surface side by side; each
# product reads its own.
market = (
    hlx.MarketContext(dt.date(2026, 5, 21))
    .with_swaption_vols("USD", atm)
    .with_cap_vols("USD", smile)
)
swaption_read = market.swaption_vols("USD").vol(3.0, 7.0)
cap_read = market.cap_vols("USD").vol(2.0, 0.25, 0.035)
print(f"swaption surface, 3Y x 7Y   {swaption_read * 10_000.0:6.2f} bp")
print(f"cap surface, 2Y at 3.50%    {cap_read * 10_000.0:6.2f} bp")