solvr 0.2.0

Advanced computing library for real-world problem solving - optimization, differential equations, interpolation, statistics, and more
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

//! Numerical integration and ODE solvers for solvr.
//!
//! This module provides Runtime-first numerical methods for:
//! - **Quadrature**: Numerical integration of functions (definite integrals)
//! - **ODE Solvers**: Initial value problem solvers for ordinary differential equations
//! - **BVP Solvers**: Boundary value problem solvers
//!
//! # Architecture
//!
//! All algorithms implement the [`IntegrationAlgorithms`] trait and use
//! `Tensor<R>` for data, enabling GPU acceleration and batch operations.
//!
//! # Quadrature Methods
//!
//! - [`IntegrationAlgorithms::trapezoid`] - Trapezoidal rule with tensor support
//! - [`IntegrationAlgorithms::simpson`] - Simpson's rule with tensor support
//! - [`IntegrationAlgorithms::fixed_quad`] - Gaussian quadrature with tensor functions
//! - [`IntegrationAlgorithms::quad`] - Adaptive Gauss-Kronrod quadrature
//! - [`IntegrationAlgorithms::romberg`] - Romberg integration via Richardson extrapolation
//! - [`IntegrationAlgorithms::tanh_sinh`] - Double-exponential for endpoint singularities
//! - [`IntegrationAlgorithms::monte_carlo`] - Monte Carlo integration
//! - [`IntegrationAlgorithms::qmc_quad`] - Quasi-Monte Carlo with Sobol/Halton
//! - [`IntegrationAlgorithms::dblquad`] - Double integrals
//! - [`IntegrationAlgorithms::nquad`] - N-dimensional adaptive quadrature
//!
//! # ODE Solvers
//!
//! ## Explicit Methods (Non-Stiff)
//!
//! - **RK23**: Bogacki-Shampine 2(3) - Low accuracy, fast
//! - **RK45**: Dormand-Prince 4(5) - General purpose (default)
//! - **DOP853**: Dormand-Prince 8(5,3) - High accuracy
//!
//! ## Implicit Methods (Stiff)
//!
//! - **BDF**: Backward Differentiation Formula (orders 1-5)
//! - **Radau**: Radau IIA order 5 for very stiff problems
//! - **LSODA**: Automatic stiff/non-stiff switching
//!
//! ## Symplectic Methods (Hamiltonian Systems)
//!
//! - **Verlet**: Störmer-Verlet for energy conservation
//! - **Leapfrog**: N-body simulations
//!
//! # BVP Solvers
//!
//! - [`IntegrationAlgorithms::solve_bvp`] - Two-point BVP via collocation
//!
//! # Example
//!
//! ```
//! # use numr::runtime::cpu::{CpuClient, CpuDevice};
//! # use numr::tensor::Tensor;
//! use solvr::integrate::IntegrationAlgorithms;
//! # let device = CpuDevice::new();
//! # let client = CpuClient::new(device.clone());
//! // Tensor-based integration
//! # let x = Tensor::from_slice(&[0.0, 0.5, 1.0], &[3], &device);
//! # let y = Tensor::from_slice(&[0.0, 0.25, 1.0], &[3], &device);
//! let result = client.trapezoid(&y, &x)?;
//! # Ok::<(), Box<dyn std::error::Error>>(())
//! ```

mod cpu;
#[cfg(feature = "cuda")]
mod cuda;
pub mod error;
pub mod impl_generic;
pub mod ode;
pub mod sensitivity;
mod traits;
#[cfg(feature = "wgpu")]
mod wgpu;

// Re-export error types
pub use error::{IntegrateError, IntegrateResult};

// Re-export ODE types
pub use ode::{
    BDFOptions, BVPOptions, DAEOptions, DAEResultTensor, DAEVariableType, EventDirection,
    EventOptions, EventRecord, EventSpec, LSODAOptions, ODEMethod, ODEOptions, ODEResultWithEvents,
    RadauOptions, SymplecticOptions,
};

// Re-export tensor-based ODE types and functions
pub use impl_generic::ode::{ODEResultTensor, rk45_with_events_impl, solve_ivp_impl};

// Re-export the main trait and types
pub use traits::{
    BVPResult, IntegrationAlgorithms, MonteCarloMethod, MonteCarloOptions, MonteCarloResult,
    NQuadOptions, QMCOptions, QMCSequence, QuadOptions, QuadResult, RombergOptions,
    SymplecticResult, TanhSinhOptions,
    events::{EventFn, EventFunction, EventSet},
};

// Re-export sensitivity types and traits
pub use sensitivity::{
    AdjointSensitivityAlgorithms, Checkpoint, CheckpointManager, CheckpointStrategy,
    SensitivityOptions, SensitivityResult, adjoint_sensitivity_impl,
};