xmake build succeeds

Author: WenyinWei

.gitignore

@@ -37,14 +37,18 @@
 *.out
 *.app
 
+
+
 # debug information files
 *.dwo
 
 # Build directories
 .xmake/
-.vscode/
 build/
 
+# vscode config
+.vscode/
+
 # Example executables
 simple_standard_parallelism
 standard_parallelism_demo

examples/parallelism_usage_demo.cpp

@@ -39,7 +39,7 @@ void modern_parallel_integration_example() {
     std::for_each(std::execution::par, initial_conditions.begin(), initial_conditions.end(),
         [&](std::vector<double>& state) {
             auto integrator = diffeq::make_rk45<std::vector<double>>(system);
-            integrator.step(state, 0.01); // Single integration step
+            integrator->step(state, 0.01); // Single integration step
         });
 
     auto end_time = std::chrono::high_resolution_clock::now();
@@ -97,7 +97,7 @@ void demonstrate_realtime_control() {
         [](std::vector<double>& state) {
             RobotArmSystem system;
             auto integrator = diffeq::make_rk45<std::vector<double>>(system);
-            integrator.step(state, 0.001); // 1ms control timestep
+            integrator->step(state, 0.001); // 1ms control timestep
         });
 
     auto end_time = std::chrono::high_resolution_clock::now();
@@ -129,7 +129,7 @@ void demonstrate_realtime_control() {
     for (double t = 0.0; t < simulation_time; t += dt) {
         // Execute control step asynchronously
         auto control_future = std::async(std::launch::async, [&, t]() {
-            integrator.step(state, dt);
+            integrator->step(state, dt);
         });
 
         // Simulate sensor reading (parallel)
@@ -273,9 +273,9 @@ void benchmark_hardware_targets() {
     // Sequential execution
     auto seq_start = std::chrono::high_resolution_clock::now();
     std::vector<std::vector<double>> seq_states(num_integrations, initial_state);
-    for (int i = 0; i < num_integrations; ++i) {
-        integrator.integrate(seq_states[i], dt, t_final);
-    }
+            for (int i = 0; i < num_integrations; ++i) {
+            integrator->integrate(seq_states[i], dt, t_final);
+        }
     auto seq_end = std::chrono::high_resolution_clock::now();
     auto seq_duration = std::chrono::duration_cast<std::chrono::milliseconds>(seq_end - seq_start);
 
@@ -285,7 +285,7 @@ void benchmark_hardware_targets() {
     std::for_each(std::execution::par, par_states.begin(), par_states.end(),
         [&](std::vector<double>& state) {
             auto local_integrator = diffeq::make_rk45<std::vector<double>>(system);
-            local_integrator.integrate(state, dt, t_final);
+            local_integrator->integrate(state, dt, t_final);
         });
     auto par_end = std::chrono::high_resolution_clock::now();
     auto par_duration = std::chrono::duration_cast<std::chrono::milliseconds>(par_end - par_start);

examples/sde_usage_demo.cpp

@@ -198,14 +198,14 @@ class HestonModel {
         int steps = static_cast<int>(T / dt);
 
         // Use high-order SDE integrator for better accuracy
-        auto integrator = diffeq::sde::factory::make_sosra_integrator<std::vector<double>, double>(problem, wiener);
-        integrator->set_time(0.0);
+        diffeq::sde::SOSRAIntegrator<std::vector<double>, double> integrator(problem, wiener);
+        integrator.set_time(0.0);
 
         std::cout << "Initial state: S = " << x[0] << ", V = " << x[1] << std::endl;
 
         // Integrate Heston model
         for (int i = 0; i < steps; ++i) {
-            integrator->step(x, dt);
+            integrator.step(x, dt);
 
             // Output every 25 steps (quarterly)
             if (i % 25 == 0) {
@@ -270,14 +270,14 @@ class NoisyOscillator {
             drift_func, diffusion_func, diffeq::sde::NoiseType::DIAGONAL_NOISE);
 
         auto wiener = diffeq::sde::factory::make_wiener_process<std::vector<double>, double>(1, 67890);
-        auto integrator = diffeq::sde::factory::make_milstein_integrator<std::vector<double>, double>(problem, wiener);
+        diffeq::sde::MilsteinIntegrator<std::vector<double>, double> integrator(problem, wiener);
 
         std::vector<double> state = {0.0, 0.0};  // Initial [x, xdot]
         double dt = 0.01;
         double T = 10.0;
         int steps = static_cast<int>(T / dt);
 
-        integrator->set_time(0.0);
+        integrator.set_time(0.0);
 
         std::cout << "Simulating controlled oscillator with noise..." << std::endl;
 
@@ -293,7 +293,7 @@ class NoisyOscillator {
             total_error += error;
             max_error = std::max(max_error, error);
 
-            integrator->step(state, dt);
+            integrator.step(state, dt);
 
             // Output every 100 steps
             if (i % 100 == 0) {
@@ -356,14 +356,14 @@ class StochasticLotkaVolterra {
             drift_func, diffusion_func, diffeq::sde::NoiseType::DIAGONAL_NOISE);
 
         auto wiener = diffeq::sde::factory::make_wiener_process<std::vector<double>, double>(2, 11111);
-        auto integrator = diffeq::sde::factory::make_sra1_integrator<std::vector<double>, double>(problem, wiener);
+        diffeq::sde::SRA1Integrator<std::vector<double>, double> integrator(problem, wiener);
 
         std::vector<double> population = {2.0, 1.0};  // Initial [prey, predator]
         double dt = 0.01;
         double T = 20.0;
         int steps = static_cast<int>(T / dt);
 
-        integrator->set_time(0.0);
+        integrator.set_time(0.0);
 
         std::cout << "Initial populations: prey = " << population[0] << ", predator = " << population[1] << std::endl;
 
@@ -372,7 +372,7 @@ class StochasticLotkaVolterra {
         double min_pred = population[1], max_pred = population[1];
 
         for (int i = 0; i < steps; ++i) {
-            integrator->step(population, dt);
+            integrator.step(population, dt);
 
             // Update min/max
             min_prey = std::min(min_prey, population[0]);
@@ -423,10 +423,10 @@ void demonstrate_async_sde_integration() {
         drift_func, diffusion_func, diffeq::sde::NoiseType::DIAGONAL_NOISE);
 
     auto wiener = diffeq::sde::factory::make_wiener_process<std::vector<double>, double>(2, 22222);
-    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);
 
-    // Create async integrator
-    auto async_integrator = diffeq::async::make_async_integrator(integrator);
+    // Note: Async integrator functionality is not currently available
+    // For now, we'll use the regular integrator
 
     std::vector<double> state = {1.0, 0.0};
     double dt = 0.01;
@@ -437,10 +437,9 @@ void demonstrate_async_sde_integration() {
 
     auto start_time = std::chrono::high_resolution_clock::now();
 
-    // Async integration
+    // Regular integration (async not available)
     for (int i = 0; i < steps; ++i) {
-        auto future = async_integrator->step_async(state, dt);
-        future.wait();  // Wait for completion
+        integrator.step(state, dt);
 
         if (i % 100 == 0) {
             std::cout << "Step " << i << ": [" << state[0] << ", " << state[1] << "]" << std::endl;
@@ -450,7 +449,7 @@ void demonstrate_async_sde_integration() {
     auto end_time = std::chrono::high_resolution_clock::now();
     auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
 
-    std::cout << "Async integration completed in " << duration.count() << "ms" << std::endl;
+    std::cout << "Integration completed in " << duration.count() << "ms" << std::endl;
     std::cout << "Final state: [" << state[0] << ", " << state[1] << "]" << std::endl;
 }