Struct BackwardDifferentiationFormula 

pub struct BackwardDifferentiationFormula<E, T: Real, Y: State<T>> {

    pub h0: T,
    pub rtol: Tolerance<T>,
    pub atol: Tolerance<T>,
    pub h_max: T,
    pub h_min: T,
    pub max_steps: usize,
    pub safety_factor: T,
    pub min_scale: T,
    pub max_scale: T,
    pub filter: fn(T) -> T,
    pub newton_tol: T,
    pub max_newton_iter: usize,
    pub max_order: usize,
    /* private fields */
}

Adaptive variable-order Backward Differentiation Formula solver.

Uses Backward Differentiation Formula orders 1-5 with automatic order and step size selection. Newton iteration resolves the implicit Backward Differentiation Formula equations. Dense output via polynomial interpolation is supported.

The solver starts at order 1 and considers increasing the order after enough successful steps. On step rejection, the order is decreased.

Fields

h0: T

rtol: Tolerance<T>

atol: Tolerance<T>

h_max: T

h_min: T

max_steps: usize

safety_factor: T

min_scale: T

max_scale: T

filter: fn(T) -> T

newton_tol: T

max_newton_iter: usize

max_order: usize

Implementations

impl<E, T: Real, Y: State<T>> BackwardDifferentiationFormula<E, T, Y>

pub fn adaptive() -> Self

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

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

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

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

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

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

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

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

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

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

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

pub fn order(&self) -> usize

Trait Implementations

impl<E, T: Real, Y: State<T>> Default for BackwardDifferentiationFormula<E, T, Y>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Real, Y: State<T>> Interpolation<T, Y> for BackwardDifferentiationFormula<Ordinary, T, Y>

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>> OrdinaryNumericalMethod<T, Y> for BackwardDifferentiationFormula<Ordinary, T, Y>

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

where F: ODE<T, Y> + ?Sized,

Initialize the solver before integration

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

where F: ODE<T, Y> + ?Sized,

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