Interest rate swap

use chrono::NaiveDate;
use helixio_docs_sheets::{EUR_CLOSE, SOFR_CLOSE_DATE, Sheet};
use helixrs::{
    AnyInstrument, AnyTemplate, CollateralSpec, MarketContext, QuoteSheet, Side,
    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 quote(rows: Sheet, template: &str, tenor: &str) -> f64 {
    let (_, _, quote) = rows
        .iter()
        .find(|(t, l, _)| *t == template && *l == tenor)
        .expect("quoted");
    *quote
}

fn swap(irs: &AnyTemplate, close: NaiveDate, rate: f64, side: Side) -> Outcome<AnyInstrument> {
    Ok(irs
        .swap(close)?
        .with_maturity("5Y".parse::<Termination>()?)?
        .with_notional(10_000_000.0)
        .with_fixed_rate(rate)
        .with_side(side)
        .build()?)
}

fn main() -> Outcome<()> {
    let close = date(SOFR_CLOSE_DATE);
    let market = MarketContext::as_of(close).with_recipe_quotes(
        &CollateralSpec::Currency("EUR".parse()?),
        &QuoteSheet::from_rows(EUR_CLOSE.iter().copied())?,
    )?;
    let irs = template("EUR-EURIBOR-3M-IRS")?;

    // Receive 2.30% fixed for five years against EURIBOR 3M.
    let receiver = swap(&irs, close, 0.0230, Side::Receiver)?;
    let npv = receiver.npv(&market)?;
    let par = receiver.par_rate(&market)?;
    println!("product     {}", receiver.product_name());
    println!("npv         {npv:.2}");
    println!("par rate    {par:.8}");

    // Paying fixed is the same two legs the other way round.
    let payer = swap(&irs, close, 0.0230, Side::Payer)?.npv(&market)?;
    println!("payer npv   {payer:.2}");

    // Value is linear in the fixed rate: the slope is the annuity, so moving the
    // rate by one basis point moves the value by the same amount at every rate.
    let value =
        |rate: f64| -> Outcome<f64> { Ok(swap(&irs, close, rate, Side::Receiver)?.npv(&market)?) };
    let step_low = value(0.0231)? - value(0.0230)?;
    println!("value of 1bp of fixed rate  {step_low:.2}");

    // Struck at par, the swap is worth nothing on the market it was struck on.
    let fair = irs
        .swap(close)?
        .with_maturity("5Y".parse::<Termination>()?)?
        .with_notional(10_000_000.0)
        .at_par(&market)?;
    println!("struck at   {:.8}", fair.par_rate(&market)?);

    Ok(())
}

import helixio as hlx
from desk_sheets import EUR_CLOSE, SOFR_CLOSE_DATE

market = hlx.MarketContext(SOFR_CLOSE_DATE).with_recipe_quotes("EUR", EUR_CLOSE)
irs = hlx.templates.get("EUR-EURIBOR-3M-IRS")

def swap(rate, side="receiver"):
    return (
        irs.swap(SOFR_CLOSE_DATE)
        .with_maturity("5Y")
        .with_notional(10_000_000.0)
        .with_fixed_rate(rate)
        .with_side(side)
        .build()
    )

# Receive 2.30% fixed for five years against EURIBOR 3M.
receiver = swap(0.0230)
npv = receiver.npv(market)
par = receiver.par_rate(market)
print(f"product     {receiver.product()}")
print(f"npv         {npv:.2f}")
print(f"par rate    {par:.8f}")

# Paying fixed is the same two legs the other way round.
payer = swap(0.0230, "payer").npv(market)
print(f"payer npv   {payer:.2f}")

# Value is linear in the fixed rate: the slope is the annuity, so moving the
# rate by one basis point moves the value by the same amount at every rate.
step_low = swap(0.0231).npv(market) - swap(0.0230).npv(market)
print(f"value of 1bp of fixed rate  {step_low:.2f}")

# Struck at par, the swap is worth nothing on the market it was struck on.
fair = irs.swap(SOFR_CLOSE_DATE).with_maturity("5Y").with_notional(10_000_000.0).at_par(market)
print(f"struck at   {fair.par_rate(market):.8f}")