libitofin 0.52.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

//! Municipal BMA versus a fraction of Ibor, from QuantLib's `bmaswap.cpp`.
use crate::cashflows::{AverageBMALeg, IborLeg};
use crate::errors::QlResult;
use crate::indexes::{BMAIndex, IborIndex, InterestRateIndex};
use crate::instrument::{Instrument, InstrumentBase};
use crate::instruments::{Swap, swap::SwapType};
use crate::pricingengine::{Arguments, Results};
use crate::settings::Settings;
use crate::shared::Shared;
use crate::time::{date::Date, daycounter::DayCounter, schedule::Schedule};

/// Two-leg municipal swap. Payer pays BMA and receives the Ibor leg.
pub struct BMASwap {
    swap: Swap,
    swap_type: SwapType,
    nominal: f64,
    libor_fraction: f64,
    libor_spread: f64,
}
impl BMASwap {
    /// Constructs the two observed legs, retaining indexes, history and settings.
    #[allow(clippy::too_many_arguments)]
    pub fn new(
        swap_type: SwapType,
        nominal: f64,
        libor_schedule: Schedule,
        libor_fraction: f64,
        libor_spread: f64,
        libor_index: Shared<IborIndex>,
        libor_day_count: DayCounter,
        bma_schedule: Schedule,
        bma_index: Shared<BMAIndex>,
        bma_day_count: DayCounter,
        settings: Shared<Settings<Date>>,
    ) -> QlResult<Self> {
        crate::require!(
            nominal.is_finite() && libor_fraction.is_finite() && libor_spread.is_finite(),
            "BMA swap inputs must be finite"
        );
        crate::require!(
            Shared::ptr_eq(libor_index.base().settings(), &settings)
                && Shared::ptr_eq(bma_index.base().settings(), &settings),
            "BMA swap indexes must share settings"
        );
        let lc = libor_schedule.business_day_convention();
        let bc = bma_schedule.business_day_convention();
        let libor = IborLeg::new(libor_schedule, libor_index)
            .with_notional(nominal)
            .with_payment_day_counter(libor_day_count)
            .with_payment_adjustment(lc)
            .with_gearing(libor_fraction)
            .with_spread(libor_spread)
            .build()?;
        let bma = AverageBMALeg::new(bma_schedule, bma_index)
            .with_notional(nominal)
            .with_payment_day_counter(bma_day_count)
            .with_payment_adjustment(bc)
            .build()?;
        let payer = swap_type == SwapType::Payer;
        Ok(Self {
            swap: Swap::new(vec![libor, bma], vec![!payer, payer], settings)?,
            swap_type,
            nominal,
            libor_fraction,
            libor_spread,
        })
    }
    /// Base swap, including generic leg results and dates.
    pub fn swap(&self) -> &Swap {
        &self.swap
    }
    /// Mutable base swap for pricing and leg results.
    pub fn swap_mut(&mut self) -> &mut Swap {
        &mut self.swap
    }
    /// Payer/receiver orientation.
    pub fn swap_type(&self) -> SwapType {
        self.swap_type
    }
    /// Leg notional.
    pub fn nominal(&self) -> f64 {
        self.nominal
    }
    /// Contractual Ibor fraction.
    pub fn libor_fraction(&self) -> f64 {
        self.libor_fraction
    }
    /// Contractual Ibor spread.
    pub fn libor_spread(&self) -> f64 {
        self.libor_spread
    }
    /// Fraction of Ibor producing zero NPV at the contractual spread.
    pub fn fair_libor_fraction(&mut self) -> QlResult<f64> {
        let spread_npv = self.libor_spread / 1e-4 * self.swap.leg_bps(0)?;
        let pure = self.swap.leg_npv(0)? - spread_npv;
        crate::require!(pure != 0.0, "null Ibor NPV");
        Ok(-self.libor_fraction * (self.swap.leg_npv(1)? + spread_npv) / pure)
    }
    /// Additive Ibor spread producing zero NPV at the contractual fraction.
    pub fn fair_libor_spread(&mut self) -> QlResult<f64> {
        let bps = self.swap.leg_bps(0)?;
        crate::require!(bps != 0.0, "null Ibor BPS");
        Ok(self.libor_spread - self.swap.npv()? / (bps / 1e-4))
    }
}
impl Instrument for BMASwap {
    fn base(&self) -> &InstrumentBase {
        self.swap.base()
    }
    fn base_mut(&mut self) -> &mut InstrumentBase {
        self.swap.base_mut()
    }
    fn is_expired(&self) -> QlResult<bool> {
        self.swap.is_expired()
    }
    fn setup_arguments(&self, args: &mut dyn Arguments) -> QlResult<()> {
        self.swap.setup_arguments(args)
    }
    fn fetch_results(&mut self, results: &dyn Results) -> QlResult<()> {
        self.swap.fetch_results(results)
    }
    fn setup_expired(&mut self) {
        self.swap.setup_expired();
    }
}