Struct SensitivityResult 

pub struct SensitivityResult<S>
where
    S: Scalar,
{
    pub t: Vec<S>,
    pub y: Vec<S>,
    pub sensitivity: Vec<S>,
    pub n_states: usize,
    pub n_params: usize,
    pub stats: SolverStats,
    pub success: bool,
    pub message: String,
}

Result of an ODE forward-sensitivity solve.

Layout matches the conventions in the module-level docs: the state y is row-major over time; the sensitivity is row-major over time, column-major within each per-time block.

Fields

t: Vec<S>

Output time points (length n_times).

y: Vec<S>

State trajectory: y[i*N + j] = y_j(t_i), length n_times * N.

sensitivity: Vec<S>

Sensitivities: per-time block of length N · N_s, column-major within the block, so sensitivity[i * (N*N_s) + k*N + j] = ∂y_j(t_i)/∂p_k.

n_states: usize

Number of state variables N.

n_params: usize

Number of parameters N_s.

stats: SolverStats

Solver statistics from the underlying integration.

success: bool

Was the integration successful?

message: String

Error description if the integration failed.

Implementations

impl<S> SensitivityResult<S>

where S: Scalar,

pub fn len(&self) -> usize

Number of output time points.

pub fn is_empty(&self) -> bool

true if there are no output time points.

pub fn y_at(&self, i: usize) -> &[S]

State vector at output index i (length N).

pub fn sensitivity_at(&self, i: usize) -> &[S]

Full sensitivity block at output index i, column-major (length N · N_s). sensitivity_at(i)[k*N + j] = ∂y_j(t_i)/∂p_k.

pub fn sensitivity_for_param(&self, i: usize, k: usize) -> &[S]

Contiguous slice S_{:,k}(t_i) = ∂y/∂p_k at output index i, length N. Free slice thanks to the column-major flattening.

pub fn dyi_dpj(&self, i: usize, state: usize, param: usize) -> S

Single component ∂y_state(t_i)/∂p_param.

pub fn final_state(&self) -> &[S]

State at the final output time. Returns an empty slice if the result has no time points.

pub fn final_sensitivity(&self) -> &[S]

Sensitivity block at the final output time, column-major (length N · N_s). Empty slice when the result has no time points.

pub fn normalized_sensitivity_at(&self, i: usize, p_nominal: &[S]) -> Vec<S>

Normalised (logarithmic) sensitivity at output index i: (p_k / y_j) · ∂y_j/∂p_k, column-major in the same shape as Self::sensitivity_at. Components where |y_j| falls below 1e-15 · max(1, |y|_∞) are reported as zero to avoid blow-up.

Trait Implementations

impl<S> Clone for SensitivityResult<S>

where S: Clone + Scalar,

fn clone(&self) -> SensitivityResult<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S> Debug for SensitivityResult<S>

where S: Debug + Scalar,

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

Formats the value using the given formatter.