Struct DormandPrince 

pub struct DormandPrince {
    pub abs_tol: Scalar,
    pub rel_tol: Scalar,
    pub dt_beta: Scalar,
    pub dt_expn: Scalar,
    pub dt_cut: Scalar,
    pub dt_min: Scalar,
}

Explicit, six-stage, fifth-order, variable-step, Runge-Kutta method.¹

\frac{dy}{dt} = f(t, y)

t_{n+1} = t_n + h

k_1 = f(t_n, y_n)

k_2 = f(t_n + \tfrac{1}{5} h, y_n + \tfrac{1}{5} h k_1)

k_3 = f(t_n + \tfrac{3}{10} h, y_n + \tfrac{3}{40} h k_1 + \tfrac{9}{40} h k_2)

k_4 = f(t_n + \tfrac{4}{5} h, y_n + \tfrac{44}{45} h k_1 - \tfrac{56}{15} h k_2 + \tfrac{32}{9} h k_3)

k_5 = f(t_n + \tfrac{8}{9} h, y_n + \tfrac{19372}{6561} h k_1 - \tfrac{25360}{2187} h k_2 + \tfrac{64448}{6561} h k_3 - \tfrac{212}{729} h k_4)

k_6 = f(t_n + h, y_n + \tfrac{9017}{3168} h k_1 - \tfrac{355}{33} h k_2 - \tfrac{46732}{5247} h k_3 + \tfrac{49}{176} h k_4 - \tfrac{5103}{18656} h k_5)

y_{n+1} = y_n + h\left(\frac{35}{384}\,k_1 + \frac{500}{1113}\,k_3 + \frac{125}{192}\,k_4 - \frac{2187}{6784}\,k_5 + \frac{11}{84}\,k_6\right)

k_7 = f(t_{n+1}, y_{n+1})

e_{n+1} = \frac{h}{5}\left(\frac{71}{11520}\,k_1 - \frac{71}{3339}\,k_3 + \frac{71}{384}\,k_4 - \frac{17253}{67840}\,k_5 + \frac{22}{105}\,k_6 - \frac{1}{8}\,k_7\right)

---

1. J.R. Dormand and P.J. Prince, J. Comput. Appl. Math. 6, 19 (1980). ↩

Fields

abs_tol: Scalar

Absolute error tolerance.

rel_tol: Scalar

Relative error tolerance.

dt_beta: Scalar

Multiplier for adaptive time steps.

dt_expn: Scalar

Exponent for adaptive time steps.

dt_cut: Scalar

Cut back factor for the time step.

dt_min: Scalar

Minimum value for the time step.

Trait Implementations

impl Debug for DormandPrince

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for DormandPrince

fn default() -> Self

Returns the “default value” for a type.

impl<Y, U> Explicit<Y, U> for DormandPrince

where Y: Tensor, for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>, U: TensorVec<Item = Y>,

const SLOPES: usize = 7

fn integrate( &self, function: impl FnMut(Scalar, &Y) -> Result<Y, String>, time: &[Scalar], initial_condition: Y, ) -> Result<(Vector, U, U), IntegrationError>

Solves an initial value problem by explicitly integrating a system of ordinary differential equations.

impl<F, Y, Z, U, V> ExplicitDaeFirstOrderMinimize<F, Y, Z, U, V> for DormandPrince

where Y: Tensor, Z: Tensor, U: TensorVec<Item = Y>, V: TensorVec<Item = Z>, for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>,

fn integrate( &self, evolution: impl FnMut(Scalar, &Y, &Z) -> Result<Y, String>, function: impl FnMut(Scalar, &Y, &Z) -> Result<F, String>, jacobian: impl FnMut(Scalar, &Y, &Z) -> Result<Z, String>, solver: impl FirstOrderOptimization<F, Z>, time: &[Scalar], initial_condition: (Y, Z), equality_constraint: impl FnMut(Scalar) -> EqualityConstraint, ) -> Result<(Vector, U, U, V), IntegrationError>

impl<F, J, Y, Z, U, V> ExplicitDaeFirstOrderRoot<F, J, Y, Z, U, V> for DormandPrince

where Y: Tensor, Z: Tensor, U: TensorVec<Item = Y>, V: TensorVec<Item = Z>, for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>,

fn integrate( &self, evolution: impl FnMut(Scalar, &Y, &Z) -> Result<Y, String>, function: impl FnMut(Scalar, &Y, &Z) -> Result<F, String>, jacobian: impl FnMut(Scalar, &Y, &Z) -> Result<J, String>, solver: impl FirstOrderRootFinding<F, J, Z>, time: &[Scalar], initial_condition: (Y, Z), equality_constraint: impl FnMut(Scalar) -> EqualityConstraint, ) -> Result<(Vector, U, U, V), IntegrationError>

impl<F, J, H, Y, Z, U, V> ExplicitDaeSecondOrderMinimize<F, J, H, Y, Z, U, V> for DormandPrince

where Y: Tensor, Z: Tensor, U: TensorVec<Item = Y>, V: TensorVec<Item = Z>, for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>,

fn integrate( &self, evolution: impl FnMut(Scalar, &Y, &Z) -> Result<Y, String>, function: impl FnMut(Scalar, &Y, &Z) -> Result<F, String>, jacobian: impl FnMut(Scalar, &Y, &Z) -> Result<J, String>, hessian: impl FnMut(Scalar, &Y, &Z) -> Result<H, String>, solver: impl SecondOrderOptimization<F, J, H, Z>, time: &[Scalar], initial_condition: (Y, Z), equality_constraint: impl FnMut(Scalar) -> EqualityConstraint, banded: Option<Banded>, ) -> Result<(Vector, U, U, V), IntegrationError>

impl<Y, Z, U, V> ExplicitDaeVariableStep<Y, Z, U, V> for DormandPrince

where Self: ExplicitDaeZerothOrderRoot<Y, Z, U, V>, Y: Tensor, Z: Tensor, U: TensorVec<Item = Y>, V: TensorVec<Item = Z>, for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>,

fn slopes_solve( evolution: impl FnMut(Scalar, &Y, &Z) -> Result<Y, String>, solution: impl FnMut(Scalar, &Y, &Z) -> Result<Z, String>, y: &Y, z: &Z, t: Scalar, dt: Scalar, k: &mut [Y], y_trial: &mut Y, z_trial: &mut Z, ) -> Result<(), String>

fn slopes_solve_and_error( &self, evolution: impl FnMut(Scalar, &Y, &Z) -> Result<Y, String>, solution: impl FnMut(Scalar, &Y, &Z) -> Result<Z, String>, y: &Y, z: &Z, t: Scalar, dt: Scalar, k: &mut [Y], y_trial: &mut Y, z_trial: &mut Z, ) -> Result<Scalar, String>

fn step_solve( &self, _: impl FnMut(Scalar, &Y, &Z) -> Result<Y, String>, y: &mut Y, z: &mut Z, t: &mut Scalar, y_sol: &mut U, z_sol: &mut V, t_sol: &mut Vector, dydt_sol: &mut U, dt: &mut Scalar, k: &mut [Y], y_trial: &Y, z_trial: &Z, e: Scalar, ) -> Result<(), String>

fn integrate_explicit_dae_variable_step( &self, evolution: impl FnMut(Scalar, &Y, &Z) -> Result<Y, String>, solution: impl FnMut(Scalar, &Y, &Z) -> Result<Z, String>, time: &[Scalar], initial_condition: (Y, Z), ) -> Result<(Vector, U, U, V), IntegrationError>

fn interpolate_explicit_dae_variable_step( &self, evolution: impl FnMut(Scalar, &Y, &Z) -> Result<Y, String>, solution: impl FnMut(Scalar, &Y, &Z) -> Result<Z, String>, time: &Vector, tp: &Vector, yp: &U, zp: &V, ) -> Result<(U, U, V), IntegrationError>

impl<F, Y, Z, U, V> ExplicitDaeVariableStepExplicitFirstOrderMinimize<F, Y, Z, U, V> for DormandPrince

where Y: Tensor, Z: Tensor, U: TensorVec<Item = Y>, V: TensorVec<Item = Z>, for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>,

fn integrate_explicit_dae_variable_step_explicit_minimize_1( &self, evolution: impl FnMut(Scalar, &Y, &Z) -> Result<Y, String>, function: impl FnMut(Scalar, &Y, &Z) -> Result<F, String>, jacobian: impl FnMut(Scalar, &Y, &Z) -> Result<Z, String>, solver: impl FirstOrderOptimization<F, Z>, time: &[Scalar], initial_condition: (Y, Z), equality_constraint: impl FnMut(Scalar) -> EqualityConstraint, ) -> Result<(Vector, U, U, V), IntegrationError>

impl<F, J, Y, Z, U, V> ExplicitDaeVariableStepExplicitFirstOrderRoot<F, J, Y, Z, U, V> for DormandPrince

where Y: Tensor, Z: Tensor, U: TensorVec<Item = Y>, V: TensorVec<Item = Z>, for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>,

fn integrate_explicit_dae_variable_step_explicit_root_1( &self, evolution: impl FnMut(Scalar, &Y, &Z) -> Result<Y, String>, function: impl FnMut(Scalar, &Y, &Z) -> Result<F, String>, jacobian: impl FnMut(Scalar, &Y, &Z) -> Result<J, String>, solver: impl FirstOrderRootFinding<F, J, Z>, time: &[Scalar], initial_condition: (Y, Z), equality_constraint: impl FnMut(Scalar) -> EqualityConstraint, ) -> Result<(Vector, U, U, V), IntegrationError>

impl<F, J, H, Y, Z, U, V> ExplicitDaeVariableStepExplicitSecondOrderMinimize<F, J, H, Y, Z, U, V> for DormandPrince

where Y: Tensor, Z: Tensor, U: TensorVec<Item = Y>, V: TensorVec<Item = Z>, for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>,

fn integrate_explicit_dae_variable_step_explicit_minimize_2( &self, evolution: impl FnMut(Scalar, &Y, &Z) -> Result<Y, String>, function: impl FnMut(Scalar, &Y, &Z) -> Result<F, String>, jacobian: impl FnMut(Scalar, &Y, &Z) -> Result<J, String>, hessian: impl FnMut(Scalar, &Y, &Z) -> Result<H, String>, solver: impl SecondOrderOptimization<F, J, H, Z>, time: &[Scalar], initial_condition: (Y, Z), equality_constraint: impl FnMut(Scalar) -> EqualityConstraint, banded: Option<Banded>, ) -> Result<(Vector, U, U, V), IntegrationError>

impl<Y, Z, U, V> ExplicitDaeVariableStepExplicitZerothOrderRoot<Y, Z, U, V> for DormandPrince

where Y: Tensor, Z: Tensor, U: TensorVec<Item = Y>, V: TensorVec<Item = Z>, for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>,

fn integrate_explicit_dae_variable_step_explicit_root_0( &self, evolution: impl FnMut(Scalar, &Y, &Z) -> Result<Y, String>, function: impl FnMut(Scalar, &Y, &Z) -> Result<Z, String>, solver: impl ZerothOrderRootFinding<Z>, time: &[Scalar], initial_condition: (Y, Z), equality_constraint: impl FnMut(Scalar) -> EqualityConstraint, ) -> Result<(Vector, U, U, V), IntegrationError>

impl<Y, Z, U, V> ExplicitDaeVariableStepFirstSameAsLast<Y, Z, U, V> for DormandPrince

where Y: Tensor, Z: Tensor, U: TensorVec<Item = Y>, V: TensorVec<Item = Z>, for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>,

fn slopes_solve_and_error_fsal( evolution: impl FnMut(Scalar, &Y, &Z) -> Result<Y, String>, solution: impl FnMut(Scalar, &Y, &Z) -> Result<Z, String>, y: &Y, z: &Z, t: Scalar, dt: Scalar, k: &mut [Y], y_trial: &mut Y, z_trial: &mut Z, ) -> Result<Scalar, String>

fn step_solve_fsal( &self, y: &mut Y, z: &mut Z, t: &mut Scalar, y_sol: &mut U, z_sol: &mut V, t_sol: &mut Vector, dydt_sol: &mut U, dt: &mut Scalar, k: &mut [Y], y_trial: &Y, z_trial: &Z, e: Scalar, ) -> Result<(), String>

impl<Y, Z, U, V> ExplicitDaeZerothOrderRoot<Y, Z, U, V> for DormandPrince

where Y: Tensor, Z: Tensor, U: TensorVec<Item = Y>, V: TensorVec<Item = Z>, for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>,

fn integrate( &self, evolution: impl FnMut(Scalar, &Y, &Z) -> Result<Y, String>, function: impl FnMut(Scalar, &Y, &Z) -> Result<Z, String>, solver: impl ZerothOrderRootFinding<Z>, time: &[Scalar], initial_condition: (Y, Z), equality_constraint: impl FnMut(Scalar) -> EqualityConstraint, ) -> Result<(Vector, U, U, V), IntegrationError>

impl<F, Y, U> ImplicitDaeFirstOrderMinimize<F, Y, U> for DormandPrince

where Y: Tensor, U: TensorVec<Item = Y>, for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>,

fn integrate( &self, function: impl FnMut(Scalar, &Y, &Y) -> Result<F, String>, jacobian: impl FnMut(Scalar, &Y, &Y) -> Result<Y, String>, solver: impl FirstOrderOptimization<F, Y>, time: &[Scalar], initial_condition: Y, equality_constraint: impl FnMut(Scalar) -> EqualityConstraint, ) -> Result<(Vector, U, U), IntegrationError>

impl<F, J, Y, U> ImplicitDaeFirstOrderRoot<F, J, Y, U> for DormandPrince

where Y: Tensor, U: TensorVec<Item = Y>, for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>,

fn integrate( &self, function: impl FnMut(Scalar, &Y, &Y) -> Result<F, String>, jacobian: impl FnMut(Scalar, &Y, &Y) -> Result<J, String>, solver: impl FirstOrderRootFinding<F, J, Y>, time: &[Scalar], initial_condition: Y, equality_constraint: impl FnMut(Scalar) -> EqualityConstraint, ) -> Result<(Vector, U, U), IntegrationError>

impl<F, J, H, Y, U> ImplicitDaeSecondOrderMinimize<F, J, H, Y, U> for DormandPrince

where Y: Tensor, U: TensorVec<Item = Y>, for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>,

fn integrate( &self, function: impl FnMut(Scalar, &Y, &Y) -> Result<F, String>, jacobian: impl FnMut(Scalar, &Y, &Y) -> Result<J, String>, hessian: impl FnMut(Scalar, &Y, &Y) -> Result<H, String>, solver: impl SecondOrderOptimization<F, J, H, Y>, time: &[Scalar], initial_condition: Y, equality_constraint: impl FnMut(Scalar) -> EqualityConstraint, banded: Option<Banded>, ) -> Result<(Vector, U, U), IntegrationError>

impl<Y, U> ImplicitDaeVariableStep<Y, U> for DormandPrince

where Y: Tensor, U: TensorVec<Item = Y>, for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>,

fn integrate_implicit_dae_variable_step( &self, evolution: impl FnMut(Scalar, &Y, &Y) -> Result<Y, String>, time: &[Scalar], initial_condition: Y, ) -> Result<(Vector, U, U), IntegrationError>

fn interpolate_implicit_dae_variable_step( &self, evolution: impl FnMut(Scalar, &Y, &Y) -> Result<Y, String>, time: &Vector, tp: &Vector, yp: &U, dydtp: &U, ) -> Result<(U, U), IntegrationError>

impl<F, Y, U> ImplicitDaeVariableStepExplicitFirstOrderMinimize<F, Y, U> for DormandPrince

where Y: Tensor, U: TensorVec<Item = Y>, for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>,

fn integrate_implicit_dae_variable_step_explicit_minimize_1( &self, function: impl FnMut(Scalar, &Y, &Y) -> Result<F, String>, jacobian: impl FnMut(Scalar, &Y, &Y) -> Result<Y, String>, solver: impl FirstOrderOptimization<F, Y>, time: &[Scalar], initial_condition: Y, equality_constraint: impl FnMut(Scalar) -> EqualityConstraint, ) -> Result<(Vector, U, U), IntegrationError>

impl<F, J, Y, U> ImplicitDaeVariableStepExplicitFirstOrderRoot<F, J, Y, U> for DormandPrince

where Y: Tensor, U: TensorVec<Item = Y>, for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>,

fn integrate_implicit_dae_variable_step_explicit_root_1( &self, function: impl FnMut(Scalar, &Y, &Y) -> Result<F, String>, jacobian: impl FnMut(Scalar, &Y, &Y) -> Result<J, String>, solver: impl FirstOrderRootFinding<F, J, Y>, time: &[Scalar], initial_condition: Y, equality_constraint: impl FnMut(Scalar) -> EqualityConstraint, ) -> Result<(Vector, U, U), IntegrationError>

impl<F, J, H, Y, U> ImplicitDaeVariableStepExplicitSecondOrderMinimize<F, J, H, Y, U> for DormandPrince

where Y: Tensor, U: TensorVec<Item = Y>, for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>,

fn integrate_implicit_dae_variable_step_explicit_minimize_2( &self, function: impl FnMut(Scalar, &Y, &Y) -> Result<F, String>, jacobian: impl FnMut(Scalar, &Y, &Y) -> Result<J, String>, hessian: impl FnMut(Scalar, &Y, &Y) -> Result<H, String>, solver: impl SecondOrderOptimization<F, J, H, Y>, time: &[Scalar], initial_condition: Y, equality_constraint: impl FnMut(Scalar) -> EqualityConstraint, banded: Option<Banded>, ) -> Result<(Vector, U, U), IntegrationError>

impl<Y, U> ImplicitDaeVariableStepExplicitZerothOrderRoot<Y, U> for DormandPrince

where Y: Tensor, U: TensorVec<Item = Y>, for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>,

fn integrate_implicit_dae_variable_step_explicit_root_0( &self, function: impl FnMut(Scalar, &Y, &Y) -> Result<Y, String>, solver: impl ZerothOrderRootFinding<Y>, time: &[Scalar], initial_condition: Y, equality_constraint: impl FnMut(Scalar) -> EqualityConstraint, ) -> Result<(Vector, U, U), IntegrationError>

impl<Y, U> ImplicitDaeZerothOrderRoot<Y, U> for DormandPrince

where Y: Tensor, U: TensorVec<Item = Y>, for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>,

fn integrate( &self, function: impl FnMut(Scalar, &Y, &Y) -> Result<Y, String>, solver: impl ZerothOrderRootFinding<Y>, time: &[Scalar], initial_condition: Y, equality_constraint: impl FnMut(Scalar) -> EqualityConstraint, ) -> Result<(Vector, U, U), IntegrationError>

impl<Y, U> InterpolateSolution<Y, U> for DormandPrince

where Y: Tensor, for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>, U: TensorVec<Item = Y>,

fn interpolate( &self, time: &Vector, tp: &Vector, yp: &U, function: impl FnMut(Scalar, &Y) -> Result<Y, String>, ) -> Result<(U, U), IntegrationError>

Solution interpolation.

impl VariableStep for DormandPrince

fn abs_tol(&self) -> Scalar

Returns the absolute error tolerance.

fn rel_tol(&self) -> Scalar

Returns the relative error tolerance.

fn dt_beta(&self) -> Scalar

Returns the multiplier for adaptive time steps.

fn dt_expn(&self) -> Scalar

Returns the exponent for adaptive time steps.

fn dt_cut(&self) -> Scalar

Returns the cut back factor for function errors.

fn dt_min(&self) -> Scalar

Returns the minimum value for the time step.

impl<Y, U> VariableStepExplicit<Y, U> for DormandPrince

where Self: Explicit<Y, U>, Y: Tensor, for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>, U: TensorVec<Item = Y>,

fn error(dt: Scalar, k: &[Y]) -> Result<Scalar, String>

fn slopes( function: impl FnMut(Scalar, &Y) -> Result<Y, String>, y: &Y, t: Scalar, dt: Scalar, k: &mut [Y], y_trial: &mut Y, ) -> Result<(), String>

fn slopes_and_error( &self, function: impl FnMut(Scalar, &Y) -> Result<Y, String>, y: &Y, t: Scalar, dt: Scalar, k: &mut [Y], y_trial: &mut Y, ) -> Result<Scalar, String>

fn step( &self, _function: impl FnMut(Scalar, &Y) -> Result<Y, String>, y: &mut Y, t: &mut Scalar, y_sol: &mut U, t_sol: &mut Vector, dydt_sol: &mut U, dt: &mut Scalar, k: &mut [Y], y_trial: &Y, e: Scalar, ) -> Result<(), String>

fn integrate_variable_step( &self, function: impl FnMut(Scalar, &Y) -> Result<Y, String>, time: &[Scalar], initial_condition: Y, ) -> Result<(Vector, U, U), IntegrationError>

fn interpolate_variable_step( time: &Vector, tp: &Vector, yp: &U, function: impl FnMut(Scalar, &Y) -> Result<Y, String>, ) -> Result<(U, U), IntegrationError>

fn time_step(&self, error: Scalar, dt: &mut Scalar)

Provides the adaptive time step as a function of the error.

impl<Y, U> VariableStepExplicitFirstSameAsLast<Y, U> for DormandPrince

where Y: Tensor, for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>, U: TensorVec<Item = Y>,

fn slopes_and_error_fsal( function: impl FnMut(Scalar, &Y) -> Result<Y, String>, y: &Y, t: Scalar, dt: Scalar, k: &mut [Y], y_trial: &mut Y, ) -> Result<Scalar, String>

fn step_fsal( &self, y: &mut Y, t: &mut Scalar, y_sol: &mut U, t_sol: &mut Vector, dydt_sol: &mut U, dt: &mut Scalar, k: &mut [Y], y_trial: &Y, e: Scalar, ) -> Result<(), String>

impl<Y, U> OdeSolver<Y, U> for DormandPrince

where Y: Tensor, U: TensorVec<Item = Y>,