quantlib_rs 0.1.0

A ground-up, idiomatic Rust quantitative finance library inspired by QuantLib.
Documentation
//! Zero coupon bond instrument.

use crate::cashflows::leg::Leg;
use crate::cashflows::simple::SimpleCashFlow;
use crate::termstructures::yield_term_structure::YieldTermStructure;
use crate::time::calendar::{BusinessDayConvention, Calendar};
use crate::time::date::{Date, Period};
use std::sync::Arc;

/// Zero coupon bond paying principal bullet redemption at maturity.
///
/// # Examples
/// ```
/// use std::sync::Arc;
/// use quantlib_rs::instruments::bonds::zero_coupon_bond::ZeroCouponBond;
/// use quantlib_rs::termstructures::yield_term_structure::FlatForward;
/// use quantlib_rs::time::calendars::weekends_only::WeekendsOnly;
/// use quantlib_rs::time::date::{Date, Month};
///
/// let cal = Arc::new(WeekendsOnly);
/// let maturity = Date::from_ymd(2027, Month::January, 15).unwrap();
/// let bond = ZeroCouponBond::new(1, 100.0, maturity, cal, 100.0);
///
/// let today = Date::from_ymd(2026, Month::January, 15).unwrap();
/// let curve = FlatForward::new(0.05, today);
///
/// let price = bond.dirty_price(&curve, today);
/// assert!(price < 100.0 && price > 90.0);
/// ```
#[derive(Clone)]
pub struct ZeroCouponBond {
    settlement_days: u32,
    face_amount: f64,
    maturity_date: Date,
    calendar: Arc<dyn Calendar>,
    redemption: f64,
    leg: Leg,
}

impl ZeroCouponBond {
    /// Create a new zero coupon bond.
    pub fn new(
        settlement_days: u32,
        face_amount: f64,
        maturity_date: Date,
        calendar: Arc<dyn Calendar>,
        redemption: f64,
    ) -> Self {
        let mut leg = Leg::new();
        leg.push(Arc::new(SimpleCashFlow::new(redemption, maturity_date)));

        Self {
            settlement_days,
            face_amount,
            maturity_date,
            calendar,
            redemption,
            leg,
        }
    }

    /// Return the settlement date corresponding to evaluation date `as_of`.
    pub fn settlement_date(&self, as_of: Date) -> Date {
        if self.settlement_days == 0 {
            as_of
        } else {
            self.calendar
                .advance(
                    as_of,
                    Period::Days(self.settlement_days as i64),
                    BusinessDayConvention::Following,
                    false,
                )
                .unwrap_or(as_of + self.settlement_days as i64)
        }
    }

    /// Return the maturity date.
    pub fn maturity_date(&self) -> Date {
        self.maturity_date
    }

    /// Return the face amount (par value) of the bond.
    pub fn face_amount(&self) -> f64 {
        self.face_amount
    }

    /// Return the redemption value at maturity.
    pub fn redemption(&self) -> f64 {
        self.redemption
    }

    /// Calculate the price of the zero coupon bond using a discount curve.
    pub fn dirty_price(&self, curve: &dyn YieldTermStructure, as_of: Date) -> f64 {
        let settle = self.settlement_date(as_of);
        self.leg.npv(curve, settle)
    }

    /// Clean price for zero coupon bonds is identical to dirty price (accrued interest = 0).
    pub fn clean_price(&self, curve: &dyn YieldTermStructure, as_of: Date) -> f64 {
        self.dirty_price(curve, as_of)
    }
}