Struct Solution 

pub struct Solution<V: DefaultDenseMatrix> {
    pub ts: Vec<V::T>,
    pub ys: <V as DefaultDenseMatrix>::M,
    pub y_sens: Vec<<V as DefaultDenseMatrix>::M>,
    pub stop_reason: Option<OdeSolverStopReason<V::T>>,
    /* private fields */
}

Stores ODE solve output and continuation state for staged integrations.

A Solution can be reused across multiple calls to crate::OdeSolverMethod::solve_soln, allowing you to stop, inspect stop_reason, update model parameters or state, and then continue from where you left off.

Use Solution::new to collect adaptive internal timesteps up to a final time, or Solution::new_dense to fill user-provided evaluation times.

Example

use diffsol::{
    OdeBuilder, OdeSolverMethod, Solution, NalgebraLU, NalgebraMat,
    NalgebraVec,
};

type M = NalgebraMat<f64>;
type V = NalgebraVec<f64>;
type LS = NalgebraLU<f64>;

let problem = OdeBuilder::<M>::new()
    .p([0.1, 1.0])
    .rhs_implicit(
        |x, p, _t, y| {
            y[0] = -p[0] * x[0];
        },
        |_x, p, _t, v, y| {
            y[0] = -p[0] * v[0];
        },
    )
    .init(|p, _t, y| {
        y[0] = p[1];
    }, 1)
    .build()
    .unwrap();

let mut state = problem.bdf_state::<LS>().unwrap();
let mut soln = Solution::<V>::new(1.0_f64);

while !soln.is_complete() {
    state = problem
        .bdf_solver::<LS>(state)
        .unwrap()
        .solve_soln(&mut soln)
        .unwrap()
        .into_state();
}

assert!(soln.is_complete());
assert!(!soln.ts.is_empty());

Fields

ts: Vec<V::T>

ys: <V as DefaultDenseMatrix>::M

y_sens: Vec<<V as DefaultDenseMatrix>::M>

stop_reason: Option<OdeSolverStopReason<V::T>>

Implementations

impl<V: DefaultDenseMatrix> Solution<V>

pub fn is_complete(&self) -> bool

pub fn truncate<Eqn>( &mut self, problem: &OdeSolverProblem<Eqn>, state: StateRef<'_, V>, ) -> Result<(), DiffsolError>

where Eqn: OdeEquations<T = V::T, V = V, C = V::C>,

pub fn truncate_sens<Eqn>( &mut self, problem: &OdeSolverProblem<Eqn>, state: StateRef<'_, V>, ) -> Result<(), DiffsolError>

where Eqn: OdeEquationsImplicitSens<T = V::T, V = V, C = V::C>,

pub fn new(t_final: V::T) -> Self

pub fn new_dense(t_evals: Vec<V::T>) -> Result<Self, DiffsolError>