feat: update vol_surface pipeline

Author: dancixx

src/quant/calibration/heston.rs

@@ -98,6 +98,19 @@ pub struct HestonParams {
 }
 
 impl HestonParams {
+  /// Convert to a [`HestonFourier`] model for pricing / vol surface generation.
+  pub fn to_fourier(&self, r: f64, q: f64) -> crate::quant::pricing::fourier::HestonFourier {
+    crate::quant::pricing::fourier::HestonFourier {
+      v0: self.v0,
+      kappa: self.kappa,
+      theta: self.theta,
+      sigma: self.sigma,
+      rho: self.rho,
+      r,
+      q,
+    }
+  }
+
   fn periodic_map(x: f64, c: f64, d: f64) -> f64 {
     if c <= x && x <= d {
       x

src/quant/calibration/heston_stoch_corr.rs

@@ -50,6 +50,22 @@ pub struct HscmCalibrationResult {
   pub mae: f64,
 }
 
+impl From<HscmCalibrationResult> for crate::quant::pricing::heston_stoch_corr::HscmModel {
+  fn from(r: HscmCalibrationResult) -> Self {
+    Self {
+      v0: r.v0,
+      kappa_v: r.kappa_v,
+      theta_v: r.theta_v,
+      sigma_v: r.sigma_v,
+      rho0: r.rho0,
+      kappa_r: r.kappa_r,
+      mu_r: r.mu_r,
+      sigma_r: r.sigma_r,
+      rho2: r.rho2,
+    }
+  }
+}
+
 impl HscmCalibrationResult {
   pub fn to_vec(&self) -> Vec<f64> {
     vec![

src/quant/calibration/levy.rs

@@ -84,6 +84,63 @@ pub struct LevyCalibrationResult {
   pub iterations: usize,
 }
 
+impl LevyCalibrationResult {
+  /// Convert to a Fourier model for pricing / vol surface generation.
+  ///
+  /// Returns a boxed [`ModelPricer`] because the concrete type depends
+  /// on the calibrated model variant.
+  pub fn to_model(
+    &self,
+    r: f64,
+    q: f64,
+  ) -> Box<dyn crate::traits::ModelPricer> {
+    use crate::quant::pricing::fourier::*;
+    let p = &self.params;
+    match self.model_type {
+      LevyModelType::VarianceGamma => Box::new(VarianceGammaFourier {
+        sigma: p[0],
+        theta: p[1],
+        nu: p[2],
+        r,
+        q,
+      }),
+      LevyModelType::NIG => Box::new(CGMYFourier {
+        c: p[0],
+        g: p[1],
+        m: p[2],
+        y: 0.5,
+        r,
+        q,
+      }),
+      LevyModelType::CGMY => Box::new(CGMYFourier {
+        c: p[0],
+        g: p[1],
+        m: p[2],
+        y: p[3],
+        r,
+        q,
+      }),
+      LevyModelType::MertonJD => Box::new(MertonJDFourier {
+        sigma: p[0],
+        lambda: p[1],
+        mu_j: p[2],
+        sigma_j: p[3],
+        r,
+        q,
+      }),
+      LevyModelType::Kou => Box::new(KouFourier {
+        sigma: p[0],
+        lambda: p[1],
+        p_up: p[2],
+        eta1: p[3],
+        eta2: p[4],
+        r,
+        q,
+      }),
+    }
+  }
+}
+
 /// Lévy model calibrator via Fourier pricing + Levenberg-Marquardt.
 ///
 /// Source:

src/quant/calibration/svj.rs

@@ -181,6 +181,24 @@ pub struct SVJCalibrationResult {
   pub converged: bool,
 }
 
+impl SVJCalibrationResult {
+  /// Convert to a [`BatesFourier`] model for pricing / vol surface generation.
+  pub fn to_fourier(&self, r: f64, q: f64) -> crate::quant::pricing::fourier::BatesFourier {
+    crate::quant::pricing::fourier::BatesFourier {
+      v0: self.v0,
+      kappa: self.kappa,
+      theta: self.theta,
+      sigma_v: self.sigma_v,
+      rho: self.rho,
+      lambda: self.lambda,
+      mu_j: self.mu_j,
+      sigma_j: self.sigma_j,
+      r,
+      q,
+    }
+  }
+}
+
 /// SVJ (Bates) least-squares calibrator using Levenberg-Marquardt.
 ///
 /// Source:

src/quant/pricing/fourier.rs

@@ -244,6 +244,14 @@ impl LewisPricer {
   }
 }
 
+/// Blanket implementation: every [`FourierModelExt`] model automatically
+/// implements [`ModelPricer`] via Gil-Pelaez quadrature.
+impl<T: FourierModelExt> crate::traits::ModelPricer for T {
+  fn price_call(&self, s: f64, k: f64, r: f64, q: f64, tau: f64) -> f64 {
+    GilPelaezPricer::price_call(self, s, k, r, q, tau)
+  }
+}
+
 /// Black–Scholes–Merton model for Fourier pricing.
 pub struct BSMFourier {
   pub sigma: f64,

src/quant/pricing/heston_stoch_corr.rs

@@ -261,6 +261,32 @@ impl TimeExt for HestonStochCorrPricer {
   }
 }
 
+/// Heston stochastic-correlation model parameters (model only, no market data).
+///
+/// Implements [`ModelPricer`] via the Carr-Madan FFT pricer.
+#[derive(Clone, Copy, Debug)]
+pub struct HscmModel {
+  pub v0: f64,
+  pub kappa_v: f64,
+  pub theta_v: f64,
+  pub sigma_v: f64,
+  pub rho0: f64,
+  pub kappa_r: f64,
+  pub mu_r: f64,
+  pub sigma_r: f64,
+  pub rho2: f64,
+}
+
+impl crate::traits::ModelPricer for HscmModel {
+  fn price_call(&self, s: f64, k: f64, r: f64, _q: f64, tau: f64) -> f64 {
+    let pricer = HestonStochCorrPricer::new(
+      s, r, k, self.v0, self.kappa_v, self.theta_v, self.sigma_v, self.rho0, self.kappa_r,
+      self.mu_r, self.sigma_r, self.rho2, tau,
+    );
+    pricer.price_call_carr_madan()
+  }
+}
+
 #[cfg(test)]
 mod tests {
   use super::*;

src/quant/pricing/sabr.rs

@@ -319,6 +319,43 @@ impl PricerExt for SabrPricer {
   }
 }
 
+/// SABR model parameters (model only, no market data).
+///
+/// Implements [`ModelPricer`] via the Hagan (2002) implied-vol formula
+/// plugged into Black-Scholes.
+#[derive(Clone, Copy, Debug)]
+pub struct SabrModel {
+  pub alpha: f64,
+  pub beta: f64,
+  pub nu: f64,
+  pub rho: f64,
+}
+
+impl crate::traits::ModelPricer for SabrModel {
+  fn price_call(&self, s: f64, k: f64, r: f64, q: f64, tau: f64) -> f64 {
+    let fwd = s * ((r - q) * tau).exp();
+    let sigma = hagan_implied_vol(k, fwd, tau, self.alpha, self.beta, self.nu, self.rho);
+    if !sigma.is_finite() || sigma <= 0.0 {
+      return 0.0;
+    }
+    let pricer = BSMPricer::new(
+      s,
+      sigma,
+      k,
+      r,
+      None,
+      None,
+      Some(q),
+      Some(tau),
+      None,
+      None,
+      OptionType::Call,
+      BSMCoc::Merton1973,
+    );
+    pricer.calculate_call_put().0
+  }
+}
+
 #[cfg(test)]
 mod tests {
   use super::*;