Spread curves

use chrono::NaiveDate;
use helixio_docs_sheets::{SOFR_CLOSE_DATE, USD_SOFR_CLOSE};
use helixrs::{
    CollateralSpec, Curve, FlatSpread, MarketContext, PiecewiseSpread, QuoteSheet, YieldCurve,
};

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);
    let (one, five, mid) = (date((2027, 10, 1)), date((2031, 10, 1)), date((2029, 10, 1)));
    let years = |d: NaiveDate| (d - reference).num_days() as f64 / 365.0;

    // One spread for every date: 150 basis points, no pillars, no risk of its own.
    let flat = FlatSpread::new(reference, 0.0150)?;
    let flat_factor = flat.view::<f64>().discount(five)?;
    println!("pillars        {}", flat.parameters().len());
    println!("factor 5Y      {flat_factor:.10}");
    println!("exp(-s t)      {:.10}", (-0.0150 * years(five)).exp());

    // A spread of 100 basis points at one year and 200 at five, linear in time
    // between them and flat outside.
    let dated = PiecewiseSpread::new(reference, &[(one, 0.0100), (five, 0.0200)])?;
    let weight = (years(mid) - years(one)) / (years(five) - years(one));
    let spread = dated.spread_at(mid)?;
    let factor = dated.view::<f64>().discount(mid)?;
    println!("spread 3Y      {spread:.8}");
    println!("by the line    {:.8}", 0.0100 + weight * 0.0100);
    println!("factor 3Y      {factor:.10}");

    // Pinned under a security's key, the spread multiplies the factor of the curve
    // the security's currency discounts on.
    let sheet = QuoteSheet::from_rows(USD_SOFR_CLOSE.iter().copied())?;
    let market = MarketContext::as_of(reference)
        .with_recipe_quotes(&CollateralSpec::Currency("USD".parse()?), &sheet)?
        .with_security_spread("ACME-2031", Curve::PiecewiseSpread(dated.clone()));
    for (role, key) in market.contents() {
        println!("{role:<16} {key}");
    }
    // A bond naming the security discounts on this product; here it is formed by the formula.
    let (curve, _) = market.curve(&"discount(USD)".parse()?).expect("the USD curve");
    let base = curve.view::<f64>().discount(mid)?;
    println!("risky 3Y, by the formula {:.10}", base * factor);

    Ok(())
}

import datetime as dt
import math

import helixio as hlx
from desk_sheets import SOFR_CLOSE_DATE, USD_SOFR_CLOSE

REFERENCE = SOFR_CLOSE_DATE
ONE, FIVE, MID = dt.date(2027, 10, 1), dt.date(2031, 10, 1), dt.date(2029, 10, 1)

def years(d: dt.date) -> float:
    return (d - REFERENCE).days / 365.0

# One spread for every date: 150 basis points, no pillars, no risk of its own.
flat = hlx.curves.SpreadCurve.flat(REFERENCE, 0.0150)
print(f"pillars        {len(flat.pillars())}")
print(f"factor 5Y      {flat.discount(FIVE):.10f}")
print(f"exp(-s t)      {math.exp(-0.0150 * years(FIVE)):.10f}")

# A spread of 100 basis points at one year and 200 at five, linear in time
# between them and flat outside.
dated = hlx.curves.SpreadCurve(REFERENCE, [(ONE, 0.0100), (FIVE, 0.0200)])
weight = (years(MID) - years(ONE)) / (years(FIVE) - years(ONE))
print(f"spread 3Y      {dated.spread(MID):.8f}")
print(f"by the line    {0.0100 + weight * 0.0100:.8f}")
print(f"factor 3Y      {dated.discount(MID):.10f}")

# Pinned under a security's key, the spread multiplies the factor of the curve
# the security's currency discounts on.
market = (
    hlx.MarketContext(REFERENCE)
    .with_recipe_quotes("USD", USD_SOFR_CLOSE)
    .with_security_spread("ACME-2031", dated)
)
for role, key in market.contents():
    print(f"{role:<16} {key}")
# A bond naming the security discounts on this product; here it is formed by the formula.
base = market.curve("discount(USD)").discount(MID)
print(f"risky 3Y, by the formula {base * dated.discount(MID):.10f}")