use crate::instruments::swaps::vanilla_swap::{SwapType, VanillaSwap};
use crate::termstructures::yield_term_structure::YieldTermStructure;
use crate::time::date::Date;
use crate::time::day_counter::DayCounter;
use crate::time::day_counters::actual_365_fixed::Actual365Fixed;
use std::sync::Arc;
#[derive(Clone)]
pub struct DiscountingSwapEngine {
discount_curve: Arc<dyn YieldTermStructure>,
projection_curve: Arc<dyn YieldTermStructure>,
}
impl DiscountingSwapEngine {
pub fn new(curve: Arc<dyn YieldTermStructure>) -> Self {
Self {
discount_curve: curve.clone(),
projection_curve: curve,
}
}
pub fn with_dual_curves(
discount_curve: Arc<dyn YieldTermStructure>,
projection_curve: Arc<dyn YieldTermStructure>,
) -> Self {
Self {
discount_curve,
projection_curve,
}
}
pub fn discount_curve(&self) -> &dyn YieldTermStructure {
self.discount_curve.as_ref()
}
pub fn projection_curve(&self) -> &dyn YieldTermStructure {
self.projection_curve.as_ref()
}
pub fn fixed_leg_npv(&self, swap: &VanillaSwap, as_of: Date) -> f64 {
let dc_curve = Actual365Fixed;
let ref_date = self.discount_curve.reference_date();
let t_as_of = dc_curve.year_fraction(ref_date, as_of);
let df_as_of = self.discount_curve.discount(t_as_of);
if df_as_of <= 0.0 {
return 0.0;
}
let dates = swap.fixed_schedule().dates();
let mut npv = 0.0;
for i in 1..dates.len() {
let start = dates[i - 1];
let end = dates[i];
if end > as_of {
let tau = swap.fixed_day_counter().year_fraction(start, end);
let coupon = swap.nominal() * swap.fixed_rate() * tau;
let t_end = dc_curve.year_fraction(ref_date, end);
let df = self.discount_curve.discount(t_end);
npv += coupon * (df / df_as_of);
}
}
npv
}
pub fn fixed_leg_annuity(&self, swap: &VanillaSwap, as_of: Date) -> f64 {
let dc_curve = Actual365Fixed;
let ref_date = self.discount_curve.reference_date();
let t_as_of = dc_curve.year_fraction(ref_date, as_of);
let df_as_of = self.discount_curve.discount(t_as_of);
if df_as_of <= 0.0 {
return 0.0;
}
let dates = swap.fixed_schedule().dates();
let mut annuity = 0.0;
for i in 1..dates.len() {
let start = dates[i - 1];
let end = dates[i];
if end > as_of {
let tau = swap.fixed_day_counter().year_fraction(start, end);
let t_end = dc_curve.year_fraction(ref_date, end);
let df = self.discount_curve.discount(t_end);
annuity += tau * (df / df_as_of);
}
}
annuity
}
pub fn floating_leg_npv(&self, swap: &VanillaSwap, as_of: Date) -> f64 {
let dc_curve = Actual365Fixed;
let ref_date = self.discount_curve.reference_date();
let t_as_of = dc_curve.year_fraction(ref_date, as_of);
let df_as_of = self.discount_curve.discount(t_as_of);
if df_as_of <= 0.0 {
return 0.0;
}
let dates = swap.floating_schedule().dates();
let mut npv = 0.0;
for i in 1..dates.len() {
let start = dates[i - 1];
let end = dates[i];
if end > as_of {
let tau = swap.floating_day_counter().year_fraction(start, end);
if tau <= 0.0 {
continue;
}
let t_start = dc_curve.year_fraction(ref_date, start);
let t_end = dc_curve.year_fraction(ref_date, end);
let p_start = self.projection_curve.discount(t_start);
let p_end = self.projection_curve.discount(t_end);
let forward_rate = if p_end > 0.0 {
(p_start / p_end - 1.0) / tau
} else {
0.0
};
let coupon_amount = swap.nominal() * (forward_rate + swap.spread()) * tau;
let df_discount = self.discount_curve.discount(t_end);
npv += coupon_amount * (df_discount / df_as_of);
}
}
npv
}
pub fn calculate_npv(&self, swap: &VanillaSwap, as_of: Date) -> f64 {
let fixed_npv = self.fixed_leg_npv(swap, as_of);
let float_npv = self.floating_leg_npv(swap, as_of);
match swap.swap_type() {
SwapType::Payer => float_npv - fixed_npv,
SwapType::Receiver => fixed_npv - float_npv,
}
}
pub fn fair_rate(&self, swap: &VanillaSwap, as_of: Date) -> f64 {
let float_npv = self.floating_leg_npv(swap, as_of);
let annuity = self.fixed_leg_annuity(swap, as_of);
if annuity <= 1e-12 {
0.0
} else {
float_npv / (swap.nominal() * annuity)
}
}
}