differential-equations 0.5.3

A Rust library for solving differential equations.
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
101
102
103
104
105
106
107

//! # differential-equations
//!
//! A Rust library for solving ODE, DAE, DDE, and SDE initial value problems.
//!
//! [![GitHub](https://img.shields.io/badge/GitHub-differential--equations-blue)](https://github.com/Ryan-D-Gast/differential-equations)
//! [![Documentation](https://docs.rs/differential-equations/badge.svg)](https://docs.rs/differential-equations)
//!
//! ## Overview
//!
//! This library provides numerical solvers for:
//!
//! - **[Ordinary Differential Equations (ODE)](crate::ode)**: initial value problems, fixed/adaptive step, event detection, flexible output
//! - **[Differential Algebraic Equations (DAE)](crate::dae)**: equations in the form M f' = f(t,y) where M can be singular
//! - **[Delay Differential Equations (DDE)](crate::dde)**: constant/state-dependent delays, same features as ODE
//! - **[Stochastic Differential Equations (SDE)](crate::sde)**: drift-diffusion, user RNG, same features as ODE
//!
//! ## Feature Flags
//!
//! - `polars`: Enable converting `Solution` to a Polars DataFrame with `Solution::to_polars()`
//!
//! ## Example (ODE)
//!
//! ```rust
//! use differential_equations::prelude::*;
//! use nalgebra::{SVector, vector};
//!
//! pub struct LinearEquation {
//!     pub a: f64,
//!     pub b: f64,
//! }
//!
//! impl ODE<f64, SVector<f64, 1>> for LinearEquation {
//!     fn diff(&self, _t: f64, y: &SVector<f64, 1>, dydt: &mut SVector<f64, 1>) {
//!         dydt[0] = self.a + self.b * y[0];
//!     }
//! }
//!
//! fn main() {
//!     let system = LinearEquation { a: 1.0, b: 2.0 };
//!     let t0 = 0.0;
//!     let tf = 1.0;
//!     let y0 = vector![1.0];
//!     let problem = ODEProblem::new(&system, t0, tf, y0);
//!     let mut solver = ExplicitRungeKutta::dop853().rtol(1e-8).atol(1e-6);
//!     let solution = match problem.solve(&mut solver) {
//!         Ok(sol) => sol,
//!         Err(e) => panic!("Error: {:?}", e),
//!     };
//!
//!     for (t, y) in solution.iter() {
//!         println!("t: {:.4}, y: {:.4}", t, y[0]);
//!     }
//! }
//! ```
//!
//! ## License
//!
//! ```text
//! Copyright 2025 Ryan D. Gast
//!
//! Licensed under the Apache License, Version 2.0 (the "License");
//! you may not use this file except in compliance with the License.
//! You may obtain a copy of the License at
//!
//!     http://www.apache.org/licenses/LICENSE-2.0
//!
//! Unless required by applicable law or agreed to in writing, software
//! distributed under the License is distributed on an "AS IS" BASIS,
//! WITHOUT WARRANTIES OR CONDITIONS OF ANY KINeither express or implied.
//! See the License for the specific language governing permissions and
//! limitations under the License.
//! ```

// Prelude & User-Facing API
pub mod prelude;

// Numerical Methods
pub mod methods;
pub mod tableau;

// Differential Equations
pub mod dae;
pub mod dde;
pub mod ode;
pub mod sde;

// Output Control
pub mod solout;

// Core Structures
pub mod control;
pub mod error;
pub mod solution;
pub mod stats;
pub mod status;
pub mod tolerance;

// Shared Traits & Utilities
pub mod interpolate;
pub mod linalg;
pub mod traits;
pub mod utils;

// Derive Macros
pub mod derive {
    pub use differential_equations_derive::State;
}