Floating-rate note

use chrono::NaiveDate;
use helixio_docs_sheets::EUR_CLOSE_MARCH;
use helixrs::{
    AnyIndex, AnyInstrument, CollateralSpec, Column, Currency, Curve, DayCountFraction, FixingKey,
    FixingStore, FlatSpread, FloatingRateNote, IborIndex, MarketContext, PricingRiskFactors,
    QuoteSheet, Records, YieldCurve, discount_margin, index, instrument_cashflow_records,
    spread_duration,
};

fn date(year: i32, month: u32, day: u32) -> NaiveDate {
    NaiveDate::from_ymd_opt(year, month, day).expect("a real calendar date")
}

const INDEX: &str = "EUR-EURIBOR-3M";
const MARGIN: f64 = 0.0050;
const FIXING: f64 = 0.0205;

fn euribor() -> IborIndex {
    match index(INDEX) {
        Some(AnyIndex::Ibor(index)) => index,
        _ => panic!("a registered term index"),
    }
}

fn note_with(security_spread: Option<&str>) -> AnyInstrument {
    let mut note = FloatingRateNote::new(
        &euribor(),
        date(2025, 12, 17),
        date(2030, 12, 17),
        MARGIN,
        100.0,
    );
    if let Some(key) = security_spread {
        note = note.spread_by(key);
    }
    AnyInstrument::FloatingRateNote(Box::new(note))
}

fn npv(note: &AnyInstrument, market: &MarketContext) -> f64 {
    let lifted = market.lift::<f64>();
    let view = market.view(&lifted).expect("a market that binds");
    view.npv(note).expect("a priced note")
}

fn numbers(records: &Records, name: &str) -> Vec<f64> {
    match records.iter().find(|(n, _)| *n == name) {
        Some((_, Column::Number(values))) => values.clone(),
        _ => panic!("a number column"),
    }
}

fn dates(records: &Records, name: &str) -> Vec<Option<NaiveDate>> {
    match records.iter().find(|(n, _)| *n == name) {
        Some((_, Column::Date(values))) => values.clone(),
        _ => panic!("a date column"),
    }
}

fn texts(records: &Records, name: &str) -> Vec<String> {
    match records.iter().find(|(n, _)| *n == name) {
        Some((_, Column::Text(values))) => values.clone(),
        _ => panic!("a text column"),
    }
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let valuation = date(2026, 3, 2);
    let maturity = date(2030, 12, 17);
    let eur = Currency::new("EUR").expect("a registered currency");
    let fixings =
        FixingStore::from_observations_checked(&[(FixingKey::from(INDEX), date(2025, 12, 15), FIXING)])?;
    let sheet = QuoteSheet::from_rows(EUR_CLOSE_MARCH.iter().copied())?;
    let market = MarketContext::as_of(valuation)
        .with_fixings(fixings)
        .with_recipe_quotes(&CollateralSpec::Currency(eur), &sheet)?;
    let note = note_with(None);
    let lifted = market.lift::<f64>();
    let view = market.view(&lifted)?;
    let AnyInstrument::FloatingRateNote(frn) = &note else {
        unreachable!("built as a note")
    };
    let resolved = view.resolve(&frn.risk_factors().expect("a note declares its curves"))?;

    // The running coupon fixed two business days before it started. Its rate
    // is the published fixing plus the margin, whatever the curves now say.
    let rows = instrument_cashflow_records(&note, &resolved)?;
    let (rate, amount, pv) = (numbers(&rows, "rate"), numbers(&rows, "amount"), numbers(&rows, "pv"));
    let accrual_start = dates(&rows, "accrual_start");
    let fixed_rate = rate[0];
    let start = accrual_start[0].expect("a coupon accrues");
    let accrued = fixed_rate * DayCountFraction::Act360.year_fraction(start, valuation) * 100.0;
    println!(
        "period        {} to {}",
        start,
        dates(&rows, "accrual_end")[0].expect("a coupon accrues")
    );
    println!("fixed on      {}", dates(&rows, "fixing_date")[0].expect("a fixed coupon"));
    println!("coupon rate   {:.4}%", fixed_rate * 100.0);
    println!("coupon        {:.6}", amount[0]);
    println!("accrued now   {accrued:.6}");

    // Every later coupon projects the index's forward over its own window, adds
    // the margin, and is discounted on the other curve.
    let value = npv(&note, &market);
    for k in 1..4 {
        println!(
            "{}  rate {:.6}%  pv {:.6}",
            accrual_start[k].expect("a coupon accrues"),
            rate[k] * 100.0,
            pv[k]
        );
    }
    println!("coupons       {}, then the face", amount.len() - 1);
    println!("value         {value:.6}");

    // The note trades at 99.20 clean. The discount margin is the flat spread on
    // the discount curve that reprices that quote; the simple margin skips the
    // curves and spreads the pull to par over the remaining years.
    let quoted_clean = 99.20;
    let dm = discount_margin(&note, &market, quoted_clean)?;
    let sm = frn.simple_margin(quoted_clean, valuation);
    println!("quoted clean     {quoted_clean:.2}");
    println!("discount margin  {:.4} bp", dm * 10_000.0);
    println!("simple margin    {:.4} bp", sm * 10_000.0);

    // A floater's rate risk resets every quarter; its spread risk runs to
    // maturity.
    let sd = spread_duration(&note, &market)?;
    println!("spread duration     {sd:.6}");

    Ok(())
}

import datetime as dt
import helixio as hlx
from desk_sheets import EUR_CLOSE_MARCH

VALUATION = dt.date(2026, 3, 2)
INDEX = "EUR-EURIBOR-3M"
MARGIN = 0.0050
MATURITY = dt.date(2030, 12, 17)
FIXING = 0.0205
ACT360 = hlx.dates.DayCountFraction.Act360

# A EUR close on 2 March 2026: €STR swaps discount, and EURIBOR 3M swaps project.

def note_with(security_spread=None):
    return hlx.products.floating_rate_note(
        INDEX, dt.date(2025, 12, 17), MATURITY, margin=MARGIN, face=100.0,
        security_spread=security_spread,
    )

MARKET = (
    hlx.MarketContext(VALUATION)
    .with_fixings([(INDEX, dt.date(2025, 12, 15), FIXING)])
    .with_recipe_quotes("EUR", EUR_CLOSE_MARCH)
)
NOTE = note_with()

# The running coupon fixed two business days before it started. Its rate is
# the published fixing plus the margin, whatever the curves now say.
rows = NOTE.cashflow_records(MARKET).to_dict()
fixed_rate = rows["rate"][0]
accrued = fixed_rate * ACT360.year_fraction(rows["accrual_start"][0], VALUATION) * 100.0
print(f"period        {rows['accrual_start'][0]} to {rows['accrual_end'][0]}")
print(f"fixed on      {rows['fixing_date'][0]}")
print(f"coupon rate   {fixed_rate * 100:.4f}%")
print(f"coupon        {rows['amount'][0]:.6f}")
print(f"accrued now   {accrued:.6f}")

# Every later coupon projects the index's forward over its own window, adds
# the margin, and is discounted on the other curve.
value = NOTE.npv(MARKET)
for k in range(1, 4):
    print(f"{rows['accrual_start'][k]}  rate {rows['rate'][k] * 100:.6f}%  pv {rows['pv'][k]:.6f}")
print(f"coupons       {len(rows['kind']) - 1}, then the face")
print(f"value         {value:.6f}")

# The note trades at 99.20 clean. The discount margin is the flat spread on
# the discount curve that reprices that quote; the simple margin skips the
# curves and spreads the pull to par over the remaining years.
quoted_clean = 99.20
dm = hlx.bonds.discount_margin(NOTE, MARKET, quoted_clean)
sm = hlx.bonds.simple_margin(NOTE, quoted_clean, VALUATION)
print(f"quoted clean     {quoted_clean:.2f}")
print(f"discount margin  {dm * 10_000:.4f} bp")
print(f"simple margin    {sm * 10_000:.4f} bp")

# A floater's rate risk resets every quarter; its spread risk runs to maturity.
sd = hlx.bonds.spread_duration(NOTE, MARKET)
print(f"spread duration     {sd:.6f}")