Struct argmin::core::OptimizationResult

pub struct OptimizationResult<O, S, I> {
    pub problem: Problem<O>,
    pub solver: S,
    pub state: I,
}

Result of an optimization returned by after running an Executor.

Consists of the problem and the final state of the solver. Both can be accessed via deconstructing or via the methods problem and state.

Fields

problem: Problem<O>

Problem

solver: S

Solver

state: I

Iteration state

Implementations

impl<O, S, I> OptimizationResult<O, S, I>

pub fn new(problem: Problem<O>, solver: S, state: I) -> Self

Constructs a new instance of OptimizationResult from a problem and a state.

Example

let rosenbrock = Rosenbrock::new();
let state: IterState<Vec<f64>, (), (), (), (), f64> = IterState::new();
let solver = SomeSolver {};

let result = OptimizationResult::new(Problem::new(rosenbrock), solver, state);

pub fn problem(&self) -> &Problem<O>

Returns a reference to the stored problem.

Example

let problem: &Problem<Rosenbrock> = result.problem();

pub fn solver(&self) -> &S

Returns a reference to the stored solver.

Example

let solver = result.solver();

pub fn state(&self) -> &I

Returns a reference to the stored state.

Example

let state: &IterState<Vec<f64>, (), (), (), (), f64> = result.state();

Trait Implementations

impl<O: Clone, S: Clone, I: Clone> Clone for OptimizationResult<O, S, I>

fn clone(&self) -> OptimizationResult<O, S, I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<O, S, I> Display for OptimizationResult<O, S, I>

where I: State, I::Param: Debug, S: Solver<O, I>,

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

Formats the value using the given formatter.

impl<O, S, I: State> Ord for OptimizationResult<O, S, I>

fn cmp(&self, other: &OptimizationResult<O, S, I>) -> Ordering

Two OptimizationResults are equal if the absolute of the difference between their best cost values is smaller than epsilon. Else, an OptimizationResult is better if the best cost function value is strictly better than the others.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<O, S, I: State> PartialEq for OptimizationResult<O, S, I>

where I::Float: ArgminFloat,

fn eq(&self, other: &OptimizationResult<O, S, I>) -> bool

Two OptimizationResults are equal if the absolute of the difference between their best cost values is smaller than epsilon.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<O, S, I: State> PartialOrd for OptimizationResult<O, S, I>

fn partial_cmp(&self, other: &OptimizationResult<O, S, I>) -> Option<Ordering>

Two OptimizationResults are equal if the absolute of the difference between their best cost values is smaller than epsilon. Else, an OptimizationResult is better if the best cost function value is strictly better than the others.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<O, S, I: State> Eq for OptimizationResult<O, S, I>