expiration_date 0.2.1

A professional financial instrument expiration date management library with support for standard day count conventions.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

//! Financial conventions for day counting and business days.

use crate::error::ExpirationDateError;
use chrono::{DateTime, Datelike, Utc};

/// Trait for financial day count conventions.
pub trait DayCount: Copy + Send + Sync {
    /// Returns the year fraction between start and end dates.
    ///
    /// # Errors
    /// Returns [ExpirationDateError::ArithmeticOverflow] if calculation fails.
    fn year_fraction(
        &self,
        start: &DateTime<Utc>,
        end: &DateTime<Utc>,
    ) -> Result<f64, ExpirationDateError>;

    /// Returns the number of days between start and end dates.
    ///
    /// # Errors
    /// Returns [ExpirationDateError::ArithmeticOverflow] if calculation fails.
    fn day_count(
        &self,
        start: &DateTime<Utc>,
        end: &DateTime<Utc>,
    ) -> Result<f64, ExpirationDateError>;
}

/// Actual/360 day count convention. Commonly used in money markets.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct Actual360;

impl DayCount for Actual360 {
    #[inline]
    fn year_fraction(
        &self,
        start: &DateTime<Utc>,
        end: &DateTime<Utc>,
    ) -> Result<f64, ExpirationDateError> {
        Ok(self.day_count(start, end)? / 360.0)
    }

    #[inline]
    fn day_count(
        &self,
        start: &DateTime<Utc>,
        end: &DateTime<Utc>,
    ) -> Result<f64, ExpirationDateError> {
        let duration = end.signed_duration_since(*start);
        Ok(duration.num_days() as f64)
    }
}

/// Actual/365 Fixed day count convention. Standard for many derivatives.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct Actual365Fixed;

impl DayCount for Actual365Fixed {
    #[inline]
    fn year_fraction(
        &self,
        start: &DateTime<Utc>,
        end: &DateTime<Utc>,
    ) -> Result<f64, ExpirationDateError> {
        Ok(self.day_count(start, end)? / 365.0)
    }

    #[inline]
    fn day_count(
        &self,
        start: &DateTime<Utc>,
        end: &DateTime<Utc>,
    ) -> Result<f64, ExpirationDateError> {
        let duration = end.signed_duration_since(*start);
        Ok(duration.num_days() as f64)
    }
}

/// 30/360 US (NASD) day count convention.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct Thirty360US;

impl DayCount for Thirty360US {
    #[inline]
    fn year_fraction(
        &self,
        start: &DateTime<Utc>,
        end: &DateTime<Utc>,
    ) -> Result<f64, ExpirationDateError> {
        Ok(self.day_count(start, end)? / 360.0)
    }

    fn day_count(
        &self,
        start: &DateTime<Utc>,
        end: &DateTime<Utc>,
    ) -> Result<f64, ExpirationDateError> {
        let d1 = start.day().min(30) as i64;
        let mut d2 = end.day() as i64;
        if d1 == 30 && d2 == 31 {
            d2 = 30;
        }

        let m1 = start.month() as i64;
        let m2 = end.month() as i64;
        let y1 = start.year() as i64;
        let y2 = end.year() as i64;

        let y_diff = y2.checked_sub(y1).ok_or_else(|| {
            ExpirationDateError::ArithmeticOverflow("thirty_360_us year diff".into())
        })?;
        let m_diff = m2.checked_sub(m1).ok_or_else(|| {
            ExpirationDateError::ArithmeticOverflow("thirty_360_us month diff".into())
        })?;
        let d_diff = d2.checked_sub(d1).ok_or_else(|| {
            ExpirationDateError::ArithmeticOverflow("thirty_360_us day diff".into())
        })?;

        let term1 = y_diff.checked_mul(360).ok_or_else(|| {
            ExpirationDateError::ArithmeticOverflow("thirty_360_us year term".into())
        })?;
        let term2 = m_diff.checked_mul(30).ok_or_else(|| {
            ExpirationDateError::ArithmeticOverflow("thirty_360_us month term".into())
        })?;

        let total = term1
            .checked_add(term2)
            .and_then(|t| t.checked_add(d_diff))
            .ok_or_else(|| {
                ExpirationDateError::ArithmeticOverflow("thirty_360_us day_count".into())
            })?;

        Ok(total as f64)
    }
}