Crate scirs2_integrate 

SciRS2 Integrate - Numerical Integration and ODE/PDE Solvers

scirs2-integrate provides comprehensive numerical integration methods and differential equation solvers modeled after SciPy’s integrate module, with support for quadrature, ODEs, DAEs, PDEs, and specialized domain-specific solvers for physics, finance, and quantum mechanics.

🎯 Key Features

• SciPy Compatibility: Drop-in replacement for scipy.integrate functions
• Adaptive Quadrature: Automatic error control for definite integrals
• ODE Solvers: Explicit/implicit methods (RK45, BDF, Adams) for IVPs and BVPs
• PDE Solvers: Finite difference, finite element, spectral methods
• DAE Support: Differential-algebraic equations with index reduction
• Symplectic Integrators: Structure-preserving methods for Hamiltonian systems
• Specialized Solvers: Quantum mechanics, fluid dynamics, financial PDEs
• GPU Acceleration: CUDA/ROCm support for large-scale problems

📦 Module Overview

SciRS2 Module	SciPy Equivalent	Description
quad	scipy.integrate.quad	Adaptive quadrature (1D integrals)
quad_vec	scipy.integrate.quad_vec	Vectorized quadrature
tanhsinh	-	Tanh-sinh quadrature (high accuracy)
romberg	scipy.integrate.romberg	Romberg integration
monte_carlo	-	Monte Carlo integration (high dimensions)
ode	scipy.integrate.solve_ivp	ODE initial value problems
bvp	scipy.integrate.solve_bvp	ODE boundary value problems
dae	-	Differential-algebraic equations
pde	-	Partial differential equations
symplectic	-	Symplectic integrators (Hamiltonian systems)
specialized	-	Domain-specific solvers (quantum, finance, fluids)

🚀 Quick Start

Add to your Cargo.toml:

[dependencies]
scirs2-integrate = "0.1.0-rc.2"

Basic Quadrature (1D Integration)

use scirs2_integrate::quad::quad;

// Integrate f(x) = x² from 0 to 1 (exact result: 1/3)
let result = quad(|x: f64| x * x, 0.0, 1.0, None).unwrap();
assert!((result.value - 1.0/3.0).abs() < 1e-8);

Gaussian Quadrature

use scirs2_integrate::gaussian::gauss_legendre;

// Integrate f(x) = x² from 0 to 1 (exact result: 1/3)
let result = gauss_legendre(|x: f64| x * x, 0.0, 1.0, 5).unwrap();
assert!((result - 1.0/3.0).abs() < 1e-10);

Romberg Integration

use scirs2_integrate::romberg::romberg;

// Integrate f(x) = x² from 0 to 1 (exact result: 1/3)
let result = romberg(|x: f64| x * x, 0.0, 1.0, None).unwrap();
assert!((result.value - 1.0/3.0).abs() < 1e-10);

Monte Carlo Integration

use scirs2_integrate::monte_carlo::{monte_carlo, MonteCarloOptions};
use scirs2_core::ndarray::ArrayView1;

// Integrate f(x) = x² from 0 to 1 (exact result: 1/3)
let options = MonteCarloOptions {
    n_samples: 10000,
    seed: Some(42),  // For reproducibility
    ..Default::default()
};

let result = monte_carlo(
    |x: ArrayView1<f64>| x[0] * x[0],
    &[(0.0, 1.0)],
    Some(options)
).unwrap();

// Monte Carlo has statistical error, so we use a loose tolerance
assert!((result.value - 1.0/3.0).abs() < 0.02);

ODE Solving (Initial Value Problem)

use scirs2_core::ndarray::{array, ArrayView1};
use scirs2_integrate::ode::{solve_ivp, ODEOptions, ODEMethod};

// Solve y'(t) = -y with initial condition y(0) = 1
let result = solve_ivp(
    |_: f64, y: ArrayView1<f64>| array![-y[0]],
    [0.0, 1.0],
    array![1.0],
    None
).unwrap();

// Final value should be close to e^(-1) ≈ 0.368
let final_y = result.y.last().expect("Solution should have at least one point")[0];
assert!((final_y - 0.368).abs() < 1e-2);

PDE Solving (Heat Equation)

use scirs2_integrate::pde::{MOLParabolicSolver1D, MOLOptions, BoundaryCondition};

// Solve heat equation: ∂u/∂t = α ∂²u/∂x²
let nx = 50;  // Number of spatial points
let alpha = 0.01;  // Thermal diffusivity

// Initial condition: u(x, 0) = sin(πx)
let initial_condition = |x: f64| (std::f64::consts::PI * x).sin();

let options = MOLOptions {
    left_bc: BoundaryCondition::Dirichlet(0.0),
    right_bc: BoundaryCondition::Dirichlet(0.0),
    ..Default::default()
};

let solver = MOLParabolicSolver1D::new(
    initial_condition,
    alpha,
    0.0,
    1.0,
    nx,
    options,
);

Symplectic Integration (Hamiltonian Systems)

use scirs2_core::ndarray::array;
use scirs2_integrate::symplectic::{velocity_verlet, HamiltonianSystem};

// Simple harmonic oscillator: H = p²/2 + q²/2
let system = HamiltonianSystem {
    kinetic: |p: &[f64]| 0.5 * p[0] * p[0],
    potential: |q: &[f64]| 0.5 * q[0] * q[0],
};

let q0 = vec![1.0];  // Initial position
let p0 = vec![0.0];  // Initial momentum
let dt = 0.01;
let n_steps = 1000;

let result = velocity_verlet(&system, &q0, &p0, dt, n_steps);

🏗️ Architecture

scirs2-integrate
├── Quadrature Methods
│   ├── Adaptive (quad, quad_vec)
│   ├── Fixed-order (trapezoid, Simpson, Newton-Cotes)
│   ├── Gaussian (Legendre, Chebyshev, Hermite, Laguerre)
│   ├── Romberg (Richardson extrapolation)
│   ├── Tanh-sinh (double exponential)
│   └── Monte Carlo (importance sampling, QMC)
├── ODE Solvers
│   ├── Explicit (RK23, RK45, Dormand-Prince)
│   ├── Implicit (BDF, Radau)
│   ├── Adams methods (multistep)
│   ├── BVP (shooting, finite difference)
│   └── Events & dense output
├── DAE Solvers
│   ├── Index-1 DAEs (semi-explicit)
│   ├── Higher-index DAEs (index reduction)
│   └── Implicit DAEs (Newton-Krylov)
├── PDE Solvers
│   ├── Finite Difference (MOL, ADI, Crank-Nicolson)
│   ├── Finite Element (triangular, quadrilateral meshes)
│   ├── Spectral Methods (Fourier, Chebyshev, Legendre)
│   └── Spectral Elements (high-order accuracy)
├── Structure-Preserving
│   ├── Symplectic integrators (Verlet, Störmer-Verlet)
│   ├── Geometric integrators (Lie groups, manifolds)
│   └── Volume-preserving methods
└── Specialized Solvers
    ├── Quantum mechanics (Schrödinger, multi-body)
    ├── Fluid dynamics (Navier-Stokes, spectral)
    ├── Finance (Black-Scholes, stochastic PDEs)
    └── GPU-accelerated solvers

📊 Performance

Problem Type	Size	CPU	GPU	Speedup
1D Quadrature	10⁶ points	25ms	N/A	-
ODE (RK45)	10⁴ steps	180ms	15ms	12×
2D Heat Equation	100×100 grid	450ms	8ms	56×
3D Poisson	64³ grid	3.2s	45ms	71×
Navier-Stokes	128² grid	8.5s	120ms	71×

Note: Benchmarks on AMD Ryzen 9 5950X + NVIDIA RTX 3090.

🔗 Integration

• scirs2-linalg: Matrix operations for implicit solvers
• scirs2-special: Special functions (Bessel, Hermite) for Gaussian quadrature
• scirs2-optimize: Root finding for BVPs and implicit equations
• scirs2-fft: Spectral methods for PDEs

🔒 Version Information

• Version: 0.1.0-rc.2
• Release Date: October 03, 2025
• MSRV (Minimum Supported Rust Version): 1.70.0
• Documentation: docs.rs/scirs2-integrate
• Repository: github.com/cool-japan/scirs

Re-exports

pub use common::IntegrateFloat;

pub use error::IntegrateError;

pub use error::IntegrateResult;

pub use acceleration::AcceleratorOptions;

pub use acceleration::AitkenAccelerator;

pub use acceleration::AndersonAccelerator;

pub use autotuning::AlgorithmTuner;

pub use autotuning::AutoTuner;

pub use autotuning::GpuInfo;

pub use autotuning::HardwareDetector;

pub use autotuning::HardwareInfo;

pub use autotuning::SimdFeature;

pub use autotuning::TuningProfile;

pub use bvp::solve_bvp;

pub use bvp::solve_bvp_auto;

pub use bvp::BVPOptions;

pub use bvp::BVPResult;

pub use bvp_extended::solve_bvp_extended;

pub use bvp_extended::solve_multipoint_bvp;

pub use bvp_extended::BoundaryConditionType as BVPBoundaryConditionType;

pub use bvp_extended::ExtendedBoundaryConditions;

pub use bvp_extended::MultipointBVP;

pub use bvp_extended::RobinBC;

pub use cubature::cubature;

pub use cubature::nquad;

pub use cubature::Bound;

pub use cubature::CubatureOptions;

pub use cubature::CubatureResult;

pub use dae::bdf_implicit_dae;

pub use dae::bdf_implicit_with_index_reduction;

pub use dae::bdf_semi_explicit_dae;

pub use dae::bdf_with_index_reduction;

pub use dae::create_block_ilu_preconditioner;

pub use dae::create_block_jacobi_preconditioner;

pub use dae::krylov_bdf_implicit_dae;

pub use dae::krylov_bdf_semi_explicit_dae;

pub use dae::solve_higher_index_dae;

pub use dae::solve_implicit_dae;

pub use dae::solve_ivp_dae;

pub use dae::solve_semi_explicit_dae;

pub use dae::DAEIndex;

pub use dae::DAEOptions;

pub use dae::DAEResult;

pub use dae::DAEStructure;

pub use dae::DAEType;

pub use dae::DummyDerivativeReducer;

pub use dae::PantelidesReducer;

pub use dae::ProjectionMethod;

pub use lebedev::lebedev_integrate;

pub use lebedev::lebedev_rule;

pub use lebedev::LebedevOrder;

pub use lebedev::LebedevRule;

pub use memory::BlockingStrategy;

pub use memory::CacheAwareAlgorithms;

pub use memory::CacheFriendlyMatrix;

pub use memory::CacheLevel;

pub use memory::DataLayoutOptimizer;

pub use memory::MatrixLayout;

pub use memory::MemoryPool;

pub use memory::MemoryPrefetch;

pub use memory::MemoryUsage;

pub use memory::PooledBuffer;

pub use monte_carlo::importance_sampling;

pub use monte_carlo::monte_carlo;

pub use monte_carlo::monte_carlo_parallel;

pub use monte_carlo::ErrorEstimationMethod;

pub use monte_carlo::MonteCarloOptions;

pub use monte_carlo::MonteCarloResult;

pub use newton_cotes::newton_cotes;

pub use newton_cotes::newton_cotes_integrate;

pub use newton_cotes::NewtonCotesResult;

pub use newton_cotes::NewtonCotesType;

pub use ode::solve_ivp;

pub use ode::solve_ivp_with_events;

pub use ode::terminal_event;

pub use ode::EventAction;

pub use ode::EventDirection;

pub use ode::EventSpec;

pub use ode::MassMatrix;

pub use ode::MassMatrixType;

pub use ode::ODEMethod;

pub use ode::ODEOptions;

pub use ode::ODEOptionsWithEvents;

pub use ode::ODEResult;

pub use ode::ODEResultWithEvents;

pub use pde::elliptic::EllipticOptions;

pub use pde::elliptic::EllipticResult;

pub use pde::elliptic::LaplaceSolver2D;

pub use pde::elliptic::PoissonSolver2D;

pub use pde::finite_difference::first_derivative;

pub use pde::finite_difference::first_derivative_matrix;

pub use pde::finite_difference::second_derivative;

pub use pde::finite_difference::second_derivative_matrix;

pub use pde::finite_difference::FiniteDifferenceScheme;

pub use pde::finite_element::BoundaryNodeInfo;

pub use pde::finite_element::ElementType;

pub use pde::finite_element::FEMOptions;

pub use pde::finite_element::FEMPoissonSolver;

pub use pde::finite_element::FEMResult;

pub use pde::finite_element::Point;

pub use pde::finite_element::Triangle;

pub use pde::finite_element::TriangularMesh;

pub use pde::method_of_lines::MOL2DResult;

pub use pde::method_of_lines::MOL3DResult;

pub use pde::method_of_lines::MOLHyperbolicResult;

pub use pde::method_of_lines::MOLOptions;

pub use pde::method_of_lines::MOLParabolicSolver1D;

pub use pde::method_of_lines::MOLParabolicSolver2D;

pub use pde::method_of_lines::MOLParabolicSolver3D;

pub use pde::method_of_lines::MOLResult;

pub use pde::method_of_lines::MOLWaveEquation1D;

pub use pde::spectral::spectral_element::QuadElement;

pub use pde::spectral::spectral_element::SpectralElementMesh2D;

pub use pde::spectral::spectral_element::SpectralElementOptions;

pub use pde::spectral::spectral_element::SpectralElementPoisson2D;

pub use pde::spectral::spectral_element::SpectralElementResult;

pub use pde::spectral::chebyshev_inverse_transform;

pub use pde::spectral::chebyshev_points;

pub use pde::spectral::chebyshev_transform;

pub use pde::spectral::legendre_diff2_matrix;

pub use pde::spectral::legendre_diff_matrix;

pub use pde::spectral::legendre_inverse_transform;

pub use pde::spectral::legendre_points;

pub use pde::spectral::legendre_transform;

pub use pde::spectral::ChebyshevSpectralSolver1D;

pub use pde::spectral::FourierSpectralSolver1D;

pub use pde::spectral::LegendreSpectralSolver1D;

pub use pde::spectral::SpectralBasis;

pub use pde::spectral::SpectralOptions;

pub use pde::spectral::SpectralResult;

pub use pde::BoundaryCondition;

pub use pde::BoundaryConditionType;

pub use pde::BoundaryLocation;

pub use pde::Domain;

pub use pde::PDEError;

pub use pde::PDEResult;

pub use pde::PDESolution;

pub use pde::PDESolverInfo;

pub use pde::PDEType;

pub use symbolic::detect_conservation_laws;

pub use symbolic::generate_jacobian;

pub use symbolic::higher_order_to_first_order;

pub use symbolic::simplify;

pub use symbolic::ConservationEnforcer;

pub use symbolic::ConservationLaw;

pub use symbolic::FirstOrderSystem;

pub use symbolic::HigherOrderODE;

pub use symbolic::SymbolicExpression;

pub use symbolic::SymbolicJacobian;

pub use symbolic::Variable;

pub use autodiff::compress_jacobian;

pub use autodiff::compute_sensitivities;

pub use autodiff::detect_sparsity;

pub use autodiff::forward_gradient;

pub use autodiff::forward_jacobian;

pub use autodiff::reverse_gradient;

pub use autodiff::reverse_jacobian;

pub use autodiff::Dual;

pub use autodiff::DualVector;

pub use autodiff::ForwardAD;

pub use autodiff::ParameterSensitivity;

pub use autodiff::ReverseAD;

pub use autodiff::SensitivityAnalysis;

pub use autodiff::SparseJacobian;

pub use autodiff::SparsePattern;

pub use autodiff::TapeNode;

pub use specialized::DealiasingStrategy;

pub use specialized::FinanceMethod;

pub use specialized::FinancialOption;

pub use specialized::FluidBoundaryCondition;

pub use specialized::FluidState;

pub use specialized::FluidState3D;

pub use specialized::GPUMultiBodyQuantumSolver;

pub use specialized::GPUQuantumSolver;

pub use specialized::Greeks;

pub use specialized::HarmonicOscillator;

pub use specialized::HydrogenAtom;

pub use specialized::JumpProcess;

pub use specialized::LESolver;

pub use specialized::NavierStokesParams;

pub use specialized::NavierStokesSolver;

pub use specialized::OptionStyle;

pub use specialized::OptionType;

pub use specialized::ParticleInBox;

pub use specialized::QuantumAnnealer;

pub use specialized::QuantumPotential;

pub use specialized::QuantumState;

pub use specialized::RANSModel;

pub use specialized::RANSSolver;

pub use specialized::RANSState;

pub use specialized::SGSModel;

pub use specialized::SchrodingerMethod;

pub use specialized::SchrodingerSolver;

pub use specialized::SpectralNavierStokesSolver;

pub use specialized::StochasticPDESolver;

pub use specialized::VolatilityModel;

pub use geometric::ABCFlow;

pub use geometric::AngularMomentumInvariant2D;

pub use geometric::CircularFlow2D;

pub use geometric::ConservationChecker;

pub use geometric::ConstrainedIntegrator;

pub use geometric::DiscreteGradientIntegrator;

pub use geometric::DivergenceFreeFlow;

pub use geometric::DoubleGyre;

pub use geometric::EnergyInvariant;

pub use geometric::EnergyMomentumIntegrator;

pub use geometric::EnergyPreservingMethod;

pub use geometric::ExponentialMap;

pub use geometric::GLn;

pub use geometric::GeometricInvariant;

pub use geometric::Gln;

pub use geometric::HamiltonianFlow;

pub use geometric::HeisenbergAlgebra;

pub use geometric::HeisenbergGroup;

pub use geometric::IncompressibleFlow;

pub use geometric::LieAlgebra;

pub use geometric::LieGroupIntegrator;

pub use geometric::LieGroupMethod;

pub use geometric::LinearMomentumInvariant;

pub use geometric::ModifiedMidpointIntegrator;

pub use geometric::MomentumPreservingMethod;

pub use geometric::MultiSymplecticIntegrator;

pub use geometric::SE3Integrator;

pub use geometric::SLn;

pub use geometric::SO3Integrator;

pub use geometric::Se3;

pub use geometric::Sln;

pub use geometric::So3;

pub use geometric::Sp2n;

pub use geometric::SplittingIntegrator;

pub use geometric::StreamFunction;

pub use geometric::StructurePreservingIntegrator;

pub use geometric::StructurePreservingMethod;

pub use geometric::StuartVortex;

pub use geometric::TaylorGreenVortex;

pub use geometric::VariationalIntegrator;

pub use geometric::VolumeChecker;

pub use geometric::VolumePreservingIntegrator;

pub use geometric::VolumePreservingMethod;

pub use geometric::SE3;

pub use geometric::SO3;

pub use analysis::advanced::BifurcationPointData;

pub use analysis::advanced::ContinuationAnalyzer;

pub use analysis::advanced::FixedPointData;

pub use analysis::advanced::MonodromyAnalyzer;

pub use analysis::advanced::MonodromyResult;

pub use analysis::advanced::PeriodicStabilityType;

pub use analysis::BasinAnalysis;

pub use analysis::BifurcationAnalyzer;

pub use analysis::BifurcationPoint;

pub use analysis::BifurcationType;

pub use analysis::ContinuationResult;

pub use analysis::FixedPoint;

pub use analysis::PeriodicOrbit;

pub use analysis::StabilityAnalyzer;

pub use analysis::StabilityResult;

pub use analysis::StabilityType;

pub use visualization::AttractorStability;

pub use visualization::BifurcationDiagram;

pub use visualization::ColorScheme;

pub use visualization::HeatMapPlot;

pub use visualization::OutputFormat;

pub use visualization::ParameterExplorationPlot;

pub use visualization::PhaseSpace3D;

pub use visualization::PhaseSpacePlot;

pub use visualization::PlotMetadata;

pub use visualization::PlotStatistics;

pub use visualization::RealTimeBifurcationPlot;

pub use visualization::SensitivityPlot;

pub use visualization::SurfacePlot;

pub use visualization::VectorFieldPlot;

pub use amr_advanced::AMRAdaptationResult;

pub use amr_advanced::AdaptiveCell;

pub use amr_advanced::AdaptiveMeshLevel;

pub use amr_advanced::AdvancedAMRManager;

pub use amr_advanced::CurvatureRefinementCriterion;

pub use amr_advanced::FeatureDetectionCriterion;

pub use amr_advanced::GeometricLoadBalancer;

pub use amr_advanced::GradientRefinementCriterion;

pub use amr_advanced::LoadBalancer;

pub use amr_advanced::MeshHierarchy;

pub use amr_advanced::RefinementCriterion;

pub use error_estimation::AdvancedErrorEstimator;

pub use error_estimation::DefectCorrector;

pub use error_estimation::ErrorAnalysisResult;

pub use error_estimation::ErrorDistribution;

pub use error_estimation::RichardsonExtrapolator;

pub use error_estimation::SolutionQualityMetrics;

pub use error_estimation::SpectralErrorIndicator;

pub use parallel_optimization::LoadBalancingStrategy;

pub use parallel_optimization::NumaTopology;

pub use parallel_optimization::ParallelExecutionStats;

pub use parallel_optimization::ParallelOptimizer;

pub use parallel_optimization::ParallelTask;

pub use parallel_optimization::VectorOperation;

pub use parallel_optimization::VectorizedComputeTask;

pub use parallel_optimization::WorkStealingConfig;

pub use parallel_optimization::WorkStealingStats;

pub use performance_monitor::ConvergenceAnalysis as PerfConvergenceAnalysis;

pub use performance_monitor::OptimizationRecommendation;

pub use performance_monitor::PerformanceAnalyzer;

pub use performance_monitor::PerformanceBottleneck;

pub use performance_monitor::PerformanceMetrics;

pub use performance_monitor::PerformanceProfiler;

pub use performance_monitor::PerformanceReport;

pub use advanced_memory_optimization::AccessPattern;

pub use advanced_memory_optimization::AdvancedMemoryOptimizer;

pub use advanced_memory_optimization::CacheStrategy;

pub use advanced_memory_optimization::L1CacheBuffer;

pub use advanced_memory_optimization::L2CacheBuffer;

pub use advanced_memory_optimization::L3CacheBuffer;

pub use advanced_memory_optimization::MemoryHierarchyManager;

pub use advanced_memory_optimization::MemoryLayout;

pub use advanced_memory_optimization::MemoryTier;

pub use advanced_memory_optimization::MemoryType;

pub use advanced_memory_optimization::NumaPlacement;

pub use advanced_memory_optimization::OptimizedMemoryRegion;

pub use advanced_memory_optimization::PrefetchStrategy;

pub use advanced_memory_optimization::ZeroCopyBuffer;

pub use advanced_memory_optimization::ZeroCopyBufferPool;

pub use advanced_simd_acceleration::AdvancedSimdAccelerator;

pub use advanced_simd_acceleration::Avx512Support;

pub use advanced_simd_acceleration::MixedPrecisionOperation;

pub use advanced_simd_acceleration::PrecisionLevel;

pub use advanced_simd_acceleration::SimdCapabilities;

pub use advanced_simd_acceleration::SveSupport;

pub use advanced_simd_acceleration::VectorizationStrategies;

pub use gpu_advanced_acceleration::AdvancedGPUAccelerator;

pub use gpu_advanced_acceleration::AdvancedGPUMemoryPool;

pub use gpu_advanced_acceleration::GpuDeviceInfo;

pub use gpu_advanced_acceleration::LoadBalancingStrategy as GpuLoadBalancingStrategy;

pub use gpu_advanced_acceleration::MemoryBlock;

pub use gpu_advanced_acceleration::MemoryBlockType;

pub use gpu_advanced_acceleration::MultiGpuConfiguration;

pub use gpu_advanced_acceleration::RealTimeGpuMonitor;

pub use realtime_performance_adaptation::AdaptationStrategy;

pub use realtime_performance_adaptation::AlgorithmSwitchRecommendation;

pub use realtime_performance_adaptation::AnomalyAnalysisResult;

pub use realtime_performance_adaptation::AnomalySeverity;

pub use realtime_performance_adaptation::AnomalyType;

pub use realtime_performance_adaptation::OptimizationRecommendations;

pub use realtime_performance_adaptation::PerformanceAnalysis;

pub use realtime_performance_adaptation::PerformanceAnomaly;

pub use realtime_performance_adaptation::PerformanceBottleneck as AdaptivePerformanceBottleneck;

pub use realtime_performance_adaptation::PerformanceMetrics as AdaptivePerformanceMetrics;

pub use realtime_performance_adaptation::PerformanceTrend;

pub use realtime_performance_adaptation::RealTimeAdaptiveOptimizer;

pub use neural_rl_step_control::DeepQNetwork;

pub use neural_rl_step_control::Experience;

pub use neural_rl_step_control::NetworkWeights;

pub use neural_rl_step_control::NeuralRLStepController;

pub use neural_rl_step_control::PrioritizedExperienceReplay;

pub use neural_rl_step_control::RLEvaluationResults;

pub use neural_rl_step_control::StateFeatureExtractor;

pub use neural_rl_step_control::StepSizePrediction;

pub use neural_rl_step_control::TrainingConfiguration;

pub use neural_rl_step_control::TrainingResult;

pub use pde::implicit::ADIResult;

pub use pde::implicit::BackwardEuler1D;

pub use pde::implicit::CrankNicolson1D;

pub use pde::implicit::ImplicitMethod;

pub use pde::implicit::ImplicitOptions;

pub use pde::implicit::ImplicitResult;

pub use pde::implicit::ADI2D;

pub use qmc::qmc_quad;

pub use qmc::qmc_quad_parallel;

pub use qmc::Faure;

pub use qmc::Halton;

pub use qmc::QMCQuadResult;

pub use qmc::RandomGenerator;

pub use qmc::Sobol;

pub use quad::quad;

pub use quad::simpson;

pub use quad::trapezoid;

pub use quad_vec::quad_vec;

pub use quad_vec::NormType;

pub use quad_vec::QuadRule;

pub use quad_vec::QuadVecOptions;

pub use quad_vec::QuadVecResult;

pub use symplectic::position_verlet;

pub use symplectic::symplectic_euler;

pub use symplectic::symplectic_euler_a;

pub use symplectic::symplectic_euler_b;

pub use symplectic::velocity_verlet;

pub use symplectic::CompositionMethod;

pub use symplectic::GaussLegendre4;

pub use symplectic::GaussLegendre6;

pub use symplectic::HamiltonianFn;

pub use symplectic::HamiltonianSystem;

pub use symplectic::SeparableHamiltonian;

pub use symplectic::StormerVerlet;

pub use symplectic::SymplecticIntegrator;

pub use symplectic::SymplecticResult;

pub use tanhsinh::nsum;

pub use tanhsinh::tanhsinh;

pub use tanhsinh::TanhSinhOptions;

pub use tanhsinh::TanhSinhResult;

pub use verification::polynomial_solution;

pub use verification::trigonometric_solution_2d;

pub use verification::ConvergenceAnalysis;

pub use verification::ErrorAnalysis;

pub use verification::ExactSolution;

pub use verification::MMSODEProblem;

pub use verification::MMSPDEProblem;

pub use verification::PDEType as VerificationPDEType;

pub use verification::PolynomialSolution;

pub use verification::TrigonometricSolution2D;

Modules

acceleration

Acceleration methods for iterative algorithms

advanced_memory_optimization

Advanced-advanced memory optimization system for ODE solvers

advanced_simd_acceleration

Optimized SIMD acceleration for ODE solvers

amr_advanced

Advanced Adaptive Mesh Refinement (AMR) with sophisticated error indicators

analysis

Advanced analysis tools for dynamical systems

autodiff

Enhanced automatic differentiation for numerical integration

autotuning

Auto-tuning for hardware configurations

bvp

Boundary Value Problem solvers for ODEs

bvp_extended

Extended Boundary Value Problem solvers with Robin and mixed boundary conditions

common

Common traits and types used throughout the crate

cubature

Adaptive multidimensional integration using cubature methods

dae

Differential Algebraic Equation (DAE) solvers

error

Error types for the SciRS2 integration module

error_estimation

Advanced error estimation and quality assessment for numerical solutions

gaussian

Gaussian quadrature integration methods

geometric

Geometric integration methods

gpu_advanced_acceleration

Advanced-performance GPU acceleration framework for ODE solvers

lebedev

Lebedev quadrature for spherical integration

memory

Memory access pattern optimization utilities

mode_coordinator

Advanced Mode Coordinator

monte_carlo

Monte Carlo integration methods

neural_rl_step_control

Neural Reinforcement Learning Step Size Control

newton_cotes

Newton-Cotes quadrature rule generator

ode

Ordinary Differential Equation solvers

parallel_optimization

Advanced parallel processing optimization for numerical algorithms

pde

Partial Differential Equation (PDE) solvers

performance_monitor

Performance monitoring and profiling for numerical algorithms

qmc

Quasi-Monte Carlo integration

quad

Numerical quadrature methods for integration

quad_vec

Vector-valued integration

realtime_performance_adaptation

Real-time performance adaptation system for ODE solvers

romberg

Romberg integration method

scheduling

Work-stealing schedulers for adaptive algorithms

specialized

Specialized solvers for domain-specific problems

symbolic

Symbolic integration support for enhanced numerical methods

symplectic

Symplectic integrators for Hamiltonian systems

tanhsinh

Tanh-sinh quadrature (double exponential formula)

utils

Utility functions for numerical integration

verification

Method of Manufactured Solutions (MMS) toolkit for verification

visualization

Visualization utilities for numerical integration and specialized solvers

Macros

profile_block

Macro for easy profiling of code blocks