remove Unicode characters that causes display issues on Windows

Author: WenyinWei

examples/advanced_integrators_usage.cpp

@@ -14,14 +14,14 @@ void exponential_decay(double t, const std::vector<double>& y, std::vector<doubl
     dydt[0] = -y[0];
 }
 
-// 2. Van der Pol oscillator: d²x/dt² - μ(1-x²)dx/dt + x = 0
+// 2. Van der Pol oscillator: d^2x/dt^2 - mu*(1-x^2)*dx/dt + x = 0
 class VanderPolOscillator {
 public:
     explicit VanderPolOscillator(double mu) : mu_(mu) {}
 
     void operator()(double t, const std::vector<double>& y, std::vector<double>& dydt) {
         dydt[0] = y[1];                                    // dx/dt = v
-        dydt[1] = mu_ * (1 - y[0]*y[0]) * y[1] - y[0];    // dv/dt = μ(1-x²)v - x
+        dydt[1] = mu_ * (1 - y[0]*y[0]) * y[1] - y[0];    // dv/dt = mu*(1-x^2)*v - x
     }
 
 private:
@@ -34,9 +34,9 @@ void lorenz_system(double t, const std::vector<double>& y, std::vector<double>&
     const double rho = 28.0;
     const double beta = 8.0/3.0;
 
-    dydt[0] = sigma * (y[1] - y[0]);           // dx/dt = σ(y - x)
-    dydt[1] = y[0] * (rho - y[2]) - y[1];      // dy/dt = x(ρ - z) - y
-    dydt[2] = y[0] * y[1] - beta * y[2];       // dz/dt = xy - βz
+    dydt[0] = sigma * (y[1] - y[0]);           // dx/dt = sigma*(y - x)
+    dydt[1] = y[0] * (rho - y[2]) - y[1];      // dy/dt = x*(rho - z) - y
+    dydt[2] = y[0] * y[1] - beta * y[2];       // dz/dt = xy - beta*z
 }
 
 // 4. Stiff test problem: Robertson chemical kinetics
@@ -70,7 +70,7 @@ double time_integrator(Integrator& integrator, std::vector<double>& y,
         std::cout << std::setw(12) << std::scientific << std::setprecision(4) << y[i];
         if (i < y.size() - 1) std::cout << ", ";
     }
-    std::cout << "] (Time: " << duration.count() << " μs)";
+    std::cout << "] (Time: " << duration.count() << " us)";
 
     if (!completed) {
         std::cout << " [TIMEOUT]";
@@ -126,8 +126,8 @@ void demonstrate_exponential_decay() {
 }
 
 void demonstrate_van_der_pol() {
-    std::cout << "\n=== Van der Pol Oscillator: μ = 5 (moderately stiff) ===" << std::endl;
-    std::cout << "x''(t) - μ(1-x²)x'(t) + x(t) = 0" << std::endl;
+    std::cout << "\n=== Van der Pol Oscillator: mu = 5 (moderately stiff) ===" << std::endl;
+    std::cout << "x''(t) - mu*(1-x^2)*x'(t) + x(t) = 0" << std::endl;
     std::cout << "Initial conditions: x(0) = 1, x'(0) = 0" << std::endl << std::endl;
 
     VanderPolOscillator vdp(5.0);
@@ -185,8 +185,8 @@ void demonstrate_van_der_pol() {
 
 void demonstrate_lorenz_system() {
     std::cout << "\n=== Lorenz System (Chaotic) ===" << std::endl;
-    std::cout << "dx/dt = σ(y - x), dy/dt = x(ρ - z) - y, dz/dt = xy - βz" << std::endl;
-    std::cout << "σ = 10, ρ = 28, β = 8/3" << std::endl;
+    std::cout << "dx/dt = sigma*(y - x), dy/dt = x*(rho - z) - y, dz/dt = xy - beta*z" << std::endl;
+    std::cout << "sigma = 10, rho = 28, beta = 8/3" << std::endl;
     std::cout << "Initial conditions: x(0) = 1, y(0) = 1, z(0) = 1" << std::endl << std::endl;
 
     double t_start = 0.0, t_end = 0.5, dt = 0.01;  // Reduced from 5.0 to 0.5 for faster execution
@@ -295,13 +295,13 @@ int main() {
         demonstrate_adaptive_features();
 
         std::cout << "\n=== Summary ===" << std::endl;
-        std::cout << "✓ RK4: Simple, fixed-step 4th order method" << std::endl;
-        std::cout << "✓ RK23: Adaptive 3rd order with embedded error estimation" << std::endl;
-        std::cout << "✓ RK45: Adaptive 5th order Dormand-Prince (scipy default)" << std::endl;
-        std::cout << "✓ DOP853: High-accuracy 8th order for demanding problems" << std::endl;
-        std::cout << "• Radau: Implicit 5th order for stiff systems (not yet implemented)" << std::endl;
-        std::cout << "✓ BDF: Variable-order implicit multistep for stiff systems" << std::endl;
-        std::cout << "✓ LSODA: Automatic method switching (Adams ↔ BDF)" << std::endl;
+        std::cout << "[OK] RK4: Simple, fixed-step 4th order method" << std::endl;
+        std::cout << "[OK] RK23: Adaptive 3rd order with embedded error estimation" << std::endl;
+        std::cout << "[OK] RK45: Adaptive 5th order Dormand-Prince (scipy default)" << std::endl;
+        std::cout << "[OK] DOP853: High-accuracy 8th order for demanding problems" << std::endl;
+        std::cout << "- Radau: Implicit 5th order for stiff systems (not yet implemented)" << std::endl;
+        std::cout << "[OK] BDF: Variable-order implicit multistep for stiff systems" << std::endl;
+        std::cout << "[OK] LSODA: Automatic method switching (Adams <-> BDF)" << std::endl;
 
     } catch (const std::exception& e) {
         std::cerr << "Error: " << e.what() << std::endl;

examples/parallelism_usage_demo.cpp

@@ -45,7 +45,7 @@ void modern_parallel_integration_example() {
     auto end_time = std::chrono::high_resolution_clock::now();
     auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);
 
-    std::cout << "✓ Parallel integration completed in " << duration.count() << " μs!" << std::endl;
+    std::cout << "[PASS] Parallel integration completed in " << duration.count() << " us!" << std::endl;
     std::cout << "Result for initial condition 10: [" << initial_conditions[10][0] 
               << ", " << initial_conditions[10][1] << "]" << std::endl;
 }
@@ -103,8 +103,8 @@ void demonstrate_realtime_control() {
     auto end_time = std::chrono::high_resolution_clock::now();
     auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);
 
-    std::cout << "Parallel control completed in " << duration.count() << " μs" << std::endl;
-    std::cout << "Average per joint: " << duration.count() / joint_states.size() << " μs" << std::endl;
+    std::cout << "Parallel control completed in " << duration.count() << " us" << std::endl;
+    std::cout << "Average per joint: " << duration.count() / joint_states.size() << " us" << std::endl;
 
     // Advanced async approach using diffeq async capabilities
     std::cout << "\n--- Advanced Async Approach ---" << std::endl;

examples/rk4_integrator_usage.cpp

@@ -13,9 +13,9 @@ void exponential_decay(double t, const std::vector<double>& y, std::vector<doubl
 }
 
 // Example 2: Lorenz attractor (simplified)
-// dx/dt = σ(y - x)
-// dy/dt = x(ρ - z) - y  
-// dz/dt = xy - βz
+// dx/dt = sigma*(y - x)
+// dy/dt = x*(rho - z) - y  
+// dz/dt = xy - beta*z
 void lorenz_system(double t, const std::vector<double>& state, std::vector<double>& dydt) {
     const double sigma = 10.0;
     const double rho = 28.0;
@@ -31,14 +31,14 @@ void lorenz_system(double t, const std::vector<double>& state, std::vector<doubl
 }
 
 // Example 3: Damped harmonic oscillator
-// d²x/dt² + 2γ(dx/dt) + ω²x = 0
+// d^2x/dt^2 + 2*gamma*(dx/dt) + omega^2*x = 0
 // State: [x, dx/dt]
 void damped_oscillator(float t, const std::array<float, 2>& state, std::array<float, 2>& dydt) {
     const float gamma = 0.1f; // damping coefficient
-    const float omega_sq = 4.0f; // ω² = 4
+    const float omega_sq = 4.0f; // omega^2 = 4
 
     dydt[0] = state[1]; // dx/dt = v
-    dydt[1] = -2.0f * gamma * state[1] - omega_sq * state[0]; // dv/dt = -2γv - ω²x
+    dydt[1] = -2.0f * gamma * state[1] - omega_sq * state[0]; // dv/dt = -2*gamma*v - omega^2*x
 }
 
 int main() {

examples/test_rk4_only.cpp

@@ -15,9 +15,9 @@ int main() {
         integrator.set_time(0.0);
         integrator.integrate(y, 0.1, 1.0);
         std::cout << "RK4 result: " << y[0] << " (expected: " << std::exp(-1.0) << ")" << std::endl;
-        std::cout << "✓ RK4 test passed!" << std::endl;
-    } catch (const std::exception& e) {
-        std::cout << "✗ RK4 test failed: " << e.what() << std::endl;
+            std::cout << "[PASS] RK4 test passed!" << std::endl;
+} catch (const std::exception& e) {
+    std::cout << "[FAIL] RK4 test failed: " << e.what() << std::endl;
         return 1;
     }
 

simple_test.cpp

@@ -26,7 +26,7 @@ int main() {
         integrator.set_time(t_start);
         integrator.integrate(y, dt, t_end);
         std::cout << std::setprecision(6) << y[0] << std::endl;
-        std::cout << "✓ Basic RK4 test successful!" << std::endl;
+        std::cout << "[PASS] Basic RK4 test successful!" << std::endl;
     } catch (const std::exception& e) {
         std::cout << "Failed: " << e.what() << std::endl;
         return 1;

test/integration/test_standard_parallelism.cpp

@@ -93,7 +93,7 @@ void test_std_execution_multiple_conditions() {
     double tolerance = 0.1;
     assert(std::abs(states[0][0] - expected) < tolerance);
 
-    std::cout << "✓ std::execution multiple conditions test passed\n";
+    std::cout << "[PASS] std::execution multiple conditions test passed\n";
 }
 
 void test_parameter_sweep() {
@@ -151,7 +151,7 @@ void test_parameter_sweep() {
     assert(results[1][0] > results[2][0]);
     assert(results[2][0] > results[3][0]);
 
-    std::cout << "✓ Parameter sweep test passed (flexibility beyond initial conditions)\n";
+    std::cout << "[PASS] Parameter sweep test passed (flexibility beyond initial conditions)\n";
 }
 
 void test_different_integrators() {
@@ -236,7 +236,7 @@ void test_different_integrators() {
     assert(euler_results[0][0] > 0.1 && euler_results[0][0] < 1.0);
     assert(rk2_results[0][0] > 0.1 && rk2_results[0][0] < 1.0);
 
-    std::cout << "✓ Different integrators test passed\n";
+    std::cout << "[PASS] Different integrators test passed\n";
 }
 
 #ifdef _OPENMP
@@ -274,7 +274,7 @@ void test_openmp() {
     double tolerance = 0.1;
     assert(std::abs(states[0][0] - expected) < tolerance);
 
-    std::cout << "✓ OpenMP integration test passed\n";
+    std::cout << "[PASS] OpenMP integration test passed\n";
 }
 #endif
 
@@ -298,8 +298,8 @@ void test_hardware_detection() {
     #endif
 
     std::cout << "Hardware/Library Detection (using standard functions):\n";
-    std::cout << "- std::execution: " << (std_execution_available ? "✓" : "✗") << "\n";
-    std::cout << "- OpenMP: " << (openmp_available ? "✓" : "✗");
+    std::cout << "- std::execution: " << (std_execution_available ? "[OK]" : "[FAIL]") << "\n";
+    std::cout << "- OpenMP: " << (openmp_available ? "[OK]" : "[FAIL]");
     if (openmp_available) {
         std::cout << " (" << num_threads << " threads)";
     }
@@ -309,18 +309,18 @@ void test_hardware_detection() {
     std::cout << "- GPU: Use cudaGetDeviceCount() for CUDA detection\n";
     std::cout << "- TBB: Use tbb::task_scheduler_init() for TBB detection\n";
 
-    std::cout << "✓ Hardware detection test passed (using standard library functions)\n";
+    std::cout << "[PASS] Hardware detection test passed (using standard library functions)\n";
 }
 
 int main() {
     std::cout << "=================================================================\n";
     std::cout << "Testing Standard Library Parallelism Integration\n";
     std::cout << "=================================================================\n";
     std::cout << "This demonstrates the approach requested:\n";
-    std::cout << "• Use standard libraries instead of custom parallel classes\n";
-    std::cout << "• Show flexibility beyond just initial conditions\n";
-    std::cout << "• No custom 'facade' classes needed\n";
-    std::cout << "• Standard library hardware detection\n\n";
+    std::cout << "- Use standard libraries instead of custom parallel classes\n";
+    std::cout << "- Show flexibility beyond just initial conditions\n";
+    std::cout << "- No custom 'facade' classes needed\n";
+    std::cout << "- Standard library hardware detection\n\n";
 
     try {
         test_hardware_detection();
@@ -340,18 +340,18 @@ int main() {
         std::cout << "\n";
         #endif
 
-        std::cout << "✅ All standard library parallelism tests passed!\n";
+        std::cout << "[PASS] All standard library parallelism tests passed!\n";
         std::cout << "\nKey Benefits Demonstrated:\n";
-        std::cout << "• ✓ No custom 'facade' classes - use proven standard libraries\n";
-        std::cout << "• ✓ std::execution::par for simple parallel loops\n";
-        std::cout << "• ✓ OpenMP for CPU-intensive computation\n";
-        std::cout << "• ✓ Flexibility: vary parameters, integrators, callbacks\n";
-        std::cout << "• ✓ Standard library hardware detection\n";
-        std::cout << "• ✓ Choose the right tool for each specific use case\n";
-        std::cout << "• ✓ GPU support via Thrust (no custom kernels needed)\n";
+        std::cout << "- [OK] No custom 'facade' classes - use proven standard libraries\n";
+        std::cout << "- [OK] std::execution::par for simple parallel loops\n";
+        std::cout << "- [OK] OpenMP for CPU-intensive computation\n";
+        std::cout << "- [OK] Flexibility: vary parameters, integrators, callbacks\n";
+        std::cout << "- [OK] Standard library hardware detection\n";
+        std::cout << "- [OK] Choose the right tool for each specific use case\n";
+        std::cout << "- [OK] GPU support via Thrust (no custom kernels needed)\n";
 
     } catch (const std::exception& e) {
-        std::cerr << "❌ Test failed: " << e.what() << std::endl;
+        std::cerr << "[FAIL] Test failed: " << e.what() << std::endl;
         return 1;
     }
 

test/unit/test_high_performance_sde.cpp

@@ -391,7 +391,7 @@ TEST_CASE("Convenience factory functions", "[sde_multithreading]") {
         auto latency = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start);
 
         REQUIRE(noise.increments.size() == 1);
-        REQUIRE(latency.count() < 100000);  // Should be sub-100μs
+        REQUIRE(latency.count() < 100000);  // Should be sub-100us
     }
 
     SECTION("create_numa_system") {

test/unit/test_output_facilities.cpp

@@ -59,11 +59,11 @@ bool test_interpolation_decorator() {
         assert(times.size() == 11);
         assert(states.size() == 11);
 
-        std::cout << "✓ PASSED\n";
+        std::cout << "[PASS] PASSED\n";
         return true;
 
     } catch (const std::exception& e) {
-        std::cout << "✗ FAILED: " << e.what() << "\n";
+        std::cout << "[FAIL] FAILED: " << e.what() << "\n";
         return false;
     }
 }
@@ -113,11 +113,11 @@ bool test_event_decorator() {
         assert(stats.total_events > 0);
         assert(stats.sensor_events > 0);
 
-        std::cout << "✓ PASSED (events: " << stats.total_events << ")\n";
+        std::cout << "[PASS] PASSED (events: " << stats.total_events << ")\n";
         return true;
 
     } catch (const std::exception& e) {
-        std::cout << "✗ FAILED: " << e.what() << "\n";
+        std::cout << "[FAIL] FAILED: " << e.what() << "\n";
         return false;
     }
 }
@@ -148,17 +148,17 @@ bool test_interprocess_decorator() {
             assert(ipc_decorator->config().direction == IPCDirection::PRODUCER);
             assert(ipc_decorator->config().buffer_size == 1024);
 
-            std::cout << "✓ PASSED (IPC created)\n";
+            std::cout << "[PASS] PASSED (IPC created)\n";
             return true;
 
         } catch (const std::runtime_error& e) {
             // IPC setup failed - this is expected in many test environments
-            std::cout << "✓ PASSED (IPC unavailable, but decorator created)\n";
+            std::cout << "[PASS] PASSED (IPC unavailable, but decorator created)\n";
             return true;
         }
 
     } catch (const std::exception& e) {
-        std::cout << "✗ FAILED: " << e.what() << "\n";
+        std::cout << "[FAIL] FAILED: " << e.what() << "\n";
         return false;
     }
 }
@@ -203,11 +203,11 @@ bool test_sde_synchronization() {
         auto stats = synchronizer.get_statistics();
         assert(stats.noise_requests > 0);
 
-        std::cout << "✓ PASSED\n";
+        std::cout << "[PASS] PASSED\n";
         return true;
 
     } catch (const std::exception& e) {
-        std::cout << "✗ FAILED: " << e.what() << "\n";
+        std::cout << "[FAIL] FAILED: " << e.what() << "\n";
         return false;
     }
 }
@@ -301,11 +301,11 @@ bool test_configuration_validation() {
             assert(caught_exception);
         }
 
-        std::cout << "✓ PASSED\n";
+        std::cout << "[PASS] PASSED\n";
         return true;
 
     } catch (const std::exception& e) {
-        std::cout << "✗ FAILED: " << e.what() << "\n";
+        std::cout << "[FAIL] FAILED: " << e.what() << "\n";
         return false;
     }
 }
@@ -341,10 +341,10 @@ int main() {
     std::cout << "Test Results: " << passed << "/" << total << " passed\n";
 
     if (passed == total) {
-        std::cout << "🎉 All tests passed!\n";
+        std::cout << "[PASS] All tests passed!\n";
         return 0;
     } else {
-        std::cout << "❌ Some tests failed.\n";
+        std::cout << "[FAIL] Some tests failed.\n";
         return 1;
     }
 } 

test/unit/test_rk4_integrator.cpp

@@ -33,13 +33,13 @@ void exponential_decay_float(float t, const std::vector<float>& y, std::vector<f
     dydt[0] = -y[0];
 }
 
-// Harmonic oscillator: d²x/dt² = -ω²x
+// Harmonic oscillator: d^2x/dt^2 = -omega^2*x
 // State vector: [x, dx/dt]
-// dy/dt = [y[1], -ω²*y[0]]
+// dy/dt = [y[1], -omega^2*y[0]]
 void harmonic_oscillator(double t, const std::vector<double>& y, std::vector<double>& dydt) {
-    const double omega_squared = 1.0; // ω² = 1
+    const double omega_squared = 1.0; // omega^2 = 1
     dydt[0] = y[1];           // dx/dt = v
-    dydt[1] = -omega_squared * y[0];  // dv/dt = -ω²x
+    dydt[1] = -omega_squared * y[0];  // dv/dt = -omega^2*x
 }
 
 bool test_rk4_double() {
@@ -163,17 +163,17 @@ int main() {
 
         std::cout << "\n=== Test Results ===" << std::endl;
         if (all_passed) {
-            std::cout << "🎉 All tests PASSED!" << std::endl;
+            std::cout << "[PASS] All tests PASSED!" << std::endl;
             return 0;
         } else {
-            std::cout << "❌ Some tests FAILED!" << std::endl;
+            std::cout << "[FAIL] Some tests FAILED!" << std::endl;
             return 1;
         }
     } catch (const std::exception& e) {
-        std::cerr << "❌ Test execution failed with exception: " << e.what() << std::endl;
+        std::cerr << "[FAIL] Test execution failed with exception: " << e.what() << std::endl;
         return 1;
     } catch (...) {
-        std::cerr << "❌ Test execution failed with unknown exception" << std::endl;
+        std::cerr << "[FAIL] Test execution failed with unknown exception" << std::endl;
         return 1;
     }
 }