Struct ClosureSystem 

pub struct ClosureSystem<S: Scalar, F> { /* private fields */ }

Closure-shaped adapter for solve_forward_sensitivity_with.

Wraps a closure of shape Fn(t, y, p, dydt) and a fixed parameter vector into a ParametricOdeSystem using FD-default Jacobians. Public so that callers writing a one-shot harness can construct it explicitly when they need to share it across multiple solver invocations.

Implementations

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

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

pub fn new(rhs: F, params: Vec<S>, n_states: usize) -> Self

Build a closure-backed ParametricOdeSystem.

Trait Implementations

impl<S: Scalar, F> ParametricOdeSystem<S> for ClosureSystem<S, F>

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

fn n_states(&self) -> usize

Number of state variables N (the dimension of y).

fn n_params(&self) -> usize

Number of parameters N_s (the dimension of p).

fn params(&self) -> &[S]

Nominal parameter vector. Length must equal Self::n_params.

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

Evaluate f(t, y, p) -> dy/dt for an arbitrary parameter vector p.

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

Convenience: evaluate the RHS at the system’s nominal parameters.

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

Fill the state Jacobian J_y[i,j] = ∂f_i/∂y_j in row-major order (jac[i*N + j], length N²).

fn jacobian_p(&self, t: S, y: &[S], jp: &mut [S])

Fill the parameter Jacobian J_p[i,k] = ∂f_i/∂p_k in column-major order (jp[k*N + i], length N · N_s).

fn initial_sensitivity(&self, _y0: &[S], s0: &mut [S])

Initial sensitivity ∂y_0/∂p, column-major (s0[k*N + i], length N · N_s).

fn has_analytical_jacobian_y(&self) -> bool

Returns true iff Self::jacobian_y has been overridden with an analytical implementation. Default: false.

fn has_analytical_jacobian_p(&self) -> bool

Returns true iff Self::jacobian_p has been overridden with an analytical implementation. Default: false. See Self::has_analytical_jacobian_y for the rationale, contract, and debug-build consistency check.