quantlib_rs 0.1.0

A ground-up, idiomatic Rust quantitative finance library inspired by QuantLib.
Documentation
//! Actual/Actual day counters (ISDA convention).

use crate::time::date::{is_leap_year, Date, Month};
use crate::time::day_counter::DayCounter;

/// Actual/Actual conventions.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub enum ActualActualConvention {
    /// ISDA convention: allocates days according to the actual number of days in each calendar year.
    #[default]
    ISDA,
}

/// Actual/Actual day counter supporting the ISDA convention.
///
/// Under ISDA, the year fraction for a period $[d_1, d_2]$ spanning years $y_1$ to $y_2$ is:
/// $$\text{Year Fraction} = \frac{\text{days in } y_1}{\text{days in year}(y_1)} + (y_2 - y_1 - 1) + \frac{\text{days in } y_2}{\text{days in year}(y_2)}$$
/// where $\text{days in year}(y)$ is 366 if $y$ is a leap year and 365 otherwise.
///
/// # Examples
/// ```
/// use quantlib_rs::time::date::{Date, Month};
/// use quantlib_rs::time::day_counter::DayCounter;
/// use quantlib_rs::time::day_counters::actual_actual::ActualActual;
///
/// let dc = ActualActual::default();
/// // 2003-11-01 to 2004-05-01: spans 2003 (365 days) and leap year 2004 (366 days)
/// let d1 = Date::from_ymd(2003, Month::November, 1).unwrap();
/// let d2 = Date::from_ymd(2004, Month::May, 1).unwrap();
///
/// // 61 days in 2003, 121 days in 2004
/// let expected = 61.0 / 365.0 + 121.0 / 366.0;
/// assert!((dc.year_fraction(d1, d2) - expected).abs() < 1e-12);
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct ActualActual {
    convention: ActualActualConvention,
}

impl ActualActual {
    /// Create a new ActualActual day counter with the specified convention.
    pub const fn new(convention: ActualActualConvention) -> Self {
        Self { convention }
    }
}

impl DayCounter for ActualActual {
    fn name(&self) -> &'static str {
        match self.convention {
            ActualActualConvention::ISDA => "Actual/Actual (ISDA)",
        }
    }

    #[inline]
    fn day_count(&self, start: Date, end: Date) -> i64 {
        end - start
    }

    fn year_fraction(&self, start: Date, end: Date) -> f64 {
        if start == end {
            return 0.0;
        }
        if start > end {
            return -self.year_fraction(end, start);
        }

        let (y1, _, _) = start.ymd();
        let (y2, _, _) = end.ymd();

        if y1 == y2 {
            let denom = if is_leap_year(y1) { 366.0 } else { 365.0 };
            (end - start) as f64 / denom
        } else {
            let next_year_start = Date::from_ymd(y1 + 1, Month::January, 1).unwrap();
            let d1 = next_year_start - start;
            let denom1 = if is_leap_year(y1) { 366.0 } else { 365.0 };

            let current_year_start = Date::from_ymd(y2, Month::January, 1).unwrap();
            let d2 = end - current_year_start;
            let denom2 = if is_leap_year(y2) { 366.0 } else { 365.0 };

            let full_years = (y2 - y1 - 1) as f64;
            (d1 as f64 / denom1) + full_years + (d2 as f64 / denom2)
        }
    }
}