gradually let it successfully build

Author: WenyinWei

.gitignore

@@ -40,12 +40,13 @@
 # debug information files
 *.dwo
 
-# Build directories
-.xmake/
-build/
-
-# Example executables
-simple_standard_parallelism
-standard_parallelism_demo
-test_standard_parallelism
+# Build directories
+.xmake/
+.vscode/
+build/
+
+# Example executables
+simple_standard_parallelism
+standard_parallelism_demo
+test_standard_parallelism
 parallelism_integration_demo

examples/sde_demo.cpp

@@ -18,7 +18,8 @@ int main() {
             drift_func, diffusion_func, diffeq::sde::NoiseType::DIAGONAL_NOISE);
 
         auto wiener = diffeq::sde::factory::make_wiener_process<std::vector<double>, double>(1, 12345);
-        auto integrator = diffeq::sde::factory::make_euler_maruyama_integrator<std::vector<double>, double>(problem, wiener);
+        // auto integrator = diffeq::sde::factory::make_euler_maruyama_integrator<std::vector<double>, double>(problem, wiener);
+        diffeq::sde::EulerMaruyamaIntegrator<std::vector<double>, double> integrator(problem, wiener);
 
         std::vector<double> state = {1.0};  // Initial condition
         double dt = 0.01;
@@ -28,7 +29,7 @@ int main() {
         std::cout << "Initial state: " << state[0] << std::endl;
 
         for (int i = 0; i < steps; ++i) {
-            integrator->step(state, dt);
+            integrator.step(state, dt);
             if (i % 25 == 0) {  // Output every quarter
                 std::cout << "t = " << (i * dt) << ": X = " << state[0] << std::endl;
             }

examples/sde_usage_demo.cpp

@@ -96,39 +96,39 @@ class BlackScholesModel {
 
         // SOSRA
         {
-            auto integrator = diffeq::sde::factory::make_sosra_integrator<std::vector<double>, double>(problem, wiener);
+            diffeq::sde::SOSRAIntegrator<std::vector<double>, double> integrator(problem, wiener);
             std::vector<double> S = {S0};
-            integrator->set_time(0.0);
+            integrator.set_time(0.0);
             wiener->set_seed(12345);
 
             for (int i = 0; i < steps; ++i) {
-                integrator->step(S, dt);
+                integrator.step(S, dt);
             }
             results.push_back(S[0]);
         }
 
         // SRIW1
         {
-            auto integrator = diffeq::sde::factory::make_sriw1_integrator<std::vector<double>, double>(problem, wiener);
+            diffeq::sde::SRIW1Integrator<std::vector<double>, double> integrator(problem, wiener);
             std::vector<double> S = {S0};
-            integrator->set_time(0.0);
+            integrator.set_time(0.0);
             wiener->set_seed(12345);
 
             for (int i = 0; i < steps; ++i) {
-                integrator->step(S, dt);
+                integrator.step(S, dt);
             }
             results.push_back(S[0]);
         }
 
         // SOSRI
         {
-            auto integrator = diffeq::sde::factory::make_sosri_integrator<std::vector<double>, double>(problem, wiener);
+            diffeq::sde::SOSRIIntegrator<std::vector<double>, double> integrator(problem, wiener);
             std::vector<double> S = {S0};
-            integrator->set_time(0.0);
+            integrator.set_time(0.0);
             wiener->set_seed(12345);
 
             for (int i = 0; i < steps; ++i) {
-                integrator->step(S, dt);
+                integrator.step(S, dt);
             }
             results.push_back(S[0]);
         }

include/diffeq.hpp

@@ -21,8 +21,6 @@
 #include <integrators/sde/milstein.hpp>        // Milstein method with Lévy area (strong order 1.0)
 #include <integrators/sde/sri1.hpp>            // Stochastic Runge-Kutta method (strong order 1.0)
 #include <integrators/sde/implicit_euler_maruyama.hpp>  // Implicit method for stiff SDEs
-
-// Advanced high-order SDE integrators (strong order 1.5)
 #include <integrators/sde/sra.hpp>             // SRA base implementation
 #include <integrators/sde/sra1.hpp>            // SRA1 variant for additive noise
 #include <integrators/sde/sra2.hpp>            // SRA2 variant for additive noise
@@ -319,7 +317,7 @@ namespace diffeq {
     using DefaultTime = double;
 }
 
-// Optional: Convenience factory functions
+// Modern factory functions using std::make_unique
 namespace diffeq {
 
     /**
@@ -329,7 +327,7 @@ namespace diffeq {
     auto make_rk45(typename AbstractIntegrator<S>::system_function sys,
                    typename S::value_type rtol = 1e-6,
                    typename S::value_type atol = 1e-9) {
-        return integrators::ode::RK45Integrator<S>(std::move(sys), rtol, atol);
+        return std::make_unique<integrators::ode::RK45Integrator<S>>(std::move(sys), rtol, atol);
     }
 
     /**
@@ -339,7 +337,7 @@ namespace diffeq {
     auto make_dop853(typename AbstractIntegrator<S>::system_function sys,
                      typename S::value_type rtol = 1e-10,
                      typename S::value_type atol = 1e-15) {
-        return integrators::ode::DOP853Integrator<S>(std::move(sys), rtol, atol);
+        return std::make_unique<integrators::ode::DOP853Integrator<S>>(std::move(sys), rtol, atol);
     }
 
     /**
@@ -349,6 +347,40 @@ namespace diffeq {
     auto make_bdf(typename AbstractIntegrator<S>::system_function sys,
                   typename S::value_type rtol = 1e-6,
                   typename S::value_type atol = 1e-9) {
-        return integrators::ode::BDFIntegrator<S>(std::move(sys), rtol, atol);
+        return std::make_unique<integrators::ode::BDFIntegrator<S>>(std::move(sys), rtol, atol);
+    }
+    
+    /**
+     * Create an RK4 integrator (fixed step)
+     */
+    template<system_state S>
+    auto make_rk4(typename AbstractIntegrator<S>::system_function sys) {
+        return std::make_unique<integrators::ode::RK4Integrator<S>>(std::move(sys));
+    }
+    
+    /**
+     * Create an RK23 integrator (adaptive)
+     */
+    template<system_state S>
+    auto make_rk23(typename AbstractIntegrator<S>::system_function sys,
+                   typename S::value_type rtol = 1e-6,
+                   typename S::value_type atol = 1e-9) {
+        return std::make_unique<integrators::ode::RK23Integrator<S>>(std::move(sys), rtol, atol);
+    }
+    
+    /**
+     * Create an Euler integrator (fixed step)
+     */
+    template<system_state S>
+    auto make_euler(typename AbstractIntegrator<S>::system_function sys) {
+        return std::make_unique<integrators::ode::EulerIntegrator<S>>(std::move(sys));
+    }
+    
+    /**
+     * Create an Improved Euler integrator (fixed step)
+     */
+    template<system_state S>
+    auto make_improved_euler(typename AbstractIntegrator<S>::system_function sys) {
+        return std::make_unique<integrators::ode::ImprovedEulerIntegrator<S>>(std::move(sys));
     }
 }

include/sde/sde_base.hpp

@@ -197,7 +197,7 @@ class AbstractSDEIntegrator {
 };
 
 /**
- * @brief Factory functions for creating SDE problems and integrators
+ * @brief Factory functions for creating SDE problems and Wiener processes
  */
 namespace factory {
 

test/integration/test_sde_integration.cpp

@@ -11,7 +11,6 @@
 
 #include <diffeq.hpp>
 #include <sde/sde_base.hpp>
-#include <sde/sde_solvers.hpp>
 #include <iostream>
 #include <vector>
 #include <array>