Struct BdfState 

pub struct BdfState<V, M = <V as DefaultDenseMatrix>::M>
where
    V: Vector + DefaultDenseMatrix,
    M: DenseMatrix<T = V::T, V = V>,
{ /* private fields */ }

Implementations

impl<V, M> BdfState<V, M>

where V: Vector + DefaultDenseMatrix, M: DenseMatrix<T = V::T, V = V>,

pub fn initialise_diff_to_first_order(&mut self)

pub fn initialise_sdiff_to_first_order(&mut self)

pub fn initialise_gdiff_to_first_order(&mut self)

pub fn initialise_sgdiff_to_first_order(&mut self)

Trait Implementations

impl<V, M> Clone for BdfState<V, M>

where V: Vector + DefaultDenseMatrix + Clone, M: DenseMatrix<T = V::T, V = V> + Clone, V::T: Clone,

fn clone(&self) -> BdfState<V, M>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V, M> OdeSolverState<V> for BdfState<V, M>

where V: Vector + DefaultDenseMatrix, M: DenseMatrix<T = V::T, V = V, C = V::C>,

fn set_problem<Eqn: OdeEquations>( &mut self, ode_problem: &OdeSolverProblem<Eqn>, ) -> Result<(), DiffsolError>

fn set_augmented_problem<Eqn: OdeEquations, AugmentedEqn: AugmentedOdeEquations<Eqn>>( &mut self, ode_problem: &OdeSolverProblem<Eqn>, augmented_eqn: &AugmentedEqn, ) -> Result<(), DiffsolError>

fn new_from_common(state: StateCommon<V>) -> Self

fn into_common(self) -> StateCommon<V>

fn as_ref(&self) -> StateRef<'_, V>

fn as_mut(&mut self) -> StateRefMut<'_, V>

fn check_consistent_with_problem<Eqn: OdeEquations>( &self, problem: &OdeSolverProblem<Eqn>, ) -> Result<(), DiffsolError>

fn check_sens_consistent_with_problem<Eqn: OdeEquations, AugmentedEqn: AugmentedOdeEquations<Eqn>>( &self, problem: &OdeSolverProblem<Eqn>, augmented_eqn: &AugmentedEqn, ) -> Result<(), DiffsolError>

fn new<Eqn>( ode_problem: &OdeSolverProblem<Eqn>, solver_order: usize, ) -> Result<Self, DiffsolError>

where Eqn: OdeEquations<T = V::T, V = V, C = V::C>,

Create a new solver state from an ODE problem. This function will set the initial step size based on the given solver. If you want to create a state without this default initialisation, use Self::new_without_initialise instead. You can then use Self::set_consistent and Self::set_step_size to set the state up if you need to.

fn new_and_consistent<LS, Eqn>( ode_problem: &OdeSolverProblem<Eqn>, solver_order: usize, ) -> Result<Self, DiffsolError>

where Eqn: OdeEquationsImplicit<T = V::T, V = V, C = V::C>, LS: LinearSolver<Eqn::M>,

Create a new solver state from an ODE problem. This function will make the state consistent with any algebraic constraints using a default nonlinear solver. It will also set the initial step size based on the given solver. If you want to create a state without this default initialisation, use Self::new_without_initialise instead. You can then use Self::set_consistent and Self::set_step_size to set the state up if you need to.

fn new_with_sensitivities<Eqn>( ode_problem: &OdeSolverProblem<Eqn>, solver_order: usize, ) -> Result<Self, DiffsolError>

where Eqn: OdeEquationsImplicitSens<T = V::T, V = V, C = V::C>,

fn new_with_sensitivities_and_consistent<LS, Eqn>( ode_problem: &OdeSolverProblem<Eqn>, solver_order: usize, ) -> Result<Self, DiffsolError>

where Eqn: OdeEquationsImplicitSens<T = V::T, V = V, C = V::C>, LS: LinearSolver<Eqn::M>,

fn into_adjoint<LS, Eqn, AugmentedEqn>( self, ode_problem: &OdeSolverProblem<Eqn>, augmented_eqn: &mut AugmentedEqn, ) -> Result<Self, DiffsolError>

where Eqn: OdeEquationsImplicit<T = V::T, V = V, C = V::C>, AugmentedEqn: AugmentedOdeEquationsImplicit<Eqn> + Debug, LS: LinearSolver<AugmentedEqn::M>,

fn new_without_initialise<Eqn>( ode_problem: &OdeSolverProblem<Eqn>, ) -> Result<Self, DiffsolError>

where Eqn: OdeEquations<T = V::T, V = V, C = V::C>,

Create a new solver state from an ODE problem, without any initialisation apart from setting the initial time state vector y, the initial time derivative dy and if applicable the sensitivity vectors s. This is useful if you want to set up the state yourself, or if you want to use a different nonlinear solver to make the state consistent, or if you want to set the step size yourself or based on the exact order of the solver.

fn new_without_initialise_augmented<Eqn, AugmentedEqn>( ode_problem: &OdeSolverProblem<Eqn>, augmented_eqn: &mut AugmentedEqn, ) -> Result<Self, DiffsolError>

where Eqn: OdeEquations<T = V::T, V = V, C = V::C>, AugmentedEqn: AugmentedOdeEquations<Eqn>,

fn set_consistent<Eqn, S>( &mut self, ode_problem: &OdeSolverProblem<Eqn>, root_solver: &mut S, ) -> Result<(), DiffsolError>

where Eqn: OdeEquationsImplicit<T = V::T, V = V, C = V::C>, S: NonLinearSolver<Eqn::M>,

Calculate a consistent state and time derivative of the state, based on the equations of the problem.

fn set_consistent_augmented<Eqn, AugmentedEqn, S>( &mut self, ode_problem: &OdeSolverProblem<Eqn>, augmented_eqn: &mut AugmentedEqn, root_solver: &mut S, ) -> Result<(), DiffsolError>

where Eqn: OdeEquationsImplicit<T = V::T, V = V, C = V::C>, AugmentedEqn: AugmentedOdeEquationsImplicit<Eqn> + Debug, S: NonLinearSolver<AugmentedEqn::M>,

Calculate the initial sensitivity vectors and their time derivatives, based on the equations of the problem. Note that this function assumes that the state is already consistent with the algebraic constraints (either via Self::set_consistent or by setting the state up manually).

fn set_step_size<Eqn>( &mut self, h0: Eqn::T, atol: &Eqn::V, rtol: Eqn::T, eqn: &Eqn, solver_order: usize, )

where Eqn: OdeEquations<T = V::T, V = V, C = V::C>,

compute size of first step based on alg in Hairer, Norsett, Wanner Solving Ordinary Differential Equations I, Nonstiff Problems Section II.4.2 Note: this assumes that the state is already consistent with the algebraic constraints and y and dy are already set appropriately