quantsupport 0.1.5

Rust library for derivative pricing and risk analytics.
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

use crate::{
    core::{
        instrument::Instrument,
        trade::{Side, Trade},
    },
    currencies::currency::Currency,
    indices::marketindex::MarketIndex,
    time::{date::Date, daycounter::DayCounter},
};

/// An [`EquityForward`] represents a forward contract on an equity underlying (stock or index).
/// The holder agrees to buy (or sell) the underlying at a pre-agreed forward price on the
/// delivery date.
pub struct EquityForward {
    identifier: String,
    market_index: MarketIndex,
    delivery_date: Date,
    strike: f64,
    currency: Currency,
    day_counter: DayCounter,
}

impl EquityForward {
    /// Creates a new [`EquityForward`].
    #[must_use]
    pub const fn new(
        identifier: String,
        market_index: MarketIndex,
        delivery_date: Date,
        strike: f64,
        currency: Currency,
        day_counter: DayCounter,
    ) -> Self {
        Self {
            identifier,
            market_index,
            delivery_date,
            strike,
            currency,
            day_counter,
        }
    }

    /// Returns the market index for the underlying equity.
    #[must_use]
    pub fn market_index(&self) -> MarketIndex {
        self.market_index.clone()
    }

    /// Returns the delivery date.
    #[must_use]
    pub const fn delivery_date(&self) -> Date {
        self.delivery_date
    }

    /// Returns the agreed forward (strike) price.
    #[must_use]
    pub const fn strike(&self) -> f64 {
        self.strike
    }

    /// Returns the currency.
    #[must_use]
    pub const fn currency(&self) -> &Currency {
        &self.currency
    }

    /// Returns the day count convention.
    #[must_use]
    pub const fn day_counter(&self) -> &DayCounter {
        &self.day_counter
    }
}

impl Instrument for EquityForward {
    fn identifier(&self) -> String {
        self.identifier.clone()
    }
}

/// Represents a trade of an equity forward.
pub struct EquityForwardTrade {
    instrument: EquityForward,
    trade_date: Date,
    notional: f64,
    side: Side,
}

impl EquityForwardTrade {
    /// Creates a new [`EquityForwardTrade`].
    #[must_use]
    pub const fn new(
        instrument: EquityForward,
        trade_date: Date,
        notional: f64,
        side: Side,
    ) -> Self {
        Self {
            instrument,
            trade_date,
            notional,
            side,
        }
    }

    /// Returns the notional amount.
    #[must_use]
    pub const fn notional(&self) -> f64 {
        self.notional
    }
}

impl Trade<EquityForward> for EquityForwardTrade {
    fn instrument(&self) -> &EquityForward {
        &self.instrument
    }

    fn trade_date(&self) -> Date {
        self.trade_date
    }

    fn side(&self) -> Side {
        self.side
    }
}