Struct GradientStatus 

pub struct GradientStatus {
    pub message: StatusMessage,
    pub x: DVector<Float>,
    pub fx: Float,
    pub n_f_evals: usize,
    pub n_g_evals: usize,
    pub n_h_evals: usize,
    pub hess: Option<DMatrix<Float>>,
    pub cov: Option<DMatrix<Float>>,
    pub err: Option<DVector<Float>>,
}

A status message struct containing all information about a minimization result.

Fields

message: StatusMessage

A StatusMessage that can be set by Algorithms.

x: DVector<Float>

The current parameters of the minimization.

fx: Float

The current value of the minimization problem function at GradientStatus::x.

n_f_evals: usize

The number of function evaluations (approximately, this is left up to individual Algorithms to correctly compute and may not be exact).

n_g_evals: usize

The number of gradient evaluations (approximately, this is left up to individual Algorithms to correctly compute and may not be exact).

n_h_evals: usize

The number of Hessian evaluations (approximately, this is left up to individual Algorithms to correctly compute and may not be exact).

hess: Option<DMatrix<Float>>

The Hessian matrix at the end of the fit (None if not computed yet)

cov: Option<DMatrix<Float>>

Covariance matrix at the end of the fit (None if not computed yet)

err: Option<DVector<Float>>

Errors on parameters at the end of the fit (None if not computed yet)

Implementations

impl GradientStatus

pub fn initialize(&mut self, pos: (DVector<Float>, Float))

Updates the GradientStatus::x and GradientStatus::fx fields and sets the status message to an initialized state.

pub fn set_position(&mut self, pos: (DVector<Float>, Float))

Updates the GradientStatus::x and GradientStatus::fx fields and sets the status message to a step state.

pub fn initialize_silent(&mut self, pos: (DVector<Float>, Float))

Updates the GradientStatus::x and GradientStatus::fx fields and marks the status as initialized without formatting a message payload.

pub fn set_position_silent(&mut self, pos: (DVector<Float>, Float))

Updates the GradientStatus::x and GradientStatus::fx fields and marks the status as a step without formatting a message payload.

pub fn inc_n_f_evals(&mut self)

Increments GradientStatus::n_f_evals by 1.

pub fn inc_n_g_evals(&mut self)

Increments GradientStatus::n_g_evals by 1.

pub fn inc_n_h_evals(&mut self)

Increments GradientStatus::n_h_evals by 1.

pub fn set_cov(&mut self, covariance: Option<DMatrix<Float>>)

Updates the GradientStatus::err field.

pub fn set_hess(&mut self, hessian: &DMatrix<Float>)

Updates the GradientStatus::hess field and computes GradientStatus::cov and GradientStatus::err.

Trait Implementations

impl<P, U, E> Algorithm<P, GradientStatus, U, E> for Adam

where P: Gradient<U, E>,

type Summary = MinimizationSummary

A type which holds a summary of the algorithm’s ending state.

type Config = AdamConfig

The configuration struct for the algorithm.

type Init = Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>

The initialization payload for a single run.

fn initialize( &mut self, problem: &P, status: &mut GradientStatus, args: &U, init: &Self::Init, config: &Self::Config, ) -> Result<(), E>

Any setup work done before the main steps of the algorithm should be done here.

fn step( &mut self, i_step: usize, problem: &P, status: &mut GradientStatus, args: &U, config: &Self::Config, ) -> Result<(), E>

The main “step” of an algorithm, which is repeated until termination conditions are met or the max number of steps have been taken.

fn summarize( &self, _current_step: usize, _problem: &P, status: &GradientStatus, _args: &U, init: &Self::Init, config: &Self::Config, ) -> Result<Self::Summary, E>

Generates a new Algorithm::Summary from the current state of the Algorithm, which can be displayed or used elsewhere.

fn reset(&mut self)

Reset the algorithm to its initial state.

fn default_callbacks() -> Callbacks<Self, P, GradientStatus, U, E, Self::Config>

where Self: Sized,

Provides a set of reasonable default callbacks specific to this Algorithm.

fn postprocessing( &mut self, problem: &P, status: &mut S, args: &U, config: &Self::Config, ) -> Result<(), E>

Runs any steps needed by the Algorithm after termination or convergence. This will run regardless of whether the Algorithm converged.

fn process<C>( &mut self, problem: &P, args: &U, init: Self::Init, config: Self::Config, callbacks: C, ) -> Result<Self::Summary, E>

where C: Into<Callbacks<Self, P, S, U, E, Self::Config>>, Self: Sized,

Process the given problem using this Algorithm.

fn process_with_default_callbacks( &mut self, problem: &P, user_data: &U, init: Self::Init, config: Self::Config, ) -> Result<Self::Summary, E>

where Self: Sized,

Process the given problem using this Algorithm and the algorithm’s default callbacks.

fn process_default( &mut self, problem: &P, user_data: &U, init: Self::Init, ) -> Result<Self::Summary, E>

where Self: Sized, Self::Config: Default,

Process the given problem using this Algorithm with default config and default callbacks.

impl<P, U, E> Algorithm<P, GradientStatus, U, E> for ConjugateGradient

where P: Gradient<U, E>,

type Summary = MinimizationSummary

A type which holds a summary of the algorithm’s ending state.

type Config = ConjugateGradientConfig

The configuration struct for the algorithm.

type Init = Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>

The initialization payload for a single run.

fn initialize( &mut self, problem: &P, status: &mut GradientStatus, args: &U, init: &Self::Init, config: &Self::Config, ) -> Result<(), E>

Any setup work done before the main steps of the algorithm should be done here.

fn step( &mut self, _current_step: usize, problem: &P, status: &mut GradientStatus, args: &U, config: &Self::Config, ) -> Result<(), E>

The main “step” of an algorithm, which is repeated until termination conditions are met or the max number of steps have been taken.

fn summarize( &self, _current_step: usize, _problem: &P, status: &GradientStatus, _args: &U, init: &Self::Init, config: &Self::Config, ) -> Result<Self::Summary, E>

Generates a new Algorithm::Summary from the current state of the Algorithm, which can be displayed or used elsewhere.

fn reset(&mut self)

Reset the algorithm to its initial state.

fn default_callbacks() -> Callbacks<Self, P, GradientStatus, U, E, Self::Config>

where Self: Sized,

Provides a set of reasonable default callbacks specific to this Algorithm.

fn postprocessing( &mut self, problem: &P, status: &mut S, args: &U, config: &Self::Config, ) -> Result<(), E>

Runs any steps needed by the Algorithm after termination or convergence. This will run regardless of whether the Algorithm converged.

fn process<C>( &mut self, problem: &P, args: &U, init: Self::Init, config: Self::Config, callbacks: C, ) -> Result<Self::Summary, E>

where C: Into<Callbacks<Self, P, S, U, E, Self::Config>>, Self: Sized,

Process the given problem using this Algorithm.

fn process_with_default_callbacks( &mut self, problem: &P, user_data: &U, init: Self::Init, config: Self::Config, ) -> Result<Self::Summary, E>

where Self: Sized,

Process the given problem using this Algorithm and the algorithm’s default callbacks.

fn process_default( &mut self, problem: &P, user_data: &U, init: Self::Init, ) -> Result<Self::Summary, E>

where Self: Sized, Self::Config: Default,

Process the given problem using this Algorithm with default config and default callbacks.

impl<P, U, E> Algorithm<P, GradientStatus, U, E> for LBFGSB

where P: Gradient<U, E>,

type Summary = MinimizationSummary

A type which holds a summary of the algorithm’s ending state.

type Config = LBFGSBConfig

The configuration struct for the algorithm.

type Init = Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>

The initialization payload for a single run.

fn initialize( &mut self, problem: &P, status: &mut GradientStatus, args: &U, init: &Self::Init, config: &Self::Config, ) -> Result<(), E>

Any setup work done before the main steps of the algorithm should be done here.

fn step( &mut self, _current_step: usize, problem: &P, status: &mut GradientStatus, args: &U, config: &Self::Config, ) -> Result<(), E>

The main “step” of an algorithm, which is repeated until termination conditions are met or the max number of steps have been taken.

fn postprocessing( &mut self, problem: &P, status: &mut GradientStatus, args: &U, config: &Self::Config, ) -> Result<(), E>

Runs any steps needed by the Algorithm after termination or convergence. This will run regardless of whether the Algorithm converged.

fn summarize( &self, _current_step: usize, _problem: &P, status: &GradientStatus, _args: &U, init: &Self::Init, config: &Self::Config, ) -> Result<Self::Summary, E>

Generates a new Algorithm::Summary from the current state of the Algorithm, which can be displayed or used elsewhere.

fn reset(&mut self)

Reset the algorithm to its initial state.

fn default_callbacks() -> Callbacks<Self, P, GradientStatus, U, E, Self::Config>

where Self: Sized,

Provides a set of reasonable default callbacks specific to this Algorithm.

fn process<C>( &mut self, problem: &P, args: &U, init: Self::Init, config: Self::Config, callbacks: C, ) -> Result<Self::Summary, E>

where C: Into<Callbacks<Self, P, S, U, E, Self::Config>>, Self: Sized,

Process the given problem using this Algorithm.

fn process_with_default_callbacks( &mut self, problem: &P, user_data: &U, init: Self::Init, config: Self::Config, ) -> Result<Self::Summary, E>

where Self: Sized,

Process the given problem using this Algorithm and the algorithm’s default callbacks.

fn process_default( &mut self, problem: &P, user_data: &U, init: Self::Init, ) -> Result<Self::Summary, E>

where Self: Sized, Self::Config: Default,

Process the given problem using this Algorithm with default config and default callbacks.

impl<P, U, E> Algorithm<P, GradientStatus, U, E> for TrustRegion

where P: Gradient<U, E>,

type Summary = MinimizationSummary

A type which holds a summary of the algorithm’s ending state.

type Config = TrustRegionConfig

The configuration struct for the algorithm.

type Init = Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>

The initialization payload for a single run.

fn initialize( &mut self, problem: &P, status: &mut GradientStatus, args: &U, init: &Self::Init, config: &Self::Config, ) -> Result<(), E>

Any setup work done before the main steps of the algorithm should be done here.

fn step( &mut self, _current_step: usize, problem: &P, status: &mut GradientStatus, args: &U, config: &Self::Config, ) -> Result<(), E>

The main “step” of an algorithm, which is repeated until termination conditions are met or the max number of steps have been taken.

fn postprocessing( &mut self, problem: &P, status: &mut GradientStatus, args: &U, config: &Self::Config, ) -> Result<(), E>

Runs any steps needed by the Algorithm after termination or convergence. This will run regardless of whether the Algorithm converged.

fn summarize( &self, _current_step: usize, _problem: &P, status: &GradientStatus, _args: &U, init: &Self::Init, config: &Self::Config, ) -> Result<Self::Summary, E>

Generates a new Algorithm::Summary from the current state of the Algorithm, which can be displayed or used elsewhere.

fn reset(&mut self)

Reset the algorithm to its initial state.

fn default_callbacks() -> Callbacks<Self, P, GradientStatus, U, E, Self::Config>

where Self: Sized,

Provides a set of reasonable default callbacks specific to this Algorithm.

fn process<C>( &mut self, problem: &P, args: &U, init: Self::Init, config: Self::Config, callbacks: C, ) -> Result<Self::Summary, E>

where C: Into<Callbacks<Self, P, S, U, E, Self::Config>>, Self: Sized,

Process the given problem using this Algorithm.

fn process_with_default_callbacks( &mut self, problem: &P, user_data: &U, init: Self::Init, config: Self::Config, ) -> Result<Self::Summary, E>

where Self: Sized,

Process the given problem using this Algorithm and the algorithm’s default callbacks.

fn process_default( &mut self, problem: &P, user_data: &U, init: Self::Init, ) -> Result<Self::Summary, E>

where Self: Sized, Self::Config: Default,

Process the given problem using this Algorithm with default config and default callbacks.

impl<P, U, E> CheckpointableAlgorithm<P, GradientStatus, U, E> for LBFGSB

where P: Gradient<U, E>,

type Checkpoint = LBFGSBCheckpoint

The checkpoint type used to resume the algorithm.

fn checkpoint( &self, status: &GradientStatus, next_step: usize, ) -> Self::Checkpoint

Create a checkpoint that resumes at next_step.

fn restore( &mut self, checkpoint: &Self::Checkpoint, config: &Self::Config, ) -> (GradientStatus, usize)

Restore the algorithm and status from a prior checkpoint.

fn process_from_checkpoint<C>( &mut self, problem: &P, args: &U, init: Self::Init, config: Self::Config, checkpoint: &Self::Checkpoint, callbacks: C, ) -> Result<Self::Summary, E>

where C: Into<Callbacks<Self, P, S, U, E, Self::Config>>, Self: Sized,

Continue processing from a prior checkpoint.

impl Clone for GradientStatus

fn clone(&self) -> GradientStatus

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GradientStatus

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

Formats the value using the given formatter.

impl Default for GradientStatus

fn default() -> GradientStatus

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for GradientStatus

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<U, E> LineSearch<GradientStatus, U, E> for BacktrackingLineSearch

fn search( &mut self, x: &DVector<Float>, p: &DVector<Float>, max_step: Option<Float>, problem: &dyn Gradient<U, E>, _bounds: Option<&Bounds>, args: &U, status: &mut GradientStatus, ) -> Result<Result<LineSearchOutput, LineSearchOutput>, E>

The search method takes the current position of the minimizer, x, the search direction p, the objective function func, optional bounds bounds, and any arguments to the objective function args, and returns a Result containing another Result. The outer Result tells the caller if the line search encountered any errors in evaluating cost functions or gradients, while the inner Result indicates if the line search algorithm found a valid step. Even if the line search failed to find a valid step, it will still return the best LineSearchOutput found, as there are some cases where this is recoverable. For example, some line searches will hit the maximum number of iterations for an interval bisection if x is the true minimum, in which case a search between x + eps and x + anything will never improve upon x itself. Individual algorithms should determine how to handle these edge cases.

impl<U, E> LineSearch<GradientStatus, U, E> for HagerZhangLineSearch

fn search( &mut self, x0: &DVector<Float>, p: &DVector<Float>, max_step: Option<Float>, problem: &dyn Gradient<U, E>, _bounds: Option<&Bounds>, args: &U, status: &mut GradientStatus, ) -> Result<Result<LineSearchOutput, LineSearchOutput>, E>

The search method takes the current position of the minimizer, x, the search direction p, the objective function func, optional bounds bounds, and any arguments to the objective function args, and returns a Result containing another Result. The outer Result tells the caller if the line search encountered any errors in evaluating cost functions or gradients, while the inner Result indicates if the line search algorithm found a valid step. Even if the line search failed to find a valid step, it will still return the best LineSearchOutput found, as there are some cases where this is recoverable. For example, some line searches will hit the maximum number of iterations for an interval bisection if x is the true minimum, in which case a search between x + eps and x + anything will never improve upon x itself. Individual algorithms should determine how to handle these edge cases.

impl<U, E> LineSearch<GradientStatus, U, E> for MoreThuenteLineSearch

fn search( &mut self, x0: &DVector<Float>, p: &DVector<Float>, max_step: Option<Float>, problem: &dyn Gradient<U, E>, _bounds: Option<&Bounds>, args: &U, status: &mut GradientStatus, ) -> Result<Result<LineSearchOutput, LineSearchOutput>, E>

The search method takes the current position of the minimizer, x, the search direction p, the objective function func, optional bounds bounds, and any arguments to the objective function args, and returns a Result containing another Result. The outer Result tells the caller if the line search encountered any errors in evaluating cost functions or gradients, while the inner Result indicates if the line search algorithm found a valid step. Even if the line search failed to find a valid step, it will still return the best LineSearchOutput found, as there are some cases where this is recoverable. For example, some line searches will hit the maximum number of iterations for an interval bisection if x is the true minimum, in which case a search between x + eps and x + anything will never improve upon x itself. Individual algorithms should determine how to handle these edge cases.

impl<U, E> LineSearch<GradientStatus, U, E> for StrongWolfeLineSearch

fn search( &mut self, x: &DVector<Float>, p: &DVector<Float>, max_step: Option<Float>, problem: &dyn Gradient<U, E>, bounds: Option<&Bounds>, args: &U, status: &mut GradientStatus, ) -> Result<Result<LineSearchOutput, LineSearchOutput>, E>

The search method takes the current position of the minimizer, x, the search direction p, the objective function func, optional bounds bounds, and any arguments to the objective function args, and returns a Result containing another Result. The outer Result tells the caller if the line search encountered any errors in evaluating cost functions or gradients, while the inner Result indicates if the line search algorithm found a valid step. Even if the line search failed to find a valid step, it will still return the best LineSearchOutput found, as there are some cases where this is recoverable. For example, some line searches will hit the maximum number of iterations for an interval bisection if x is the true minimum, in which case a search between x + eps and x + anything will never improve upon x itself. Individual algorithms should determine how to handle these edge cases.

impl ProgressStatus for GradientStatus

fn write_progress(&self, out: &mut String) -> Result

Write a status-specific progress payload into out.

impl Serialize for GradientStatus

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Status for GradientStatus

fn reset(&mut self)

Resets the status to its default state. This is called at the beginning of every Algorithm::process run. Only members that are not persistent between runs should be reset. For example, the initial parameters of a minimization should not be reset.

fn message(&self) -> &StatusMessage

Returns the message of the minimization.

fn set_message(&mut self) -> &mut StatusMessage

Sets the message of the minimization.

fn success(&self) -> bool

Returns true if the algorithm has terminated successfully

impl<P, U, E> Terminator<Adam, P, GradientStatus, U, E, AdamConfig> for AdamEMATerminator

where P: Gradient<U, E>,

fn check_for_termination( &mut self, _current_step: usize, algorithm: &mut Adam, _problem: &P, status: &mut GradientStatus, _args: &U, _config: &AdamConfig, ) -> ControlFlow<()>

A termination check which is called on each step of an Algorithm.

impl<P, U, E> Terminator<ConjugateGradient, P, GradientStatus, U, E, ConjugateGradientConfig> for ConjugateGradientGTerminator

where P: Gradient<U, E>,

fn check_for_termination( &mut self, _current_step: usize, algorithm: &mut ConjugateGradient, _problem: &P, status: &mut GradientStatus, _args: &U, _config: &ConjugateGradientConfig, ) -> ControlFlow<()>

A termination check which is called on each step of an Algorithm.

impl<P, U, E> Terminator<LBFGSB, P, GradientStatus, U, E, LBFGSBConfig> for LBFGSBFTerminator

where P: Gradient<U, E>,

fn check_for_termination( &mut self, _current_step: usize, algorithm: &mut LBFGSB, _problem: &P, status: &mut GradientStatus, _args: &U, _config: &LBFGSBConfig, ) -> ControlFlow<()>

A termination check which is called on each step of an Algorithm.

impl<P, U, E> Terminator<LBFGSB, P, GradientStatus, U, E, LBFGSBConfig> for LBFGSBGTerminator

where P: Gradient<U, E>,

fn check_for_termination( &mut self, _current_step: usize, algorithm: &mut LBFGSB, _problem: &P, status: &mut GradientStatus, _args: &U, _config: &LBFGSBConfig, ) -> ControlFlow<()>

A termination check which is called on each step of an Algorithm.

impl<P, U, E> Terminator<LBFGSB, P, GradientStatus, U, E, LBFGSBConfig> for LBFGSBInfNormGTerminator

where P: Gradient<U, E>,

fn check_for_termination( &mut self, _current_step: usize, algorithm: &mut LBFGSB, _problem: &P, status: &mut GradientStatus, _args: &U, _config: &LBFGSBConfig, ) -> ControlFlow<()>

A termination check which is called on each step of an Algorithm.

impl<P, U, E> Terminator<TrustRegion, P, GradientStatus, U, E, TrustRegionConfig> for TrustRegionGTerminator

where P: Gradient<U, E>,

fn check_for_termination( &mut self, _current_step: usize, algorithm: &mut TrustRegion, _problem: &P, status: &mut GradientStatus, _args: &U, _config: &TrustRegionConfig, ) -> ControlFlow<()>

A termination check which is called on each step of an Algorithm.