Nth-to-default

use chrono::NaiveDate;
use helixio_docs_sheets::{SOFR_CLOSE_DATE, USD_SOFR_CLOSE};
use helixrs::{
    AnyInstrument, CollateralSpec, CreditCurveId, CreditDefaultSwap, Currency, DayCountFraction,
    FlatHazard, MarketContext, NthToDefaultSwap, QuoteSheet, Survival, cds_standard,
};

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")
}

const NAMES: [(&str, f64); 3] = [("ACME", 0.020), ("BETA", 0.015), ("GAMMA", 0.010)];

fn main() -> Outcome<()> {
    let close = date(SOFR_CLOSE_DATE);
    let usd: Currency = "USD".parse()?;
    let template = cds_standard();
    // A bare name reads on the template's standard tier and clause.
    let identity = |name: &str| -> Outcome<CreditCurveId> { Ok(template.reference(name)?.in_currency(usd)) };

    // Each name's survival curve under its identity, and the basket's correlation
    // under a key the contract reads, so it carries a risk row of its own.
    let sheet = QuoteSheet::from_rows(USD_SOFR_CLOSE.iter().copied())?;
    let mut market = MarketContext::as_of(close).with_recipe_quotes(&CollateralSpec::Currency(usd), &sheet)?;
    for (name, hazard) in NAMES {
        market = market.with_credit_curve(
            identity(name)?,
            Survival::FlatHazard(FlatHazard::new(close, hazard, DayCountFraction::Act365Fixed)?),
            Some(0.4),
        );
    }
    let market = market.with_basket_correlation("TRIO", 0.30)?;
    let mut singles = Vec::new();
    for (name, _) in NAMES {
        let cds = CreditDefaultSwap::standard(&template, close, name, usd, 5, 1.0, 0.01, true);
        singles.push(AnyInstrument::Cds(cds).par_spread(&market)?);
    }
    for ((name, _), spread) in NAMES.iter().zip(&singles) {
        println!("{name:<6} single  {spread:.6}");
    }

    let basket = |n: usize| -> Outcome<f64> {
        let entities = NAMES.iter().map(|(name, _)| identity(name)).collect::<Outcome<Vec<_>>>()?;
        let swap = NthToDefaultSwap::standard(&template, close, entities, n, usd, 5, 10_000_000.0, 0.0300, 0.0, true)?
            .on_market_correlation("TRIO");
        Ok(AnyInstrument::NthToDefault(Box::new(swap)).par_spread(&market)?)
    };
    let first = basket(1)?;
    let second = basket(2)?;
    println!("first to default   {first:.6}");
    println!("second to default  {second:.6}");

    Ok(())
}

import helixio as hlx
from desk_sheets import SOFR_CLOSE_DATE, USD_SOFR_CLOSE

NAMES = {"ACME": 0.020, "BETA": 0.015, "GAMMA": 0.010}

# Each name's survival curve under its identity, and the basket's correlation
# under a key the contract reads, so it carries a risk row of its own.
market = hlx.MarketContext(SOFR_CLOSE_DATE).with_recipe_quotes("USD", USD_SOFR_CLOSE)
for name, hazard in NAMES.items():
    market = market.with_credit_curve(
        f"{name}/SeniorUnSec/XR14/USD",
        hlx.curves.SurvivalCurve.flat_hazard(SOFR_CLOSE_DATE, hazard),
        recovery=0.4,
    )
market = market.with_basket_correlation("TRIO", 0.30)
singles = [
    hlx.products.credit_default_swap(SOFR_CLOSE_DATE, name, "USD", 5, notional=1.0, coupon=0.01).par_spread(market)
    for name in NAMES
]
for name, spread in zip(NAMES, singles):
    print(f"{name:<6} single  {spread:.6f}")

def basket(n):
    return hlx.products.nth_to_default_swap(
        SOFR_CLOSE_DATE, list(NAMES), n, "USD", 5,
        notional=10_000_000.0, spread=0.0300, correlation_key="TRIO",
    )

first = basket(1).par_spread(market)
second = basket(2).par_spread(market)
print(f"first to default   {first:.6f}")
print(f"second to default  {second:.6f}")