Crate numra_ode 

Numra ODE Solvers

This crate provides a comprehensive suite of ODE solvers for solving initial value problems of the form:

dy/dt = f(t, y),  y(t0) = y0

Available Solvers

Explicit Runge-Kutta (Non-stiff)

• DoPri5 - Dormand-Prince 5(4) with dense output
• Tsit5 - Tsitouras 5(4), efficient with FSAL
• Vern6 - Verner 6(5), high accuracy
• Vern7 - Verner 7(6), higher accuracy
• Vern8 - Verner 8(7), very high accuracy

Implicit Runge-Kutta (Stiff)

• Radau5 - Radau IIA 3-stage, L-stable (5th order)
• Esdirk32 - ESDIRK 3-stage, 2nd order
• Esdirk43 - ESDIRK 4-stage, 3rd order
• Esdirk54 - ESDIRK 5-stage, 4th order (L-stable)

Multistep Methods (Stiff)

• Bdf - BDF orders 1-5 with variable order

Automatic Selection

• auto_solve / auto_solve_with_hints - Automatic solver selection based on problem characteristics

Example

use numra_ode::{OdeProblem, DoPri5, Solver, SolverOptions};

// Define the Lorenz system
fn lorenz(t: f64, y: &[f64], dydt: &mut [f64]) {
    let sigma = 10.0;
    let rho = 28.0;
    let beta = 8.0 / 3.0;
    dydt[0] = sigma * (y[1] - y[0]);
    dydt[1] = y[0] * (rho - y[2]) - y[1];
    dydt[2] = y[0] * y[1] - beta * y[2];
}

// Create problem
let y0 = vec![1.0, 1.0, 1.0];
let problem = OdeProblem::new(lorenz, 0.0, 20.0, y0.clone());

// Solve with DoPri5
let options = SolverOptions::default();
let result = DoPri5::solve(&problem, 0.0, 20.0, &y0, &options).unwrap();

println!("Final state: {:?}", result.y_final());

Author: Moussa Leblouba Date: 9 February 2026 Modified: 2 May 2026

Re-exports

pub use dense::DenseOutput;

pub use error::SolverError;

pub use problem::DaeProblem;

pub use problem::OdeProblem;

pub use problem::OdeSystem;

pub use solver::Solver;

pub use solver::SolverOptions;

pub use solver::SolverResult;

pub use solver::SolverStats;

pub use step_control::PIController;

pub use step_control::StepController;

pub use dopri5::DoPri5;

pub use tsit5::Tsit5;

pub use verner::Vern6;

pub use verner::Vern7;

pub use verner::Vern8;

pub use bdf::Bdf;

pub use esdirk::Esdirk32;

pub use esdirk::Esdirk43;

pub use esdirk::Esdirk54;

pub use radau5::Radau5;

pub use auto::auto_solve;

pub use auto::auto_solve_with_hints;

pub use auto::Accuracy;

pub use auto::SolverHints;

pub use auto::Stiffness;

pub use sensitivity::solve_forward_sensitivity;

pub use sensitivity::solve_forward_sensitivity_with;

pub use sensitivity::AugmentedSystem;

pub use sensitivity::ClosureSystem;

pub use sensitivity::ParametricOdeSystem;

pub use sensitivity::SensitivityResult;

pub use dae_init::compute_consistent_initial;

pub use dae_init::compute_consistent_initial_tol;

pub use index_reduction::analyze_dae_index;

pub use index_reduction::analyze_system;

pub use index_reduction::detect_structure;

pub use index_reduction::reduce_dae_problem;

pub use index_reduction::reduce_index;

pub use index_reduction::DaeIndexInfo;

pub use index_reduction::DaeStructure;

pub use index_reduction::ReducedDaeSystem;

pub use uncertainty::solve_monte_carlo;

pub use uncertainty::solve_trajectory;

pub use uncertainty::solve_with_uncertainty;

pub use uncertainty::UncertainParam;

pub use uncertainty::UncertainSolverResult;

pub use uncertainty::UncertaintyMode;

Modules

auto

Automatic solver selection.

bdf

BDF / NDF: variable-order, variable-step backward differentiation formulas.

dae_init

Consistent initialization for DAEs.

dense

Dense output for continuous solution interpolation.

dopri5

Dormand-Prince 5(4) explicit Runge-Kutta solver.

error

Error types for ODE solvers.

esdirk

ESDIRK: Explicit first Stage, Singly Diagonally Implicit Runge-Kutta methods.

events

Event detection and handling for ODE solvers.

index_reduction

DAE index analysis and automatic index reduction.

problem

ODE problem definition.

radau5

Radau5: 3-stage Radau IIA implicit Runge-Kutta method (5th order, L-stable).

sensitivity

Forward sensitivity analysis for parameterised ODE systems.

solver

ODE solver infrastructure.

step_control

Step size control for ODE solvers.

t_eval

Output-grid emission for SolverOptions::t_eval.

tsit5

Tsit5: Tsitouras 5(4) explicit Runge-Kutta method.

uncertainty

Uncertainty propagation in ODE solutions.

verner

Verner: High-order explicit Runge-Kutta methods.

Traits

Scalar

A real scalar type suitable for numerical computation.

Vector

A vector type for numerical computation.