yield-curves 0.4.0

Pure-Rust yield curve interpolation (Nelson-Siegel, Svensson, PCHIP) and bond pricing. Zero deps.
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
105

//! Piecewise-linear interpolation with flat extrapolation.

use crate::{validate::validate_and_sort, YieldCurveError, YieldCurveInterpolator};

/// Piecewise-linear interpolation between anchor points. Extrapolates flat
/// outside the observed range.
///
/// O(log n) evaluation via binary search.
#[derive(Debug, Clone)]
pub struct LinearCurve {
    points: Vec<(f64, f64)>,
}

impl LinearCurve {
    /// Fits from `(t_years, rate)` anchor points. Requires at least 2 points.
    pub fn fit(points: &[(f64, f64)]) -> Result<Self, YieldCurveError> {
        let points = validate_and_sort(points, "linear", 2)?;
        Ok(Self { points })
    }
}

impl YieldCurveInterpolator for LinearCurve {
    fn rate_at(&self, t_years: f64) -> f64 {
        let pts = &self.points;
        if t_years <= pts[0].0 {
            return pts[0].1;
        }
        if t_years >= pts.last().unwrap().0 {
            return pts.last().unwrap().1;
        }
        let idx = pts.partition_point(|p| p.0 < t_years);
        let (x0, y0) = pts[idx - 1];
        let (x1, y1) = pts[idx];
        let t = (t_years - x0) / (x1 - x0);
        y0 + t * (y1 - y0)
    }

    fn method_name(&self) -> &'static str {
        "linear"
    }

    fn observed_range(&self) -> (f64, f64) {
        (self.points[0].0, self.points.last().unwrap().0)
    }
}

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

    fn approx_eq(a: f64, b: f64, eps: f64) -> bool {
        (a - b).abs() < eps
    }

    #[test]
    fn passes_through_anchors() {
        let curve = LinearCurve::fit(&[(0.25, 13.0), (0.5, 13.5), (1.0, 14.0)]).unwrap();
        assert!(approx_eq(curve.rate_at(0.25), 13.0, 1e-10));
        assert!(approx_eq(curve.rate_at(0.5), 13.5, 1e-10));
        assert!(approx_eq(curve.rate_at(1.0), 14.0, 1e-10));
    }

    #[test]
    fn midpoint_is_average() {
        let curve = LinearCurve::fit(&[(0.0, 10.0), (1.0, 20.0)]).unwrap();
        assert!(approx_eq(curve.rate_at(0.5), 15.0, 1e-10));
    }

    #[test]
    fn flat_extrapolation() {
        let curve = LinearCurve::fit(&[(0.25, 13.0), (1.0, 14.0)]).unwrap();
        assert_eq!(curve.rate_at(0.1), 13.0);
        assert_eq!(curve.rate_at(5.0), 14.0);
    }

    #[test]
    fn rejects_single_point() {
        let err = LinearCurve::fit(&[(0.25, 13.0)]).unwrap_err();
        assert!(matches!(err, YieldCurveError::InsufficientData { .. }));
    }

    #[test]
    fn rejects_nan() {
        let err = LinearCurve::fit(&[(0.25, f64::NAN), (0.5, 13.5)]).unwrap_err();
        assert!(matches!(err, YieldCurveError::InvalidPoint(_)));
    }

    #[test]
    fn rejects_duplicate_vertex() {
        let err = LinearCurve::fit(&[(0.25, 13.0), (0.25, 13.5)]).unwrap_err();
        assert!(matches!(err, YieldCurveError::InvalidPoint(_)));
    }

    #[test]
    fn method_name_stable() {
        let curve = LinearCurve::fit(&[(1.0, 1.0), (2.0, 2.0)]).unwrap();
        assert_eq!(curve.method_name(), "linear");
    }

    #[test]
    fn observed_range_reflects_input() {
        let curve = LinearCurve::fit(&[(0.25, 13.0), (0.5, 13.5), (3.0, 14.0)]).unwrap();
        assert_eq!(curve.observed_range(), (0.25, 3.0));
    }
}