move all the hpp files in include/examples to examples

Author: WenyinWei

docs/STANDARD_PARALLELISM.md

@@ -7,7 +7,7 @@ This document shows how to use standard parallelism libraries with the diffeq li
 For most users, the simplest approach is to use the unified convenience interface:
 
 ```cpp
-#include <examples/standard_parallelism.hpp>
+#include <diffeq.hpp>
 
 // SIMPLEST USAGE: Just add parallel to existing code
 auto system = [](double t, const std::vector<double>& y, std::vector<double>& dydt) {
@@ -56,7 +56,7 @@ Instead of creating custom parallel classes, we recommend using established stan
 ### 1. Basic Parallel Integration with std::execution
 
 ```cpp
-#include <examples/standard_parallelism.hpp>
+#include <diffeq.hpp>
 #include <execution>
 #include <algorithm>
 

examples/README.md

@@ -0,0 +1,162 @@
+# diffeq Examples
+
+This directory contains comprehensive examples demonstrating how to use the diffeq library for solving differential equations.
+
+## Example Programs
+
+### Core Integration Examples
+
+- **`working_integrators_demo.cpp`** - Demonstrates all working ODE integrators (RK4, RK23, RK45, BDF, LSODA)
+- **`rk4_integrator_usage.cpp`** - Basic RK4 integrator usage with various ODE systems
+- **`advanced_integrators_usage.cpp`** - Advanced integrator features and configurations
+- **`state_concept_usage.cpp`** - Shows how to use different state types (vectors, arrays, custom types)
+
+### Parallelism Examples
+
+- **`parallelism_usage_demo.cpp`** - Comprehensive parallelism features including:
+  - Quick start parallel interface
+  - Robotics control systems with real-time parallelism
+  - Stochastic process research with GPU-accelerated Monte Carlo
+  - Multi-hardware target benchmarking
+- **`standard_parallelism_demo.cpp`** - Standard library parallelism integration:
+  - C++17/20 std::execution policies
+  - OpenMP parallel loops
+  - Intel TBB integration
+  - Task-based async dispatchers
+- **`simple_standard_parallelism.cpp`** - Simplified parallel usage patterns
+- **`standard_parallelism_demo.cpp`** - Advanced standard parallelism features
+- **`simplified_parallel_usage.cpp`** - Easy-to-use parallel interfaces
+- **`test_advanced_parallelism.cpp`** - Testing advanced parallelism features
+
+### Advanced Features
+
+- **`interface_usage_demo.cpp`** - Integration interface examples:
+  - Financial portfolio modeling with signal processing
+  - Robotics control with real-time feedback
+  - Scientific simulations with parameter updates
+- **`sde_usage_demo.cpp`** - Stochastic Differential Equation examples:
+  - Black-Scholes financial models
+  - Heston stochastic volatility
+  - Noisy oscillator control systems
+  - Stochastic Lotka-Volterra ecosystem models
+- **`advanced_gpu_async_demo.cpp`** - GPU acceleration with async processing
+- **`realtime_signal_processing.cpp`** - Real-time signal processing integration
+
+### Testing and Validation
+
+- **`quick_test.cpp`** - Quick validation tests
+- **`test_dop853.cpp`** - DOP853 integrator testing
+- **`test_rk4_only.cpp`** - RK4 integrator testing
+- **`sde_demo.cpp`** - Basic SDE demonstration
+
+## Building and Running Examples
+
+### Prerequisites
+
+- C++17 or later compiler
+- CMake or xmake build system
+- Optional: OpenMP, Intel TBB, CUDA for advanced parallelism examples
+
+### Building
+
+```bash
+# Using xmake (recommended)
+xmake
+
+# Or using CMake
+mkdir build && cd build
+cmake ..
+make
+```
+
+### Running Examples
+
+```bash
+# Run a specific example
+./examples/working_integrators_demo
+
+# Run parallelism examples
+./examples/parallelism_usage_demo
+./examples/standard_parallelism_demo
+
+# Run SDE examples
+./examples/sde_usage_demo
+
+# Run interface examples
+./examples/interface_usage_demo
+```
+
+## Example Categories
+
+### 1. Basic Usage
+Start with these examples to understand the fundamentals:
+- `working_integrators_demo.cpp`
+- `rk4_integrator_usage.cpp`
+- `state_concept_usage.cpp`
+
+### 2. Parallelism
+For performance-critical applications:
+- `parallelism_usage_demo.cpp` - Full-featured parallelism
+- `standard_parallelism_demo.cpp` - Standard library integration
+- `simple_standard_parallelism.cpp` - Easy parallel usage
+
+### 3. Advanced Features
+For complex applications:
+- `interface_usage_demo.cpp` - Signal processing and real-time integration
+- `sde_usage_demo.cpp` - Stochastic differential equations
+- `advanced_gpu_async_demo.cpp` - GPU acceleration
+
+### 4. Domain-Specific Examples
+- **Finance**: Black-Scholes, Heston models in `sde_usage_demo.cpp`
+- **Robotics**: Control systems in `parallelism_usage_demo.cpp`
+- **Scientific**: Chemical reactions, ecosystem models in `sde_usage_demo.cpp`
+
+## Key Features Demonstrated
+
+### Integration Methods
+- **ODE Solvers**: RK4, RK23, RK45, BDF, LSODA, DOP853
+- **SDE Solvers**: Euler-Maruyama, Milstein, SRA1, SOSRA, SRIW1, SOSRI
+- **Adaptive Methods**: Automatic step size control
+- **Stiff Systems**: BDF and LSODA for stiff problems
+
+### Parallelism
+- **CPU Parallelism**: std::execution, OpenMP, Intel TBB
+- **GPU Acceleration**: CUDA, Thrust integration
+- **Async Processing**: Task-based parallel execution
+- **Real-time Control**: Low-latency parallel integration
+
+### Advanced Features
+- **Signal Processing**: Real-time event handling
+- **Parameter Sweeps**: Parallel parameter studies
+- **Multi-physics**: Coupled system integration
+- **Hardware Optimization**: Automatic backend selection
+
+## Best Practices
+
+1. **Start Simple**: Begin with `working_integrators_demo.cpp` to understand basic usage
+2. **Choose the Right Integrator**: Use RK45 for general problems, BDF for stiff systems
+3. **Leverage Parallelism**: Use parallel examples for performance-critical applications
+4. **Handle Real-time Requirements**: Use interface examples for systems with external signals
+5. **Validate Results**: Compare with analytical solutions when available
+
+## Troubleshooting
+
+### Common Issues
+- **Compilation Errors**: Ensure C++17 support and required libraries
+- **Performance Issues**: Check parallel backend availability
+- **Accuracy Problems**: Verify integrator choice and tolerances
+- **Memory Issues**: Use appropriate state types and batch sizes
+
+### Getting Help
+- Check the main library documentation
+- Review the test suite for usage patterns
+- Examine the source code for implementation details
+
+## Contributing
+
+When adding new examples:
+1. Follow the existing naming convention
+2. Include comprehensive comments
+3. Demonstrate realistic use cases
+4. Add to this README if appropriate
+5. Ensure the example compiles and runs correctly 

include/examples/interface_usage.hpp renamed to examples/interface_usage_demo.cpp

@@ -1,6 +1,5 @@
-#pragma once
-
 #include <interfaces/integration_interface.hpp>
+#include <diffeq.hpp>
 #include <vector>
 #include <array>
 #include <string>
@@ -176,6 +175,8 @@ auto create_scientific_interface() {
  */
 template<system_state StateType>
 void demonstrate_usage(StateType initial_state) {
+    std::cout << "\n=== Integration Interface Usage Demo ===" << std::endl;
+    
     // Create interface for your domain (finance example)
     auto interface = create_portfolio_interface<StateType>();
 
@@ -198,22 +199,104 @@ void demonstrate_usage(StateType initial_state) {
     auto signal_proc = interface->get_signal_processor();
 
     StateType state = initial_state;
+    double t_start = 0.0, t_end = 1.0, dt = 0.1;
 
-    // Integration with signal processing
-    for (int step = 0; step < 100; ++step) {
-        integrator.integrate(state, 0.01, 0.01 * step);
-        
-        // Simulate external signals
-        if (step == 25) {
-            signal_proc->emit_signal("price_update", 105.0);
+    std::cout << "Initial portfolio state: [" << state[0] << ", " << state[1] << ", " << state[2] << "]" << std::endl;
+    
+    // Integrate with signal processing
+    for (double t = t_start; t < t_end; t += dt) {
+        // Simulate market signals
+        if (t > 0.3 && t < 0.4) {
+            signal_proc->emit_signal("price_update", 110.0);
         }
-        if (step == 50) {
+        if (t > 0.7) {
             signal_proc->emit_signal("risk_alert", std::string("high_volatility"));
         }
-        if (step == 75) {
-            signal_proc->emit_signal("price_update", 95.0);
-        }
+        
+        // Integrate one step
+        integrator->step(state, dt);
     }
+    
+    std::cout << "Final portfolio state: [" << state[0] << ", " << state[1] << ", " << state[2] << "]" << std::endl;
+    std::cout << "Integration completed successfully!" << std::endl;
 }
 
 } // namespace diffeq::examples
+
+int main() {
+    std::cout << "=== diffeq Integration Interface Examples ===" << std::endl;
+    
+    // Example with vector state
+    std::vector<double> initial_portfolio = {1000.0, 2000.0, 1500.0};
+    diffeq::examples::demonstrate_usage(initial_portfolio);
+    
+    std::cout << "\n=== Robotics Interface Example ===" << std::endl;
+    
+    // Create robotics interface
+    auto robotics_interface = diffeq::examples::create_robotics_interface<std::vector<double>>();
+    
+    // Define robot dynamics
+    auto robot_ode = [](double t, const std::vector<double>& y, std::vector<double>& dydt) {
+        // Simple double integrator: d²θ/dt² = u
+        dydt[0] = y[1];  // dθ/dt = ω
+        dydt[1] = -0.1 * y[0] - 0.5 * y[1];  // Simple PD control
+    };
+    
+    auto signal_aware_robot_ode = robotics_interface->make_signal_aware_ode(robot_ode);
+    auto robot_integrator = diffeq::make_rk4<std::vector<double>>(signal_aware_robot_ode);
+    
+    std::vector<double> robot_state = {0.1, 0.0}; // [angle, angular_velocity]
+    auto robot_signal_proc = robotics_interface->get_signal_processor();
+    
+    std::cout << "Initial robot state: angle=" << robot_state[0] << " rad, velocity=" << robot_state[1] << " rad/s" << std::endl;
+    
+    // Simulate robot control
+    for (double t = 0.0; t < 2.0; t += 0.01) {
+        if (t > 0.5) {
+            robot_signal_proc->emit_signal("control_command", std::vector<double>{0.5});
+        }
+        if (t > 1.5) {
+            robot_signal_proc->emit_signal("emergency_stop", true);
+        }
+        
+        robot_integrator->step(robot_state, 0.01);
+    }
+    
+    std::cout << "Final robot state: angle=" << robot_state[0] << " rad, velocity=" << robot_state[1] << " rad/s" << std::endl;
+    
+    std::cout << "\n=== Scientific Interface Example ===" << std::endl;
+    
+    // Create scientific interface
+    auto scientific_interface = diffeq::examples::create_scientific_interface<std::vector<double>>();
+    
+    // Define scientific system (e.g., chemical reaction)
+    auto chemical_ode = [](double t, const std::vector<double>& y, std::vector<double>& dydt) {
+        // Simple chemical reaction: A -> B
+        double k = 0.1; // reaction rate
+        dydt[0] = -k * y[0];  // dA/dt = -k*A
+        dydt[1] = k * y[0];   // dB/dt = k*A
+    };
+    
+    auto signal_aware_chemical_ode = scientific_interface->make_signal_aware_ode(chemical_ode);
+    auto chemical_integrator = diffeq::make_rk45<std::vector<double>>(signal_aware_chemical_ode);
+    
+    std::vector<double> chemical_state = {1.0, 0.0}; // [A, B]
+    auto chemical_signal_proc = scientific_interface->get_signal_processor();
+    
+    std::cout << "Initial chemical state: A=" << chemical_state[0] << ", B=" << chemical_state[1] << std::endl;
+    
+    // Simulate chemical reaction with parameter updates
+    for (double t = 0.0; t < 10.0; t += 0.1) {
+        if (t > 5.0) {
+            chemical_signal_proc->emit_signal("parameter_update", 0.2); // Increase reaction rate
+        }
+        
+        chemical_integrator->step(chemical_state, 0.1);
+    }
+    
+    std::cout << "Final chemical state: A=" << chemical_state[0] << ", B=" << chemical_state[1] << std::endl;
+    
+    std::cout << "\n=== All examples completed successfully! ===" << std::endl;
+    
+    return 0;
+}