only xmake, no cmake anymore

Author: WenyinWei

CMakeLists.txt

@@ -269,18 +269,9 @@ int main() {
 
 ### Prerequisites
 - C++20 compatible compiler (GCC 10+, Clang 12+, MSVC 2019+)
-- CMake 3.20+ (recommended) or xmake
+- xmake build system
 
-### Modern CMake Build (Recommended)
-```bash
-cd diffeq
-mkdir build && cd build
-cmake .. -DCMAKE_BUILD_TYPE=Release
-make -j$(nproc)
-ctest  # Run tests
-```
-
-### Legacy xmake Build
+### xmake Build
 ```bash
 cd diffeq
 xmake          # Build all examples and tests
@@ -293,9 +284,9 @@ Since the library is header-only, you can also simply:
 #include "path/to/diffeq/include/diffeq.hpp"
 ```
 
-Or with CMake:
-```cmake
-find_package(diffeq REQUIRED)
+Or with xmake:
+```lua
+add_requires("diffeq")
 target_link_libraries(your_target diffeq::diffeq)
 ```
 

README.md

@@ -657,34 +657,34 @@ public:
 
 ## Building and Dependencies
 
-### CMake Integration
-```cmake
-# For std::execution
-target_compile_features(your_target PRIVATE cxx_std_17)
-
-# For OpenMP
-find_package(OpenMP REQUIRED)
-target_link_libraries(your_target OpenMP::OpenMP_CXX)
-
-# For Intel TBB
-find_package(TBB REQUIRED)
-target_link_libraries(your_target TBB::tbb)
-
-# For NVIDIA Thrust (comes with CUDA)
-find_package(CUDA REQUIRED)
-target_link_libraries(your_target ${CUDA_LIBRARIES})
-
-# For direct CUDA kernel usage
-enable_language(CUDA)
-set_property(TARGET your_target PROPERTY CUDA_SEPARABLE_COMPILATION ON)
-
-# For OpenCL
-find_package(OpenCL REQUIRED)
-target_link_libraries(your_target OpenCL::OpenCL)
-
-# For MPI (distributed computing)
-find_package(MPI REQUIRED)
-target_link_libraries(your_target MPI::MPI_CXX)
+### xmake Integration
+```lua
+-- For std::execution
+set_languages("c++17")
+
+-- For OpenMP
+add_requires("openmp")
+target_link_libraries(your_target openmp)
+
+-- For Intel TBB
+add_requires("tbb")
+target_link_libraries(your_target tbb)
+
+-- For NVIDIA Thrust (comes with CUDA)
+add_requires("cuda")
+target_link_libraries(your_target cuda)
+
+-- For direct CUDA kernel usage
+set_languages("cuda")
+set_policy("build.cuda.devlink", true)
+
+-- For OpenCL
+add_requires("opencl")
+target_link_libraries(your_target opencl)
+
+-- For MPI (distributed computing)
+add_requires("mpi")
+target_link_libraries(your_target mpi)
 ```
 
 ## Summary: Choosing the Right Approach

docs/STANDARD_PARALLELISM.md

@@ -54,19 +54,14 @@ This directory contains comprehensive examples demonstrating how to use the diff
 ### Prerequisites
 
 - C++17 or later compiler
-- CMake or xmake build system
+- xmake build system
 - Optional: OpenMP, Intel TBB, CUDA for advanced parallelism examples
 
 ### Building
 
 ```bash
-# Using xmake (recommended)
+# Using xmake
 xmake
-
-# Or using CMake
-mkdir build && cd build
-cmake ..
-make
 ```
 
 ### Running Examples

examples/README.md

@@ -7,8 +7,6 @@
 #include <chrono>
 #include <iostream>
 
-namespace diffeq::examples {
-
 /**
  * @brief Example usage patterns for the general integration interface
  * 
@@ -21,12 +19,12 @@ namespace diffeq::examples {
  */
 template<system_state StateType>
 auto create_portfolio_interface() {
-    auto interface = interfaces::make_integration_interface<StateType>();
+    auto interface = diffeq::interfaces::make_integration_interface<StateType>();
 
     // Example: Market data signal causes continuous trajectory shift
     interface->template register_signal_influence<double>(
         "price_update",
-        interfaces::IntegrationInterface<StateType>::InfluenceMode::CONTINUOUS_SHIFT,
+        diffeq::interfaces::IntegrationInterface<StateType>::InfluenceMode::CONTINUOUS_SHIFT,
         [](const double& new_price, StateType& state, auto t) {
             // Modify portfolio dynamics based on price update
             if (state.size() >= 3) {
@@ -42,7 +40,7 @@ auto create_portfolio_interface() {
     // Example: Risk alert causes discrete state modification
     interface->template register_signal_influence<std::string>(
         "risk_alert",
-        interfaces::IntegrationInterface<StateType>::InfluenceMode::DISCRETE_EVENT,
+        diffeq::interfaces::IntegrationInterface<StateType>::InfluenceMode::DISCRETE_EVENT,
         [](const std::string& alert_type, StateType& state, auto t) {
             if (alert_type == "high_volatility" && state.size() >= 3) {
                 // Reduce all positions by 10%
@@ -76,12 +74,12 @@ auto create_portfolio_interface() {
  */
 template<system_state StateType>
 auto create_robotics_interface() {
-    auto interface = interfaces::make_integration_interface<StateType>();
+    auto interface = diffeq::interfaces::make_integration_interface<StateType>();
 
     // Example: Control command causes discrete position target update
     interface->template register_signal_influence<std::vector<double>>(
         "control_command",
-        interfaces::IntegrationInterface<StateType>::InfluenceMode::DISCRETE_EVENT,
+        diffeq::interfaces::IntegrationInterface<StateType>::InfluenceMode::DISCRETE_EVENT,
         [](const std::vector<double>& targets, StateType& state, auto t) {
             // Update target positions (assuming state has position targets)
             size_t n_joints = std::min(targets.size(), state.size() / 3);
@@ -98,7 +96,7 @@ auto create_robotics_interface() {
     // Example: Emergency stop signal
     interface->template register_signal_influence<bool>(
         "emergency_stop",
-        interfaces::IntegrationInterface<StateType>::InfluenceMode::DISCRETE_EVENT,
+        diffeq::interfaces::IntegrationInterface<StateType>::InfluenceMode::DISCRETE_EVENT,
         [](const bool& stop, StateType& state, auto t) {
             if (stop) {
                 // Set all velocities to zero
@@ -136,12 +134,12 @@ auto create_robotics_interface() {
  */
 template<system_state StateType>
 auto create_scientific_interface() {
-    auto interface = interfaces::make_integration_interface<StateType>();
+    auto interface = diffeq::interfaces::make_integration_interface<StateType>();
 
     // Example: Parameter update from external optimization
     interface->template register_signal_influence<double>(
         "parameter_update",
-        interfaces::IntegrationInterface<StateType>::InfluenceMode::PARAMETER_UPDATE,
+        diffeq::interfaces::IntegrationInterface<StateType>::InfluenceMode::PARAMETER_UPDATE,
         [](const double& new_param, StateType& state, auto t) {
             // Update system parameters affecting dynamics
             // This could modify integration tolerances, system constants, etc.
@@ -151,7 +149,7 @@ auto create_scientific_interface() {
     // Example: Data logging triggered by external events
     interface->template register_signal_influence<std::string>(
         "log_trigger",
-        interfaces::IntegrationInterface<StateType>::InfluenceMode::OUTPUT_TRIGGER,
+        diffeq::interfaces::IntegrationInterface<StateType>::InfluenceMode::OUTPUT_TRIGGER,
         [](const std::string& log_type, StateType& state, auto t) {
             // This will trigger all output streams immediately
         }
@@ -221,19 +219,17 @@ void demonstrate_usage(StateType initial_state) {
     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);
+    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>>();
+    auto robotics_interface = create_robotics_interface<std::vector<double>>();
 
     // Define robot dynamics
     auto robot_ode = [](double t, const std::vector<double>& y, std::vector<double>& dydt) {
@@ -243,7 +239,7 @@ int main() {
     };
 
     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);
+    auto robot_integrator = diffeq::make_rk45<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();
@@ -267,7 +263,7 @@ int main() {
     std::cout << "\n=== Scientific Interface Example ===" << std::endl;
 
     // Create scientific interface
-    auto scientific_interface = diffeq::examples::create_scientific_interface<std::vector<double>>();
+    auto scientific_interface = 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) {

examples/interface_usage_demo.cpp

@@ -4,8 +4,6 @@
 #include <chrono>
 #include <random>
 
-namespace diffeq::examples::parallelism {
-
 /**
  * @brief Quick Start Example - Simplified Parallel Interface
  * 
@@ -364,13 +362,11 @@ void demonstrate_all_parallelism_features() {
     std::cout << "\n=== All parallelism features demonstrated! ===" << std::endl;
 }
 
-} // namespace diffeq::examples::parallelism
-
 int main() {
     std::cout << "=== diffeq Parallelism Usage Examples ===" << std::endl;
 
     // Run comprehensive demonstration
-    diffeq::examples::parallelism::demonstrate_all_parallelism_features();
+    demonstrate_all_parallelism_features();
 
     return 0;
 }