Struct Euler 

pub struct Euler<N: ComplexField, S: DimName>
where
    DefaultAllocator: Allocator<N, S>,
{ /* private fields */ }

Euler solver for an IVP.

Solves an initial value problem using Euler’s method.

Examples

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

fn example() -> Result<(), String> {
    let solver = Euler::new()
        .with_dt_max(0.001)?
        .with_initial_conditions(&[1.0])?
        .with_start(0.0)?
        .with_end(1.0)?
        .build();
    let path = solver.solve_ivp(derivative, &mut ())?;

    for (time, state) in &path {
        assert!((time.exp() - state.column(0)[0]).abs() <= 0.001);
    }
    Ok(())
}

Implementations

impl<N: ComplexField, S: DimName> Euler<N, S>

where DefaultAllocator: Allocator<N, S>,

pub fn new() -> Self

Trait Implementations

impl<N: Clone + ComplexField, S: Clone + DimName> Clone for Euler<N, S>

where DefaultAllocator: Allocator<N, S>, N::RealField: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<N: Debug + ComplexField, S: Debug + DimName> Debug for Euler<N, S>

where DefaultAllocator: Allocator<N, S>, N::RealField: Debug,

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

Formats the value using the given formatter.

impl<N: Default + ComplexField, S: Default + DimName> Default for Euler<N, S>

where DefaultAllocator: Allocator<N, S>, N::RealField: Default,

fn default() -> Euler<N, S>

Returns the “default value” for a type.

impl<N: ComplexField, S: DimName> IVPSolver<N, S> for Euler<N, S>

where DefaultAllocator: Allocator<N, S>,

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

Step forward in the solver. Returns if the solver is finished, produced an acceptable state, or needs to be redone.

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

Set the error tolerance for this solver.

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

Set the maximum time step for this solver.

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

Set the minimum time step for this solver.

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

Set the initial time for this solver.

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

Set the end time for this solver.

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

Set the initial conditions for this solver.

fn build(self) -> Self

Build this solver.

fn get_initial_conditions(&self) -> Option<VectorN<N, S>>

Return the initial conditions. Called once at the very start of solving.

fn get_time(&self) -> Option<N::RealField>

Get the current time of the solver.

fn check_start(&self) -> Result<(), String>

Make sure that every value that needs to be set is set before the solver starts

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>

Solve an initial value problem, consuming the solver