.. _program_listing_file_include_diffeq.hpp:

Program Listing for File diffeq.hpp
===================================

|exhale_lsh| :ref:`Return to documentation for file <file_include_diffeq.hpp>` (``include/diffeq.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #pragma once
   
   // Core concepts and base classes
   #include <core/concepts.hpp>
   #include <core/abstract_integrator.hpp>
   #include <core/adaptive_integrator.hpp>
   #include <core/timeout_integrator.hpp>
   #include <core/composable_integration.hpp>
   
   // ODE integrator implementations (organized by method type)
   #include <integrators/ode/euler.hpp>           // Simple Euler method
   #include <integrators/ode/improved_euler.hpp>  // Heun's method
   #include <integrators/ode/rk4.hpp>             // Classic 4th order Runge-Kutta
   #include <integrators/ode/rk23.hpp>            // RK23 (adaptive, Bogacki-Shampine)
   #include <integrators/ode/rk45.hpp>            // RK45 (adaptive, Dormand-Prince)
   #include <integrators/ode/dop853.hpp>          // DOP853 (8th order, high accuracy)
   #include <integrators/ode/bdf.hpp>             // BDF (multistep, stiff systems) - SciPy-compatible
   #include <integrators/ode/lsoda.hpp>           // LSODA (automatic stiff/non-stiff switching)
   
   // SDE (Stochastic Differential Equation) integrators (organized by method type)
   #include <sde/sde_base.hpp>                    // SDE base infrastructure
   #include <integrators/sde/euler_maruyama.hpp>  // Basic SDE solver (strong order 0.5)
   #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
   #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
   #include <integrators/sde/sosra.hpp>           // Stability-optimized SRA
   #include <integrators/sde/sri.hpp>             // SRI base implementation
   #include <integrators/sde/sriw1.hpp>           // SRIW1 variant for general SDEs
   #include <integrators/sde/sosri.hpp>           // Stability-optimized SRI
   
   // Modern async and signal processing components (standard C++ only)
   #include <async/async_integrator.hpp>    // Async integration with std::future
   #include <signal/signal_processor.hpp>   // Generic signal processing
   #include <interfaces/integration_interface.hpp>  // Unified interface for all domains
   
   // Standard parallelism library integration examples
   // Note: Use standard libraries (std::execution, OpenMP, TBB, Thrust) instead of custom parallel classes
   // See docs/STANDARD_PARALLELISM.md and examples/standard_parallelism_demo.cpp for integration examples
   
   namespace diffeq {
       // Re-export core functionality
       using core::TimeoutIntegrator;
       using core::IntegrationResult;
       using core::IntegrationTimeoutException;
       using core::make_timeout_integrator;
       using core::integrate_with_timeout;
       
       // Note: ParallelTimeoutIntegrator was removed in favor of composable architecture
       // Use make_builder(base).with_timeout().with_parallel().build() instead
       
       // Re-export composable integration facilities
       using core::composable::IntegratorDecorator;
       using core::composable::TimeoutDecorator;
       using core::composable::ParallelDecorator;
       using core::composable::OutputDecorator;
       using core::composable::SignalDecorator;
       using core::composable::IntegratorBuilder;
       using core::composable::make_builder;
       using core::composable::with_timeout_only;
       using core::composable::with_parallel_only;
       using core::composable::TimeoutConfig;
       using core::composable::TimeoutResult;
       using core::composable::ParallelConfig;
       using core::composable::OutputConfig;
       using core::composable::OutputMode;
       using core::composable::SignalConfig;
       
       // Re-export integrator classes for convenience
       // Note: Integrators are already in diffeq namespace, no need to re-export
       
       // Re-export SDE integrators
       // Note: SDE integrators are already in diffeq namespace, no need to re-export
       
       // Common type aliases for system_state concept
       template<typename T>
       using VectorState = std::vector<T>;
       
       template<typename T, std::size_t N>
       using ArrayState = std::array<T, N>;
       
       // Default scalar types for can_be_time concept
       using DefaultScalar = double;
       using DefaultTime = double;
   }