quantlib_rs 0.1.0

A ground-up, idiomatic Rust quantitative finance library inspired by QuantLib.
Documentation
//! Interpolated discount curve with log-linear discount interpolation.

use crate::termstructures::yield_term_structure::YieldTermStructure;
use crate::time::date::Date;
use thiserror::Error;

/// Errors when building interpolated curves.
#[derive(Debug, Clone, PartialEq, Error)]
pub enum CurveError {
    /// Dimension mismatch between pillars and rates/discounts.
    #[error("Dimension mismatch: {times_len} times vs {values_len} values")]
    DimensionMismatch {
        /// Times length
        times_len: usize,
        /// Values length
        values_len: usize,
    },
    /// Pillar times are not strictly increasing.
    #[error("Times must be strictly increasing and start at 0.0")]
    NonMonotonicTimes,
    /// Discount factor is non-positive.
    #[error("Discount factor at index {0} must be positive, got {1}")]
    NonPositiveDiscount(usize, f64),
}

/// Yield curve formed by log-linear interpolation on discount factors $P(0, t)$.
///
/// Log-linear discount interpolation is standard in fixed income because it implies
/// piecewise-constant instantaneous forward rates between pillars:
/// $$\ln P(0, t) = \ln P(0, t_i) + \frac{t - t_i}{t_{i+1} - t_i} (\ln P(0, t_{i+1}) - \ln P(0, t_i))$$
///
/// # Examples
/// ```
/// use quantlib_rs::termstructures::interpolated_discount_curve::InterpolatedDiscountCurve;
/// use quantlib_rs::termstructures::yield_term_structure::YieldTermStructure;
/// use quantlib_rs::time::date::{Date, Month};
///
/// let today = Date::from_ymd(2026, Month::September, 3).unwrap();
/// let times = vec![0.0, 1.0, 2.0];
/// let discounts = vec![1.0, 0.95, 0.90];
///
/// let curve = InterpolatedDiscountCurve::new(times, discounts, today).unwrap();
/// assert_eq!(curve.discount(0.0), 1.0);
/// assert_eq!(curve.discount(1.0), 0.95);
/// // Midpoint discount factor
/// assert!((curve.discount(0.5) - (1.0f64 * 0.95).sqrt()).abs() < 1e-12);
/// ```
#[derive(Debug, Clone)]
pub struct InterpolatedDiscountCurve {
    times: Vec<f64>,
    discounts: Vec<f64>,
    log_discounts: Vec<f64>,
    reference_date: Date,
}

impl InterpolatedDiscountCurve {
    /// Construct a new log-linear interpolated discount curve.
    pub fn new(
        times: Vec<f64>,
        discounts: Vec<f64>,
        reference_date: Date,
    ) -> Result<Self, CurveError> {
        let n = times.len();
        if n != discounts.len() {
            return Err(CurveError::DimensionMismatch {
                times_len: n,
                values_len: discounts.len(),
            });
        }
        if n < 2 || times[0] != 0.0 || discounts[0] != 1.0 {
            return Err(CurveError::NonMonotonicTimes);
        }
        for i in 1..n {
            if times[i] <= times[i - 1] {
                return Err(CurveError::NonMonotonicTimes);
            }
            if discounts[i] <= 0.0 {
                return Err(CurveError::NonPositiveDiscount(i, discounts[i]));
            }
        }

        let log_discounts: Vec<f64> = discounts.iter().map(|&d| d.ln()).collect();

        Ok(Self {
            times,
            discounts,
            log_discounts,
            reference_date,
        })
    }

    /// Return the pillar times.
    pub fn times(&self) -> &[f64] {
        &self.times
    }

    /// Return the pillar discount factors.
    pub fn discounts(&self) -> &[f64] {
        &self.discounts
    }
}

impl YieldTermStructure for InterpolatedDiscountCurve {
    #[inline]
    fn reference_date(&self) -> Date {
        self.reference_date
    }

    fn discount(&self, t: f64) -> f64 {
        if t <= 0.0 {
            return 1.0;
        }
        let n = self.times.len();
        if t >= self.times[n - 1] {
            // Flat forward extrapolation beyond the last pillar
            let t_last = self.times[n - 1];
            let t_prev = self.times[n - 2];
            let f_last =
                (self.log_discounts[n - 2] - self.log_discounts[n - 1]) / (t_last - t_prev);
            return (self.log_discounts[n - 1] - f_last * (t - t_last)).exp();
        }

        // Binary search for interval [times[i], times[i+1]]
        let idx = self.times.partition_point(|&val| val <= t);
        let i = if idx == 0 { 0 } else { idx - 1 };

        let t0 = self.times[i];
        let t1 = self.times[i + 1];
        let l0 = self.log_discounts[i];
        let l1 = self.log_discounts[i + 1];

        let ratio = (t - t0) / (t1 - t0);
        let log_d = l0 + ratio * (l1 - l0);
        log_d.exp()
    }

    fn zero_rate(&self, t: f64) -> f64 {
        if t <= 1e-6 {
            // Instantaneous forward rate at t=0
            let dt = self.times[1] - self.times[0];
            -(self.log_discounts[1] - self.log_discounts[0]) / dt
        } else {
            let d = self.discount(t);
            -d.ln() / t
        }
    }
}