Struct Euler

pub struct Euler<'a, N, D, T, F>
where
    N: ComplexField + Copy,
    D: Dimension,
    T: Clone,
    F: Derivative<N, D, T> + 'a,
    DefaultAllocator: Allocator<N, D>,
{ /* private fields */ }

Euler solver for an IVP.

Solves an initial value problem using Euler’s method.

Examples

use std::error::Error;
use bacon_sci::{BSVector, ivp::{Euler, IVPSolver, IVPError}};
fn derivative(_t: f64, state: &[f64], _p: &mut ()) -> Result<BSVector<f64, 1>, Box<dyn Error>> {
    Ok(BSVector::<f64, 1>::from_column_slice(state))
}

fn example() -> Result<(), IVPError> {
    let solver = Euler::new()?
        .with_maximum_dt(0.001)?
        .with_initial_conditions_slice(&[1.0])?
        .with_initial_time(0.0)?
        .with_ending_time(1.0)?
        .with_derivative(derivative)
        .solve(())?;
    let path = solver.collect_vec()?;

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

Trait Implementations

impl<'a, N, D, T, F> IVPSolver<'a, D> for Euler<'a, N, D, T, F>

where N: ComplexField + Copy, D: Dimension, T: Clone, F: Derivative<N, D, T> + 'a, DefaultAllocator: Allocator<N, D>,

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

Unused for Euler, call is a no-op

fn with_maximum_dt(self, max: Self::RealField) -> Result<Self, Self::Error>

If there is not time step already, set, then set the time step. If there is, set the time step to the average of that and the max passed in.

fn with_minimum_dt(self, min: Self::RealField) -> Result<Self, Self::Error>

If there is not time step already, set, then set the time step. If there is, set the time step to the average of that and the max passed in.

type Error = IVPError

Error type. IVPError must be able to convert to the error type.

type Field = N

The field, complex or real, that the solver is operating on.

type RealField = <N as ComplexField>::RealField

The real field associated with the solver’s Field.

type Derivative = F

The type signature of the derivative function to use

type UserData = T

Arbitrary data provided by the user for the derivative function

type Solver = EulerSolver<'a, N, D, T, F>

The type that actually does the solving.

fn new() -> Result<Self, Self::Error>

Create the solver. Will fail for dynamically sized solvers

fn new_dyn(size: usize) -> Result<Self, Self::Error>

Create the solver with a run-time dimension. Will fail for statically sized solvers

fn dim(&self) -> D

Gets the dimension of the solver

fn with_initial_time( self, initial: Self::RealField, ) -> Result<Self, Self::Error>

fn with_ending_time(self, ending: Self::RealField) -> Result<Self, Self::Error>

fn with_initial_conditions( self, start: BVector<Self::Field, D>, ) -> Result<Self, Self::Error>

The initial conditions of the problem, in a BVector. Should reset any previous values.

fn with_derivative(self, derivative: Self::Derivative) -> Self

Sets the derivative function to use during the solve

fn solve( self, data: Self::UserData, ) -> Result<IVPIterator<D, Self::Solver>, Self::Error>

Turns the solver into an iterator over the solution, using IVPStep::step

fn with_initial_conditions_slice( self, start: &[Self::Field], ) -> Result<Self, Self::Error>

The initial conditions of the problem, should reset any previous values.