69 lines
2.1 KiB
Markdown
69 lines
2.1 KiB
Markdown
# DifferentialEquations
|
|
|
|
A library, written in Rust, for integrating ordinary differential equations. For now, this is
|
|
relatively simple, but it does have key features that are needed for orbit propagation, ray tracing,
|
|
and field line tracing:
|
|
|
|
## Features
|
|
|
|
- A relatively efficient Dormand Prince 5th(4th) order integration algorithm, which is effective for
|
|
non-stiff problems
|
|
- A PI-controller for adaptive time stepping
|
|
- The ability to define "callback events" and stop or change the integator or underlying ODE if
|
|
certain conditions are met (zero crossings)
|
|
- A fourth order interpolator for the Domand Prince algorithm
|
|
- Parameters in the derivative and callback functions
|
|
|
|
|
|
### Future Improvements
|
|
|
|
- More algorithms
|
|
- Rosenbrock
|
|
- Verner
|
|
- Tsit(5)
|
|
- Runge Kutta Cash Karp
|
|
- Composite Algorithms
|
|
- Automatic Stiffness Detection
|
|
- Fixed Time Steps
|
|
- Boolean callback eventing
|
|
- Improved solution handling like `DifferentialEquations.jl`
|
|
|
|
## To Use
|
|
|
|
For now, here is a simple example of using the propagator to solve a simple system:
|
|
|
|
```rust
|
|
use nalgebra::Vector3;
|
|
use differential_equations::integrator::dormand_prince::DormandPrince45;
|
|
use differential_equations::controller::PIController;
|
|
use differential_equations::callback::stop;
|
|
use differential_equations::problem::*;
|
|
|
|
// Define the system (parameters, derivative, and initial state)
|
|
type Params = (f64, bool);
|
|
let params = (34.0, true);
|
|
|
|
fn derivative(t: f64, y: Vector3<f64>, p: &Params) -> Vector3<f64> {
|
|
if p.1 { -y } else { y * t }
|
|
}
|
|
|
|
let y0 = Vector3::new(1.0, 1.0, 1.0);
|
|
|
|
// Set up the problem (ODE, Integrator, Controller, and Callbacks)
|
|
let ode = ODE::new(&derivative, 0.0, 10.0, y0, params);
|
|
let dp45 = DormandPrince45::new(1e-12_f64, 1e-5_f64);
|
|
let controller = PIController::default();
|
|
|
|
let value_too_high = Callback {
|
|
event: &|_: f64, y: Vector3<f64>, _: &Params| { 10.0 - y[0] },
|
|
effect: &stop,
|
|
};
|
|
|
|
// Solve the problem
|
|
let mut problem = Problem::new(ode, dp45, controller).with_callback(value_too_high);
|
|
let solution = problem.solve();
|
|
|
|
// Can interpolate solutions to whatever you want
|
|
let interpolated_answer = solution.interpolate(8.2);
|
|
```
|