Struct DDEProblem

pub struct DDEProblem<const L: usize, T, V, D, F, H>
where
    T: Real,
    V: State<T>,
    D: CallBackData,
    F: DDE<L, T, V, D>,
    H: Fn(T) -> V,
{
    pub dde: F,
    pub t0: T,
    pub tf: T,
    pub y0: V,
    pub phi: H,
    /* private fields */
}

Initial Value Problem for Delay Differential Equations (DDEs)

The Initial Value Problem takes the form: y’(t) = f(t, y(t), y(t-tau1), …), t ∈ [t0, tf], y(t) = phi(t) for t <= t0

Overview

The DDEProblem struct provides a simple interface for solving DDEs:

Example

use differential_equations::prelude::*;
use differential_equations::dde::methods::BS23;
use nalgebra::{Vector2, vector};

let mut bs23 = BS23::new()
   .rtol(1e-6)
   .atol(1e-6);

let t0 = 0.0;
let tf = 10.0;
let y0 = vector![1.0, 0.0];
let phi = |t| {
    y0
};
struct Example;
impl DDE<1, f64, Vector2<f64>> for Example {
    fn diff(&self, t: f64, y: &Vector2<f64>, yd: &[Vector2<f64>; 1], dydt: &mut Vector2<f64>) {
       dydt[0] = y[1] + yd[0][0];
       dydt[1] = -y[0] + yd[0][1];
    }

    fn lags(&self, _t: f64, _y: &Vector2<f64>, lags: &mut [f64; 1]) {
       lags[0] = 1.0; // Fixed delay of 1.0
    }
}
let solution = DDEProblem::new(Example, t0, tf, y0, phi).solve(&mut bs23).unwrap();

let (t, y) = solution.last().unwrap();
println!("Solution: ({}, {})", t, y);

Fields

• dde - DDE implementing the differential equation
• t0 - Initial time
• tf - Final time
• y0 - Initial state vector at t0
• phi - Initial history function phi(t) for t <= t0

Basic Usage

• new(dde, t0, tf, y0, phi) - Create a new DDEProblem
• solve(&mut solver) - Solve using default output (solver step points)

Output Control Methods

These methods configure how solution points are generated and returned:

• even(dt) - Generate evenly spaced output points with interval dt
• dense(n) - Include n interpolated points between each solver step
• t_eval(points) - Evaluate solution at specific time points
• solout(custom_solout) - Use a custom output handler

Each returns a solver configuration that can be executed with .solve(&mut solver).

Fields

dde: F

t0: T

tf: T

y0: V

phi: H

Implementations

impl<const L: usize, T, V, D, F, H> DDEProblem<L, T, V, D, F, H>

where T: Real, V: State<T>, D: CallBackData, F: DDE<L, T, V, D>, H: Fn(T) -> V + Clone,

pub fn new(dde: F, t0: T, tf: T, y0: V, phi: H) -> Self

Create a new Initial Value Problem for DDEs

Arguments

• dde - DDE containing the Differential Equation and Optional Terminate Function.
• t0 - Initial Time.
• tf - Final Time.
• y0 - Initial State Vector at t0.
• phi - Initial History Function phi(t) for t <= t0.

Returns

• DDEProblem Problem ready to be solved.

pub fn solve<S>(&self, solver: &mut S) -> Result<Solution<T, V, D>, Error<T, V>>

where S: DDENumericalMethod<L, T, V, H, D> + Interpolation<T, V>, H: Clone,

Solve the DDEProblem using a default solout, e.g. outputting solutions at calculated steps.

Returns

• Result<Solution<T, V, D>, Error<T, V>> - Ok(Solution) if successful or interrupted by events, Err(Error) if errors or issues are encountered.

pub fn solout<'a, O: Solout<T, V, D>>( &'a self, solout: &'a mut O, ) -> DDEProblemMutRefSoloutPair<'a, L, T, V, D, F, H, O>

Returns a DDEProblem DDENumericalMethod with the provided solout function for outputting points.

Returns

• DDEProblem DDENumericalMethod with the provided solout function ready for .solve() method.

pub fn even( &self, dt: T, ) -> DDEProblemSoloutPair<'_, L, T, V, D, F, H, EvenSolout<T>>

Uses the an Even Solout implementation to output evenly spaced points between the initial and final time. Note that this does not include the solution of the calculated steps.

Arguments

• dt - Interval between each output point.

Returns

• DDEProblem DDENumericalMethod with Even Solout function ready for .solve() method.

pub fn dense( &self, n: usize, ) -> DDEProblemSoloutPair<'_, L, T, V, D, F, H, DenseSolout>

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

Arguments

• n - Number of interpolation points between each step.

Returns

• DDEProblem DDENumericalMethod with Dense Output function ready for .solve() method.

pub fn t_eval( &self, points: Vec<T>, ) -> DDEProblemSoloutPair<'_, L, T, V, D, F, H, TEvalSolout<T>>

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

Arguments

• points - Custom output points.

Returns

• DDEProblem DDENumericalMethod with Custom Time Evaluation function ready for .solve() method.

pub fn crossing( &self, component_idx: usize, threshhold: T, direction: CrossingDirection, ) -> DDEProblemSoloutPair<'_, L, T, V, D, F, H, 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.

Arguments

• component_idx - Index of the component to monitor for crossing.
• threshhold - Value to cross.
• direction - Direction of crossing (positive or negative).

Returns

• DDEProblem DDENumericalMethod with CrossingSolout function ready for .solve() method.

pub fn hyperplane_crossing<V1>( &self, point: V1, normal: V1, extractor: fn(&V) -> V1, direction: CrossingDirection, ) -> DDEProblemSoloutPair<'_, L, T, V, D, F, H, HyperplaneCrossingSolout<T, V1, V>>

where V1: State<T>,

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

Arguments

• point - Point on the hyperplane.
• normal - Normal vector of the hyperplane.
• extractor - Function to extract the component from the state vector.
• direction - Direction of crossing (positive or negative).

Returns

• DDEProblem DDENumericalMethod with HyperplaneCrossingSolout function ready for .solve() method.

Trait Implementations

impl<const L: usize, T, V, D, F, H> Clone for DDEProblem<L, T, V, D, F, H>

where T: Real + Clone, V: State<T> + Clone, D: CallBackData + Clone, F: DDE<L, T, V, D> + Clone, H: Fn(T) -> V + Clone,

fn clone(&self) -> DDEProblem<L, T, V, D, F, H>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const L: usize, T, V, D, F, H> Debug for DDEProblem<L, T, V, D, F, H>

where T: Real + Debug, V: State<T> + Debug, D: CallBackData + Debug, F: DDE<L, T, V, D> + Debug, H: Fn(T) -> V + Debug,

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

Formats the value using the given formatter.