Quote a bond from its yield

use chrono::NaiveDate;
use helixrs::{Currency, DayCountFraction, FixedRateBond, Frequency, PriceBasis, YieldQuoteConvention, yield_moments};

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

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. Describe the bond: a EUR 2.75% annual bond on ACT/ACT ICMA, issued on
    //    15 September 2024 and maturing on 15 September 2034.
    let bond = FixedRateBond::bullet(
        Currency::new("EUR").expect("a registered currency"),
        date(2024, 9, 15),
        date(2034, 9, 15),
        0.0275,
        Frequency::Annual,
        DayCountFraction::ActActIcma,
        100.0,
    )?;
    let settlement = date(2026, 11, 3);
    let clean = 97.85;
    let face = 25_000_000.0;

    // 2. Turn the clean quote into the cash a buyer pays: add the accrued.
    let accrued = bond.accrued(settlement);
    let dirty = clean + accrued;
    println!("accrued per 100      {accrued:.6}");
    println!("cash per 100         {dirty:.6}");
    println!("cash on the face     {:.2}", dirty * face / 100.0);

    // 3. Read the quote as a yield in the bond's own (annual) convention, and
    //    turn a yield back into a clean price.
    let own = YieldQuoteConvention::Default;
    let y = bond
        .yield_(clean, settlement, PriceBasis::Clean, own, None)
        .expect("a bracketed solve");
    let at_three = bond.price(0.0300, settlement, PriceBasis::Clean, own, None);
    println!("yield of 97.85       {:.6}%", y * 100.0);
    println!("clean at 3.00%       {at_three:.6}");

    // 4. Size the rate risk: DV01 per 100, then on the position.
    let basis = own.basis(bond.frequency).expect("a compounding convention");
    let dv01 = yield_moments(&bond, y, settlement, basis).dv01();
    println!("DV01 per 100         {dv01:.6}");
    println!("DV01 on the face     {:.2}", dv01 * face / 100.0);

    Ok(())
}

from datetime import date

import helixio as hlx

# 1. Describe the bond: a EUR 2.75% annual bond on ACT/ACT ICMA, issued on
#    15 September 2024 and maturing on 15 September 2034.
bond = hlx.products.fixed_rate_bond(
    "EUR", date(2024, 9, 15), date(2034, 9, 15), coupon=0.0275,
    frequency=hlx.dates.Frequency.Annual, day_count=hlx.dates.DayCountFraction.ActActIcma,
)
settlement = date(2026, 11, 3)
clean = 97.85
face = 25_000_000.0

# 2. Turn the clean quote into the cash a buyer pays: add the accrued.
accrued = bond.accrued(settlement)
dirty = clean + accrued
print(f"accrued per 100      {accrued:.6f}")
print(f"cash per 100         {dirty:.6f}")
print(f"cash on the face     {dirty * face / 100.0:.2f}")

# 3. Read the quote as a yield in the bond's own (annual) convention, and turn
#    a yield back into a clean price.
y = bond.yield_(clean, settlement, hlx.bonds.PriceBasis.Clean, "default")
at_three = bond.price(0.0300, settlement, hlx.bonds.PriceBasis.Clean, "default")
print(f"yield of 97.85       {y * 100:.6f}%")
print(f"clean at 3.00%       {at_three:.6f}")

# 4. Size the rate risk: DV01 per 100, then on the position.
dv01 = bond.dv01(y, settlement, "default")
print(f"DV01 per 100         {dv01:.6f}")
print(f"DV01 on the face     {dv01 * face / 100.0:.2f}")