quantsupport 0.1.7

Rust quantitative finance library for derivatives pricing, yield-curve bootstrapping, AAD risk, Monte Carlo exposure, and XVA.
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

//! Credit curve (hazard-rate) configuration.
//!
//! A [`CreditCurveConfiguration`] describes how to bootstrap a survival
//! curve for a single reference entity from its CDS par-spread quotes.
//! The struct is serde-deserializable so it can be loaded straight from
//! JSON configuration files:
//!
//! ```json
//! {
//!     "market_index": "Credit(ACME)",
//!     "currency": "USD",
//!     "discount_index": "SOFR",
//!     "recovery": 0.4,
//!     "quotes": ["Cds_ACME_USD_1Y", "Cds_ACME_USD_5Y", "Cds_ACME_USD_10Y"]
//! }
//! ```

use serde::{Deserialize, Serialize};

use crate::{
    currencies::currency::Currency,
    indices::marketindex::MarketIndex,
    math::interpolation::interpolator::Interpolator,
    time::{daycounter::DayCounter, enums::Frequency},
};

const fn default_day_counter() -> DayCounter {
    DayCounter::Actual360
}

const fn default_premium_frequency() -> Frequency {
    Frequency::Quarterly
}

const fn default_interpolator() -> Interpolator {
    Interpolator::LogLinear
}

const fn default_enable_extrapolation() -> bool {
    true
}

/// Configuration for bootstrapping one credit (survival) curve.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct CreditCurveConfiguration {
    /// Credit curve index of the reference entity (`MarketIndex::Credit`).
    market_index: MarketIndex,
    /// Currency of the CDS quotes.
    currency: Currency,
    /// Discount curve used to price the CDS pillar instruments.
    discount_index: MarketIndex,
    /// Assumed recovery rate of the reference entity.
    recovery: f64,
    /// Premium accrual day counter.
    #[serde(default = "default_day_counter")]
    day_counter: DayCounter,
    /// Premium payment frequency.
    #[serde(default = "default_premium_frequency")]
    premium_frequency: Frequency,
    /// Interpolation on survival probabilities.
    #[serde(default = "default_interpolator")]
    interpolator: Interpolator,
    /// Whether extrapolation beyond the last pillar is allowed.
    #[serde(default = "default_enable_extrapolation")]
    enable_extrapolation: bool,
    /// CDS par-spread quote identifiers (e.g. `Cds_ACME_USD_5Y`).
    #[serde(default)]
    quotes: Vec<String>,
}

impl CreditCurveConfiguration {
    /// Creates a new credit curve configuration.
    #[must_use]
    pub const fn new(
        market_index: MarketIndex,
        currency: Currency,
        discount_index: MarketIndex,
        recovery: f64,
        quotes: Vec<String>,
    ) -> Self {
        Self {
            market_index,
            currency,
            discount_index,
            recovery,
            day_counter: default_day_counter(),
            premium_frequency: default_premium_frequency(),
            interpolator: default_interpolator(),
            enable_extrapolation: default_enable_extrapolation(),
            quotes,
        }
    }

    /// Sets the premium day counter.
    #[must_use]
    pub const fn with_day_counter(mut self, day_counter: DayCounter) -> Self {
        self.day_counter = day_counter;
        self
    }

    /// Sets the premium payment frequency.
    #[must_use]
    pub const fn with_premium_frequency(mut self, frequency: Frequency) -> Self {
        self.premium_frequency = frequency;
        self
    }

    /// Credit curve index.
    #[must_use]
    pub const fn market_index(&self) -> &MarketIndex {
        &self.market_index
    }

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

    /// Discount curve index used for pillar pricing.
    #[must_use]
    pub const fn discount_index(&self) -> &MarketIndex {
        &self.discount_index
    }

    /// Assumed recovery rate.
    #[must_use]
    pub const fn recovery(&self) -> f64 {
        self.recovery
    }

    /// Premium day counter.
    #[must_use]
    pub const fn day_counter(&self) -> DayCounter {
        self.day_counter
    }

    /// Premium payment frequency.
    #[must_use]
    pub const fn premium_frequency(&self) -> Frequency {
        self.premium_frequency
    }

    /// Interpolator applied to survival probabilities.
    #[must_use]
    pub const fn interpolator(&self) -> Interpolator {
        self.interpolator
    }

    /// Whether extrapolation is enabled.
    #[must_use]
    pub const fn enable_extrapolation(&self) -> bool {
        self.enable_extrapolation
    }

    /// CDS quote identifiers.
    #[must_use]
    pub fn quotes(&self) -> &[String] {
        &self.quotes
    }
}