use crate::termstructures::yield_term_structure::YieldTermStructure;
use crate::time::date::Date;
use thiserror::Error;
#[derive(Debug, Clone, PartialEq, Error)]
pub enum CurveError {
#[error("Dimension mismatch: {times_len} times vs {values_len} values")]
DimensionMismatch {
times_len: usize,
values_len: usize,
},
#[error("Times must be strictly increasing and start at 0.0")]
NonMonotonicTimes,
#[error("Discount factor at index {0} must be positive, got {1}")]
NonPositiveDiscount(usize, f64),
}
#[derive(Debug, Clone)]
pub struct InterpolatedDiscountCurve {
times: Vec<f64>,
discounts: Vec<f64>,
log_discounts: Vec<f64>,
reference_date: Date,
}
impl InterpolatedDiscountCurve {
pub fn new(
times: Vec<f64>,
discounts: Vec<f64>,
reference_date: Date,
) -> Result<Self, CurveError> {
let n = times.len();
if n != discounts.len() {
return Err(CurveError::DimensionMismatch {
times_len: n,
values_len: discounts.len(),
});
}
if n < 2 || times[0] != 0.0 || discounts[0] != 1.0 {
return Err(CurveError::NonMonotonicTimes);
}
for i in 1..n {
if times[i] <= times[i - 1] {
return Err(CurveError::NonMonotonicTimes);
}
if discounts[i] <= 0.0 {
return Err(CurveError::NonPositiveDiscount(i, discounts[i]));
}
}
let log_discounts: Vec<f64> = discounts.iter().map(|&d| d.ln()).collect();
Ok(Self {
times,
discounts,
log_discounts,
reference_date,
})
}
pub fn times(&self) -> &[f64] {
&self.times
}
pub fn discounts(&self) -> &[f64] {
&self.discounts
}
}
impl YieldTermStructure for InterpolatedDiscountCurve {
#[inline]
fn reference_date(&self) -> Date {
self.reference_date
}
fn discount(&self, t: f64) -> f64 {
if t <= 0.0 {
return 1.0;
}
let n = self.times.len();
if t >= self.times[n - 1] {
let t_last = self.times[n - 1];
let t_prev = self.times[n - 2];
let f_last =
(self.log_discounts[n - 2] - self.log_discounts[n - 1]) / (t_last - t_prev);
return (self.log_discounts[n - 1] - f_last * (t - t_last)).exp();
}
let idx = self.times.partition_point(|&val| val <= t);
let i = if idx == 0 { 0 } else { idx - 1 };
let t0 = self.times[i];
let t1 = self.times[i + 1];
let l0 = self.log_discounts[i];
let l1 = self.log_discounts[i + 1];
let ratio = (t - t0) / (t1 - t0);
let log_d = l0 + ratio * (l1 - l0);
log_d.exp()
}
fn zero_rate(&self, t: f64) -> f64 {
if t <= 1e-6 {
let dt = self.times[1] - self.times[0];
-(self.log_discounts[1] - self.log_discounts[0]) / dt
} else {
let d = self.discount(t);
-d.ln() / t
}
}
}