Hull-White calibration

use chrono::NaiveDate;
use helixio_docs_sheets::{SOFR_CLOSE_DATE, USD_SOFR_CLOSE};
use helixrs::{
    CollateralSpec, MarketContext, QuoteSheet, SigmaShape, SigmaTerm, StripPoint,
    calibrate_hull_white_to_strip,
};

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

fn date((year, month, day): (i32, u32, u32)) -> NaiveDate {
    NaiveDate::from_ymd_opt(year, month, day).expect("a real calendar date")
}

fn main() -> Outcome<()> {
    let close = date(SOFR_CLOSE_DATE);
    let end = date((2031, 10, 1));
    let mean_reversion = 0.03;
    let usd = CollateralSpec::Currency("USD".parse()?);

    // The curve from the sheet, and one ATM normal vol per strip point, each pinned
    // under the label the fit reads.
    let strip: Vec<StripPoint> = [1, 2, 3, 4]
        .iter()
        .map(|years| StripPoint { expiry: date((2026 + years, 10, 1)), end })
        .collect();
    let quotes = [0.0102, 0.0099, 0.0097, 0.0094];
    let sheet = QuoteSheet::from_rows(USD_SOFR_CLOSE.iter().copied())?;
    let mut market = MarketContext::as_of(close).with_recipe_quotes(&usd, &sheet)?;
    for (point, vol) in strip.iter().zip(quotes) {
        market = market.with_flat_swaption_vol("USD".parse()?, point.expiry, point.end, vol);
        println!("{} into {}  normal vol {vol:.4}", point.expiry, point.end);
    }

    // One σ for four quotes: the best fit, not an exact one.
    let flat = calibrate_hull_white_to_strip(&market, "USD".parse()?, &usd, &strip, mean_reversion, SigmaShape::Flat)?;
    let sigma = flat.flat().expect("a flat fit");
    let flat_misfit = flat.fits.iter().map(|f| f.vol_misfit.abs()).fold(0.0, f64::max);
    println!("sigma        {sigma:.6}");
    println!("largest misfit {:.2} bp of normal vol", flat_misfit * 1e4);

    // One piece per expiry: as many unknowns as quotes, so every quote is matched.
    let piecewise = calibrate_hull_white_to_strip(&market, "USD".parse()?, &usd, &strip, mean_reversion, SigmaShape::Piecewise)?;
    let SigmaTerm::Pieces { values, .. } = &piecewise.sigma else {
        panic!("a piecewise fit has pieces")
    };
    for (piece_end, sigma) in piecewise.piece_ends.iter().zip(values) {
        println!("piece to {piece_end}  sigma {sigma:.6}");
    }
    let piece_misfit = piecewise.fits.iter().map(|f| f.vol_misfit.abs()).fold(0.0, f64::max);
    println!("largest misfit {:.2} bp of normal vol", piece_misfit * 1e4);

    Ok(())
}

import datetime as dt

import helixio as hlx
from desk_sheets import SOFR_CLOSE_DATE, USD_SOFR_CLOSE

calibration = hlx.calibration
END = dt.date(2031, 10, 1)
MEAN_REVERSION = 0.03

# The curve from the sheet, and one ATM normal vol per strip point, each pinned
# under the label the fit reads.
strip = [(dt.date(2026 + years, 10, 1), END) for years in (1, 2, 3, 4)]
quotes = [0.0102, 0.0099, 0.0097, 0.0094]
market = hlx.MarketContext(SOFR_CLOSE_DATE).with_recipe_quotes("USD", USD_SOFR_CLOSE)
for (expiry, end), vol in zip(strip, quotes):
    market = market.with_flat_swaption_vol("USD", expiry, end, vol)
    print(f"{expiry} into {end}  normal vol {vol:.4f}")

# One σ for four quotes: the best fit, not an exact one.
flat = calibration.hull_white_strip(market, "USD", strip, MEAN_REVERSION, shape="flat")
flat_misfit = max(abs(m) for m in flat.fits().to_dict()["vol_misfit"])
print(f"sigma        {flat.sigma():.6f}")
print(f"largest misfit {flat_misfit * 1e4:.2f} bp of normal vol")

# One piece per expiry: as many unknowns as quotes, so every quote is matched.
piecewise = calibration.hull_white_strip(market, "USD", strip, MEAN_REVERSION, shape="piecewise")
pieces = piecewise.sigma().to_dict()
for end, sigma in zip(pieces["end"], pieces["sigma"]):
    print(f"piece to {end}  sigma {sigma:.6f}")
piece_misfit = max(abs(m) for m in piecewise.fits().to_dict()["vol_misfit"])
print(f"largest misfit {piece_misfit * 1e4:.2f} bp of normal vol")