Struct DaeProblem 

pub struct DaeProblem<S: Scalar, F, M>
where
    F: Fn(S, &[S], &mut [S]),
    M: Fn(&mut [S]),
{
    pub f: F,
    pub mass: M,
    pub t0: S,
    pub tf: S,
    pub y0: Vec<S>,
    pub alg_indices: Vec<usize>,
}

DAE (Differential-Algebraic Equation) problem.

Represents: M * y’ = f(t, y)

where M is a (possibly singular) mass matrix.

• When M is nonsingular, this is equivalent to y’ = M⁻¹ f(t, y)
• When M is singular (index-1 DAE), some equations are algebraic constraints

Example: Pendulum DAE

The pendulum in Cartesian coordinates:

x'' = -λx         (x-component of constraint force)
y'' = -λy - g     (y-component + gravity)
x² + y² = L²      (constraint: pendulum length)

Written as first-order DAE with y = [x, y, vx, vy, λ]:

x'  = vx           (differential)
y'  = vy           (differential)
vx' = -λx          (differential)
vy' = -λy - g      (differential)
0   = x² + y² - L² (algebraic)

Fields

f: F

Right-hand side function

mass: M

Mass matrix function

t0: S

Initial time

tf: S

Final time

y0: Vec<S>

Initial state (must be consistent!)

alg_indices: Vec<usize>

Indices of algebraic variables (where M[i,i] = 0)

Implementations

impl<S: Scalar, F, M> DaeProblem<S, F, M>

where F: Fn(S, &[S], &mut [S]), M: Fn(&mut [S]),

pub fn new( f: F, mass: M, t0: S, tf: S, y0: Vec<S>, alg_indices: Vec<usize>, ) -> Self

Create a new DAE problem.

Arguments

• f - RHS function
• mass - Mass matrix function (fills row-major array)
• t0 - Initial time
• tf - Final time
• y0 - Initial state (must satisfy algebraic constraints!)
• alg_indices - Indices of algebraic equations

pub fn dim(&self) -> usize

Dimension of the system.

Trait Implementations

impl<S: Scalar, F, M> OdeSystem<S> for DaeProblem<S, F, M>

where F: Fn(S, &[S], &mut [S]), M: Fn(&mut [S]),

fn dim(&self) -> usize

Dimension of the system.

fn rhs(&self, t: S, y: &[S], dydt: &mut [S])

Compute the right-hand side: dydt = f(t, y)

fn has_mass_matrix(&self) -> bool

Does this system have a mass matrix?

fn mass_matrix(&self, mass: &mut [S])

Get the mass matrix M for the DAE: M * y’ = f(t, y)

fn is_singular_mass(&self) -> bool

Is the mass matrix singular? (i.e., is this a DAE?)

fn algebraic_indices(&self) -> Vec<usize>

Return indices of algebraic variables (where M[i,i] = 0).

fn jacobian(&self, t: S, y: &[S], jac: &mut [S])

Optionally compute the Jacobian: J = ∂f/∂y, row-major (jac[i*n + j] = ∂f_i/∂y_j, length n²).

fn is_autonomous(&self) -> bool

Is the system autonomous? (f does not depend on t explicitly)