Merge pull request #270 from yfnaji/monte-carlo

Monte-Carlo Engine, seed parameter implementation and new numerical schemes for SDEs

Author: avhz

crates/RustQuant_instruments/src/monte_carlo_pricer.rs

@@ -41,7 +41,7 @@ macro_rules! impl_monte_carlo_pricer {
                 config: &StochasticProcessConfig,
                 rate: f64,
             ) -> f64 {
-                let out = process.euler_maruyama(&config);
+                let out = process.generate(&config);
 
                 let n = out.paths.len();
 

crates/RustQuant_instruments/src/options/vanilla.rs

@@ -389,7 +389,7 @@ mod test_vanilla_option_monte_carlo {
     use std::time::Instant;
     use time::macros::date;
     use RustQuant_stochastics::geometric_brownian_motion::GeometricBrownianMotion;
-    use RustQuant_stochastics::StochasticProcessConfig;
+    use RustQuant_stochastics::{StochasticProcessConfig, StochasticScheme};
 
     #[test]
     fn test_vanilla_option_monte_carlo() {
@@ -410,7 +410,9 @@ mod test_vanilla_option_monte_carlo {
         let process = GeometricBrownianMotion::new(interest_rate, volatility);
 
         let config =
-            StochasticProcessConfig::new(underlying, 0.0, time_to_maturity, 1, 1_000_000, true);
+            StochasticProcessConfig::new(
+                underlying, 0.0, time_to_maturity, 1, StochasticScheme::EulerMaruyama,1_000_000, true, None
+            );
 
         let start = Instant::now();
         let price = option.price_monte_carlo(&process, &config, interest_rate);
@@ -442,7 +444,9 @@ mod test_vanilla_option_monte_carlo {
         let process = GeometricBrownianMotion::new(interest_rate, volatility);
 
         let config =
-            StochasticProcessConfig::new(underlying, 0.0, time_to_maturity, 1000, 1000, true);
+            StochasticProcessConfig::new(
+                underlying, 0.0, time_to_maturity, 1000, StochasticScheme::EulerMaruyama,1000, true, None
+            );
 
         let start = Instant::now();
         let price = option.price_monte_carlo(&process, &config, interest_rate);

crates/RustQuant_stochastics/src/arithmetic_brownian_motion.rs

@@ -7,7 +7,6 @@
 //      - LICENSE-MIT.md
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-// use crate::models::arithmetic_brownian_motion::ArithmeticBrownianMotion;
 use crate::process::StochasticProcess;
 use crate::ModelParameter;
 
@@ -58,15 +57,17 @@ impl StochasticProcess for ArithmeticBrownianMotion {
 #[cfg(test)]
 mod tests_abm {
     use super::*;
-    use crate::StochasticProcessConfig;
+    use crate::{StochasticProcessConfig, StochasticScheme};
     use RustQuant_math::*;
     use RustQuant_utils::assert_approx_equal;
 
     #[test]
     fn test_arithmetic_brownian_motion() {
         let abm = ArithmeticBrownianMotion::new(0.05, 0.9);
-        let config = StochasticProcessConfig::new(10.0, 0.0, 0.5, 125, 1000, false);
-        let output = abm.euler_maruyama(&config);
+        let config = StochasticProcessConfig::new(
+            10.0, 0.0, 0.5, 125, StochasticScheme::EulerMaruyama, 1000, false, None
+        );
+        let output = abm.generate(&config);
 
         // let file1 = "./images/ABM1.png";
         // plot_vector((&output.trajectories[0]).clone(), file1).unwrap();

crates/RustQuant_stochastics/src/black_derman_toy.rs

@@ -65,7 +65,7 @@ pub(crate) fn diff(f: &(dyn Fn(f64) -> f64 + Send + Sync), t: f64) -> f64 {
 #[cfg(test)]
 mod tests_black_derman_toy {
     use super::*;
-    use crate::StochasticProcessConfig;
+    use crate::{StochasticProcessConfig, StochasticScheme};
     use RustQuant_math::*;
 
     // fn theta_t(_t: f64) -> f64 {
@@ -82,8 +82,10 @@ mod tests_black_derman_toy {
 
         let hw = BlackDermanToy::new(sigma, theta);
 
-        let config = StochasticProcessConfig::new(0.13, 0.0, 1.0, 100, 1000, false);
-        let output = hw.euler_maruyama(&config);
+        let config = StochasticProcessConfig::new(
+            0.13, 0.0, 1.0, 100, StochasticScheme::EulerMaruyama, 1000, false, None
+        );
+        let output = hw.generate(&config);
 
         // Test the distribution of the final values.
         let X_T: Vec<f64> = output
@@ -103,8 +105,10 @@ mod tests_black_derman_toy {
         let theta = 1.5;
 
         let hw = BlackDermanToy::new(sigma, theta);
-        let config = StochasticProcessConfig::new(0.13, 0.0, 1.0, 100, 1000, false);
-        let output = hw.euler_maruyama(&config);
+        let config = StochasticProcessConfig::new(
+            0.13, 0.0, 1.0, 100, crate::StochasticScheme::EulerMaruyama, 1000, false, None
+        );
+        let output = hw.generate(&config);
 
         // Test the distribution of the final values.
         let X_T: Vec<f64> = output

crates/RustQuant_stochastics/src/brownian_motion.rs

@@ -54,7 +54,7 @@ mod sde_tests {
     // use std::time::Instant;
 
     use super::*;
-    use crate::StochasticProcessConfig;
+    use crate::{StochasticProcessConfig, StochasticScheme};
     use RustQuant_math::*;
     use RustQuant_utils::assert_approx_equal;
 
@@ -84,8 +84,10 @@ mod sde_tests {
         // }
         // assert!(1 == 2);
 
-        let config = StochasticProcessConfig::new(0.0, 0.0, 0.5, 100, 1000, false);
-        let output_serial = bm.euler_maruyama(&config);
+        let config = StochasticProcessConfig::new(
+            0.0, 0.0, 0.5, 100, StochasticScheme::EulerMaruyama, 1000, false, None
+        );
+        let output_serial = bm.generate(&config);
         // let output_parallel = (&bm).euler_maruyama(10.0, 0.0, 0.5, 100, 10, true);
 
         // let file1 = "./images/BM1.png";

crates/RustQuant_stochastics/src/constant_elasticity_of_variance.rs

@@ -67,14 +67,16 @@ impl StochasticProcess for ConstantElasticityOfVariance {
 #[cfg(test)]
 mod tests_cev {
     use super::*;
-    use crate::StochasticProcessConfig;
+    use crate::{StochasticProcessConfig, StochasticScheme};
     use RustQuant_math::*;
 
     #[test]
     fn test_cev_process() {
         let cev = ConstantElasticityOfVariance::new(0.05, 0.9, 0.45);
-        let config = StochasticProcessConfig::new(10.0, 0.0, 0.5, 100, 100, false);
-        let output = cev.euler_maruyama(&config);
+        let config = StochasticProcessConfig::new(
+            10.0, 0.0, 0.5, 100, StochasticScheme::EulerMaruyama, 100, false, None
+        );
+        let output = cev.generate(&config);
 
         // Test the distribution of the final values.
         let X_T: Vec<f64> = output

crates/RustQuant_stochastics/src/cox_ingersoll_ross.rs

@@ -65,17 +65,19 @@ impl StochasticProcess for CoxIngersollRoss {
 #[cfg(test)]
 mod tests_cir {
     use super::*;
-    use crate::StochasticProcessConfig;
+    use crate::{StochasticProcessConfig, StochasticScheme};
     use RustQuant_math::*;
     use RustQuant_utils::assert_approx_equal;
 
     #[test]
     fn test_cox_ingersoll_ross() {
         let cir = CoxIngersollRoss::new(0.15, 0.45, 0.01);
 
-        let config = StochasticProcessConfig::new(10.0, 0.0, 0.5, 100, 100, false);
+        let config = StochasticProcessConfig::new(
+            10.0, 0.0, 0.5, 100, StochasticScheme::EulerMaruyama, 100, false, None
+        );
 
-        let output = cir.euler_maruyama(&config);
+        let output = cir.generate(&config);
 
         // Test the distribution of the final values.
         let X_T: Vec<f64> = output

crates/RustQuant_stochastics/src/extended_vasicek.rs

@@ -62,7 +62,7 @@ impl StochasticProcess for ExtendedVasicek {
 #[cfg(test)]
 mod tests_extended_vasicek {
     use super::*;
-    use crate::StochasticProcessConfig;
+    use crate::{StochasticProcessConfig, StochasticScheme};
     use RustQuant_math::*;
     use RustQuant_utils::assert_approx_equal;
 
@@ -81,9 +81,11 @@ mod tests_extended_vasicek {
 
         let ev = ExtendedVasicek::new(alpha, sigma, theta);
 
-        let config = StochasticProcessConfig::new(10.0, 0.0, 1.0, 150, 1000, false);
+        let config = StochasticProcessConfig::new(
+            10.0, 0.0, 1.0, 150, StochasticScheme::EulerMaruyama, 1000, false, None
+        );
 
-        let output = ev.euler_maruyama(&config);
+        let output = ev.generate(&config);
 
         // Test the distribution of the final values.
         let X_T: Vec<f64> = output