Struct ImplicitRungeKutta 

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

IRK solver core. Supports fixed/adaptive stepping and common IRK families (Gauss, Radau, Lobatto).

Type params: E (equation), F (family), T (scalar), Y (state), D (callback), O (order), S (stages), I (dense output terms).

Fields

h0: T

newton_tol: T

max_newton_iter: usize

rtol: Tolerance<T>

atol: Tolerance<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>> ImplicitRungeKutta<E, Adaptive, T, Y, 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, Y: State<T>> ImplicitRungeKutta<E, Adaptive, T, Y, 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, Y: State<T>> ImplicitRungeKutta<E, Adaptive, T, Y, 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, Y: State<T>> ImplicitRungeKutta<E, Adaptive, T, Y, 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, Y: State<T>> ImplicitRungeKutta<E, Fixed, T, Y, 1, 1, 1>

pub fn backward_euler(h0: T) -> Self

Backward Euler, order 1, 1 stage. A-stable; stiff-suitable.

impl<E, T: Real, Y: State<T>> ImplicitRungeKutta<E, Fixed, T, Y, 2, 2, 2>

pub fn crank_nicolson(h0: T) -> Self

Crank-Nicolson, order 2, 2 stages. A-stable; stiff-suitable.

impl<E, T: Real, Y: State<T>> ImplicitRungeKutta<E, Fixed, T, Y, 2, 2, 2>

pub fn trapezoidal(h0: T) -> Self

Trapezoidal, order 2, 2 stages. A-stable; stiff-suitable.

impl<E, T: Real, Y: State<T>> ImplicitRungeKutta<E, Radau, T, Y, 5, 3, 3>

Constructor for Radau5

pub fn radau5() -> Radau5<E, T, Y>

Creates a new Radau IIA 3-stage implicit Runge-Kutta method of order 5.

For full usage details, DAE index handling, tuning notes and examples, see the documentation on the [Radau5] type.

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

pub fn rtol<V: Into<Tolerance<T>>>(self, rtol: V) -> Self

Set relative tolerance

pub fn atol<V: Into<Tolerance<T>>>(self, atol: V) -> Self

Set absolute tolerance

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

Set initial step size

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

Set minimum step size

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

Set maximum step size

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

Set max steps

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

Set max consecutive rejections

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

Set step size safety factor (default: 0.9)

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

Set minimum scale for step changes (default: 0.2)

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

Set maximum scale for step changes (default: 10.0)

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

Set Newton tolerance (default: 1e-10)

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

Set max Newton iterations per stage (default: 50)

pub fn order(&self) -> usize

Get method order

pub fn stages(&self) -> usize

Get number of stages

pub fn dense_stages(&self) -> usize

Get dense output terms

Trait Implementations

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

fn default() -> Self

Returns the “default value” for a type.

impl<T: Real, Y: State<T>, const O: usize, const S: usize, const I: usize> Interpolation<T, Y> for ImplicitRungeKutta<Ordinary, Adaptive, T, Y, 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>, const O: usize, const S: usize, const I: usize> Interpolation<T, Y> for ImplicitRungeKutta<Ordinary, Fixed, T, Y, 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>, const O: usize, const S: usize, const I: usize> OrdinaryNumericalMethod<T, Y> for ImplicitRungeKutta<Ordinary, Adaptive, T, Y, 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>,

Initialize the solver before integration

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

where F: ODE<T, Y>,

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>

Current solver status

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

Set solver status

impl<T: Real, Y: State<T>, const O: usize, const S: usize, const I: usize> OrdinaryNumericalMethod<T, Y> for ImplicitRungeKutta<Ordinary, Fixed, T, Y, 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>,

Initialize the solver before integration

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

where F: ODE<T, Y>,

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>

Current solver status

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

Set solver status