differential-equations/readme.md

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:

use nalgebra::Vector3;
use differential_equations::prelude::*;

// 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);