Struct ImplicitRungeKutta

pub struct ImplicitRungeKutta<E, F, T: Real, V: State<T>, D: CallBackData, const O: usize, const S: usize, const I: usize> {
    pub h0: T,
    pub newton_tol: T,
    pub max_newton_iter: usize,
    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 */
}

Implicit Runge-Kutta solver that can handle:

• Fixed-step methods with Newton iteration for stage equations
• Adaptive step methods with embedded error estimation
• Gauss methods (A-stable, symplectic for Hamiltonian systems)
• Radau methods (L-stable, good for stiff problems)
• Lobatto methods (A-stable, good for constrained systems)

Type Parameters

• E: Equation type (e.g., Ordinary, Delay, Stochastic)
• F: Family type (e.g., Adaptive, Fixed, Gauss, Radau, Lobatto)
• T: Real number type (f32, f64)
• V: 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

newton_tol: T

max_newton_iter: usize

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, V: State<T>, D: CallBackData> ImplicitRungeKutta<E, Adaptive, T, V, D, 4, 2, 2>

pub fn gauss_legendre_4() -> Self

Creates a new Gauss-Legendre 2-stage implicit Runge-Kutta method of order 4.

impl<E, T: Real, V: State<T>, D: CallBackData> ImplicitRungeKutta<E, Adaptive, T, V, D, 6, 3, 3>

pub fn gauss_legendre_6() -> Self

Creates a new Gauss-Legendre 3-stage implicit Runge-Kutta method of order 6.

impl<E, T: Real, V: State<T>, D: CallBackData> ImplicitRungeKutta<E, Adaptive, T, V, D, 2, 2, 2>

pub fn lobatto_iiic_2() -> Self

Creates a new Lobatto IIIC 2-stage implicit Runge-Kutta method of order 2.

impl<E, T: Real, V: State<T>, D: CallBackData> ImplicitRungeKutta<E, Adaptive, T, V, D, 4, 3, 3>

pub fn lobatto_iiic_4() -> Self

Creates a new Lobatto IIIC 3-stage implicit Runge-Kutta method of order 4.

impl<E, T: Real, V: State<T>, D: CallBackData> ImplicitRungeKutta<E, Fixed, T, V, D, 1, 1, 1>

pub fn backward_euler(h0: T) -> Self

Backward Euler method of order 1 with 1 stage. A-stable and suitable for stiff problems.

impl<E, T: Real, V: State<T>, D: CallBackData> ImplicitRungeKutta<E, Fixed, T, V, D, 2, 2, 2>

pub fn crank_nicolson(h0: T) -> Self

Crank-Nicolson method of order 2 with 2 stages. A-stable and suitable for stiff problems.

impl<E, T: Real, V: State<T>, D: CallBackData> ImplicitRungeKutta<E, Fixed, T, V, D, 2, 2, 2>

pub fn trapezoidal(h0: T) -> Self

Trapezoidal method of order 2 with 2 stages. A-stable and suitable for stiff problems.

impl<E, T: Real, V: State<T>, D: CallBackData> ImplicitRungeKutta<E, Fixed, T, V, D, 3, 2, 2>

pub fn radau_iia_3(h0: T) -> Self

Radau IIA method of order 3 with 2 stages. A-stable and suitable for stiff problems.

impl<E, T: Real, V: State<T>, D: CallBackData> ImplicitRungeKutta<E, Fixed, T, V, D, 5, 3, 3>

pub fn radau_iia_5(h0: T) -> Self

Radau IIA method of order 5 with 3 stages. A-stable and suitable for stiff problems.

impl<E, F, T: Real, V: State<T>, D: CallBackData, const O: usize, const S: usize, const I: usize> ImplicitRungeKutta<E, F, T, V, 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 newton_tol(self, newton_tol: T) -> Self

Set the Newton iteration tolerance (default: 1e-10)

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

Set the maximum number of Newton iterations per stage (default: 50)

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

Trait Implementations

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

fn default() -> Self

Returns the “default value” for a type.

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

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

Interpolate between previous and current step

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

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

Interpolate between previous and current step

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

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

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

Initialize OrdinaryNumericalMethod before solving ODE

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

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

Step through solving the ODE by one step

fn t(&self) -> T

Access time of last accepted step

fn y(&self) -> &V

Access solution of last accepted step

fn t_prev(&self) -> T

Access time of previous accepted step

fn y_prev(&self) -> &V

Access solution of previous accepted step

fn h(&self) -> T

Access step size of next step

fn set_h(&mut self, h: T)

Set step size of next step

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

Status of solver

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

Set status of solver

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

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

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

Initialize OrdinaryNumericalMethod before solving ODE

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

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

Step through solving the ODE by one step

fn t(&self) -> T

Access time of last accepted step

fn y(&self) -> &V

Access solution of last accepted step

fn t_prev(&self) -> T

Access time of previous accepted step

fn y_prev(&self) -> &V

Access solution of previous accepted step

fn h(&self) -> T

Access step size of next step

fn set_h(&mut self, h: T)

Set step size of next step

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

Status of solver

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

Set status of solver