Struct SolverOptions 

pub struct SolverOptions<S: Scalar> {
    pub rtol: S,
    pub atol: S,
    pub h0: Option<S>,
    pub h_max: S,
    pub h_min: S,
    pub max_steps: usize,
    pub t_eval: Option<Vec<S>>,
    pub dense_output: bool,
    pub events: Vec<Arc<dyn EventFunction<S>>>,
}

Solver options and tolerances.

Cloneable thanks to Arc-wrapped event functions.

Fields

rtol: S

Relative tolerance

atol: S

Absolute tolerance (scalar)

h0: Option<S>

Initial step size (None = auto)

h_max: S

Maximum step size

h_min: S

Minimum step size

max_steps: usize

Maximum number of steps

t_eval: Option<Vec<S>>

Output grid in the integration direction. When Some, each solver returns exactly these (t, y) pairs (Hermite cubic interpolated from accepted step endpoints; endpoints are reproduced bit-exact). When None, the natural adaptive step grid is returned.

dense_output: bool

Enable dense output

events: Vec<Arc<dyn EventFunction<S>>>

Event functions for zero-crossing detection (Arc enables Clone)

Implementations

impl<S: Scalar> SolverOptions<S>

pub fn rtol(self, rtol: S) -> Self

Set relative tolerance.

Examples found in repository

examples/radau5_step_audit.rs (line 15)

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 atol(self, atol: S) -> Self

Set absolute tolerance.

Examples found in repository

examples/radau5_step_audit.rs (line 15)

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 h0(self, h0: S) -> Self

Set initial step size.

pub fn h_max(self, h_max: S) -> Self

Set maximum step size.

pub fn t_eval(self, t_eval: Vec<S>) -> Self

Set evaluation times.

pub fn dense(self) -> Self

Enable dense output.

pub fn max_steps(self, max_steps: usize) -> Self

Set maximum number of steps.

pub fn h_min(self, h_min: S) -> Self

Set minimum step size.

pub fn event(self, event: Box<dyn EventFunction<S>>) -> Self

Add an event function for zero-crossing detection.

Internally converts to Arc to enable Clone on SolverOptions.

Trait Implementations

impl<S: Scalar> Clone for SolverOptions<S>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Scalar> Debug for SolverOptions<S>

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

Formats the value using the given formatter.

impl<S: Scalar> Default for SolverOptions<S>

fn default() -> Self

Returns the “default value” for a type.