Struct APCF4

pub struct APCF4<T: Real, V: State<T>, D: CallBackData> {
    pub h: T,
    pub evals: usize,
    /* private fields */
}

Adams-Predictor-Corrector 4th Order Fixed Step Size Method.

The Adams-Predictor-Corrector method is an explicit method that uses the previous states to predict the next state.

The First 3 steps, of fixed step size h, are calculated using the Runge-Kutta method of order 4(5) and then the Adams-Predictor-Corrector method is used to calculate the remaining steps tell the final time.

Example

use differential_equations::prelude::*;
use differential_equations::ode::methods::adams::APCF4;
use nalgebra::{SVector, vector};

struct HarmonicOscillator {
    k: f64,
}

impl ODE<f64, SVector<f64, 2>> for HarmonicOscillator {
    fn diff(&self, _t: f64, y: &SVector<f64, 2>, dydt: &mut SVector<f64, 2>) {
        dydt[0] = y[1];
        dydt[1] = -self.k * y[0];
    }
}
let mut apcf4 = APCF4::new(0.01);
let t0 = 0.0;
let tf = 10.0;
let y0 = vector![1.0, 0.0];
let system = HarmonicOscillator { k: 1.0 };
let results = ODEProblem::new(system, t0, tf, y0).solve(&mut apcf4).unwrap();
let expected = vector![-0.83907153, 0.54402111];
assert!((results.y.last().unwrap()[0] - expected[0]).abs() < 1e-2);
assert!((results.y.last().unwrap()[1] - expected[1]).abs() < 1e-2);

Settings

• h - Step Size

Fields

h: T

evals: usize

Implementations

impl<T: Real, V: State<T>, D: CallBackData> APCF4<T, V, D>

pub fn new(h: T) -> Self

Trait Implementations

impl<T: Real, V: State<T>, D: CallBackData> Default for APCF4<T, V, D>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Real, V: State<T>, D: CallBackData> Interpolation<T, V> for APCF4<T, V, D>

fn interpolate(&mut self, t_interp: T) -> Result<V, Error<T, V>>

Interpolate between previous and current step

impl<T: Real, V: State<T>, D: CallBackData> ODENumericalMethod<T, V, D> for APCF4<T, V, D>

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

where F: ODE<T, V, D>,

Initialize ODENumericalMethod before solving ODE

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

where F: ODE<T, V, D>,

Step through solving the ODE by one step

fn t(&self) -> T

Access time of last accepted step

fn y(&self) -> &V

Access solution of last accepted step

fn t_prev(&self) -> T

Access time of previous accepted step

fn y_prev(&self) -> &V

Access solution of previous accepted step

fn h(&self) -> T

Access step size of next step

fn set_h(&mut self, h: T)

Set step size of next step

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

Status of solver

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

Set status of solver