Struct OdeProblem 

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

ODE initial value problem.

Represents: dy/dt = f(t, y), y(t0) = y0, solve from t0 to tf

Fields

f: F

Right-hand side function

t0: S

Initial time

tf: S

Final time

y0: Vec<S>

Initial state

Implementations

impl<S: Scalar, F> OdeProblem<S, F>

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

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

Create a new ODE problem.

Examples found in repository

examples/radau5_step_audit.rs (line 14)

fn run<F>(name: &str, rhs: F, t0: f64, tf: f64, y0: Vec<f64>, rtol: f64, atol: f64)
where
    F: Fn(f64, &[f64], &mut [f64]) + Copy,
{
    let problem = OdeProblem::new(rhs, t0, tf, y0.clone());
    let opts = SolverOptions::default().rtol(rtol).atol(atol);
    let res = Radau5::solve(&problem, t0, tf, &y0, &opts).expect("solve failed");
    println!(
        "{:<32} acc={:>4}  rej={:>3}  rhs={:>5}  jac={:>3}  lu={:>4}",
        name,
        res.stats.n_accept,
        res.stats.n_reject,
        res.stats.n_eval,
        res.stats.n_jac,
        res.stats.n_lu,
    );
}

pub fn dim(&self) -> usize

Dimension of the system.

pub fn tspan(&self) -> (S, S)

Time span.

pub fn direction(&self) -> S

Integration direction: 1 for forward, -1 for backward.

Trait Implementations

impl<S: Scalar, F> OdeSystem<S> for OdeProblem<S, F>

where F: Fn(S, &[S], &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 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)

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).