Replace dates with floats for interpolation and curves

yfnaji · yfnaji · commit 46f183d63951 · 2025-10-05T15:11:51.000+01:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -99,6 +99,7 @@ rayon = "1.9.0"             # https://docs.rs/rayon/latest/rayon/
 rust_decimal = { version = "1.34.3", features = ["maths"] }     # https://docs.rs/rust_decimal/latest/rust_decimal/
 statrs = "0.17.1"           # https://docs.rs/statrs/latest/statrs/
 thiserror = "1.0.57"        # https://docs.rs/thiserror/latest/thiserror/
+ordered-float = "5.1.0"    # https://docs.rs/ordered-float/latest/ordered_float/
 
 # https://docs.rs/ndarray/latest/ndarray/
 ndarray = { version = "0.16.1", features = ["rayon"] }
diff --git a/crates/RustQuant_data/Cargo.toml b/crates/RustQuant_data/Cargo.toml
@@ -30,6 +30,7 @@ time = { workspace = true }
 plotly = { workspace = true }
 argmin = { workspace = true }
 argmin-math = { workspace = true }
+ordered-float = {workspace=true}
 pyo3 = {workspace=true}
 
 ## ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
diff --git a/crates/RustQuant_data/src/curves.rs b/crates/RustQuant_data/src/curves.rs
@@ -35,7 +35,7 @@ use plotly::{common::Mode, Plot, Scatter};
 use pyo3::{pyclass, pymethods, PyResult};
 use std::collections::BTreeMap;
 use std::sync::Arc;
-use time::Date;
+use ordered_float::OrderedFloat;
 use RustQuant_math::interpolation::{ExponentialInterpolator, Interpolator, LinearInterpolator};
 use RustQuant_stochastics::{CurveModel, NelsonSiegelSvensson};
 
@@ -84,7 +84,7 @@ pub enum InterpolationMethod {
 #[pyclass]
 pub struct Curve {
     /// The nodes of the curve.
-    nodes: BTreeMap<Date, f64>,
+    nodes: BTreeMap<OrderedFloat<f64>, f64>,
 
     /// The type of the curve.
     curve_type: CurveType,
@@ -93,7 +93,7 @@ pub struct Curve {
     interpolation_method: InterpolationMethod,
 
     /// Interpolator backend.
-    interpolator: Arc<dyn Interpolator<Date, f64>>,
+    interpolator: Arc<dyn Interpolator<f64, f64>>,
 
     /// Nelson-Siegel-Svensson curve parameters.
     nss: Option<NelsonSiegelSvensson>,
@@ -104,12 +104,12 @@ impl Curve {
     /// Create a new curve.
     #[new]
     pub fn new(
-        dates: Vec<Date>,
+        dates: Vec<f64>,
         rates: Vec<f64>,
         curve_type: CurveType,
         interpolation_method: InterpolationMethod,
     ) -> PyResult<Self> {
-        let interpolator: Arc<dyn Interpolator<Date, f64>> = match interpolation_method {
+        let interpolator: Arc<dyn Interpolator<f64, f64>> = match interpolation_method {
             InterpolationMethod::Linear => {
                 Arc::new(LinearInterpolator::new(dates.clone(), rates.clone())?)
             }
@@ -123,92 +123,101 @@ impl Curve {
                 todo!("Implement LagrangeInterpolator")
             }
         };
+        // let x: BTreeMap<f64, f64> = dates.into_iter().zip(rates.into_iter()).collect();
+            
 
         Ok(Self {
-            nodes: dates.into_iter().zip(rates.into_iter()).collect(),
+            nodes: dates.into_iter().zip(rates.into_iter()).map(|(a, b)| (OrderedFloat(a), b)).collect(),
             curve_type,
             interpolation_method,
             interpolator,
             nss: None,
         })
     }
 
-    /// Create a new Curve from a list of nodes.
-    #[staticmethod]
-    pub fn from_nodes(
-        nodes: BTreeMap<Date, f64>,
-        curve_type: CurveType,
-        interpolation_method: InterpolationMethod,
-    ) -> PyResult<Self> {
-        let interpolator: Arc<dyn Interpolator<Date, f64>> = match interpolation_method {
-            InterpolationMethod::Linear => Arc::new(LinearInterpolator::new(
-                nodes.keys().cloned().collect(),
-                nodes.values().cloned().collect(),
-            )?),
-            InterpolationMethod::Exponential => Arc::new(ExponentialInterpolator::new(
-                nodes.keys().cloned().collect(),
-                nodes.values().cloned().collect(),
-            )?),
-            InterpolationMethod::CubicSpline => {
-                todo!("Implement CubicSplineInterpolator")
-            }
-            InterpolationMethod::Lagrange => {
-                todo!("Implement LagrangeInterpolator")
-            }
-        };
 
-        Ok(Self {
-            nodes,
-            curve_type,
-            interpolation_method,
-            interpolator,
-            nss: None,
-        })
-    }
+    // /// Create a new Curve from a list of nodes.
+    // #[staticmethod]
+    // pub fn from_nodes(
+    //     nodes: BTreeMap<Date, f64>,
+    //     curve_type: CurveType,
+    //     interpolation_method: InterpolationMethod,
+    // ) -> PyResult<Self> {
+    //     let interpolator: Arc<dyn Interpolator<Date, f64>> = match interpolation_method {
+    //         InterpolationMethod::Linear => Arc::new(LinearInterpolator::new(
+    //             nodes.keys().cloned().collect(),
+    //             nodes.values().cloned().collect(),
+    //         )?),
+    //         InterpolationMethod::Exponential => Arc::new(ExponentialInterpolator::new(
+    //             nodes.keys().cloned().collect(),
+    //             nodes.values().cloned().collect(),
+    //         )?),
+    //         InterpolationMethod::CubicSpline => {
+    //             todo!("Implement CubicSplineInterpolator")
+    //         }
+    //         InterpolationMethod::Lagrange => {
+    //             todo!("Implement LagrangeInterpolator")
+    //         }
+    //     };
+
+    //     Ok(Self {
+    //         nodes,
+    //         curve_type,
+    //         interpolation_method,
+    //         interpolator,
+    //         nss: None,
+    //     })
+    // }
 
     /// Get the interpolation method used by the curve.
     pub fn interpolation_method(&self) -> InterpolationMethod {
         self.interpolation_method
     }
 
     /// Get a rate from the curve.
-    pub fn get_rate(&self, date: Date) -> Option<f64> {
-        match self.nodes.get(&date) {
+    pub fn get_rate(&self, date: f64) -> Option<f64> {
+        match self.nodes.get(&OrderedFloat(date)) {
             Some(rate) => Some(*rate),
             None => self.interpolator.interpolate(date).ok(),
         }
     }
 
     /// Get multiple rates from the curve.
-    pub fn get_rates(&self, dates: Vec<Date>) -> Vec<Option<f64>> {
+    pub fn get_rates(&self, dates: Vec<f64>) -> Vec<Option<f64>> {
         dates.iter().map(|date| self.get_rate(*date)).collect()
     }
 
     /// Set a rate in the curve.
-    pub fn set_rate(&mut self, date: Date, rate: f64) {
-        self.nodes.insert(date, rate);
+    pub fn set_rate(&mut self, date: f64, rate: f64) {
+        self.nodes.insert(OrderedFloat(date), rate);
     }
 
     /// Set multiple rates in the curve.
-    pub fn set_rates(&mut self, rates: Vec<(Date, f64)>) {
+    pub fn set_rates(&mut self, rates: Vec<(f64, f64)>) {
         for (date, rate) in rates {
             self.set_rate(date, rate);
         }
     }
 
     /// Get the first date in the curve.
-    pub fn first_date(&self) -> Option<&Date> {
-        self.nodes.keys().next()
+    pub fn first_date(&self) -> Option<&f64> {
+        match self.nodes.keys().next() {
+            Some(date) => Some(&date.0),
+            None => None,
+        }
     }
 
     /// Get the last date in the curve.
-    pub fn last_date(&self) -> Option<&Date> {
-        self.nodes.keys().next_back()
+    pub fn last_date(&self) -> Option<&f64> {
+        match self.nodes.keys().next_back() {
+            Some(date) => Some(&date.0),
+            None => None,
+        }
     }
 
     /// Get the dates of the curve.
-    pub fn dates(&self) -> Vec<Date> {
-        self.nodes.keys().cloned().collect()
+    pub fn dates(&self) -> Vec<f64> {
+        self.nodes.keys().map(|k| k.0).collect()//.cloned().collect()
     }
 
     /// Get the rates of the curve.
@@ -237,7 +246,7 @@ impl Curve {
     }
 
     /// Get the bracketing indices for a specific index.
-    pub fn get_brackets(&self, index: Date) -> (Date, Date) {
+    pub fn get_brackets(&self, index: f64) -> (f64, f64) {
         let first = self.first_date().unwrap();
         let last = self.last_date().unwrap();
 
@@ -248,10 +257,10 @@ impl Curve {
             return (*last, *last);
         }
 
-        let left = self.nodes.range(..index).next_back().unwrap().0;
-        let right = self.nodes.range(index..).next().unwrap().0;
+        let left = self.nodes.range(..OrderedFloat(index)).next_back().unwrap().0;
+        let right = self.nodes.range(OrderedFloat(index)..).next().unwrap().0;
 
-        return (*left, *right);
+        return (left.0, right.0);
     }
 
     /// Shift the curve by a constant value.
@@ -306,7 +315,7 @@ impl CostFunction for Curve {
 
         let y_model = x
             .into_iter()
-            .map(|date| curve_function(&nss, *date))
+            .map(|date| curve_function(&nss, **date))
             .collect::<Vec<f64>>();
 
         let data = std::iter::zip(y, y_model);
diff --git a/crates/RustQuant_math/src/interpolation/b_splines.rs b/crates/RustQuant_math/src/interpolation/b_splines.rs
@@ -181,32 +181,6 @@ mod tests_b_splines {
         );
     }
 
-    #[test]
-    fn test_b_spline_dates() {
-        let now = time::OffsetDateTime::now_utc();
-        let knots: Vec<time::OffsetDateTime> = vec![
-            now,
-            now + time::Duration::days(1),
-            now + time::Duration::days(2),
-            now + time::Duration::days(3),
-            now + time::Duration::days(4),
-            now + time::Duration::days(5),
-            now + time::Duration::days(6),
-        ];
-        let control_points = vec![-1.0, 2.0, 0.0, -1.0];
-
-        let mut interpolator = BSplineInterpolator::new(knots.clone(), control_points, 2).unwrap();
-        let _ = interpolator.fit();
-
-        assert_approx_equal!(
-            1.375,
-            interpolator
-                .interpolate(knots[2] + time::Duration::hours(12))
-                .unwrap(),
-            RUSTQUANT_EPSILON
-        );
-    }
-
     #[test]
     fn test_b_spline_inconsistent_parameters() {
         let knots = vec![0.0, 1.0, 2.0, 3.0, 4.0];
diff --git a/crates/RustQuant_math/src/interpolation/cubic_spline.rs b/crates/RustQuant_math/src/interpolation/cubic_spline.rs
@@ -298,32 +298,6 @@ mod tests_cubic_spline_interpolation {
         );
     }
 
-    #[test]
-    fn test_natural_cubic_interpolation_dates() {
-        let now: time::OffsetDateTime = time::OffsetDateTime::now_utc();
-
-        let xs: Vec<time::OffsetDateTime> = vec![
-            now,
-            now + time::Duration::days(1),
-            now + time::Duration::days(2),
-            now + time::Duration::days(3),
-            now + time::Duration::days(4),
-        ];
-
-        let ys: Vec<f64> = vec![0., 1., 16., 81., 256.];
-
-        let mut interpolator: CubicSplineInterpolator<time::OffsetDateTime, f64> = CubicSplineInterpolator::new(xs.clone(), ys).unwrap();
-        let _ = interpolator.fit();
-
-        assert_approx_equal!(
-            36.660714285714285,
-            interpolator
-                .interpolate(xs[2] + time::Duration::hours(12))
-                .unwrap(),
-            RUSTQUANT_EPSILON
-        );
-    }
-
     #[test]
     fn test_cubic_interpolation_out_of_range() {
         let xs: Vec<f64> = vec![1., 2., 3., 4., 5.];
diff --git a/crates/RustQuant_math/src/interpolation/exponential_interpolator.rs b/crates/RustQuant_math/src/interpolation/exponential_interpolator.rs
@@ -188,24 +188,4 @@ mod tests_exponential_interpolation {
             RUSTQUANT_EPSILON
         );
     }
-
-    #[test]
-    fn test_exponential_interpolation_dates() {
-        let d_1m = date!(1990 - 06 - 16);
-        let d_2m = date!(1990 - 07 - 17);
-
-        let r_1m = 0.9870;
-        let r_2m = 0.9753;
-
-        let dates = vec![d_1m, d_2m];
-        let rates = vec![r_1m, r_2m];
-
-        let interpolator = ExponentialInterpolator::new(dates, rates).unwrap();
-
-        assert_approx_equal!(
-            0.9854824711068088,
-            interpolator.interpolate(date!(1990 - 06 - 20)).unwrap(),
-            RUSTQUANT_EPSILON
-        );
-    }
 }
diff --git a/crates/RustQuant_math/src/interpolation/linear_interpolator.rs b/crates/RustQuant_math/src/interpolation/linear_interpolator.rs
@@ -129,7 +129,6 @@ where
 #[cfg(test)]
 mod tests_linear_interpolation {
     use super::*;
-    use time::macros::date;
     use RustQuant_utils::{assert_approx_equal, RUSTQUANT_EPSILON};
 
     #[test]
@@ -162,51 +161,4 @@ mod tests_linear_interpolation {
 
         assert!(interpolator.interpolate(6.).is_err());
     }
-
-    #[test]
-    fn test_linear_interpolation_dates() {
-        let now = time::OffsetDateTime::now_utc();
-
-        let xs = vec![
-            now,
-            now + time::Duration::days(1),
-            now + time::Duration::days(2),
-            now + time::Duration::days(3),
-            now + time::Duration::days(4),
-        ];
-
-        let ys = vec![1., 2., 3., 4., 5.];
-
-        let mut interpolator = LinearInterpolator::new(xs.clone(), ys).unwrap();
-        let _ = interpolator.fit();
-
-        assert_approx_equal!(
-            2.5,
-            interpolator
-                .interpolate(xs[1] + time::Duration::hours(12))
-                .unwrap(),
-            RUSTQUANT_EPSILON
-        );
-    }
-
-    #[test]
-    fn test_linear_interpolation_dates_textbook() {
-        let d_1m = date!(1990 - 06 - 16);
-        let d_2m = date!(1990 - 07 - 17);
-
-        let r_1m = 0.9870;
-        let r_2m = 0.9753;
-
-        let dates = vec![d_1m, d_2m];
-        let rates = vec![r_1m, r_2m];
-
-        let interpolator = LinearInterpolator::new(dates, rates).unwrap();
-
-        let d = date!(1990 - 06 - 20);
-        assert_approx_equal!(
-            interpolator.interpolate(d).unwrap(),
-            0.9854903225806452,
-            RUSTQUANT_EPSILON
-        );
-    }
 }
diff --git a/crates/RustQuant_math/src/interpolation/mod.rs b/crates/RustQuant_math/src/interpolation/mod.rs
diff --git a/crates/RustQuant_stochastics/src/curve_model.rs b/crates/RustQuant_stochastics/src/curve_model.rs
diff --git a/crates/RustQuant_stochastics/src/nelson_siegel_svensson.rs b/crates/RustQuant_stochastics/src/nelson_siegel_svensson.rs
