Struct BS23

pub struct BS23<const L: usize, T: Real, V: State<T>, H: Fn(T) -> V, D: CallBackData> {
    pub h0: T,
    pub rtol: T,
    pub atol: T,
    pub h_max: T,
    pub h_min: T,
    pub max_steps: usize,
    pub safe: T,
    pub fac1: T,
    pub fac2: T,
    pub beta: T,
    pub max_delay: Option<T>,
    /* private fields */
}

Bogacki-Shampine 3(2) method adapted for DDEs. 3rd order method with embedded 2nd order error estimation and 3rd order dense output (cubic Hermite interpolation). FSAL property.

Example

use differential_equations::prelude::*;
use differential_equations::dde::methods::BS23;
use nalgebra::{Vector2, vector};

let mut bs23 = BS23::new()
   .rtol(1e-5)
   .atol(1e-5);

let t0 = 0.0;
let tf = 5.0;
let y0 = vector![1.0, 0.0];
let phi = |t| { // History function for t <= t0
    if t <= 0.0 { vector![1.0, 0.0] } else { panic!("phi called for t > t0") }
};
struct ExampleDDE;
impl DDE<1, f64, Vector2<f64>> for ExampleDDE {
    fn diff(&self, t: f64, y: &Vector2<f64>, yd: &[Vector2<f64>; 1], dydt: &mut Vector2<f64>) {
       dydt[0] = yd[0][1];
       dydt[1] = -yd[0][0] - 1.0 * y[1];
    }

    fn lags(&self, t: f64, y: &Vector2<f64>, lags: &mut [f64; 1]) {
        lags[0] = 1.0; // Constant delay tau = 1.0
    }
}
let problem = DDEProblem::new(ExampleDDE, t0, tf, y0, phi);
let solution = problem.solve(&mut bs23).unwrap();

let (t, y) = solution.last().unwrap();
println!("BS23 Solution at t={}: ({}, {})", t, y[0], y[1]);

Settings (similar to BS23)

• rtol, atol, h0, h_max, h_min, max_steps, safe, fac1, fac2, beta, max_delay.

Default Settings (typical for BS23)

• rtol - 1e-3
• atol - 1e-6
• h0 - None
• h_max - None
• h_min - 0.0
• max_steps - 100_000
• safe - 0.9
• fac1 - 0.2 (1/5 for order 3, can be tuned)
• fac2 - 10.0
• beta - 0.0 (No PI stabilization by default for BS23, can be enabled)
• max_delay - None

Fields

h0: T

rtol: T

atol: T

h_max: T

h_min: T

max_steps: usize

safe: T

fac1: T

fac2: T

beta: T

max_delay: Option<T>

Implementations

impl<const L: usize, T: Real, V: State<T>, H: Fn(T) -> V, D: CallBackData> BS23<L, T, V, H, D>

pub fn new() -> Self

pub fn rtol(self, rtol: T) -> Self

pub fn atol(self, atol: T) -> Self

pub fn h0(self, h0: T) -> Self

pub fn h_max(self, h_max: T) -> Self

pub fn h_min(self, h_min: T) -> Self

pub fn max_steps(self, max_steps: usize) -> Self

pub fn safe(self, safe: T) -> Self

pub fn fac1(self, fac1: T) -> Self

pub fn fac2(self, fac2: T) -> Self

pub fn beta(self, beta: T) -> Self

pub fn max_delay(self, max_delay: T) -> Self

Trait Implementations

impl<const L: usize, T: Real, V: State<T>, H: Fn(T) -> V, D: CallBackData> DDENumericalMethod<L, T, V, H, D> for BS23<L, T, V, H, D>

fn init<F>( &mut self, dde: &F, t0: T, tf: T, y0: &V, phi: H, ) -> Result<Evals, Error<T, V>>

where F: DDE<L, T, V, D>,

Initialize DDENumericalMethod before solving DDE.

fn step<F>(&mut self, dde: &F) -> Result<Evals, Error<T, V>>

where F: DDE<L, T, V, D>,

Perform one integration step for the DDE.

fn t(&self) -> T

Access time of the current state (end of the last accepted step).

fn y(&self) -> &V

Access solution state y at the current time t.

fn t_prev(&self) -> T

Access time at the beginning of the last accepted step.

fn y_prev(&self) -> &V

Access solution state y at the beginning of the last accepted step.

fn h(&self) -> T

Access the proposed step size h for the next step attempt.

fn set_h(&mut self, h: T)

Set the step size h for the next step attempt.

fn status(&self) -> &Status<T, V, D>

Get the current status of the solver (Solving, Complete, Error, etc.).

fn set_status(&mut self, status: Status<T, V, D>)

Set the status of the solver.

impl<const L: usize, T: Real, V: State<T>, H: Fn(T) -> V, D: CallBackData> Default for BS23<L, T, V, H, D>

fn default() -> Self

Returns the “default value” for a type.

impl<const L: usize, T: Real, V: State<T>, H: Fn(T) -> V, D: CallBackData> Interpolation<T, V> for BS23<L, T, V, H, D>

fn interpolate(&mut self, t_interp: T) -> Result<V, Error<T, V>>

Interpolate between previous and current step