libitofin 0.6.1

A ground-up Rust port of QuantLib: quantitative-finance primitives for pricing, risk, and numerical methods.
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

//! Maltese calendar.
//!
//! Port of `ql/time/calendars/malta.{hpp,cpp}`.

use crate::shared::shared;
use crate::time::calendar::{Calendar, CalendarImpl, western_easter_monday};
use crate::time::date::{Date, Month};
use crate::time::weekday::Weekday;

/// Malta calendar markets.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Market {
    /// Malta Stock Exchange.
    Mse,
}

/// The weekend for the Malta Stock Exchange is Friday and Saturday.
fn is_weekend(w: Weekday) -> bool {
    w == Weekday::Friday || w == Weekday::Saturday
}

/// The Maltese calendar.
pub struct Malta;

impl Malta {
    /// Builds a Maltese calendar for the given market.
    ///
    /// QuantLib defaults to [`Market::Mse`].
    pub fn new(market: Market) -> Calendar {
        let imp: crate::shared::Shared<dyn CalendarImpl> = match market {
            Market::Mse => shared(MseImpl),
        };
        Calendar::from_impl(imp)
    }
}

struct MseImpl;

impl CalendarImpl for MseImpl {
    fn name(&self) -> String {
        "Malta Stock Exchange".to_string()
    }

    fn is_weekend(&self, w: Weekday) -> bool {
        is_weekend(w)
    }

    fn is_business_day(&self, date: Date) -> bool {
        let w = date.weekday();
        let d = date.day_of_month();
        let m = date.month();
        let y = date.year();
        let em = western_easter_monday(y);
        let gf = em - 3; // Good Friday
        !(is_weekend(w)
            // New Year's Day
            || (d == 1 && m == Month::January)
            // St. Paul's Shipwreck
            || (d == 10 && m == Month::February)
            // St. Joseph's Day
            || (d == 19 && m == Month::March)
            // Freedom Day
            || (d == 31 && m == Month::March)
            // Good Friday
            || (date.day_of_year() == gf)
            // Easter Monday (exchange holiday)
            || (date.day_of_year() == em)
            // Labour Day
            || (d == 1 && m == Month::May)
            // Imnarja (Feast of Saints Peter & Paul)
            || (d == 29 && m == Month::June)
            // Assumption of Mary
            || (d == 15 && m == Month::August)
            // Our Lady of Victories (Nativity of Mary)
            || (d == 8 && m == Month::September)
            // Independence Day
            || (d == 21 && m == Month::September)
            // Immaculate Conception
            || (d == 8 && m == Month::December)
            // Republic Day
            || (d == 13 && m == Month::December)
            // Christmas Vigil
            || (d == 24 && m == Month::December)
            // Christmas Day
            || (d == 25 && m == Month::December)
            // Boxing Day (occasionally observed by MSE)
            || (d == 26 && m == Month::December)
            // New Year's Eve (non-trading)
            || (d == 31 && m == Month::December))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    // Spot-checks, not a full transcription of test-suite/calendars.cpp.
    #[test]
    fn name_matches_quantlib() {
        assert_eq!(Malta::new(Market::Mse).name(), "Malta Stock Exchange");
    }

    #[test]
    fn fixed_holidays() {
        let c = Malta::new(Market::Mse);
        assert!(c.is_holiday(Date::new(1, Month::January, 2019)));
        assert!(c.is_holiday(Date::new(10, Month::February, 2019)));
        assert!(c.is_holiday(Date::new(19, Month::March, 2019)));
        assert!(c.is_holiday(Date::new(31, Month::March, 2019)));
        assert!(c.is_holiday(Date::new(1, Month::May, 2019)));
        assert!(c.is_holiday(Date::new(29, Month::June, 2019)));
        assert!(c.is_holiday(Date::new(15, Month::August, 2019)));
        assert!(c.is_holiday(Date::new(8, Month::September, 2019)));
        assert!(c.is_holiday(Date::new(21, Month::September, 2019)));
        assert!(c.is_holiday(Date::new(8, Month::December, 2019)));
        assert!(c.is_holiday(Date::new(13, Month::December, 2019)));
        assert!(c.is_holiday(Date::new(24, Month::December, 2019)));
        assert!(c.is_holiday(Date::new(25, Month::December, 2019)));
        assert!(c.is_holiday(Date::new(26, Month::December, 2019)));
        assert!(c.is_holiday(Date::new(31, Month::December, 2019)));
    }

    #[test]
    fn friday_saturday_weekend() {
        let c = Malta::new(Market::Mse);
        assert!(c.is_weekend(Weekday::Friday));
        assert!(c.is_weekend(Weekday::Saturday));
        assert!(!c.is_weekend(Weekday::Sunday));
    }
}