CMS coupons

use chrono::NaiveDate;
use helixio_docs_sheets::{EUR_CLOSE, SOFR_CLOSE_DATE};
use helixrs::{
    AnyCoupon, CmsCoupon, CollateralSpec, Direction, Leg, MarketContext, OptionKind, QuoteSheet,
    RateVolSurface, SwapIndex, VolConvention, YieldCurve, cms_option, cms_rate,
    cms_spread_coupon_rate, leg_cashflow_records,
};

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 (fixing, payment, reversion) = (date((2027, 10, 1)), date((2028, 1, 5)), 0.01);

    // Curves from the sheet; swaption vols, which no recipe builds, joined with the
    // market's verb: normal vols by expiry and swap tenor, both in years.
    let swaption_vols = RateVolSurface::new(
        vec![0.5, 1.0, 2.0, 5.0],
        vec![2.0, 10.0, 20.0],
        &[
            vec![0.0070, 0.0068, 0.0066],
            vec![0.0072, 0.0070, 0.0068],
            vec![0.0075, 0.0072, 0.0070],
            vec![0.0078, 0.0074, 0.0071],
        ],
        VolConvention::Normal,
    )?;
    let sheet = QuoteSheet::from_rows(EUR_CLOSE.iter().copied())?;
    let market = MarketContext::as_of(close)
        .with_recipe_quotes(&CollateralSpec::Currency("EUR".parse()?), &sheet)?
        .with_swaption_vols("EUR".parse()?, swaption_vols);
    let ten = SwapIndex::new("EUR-EURIBOR-3M-IRS", "10Y".parse()?)?;
    let two = SwapIndex::new("EUR-EURIBOR-3M-IRS", "2Y".parse()?)?;
    let projection = ten.projection();
    let factors = ten.risk_factors(&projection);

    // The 10Y swap rate fixing on 1 October 2027, paid on 5 January 2028.
    let ten_year = market.priced(&factors, |view| cms_rate(&ten, fixing, payment, reversion, view))?;
    let (forward, cms) = (ten_year.forward, ten_year.rate);
    println!("forward swap rate  {forward:.8}");
    println!("CMS rate           {cms:.8}");

    // A CMS call and put at one strike, replicated off the same smile.
    let strike = 0.026;
    let option = |kind| {
        market.priced(&factors, |view| cms_option(&ten, fixing, payment, reversion, strike, kind, view))
    };
    let (call, put) = (option(OptionKind::Call)?, option(OptionKind::Put)?);
    println!("call  {call:.8}");
    println!("put   {put:.8}");
    println!("call less put  {:.8}", call - put);
    println!("CMS less K     {:.8}", cms - strike);

    // A 10Y-less-2Y spread coupon. With no option on it the correlation does not
    // enter, and it pays the difference of the two adjusted rates.
    let cms_2y = market.priced(&factors, |view| cms_rate(&two, fixing, payment, reversion, view))?.rate;
    let spread = market.priced(&factors, |view| {
        cms_spread_coupon_rate(&ten, &two, fixing, payment, reversion, 0.8, 1.0, 0.0, None, view)
    })?;
    println!("2Y CMS rate  {cms_2y:.8}");
    println!("10Y less 2Y  {spread:.8}");

    // The same rate as a coupon in a leg: accruing from 5 October 2027, it fixes two
    // TARGET days before, on 1 October, and its table carries the rate above.
    let coupon = CmsCoupon::on_index(
        &ten,
        date((2027, 10, 5)),
        payment,
        payment,
        10_000_000.0,
        1.0,
        0.0,
        "ACT/360".parse()?,
        reversion,
    );
    let leg = Leg::new(vec![AnyCoupon::Cms(coupon)], Direction::Receive);
    let eur = CollateralSpec::Currency("EUR".parse()?);
    let projections = leg.projections();
    let row = market.priced(&leg.risk_factors(&eur, &projections), |view| {
        Ok(leg_cashflow_records(&leg, &view.disc, view, &view.fixings, close)?)
    })?;
    let fixes = row["fixing_date"].dates().expect("dates")[0].expect("a fixing date");
    let rate = row["rate"].numbers().expect("numbers")[0];
    let npv = leg.npv_on(&market, &eur)?;
    println!("fixes on  {fixes}");
    println!("rate      {rate:.8}");
    println!("npv       {npv:.2}");

    Ok(())
}

import datetime as dt

import helixio as hlx
from desk_sheets import EUR_CLOSE, SOFR_CLOSE_DATE

INDEX, FIXING, PAYMENT, REVERSION = "EUR-EURIBOR-3M-IRS", dt.date(2027, 10, 1), dt.date(2028, 1, 5), 0.01

# Curves from the sheet; swaption vols, which no recipe builds, joined with the
# market's verb: normal vols by expiry and swap tenor, both in years.
swaption_vols = hlx.vols.RateVolSurface(
    [0.5, 1.0, 2.0, 5.0],
    [2.0, 10.0, 20.0],
    [[0.0070, 0.0068, 0.0066], [0.0072, 0.0070, 0.0068], [0.0075, 0.0072, 0.0070], [0.0078, 0.0074, 0.0071]],
    vol_convention="normal",
)
market = (
    hlx.MarketContext(SOFR_CLOSE_DATE)
    .with_recipe_quotes("EUR", EUR_CLOSE)
    .with_swaption_vols("EUR", swaption_vols)
)

# The 10Y swap rate fixing on 1 October 2027, paid on 5 January 2028.
forward, cms = hlx.rates.cms_rate(market, INDEX, "10Y", FIXING, PAYMENT, REVERSION)
print(f"forward swap rate  {forward:.8f}")
print(f"CMS rate           {cms:.8f}")

# A CMS call and put at one strike, replicated off the same smile.
STRIKE = 0.026
call = hlx.rates.cms_option(market, INDEX, "10Y", FIXING, PAYMENT, REVERSION, strike=STRIKE, kind="Call")
put = hlx.rates.cms_option(market, INDEX, "10Y", FIXING, PAYMENT, REVERSION, strike=STRIKE, kind="Put")
print(f"call  {call:.8f}")
print(f"put   {put:.8f}")
print(f"call less put  {call - put:.8f}")
print(f"CMS less K     {cms - STRIKE:.8f}")

# A 10Y-less-2Y spread coupon. With no option on it the correlation does not
# enter, and it pays the difference of the two adjusted rates.
_, cms_2y = hlx.rates.cms_rate(market, INDEX, "2Y", FIXING, PAYMENT, REVERSION)
spread = hlx.rates.cms_spread_coupon_rate(market, INDEX, "10Y", "2Y", FIXING, PAYMENT, REVERSION, correlation=0.8)
print(f"2Y CMS rate  {cms_2y:.8f}")
print(f"10Y less 2Y  {spread:.8f}")

# The same rate as a coupon in a leg: accruing from 5 October 2027, it fixes two
# TARGET days before, on 1 October, and its table carries the rate above.
coupon = hlx.legs.cms_coupon(
    INDEX, "10Y", dt.date(2027, 10, 5), PAYMENT, PAYMENT, notional=10_000_000.0, day_count="ACT/360"
)
leg = hlx.Leg([coupon], "Receive", "EUR")
row = leg.cashflow_records(market).to_dict()
npv = leg.npv(market)
print(f"fixes on  {row['fixing_date'][0]}")
print(f"rate      {row['rate'][0]:.8f}")
print(f"npv       {npv:.2f}")