Trait OrdinaryNumericalMethod 

pub trait OrdinaryNumericalMethod<T, Y>
where
    T: Real,
    Y: State<T>,
{
    // Required methods
    fn init<F>(
        &mut self,
        ode: &F,
        t0: T,
        tf: T,
        y0: &Y,
    ) -> Result<Evals, Error<T, Y>>
       where F: ODE<T, Y>;
    fn step<F>(&mut self, ode: &F) -> Result<Evals, Error<T, Y>>
       where F: ODE<T, Y>;
    fn t(&self) -> T;
    fn y(&self) -> &Y;
    fn t_prev(&self) -> T;
    fn y_prev(&self) -> &Y;
    fn h(&self) -> T;
    fn set_h(&mut self, h: T);
    fn status(&self) -> &Status<T, Y>;
    fn set_status(&mut self, status: Status<T, Y>);
}

Trait for ODE solvers.

Implemented by types that can solve ODEs via repeated calls to step.

Required Methods

fn init<F>( &mut self, ode: &F, t0: T, tf: T, y0: &Y, ) -> Result<Evals, Error<T, Y>>

where F: ODE<T, Y>,

Initialize the solver before integration

Arguments

• system - System of ODEs to solve.
• t0 - Initial time.
• tf - Final time.
• y0 - Initial state.

Returns

• Result<Evals, Error<T, Y>> - Ok if initialization is successful,

fn step<F>(&mut self, ode: &F) -> Result<Evals, Error<T, Y>>

where F: ODE<T, Y>,

Advance the solution by one step

Arguments

• system - System of ODEs to solve.

Returns

• Result<Evals, Errors<T, Y>> - Ok if step is successful with the number of function evaluations,

fn t(&self) -> T

Time of last accepted step

fn y(&self) -> &Y

State at last accepted step

fn t_prev(&self) -> T

Time of previous accepted step

fn y_prev(&self) -> &Y

State at previous accepted step

fn h(&self) -> T

Step size for next step

fn set_h(&mut self, h: T)

Set step size for next step

fn status(&self) -> &Status<T, Y>

Current solver status

fn set_status(&mut self, status: Status<T, Y>)

Set solver status

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<T: Real, Y: State<T>> OrdinaryNumericalMethod<T, Y> for AdamsPredictorCorrector<Ordinary, Adaptive, T, Y, 4>

impl<T: Real, Y: State<T>> OrdinaryNumericalMethod<T, Y> for AdamsPredictorCorrector<Ordinary, Fixed, T, Y, 4>

impl<T: Real, Y: State<T>, const O: usize, const S: usize, const I: usize> OrdinaryNumericalMethod<T, Y> for DiagonallyImplicitRungeKutta<Ordinary, Adaptive, T, Y, O, S, I>

impl<T: Real, Y: State<T>, const O: usize, const S: usize, const I: usize> OrdinaryNumericalMethod<T, Y> for DiagonallyImplicitRungeKutta<Ordinary, Fixed, T, Y, O, S, I>

impl<T: Real, Y: State<T>, const O: usize, const S: usize, const I: usize> OrdinaryNumericalMethod<T, Y> for ExplicitRungeKutta<Ordinary, Adaptive, T, Y, O, S, I>

impl<T: Real, Y: State<T>, const O: usize, const S: usize, const I: usize> OrdinaryNumericalMethod<T, Y> for ExplicitRungeKutta<Ordinary, DormandPrince, T, Y, O, S, I>

impl<T: Real, Y: State<T>, const O: usize, const S: usize, const I: usize> OrdinaryNumericalMethod<T, Y> for ExplicitRungeKutta<Ordinary, Fixed, T, Y, O, S, I>

impl<T: Real, Y: State<T>, const O: usize, const S: usize, const I: usize> OrdinaryNumericalMethod<T, Y> for ImplicitRungeKutta<Ordinary, Adaptive, T, Y, O, S, I>

impl<T: Real, Y: State<T>, const O: usize, const S: usize, const I: usize> OrdinaryNumericalMethod<T, Y> for ImplicitRungeKutta<Ordinary, Fixed, T, Y, O, S, I>