Struct ExplicitRungeKutta

pub struct ExplicitRungeKutta<E, F, T: Real, Y: State<T>, D: CallBackData, const O: usize, const S: usize, const I: usize> {
    pub h0: T,
    pub rtol: T,
    pub atol: T,
    pub h_max: T,
    pub h_min: T,
    pub max_steps: usize,
    pub max_rejects: usize,
    pub safety_factor: T,
    pub min_scale: T,
    pub max_scale: T,
    /* private fields */
}

Runge-Kutta solver that can handle:

• Fixed-step methods with cubic Hermite interpolation
• Adaptive step methods with embedded error estimation and cubic Hermite interpolation
• Advanced methods with dense output interpolation using Butcher tableau coefficients

Type Parameters

• E: Equation type (e.g., Ordinary, Delay, Stochastic)
• F: Family type (e.g., Adaptive, Fixed, DormandPrince, etc.)
• T: Real number type (f32, f64)
• Y: State vector type
• D: Callback data type
• const O: Order of the method
• const S: Number of stages in the method
• const I: Total number of stages including interpolation (equal to S for methods without dense output)

Fields

h0: T

rtol: T

atol: T

h_max: T

h_min: T

max_steps: usize

max_rejects: usize

safety_factor: T

min_scale: T

max_scale: T

Implementations

impl<E, T: Real, Y: State<T>, D: CallBackData> ExplicitRungeKutta<E, Adaptive, T, Y, D, 5, 6, 6>

pub fn rkf45() -> Self

Creates a Runge-Kutta-Fehlberg 4(5) method with error estimation.

impl<E, T: Real, Y: State<T>, D: CallBackData> ExplicitRungeKutta<E, Adaptive, T, Y, D, 5, 6, 6>

pub fn cash_karp() -> Self

Creates a Cash-Karp 4(5) method with error estimation.

impl<E, T: Real, Y: State<T>, D: CallBackData> ExplicitRungeKutta<E, Adaptive, T, Y, D, 6, 9, 10>

pub fn rkv655e() -> Self

Creates an Explicit Runge-Kutta 6(5) method with 9 stages and a 5th order interpolant.

impl<E, T: Real, Y: State<T>, D: CallBackData> ExplicitRungeKutta<E, Adaptive, T, Y, D, 6, 9, 12>

pub fn rkv656e() -> Self

Creates an Explicit Runge-Kutta 6(5) method with 9 stages and a 6th order interpolant.

impl<E, T: Real, Y: State<T>, D: CallBackData> ExplicitRungeKutta<E, Adaptive, T, Y, D, 7, 10, 13>

pub fn rkv766e() -> Self

Creates an Explicit Runge-Kutta 7(6) method with 10 stages and a 6th order interpolant.

impl<E, T: Real, Y: State<T>, D: CallBackData> ExplicitRungeKutta<E, Adaptive, T, Y, D, 7, 10, 16>

pub fn rkv767e() -> Self

Creates an Explicit Runge-Kutta 7(6) method with 10 stages and a 7th order interpolant.

impl<E, T: Real, Y: State<T>, D: CallBackData> ExplicitRungeKutta<E, Adaptive, T, Y, D, 8, 13, 17>

pub fn rkv877e() -> Self

Creates an Explicit Runge-Kutta 8(7) method with 13 stages and a 7th order interpolant.

impl<E, T: Real, Y: State<T>, D: CallBackData> ExplicitRungeKutta<E, Adaptive, T, Y, D, 8, 13, 21>

pub fn rkv878e() -> Self

Creates an Explicit Runge-Kutta 8(7) method with 13 stages and an 8th order interpolant.

impl<E, T: Real, Y: State<T>, D: CallBackData> ExplicitRungeKutta<E, Adaptive, T, Y, D, 9, 16, 21>

pub fn rkv988e() -> Self

Creates an Explicit Runge-Kutta 9(8) method with 16 stages and an 8th order interpolant.

impl<E, T: Real, Y: State<T>, D: CallBackData> ExplicitRungeKutta<E, Adaptive, T, Y, D, 9, 16, 26>

pub fn rkv989e() -> Self

Creates an Explicit Runge-Kutta 9(8) method with 16 stages and a 9th order interpolant.

impl<E, T: Real, Y: State<T>, D: CallBackData> ExplicitRungeKutta<E, DormandPrince, T, Y, D, 8, 12, 16>

pub fn dop853() -> Self

Creates the DOP853 method (8th order, 12 stages, 4 dense output stages).

impl<E, T: Real, Y: State<T>, D: CallBackData> ExplicitRungeKutta<E, DormandPrince, T, Y, D, 5, 7, 7>

pub fn dopri5() -> Self

Creates the DOPRI5 method (5th order, 7 stages).

impl<T: Real, Y: State<T>, D: CallBackData, const O: usize, const S: usize, const I: usize> ExplicitRungeKutta<Delay, Fixed, T, Y, D, O, S, I>

pub fn lagvals<const L: usize, H>( &mut self, t_stage: T, delays: &[T; L], y_delayed: &mut [Y; L], phi: &H, ) -> Result<(), Error<T, Y>>

where H: Fn(T) -> Y,

impl<E, T: Real, Y: State<T>, D: CallBackData> ExplicitRungeKutta<E, Fixed, T, Y, D, 1, 1, 1>

pub fn euler(h0: T) -> Self

Creates an Explicit Euler method (1st order, 1 stage).

impl<E, T: Real, Y: State<T>, D: CallBackData> ExplicitRungeKutta<E, Fixed, T, Y, D, 2, 2, 2>

pub fn midpoint(h0: T) -> Self

Creates an Explicit Midpoint method (2nd order, 2 stages).

impl<E, T: Real, Y: State<T>, D: CallBackData> ExplicitRungeKutta<E, Fixed, T, Y, D, 2, 2, 2>

pub fn heun(h0: T) -> Self

Creates an Explicit Heun method (2nd order, 2 stages).

impl<E, T: Real, Y: State<T>, D: CallBackData> ExplicitRungeKutta<E, Fixed, T, Y, D, 2, 2, 2>

pub fn ralston(h0: T) -> Self

Creates an Explicit Ralston method (2nd order, 2 stages).

impl<E, T: Real, Y: State<T>, D: CallBackData> ExplicitRungeKutta<E, Fixed, T, Y, D, 4, 4, 4>

pub fn rk4(h0: T) -> Self

Creates the classical 4th order Runge-Kutta method.

impl<E, T: Real, Y: State<T>, D: CallBackData> ExplicitRungeKutta<E, Fixed, T, Y, D, 4, 4, 4>

pub fn three_eighths(h0: T) -> Self

Creates the three-eighths rule 4th order Runge-Kutta method.

impl<E, F, T: Real, Y: State<T>, D: CallBackData, const O: usize, const S: usize, const I: usize> ExplicitRungeKutta<E, F, T, Y, D, O, S, I>

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

Set the relative tolerance for error control

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

Set the absolute tolerance for error control

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

Set the initial step size

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

Set the minimum allowed step size

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

Set the maximum allowed step size

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

Set the maximum number of steps allowed

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

Set the maximum number of consecutive rejected steps before declaring stiffness

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

Set the safety factor for step size control (default: 0.9)

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

Set the minimum scale factor for step size changes (default: 0.2)

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

Set the maximum scale factor for step size changes (default: 10.0)

pub fn order(&self) -> usize

Get the order of the method

pub fn stages(&self) -> usize

Get the number of stages in the method

pub fn dense_stages(&self) -> usize

Get the number of terms in the dense output interpolation polynomial

impl<F, T: Real, Y: State<T>, D: CallBackData, const O: usize, const S: usize, const I: usize> ExplicitRungeKutta<Delay, F, T, Y, D, O, S, I>

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

Set the maximum delay for DDEs

Trait Implementations

impl<E, F, T: Real, Y: State<T>, D: CallBackData, const O: usize, const S: usize, const I: usize> Default for ExplicitRungeKutta<E, F, T, Y, D, O, S, I>

fn default() -> Self

Returns the “default value” for a type.

impl<const L: usize, T: Real, Y: State<T>, H: Fn(T) -> Y, D: CallBackData, const O: usize, const S: usize, const I: usize> DelayNumericalMethod<L, T, Y, H, D> for ExplicitRungeKutta<Delay, Adaptive, T, Y, D, O, S, I>

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

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

Initialize the solver before integration

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

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

Advance the solution by one step

fn t(&self) -> T

Time of last accepted step

fn y(&self) -> &Y

State at last accepted step

fn t_prev(&self) -> T

Time of previous accepted step

fn y_prev(&self) -> &Y

State at previous accepted step

fn h(&self) -> T

Step size for next step

fn set_h(&mut self, h: T)

Set step size for next step

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

Current solver status

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

Set solver status

impl<const L: usize, T: Real, Y: State<T>, H: Fn(T) -> Y, D: CallBackData, const O: usize, const S: usize, const I: usize> DelayNumericalMethod<L, T, Y, H, D> for ExplicitRungeKutta<Delay, DormandPrince, T, Y, D, O, S, I>

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

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

Initialize the solver before integration

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

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

Advance the solution by one step

fn t(&self) -> T

Time of last accepted step

fn y(&self) -> &Y

State at last accepted step

fn t_prev(&self) -> T

Time of previous accepted step

fn y_prev(&self) -> &Y

State at previous accepted step

fn h(&self) -> T

Step size for next step

fn set_h(&mut self, h: T)

Set step size for next step

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

Current solver status

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

Set solver status

impl<const L: usize, T: Real, Y: State<T>, H: Fn(T) -> Y, D: CallBackData, const O: usize, const S: usize, const I: usize> DelayNumericalMethod<L, T, Y, H, D> for ExplicitRungeKutta<Delay, Fixed, T, Y, D, O, S, I>

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

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

Initialize the solver before integration

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

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

Advance the solution by one step

fn t(&self) -> T

Time of last accepted step

fn y(&self) -> &Y

State at last accepted step

fn t_prev(&self) -> T

Time of previous accepted step

fn y_prev(&self) -> &Y

State at previous accepted step

fn h(&self) -> T

Step size for next step

fn set_h(&mut self, h: T)

Set step size for next step

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

Current solver status

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

Set solver status

impl<T: Real, Y: State<T>, D: CallBackData, const O: usize, const S: usize, const I: usize> Interpolation<T, Y> for ExplicitRungeKutta<Delay, Adaptive, T, Y, D, O, S, I>

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

Interpolates the solution at a given time t_interp.

impl<T: Real, Y: State<T>, D: CallBackData, const O: usize, const S: usize, const I: usize> Interpolation<T, Y> for ExplicitRungeKutta<Delay, DormandPrince, T, Y, D, O, S, I>

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

Evaluate the step-local interpolant at the given time.

impl<T: Real, Y: State<T>, D: CallBackData, const O: usize, const S: usize, const I: usize> Interpolation<T, Y> for ExplicitRungeKutta<Delay, Fixed, T, Y, D, O, S, I>

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

Interpolates the solution at time t_interp within the last accepted step.

impl<T: Real, Y: State<T>, D: CallBackData, const O: usize, const S: usize, const I: usize> Interpolation<T, Y> for ExplicitRungeKutta<Ordinary, Adaptive, T, Y, D, O, S, I>

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

Evaluate the step-local interpolant at the given time.

impl<T: Real, Y: State<T>, D: CallBackData, const O: usize, const S: usize, const I: usize> Interpolation<T, Y> for ExplicitRungeKutta<Ordinary, DormandPrince, T, Y, D, O, S, I>

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

Evaluate the step-local interpolant at the given time.

impl<T: Real, Y: State<T>, D: CallBackData, const O: usize, const S: usize, const I: usize> Interpolation<T, Y> for ExplicitRungeKutta<Ordinary, Fixed, T, Y, D, O, S, I>

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

Evaluate the step-local interpolant at the given time.

impl<T: Real, Y: State<T>, D: CallBackData, const O: usize, const S: usize, const I: usize> Interpolation<T, Y> for ExplicitRungeKutta<Stochastic, Fixed, T, Y, D, O, S, I>

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

Evaluate the step-local interpolant at the given time.

impl<T: Real, Y: State<T>, D: CallBackData, const O: usize, const S: usize, const I: usize> OrdinaryNumericalMethod<T, Y, D> for ExplicitRungeKutta<Ordinary, Adaptive, T, Y, D, O, S, I>

fn init<F>( &mut self, ode: &F, t0: T, tf: T, y0: &Y, ) -> Result<Evals, Error<T, Y>>

where F: ODE<T, Y, D>,

Initialize the solver before integration

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

where F: ODE<T, Y, D>,

Advance the solution by one step

fn t(&self) -> T

Time of last accepted step

fn y(&self) -> &Y

State at last accepted step

fn t_prev(&self) -> T

Time of previous accepted step

fn y_prev(&self) -> &Y

State at previous accepted step

fn h(&self) -> T

Step size for next step

fn set_h(&mut self, h: T)

Set step size for next step

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

Current solver status

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

Set solver status

impl<T: Real, Y: State<T>, D: CallBackData, const O: usize, const S: usize, const I: usize> OrdinaryNumericalMethod<T, Y, D> for ExplicitRungeKutta<Ordinary, DormandPrince, T, Y, D, O, S, I>

fn init<F>( &mut self, ode: &F, t0: T, tf: T, y0: &Y, ) -> Result<Evals, Error<T, Y>>

where F: ODE<T, Y, D>,

Initialize the solver before integration

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

where F: ODE<T, Y, D>,

Advance the solution by one step

fn t(&self) -> T

Time of last accepted step

fn y(&self) -> &Y

State at last accepted step

fn t_prev(&self) -> T

Time of previous accepted step

fn y_prev(&self) -> &Y

State at previous accepted step

fn h(&self) -> T

Step size for next step

fn set_h(&mut self, h: T)

Set step size for next step

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

Current solver status

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

Set solver status

impl<T: Real, Y: State<T>, D: CallBackData, const O: usize, const S: usize, const I: usize> OrdinaryNumericalMethod<T, Y, D> for ExplicitRungeKutta<Ordinary, Fixed, T, Y, D, O, S, I>

fn init<F>( &mut self, ode: &F, t0: T, tf: T, y0: &Y, ) -> Result<Evals, Error<T, Y>>

where F: ODE<T, Y, D>,

Initialize the solver before integration

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

where F: ODE<T, Y, D>,

Advance the solution by one step

fn t(&self) -> T

Time of last accepted step

fn y(&self) -> &Y

State at last accepted step

fn t_prev(&self) -> T

Time of previous accepted step

fn y_prev(&self) -> &Y

State at previous accepted step

fn h(&self) -> T

Step size for next step

fn set_h(&mut self, h: T)

Set step size for next step

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

Current solver status

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

Set solver status

impl<T: Real, Y: State<T>, D: CallBackData, const O: usize, const S: usize, const I: usize> StochasticNumericalMethod<T, Y, D> for ExplicitRungeKutta<Stochastic, Fixed, T, Y, D, O, S, I>

fn init<F>( &mut self, sde: &mut F, t0: T, tf: T, y0: &Y, ) -> Result<Evals, Error<T, Y>>

where F: SDE<T, Y, D>,

Initialize the solver before integration

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

where F: SDE<T, Y, D>,

Advance the solution by one step

fn t(&self) -> T

Time of last accepted step

fn y(&self) -> &Y

State at last accepted step

fn t_prev(&self) -> T

Time of previous accepted step

fn y_prev(&self) -> &Y

State at previous accepted step

fn h(&self) -> T

Step size for next step

fn set_h(&mut self, h: T)

Set step size for next step

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

Current solver status

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

Set solver status