Struct bacon_sci::ivp::Adams2

pub struct Adams2<N: ComplexField, S: DimName> where
    DefaultAllocator: Allocator<N, S>,
    DefaultAllocator: Allocator<N::RealField, U3>,
    DefaultAllocator: Allocator<N, U3>,  { /* fields omitted */ }

3rd order Adams predictor-corrector method for solving an IVP.

Defines the predictor and corrector coefficients, as well as the error coefficient. Uses AdamsInfo for the actual solving.

Examples

use nalgebra::{VectorN, U1};
use bacon_sci::ivp::{Adams2, AdamsSolver};
fn derivatives(_t: f64, state: &[f64], _p: &mut ()) -> Result<VectorN<f64, U1>, String> {
    Ok(VectorN::<f64, U1>::from_column_slice(state))
}


fn example() -> Result<(), String> {
    let adams = Adams2::new()
        .with_dt_max(0.1)?
        .with_dt_min(0.00001)?
        .with_tolerance(0.00001)?
        .with_start(0.0)?
        .with_end(1.0)?
        .with_initial_conditions(&[1.0])?
        .build();
    let path = adams.solve_ivp(derivatives, &mut ())?;
    for (time, state) in &path {
        assert!((time.exp() - state.column(0)[0]).abs() < 0.001);
    }
    Ok(())
}

Implementations

impl<N: ComplexField, S: DimName> Adams2<N, S> where
    DefaultAllocator: Allocator<N, S>,
    DefaultAllocator: Allocator<N, U3>,
    DefaultAllocator: Allocator<N::RealField, U3>, 

pub fn new() -> Self

Trait Implementations

impl<N: ComplexField, S: DimName> AdamsSolver<N, S, U3> for Adams2<N, S> where
    DefaultAllocator: Allocator<N, S>,
    DefaultAllocator: Allocator<N::RealField, U3>,
    DefaultAllocator: Allocator<N, U3>, 

fn predictor_coefficients() -> VectorN<N::RealField, U3>

The polynomial interpolation coefficients for the predictor. Should start with the coefficient for n - 1

fn corrector_coefficients() -> VectorN<N::RealField, U3>

The polynomial interpolation coefficients for the corrector. Must be the same length as predictor_coefficients. Should start with the implicit coefficient.

fn error_coefficient() -> N::RealField

Coefficient for multiplying error by.

fn solve_ivp<T: Clone, F: FnMut(N::RealField, &[N], &mut T) -> Result<VectorN<N, S>, String>>(
    self,
    f: F,
    params: &mut T
) -> Result<Vec<(N::RealField, VectorN<N, S>)>, String>

Use AdamsInfo to solve an initial value problem

fn with_tolerance(mut self: Self, tol: N::RealField) -> Result<Self, String>

Set the error tolerance for this solver.

fn with_dt_max(mut self: Self, max: N::RealField) -> Result<Self, String>

Set the maximum time step for this solver.

fn with_dt_min(mut self: Self, min: N::RealField) -> Result<Self, String>

Set the minimum time step for this solver.

fn with_start(mut self: Self, t_initial: N::RealField) -> Result<Self, String>

Set the initial time for this solver.

fn with_end(mut self: Self, t_final: N::RealField) -> Result<Self, String>

Set the end time for this solver.

fn with_initial_conditions(mut self: Self, start: &[N]) -> Result<Self, String>

Set the initial conditions for this solver.

fn build(mut self: Self) -> Self

Build this solver.

impl<N: Clone + ComplexField, S: Clone + DimName> Clone for Adams2<N, S> where
    DefaultAllocator: Allocator<N, S>,
    DefaultAllocator: Allocator<N::RealField, U3>,
    DefaultAllocator: Allocator<N, U3>, 

fn clone(&self) -> Adams2<N, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: Debug + ComplexField, S: Debug + DimName> Debug for Adams2<N, S> where
    DefaultAllocator: Allocator<N, S>,
    DefaultAllocator: Allocator<N::RealField, U3>,
    DefaultAllocator: Allocator<N, U3>, 

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

Formats the value using the given formatter.

impl<N: ComplexField, S: DimName> Default for Adams2<N, S> where
    DefaultAllocator: Allocator<N, S>,
    DefaultAllocator: Allocator<N::RealField, U3>,
    DefaultAllocator: Allocator<N, U3>, 

fn default() -> Self

Returns the "default value" for a type.

impl<N: ComplexField, S: DimName> From<Adams2<N, S>> for AdamsInfo<N, S, U3> where
    DefaultAllocator: Allocator<N, S>,
    DefaultAllocator: Allocator<N, U3>,
    DefaultAllocator: Allocator<N::RealField, U3>, 

fn from(adams: Adams2<N, S>) -> AdamsInfo<N, S, U3>

Performs the conversion.