Struct PIController 

pub struct PIController<S: Scalar> {
    pub safety: S,
    pub fac_min: S,
    pub fac_max: S,
    pub beta1: S,
    pub beta2: S,
    /* private fields */
}

PI (Proportional-Integral) step size controller.

This is the standard controller used in most production ODE codes. It provides smoother step size changes than a simple error-based controller.

The new step size is computed as: h_new = h * (1/err)^(beta1/p) * (err_old/err)^(beta2/p)

where p is the method order.

Fields

safety: S

Safety factor (typically 0.9)

fac_min: S

Minimum step size factor

fac_max: S

Maximum step size factor

beta1: S

I-controller gain (typically 0.7/p)

beta2: S

P-controller gain (typically 0.4/p)

Implementations

impl<S: Scalar> PIController<S>

pub fn new() -> Self

Create a new PI controller with default parameters.

pub fn with_params( safety: S, fac_min: S, fac_max: S, beta1: S, beta2: S, ) -> Self

Create with custom parameters.

pub fn for_order(order: usize) -> Self

Create a controller tuned for a specific method order.

Trait Implementations

impl<S: Clone + Scalar> Clone for PIController<S>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug + Scalar> Debug for PIController<S>

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

impl<S: Scalar> StepController<S> for PIController<S>

fn propose(&mut self, h: S, err: S, order: usize) -> StepProposal<S>

Propose a new step size based on the error estimate.

fn accept(&mut self, h: S, err: S)

Called when a step is accepted.

fn reject(&mut self, _h: S, _err: S)

Called when a step is rejected.

fn reset(&mut self)

Reset the controller state.