Cubic-Splines: Add helper functions unit tests

Author: yfnaji

crates/RustQuant_math/src/interpolation/cubic_spline.rs

@@ -492,3 +492,132 @@ mod tests_cubic_spline_interpolation {
         );
     }
 }
+
+#[cfg(test)]
+mod tests_cubic_spline_helper_functions {
+    use super::*;
+
+    #[test]
+    fn test_compute_lower_tri_and_diagonal_matrices() {
+        let xs: Vec<f64> = vec![1., 2., 3., 4., 5.];
+        let ys: Vec<f64> = vec![1., 2., 3., 4., 5.];
+
+        let time_steps: Vec<f64> = xs.windows(2)
+            .map(|x| (x[1] - x[0]))
+            .collect();
+
+        let interpolator: CubicSplineInterpolator<f64, f64> = CubicSplineInterpolator::new(xs, ys).unwrap();
+        let (lower_triangular, diagonal) = interpolator.compute_lower_tri_and_diagonal_matrices(&time_steps);
+
+        assert!(lower_triangular == vec![4.0, 3.75, 3.7333333333333334]);
+        assert!(diagonal == vec![0.25, 0.26666666666666666]);
+    }
+
+    #[test]
+    fn test_invert_lower_tri_matrix() {
+        let xs: Vec<f64> = vec![1., 2., 3., 4., 5.];
+        let ys: Vec<f64> = vec![1., 2., 3., 4., 5.];
+
+        let interpolator: CubicSplineInterpolator<f64, f64> = CubicSplineInterpolator::new(xs, ys).unwrap();
+        let inv_lower_tri_matrix: Vec<Vec<f64>> = interpolator.invert_lower_tri_matrix(&[3.0, 2.0, 1.0]);
+
+        assert!(
+            inv_lower_tri_matrix == vec![
+                vec![1.0],
+                vec![-3.0, 1.0],
+                vec![6.0, -2.0, 1.0],
+                vec![-6.0, 2.0, -1.0, 1.0]
+            ]
+        )
+    }
+
+    #[test]
+    fn test_transpose() {
+        let xs: Vec<f64> = vec![1., 2., 3., 4., 5.];
+        let ys: Vec<f64> = vec![1., 2., 3., 4., 5.];
+
+        let interpolator: CubicSplineInterpolator<f64, f64> = CubicSplineInterpolator::new(xs, ys).unwrap();
+        let transposed_matrix = interpolator.transpose(vec![
+            vec![1.0],
+            vec![2.0, 3.0],
+            vec![4.0, 5.0, 6.0],
+        ]);
+
+        assert!(
+            transposed_matrix == vec![
+                vec![1.0, 2.0, 4.0],
+                vec![3.0, 5.0],
+                vec![6.0],
+            ]
+        );
+    }
+
+    #[test]
+    fn lower_tri_transpose_times_diag_inv() {
+        let xs: Vec<f64> = vec![1., 2., 3., 4., 5.];
+        let ys: Vec<f64> = vec![1., 2., 3., 4., 5.];
+
+        let interpolator: CubicSplineInterpolator<f64, f64> = CubicSplineInterpolator::new(xs, ys).unwrap();
+        let lower_tri_inverse: Vec<Vec<f64>> = vec![vec![1.0], vec![2.0, 3.0], vec![4.0, 5.0, 6.0]];
+        let diagonal: Vec<f64> = vec![1.0, 2.0, 3.0];
+
+        assert!(
+            interpolator.lower_tri_transpose_times_diag_inv(&lower_tri_inverse, &diagonal) == vec![
+                vec![1.0, 2.0, 4.0],
+                vec![0.5, 2.5],
+                vec![0.3333333333333333]
+            ]
+        );
+    }
+
+    #[test]
+    fn test_upper_tri_times_lower_tri() {
+        let xs: Vec<f64> = vec![1., 2., 3., 4., 5.];
+        let ys: Vec<f64> = vec![1., 2., 3., 4., 5.];
+
+        let interpolator: CubicSplineInterpolator<f64, f64> = CubicSplineInterpolator::new(xs, ys).unwrap();
+        let upper_tri_matrix = vec![
+            vec![1.0, 2.0, 3.0],
+            vec![4.0, 5.0],
+            vec![6.0],
+        ];
+        let lower_tri_matrix_transpose = vec![
+            vec![-1.0, -2.0, -3.0],
+            vec![-4.0, -5.0],
+            vec![-6.0],
+        ];
+
+        let product: Vec<Vec<f64>> = interpolator.upper_tri_times_lower_tri(
+            &upper_tri_matrix,
+            &lower_tri_matrix_transpose
+        );
+
+        assert!(
+            product == vec![
+                [-14.0, -23.0, -18.0],
+                [-23.0, -41.0, -30.0],
+                [-18.0, -30.0, -36.0]
+            ]
+        );
+    }
+
+    #[test]
+    fn test_spline() {
+        let xs: Vec<f64> = vec![0., 1., 2., 3., 4.];
+        let ys: Vec<f64> = vec![0., 1., 16., 81., 256.];
+
+        let interpolator: CubicSplineInterpolator<f64, f64> = CubicSplineInterpolator::new(xs, ys).unwrap();
+        let spline_result: f64 = interpolator.spline(
+            2.5, 
+            1.0, 
+            2.0, 
+            3.0, 
+            16.0, 
+            81.0, 
+            32.75733333333333, 
+            156.85714285714286
+        );
+
+        assert!(spline_result == 36.64909523809524);
+    }
+}