Bootstrapping

use chrono::NaiveDate;
use helixio_docs_sheets::{SOFR_CLOSE_DATE, USD_SOFR_CLOSE};
use helixrs::{
    CollateralSpec, FixingStore, FxRates, Interpolation, MarketContext, Period, QuoteSheet,
    Tolerance, YieldCurve, calibrate, par_rungs,
};

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 ten_years = date((2036, 10, 1));
    let usd = CollateralSpec::Currency("USD".parse()?);
    let quotes: Vec<(&str, f64)> = USD_SOFR_CLOSE.iter().map(|(_, tenor, quote)| (*tenor, *quote)).collect();

    // The par rungs of a swap ladder: the template's swap from spot to each tenor,
    // struck at its quote and noded at its final payment.
    let tenors = quotes.iter().map(|(t, _)| t.parse::<Period>()).collect::<Result<Vec<_>, _>>()?;
    let rates: Vec<f64> = quotes.iter().map(|(_, q)| *q).collect();
    let rungs = par_rungs("USD-SOFR-OIS", close, &tenors, &rates, 1.0)?;
    println!("rungs        {}", rungs.len());
    println!("first pillar {}", rungs[0].pillar);
    println!("last pillar  {}", rungs[rungs.len() - 1].pillar);

    // The solve: one pillar per rung, each to the default tolerance.
    let (fixings, fx) = (FixingStore::new(), FxRates::default());
    let solved = calibrate(close, &rungs, &fixings, &fx, Tolerance::default(), Interpolation::LogLinear)?;
    println!("parameters   {}", solved.curve_value().parameter_count());
    println!("sweeps       {}", solved.sweeps);

    // Filed as both the USD discount curve and the SOFR projection, the curve is
    // the one the recipe constructor builds from the same sheet.
    let market = MarketContext::as_of(close)
        .with_discount(usd.clone(), solved.clone())
        .with_projection("USD-SOFR", solved.clone());
    let sheet = QuoteSheet::from_rows(USD_SOFR_CLOSE.iter().copied())?;
    let recipe = MarketContext::as_of(close).with_recipe_quotes(&usd, &sheet)?;
    let read = |m: &MarketContext| -> Outcome<f64> {
        let (curve, _) = m.curve(&"discount(USD)".parse()?).expect("the USD curve");
        Ok(curve.view::<f64>().discount(ten_years)?)
    };
    let factor = read(&market)?;
    println!("10Y discount, solved {factor:.12}");
    println!("10Y discount, recipe {:.12}", read(&recipe)?);

    // The defaults, then a looser residual tolerance, which stops each pillar a step
    // sooner. Inside the tolerance each pillar takes one polishing step, so the
    // residuals still end below 1e-12 and the curve does not move.
    let default = Tolerance::default();
    println!(
        "defaults     residual {:.0e}, step {:.0e}, iterations {}, backtracks {}, sweeps {}",
        default.residual, default.step, default.max_iterations, default.max_backtracks, default.max_sweeps
    );
    let tolerance = Tolerance { residual: 1e-6, ..Tolerance::default() };
    let loose = calibrate(close, &rungs, &fixings, &fx, tolerance, Interpolation::LogLinear)?;
    let steps: usize = solved.solves.iter().map(|s| s.iterations).sum();
    let loose_steps: usize = loose.solves.iter().map(|s| s.iterations).sum();
    println!("steps        {steps} at 1e-12, {loose_steps} at 1e-6");
    let loose_largest = loose.solves.iter().map(|s| s.residual.abs()).fold(0.0_f64, f64::max);
    println!("loose residuals below 1e-12: {}", if loose_largest < 1e-12 { "yes" } else { "no" });
    println!("10Y discount, loose  {:.12}", loose.curve_value().view::<f64>().discount(ten_years)?);

    Ok(())
}

import datetime as dt

import helixio as hlx
from desk_sheets import SOFR_CLOSE_DATE, USD_SOFR_CLOSE

calibration = hlx.calibration
TEN_YEARS = dt.date(2036, 10, 1)

# The par rungs of a swap ladder: the template's swap from spot to each tenor,
# struck at its quote and noded at its final payment.
rungs = calibration.par_rungs("USD-SOFR-OIS", SOFR_CLOSE_DATE, USD_SOFR_CLOSE["USD-SOFR-OIS"])
print(f"rungs        {len(rungs)}")
print(f"first pillar {rungs[0].pillar()}")
print(f"last pillar  {rungs[-1].pillar()}")

# The solve: one pillar per rung, each to the default tolerance.
solved = calibration.curve(SOFR_CLOSE_DATE, rungs)
print(f"parameters   {solved.curve().parameter_count()}")
print(f"sweeps       {solved.sweeps()}")

# Filed as both the USD discount curve and the SOFR projection, the curve is
# the one the recipe constructor builds from the same sheet.
market = (
    hlx.MarketContext(SOFR_CLOSE_DATE)
    .with_discount("USD", solved.curve())
    .with_projection("USD-SOFR", solved.curve())
)
recipe = hlx.MarketContext(SOFR_CLOSE_DATE).with_recipe_quotes("USD", USD_SOFR_CLOSE)
factor = market.curve("discount(USD)").discount(TEN_YEARS)
print(f"10Y discount, solved {factor:.12f}")
print(f"10Y discount, recipe {recipe.curve('discount(USD)').discount(TEN_YEARS):.12f}")

# The defaults, then a looser residual tolerance, which stops each pillar a step
# sooner. Inside the tolerance each pillar takes one polishing step, so the
# residuals still end below 1e-12 and the curve does not move.
default = calibration.Tolerance()
print(
    f"defaults     residual {default.residual():.0e}, step {default.step():.0e}, "
    f"iterations {default.max_iterations()}, backtracks {default.max_backtracks()}, "
    f"sweeps {default.max_sweeps()}"
)
loose = calibration.curve(SOFR_CLOSE_DATE, rungs, tolerance=calibration.Tolerance(residual=1e-6))
steps = solved.solves().to_dict()["iterations"]
loose_steps = loose.solves().to_dict()["iterations"]
print(f"steps        {int(sum(steps))} at 1e-12, {int(sum(loose_steps))} at 1e-6")
loose_largest = max(abs(r) for r in loose.solves().to_dict()["residual"])
print(f"loose residuals below 1e-12: {'yes' if loose_largest < 1e-12 else 'no'}")
print(f"10Y discount, loose  {loose.curve().discount(TEN_YEARS):.12f}")