quantrs 0.1.8

A tiny Rust library for quantitative finance
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

//! Module for fixed income types and error handling
//!! ## References
//! - [Wikipedia: Day Count Convention](https://en.wikipedia.org/wiki/Day_count_convention)
//! - [Wikipedia: Cash Flow](https://en.wikipedia.org/wiki/Cash_flow)

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DayCount {
    /// Actual/365 Fixed - 365 days per year
    Act365F,
    /// Actual/365 - actual days, 365 days per year (no leap year adjustment)
    Act365,
    /// Actual/360 - actual days, 360 days per year
    Act360,
    /// 30/360 US (Bond Basis) - 30 days per month, 360 days per year
    Thirty360US,
    /// 30/360 European - European version of 30/360
    Thirty360E,
    /// Actual/Actual ISDA - actual days, actual year length
    ActActISDA,
    /// Actual/Actual ICMA - used for bonds
    ActActICMA,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CashFlowType {
    Coupon,
    Principal,
    CallPayment,
    Other,
}

#[derive(Debug, Clone)]
pub enum BondPricingError {
    /// Invalid yield to maturity (e.g., negative or extremely high values)
    InvalidYield(f64),

    /// Settlement date is after maturity date
    SettlementAfterMaturity {
        settlement: chrono::NaiveDate,
        maturity: chrono::NaiveDate,
    },

    /// Invalid coupon frequency (must be 1, 2, 4, or 12)
    InvalidFrequency(u32),

    /// Negative face value or coupon rate
    NegativeInput(String),

    /// Error in payment schedule generation
    ScheduleGenerationError(String),

    /// Mathematical calculation error (e.g., division by zero)
    CalculationError(String),

    /// Invalid day count convention
    InvalidDayCount,

    /// Missing required bond parameters
    MissingParameter(String),
}

impl std::fmt::Display for BondPricingError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            BondPricingError::InvalidYield(ytm) => {
                write!(f, "Invalid yield to maturity: {ytm}")
            }
            BondPricingError::SettlementAfterMaturity {
                settlement,
                maturity,
            } => {
                write!(
                    f,
                    "Settlement date ({settlement}) must be before maturity date ({maturity})"
                )
            }
            BondPricingError::InvalidFrequency(freq) => {
                write!(
                    f,
                    "Invalid coupon frequency: {freq}. Must be 1, 2, 4, or 12"
                )
            }
            BondPricingError::NegativeInput(param) => {
                write!(f, "Negative input not allowed for: {param}")
            }
            BondPricingError::ScheduleGenerationError(msg) => {
                write!(f, "Schedule generation error: {msg}")
            }
            BondPricingError::CalculationError(msg) => {
                write!(f, "Calculation error: {msg}")
            }
            BondPricingError::InvalidDayCount => {
                write!(f, "Invalid day count convention")
            }
            BondPricingError::MissingParameter(param) => {
                write!(f, "Missing required parameter: {param}")
            }
        }
    }
}

impl std::error::Error for BondPricingError {}

// Helper methods for creating common errors
impl BondPricingError {
    pub fn invalid_yield(ytm: f64) -> Self {
        Self::InvalidYield(ytm)
    }

    pub fn settlement_after_maturity(
        settlement: chrono::NaiveDate,
        maturity: chrono::NaiveDate,
    ) -> Self {
        Self::SettlementAfterMaturity {
            settlement,
            maturity,
        }
    }

    pub fn negative_input(param: &str) -> Self {
        Self::NegativeInput(param.to_string())
    }
}