timevalue/

lib.rs

#![deny(rust_2018_idioms)]
#![deny(unused)]

pub trait AnnuityRegular {
    type Output;
    type Error;

    fn present_value(self) -> Result<Self::Output, Self::Error>;
    fn future_value(self) -> Result<Self::Output, Self::Error>;
}
pub trait AnnuityDue {
    type Output;
    type Error;

    fn present_value(self) -> Result<Self::Output, Self::Error>;
    fn future_value(self) -> Result<Self::Output, Self::Error>;
}

#[cfg(not(feature = "rust_decimal"))]
type F64 = f64;

#[cfg(feature = "rust_decimal")]
use rust_decimal::dec;
#[cfg(feature = "rust_decimal")]
type F64 = rust_decimal::Decimal;

#[cfg(feature = "rust_decimal")]
use rust_decimal::MathematicalOps;

#[derive(PartialEq, Eq, Debug)]
pub enum TimeValueError {
    EmptyCashFlow,
    NegativeDiscount,
}

#[derive(Clone, Copy)]
pub struct Annuity<T, I>
where
    I: IntoIterator<Item = T>,
    T: Into<F64> + Copy,
{
    cashflows: I,
    rate: F64,
}

impl<T, I> Annuity<T, I>
where
    I: IntoIterator<Item = T>,
    T: Into<F64> + Copy,
{
    pub fn new(cashflows: I, rate: impl Into<F64>) -> Self {
        Self {
            cashflows,
            rate: rate.into(),
        }
    }
}

#[cfg(not(feature = "rust_decimal"))]
const ZERO: F64 = 0.0;

#[cfg(feature = "rust_decimal")]
const ZERO: F64 = dec!(0.0);

#[cfg(not(feature = "rust_decimal"))]
const ONE: F64 = 1.0;

#[cfg(feature = "rust_decimal")]
const ONE: F64 = dec!(1.0);

impl<T, I> AnnuityRegular for Annuity<T, I>
where
    I: IntoIterator<Item = T>,
    T: Into<F64> + Copy,
{
    type Output = F64;

    type Error = TimeValueError;

    fn present_value(self) -> Result<Self::Output, Self::Error> {
        if self.rate < ZERO {
            return Err(TimeValueError::NegativeDiscount);
        }

        let mut is_empty = true;
        let mut sum = ZERO;

        for (n, cf) in self.cashflows.into_iter().enumerate() {
            is_empty = false;
            let val: F64 = cf.into();

            #[cfg(not(feature = "rust_decimal"))]
            let exp: i32 = n as i32 + 1;

            #[cfg(feature = "rust_decimal")]
            let exp: i64 = n as i64 + 1;

            let disc = val / (ONE + self.rate).powi(exp);
            sum += disc;
        }

        if is_empty {
            return Err(TimeValueError::EmptyCashFlow);
        }

        Ok(sum)
    }

    fn future_value(self) -> Result<Self::Output, Self::Error> {
        if self.rate < ZERO {
            return Err(TimeValueError::NegativeDiscount);
        }

        let cash_flows: Vec<_> = self.cashflows.into_iter().map(|i| i.into()).collect();
        if cash_flows.is_empty() {
            return Err(TimeValueError::EmptyCashFlow);
        }

        let mut f: Vec<_> = cash_flows
            .iter()
            .enumerate()
            .map(|(n, &cash_flow)| {
                #[cfg(not(feature = "rust_decimal"))]
                let exp: i32 = n as i32 + 1;

                #[cfg(feature = "rust_decimal")]
                let exp: i64 = n as i64 + 1;

                cash_flow * (ONE + self.rate).powi(exp)
            })
            .collect();
        f.pop();

        if let Some(value) = cash_flows.last() {
            f.push(*value);
        }
        let future_value = f.iter().sum::<F64>();

        Ok(future_value)
    }
}

impl<T, I> AnnuityDue for Annuity<T, I>
where
    I: IntoIterator<Item = T>,
    T: Into<F64> + Copy,
{
    type Output = F64;

    type Error = TimeValueError;

    fn present_value(self) -> Result<Self::Output, Self::Error> {
        let rate = self.rate;
        let pv = <Self as AnnuityRegular>::present_value(self)?;

        Ok(pv * (ONE + rate))
    }

    fn future_value(self) -> Result<Self::Output, Self::Error> {
        if self.rate < ZERO {
            return Err(TimeValueError::NegativeDiscount);
        }
        let cash_flows: Vec<_> = self.cashflows.into_iter().map(|i| i.into()).collect();
        if cash_flows.is_empty() {
            return Err(TimeValueError::EmptyCashFlow);
        }

        let future_value = cash_flows
            .iter()
            .enumerate()
            .map(|(i, &cash_flow)| {
                #[cfg(not(feature = "rust_decimal"))]
                let exp: i32 = i as i32 + 1;

                #[cfg(feature = "rust_decimal")]
                let exp: i64 = i as i64 + 1;

                cash_flow * (ONE + self.rate).powi(exp)
            })
            .sum();

        Ok(future_value)
    }
}

#[cfg(test)]
mod tests {

    use super::*;

    macro_rules! f64 {
        ($val:literal) => {{
            #[cfg(not(feature = "rust_decimal"))]
            {
                $val as f64
            }
            #[cfg(feature = "rust_decimal")]
            {
                dec!($val)
            }
        }};
    }

    #[test]
    fn annuity_pv() {
        let rate = f64!(0.12);

        let f = Annuity::new(
            [
                5_000, 5_000, 5_000, 5_000, 5_000, 5_000, 5_000, 5_000, 5_000, 5_000,
            ],
            rate,
        );

        let pv = super::AnnuityRegular::present_value(f).unwrap();

        #[cfg(not(feature = "rust_decimal"))]
        let exp: F64 = 28251.115142054317;

        #[cfg(feature = "rust_decimal")]
        let exp: F64 = dec!(28251.115142054324467040310164);

        #[cfg(feature = "rust_decimal")]
        assert_eq!(pv, exp); // Decimal is precise, assert_eq is fine

        #[cfg(not(feature = "rust_decimal"))]
        assert!(
            (pv - exp).abs() < f64::EPSILON,
            "Left: {}, Right: {}",
            pv,
            exp
        );
    }
    #[test]
    fn annuity_pv_due() {
        let f = Annuity::new([5_000].repeat(10), f64!(0.12));
        let pv = super::AnnuityDue::present_value(f).unwrap();

        #[cfg(not(feature = "rust_decimal"))]
        assert_eq!(pv, f64!(31641.248959100838));

        #[cfg(feature = "rust_decimal")]
        assert_eq!(pv, f64!(31641.248959100843403085147384));
    }
    #[test]
    fn annuity_fv_reg() {
        #[cfg(not(feature = "rust_decimal"))]
        let rate: F64 = 0.09;

        #[cfg(feature = "rust_decimal")]
        let rate: F64 = dec!(0.09);

        let f = Annuity::new([50_000].repeat(7), rate);
        let pv = super::AnnuityRegular::future_value(f).unwrap();

        #[cfg(not(feature = "rust_decimal"))]
        let exp: F64 = 460021.7337870501;

        #[cfg(feature = "rust_decimal")]
        let exp: F64 = dec!(460021.733787050000);

        assert_eq!(pv, exp);
    }

    #[test]
    fn annuity_fv_due() {
        let f = Annuity::new(
            [
                200_000, 200_000, 200_000, 200_000, 200_000, 200_000, 200_000,
            ],
            f64!(0.12),
        );
        let pv = super::AnnuityDue::future_value(f).unwrap();

        #[cfg(not(feature = "rust_decimal"))]
        assert_eq!(pv, f64!(2259938.6271580164));

        #[cfg(feature = "rust_decimal")]
        assert_eq!(pv, f64!(2259938.62715801600000));
    }
}