Struct Bdf

pub struct Bdf<'a, Eqn: OdeEquationsImplicit, Nls: NonLinearSolver<Eqn::M>, M: DenseMatrix<T = Eqn::T, V = Eqn::V, C = Eqn::C> = <<Eqn as Op>::V as DefaultDenseMatrix>::M, AugmentedEqn: AugmentedOdeEquationsImplicit<Eqn> = NoAug<Eqn>>
where
    Eqn::V: DefaultDenseMatrix,
{ /* private fields */ }

Implements a Backward Difference formula (BDF) implicit multistep integrator.

The basic algorithm is derived in [1]. This particular implementation follows that implemented in the Matlab routine ode15s described in [2] and the SciPy implementation /[3/], which features the NDF formulas for improved stability with associated differences in the error constants, and calculates the jacobian at J(t_{n+1}, y^0_{n+1}). This implementation was based on that implemented in the SciPy library [3], which also mainly follows [2] but uses the more standard Jacobian update.

References

[1] Byrne, G. D., & Hindmarsh, A. C. (1975). A polyalgorithm for the numerical solution of ordinary differential equations. ACM Transactions on Mathematical Software (TOMS), 1(1), 71-96. [2] Shampine, L. F., & Reichelt, M. W. (1997). The matlab ode suite. SIAM journal on scientific computing, 18(1), 1-22. [3] Virtanen, P., Gommers, R., Oliphant, T. E., Haberland, M., Reddy, T., Cournapeau, D., … & Van Mulbregt, P. (2020). SciPy 1.0: fundamental algorithms for scientific computing in Python. Nature methods, 17(3), 261-272.

Implementations

impl<'a, M, Eqn, Nls, AugmentedEqn> Bdf<'a, Eqn, Nls, M, AugmentedEqn>

where AugmentedEqn: AugmentedOdeEquations<Eqn> + OdeEquationsImplicit, Eqn: OdeEquationsImplicit, Eqn::V: DefaultDenseMatrix, M: DenseMatrix<T = Eqn::T, V = Eqn::V, C = Eqn::C>, for<'b> &'b Eqn::V: VectorRef<Eqn::V>, for<'b> &'b Eqn::M: MatrixRef<Eqn::M>, Nls: NonLinearSolver<Eqn::M>,

pub fn new( problem: &'a OdeSolverProblem<Eqn>, state: BdfState<Eqn::V, M>, nonlinear_solver: Nls, ) -> Result<Self, DiffsolError>

pub fn new_augmented( state: BdfState<Eqn::V, M>, problem: &'a OdeSolverProblem<Eqn>, augmented_eqn: AugmentedEqn, nonlinear_solver: Nls, ) -> Result<Self, DiffsolError>

pub fn get_statistics(&self) -> &BdfStatistics

Trait Implementations

impl<'a, M, Eqn, Nls, AugEqn> AugmentedOdeSolverMethod<'a, Eqn, AugEqn> for Bdf<'a, Eqn, Nls, M, AugEqn>

where Eqn: OdeEquationsImplicit, AugEqn: AugmentedOdeEquationsImplicit<Eqn>, M: DenseMatrix<T = Eqn::T, V = Eqn::V, C = Eqn::C>, for<'b> &'b Eqn::V: VectorRef<Eqn::V>, for<'b> &'b Eqn::M: MatrixRef<Eqn::M>, Nls: NonLinearSolver<Eqn::M>, Eqn::V: DefaultDenseMatrix<T = Eqn::T>,

fn into_state_and_eqn(self) -> (Self::State, Option<AugEqn>)

fn augmented_eqn(&self) -> Option<&AugEqn>

impl<M, Eqn, Nls, AugmentedEqn> Clone for Bdf<'_, Eqn, Nls, M, AugmentedEqn>

where Eqn: OdeEquationsImplicit, Nls: NonLinearSolver<Eqn::M>, M: DenseMatrix<T = Eqn::T, V = Eqn::V, C = Eqn::C>, AugmentedEqn: AugmentedOdeEquationsImplicit<Eqn>, Eqn::V: DefaultDenseMatrix,

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, M, Eqn, Nls, AugmentedEqn> OdeSolverMethod<'a, Eqn> for Bdf<'a, Eqn, Nls, M, AugmentedEqn>

where Eqn: OdeEquationsImplicit, AugmentedEqn: AugmentedOdeEquations<Eqn> + OdeEquationsImplicit, M: DenseMatrix<T = Eqn::T, V = Eqn::V, C = Eqn::C>, Eqn::V: DefaultDenseMatrix, Nls: NonLinearSolver<Eqn::M>, for<'b> &'b Eqn::V: VectorRef<Eqn::V>, for<'b> &'b Eqn::M: MatrixRef<Eqn::M>,

type State = BdfState<<Eqn as Op>::V, M>

fn order(&self) -> usize

Get the current order of accuracy of the solver (e.g. explict euler method is first-order)

fn jacobian(&self) -> Option<Ref<'_, Eqn::M>>

Returns the current jacobian matrix of the solver, if it has one Note that this will force a full recalculation of the Jacobian.

fn mass(&self) -> Option<Ref<'_, Eqn::M>>

Returns the current mass matrix of the solver, if it has one Note that this will force a full recalculation of the mass matrix.

fn set_state(&mut self, state: Self::State)

Replace the current state of the solver with a new state.

fn interpolate(&self, t: Eqn::T) -> Result<Eqn::V, DiffsolError>

Interpolate the solution at a given time. This time should be between the current time and the last solver time step

fn interpolate_out(&self, t: Eqn::T) -> Result<Eqn::V, DiffsolError>

Interpolate the integral of the output function at a given time. This time should be between the current time and the last solver time step

fn interpolate_sens( &self, t: <Eqn as Op>::T, ) -> Result<Vec<Eqn::V>, DiffsolError>

Interpolate the sensitivity vectors at a given time. This time should be between the current time and the last solver time step

fn problem(&self) -> &'a OdeSolverProblem<Eqn>

Get the current problem

fn state(&self) -> StateRef<'_, Eqn::V>

Get the current state of the solver

fn into_state(self) -> BdfState<Eqn::V, M>

Take the current state of the solver, if it exists, returning it to the user. This is useful if you want to use this state in another solver or problem. Note that this will unset the current problem and solver state, so you will need to call set_problem again before calling step or solve.

fn state_mut(&mut self) -> StateRefMut<'_, Eqn::V>

Get a mutable reference to the current state of the solver Note that calling this will cause the next call to step to perform some reinitialisation to take into account the mutated state, this could be expensive for multi-step methods.

fn checkpoint(&mut self) -> Self::State

Take a checkpoint of the current state of the solver, returning it to the user. This is useful if you want to use this state in another solver or problem but want to keep this solver active. If you don’t need to use this solver again, you can use take_state instead. Note that this will force a reinitialisation of the internal Jacobian for the solver, if it has one.

fn step(&mut self) -> Result<OdeSolverStopReason<Eqn::T>, DiffsolError>

Step the solution forward by one step, altering the internal state of the solver. The return value is a Result containing the reason for stopping the solver, possible reasons are:

fn set_stop_time(&mut self, tstop: <Eqn as Op>::T) -> Result<(), DiffsolError>

Set a stop time for the solver. The solver will stop when the internal time reaches this time. Once it stops, the stop time is unset. If tstop is at or before the current internal time, an error is returned.

fn solve( &mut self, final_time: Eqn::T, ) -> Result<(<Eqn::V as DefaultDenseMatrix>::M, Vec<Eqn::T>), DiffsolError>

where Eqn::V: DefaultDenseMatrix, Self: Sized,

Using the provided state, solve the problem up to time final_time Returns a Vec of solution values at timepoints chosen by the solver. After the solver has finished, the internal state of the solver is at time final_time.

fn solve_dense( &mut self, t_eval: &[Eqn::T], ) -> Result<<Eqn::V as DefaultDenseMatrix>::M, DiffsolError>

where Eqn::V: DefaultDenseMatrix, Self: Sized,

Using the provided state, solve the problem up to time t_eval[t_eval.len()-1] Returns a Vec of solution values at timepoints given by t_eval. After the solver has finished, the internal state of the solver is at time t_eval[t_eval.len()-1].

fn solve_with_checkpointing( &mut self, final_time: Eqn::T, max_steps_between_checkpoints: Option<usize>, ) -> Result<(Checkpointing<'a, Eqn, Self>, <Eqn::V as DefaultDenseMatrix>::M, Vec<Eqn::T>), DiffsolError>

where Eqn::V: DefaultDenseMatrix, Self: Sized,

fn solve_dense_with_checkpointing( &mut self, t_eval: &[Eqn::T], max_steps_between_checkpoints: Option<usize>, ) -> Result<(Checkpointing<'a, Eqn, Self>, <Eqn::V as DefaultDenseMatrix>::M), DiffsolError>

where Eqn::V: DefaultDenseMatrix, Self: Sized,

Solve the problem and write out the solution at the given timepoints, using checkpointing so that the solution can be interpolated at any timepoint. See Self::solve_dense for a similar method that does not use checkpointing.