Bermudan swaptions

use chrono::NaiveDate;
use helixio_docs_sheets::{SOFR_CLOSE_DATE, USD_SOFR_CLOSE};
use helixrs::{
    AnyInstrument, BermudanSwaption, CollateralSpec, EuropeanSwaption, MarketContext,
    OvernightIndexedSwap, QuoteSheet, Side, SwaptionEngine, SwaptionKind, SwaptionUnderlying,
    Termination, template,
};

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 underlying(close: NaiveDate, kind: SwaptionKind) -> Outcome<OvernightIndexedSwap> {
    let side = if kind == SwaptionKind::Payer {
        Side::Payer
    } else {
        Side::Receiver
    };
    let AnyInstrument::Ois(swap) = template("USD-SOFR-OIS")?
        .swap(close)?
        .with_maturity("1Y5Y".parse::<Termination>()?)?
        .with_notional(10_000_000.0)
        .with_fixed_rate(0.0480)
        .with_side(side)
        .build()?
    else {
        unreachable!("a SOFR swap is an overnight indexed swap")
    };
    Ok(swap)
}

fn bermudan(close: NaiveDate, dates: &[NaiveDate], kind: SwaptionKind) -> Outcome<AnyInstrument> {
    let swap = SwaptionUnderlying::Ois(underlying(close, kind)?);
    let option = BermudanSwaption::new(swap, dates.to_vec(), 0.0480, kind)?;
    Ok(AnyInstrument::BermudanSwaption(Box::new(option)))
}

fn main() -> Outcome<()> {
    let close = date(SOFR_CLOSE_DATE);
    let market = MarketContext::as_of(close)
        .with_recipe_quotes(
            &CollateralSpec::Currency("USD".parse()?),
            &QuoteSheet::from_rows(USD_SOFR_CLOSE.iter().copied())?,
        )?
        .with_hull_white("USD".parse()?, 0.03, 0.01);
    let (first, second, third) = (
        date((2027, 10, 5)),
        date((2028, 10, 5)),
        date((2029, 10, 5)),
    );
    let value = |dates: &[NaiveDate], kind: SwaptionKind| -> Outcome<f64> {
        Ok(bermudan(close, dates, kind)?.npv(&market)?)
    };

    // One date, two dates, three: each added right can only add value.
    let one = value(&[first], SwaptionKind::Payer)?;
    let two = value(&[first, second], SwaptionKind::Payer)?;
    let three = value(&[first, second, third], SwaptionKind::Payer)?;
    println!("one date      {one:.2}");
    println!("two dates     {two:.2}");
    println!("three dates   {three:.2}");

    // The same holds for the right to receive fixed.
    let r_one = value(&[first], SwaptionKind::Receiver)?;
    let r_three = value(&[first, second, third], SwaptionKind::Receiver)?;
    println!("receiver, one date     {r_one:.2}");
    println!("receiver, three dates  {r_three:.2}");

    // With one date the right to pay less the right to receive is the swap itself.
    // The Hull-White European is exact; the lattice is a discretisation of the same
    // model, so its parity holds to within its grid.
    let swap = AnyInstrument::Ois(underlying(close, SwaptionKind::Payer)?).npv(&market)?;
    let european = |kind: SwaptionKind| -> Outcome<f64> {
        let swap = SwaptionUnderlying::Ois(underlying(close, kind)?);
        let option = EuropeanSwaption::new(swap, first, 0.0480, kind)?
            .with_engine(SwaptionEngine::HullWhite);
        Ok(AnyInstrument::EuropeanSwaption(Box::new(option)).npv(&market)?)
    };
    let european_parity = european(SwaptionKind::Payer)? - european(SwaptionKind::Receiver)?;
    let lattice_parity = one - r_one;
    println!("forward swap           {swap:.2}");
    println!("european pay - rec     {european_parity:.2}");
    println!("one-date pay - rec     {lattice_parity:.2}");

    Ok(())
}

import datetime as dt

import helixio as hlx
from desk_sheets import SOFR_CLOSE_DATE, USD_SOFR_CLOSE

market = (
    hlx.MarketContext(SOFR_CLOSE_DATE)
    .with_recipe_quotes("USD", USD_SOFR_CLOSE)
    .with_hull_white("USD", 0.03, 0.01)
)
sofr = hlx.templates.get("USD-SOFR-OIS")
FIRST, SECOND, THIRD = dt.date(2027, 10, 5), dt.date(2028, 10, 5), dt.date(2029, 10, 5)

def underlying(side):
    return sofr.swap(SOFR_CLOSE_DATE).with_maturity("1Y5Y").with_notional(10_000_000.0)\
        .with_fixed_rate(0.0480).with_side(side).build()

def bermudan(dates, kind="payer"):
    side = "payer" if kind == "payer" else "receiver"
    return hlx.products.bermudan_swaption(underlying(side), dates, strike=0.0480, kind=kind)

# One date, two dates, three: each added right can only add value.
one = bermudan([FIRST]).npv(market)
two = bermudan([FIRST, SECOND]).npv(market)
three = bermudan([FIRST, SECOND, THIRD]).npv(market)
print(f"one date      {one:.2f}")
print(f"two dates     {two:.2f}")
print(f"three dates   {three:.2f}")

# The same holds for the right to receive fixed.
r_one = bermudan([FIRST], "receiver").npv(market)
r_three = bermudan([FIRST, SECOND, THIRD], "receiver").npv(market)
print(f"receiver, one date     {r_one:.2f}")
print(f"receiver, three dates  {r_three:.2f}")

# With one date the right to pay less the right to receive is the swap itself.
# The Hull-White European is exact; the lattice is a discretisation of the same
# model, so its parity holds to within its grid.
swap = underlying("payer").npv(market)

def european(kind):
    side = "payer" if kind == "payer" else "receiver"
    return hlx.products.european_swaption(
        underlying(side), FIRST, strike=0.0480, kind=kind, engine="hull_white"
    ).npv(market)

european_parity = european("payer") - european("receiver")
lattice_parity = one - r_one
print(f"forward swap           {swap:.2f}")
print(f"european pay - rec     {european_parity:.2f}")
print(f"one-date pay - rec     {lattice_parity:.2f}")