use crate::cashflows::coupon::FixedRateCoupon;
use crate::cashflows::leg::Leg;
use crate::cashflows::simple::SimpleCashFlow;
use crate::math::solvers::{NewtonRaphson, SolverError};
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::schedule::Schedule;
use std::sync::Arc;
use thiserror::Error;
#[derive(Debug, Clone, PartialEq, Error)]
pub enum BondError {
#[error("Yield to maturity calculation failed to converge: {0}")]
YtmConvergence(#[from] SolverError),
#[error("Bond has already matured at {maturity} on settlement {settlement}")]
AlreadyMatured {
maturity: Date,
settlement: Date,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum DurationType {
Macaulay,
#[default]
Modified,
}
#[derive(Clone)]
pub struct FixedRateBond {
settlement_days: u32,
face_amount: f64,
schedule: Schedule,
coupon_rate: f64,
day_counter: Arc<dyn DayCounter>,
calendar: Arc<dyn Calendar>,
issue_date: Date,
redemption: f64,
leg: Leg,
}
impl FixedRateBond {
#[allow(clippy::too_many_arguments)]
pub fn new(
settlement_days: u32,
face_amount: f64,
schedule: Schedule,
coupon_rate: f64,
day_counter: Arc<dyn DayCounter>,
calendar: Arc<dyn Calendar>,
issue_date: Date,
redemption: f64,
) -> Self {
let mut leg = Leg::new();
let dates = schedule.dates();
for i in 1..dates.len() {
let start = dates[i - 1];
let end = dates[i];
let coupon = FixedRateCoupon::new(
face_amount,
coupon_rate,
end,
start,
end,
day_counter.clone(),
);
leg.push(Arc::new(coupon));
}
if let Some(&maturity) = dates.last() {
leg.push(Arc::new(SimpleCashFlow::new(redemption, maturity)));
}
Self {
settlement_days,
face_amount,
schedule,
coupon_rate,
day_counter,
calendar,
issue_date,
redemption,
leg,
}
}
pub fn settlement_date(&self, as_of: Date) -> Date {
if self.settlement_days == 0 {
as_of
} else {
self.calendar
.advance(
as_of,
Period::Days(self.settlement_days as i64),
BusinessDayConvention::Following,
false,
)
.unwrap_or(as_of + self.settlement_days as i64)
}
}
pub fn maturity_date(&self) -> Date {
*self
.schedule
.dates()
.last()
.expect("Bond schedule has dates")
}
pub fn leg(&self) -> &Leg {
&self.leg
}
pub fn face_amount(&self) -> f64 {
self.face_amount
}
pub fn issue_date(&self) -> Date {
self.issue_date
}
pub fn coupon_rate(&self) -> f64 {
self.coupon_rate
}
pub fn accrued_amount(&self, settlement_date: Date) -> f64 {
let dates = self.schedule.dates();
if settlement_date <= dates[0] || settlement_date >= *dates.last().unwrap() {
return 0.0;
}
for i in 1..dates.len() {
let start = dates[i - 1];
let end = dates[i];
if settlement_date >= start && settlement_date <= end {
if settlement_date == start || settlement_date == end {
return 0.0;
}
let tau = self.day_counter.year_fraction(start, settlement_date);
return self.face_amount * self.coupon_rate * tau;
}
}
0.0
}
pub fn dirty_price(
&self,
curve: &dyn YieldTermStructure,
as_of: Date,
) -> Result<f64, BondError> {
let settle = self.settlement_date(as_of);
if settle >= self.maturity_date() {
return Err(BondError::AlreadyMatured {
maturity: self.maturity_date(),
settlement: settle,
});
}
let mut npv = 0.0;
for cf in self.leg.cash_flows() {
if cf.date() > settle {
let tau = self.day_counter.year_fraction(settle, cf.date());
let df = curve.discount(tau);
npv += cf.amount() * df;
}
}
Ok(npv)
}
pub fn clean_price(
&self,
curve: &dyn YieldTermStructure,
as_of: Date,
) -> Result<f64, BondError> {
let dirty = self.dirty_price(curve, as_of)?;
let settle = self.settlement_date(as_of);
let accrued = self.accrued_amount(settle);
Ok(dirty - accrued)
}
pub fn dirty_price_from_yield(
&self,
ytm: f64,
as_of: Date,
frequency: u32,
) -> Result<f64, BondError> {
let settle = self.settlement_date(as_of);
if settle >= self.maturity_date() {
return Err(BondError::AlreadyMatured {
maturity: self.maturity_date(),
settlement: settle,
});
}
let m = frequency as f64;
let mut dirty = 0.0;
for cf in self.leg.cash_flows() {
if cf.date() > settle {
let tau = self.day_counter.year_fraction(settle, cf.date());
dirty += cf.amount() / (1.0 + ytm / m).powf(m * tau);
}
}
Ok(dirty)
}
pub fn clean_price_from_yield(
&self,
ytm: f64,
as_of: Date,
frequency: u32,
) -> Result<f64, BondError> {
let dirty = self.dirty_price_from_yield(ytm, as_of, frequency)?;
let settle = self.settlement_date(as_of);
let accrued = self.accrued_amount(settle);
Ok(dirty - accrued)
}
pub fn yield_to_maturity(
&self,
clean_price: f64,
as_of: Date,
frequency: u32,
tolerance: f64,
max_iter: usize,
) -> Result<f64, BondError> {
let settle = self.settlement_date(as_of);
let target_dirty = clean_price + self.accrued_amount(settle);
let m = frequency as f64;
let mut future_cfs = Vec::new();
for cf in self.leg.cash_flows() {
if cf.date() > settle {
let tau = self.day_counter.year_fraction(settle, cf.date());
future_cfs.push((cf.amount(), tau));
}
}
let pv_fn = |y: f64| -> f64 {
let mut sum = 0.0;
for &(amount, tau) in &future_cfs {
sum += amount / (1.0 + y / m).powf(m * tau);
}
sum - target_dirty
};
let dpv_fn = |y: f64| -> f64 {
let mut sum = 0.0;
for &(amount, tau) in &future_cfs {
sum += -tau * amount / (1.0 + y / m).powf(m * tau + 1.0);
}
sum
};
let initial_guess = (self.coupon_rate
+ (self.redemption - clean_price) / future_cfs.last().unwrap().1)
/ (0.5 * (self.redemption + clean_price));
let ytm = NewtonRaphson::solve(
pv_fn,
dpv_fn,
-0.20,
1.0,
initial_guess.clamp(-0.10, 0.50),
tolerance,
max_iter,
)?;
Ok(ytm)
}
pub fn duration(
&self,
ytm: f64,
as_of: Date,
frequency: u32,
duration_type: DurationType,
) -> Result<f64, BondError> {
let settle = self.settlement_date(as_of);
let m = frequency as f64;
let mut pv_sum = 0.0;
let mut weighted_time_sum = 0.0;
for cf in self.leg.cash_flows() {
if cf.date() > settle {
let tau = self.day_counter.year_fraction(settle, cf.date());
let df = (1.0 + ytm / m).powf(-m * tau);
let pv = cf.amount() * df;
pv_sum += pv;
weighted_time_sum += tau * pv;
}
}
let macaulay = weighted_time_sum / pv_sum;
match duration_type {
DurationType::Macaulay => Ok(macaulay),
DurationType::Modified => Ok(macaulay / (1.0 + ytm / m)),
}
}
pub fn convexity(&self, ytm: f64, as_of: Date, frequency: u32) -> Result<f64, BondError> {
let settle = self.settlement_date(as_of);
let m = frequency as f64;
let mut pv_sum = 0.0;
let mut weighted_convexity_sum = 0.0;
for cf in self.leg.cash_flows() {
if cf.date() > settle {
let tau = self.day_counter.year_fraction(settle, cf.date());
let df = (1.0 + ytm / m).powf(-m * tau);
let pv = cf.amount() * df;
pv_sum += pv;
weighted_convexity_sum += tau * (tau + 1.0 / m) * pv;
}
}
let factor = (1.0 + ytm / m).powi(2);
Ok(weighted_convexity_sum / (pv_sum * factor))
}
pub fn dv01(&self, ytm: f64, as_of: Date, frequency: u32) -> Result<f64, BondError> {
let mod_dur = self.duration(ytm, as_of, frequency, DurationType::Modified)?;
let settle = self.settlement_date(as_of);
let dirty = {
let m = frequency as f64;
let mut sum = 0.0;
for cf in self.leg.cash_flows() {
if cf.date() > settle {
let tau = self.day_counter.year_fraction(settle, cf.date());
sum += cf.amount() * (1.0 + ytm / m).powf(-m * tau);
}
}
sum
};
Ok(dirty * mod_dur * 0.0001)
}
}