Discount curves

use chrono::NaiveDate;
use helixio_docs_sheets::SOFR_CLOSE_DATE;
use helixrs::{
    CollateralSpec, Curve, DayCountFraction, MarketContext, PiecewiseDiscount, Termination, YieldCurve,
    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 main() -> Outcome<()> {
    let reference = date(SOFR_CLOSE_DATE);

    // Four dated discount factors. At a pillar the curve returns its factor
    // exactly; between pillars it interpolates.
    let pillars = [
        (date((2027, 10, 1)), 0.9580),
        (date((2028, 10, 2)), 0.9150),
        (date((2031, 10, 1)), 0.7920),
        (date((2036, 10, 1)), 0.6180),
    ];
    let piecewise = PiecewiseDiscount::from_discount_factors(reference, &pillars)?;
    let scheme = piecewise.interpolation().code();
    let curve = Curve::Piecewise(piecewise);
    let view = curve.view::<f64>();
    println!("parameters     {}", curve.parameter_count());
    println!("interpolation  {scheme}");
    println!("at a pillar    {:.10}", view.discount(pillars[2].0)?);
    println!("between        {:.10}", view.discount(date((2030, 4, 1)))?);

    // Past the last pillar the curve holds its last segment's forward, so the
    // factor decays from the last pillar at that one rate.
    let (last, previous) = (pillars[3].0, pillars[2].0);
    let forward = view.forward_rate(previous, last)?;
    let beyond = date((2041, 10, 1));
    let expected = pillars[3].1 * (-forward * (beyond - last).num_days() as f64 / 365.0).exp();
    println!("last forward   {forward:.10}");
    println!("factor 2041    {:.10}", view.discount(beyond)?);
    println!("by the forward {expected:.10}");

    // A flat curve is one continuously compounded zero rate on ACT/365: the factor
    // to a date is exp(-r t).
    let flat = Curve::flat(reference, 0.04, DayCountFraction::Act365Fixed)?;
    let five = date((2031, 10, 1));
    let flat_view = flat.view::<f64>();
    println!("flat factor 5Y {:.10}", flat_view.discount(five)?);

    // One curve that discounts dollars and projects SOFR prices a SOFR swap. A
    // swap struck at the curve's par rate is worth nothing on it.
    let market = MarketContext::as_of(reference)
        .with_discount(CollateralSpec::Currency("USD".parse()?), curve.clone())
        .with_projection("USD-SOFR", curve.clone());
    let draft = template("USD-SOFR-OIS")?
        .swap(reference)?
        .with_maturity("5Y".parse::<Termination>()?)?
        .with_notional(10_000_000.0);
    let fair = draft.at_par(&market)?;
    let par = fair.par_rate(&market)?;
    println!("5Y par rate    {par:.8}");
    println!("npv at par     {:.2}", fair.npv(&market)?.abs());

    Ok(())
}

import datetime as dt
import math

import helixio as hlx
from desk_sheets import SOFR_CLOSE_DATE

REFERENCE = SOFR_CLOSE_DATE

# Four dated discount factors. At a pillar the curve returns its factor
# exactly; between pillars it interpolates.
PILLARS = [
    (dt.date(2027, 10, 1), 0.9580),
    (dt.date(2028, 10, 2), 0.9150),
    (dt.date(2031, 10, 1), 0.7920),
    (dt.date(2036, 10, 1), 0.6180),
]
curve = hlx.curves.DiscountCurve(REFERENCE, PILLARS)
print(f"parameters     {curve.parameter_count()}")
print(f"interpolation  {curve.interpolation()}")
print(f"at a pillar    {curve.discount(PILLARS[2][0]):.10f}")
print(f"between        {curve.discount(dt.date(2030, 4, 1)):.10f}")

# Past the last pillar the curve holds its last segment's forward, so the
# factor decays from the last pillar at that one rate.
last, previous = PILLARS[-1][0], PILLARS[-2][0]
forward = curve.forward_rate(previous, last)
beyond = dt.date(2041, 10, 1)
expected = PILLARS[-1][1] * math.exp(-forward * (beyond - last).days / 365.0)
print(f"last forward   {forward:.10f}")
print(f"factor 2041    {curve.discount(beyond):.10f}")
print(f"by the forward {expected:.10f}")

# A flat curve is one continuously compounded zero rate on ACT/365: the factor
# to a date is exp(-r t).
flat = hlx.curves.DiscountCurve.flat(REFERENCE, 0.04)
five = dt.date(2031, 10, 1)
print(f"flat factor 5Y {flat.discount(five):.10f}")

# One curve that discounts dollars and projects SOFR prices a SOFR swap. A
# swap struck at the curve's par rate is worth nothing on it.
market = (
    hlx.MarketContext(REFERENCE)
    .with_discount("USD", curve)
    .with_projection("USD-SOFR", curve)
)
draft = hlx.templates.get("USD-SOFR-OIS").swap(REFERENCE).with_maturity("5Y").with_notional(10_000_000.0)
fair = draft.at_par(market)
par = fair.par_rate(market)
print(f"5Y par rate    {par:.8f}")
print(f"npv at par     {abs(fair.npv(market)):.2f}")