diffeq.hpp

Go to the documentation of this file.

#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;
}