finance_solution/tvm/

future_value.rs

//! **Future value calculations.** Given an initial investment amount, a number of periods such as
//! periods, and fixed or varying interest rates, what is the value of the investment at the end?
//!
//! For most common usages, we recommend the [future_value_solution](./fn.future_value_solution.html) function, which provides a better debugging experience and additional features.
//!
//! For more complex scenarios, which involve varying rates in each period, we recommend the [future_value_schedule_solution](./fn.future_value_schedule_solution.html) function.
//!
//! To simply return an f64 value of the future value answer, use the [future_value](./fn.future_value.html) function.
//!
// ! If you need to calculate the present value given a future value, a number of periods, and one
// ! or more rates use [`present_value`] or related functions.
// !
// ! If you need to calculate a fixed rate given a present value, future value, and number of periods
// ! use [`rate`] or related functions.
// !
// ! If you need to calculate the number of periods given a fixed rate and a present and future value
// ! use [`periods`] or related functions.
//!
//! ## Example
//!
//! ```
//! let (rate, periods, present_value, continuous_compounding) = (0.034, 10, 1_000, false);
//! let fv = finance_solution::future_value_solution(rate, periods, present_value, continuous_compounding).unwrap();
//! dbg!(fv);
//! ```
//! Outputs to terminal:
//! ```text
//! {
//!     calculated_field: FutureValue,
//!     continuous_compounding: false,
//!     rate: 0.034,
//!     periods: 10,
//!     fractional_periods: 10.0,
//!     present_value: 1000.0,
//!     future_value: 1397.0288910795477,
//!     formula: "1397.0289 = 1000.0000 * (1.034000 ^ 10)",
//!     symbolic_formula: "fv = pv * (1 + r)^n",
//! }
//! ```
//! # Formulas
//!
//! ## Simple Compounding
//!
//! With simple compound interest, the future value is calculated with:
//!
//! > <img src="http://i.upmath.me/svg/future%5C_value%20%3D%20present%5C_value%20%5Ctimes%20(1%2Brate)%5E%7Bperiods%7D" />
//!
//! Or with some more commonly-used variable names:
//!
//! > <img src="http://i.upmath.me/svg/fv%20%3D%20pv%20%5Ctimes%20(1%2Br)%5En" />
//!
//! `n` is often used for the number of periods, though it may be `t` for time if each period is
//! assumed to be one year as in continuous compounding. `r` is the periodic rate, though this may
//! appear as `i` for interest.
//!
//! Throughout this crate we use `pv` for present value and `fv` for future value. You may see these
//! values called `P` for principal in some references.
//!
//! Within the [TvmSolution](./struct.TvmSolution.html) struct we record the formula used for the particular calculation
//! using both concrete values and symbols. For example with $1,000 growing at 3.5% per period for
//! 12 periods using simple compounding the struct contains these fields:
//! ```text
//! formula: "1511.0687 = 1000.0000 * (1.035000 ^ 12)",
//! symbolic_formula: "fv = pv * (1 + r)^n",
//! ```
//!
//! ## Continuous Compounding
//!
//! With continuous compounding the formula is:
//!
//! > <img src="http://i.upmath.me/svg/future%5C_value%20%3D%20%7Bpresent%5C_value%20%5Ctimes%20e%5E%7Brate%20%5Ctimes%20periods%7D" />
//!
//! or:
//!
//! > <img src="http://i.upmath.me/svg/fv%20%3D%20pv%20%5Ctimes%20e%5E%7Br%20%5Ctimes%20n%7D" />
//!
//! With continuous compounding the period is assumed to be years and `t` (time) is often used as
//! the variable name. Within this crate we stick with `n` for the number of periods so that it's
//! easier to compare formulas when they're printed as simple text as part of the [TvmSolution](./struct.TvmSolution.html)
//! struct. For example with $1,000 growing at 3.5% per period for 12 periods using continuous
//! compounding the struct contains these fields:
//! ```text
//! formula: "1521.9616 = 1000.0000 * 2.718282^(0.035000 * 12)",
//! symbolic_formula: "fv = pv * e^(rt)",
//! ```
//! This is the same as the example in the previous section except that it uses continuous
//! compounding.
use log::warn;

use super::tvm::*;

#[allow(unused_imports)]
use crate::{periods::*, present_value::*, rate::*};

/// Returns the value of an investment after it has grown or shrunk over time, using a fixed rate.
///
/// See the [future_value](./index.html) module page for the formulas.
///
/// Related functions:
/// * To calculate a future value with a fixed rate and return a struct that shows the formula and
/// optionally produces the the period-by-period values use [`future_value_solution`].
/// * To calculate the future value if the rates vary by period use [`future_value_schedule`] or
/// [`future_value_schedule_solution`].
///
/// # Arguments
/// * `rate` - The rate at which the investment grows or shrinks per period, expressed as a
/// floating point number. For instance 0.05 would mean 5% growth. Often appears as `r` or `i` in
/// formulas.
/// * `periods` - The number of periods such as quarters or periods. Often appears as `n` or `t`.
/// * `present_value` - The starting value of the investment. May appear as `pv` in formulas, or `C`
/// for cash flow or `P` for principal.
/// * `continuous_compounding` - True for continuous compounding, false for simple compounding.
///
/// # Errors
/// The call returns [`FinanceError`] if `rate` is less than -1.0 as this would mean the investment is
/// losing more than its full value every period.
///
/// # Examples
/// Investment that grows quarter by quarter.
/// ```
/// use finance_solution::*;
///
/// // The investment grows by 3.4% per quarter.
/// let rate = 0.034;
///
/// // The investment will grow for 5 quarters.
/// let periods = 5;
///
/// // The initial investment is $250,000.
/// let present_value = -250_000;
///
/// let continuous_compounding = false;
///
/// let future_value = future_value(rate, periods, present_value, continuous_compounding).unwrap();
/// // Confirm that the future value is correct to four decimal places (one
/// // hundredth of a cent).
/// assert_rounded_4(295_489.9418, future_value);
/// ```
/// Investment that loses money each year.
/// ```
/// # use finance_solution::*;
/// // The investment loses 5% per year.
/// let rate = -0.05;
///
/// // The investment will shrink for 6 periods.
/// let periods = 6;
///
/// // The initial investment is $10,000.75.
/// let present_value = -10_000.75;
///
/// let continuous_compounding = false;
///
/// let future_value = future_value(rate, periods, present_value, continuous_compounding).unwrap();
/// // Confirm that the future value is correct to the penny.
/// assert_rounded_2(7351.47, future_value);
/// ```
/// Error case: rate less than −100% per period is outside the domain.
/// ```
/// # use finance_solution::{future_value, FinanceError};
/// let err = future_value(-1.05, 6, 10_000.75, false).unwrap_err();
/// assert!(matches!(err, FinanceError::InvalidRate { .. }));
/// ```
///
/// # Errors
/// Returns [`FinanceError::InvalidRate`] if `rate < -1.0`, or [`FinanceError::NonFinite`]
/// if inputs or the computed result are not finite.
///
/// # Examples
/// ```
/// use finance_solution::{future_value, FinanceError, FinanceResult};
///
/// match future_value(0.05, 10, -1_000.0, false) {
///     Ok(fv) => assert!(fv > 0.0),
///     Err(FinanceError::InvalidRate { rate }) => panic!("unexpected bad rate {rate}"),
///     Err(e) => panic!("{e}"),
/// }
///
/// assert!(matches!(
///     future_value(-1.5, 10, 1000.0, false),
///     Err(FinanceError::InvalidRate { .. })
/// ));
///
/// fn project(pv: f64, years: u32) -> FinanceResult<f64> {
///     future_value(0.07, years, pv, false)
/// }
/// assert!(project(-5_000.0, 5).is_ok());
/// ```
pub fn future_value<T, C>(
    rate: f64,
    periods: u32,
    present_value: T,
    compounding: C,
) -> crate::FinanceResult<f64>
where
    T: Into<f64> + Copy,
    C: Into<crate::Compounding>,
{
    future_value_internal(
        rate,
        periods as f64,
        present_value.into(),
        compounding.into().is_continuous(),
    )
}

/// Calculates the value of an investment after it has grown or shrunk over time and returns a
/// struct with the inputs and the calculated value. This is used for keeping track of a collection
/// of financial scenarios so that they can be examined later.
///
/// See the [future_value](./index.html) module page for the formulas.
///
/// Related functions:
/// * For simply calculating a single future value using a fixed rate use [`future_value`].
/// * To calculate the future value if the rates vary by period use [`future_value_schedule`].
/// * To calculate the future value with varying rates and return a struct that can produce the
/// period-by-period values use [`future_value_schedule_solution`].
///
/// # Arguments
/// * `rate` - The rate at which the investment grows or shrinks per period, expressed as a
/// floating point number. For instance 0.05 would mean 5% growth. Often appears as `r` or `i` in
/// formulas.
/// * `periods` - The number of periods such as quarters or periods. Often appears as `n` or `t`.
/// * `present_value` - The starting value of the investment. May appear as `pv` in formulas, or `C`
/// for cash flow or `P` for principal.
/// * `continuous_compounding` - True for continuous compounding, false for simple compounding.
///
/// # Errors
/// Same domain rules as [`future_value`]: invalid rate or non-finite inputs yield
/// [`crate::FinanceError`].
///
/// # Examples
/// Calculate a future value and examine the period-by-period values.
/// ```
/// use finance_solution::*;
/// // The rate is 1.2% per month.
/// let rate = 0.012;
///
/// // The investment will grow for 8 months.
/// let periods = 8;
///
/// // The initial investment is $200,000.
/// let present_value = -200_000.0;
///
/// let continuous_compounding = false;
///
/// let solution = future_value_solution(rate, periods, present_value, continuous_compounding).unwrap();
/// dbg!(&solution);
///
/// let future_value = solution.future_value();
/// assert_rounded_4(future_value, 220_026.0467);
///
/// // Examine the formulas.
/// let formula = solution.formula();
/// dbg!(&formula);
/// assert_eq!(formula, "220026.0467 = 200000.0000 * (1.012000 ^ 8)");
/// let symbolic_formula = solution.symbolic_formula();
/// dbg!(&symbolic_formula);
/// assert_eq!(symbolic_formula, "fv = -pv * (1 + r)^n");
///
/// // Calculate the value at the end of each period.
/// let series = solution.series();
/// dbg!(&series);
/// ```
/// Create a collection of future value calculations ranging over several interest rates.
/// ```
/// # use finance_solution::*;
///
/// // The initial investment is $100,000.
/// let present_value = -100_000.0;
///
/// // The investment will grow for 12 periods.
/// let periods = 12;
///
/// let continuous_compounding = false;
///
/// // We'll keep a collection of the calculated future values along with their inputs.
/// let mut scenarios = vec![];
///
/// for i in 2..=15 {
///     // The rate is between 2% and 15% per year.
///     let rate = f64::from(i) / 100.0;
///     // Calculate the future value for this periodic rate and add the details to the collection.
///     scenarios.push(future_value_solution(rate, periods, present_value, continuous_compounding).unwrap());
/// }
/// dbg!(&scenarios);
/// assert_eq!(14, scenarios.len());
///
/// // Keep only the scenarios where the future value was between $200,000 and $400,000.
/// scenarios.retain(|x| x.future_value() >= 200_000.00 && x.future_value() <= 400_000.00);
/// dbg!(&scenarios);
/// assert_eq!(7, scenarios.len());
///
/// // Check the formulas for the first of the remainingc scenarios.
/// let formula = scenarios[0].formula();
/// dbg!(&formula);
/// assert_eq!("201219.6472 = 100000.0000 * (1.060000 ^ 12)", formula);
/// let symbolic_formula = scenarios[0].symbolic_formula();
/// dbg!(&symbolic_formula);
/// assert_eq!("fv = -pv * (1 + r)^n", symbolic_formula);
/// ```
pub fn future_value_solution<T, C>(
    rate: f64,
    periods: u32,
    present_value: T,
    compounding: C,
) -> crate::FinanceResult<TvmSolution>
where
    T: Into<f64> + Copy,
    C: Into<crate::Compounding>,
{
    future_value_solution_internal(
        rate,
        periods as f64,
        present_value.into(),
        compounding.into().is_continuous(),
    )
}

/// Calculates a future value based on rates that change for each period.
///
/// Related functions:
/// * To calculate the future value with varying rates and return a struct that can produce the
/// period-by-period values use [`future_value_schedule_solution`].
/// * If there is a single fixed rate use [`future_value`] or [`future_value_solution`].
///
/// # Arguments
/// * `rates` - A collection of rates, one for each period.
/// * `present_value` - The starting value of the investment.
///
/// # Errors
/// The call returns [`FinanceError`] if any of the rates is less than -1.0 as this would mean the investment is
/// losing more than its full value.
///
/// # Examples
/// Calculate the value of an investment whose rates vary by year.
/// ```
/// use finance_solution::*;
/// // The rates vary by year: 4% followed by -3.9%, 10.6%, and -5.7%.
/// let rates = [0.04, -0.039, 0.106, -0.057];
///
/// // The initial investment is $75,000.
/// let present_value = -75_000.00;
///
/// let future_value = future_value_schedule(&rates, present_value).unwrap();
/// dbg!(&future_value);
/// assert_rounded_4(78_178.0458, future_value);
/// ```
/// Error case: One of the rates shows a drop of over 100%.
/// ```
/// # use finance_solution::{future_value_schedule, FinanceError};
/// let rates = [0.116, -100.134, -0.09, 0.086];
/// let present_value = -4_000.00;
/// let err = future_value_schedule(&rates, present_value).unwrap_err();
/// assert!(matches!(err, FinanceError::InvalidRate { .. }));
/// ```
///
/// # Errors
/// Returns [`FinanceError::InvalidRate`] if any rate is out of domain, or
/// [`FinanceError::NonFinite`] for non-finite inputs/results.
/// An empty `rates` slice is valid and means zero periods (returns `-present_value`).
pub fn future_value_schedule<T>(rates: &[f64], present_value: T) -> crate::FinanceResult<f64>
where
    T: Into<f64> + Copy,
{
    let present_value = present_value.into();
    crate::util::error::require_rates(rates)?;
    crate::util::error::require_money("present_value", present_value)?;
    let periods = rates.len();

    let mut future_value = -present_value;
    for i in 0..periods {
        future_value *= 1.0 + rates[i];
    }

    if future_value.is_finite() {
        Ok(future_value)
    } else {
        Err(crate::FinanceError::NonFinite {
            field: "future_value",
            value: future_value,
        })
    }
}

/// Calculates a future value based on rates that change for each period, returning a struct with
/// all of the inputs and results.
///
/// Related functions:
/// * For simply calculating a single future value using a fixed rate use [`future_value`].
/// * To calculate a future value with a fixed rate and return a struct that shows the formula and
/// optionally produces the the period-by-period values use [`future_value_solution`].
/// * To calculate the future value if the rates vary by period use [`future_value_schedule`].
///
/// # Arguments
/// * `rates` - A collection of rates, one for each period.
/// * `present_value` - The starting value of the investment.
///
/// # Errors
/// The call returns [`FinanceError`] if any of the rates is less than -1.0 as this would mean the investment is
/// losing more than its full value.
///
/// # Examples
/// Calculate the value of an investment whose rates vary by year.
/// ```
/// use finance_solution::*;
/// // The rates vary by year: 8.1% followed by 11%, 4%, and -2.3%.
/// let rates = [0.081, 0.11, 0.04, -0.023];
///
/// // The initial investment is $10,000.
/// let present_value = -10_000.00;
///
/// let solution = future_value_schedule_solution(&rates, present_value).unwrap();
/// dbg!(&solution);
///
/// let future_value = solution.future_value();
/// dbg!(&future_value);
/// assert_rounded_4(future_value, 12_192.0455);
///
/// // Calculate the value for each period.
/// let series = solution.series();
/// dbg!(&series);
/// ```
pub fn future_value_schedule_solution<T>(
    rates: &[f64],
    present_value: T,
) -> crate::FinanceResult<TvmScheduleSolution>
where
    T: Into<f64> + Copy,
{
    let present_value = present_value.into();
    let future_value = future_value_schedule(rates, present_value)?;
    Ok(TvmScheduleSolution::new(
        TvmVariable::FutureValue,
        rates,
        present_value,
        future_value,
    ))
}

pub(crate) fn future_value_internal(
    rate: f64,
    periods: f64,
    present_value: f64,
    continuous_compounding: bool,
) -> crate::FinanceResult<f64> {
    crate::util::error::require_rate(rate)?;
    crate::util::error::require_money("present_value", present_value)?;
    if rate.abs() > 1.0 {
        warn!(
            "You provided a periodic rate ({}) greater than 1. Are you sure you expect a {}% return?",
            rate,
            rate * 100.0
        );
    }
    let future_value = if continuous_compounding {
        // http://www.edmichaelreggie.com/TMVContent/rate.htm
        -present_value * std::f64::consts::E.powf(rate * periods)
    } else {
        -present_value * (1.0 + rate).powf(periods)
    };
    if future_value.is_finite() {
        Ok(future_value)
    } else {
        Err(crate::FinanceError::NonFinite {
            field: "future_value",
            value: future_value,
        })
    }
}

pub(crate) fn future_value_solution_internal(
    rate: f64,
    periods: f64,
    present_value: f64,
    continuous_compounding: bool,
) -> crate::FinanceResult<TvmSolution> {
    let future_value = future_value_internal(rate, periods, present_value, continuous_compounding)?;
    let (formula, symbolic_formula) = if continuous_compounding {
        let formula = format!(
            "{:.4} = {:.4} * {:.6}^({:.6} * {})",
            future_value,
            -present_value,
            std::f64::consts::E,
            rate,
            periods
        );
        let symbolic_formula = "fv = -pv * e^(rt)";
        (formula, symbolic_formula)
    } else {
        let rate_multiplier = 1.0 + rate;
        let formula = format!(
            "{:.4} = {:.4} * ({:.6} ^ {})",
            future_value, -present_value, rate_multiplier, periods
        );
        let symbolic_formula = "fv = -pv * (1 + r)^n";
        (formula, symbolic_formula)
    };
    Ok(TvmSolution::new_fractional_periods(
        TvmVariable::FutureValue,
        continuous_compounding,
        rate,
        periods,
        present_value,
        future_value,
        &formula,
        symbolic_formula,
    ))
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::initialized_vector;

    #[test]
    fn test_future_value_error_rate_low() {
        assert!(future_value(-101.0, 5, 250_000.00, false).is_err());
    }

    #[test]
    fn test_future_value_solution_6() {
        let rate_of_return = 1.0f64 / 0.0f64;
        let periods = 6;
        let present_value = 5_000.00;
        assert!(future_value_solution(rate_of_return, periods, present_value, false).is_err());
    }

    #[test]
    fn test_future_value_solution_7() {
        let rate_of_return = 0.03;
        let periods = 6;
        let present_value = 1.0f64 / 0.0f64;
        assert!(future_value_solution(rate_of_return, periods, present_value, false).is_err());
    }

    /*
    macro_rules! compare_to_excel {
        ( $r:expr, $n:expr, $pv:expr, $fv_excel:expr, $fv_manual_simple:expr, $fv_manual_cont:expr ) => {
            println!("$r = {}, $n = {}, $pv = {}, $fv_excel: {}, $fv_manual_simple = {}, $fv_manual_cont = {}", $r, $n, $pv, $fv_excel, $fv_manual_simple, $fv_manual_cont);
            assert_approx_equal!($fv_excel, $fv_manual_simple);

            let fv_calc_simple = future_value($r, $n, $pv, false);
            println!("fv_calc_simple = {}", fv_calc_simple);
            assert_approx_equal!($fv_excel, fv_calc_simple);

            let fv_calc_cont = future_value($r, $n, $pv, true);
            println!("fv_calc_cont = {}", fv_calc_cont);
            assert_approx_equal!($fv_manual_cont, fv_calc_cont);

            let ratio = fv_calc_cont / fv_calc_simple;
            println!("ratio = {}", ratio);
            assert!(ratio >= 1.0);
            assert!(ratio < 2.0);
        }
    }
    */

    fn compare_to_excel(
        test_case: usize,
        r: f64,
        n: u32,
        pv: f64,
        fv_excel: f64,
        fv_manual_simple: f64,
        fv_manual_cont: f64,
    ) {
        let display = false;

        if display {
            println!("test_case = {}, r = {}, n = {}, pv = {}, fv_excel: {}, fv_manual_simple = {}, fv_manual_cont = {}", test_case, r, n, pv, fv_excel, fv_manual_simple, fv_manual_cont);
        }
        assert_approx_equal!(fv_excel, fv_manual_simple);

        let fv_calc_simple = future_value(r, n, pv, false).unwrap();
        if display {
            println!("fv_calc_simple = {}", fv_calc_simple)
        };
        assert_approx_equal!(fv_excel, fv_calc_simple);

        let fv_calc_cont = future_value(r, n, pv, true).unwrap();
        if display {
            println!("fv_calc_cont = {}", fv_calc_cont)
        };
        assert_approx_equal!(fv_manual_cont, fv_calc_cont);

        let ratio = fv_calc_cont / fv_calc_simple;
        if display {
            println!("ratio = {}", ratio)
        };
        assert!(ratio >= 1.0);
        assert!(ratio < 2.0);

        // Solution with simple compounding.
        let solution = future_value_solution(r, n, pv, false).unwrap();
        if display {
            dbg!(&solution);
        }
        solution.invariant();
        assert!(solution.calculated_field().is_future_value());
        assert_eq!(false, solution.continuous_compounding());
        assert_approx_equal!(r, solution.rate());
        assert_eq!(n, solution.periods());
        assert_approx_equal!(n as f64, solution.fractional_periods());
        assert_approx_equal!(pv, solution.present_value());
        assert_approx_equal!(fv_excel, solution.future_value());

        // Solution with continuous compounding.
        let solution = future_value_solution(r, n, pv, true).unwrap();
        if display {
            dbg!(&solution);
        }
        solution.invariant();
        assert!(solution.calculated_field().is_future_value());
        assert!(solution.continuous_compounding());
        assert_approx_equal!(r, solution.rate());
        assert_eq!(n, solution.periods());
        assert_approx_equal!(n as f64, solution.fractional_periods());
        assert_approx_equal!(pv, solution.present_value());
        assert_approx_equal!(fv_manual_cont, solution.future_value());

        let rates = initialized_vector(n as usize, r);

        // Schedule solution.
        let solution = future_value_schedule_solution(&rates, pv).unwrap();
        if display {
            dbg!(&solution);
        }
        solution.invariant();
        assert!(solution.calculated_field().is_future_value());
        assert_eq!(n, solution.periods());
        assert_approx_equal!(pv, solution.present_value());
        assert_approx_equal!(fv_excel, solution.future_value());
    }

    #[test]
    fn test_future_value_against_excel() {
        compare_to_excel(
            1,
            0.01f64,
            90,
            1f64,
            -2.44863267464848f64,
            -2.44863267464848f64,
            -2.45960311115695f64,
        );
        compare_to_excel(
            2,
            -0.01f64,
            85,
            -1.5f64,
            0.638385185082981f64,
            0.638385185082981f64,
            0.64112239792309f64,
        );
        compare_to_excel(3, 0f64, 80, 2.25f64, -2.25f64, -2.25f64, -2.25f64);
        compare_to_excel(
            4,
            0.05f64,
            75,
            -3.375f64,
            131.060314992675f64,
            131.060314992675f64,
            143.508651750212f64,
        );
        compare_to_excel(
            5,
            -0.05f64,
            70,
            5.0625f64,
            -0.139642432836174f64,
            -0.139642432836174f64,
            -0.152874253575487f64,
        );
        compare_to_excel(
            6,
            0.01f64,
            65,
            -7.59375f64,
            14.499251769574f64,
            14.499251769574f64,
            14.5461381703243f64,
        );
        compare_to_excel(
            7,
            -0.01f64,
            60,
            11.390625f64,
            -6.23245612973226f64,
            -6.23245612973226f64,
            -6.25130754238352f64,
        );
        compare_to_excel(
            8,
            0f64,
            55,
            -17.0859375f64,
            17.0859375f64,
            17.0859375f64,
            17.0859375f64,
        );
        compare_to_excel(
            9,
            0.05f64,
            50,
            25.62890625f64,
            -293.896914040351f64,
            -293.896914040351f64,
            -312.223995610061f64,
        );
        compare_to_excel(
            10,
            -0.05f64,
            45,
            -38.443359375f64,
            3.82281753569715f64,
            3.82281753569715f64,
            4.05190026767808f64,
        );
        compare_to_excel(
            11,
            0.01f64,
            40,
            57.6650390625f64,
            -85.8553853561044f64,
            -85.8553853561044f64,
            -86.0261294638861f64,
        );
        compare_to_excel(
            12,
            -0.01f64,
            35,
            -86.49755859375f64,
            60.8465082158636f64,
            60.8465082158636f64,
            60.9537993307622f64,
        );
        compare_to_excel(
            13,
            0f64,
            30,
            129.746337890625f64,
            -129.746337890625f64,
            -129.746337890625f64,
            -129.746337890625f64,
        );
        compare_to_excel(
            14,
            0.05f64,
            25,
            -194.619506835937f64,
            659.050728569279f64,
            659.050728569279f64,
            679.288825069511f64,
        );
        compare_to_excel(
            15,
            -0.05f64,
            20,
            291.929260253906f64,
            -104.652530140165f64,
            -104.652530140165f64,
            -107.3947731238f64,
        );
        compare_to_excel(
            16,
            0.01f64,
            15,
            -437.893890380859f64,
            508.381212478371f64,
            508.381212478371f64,
            508.760116525988f64,
        );
        compare_to_excel(
            17,
            -0.01f64,
            12,
            656.840835571289f64,
            -582.213779775772f64,
            -582.213779775772f64,
            -582.56556073855f64,
        );
        compare_to_excel(
            18,
            0f64,
            10,
            -985.261253356933f64,
            985.261253356933f64,
            985.261253356933f64,
            985.261253356933f64,
        );
        compare_to_excel(
            19,
            0.05f64,
            7,
            1477.8918800354f64,
            -2079.54228903805f64,
            -2079.54228903805f64,
            -2097.22840728772f64,
        );
        compare_to_excel(
            20,
            -0.05f64,
            5,
            -2216.8378200531f64,
            1715.34684668614f64,
            1715.34684668614f64,
            1726.47503019966f64,
        );
        compare_to_excel(
            21,
            0.01f64,
            4,
            3325.25673007965f64,
            -3460.27548760037f64,
            -3460.27548760037f64,
            -3460.96303162265f64,
        );
        compare_to_excel(
            22,
            -0.01f64,
            3,
            -4987.88509511947f64,
            4839.73991990933f64,
            4839.73991990933f64,
            4840.47081241187f64,
        );
        compare_to_excel(
            23,
            0f64,
            2,
            7481.82764267921f64,
            -7481.82764267921f64,
            -7481.82764267921f64,
            -7481.82764267921f64,
        );
        compare_to_excel(
            24,
            0.05f64,
            1,
            -11222.7414640188f64,
            11783.8785372198f64,
            11783.8785372198f64,
            11798.1437232237f64,
        );
        compare_to_excel(
            25,
            -0.05f64,
            0,
            16834.1121960282f64,
            -16834.1121960282f64,
            -16834.1121960282f64,
            -16834.1121960282f64,
        );
    }
}