Struct Verner9 

pub struct Verner9 {
    pub abs_tol: Scalar,
    pub rel_tol: Scalar,
    pub dt_beta: Scalar,
    pub dt_expn: Scalar,
    pub dt_cut: Scalar,
    pub dt_grow: Scalar,
    pub dt_min: Scalar,
    pub error_norm: Norm,
}

Explicit, sixteen-stage, ninth-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)

\cdots

---

1. J.H. Verner, Numer. Algor. 53, 383 (2010). ↩

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_grow: Scalar

Growth factor ceiling for the time step.

dt_min: Scalar

Minimum value for the time step.

error_norm: Norm

Norm type for error evaluation.

Trait Implementations

impl Debug for Verner9

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

Formats the value using the given formatter.

impl Default for Verner9

fn default() -> Self

Returns the “default value” for a type.

impl<Y, U, V, T> Explicit<Y, U, V, T> for Verner9

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

const SLOPES: usize = 16

fn integrate( &self, function: impl FnMut(Quantity<T>, &Y) -> Result<Derivative<Y, T>, String>, time: &[Quantity<T>], initial_condition: Y, ) -> Result<(Times<T>, U, V), IntegrationError>

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

fn integrate_bounded( &self, function: impl FnMut(Quantity<T>, &Y) -> Result<Derivative<Y, T>, String>, bound: impl FnMut(Quantity<T>, &Y) -> Result<Spectrum<T>, String>, safety: Scalar, time: &[Quantity<T>], initial_condition: Y, ) -> Result<(Times<T>, U, V), IntegrationError>

Solves an initial value problem like integrate, subject to a stability bound.

impl<Y, Z, U, V, W, T> ExplicitDaeVariableStepExplicit<Y, Z, U, V, W, T> for Verner9

where Y: Differentiable<T> + Tensor, Z: PartialEq + Tensor, Derivative<Y, T>: Mul<Quantity<T>, Output = Y>, U: TensorVec<Item = Y>, V: TensorVec<Item = Z>, W: TensorVec<Item = Derivative<Y, T>>, for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>, for<'a> &'a Derivative<Y, T>: Mul<Scalar, Output = Derivative<Y, T>> + Mul<Quantity<T>, Output = Y>,

fn integrate_explicit_dae_variable_step( &self, evolution: impl FnMut(Quantity<T>, &Y, &Z) -> Result<Derivative<Y, T>, String>, solution: impl FnMut(Quantity<T>, &Y, &Z) -> Result<Z, String>, time: &[Quantity<T>], initial_condition: (Y, Z), ) -> Result<(Times<T>, U, W, V), IntegrationError>

fn interpolate_explicit_dae_variable_step( &self, evolution: impl FnMut(Quantity<T>, &Y, &Z) -> Result<Derivative<Y, T>, String>, solution: impl FnMut(Quantity<T>, &Y, &Z) -> Result<Z, String>, time: &Times<T>, tp: &Times<T>, yp: &U, _dydtp: &W, _k_sol: &[W], zp: &V, ) -> Result<(U, W, V), IntegrationError>

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

VariableStepExplicit::slopes with the algebraic constraint resolved before each stage.

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

fn step_solve( &self, evolution: impl FnMut(Quantity<T>, &Y, &Z) -> Result<Derivative<Y, T>, String>, y: &mut Y, z: &mut Z, t: &mut Quantity<T>, y_sol: &mut U, z_sol: &mut V, t_sol: &mut Times<T>, dydt_sol: &mut W, k_sol: &mut Vec<W>, dt: &mut Quantity<T>, k: &mut [Derivative<Y, T>], y_trial: &Y, z_trial: &Z, e: Scalar, ) -> Result<(), String>

impl<Y, U, V, T> InterpolateSolution<Y, U, V, T> for Verner9

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

fn interpolate( &self, time: &Times<T>, tp: &Times<T>, yp: &U, _dydtp: &V, _k_sol: &[V], function: impl FnMut(Quantity<T>, &Y) -> Result<Derivative<Y, T>, String>, ) -> Result<(U, V), IntegrationError>

Solution interpolation.

impl<Y, U> OdeIntegrator<Y, U> for Verner9

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

impl<T> Stacked<T> for Verner9

fn integrate_stacked<X, UX, UV, UA>( &self, function: impl FnMut(Quantity<T>, &X, &Derivative<X, T>) -> Result<Derivative<Derivative<X, T>, T>, String>, time: &[Quantity<T>], initial_position: X, initial_velocity: Derivative<X, T>, ) -> Result<(Times<T>, UX, UV, UA), IntegrationError>

where Self: Explicit<TensorTuple<X, Derivative<X, T>>, TensorVector<TensorTuple<X, Derivative<X, T>>>, TensorVector<Derivative<TensorTuple<X, Derivative<X, T>>, T>>, T>, X: Differentiable<T> + Tensor, Derivative<X, T>: Differentiable<T> + Tensor, UX: TensorVec<Item = X>, UV: TensorVec<Item = Derivative<X, T>>, UA: TensorVec<Item = Derivative<Derivative<X, T>, T>>,

Solves an initial value problem for dynamics, given the acceleration as a function of time, position, and velocity.

fn integrate_stacked_bounded<X, UX, UV, UA>( &self, function: impl FnMut(Quantity<T>, &X, &Derivative<X, T>) -> Result<Derivative<Derivative<X, T>, T>, String>, bound: impl FnMut(Quantity<T>, &X, &Derivative<X, T>) -> Result<Quantity<T>, String>, safety: Scalar, time: &[Quantity<T>], initial_position: X, initial_velocity: Derivative<X, T>, ) -> Result<(Times<T>, UX, UV, UA), IntegrationError>

where Self: Explicit<TensorTuple<X, Derivative<X, T>>, TensorVector<TensorTuple<X, Derivative<X, T>>>, TensorVector<Derivative<TensorTuple<X, Derivative<X, T>>, T>>, T>, X: Differentiable<T> + Tensor, Derivative<X, T>: Differentiable<T> + Tensor, UX: TensorVec<Item = X>, UV: TensorVec<Item = Derivative<X, T>>, UA: TensorVec<Item = Derivative<Derivative<X, T>, T>>,

Solves an initial value problem like integrate_stacked, subject to a stability bound.

fn integrate_stacked_coupled<X, Y, UX, UV, UA, UY, UR>( &self, function: impl FnMut(Quantity<T>, &X, &Derivative<X, T>, &Y) -> Result<(Derivative<Derivative<X, T>, T>, Derivative<Y, T>), String>, time: &[Quantity<T>], initial_position: X, initial_velocity: Derivative<X, T>, initial_state: Y, ) -> Result<(Times<T>, UX, UV, UA, UY, UR), IntegrationError>

where Self: Explicit<TensorTuple<TensorTuple<X, Derivative<X, T>>, Y>, TensorVector<TensorTuple<TensorTuple<X, Derivative<X, T>>, Y>>, TensorVector<Derivative<TensorTuple<TensorTuple<X, Derivative<X, T>>, Y>, T>>, T>, X: Differentiable<T> + Tensor, Derivative<X, T>: Differentiable<T> + Tensor, Y: Differentiable<T> + Tensor, UX: TensorVec<Item = X>, UV: TensorVec<Item = Derivative<X, T>>, UA: TensorVec<Item = Derivative<Derivative<X, T>, T>>, UY: TensorVec<Item = Y>, UR: TensorVec<Item = Derivative<Y, T>>,

fn integrate_stacked_coupled_bounded<X, Y, UX, UV, UA, UY, UR>( &self, function: impl FnMut(Quantity<T>, &X, &Derivative<X, T>, &Y) -> Result<(Derivative<Derivative<X, T>, T>, Derivative<Y, T>), String>, bound: impl FnMut(Quantity<T>, &X, &Derivative<X, T>, &Y) -> Result<Spectrum<T>, String>, safety: Scalar, time: &[Quantity<T>], initial_position: X, initial_velocity: Derivative<X, T>, initial_state: Y, ) -> Result<(Times<T>, UX, UV, UA, UY, UR), IntegrationError>

where Self: Explicit<TensorTuple<TensorTuple<X, Derivative<X, T>>, Y>, TensorVector<TensorTuple<TensorTuple<X, Derivative<X, T>>, Y>>, TensorVector<Derivative<TensorTuple<TensorTuple<X, Derivative<X, T>>, Y>, T>>, T>, X: Differentiable<T> + Tensor, Derivative<X, T>: Differentiable<T> + Tensor, Y: Differentiable<T> + Tensor, UX: TensorVec<Item = X>, UV: TensorVec<Item = Derivative<X, T>>, UA: TensorVec<Item = Derivative<Derivative<X, T>, T>>, UY: TensorVec<Item = Y>, UR: TensorVec<Item = Derivative<Y, T>>,

impl<T> VariableStep<T> for Verner9

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_grow(&self) -> Scalar

Returns the growth factor ceiling for adaptive time steps.

fn dt_min(&self) -> Quantity<T>

Returns the minimum value for the time step.

fn error_norm(&self) -> &Norm

Returns the norm type for error evaluation.

impl<Y, U, V, T> VariableStepExplicit<Y, U, V, T> for Verner9

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

type Tableau = Tableau

Butcher tableau of this method’s embedded pair.

fn integrate_variable_step( &self, function: impl FnMut(Quantity<T>, &Y) -> Result<Derivative<Y, T>, String>, time: &[Quantity<T>], initial_condition: Y, ) -> Result<(Times<T>, U, V), IntegrationError>

where Self: InterpolateSolution<Y, U, V, T>,

fn integrate_variable_step_bounded( &self, function: impl FnMut(Quantity<T>, &Y) -> Result<Derivative<Y, T>, String>, bound: impl FnMut(Quantity<T>, &Y) -> Result<Spectrum<T>, String>, safety: Scalar, time: &[Quantity<T>], initial_condition: Y, ) -> Result<(Times<T>, U, V), IntegrationError>

where Self: InterpolateSolution<Y, U, V, T>,

fn integrate_variable_step_limited( &self, function: impl FnMut(Quantity<T>, &Y) -> Result<Derivative<Y, T>, String>, limit: impl FnMut(Quantity<T>, &Y) -> Result<Quantity<T>, String>, time: &[Quantity<T>], initial_condition: Y, ) -> Result<(Times<T>, U, V), IntegrationError>

where Self: InterpolateSolution<Y, U, V, T>,

fn interpolate_variable_step( time: &Times<T>, tp: &Times<T>, yp: &U, function: impl FnMut(Quantity<T>, &Y) -> Result<Derivative<Y, T>, String>, ) -> Result<(U, V), IntegrationError>

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

Runge–Kutta stages and the propagating solution.

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

Embedded local-error estimate reduced through the error norm.

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

fn step( &self, function: impl FnMut(Quantity<T>, &Y) -> Result<Derivative<Y, T>, String>, y: &mut Y, t: &mut Quantity<T>, y_sol: &mut U, t_sol: &mut Times<T>, dydt_sol: &mut V, k_sol: &mut Vec<V>, dt: &mut Quantity<T>, k: &mut [Derivative<Y, T>], y_trial: &Y, e: Scalar, ) -> Result<(), String>

fn time_step(&self, error: Scalar, tolerance: Scalar, dt: &mut Quantity<T>)

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