Struct ExplicitRk 

pub struct ExplicitRk<'a, Eqn, M = <<Eqn as Op>::V as DefaultDenseMatrix>::M, AugmentedEqn = NoAug<Eqn>>
where
    Eqn: OdeEquations,
    M: DenseMatrix<V = Eqn::V, T = Eqn::T>,
    Eqn::V: DefaultDenseMatrix<T = Eqn::T, C = Eqn::C>,
    AugmentedEqn: AugmentedOdeEquations<Eqn>,
{ /* private fields */ }

An explicit Runge-Kutta method.

The particular method is defined by the Tableau used to create the solver. If the beta matrix of the Tableau is present this is used for interpolation, otherwise hermite interpolation is used.

Restrictions:

• The upper triangular and diagonal parts of the a matrix must be zero (i.e. explicit).
• The last row of the a matrix must be the same as the b vector, and the last element of the c vector must be 1 (i.e. a stiffly accurate method)

Implementations

impl<'a, Eqn, M, AugmentedEqn> ExplicitRk<'a, Eqn, M, AugmentedEqn>

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

pub fn new( problem: &'a OdeSolverProblem<Eqn>, state: RkState<Eqn::V>, tableau: Tableau<M>, ) -> Result<Self, DiffsolError>

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

pub fn get_statistics(&self) -> &BdfStatistics

Trait Implementations

impl<'a, Eqn, M, Solver> AdjointOdeSolverMethod<'a, Eqn, Solver> for ExplicitRk<'a, Eqn, M, AdjointEquations<'a, Eqn, Solver>>

where Eqn: OdeEquationsImplicitAdjoint + 'a, Solver: OdeSolverMethod<'a, Eqn>, M: DenseMatrix<V = Eqn::V, T = Eqn::T, C = Eqn::C>, Eqn::V: DefaultDenseMatrix<T = Eqn::T, C = Eqn::C>, for<'b> &'b Eqn::V: VectorRef<Eqn::V>,

fn solve_adjoint_backwards_pass( self, t0: Option<Eqn::T>, t_eval: &[Eqn::T], dgdu_eval: &[&<Eqn::V as DefaultDenseMatrix>::M], ) -> Result<Self::State, DiffsolError>

where Eqn::V: DefaultDenseMatrix, Eqn::M: DefaultSolver,

Backwards pass for adjoint sensitivity analysis

impl<'a, Eqn, M, AugEqn> AugmentedOdeSolverMethod<'a, Eqn, AugEqn> for ExplicitRk<'a, Eqn, M, AugEqn>

where Eqn: OdeEquations, AugEqn: AugmentedOdeEquations<Eqn>, M: DenseMatrix<V = Eqn::V, T = Eqn::T, C = Eqn::C>, Eqn::V: DefaultDenseMatrix<T = Eqn::T, C = Eqn::C>, for<'b> &'b Eqn::V: VectorRef<Eqn::V>,

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

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

fn augmented_eqn_mut(&mut self) -> Option<&mut AugEqn>

impl<Eqn, M, AugmentedEqn> Clone for ExplicitRk<'_, Eqn, M, AugmentedEqn>

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

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, Eqn, M, AugmentedEqn> OdeSolverMethod<'a, Eqn> for ExplicitRk<'a, Eqn, M, AugmentedEqn>

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

type State = RkState<<Eqn as Op>::V>

The state type used by the solver

type Config = ExplicitRkConfig<<Eqn as Op>::T>

The configuration type used by the solver

fn config(&self) -> &ExplicitRkConfig<Eqn::T>

Get a reference to the current configuration of the solver

fn config_mut(&mut self) -> &mut ExplicitRkConfig<Eqn::T>

Get a mutable reference to the current configuration of the solver

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

Get the current problem

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 order(&self) -> usize

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

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

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

fn into_state(self) -> RkState<Eqn::V>

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 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 state_clone(&self) -> Self::State

Clone the current state of the solver without triggering any internal Jacobian reset.

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 interpolate_sens_inplace( &self, t: <Eqn as Op>::T, sens: &mut [Eqn::V], ) -> Result<(), DiffsolError>

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

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

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

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

Interpolate the time derivative dy/dt at a given time and place in dy. This time should be between the current time and the last solver time step

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

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

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

Get the current state of the solver

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 state_mut_back(&mut self, t: Eqn::T) -> Result<(), DiffsolError>

Move the solver state back to time t by interpolating y, dy, and (if integrate_out is set) g to that time and writing them into the current state. If the state contains sensitivity vectors they are also interpolated to time t. This is typically called after a root is found to pin the state to the root time.

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_dy(&self, t: Eqn::T) -> Result<Eqn::V, DiffsolError>

Interpolate the time derivative dy/dt 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::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 solve( &mut self, final_time: Eqn::T, ) -> Result<(<Eqn::V as DefaultDenseMatrix>::M, Vec<Eqn::T>, OdeSolverStopReason<Eqn::T>), DiffsolError>

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

Solve the ODE from the current time to final_time.

fn solve_soln(self, soln: &mut Solution<Eqn::V>) -> Result<Self, DiffsolError>

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

Continue solving into an existing Solution, appending newly computed output.

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

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

Solve the ODE from the current time to t_eval[t_eval.len()-1], evaluating at specified times.

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>, OdeSolverStopReason<Eqn::T>), DiffsolError>

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

Solve the ODE from the current time to final_time, saving checkpoints at regular intervals.

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, OdeSolverStopReason<Eqn::T>), DiffsolError>

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

Solve the ODE from the current time to t_eval[t_eval.len()-1] with checkpointing, evaluating at specified times.

impl<'a, Eqn, M> SensitivitiesOdeSolverMethod<'a, Eqn> for ExplicitRk<'a, Eqn, M, SensEquations<'a, Eqn>>

where Eqn: OdeEquationsImplicitSens + 'a, M: DenseMatrix<V = Eqn::V, T = Eqn::T, C = Eqn::C>, Eqn::V: DefaultDenseMatrix<T = Eqn::T, C = Eqn::C>, for<'b> &'b Eqn::V: VectorRef<Eqn::V>,

fn solve_soln_sensitivities( self, soln: &mut Solution<Eqn::V>, ) -> Result<Self, DiffsolError>

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

Continue solving ODE and forward sensitivities into an existing dense Solution.

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

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

Solve the ODE and the forward sensitivity equations from the current time to t_eval[t_eval.len()-1], evaluating at specified times.