quantsupport 0.1.0

Rust library for fixed-income, derivative pricing and risk analytics.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

use std::cmp::Ordering;

use crate::{
    ad::adreal::{ADReal, FloatExt},
    math::interpolation::interpolator::StaticInterpolate,
    utils::errors::{QSError, Result},
};

/// # `LogLinearInterpolator`
/// Log-linear interpolator.
#[derive(Clone)]
pub struct LogLinearInterpolator {}

impl StaticInterpolate<f64> for LogLinearInterpolator {
    fn interpolate(x: f64, x_: &[f64], y_: &[f64], enable_extrapolation: bool) -> Result<f64> {
        let index =
            match x_.binary_search_by(|&probe| probe.partial_cmp(&x).unwrap_or(Ordering::Less)) {
                Ok(index) | Err(index) => index,
            };

        let (Some(first_x), Some(last_x)) = (x_.first(), x_.last()) else {
            return Err(QSError::InterpolationErr(
                "Interpolation data must contain at least one x value.".into(),
            ));
        };

        if !(enable_extrapolation || (x >= *first_x && x <= *last_x)) {
            return Err(QSError::InterpolationErr(
                "Extrapolation is not enabled, and the provided value is outside the range.".into(),
            ));
        }

        let y = match index {
            0 => y_[0] * (y_[1] / y_[0]).powf((x - x_[0]) / (x_[1] - x_[0])),
            idx if idx == x_.len() => {
                y_[idx - 1]
                    * (y_[idx - 1] / y_[idx - 2])
                        .powf((x - x_[idx - 1]) / (x_[idx - 1] - x_[idx - 2]))
            }
            _ => {
                y_[index - 1]
                    * (y_[index] / y_[index - 1])
                        .powf((x - x_[index - 1]) / (x_[index] - x_[index - 1]))
            }
        };
        Ok(y)
    }
}

impl StaticInterpolate<ADReal> for LogLinearInterpolator {
    fn interpolate(
        x: ADReal,
        x_: &[ADReal],
        y_: &[ADReal],
        enable_extrapolation: bool,
    ) -> Result<ADReal> {
        let index =
            match x_.binary_search_by(|&probe| probe.partial_cmp(&x).unwrap_or(Ordering::Less)) {
                Ok(index) | Err(index) => index,
            };

        let (Some(first_x), Some(last_x)) = (x_.first(), x_.last()) else {
            return Err(QSError::InterpolationErr(
                "Interpolation data must contain at least one x value.".into(),
            ));
        };

        if !(enable_extrapolation || ((&x >= first_x) && (&x <= last_x))) {
            return Err(QSError::InterpolationErr(
                "Extrapolation is not enabled, and the provided value is outside the range.".into(),
            ));
        }

        let y = match index {
            0 => y_[0] * (y_[1] / y_[0]).pow_expr((x - x_[0]) / (x_[1] - x_[0])),
            idx if idx == x_.len() => {
                y_[idx - 1]
                    * (y_[idx - 1] / y_[idx - 2])
                        .pow_expr((x - x_[idx - 1]) / (x_[idx - 1] - x_[idx - 2]))
            }
            _ => {
                y_[index - 1]
                    * (y_[index] / y_[index - 1])
                        .pow_expr((x - x_[index - 1]) / (x_[index] - x_[index - 1]))
            }
        };
        Ok(y.into())
    }
}

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

    #[test]
    fn test_loglinear_interpolation() {
        let x = 0.5;
        let x_ = vec![0.0, 1.0];
        let y_ = vec![0.1, 1.0]; // Change from 0.0 to 0.1
        let y = LogLinearInterpolator::interpolate(x, &x_, &y_, true).unwrap();
        // Adjust the expected value accordingly
        assert!((y - 0.31622776601683794).abs() < 1e-10);
    }
}