Struct CachedOdeProblem 

pub struct CachedOdeProblem<F>
where
    F: Fn(f64, &[f64], &mut [f64]) + Send + Sync,
{ /* private fields */ }

A pre-compiled ODE problem for repeated integration (neural ODE pattern).

Once constructed the RK4 graph is fixed: n_steps evaluations of rhs are performed per integrate call, with no re-allocation of step vectors.

Implementations

impl<F> CachedOdeProblem<F>

where F: Fn(f64, &[f64], &mut [f64]) + Send + Sync + 'static,

pub fn new(rhs: F, t0: f64, t1: f64, dt: f64, state_dim: usize) -> Self

Create a new cached ODE problem.

Parameters

• rhs: Right-hand side f(t, y, dydt) — writes into dydt.
• t0, t1: Integration interval [t0, t1].
• dt: Fixed step size. Actual n_steps = ceil((t1 - t0) / dt).
• state_dim: Dimensionality of the state vector.

Errors

Returns IntegrateError::ValueError if dt ≤ 0 or t1 ≤ t0.

pub fn integrate(&self, y0: &[f64]) -> Result<Vec<f64>, IntegrateError>

Integrate from initial state y0 and return the final state.

Pre-allocated scratch buffers are stack-allocated for state_dim ≤ 16 and heap-allocated otherwise; either way no allocation occurs inside the RK4 loop itself.

pub fn integrate_batch( &self, batch_y0: &[Vec<f64>], ) -> Result<Vec<Vec<f64>>, IntegrateError>

Batch integration — runs all initial conditions in parallel using Rayon.

Returns one output state vector per input in batch_y0, in the same order as the inputs.

pub fn dt(&self) -> f64

The step size used during integration.

pub fn n_steps(&self) -> usize

Number of RK4 steps per integrate call.

pub fn state_dim(&self) -> usize

State dimension.