feat: add ADG model

Author: dancixx

README.md

@@ -24,9 +24,6 @@ The library is organized into several modules, each targeting specific areas of
 ## Features
 
 Planned features and models under development:
-
-- **Rough Heston Model**: Combines the Heston model with rough volatility, capturing the fine structure of volatility movements.
-- **Hull-White Model**: An interest rate model with time-dependent parameters, providing a good fit to initial term structures.
 - **Barndorff-Nielsen & Shephard Model**: A stochastic volatility model with non-Gaussian Ornstein-Uhlenbeck processes.
 - **Multi-factor CIR Model**: Extends the CIR model to multiple factors, providing greater flexibility in interest rate modeling.
 - **Brace-Gatarek-Musiela (BGM) Model**: A market model for interest rates, modeling the evolution of forward rates.

src/stochastic.rs

@@ -71,6 +71,28 @@ pub trait Sampling<T: Clone + Send + Sync + Zero>: Send + Sync {
   }
 }
 
+pub trait SamplingVector<T: Clone + Send + Sync + Zero>: Send + Sync {
+  /// Sample the vector process
+  fn sample(&self) -> Array2<T>;
+
+  /// Parallel sampling
+  fn sample_par(&self) -> Array2<T> {
+    unimplemented!()
+  }
+
+  /// Number of time steps
+  fn n(&self) -> usize;
+
+  /// Number of samples for parallel sampling
+  fn m(&self) -> Option<usize>;
+
+  /// Malliavin derivative of the process
+  #[cfg(feature = "malliavin")]
+  fn malliavin(&self) -> Array1<T> {
+    unimplemented!()
+  }
+}
+
 pub trait Sampling2D<T: Clone + Send + Sync + Zero>: Send + Sync {
   /// Sample the process
   fn sample(&self) -> [Array1<T>; 2];

src/stochastic/interest.rs

@@ -1,7 +1,12 @@
+pub mod adg;
+pub mod bgm;
 pub mod cir;
+pub mod cir_2f;
 pub mod duffie_kan;
 pub mod fvasicek;
 pub mod ho_lee;
 pub mod hull_white;
 pub mod hull_white_2f;
+pub mod mod_duffie_kan;
 pub mod vasicek;
+pub mod wu_zhang;

src/stochastic/interest/adg.rs

@@ -0,0 +1,68 @@
+use impl_new_derive::ImplNew;
+use ndarray::{Array1, Array2};
+use ndarray_rand::RandomExt;
+use rand_distr::Normal;
+
+use crate::stochastic::SamplingVector;
+
+/// Ahn-Dittmar-Gallant (ADG) model
+///
+#[derive(ImplNew)]
+pub struct ADG {
+  pub k: fn(f64) -> f64,
+  pub theta: fn(f64) -> f64,
+  pub sigma: Array1<f64>,
+  pub phi: fn(f64) -> f64,
+  pub b: fn(f64) -> f64,
+  pub c: fn(f64) -> f64,
+  pub n: usize,
+  pub xn: usize,
+  pub x0: Array1<f64>,
+  pub t: Option<f64>,
+  pub m: Option<usize>,
+}
+
+impl SamplingVector<f64> for ADG {
+  fn sample(&self) -> Array2<f64> {
+    let dt = self.t.unwrap_or(1.0) / (self.n - 1) as f64;
+
+    let mut adg = Array2::<f64>::zeros((self.xn, self.n));
+    for i in 0..self.xn {
+      adg[(i, 0)] = self.x0[i];
+    }
+
+    for i in 0..self.xn {
+      let gn = Array1::random(self.n, Normal::new(0.0, dt.sqrt()).unwrap());
+
+      for j in 1..self.n {
+        let t = j as f64 * dt;
+        adg[(i, j)] = adg[(i, j - 1)]
+          + ((self.k)(t) - (self.theta)(t) * adg[(i, j - 1)]) * dt
+          + self.sigma[i] * gn[j - 1];
+      }
+    }
+
+    let mut r = Array2::zeros((self.xn, self.n));
+
+    for i in 0..self.xn {
+      let phi = Array1::<f64>::from_shape_fn(self.n, |j| (self.phi)(j as f64 * dt));
+      let b = Array1::<f64>::from_shape_fn(self.n, |j| (self.b)(j as f64 * dt));
+      let c = Array1::<f64>::from_shape_fn(self.n, |j| (self.c)(j as f64 * dt));
+
+      r.row_mut(i)
+        .assign(&(phi + b * adg.row(i).t().to_owned() * c * adg.row(i)));
+    }
+
+    r
+  }
+
+  /// Number of time steps
+  fn n(&self) -> usize {
+    self.n
+  }
+
+  /// Number of samples for parallel sampling
+  fn m(&self) -> Option<usize> {
+    self.m
+  }
+}