quantsupport 0.1.0

Rust library for fixed-income, 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

use crate::{
    ad::adreal::{ADReal, IsReal},
    indices::marketindex::MarketIndex,
    instruments::cashflows::coupons::{NonLinearCoupon, PayoffOps},
    time::date::Date,
    utils::errors::{QSError, Result},
};

/// An [`OptionEmbeddedCoupon`] represents a cash flow that includes embedded options.
///
/// The payoff is determined by a specified payoff function. For example, this could
/// represent a floored or capped coupon, where the payoff is determined by the
/// underlying index and the specified floor or cap.
pub struct OptionEmbeddedCoupon<T: IsReal> {
    notional: f64,
    fixing: Option<T>,
    spread: ADReal,
    index: MarketIndex,
    accrual_start_date: Date,
    accrual_end_date: Date,
    payment_date: Date,
    payoff: PayoffOps,
}

impl<T: IsReal> OptionEmbeddedCoupon<T> {
    /// Creates a new [`OptionEmbeddedCoupon`].
    #[must_use] 
    pub const fn new(
        notional: f64,
        index: MarketIndex,
        spread: ADReal,
        accrual_start_date: Date,
        accrual_end_date: Date,
        payment_date: Date,
        payoff: PayoffOps,
    ) -> Self {
        Self {
            notional,
            fixing: None,
            spread,
            index,
            accrual_start_date,
            accrual_end_date,
            payment_date,
            payoff,
        }
    }

    /// Sets the fixing for the coupon, which is used to determine the payoff.
    #[must_use]
    pub const fn with_fixing(mut self, fixing: T) -> Self {
        self.fixing = Some(fixing);
        self
    }

    /// Returns the spread applied to this coupon.
    pub const fn spread(&self) -> ADReal {
        self.spread
    }

    /// Returns the fixing value if set.
    pub const fn fixing(&self) -> Option<T> {
        self.fixing
    }

    /// Returns the market index associated with this coupon.
    pub const fn market_index(&self) -> &MarketIndex {
        &self.index
    }

    /// Returns the payoff operations.
    pub const fn payoff_ops(&self) -> &PayoffOps {
        &self.payoff
    }
}

impl OptionEmbeddedCoupon<ADReal> {
    /// Returns the amount of the coupon (calculated from accrued amount). Only available for `ADReal`.
    ///
    /// # Errors
    ///
    /// Returns an error if the accrued amount calculation fails.
    pub fn amount(&self) -> Result<ADReal> {
        self.accrued_amount(self.accrual_start_date, self.accrual_end_date)
    }
}

impl NonLinearCoupon<ADReal> for OptionEmbeddedCoupon<ADReal> {
    fn accrual_end_date(&self) -> Date {
        self.accrual_end_date
    }

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

    fn accrued_amount(&self, start_date: Date, end_date: Date) -> Result<ADReal> {
        let fixing = self
            .fixing
            .ok_or_else(|| QSError::NotFoundErr("Fixing not set".into()))?;

        let year_fraction = self
            .index
            .rate_index_details()?
            .rate_definition()
            .day_counter()
            .year_fraction(start_date, end_date);

        let resuling_rate = self.payoff.evaluate(fixing)?;
        Ok(((self.spread + resuling_rate) * year_fraction * self.notional).into())
    }

    fn notional(&self) -> f64 {
        self.notional
    }

    fn payoff_description(&self) -> PayoffOps {
        self.payoff.clone()
    }

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