Struct IVP 

pub struct IVP<EqType, T: Real, Y: State<T>, Method, SoloutType> { /* private fields */ }

Unified builder for initial value problems (IVPs).

Consolidates solver configurations, output configurations, and events.

Implementations

impl<'a, F, T: Real, Y: State<T>> IVP<OdeEq<'a, F>, T, Y, (), DefaultSolout>

pub fn ode(system: &'a F, t0: T, tf: T, y0: Y) -> Self

Create a new initial value problem for an ordinary differential equation.

impl<F, T: Real, Y: State<T>> IVP<OdeEqOwned<OdeFnWrapper<F>>, T, Y, (), DefaultSolout>

where F: Fn(T, &Y, &mut Y),

pub fn ode_from_fn(f: F, t0: T, tf: T, y0: Y) -> Self

Create a new initial value problem for an ordinary differential equation from a closure.

Example

use differential_equations::prelude::*;
let t0 = 0.0;
let tf = 1.0;
let y0 = 1.0;
let ivp = IVP::ode_from_fn(|t, y, dydt| { *dydt = t * y; }, t0, tf, y0);

impl<'a, F, T: Real, Y: State<T>> IVP<DaeEq<'a, F>, T, Y, (), DefaultSolout>

pub fn dae(system: &'a F, t0: T, tf: T, y0: Y) -> Self

Create a new initial value problem for a differential algebraic equation.

impl<F, M, T: Real, Y: State<T>> IVP<DaeEqOwned<DaeFnWrapper<F, M>>, T, Y, (), DefaultSolout>

where F: Fn(T, &Y, &mut Y), M: Fn(&mut Matrix<T>),

pub fn dae_from_fn(f: F, m: M, t0: T, tf: T, y0: Y) -> Self

Create a new initial value problem for a differential algebraic equation from closures.

impl<'a, F, T: Real, Y: State<T>> IVP<SdeEq<'a, F>, T, Y, (), DefaultSolout>

pub fn sde(system: &'a mut F, t0: T, tf: T, y0: Y) -> Self

Create a new initial value problem for a stochastic differential equation.

impl<Drift, Diff, Noise, T: Real, Y: State<T>> IVP<SdeEqOwned<SdeFnWrapper<Drift, Diff, Noise>>, T, Y, (), DefaultSolout>

where Drift: Fn(T, &Y, &mut Y), Diff: Fn(T, &Y, &mut Y), Noise: FnMut(T, &mut Y),

pub fn sde_from_fn( drift: Drift, diffusion: Diff, noise: Noise, t0: T, tf: T, y0: Y, ) -> Self

Create a new initial value problem for a stochastic differential equation from closures.

impl<'a, F, H, T: Real, Y: State<T>, const L: usize> IVP<DdeEq<'a, L, F, H>, T, Y, (), DefaultSolout>

pub fn dde(system: &'a F, t0: T, tf: T, y0: Y, history_function: H) -> Self

Create a new initial value problem for a delay differential equation.

impl<const L: usize, Diff, Lags, H, T: Real, Y: State<T>> IVP<DdeEqOwned<L, DdeFnWrapper<L, Diff, Lags>, H>, T, Y, (), DefaultSolout>

where Diff: Fn(T, &Y, &[Y; L], &mut Y), Lags: Fn(T, &Y, &mut [T; L]), H: Fn(T) -> Y + Clone,

pub fn dde_from_fn( diff: Diff, lags: Lags, t0: T, tf: T, y0: Y, history_function: H, ) -> Self

Create a new initial value problem for a delay differential equation from closures.

impl<EqType, T: Real, Y: State<T>, Method, SoloutType> IVP<EqType, T, Y, Method, SoloutType>

pub fn method<SNew>(self, method: SNew) -> IVP<EqType, T, Y, SNew, SoloutType>

Set the numerical method to be used.

The builder owns the method because solving mutates method state. Construct a fresh method for each solve, or use the low-level solve_* functions when you need to manage a mutable solver reference directly.

pub fn solout<ONew>(self, solout: ONew) -> IVP<EqType, T, Y, Method, ONew>

Set a custom solout function.

pub fn even(self, dt: T) -> IVP<EqType, T, Y, Method, EvenSolout<T>>

Output evenly spaced points between the initial and final time. Note that this does not include the solution of the calculated steps.

pub fn dense(self, n: usize) -> IVP<EqType, T, Y, Method, DenseSolout>

Use the Dense Output method to output n number of interpolation points between each step. Note this includes the solution of the calculated steps.

pub fn t_eval( self, points: impl AsRef<[T]>, ) -> IVP<EqType, T, Y, Method, TEvalSolout<T>>

Use the provided time points for evaluation instead of the default method. Note this does not include the solution of the calculated steps.

pub fn event<'a, E>( self, event: &'a E, ) -> IVP<EqType, T, Y, Method, EventWrappedSolout<'a, T, Y, SoloutType, E>>

where E: Event<T, Y> + ?Sized, SoloutType: Solout<T, Y>,

Wrap current solout with event detection while preserving original output strategy.

pub fn crossing( self, component_idx: usize, threshold: T, direction: CrossingDirection, ) -> IVP<EqType, T, Y, Method, CrossingSolout<T>>

Uses the CrossingSolout method to output points when a specific component crosses a threshold. Note this does not include the solution of the calculated steps.

pub fn hyperplane_crossing<Y1: State<T>>( self, point: Y1, normal: Y1, extractor: fn(&Y) -> Y1, direction: CrossingDirection, ) -> IVP<EqType, T, Y, Method, HyperplaneCrossingSolout<T, Y1, Y>>

Uses the HyperplaneCrossingSolout method to output points when a specific hyperplane is crossed. Note this does not include the solution of the calculated steps.

impl<EqType, T: Real, Y: State<T>, Method, SoloutType> IVP<EqType, T, Y, Method, SoloutType>

where Method: ToleranceConfig<T>,

pub fn rtol<V: Into<Tolerance<T>>>(self, rtol: V) -> Self

Set relative tolerance on the underlying solver.

pub fn atol<V: Into<Tolerance<T>>>(self, atol: V) -> Self

Set absolute tolerance on the underlying solver.

impl<'a, F, T: Real, Y: State<T>, Method, SoloutType> IVP<OdeEq<'a, F>, T, Y, Method, SoloutType>

where F: ODE<T, Y>, Method: OrdinaryNumericalMethod<T, Y> + Interpolation<T, Y>, SoloutType: Solout<T, Y>,

pub fn solve(self) -> Result<Solution<T, Y>, Error<T, Y>>

Solve the ODE initial value problem.

impl<F, T: Real, Y: State<T>, Method, SoloutType> IVP<OdeEqOwned<F>, T, Y, Method, SoloutType>

where F: ODE<T, Y>, Method: OrdinaryNumericalMethod<T, Y> + Interpolation<T, Y>, SoloutType: Solout<T, Y>,

pub fn solve(self) -> Result<Solution<T, Y>, Error<T, Y>>

Solve the ODE initial value problem.

impl<'a, F, T: Real, Y: State<T>, Method, SoloutType> IVP<DaeEq<'a, F>, T, Y, Method, SoloutType>

where F: DAE<T, Y>, Method: AlgebraicNumericalMethod<T, Y> + Interpolation<T, Y>, SoloutType: Solout<T, Y>,

pub fn solve(self) -> Result<Solution<T, Y>, Error<T, Y>>

Solve the DAE initial value problem.

impl<F, T: Real, Y: State<T>, Method, SoloutType> IVP<DaeEqOwned<F>, T, Y, Method, SoloutType>

where F: DAE<T, Y>, Method: AlgebraicNumericalMethod<T, Y> + Interpolation<T, Y>, SoloutType: Solout<T, Y>,

pub fn solve(self) -> Result<Solution<T, Y>, Error<T, Y>>

Solve the DAE initial value problem.

impl<'a, F, T: Real, Y: State<T>, Method, SoloutType> IVP<SdeEq<'a, F>, T, Y, Method, SoloutType>

where F: SDE<T, Y>, Method: StochasticNumericalMethod<T, Y> + Interpolation<T, Y>, SoloutType: Solout<T, Y>,

pub fn solve(self) -> Result<Solution<T, Y>, Error<T, Y>>

Solve the SDE initial value problem.

impl<F, T: Real, Y: State<T>, Method, SoloutType> IVP<SdeEqOwned<F>, T, Y, Method, SoloutType>

where F: SDE<T, Y>, Method: StochasticNumericalMethod<T, Y> + Interpolation<T, Y>, SoloutType: Solout<T, Y>,

pub fn solve(self) -> Result<Solution<T, Y>, Error<T, Y>>

Solve the SDE initial value problem.

impl<'a, const L: usize, F, H, T: Real, Y: State<T>, Method, SoloutType> IVP<DdeEq<'a, L, F, H>, T, Y, Method, SoloutType>

where F: DDE<L, T, Y>, H: Fn(T) -> Y + Clone, Method: DelayNumericalMethod<L, T, Y, H> + Interpolation<T, Y>, SoloutType: Solout<T, Y>,

pub fn solve(self) -> Result<Solution<T, Y>, Error<T, Y>>

Solve the DDE initial value problem.

impl<const L: usize, F, H, T: Real, Y: State<T>, Method, SoloutType> IVP<DdeEqOwned<L, F, H>, T, Y, Method, SoloutType>

where F: DDE<L, T, Y>, H: Fn(T) -> Y + Clone, Method: DelayNumericalMethod<L, T, Y, H> + Interpolation<T, Y>, SoloutType: Solout<T, Y>,

pub fn solve(self) -> Result<Solution<T, Y>, Error<T, Y>>

Solve the DDE initial value problem.

Trait Implementations

impl<EqType: Clone, T: Clone + Real, Y: Clone + State<T>, Method: Clone, SoloutType: Clone> Clone for IVP<EqType, T, Y, Method, SoloutType>

fn clone(&self) -> IVP<EqType, T, Y, Method, SoloutType>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<EqType: Debug, T: Debug + Real, Y: Debug + State<T>, Method: Debug, SoloutType: Debug> Debug for IVP<EqType, T, Y, Method, SoloutType>

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

Formats the value using the given formatter.