use crate::termstructures::interpolated_discount_curve::{CurveError, InterpolatedDiscountCurve};
use crate::termstructures::yield_term_structure::YieldTermStructure;
use crate::time::calendar::{BusinessDayConvention, Calendar};
use crate::time::date::{Date, Period};
use crate::time::day_counter::DayCounter;
use crate::time::day_counters::actual_365_fixed::Actual365Fixed;
use std::sync::Arc;
pub trait RateHelper: Send + Sync {
fn maturity_date(&self) -> Date;
fn solve_discount_factor(&self, ref_date: Date, curve: &InterpolatedDiscountCurve) -> f64;
}
#[derive(Clone)]
pub struct DepositRateHelper {
rate: f64,
maturity: Date,
day_counter: Arc<dyn DayCounter>,
}
impl DepositRateHelper {
pub fn new(rate: f64, maturity: Date, day_counter: Arc<dyn DayCounter>) -> Self {
Self {
rate,
maturity,
day_counter,
}
}
}
impl RateHelper for DepositRateHelper {
#[inline]
fn maturity_date(&self) -> Date {
self.maturity
}
fn solve_discount_factor(&self, ref_date: Date, _curve: &InterpolatedDiscountCurve) -> f64 {
let tau = self.day_counter.year_fraction(ref_date, self.maturity);
1.0 / (1.0 + self.rate * tau)
}
}
#[derive(Clone)]
pub struct SwapRateHelper {
rate: f64,
maturity: Date,
fixed_dates: Vec<Date>,
day_counter: Arc<dyn DayCounter>,
}
impl SwapRateHelper {
pub fn new(
rate: f64,
maturity: Date,
fixed_dates: Vec<Date>,
day_counter: Arc<dyn DayCounter>,
) -> Self {
Self {
rate,
maturity,
fixed_dates,
day_counter,
}
}
pub fn from_tenor<C: Calendar>(
rate: f64,
ref_date: Date,
tenor: Period,
frequency_months: i64,
calendar: &C,
convention: BusinessDayConvention,
day_counter: Arc<dyn DayCounter>,
) -> Self {
let maturity = calendar
.advance(ref_date, tenor, convention, false)
.expect("Valid advance");
let mut fixed_dates = Vec::new();
let mut step = 1;
loop {
let next_date = calendar
.advance(
ref_date,
Period::Months(frequency_months * step),
convention,
false,
)
.expect("Valid advance");
if next_date >= maturity {
fixed_dates.push(maturity);
break;
}
fixed_dates.push(next_date);
step += 1;
}
Self {
rate,
maturity,
fixed_dates,
day_counter,
}
}
}
impl RateHelper for SwapRateHelper {
#[inline]
fn maturity_date(&self) -> Date {
self.maturity
}
fn solve_discount_factor(&self, ref_date: Date, curve: &InterpolatedDiscountCurve) -> f64 {
let n = self.fixed_dates.len();
if n == 0 {
return 1.0;
}
let dc_curve = Actual365Fixed;
let mut prev_date = ref_date;
let mut accrued_sum_prev = 0.0;
for &d in &self.fixed_dates[..n - 1] {
let tau = self.day_counter.year_fraction(prev_date, d);
let t_curve = dc_curve.year_fraction(ref_date, d);
let df = curve.discount(t_curve);
accrued_sum_prev += tau * df;
prev_date = d;
}
let tau_last = self.day_counter.year_fraction(prev_date, self.maturity);
let numerator = 1.0 - self.rate * accrued_sum_prev;
let denominator = 1.0 + self.rate * tau_last;
(numerator / denominator).max(1e-6)
}
}
pub struct PiecewiseYieldCurve;
impl PiecewiseYieldCurve {
pub fn bootstrap(
ref_date: Date,
mut helpers: Vec<Box<dyn RateHelper>>,
) -> Result<InterpolatedDiscountCurve, CurveError> {
if helpers.is_empty() {
return Err(CurveError::NonMonotonicTimes);
}
helpers.sort_by_key(|h| h.maturity_date());
let dc_curve = Actual365Fixed;
let mut times = vec![0.0];
let mut discounts = vec![1.0];
for helper in helpers {
let mat = helper.maturity_date();
let t = dc_curve.year_fraction(ref_date, mat);
if t <= *times.last().unwrap() {
continue; }
let df = if times.len() >= 2 {
let temp_curve =
InterpolatedDiscountCurve::new(times.clone(), discounts.clone(), ref_date)?;
helper.solve_discount_factor(ref_date, &temp_curve)
} else {
let dummy_times = vec![0.0, t];
let dummy_discounts = vec![1.0, 1.0];
let temp_curve =
InterpolatedDiscountCurve::new(dummy_times, dummy_discounts, ref_date)?;
helper.solve_discount_factor(ref_date, &temp_curve)
};
times.push(t);
discounts.push(df);
}
InterpolatedDiscountCurve::new(times, discounts, ref_date)
}
}