Pin a curve node past the last quote

use chrono::NaiveDate;
use helixrs::{
    AnyInstrument, CollateralSpec, CurvePin, CurveReading, FixingStore, FxRates, Interpolation,
    MarketContext, Period, Rung, 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((2026, 10, 1));
    let far = date((2066, 10, 1));
    let usd = CollateralSpec::Currency("USD".parse()?);

    // Step 1: one par rung per swap quote, here five SOFR swaps out to thirty years.
    let tenors = ["1Y", "2Y", "5Y", "10Y", "30Y"].iter().map(|t| t.parse::<Period>()).collect::<Result<Vec<_>, _>>()?;
    let rates = [0.0441, 0.0452, 0.0468, 0.0481, 0.0476];
    let rungs = par_rungs("USD-SOFR-OIS", close, &tenors, &rates, 1.0)?;

    // Step 2: a priced rung on the curve's own 40-year zero rate, worth the 4.60%
    // you want the curve to read there.
    let pin = AnyInstrument::CurvePin(CurvePin::new("USD".parse()?, far, CurveReading::ZeroRate));
    let mut with_pin = rungs.clone();
    with_pin.push(Rung::priced(far, pin, 0.0460, 1.0));

    // Step 3: solve the swaps and the pin together, and file the curve.
    let (fixings, fx) = (FixingStore::new(), FxRates::default());
    let solved = calibrate(close, &with_pin, &fixings, &fx, Tolerance::default(), Interpolation::LogLinear)?;
    let parameters = solved.curve_value().parameter_count();
    let market = MarketContext::as_of(close)
        .with_discount(usd, solved.clone())
        .with_projection("USD-SOFR", solved);

    // Step 4: read the curve at the last swap and at the pin, and price the swaps back.
    let (curve, _) = market.curve(&"discount(USD)".parse()?).expect("the USD curve");
    let view = curve.view::<f64>();
    println!("pillars  {parameters}");
    let last = rungs[rungs.len() - 1].pillar;
    println!("zero rate at {last}  {:.6}", view.zero_rate(last)?);
    println!("zero rate at {far}  {:.6}", view.zero_rate(far)?);
    let mut worst: f64 = 0.0;
    for rung in &rungs {
        worst = worst.max(rung.instrument.npv(&market)?.abs());
    }
    println!("largest swap value  {worst:.2}");

    Ok(())
}

import datetime as dt

import helixio as hlx

CLOSE = dt.date(2026, 10, 1)
FAR = dt.date(2066, 10, 1)
calibration = hlx.calibration

# Step 1: one par rung per swap quote, here five SOFR swaps out to thirty years.
tenors = ["1Y", "2Y", "5Y", "10Y", "30Y"]
rates = [0.0441, 0.0452, 0.0468, 0.0481, 0.0476]
rungs = calibration.par_rungs("USD-SOFR-OIS", CLOSE, list(zip(tenors, rates)))

# Step 2: a priced rung on the curve's own 40-year zero rate, worth the 4.60%
# you want the curve to read there.
pin = calibration.Rung.priced(FAR, hlx.products.curve_pin("USD", FAR, "zero_rate"), 0.0460, 1.0)

# Step 3: solve the swaps and the pin together, and file the curve.
solved = calibration.curve(CLOSE, list(rungs) + [pin])
market = hlx.MarketContext(CLOSE).with_discount("USD", solved.curve()).with_projection("USD-SOFR", solved.curve())

# Step 4: read the curve at the last swap and at the pin, and price the swaps back.
curve = market.curve("discount(USD)")
print(f"pillars  {solved.curve().parameter_count()}")
print(f"zero rate at {rungs[-1].pillar()}  {curve.zero_rate(rungs[-1].pillar()):.6f}")
print(f"zero rate at {FAR}  {curve.zero_rate(FAR):.6f}")
worst = max(abs(rung.instrument().npv(market)) for rung in rungs)
print(f"largest swap value  {worst:.2f}")