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

use std::collections::HashMap;
use std::str::FromStr;

use serde::{Deserialize, Serialize};

use crate::{
    quotes::{
        quote::{Quote, QuoteDetails, QuoteLevels},
        quoteselector::QuoteSelector,
    },
    time::date::Date,
    utils::errors::QSError,
};

/// Serde-friendly single quote record, e.g. `{"identifier": "OIS_USD_SOFR_1Y", "mid": 0.041}`.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QuoteRecord {
    /// Quote identifier parseable into [`QuoteDetails`].
    pub identifier: String,
    /// Mid level.
    #[serde(default)]
    pub mid: Option<f64>,
    /// Bid level.
    #[serde(default)]
    pub bid: Option<f64>,
    /// Ask level.
    #[serde(default)]
    pub ask: Option<f64>,
}

/// Serde-friendly quote store input:
/// `{"reference_date": "2025-11-11", "quotes": [{"identifier": ..., "mid": ...}, ...]}`.
///
/// Deserializable from JSON files or Python dicts, and convertible into a
/// [`QuoteStore`] via [`TryFrom`].
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QuoteStoreRecords {
    /// Reference date of the quotes.
    pub reference_date: Date,
    /// The quote records.
    pub quotes: Vec<QuoteRecord>,
}

impl TryFrom<QuoteStoreRecords> for QuoteStore {
    type Error = QSError;

    fn try_from(records: QuoteStoreRecords) -> Result<Self, Self::Error> {
        let mut store = Self::new(records.reference_date);
        for rec in records.quotes {
            let details = QuoteDetails::from_str(&rec.identifier)?;
            let levels = QuoteLevels::new(rec.mid, rec.bid, rec.ask);
            store.add_quote(Quote::new(details, levels));
        }
        Ok(store)
    }
}

/// Provider of market data loaded from quotes.
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct QuoteStore {
    reference_date: Date,
    quotes: HashMap<String, Quote>,
}

impl QuoteStore {
    /// Creates an empty market data provider.
    #[must_use]
    pub fn new(reference_date: Date) -> Self {
        Self {
            reference_date,
            quotes: HashMap::new(),
        }
    }
    /// Returns the reference date for the provider.
    #[must_use]
    pub const fn reference_date(&self) -> Date {
        self.reference_date
    }

    /// Adds a market quote to the provider, indexed by its identifier.
    pub fn add_quote(&mut self, quote: Quote) {
        let id = quote.details().identifier();
        self.quotes.insert(id, quote);
    }

    /// Returns a quote by identifier.
    #[must_use]
    pub fn quote(&self, identifier: &str) -> Option<&Quote> {
        self.quotes.get(identifier)
    }

    /// Returns all stored quotes.
    #[must_use]
    pub const fn quotes(&self) -> &HashMap<String, Quote> {
        &self.quotes
    }
}

impl QuoteSelector for QuoteStore {
    fn select(&self, identifier: &str) -> Option<Quote> {
        self.quotes.get(identifier).cloned()
    }

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