Struct argmin::core::IterState

pub struct IterState<O: ArgminOp> {

    pub param: O::Param,
    pub prev_param: O::Param,
    pub best_param: O::Param,
    pub prev_best_param: O::Param,
    pub cost: O::Float,
    pub prev_cost: O::Float,
    pub best_cost: O::Float,
    pub prev_best_cost: O::Float,
    pub target_cost: O::Float,
    pub grad: Option<O::Param>,
    pub prev_grad: Option<O::Param>,
    pub hessian: Option<O::Hessian>,
    pub prev_hessian: Option<O::Hessian>,
    pub inv_hessian: Option<O::Hessian>,
    pub prev_inv_hessian: Option<O::Hessian>,
    pub jacobian: Option<O::Jacobian>,
    pub prev_jacobian: Option<O::Jacobian>,
    pub population: Option<Vec<(O::Param, O::Float)>>,
    pub iter: u64,
    pub last_best_iter: u64,
    pub max_iters: u64,
    pub cost_func_count: u64,
    pub grad_func_count: u64,
    pub hessian_func_count: u64,
    pub jacobian_func_count: u64,
    pub modify_func_count: u64,
    pub time: Option<Duration>,
    pub termination_reason: TerminationReason,
}

Maintains the state from iteration to iteration of a solver

Fields

param: O::Param

Current parameter vector

prev_param: O::Param

Previous parameter vector

best_param: O::Param

Current best parameter vector

prev_best_param: O::Param

Previous best parameter vector

cost: O::Float

Current cost function value

prev_cost: O::Float

Previous cost function value

best_cost: O::Float

Current best cost function value

prev_best_cost: O::Float

Previous best cost function value

target_cost: O::Float

Target cost function value

grad: Option<O::Param>

Current gradient

prev_grad: Option<O::Param>

Previous gradient

hessian: Option<O::Hessian>

Current Hessian

prev_hessian: Option<O::Hessian>

Previous Hessian

inv_hessian: Option<O::Hessian>

Current inverse Hessian

prev_inv_hessian: Option<O::Hessian>

Previous inverse Hessian

jacobian: Option<O::Jacobian>

Current Jacobian

prev_jacobian: Option<O::Jacobian>

Previous Jacobian

population: Option<Vec<(O::Param, O::Float)>>

All members for population-based algorithms as (param, cost) tuples

iter: u64

Current iteration

last_best_iter: u64

Iteration number of last best cost

max_iters: u64

Maximum number of iterations

cost_func_count: u64

Number of cost function evaluations so far

grad_func_count: u64

Number of gradient evaluations so far

hessian_func_count: u64

Number of Hessian evaluations so far

jacobian_func_count: u64

Number of Jacobian evaluations so far

modify_func_count: u64

Number of modify evaluations so far

time: Option<Duration>

Time required so far

termination_reason: TerminationReason

Reason of termination

Implementations

impl<O: ArgminOp> IterState<O>

pub fn new(param: O::Param) -> Self

Create new IterState from param

pub fn param(&mut self, param: O::Param) -> &mut Self

Set parameter vector. This shifts the stored parameter vector to the previous parameter vector.

pub fn best_param(&mut self, param: O::Param) -> &mut Self

Set best paramater vector. This shifts the stored best parameter vector to the previous best parameter vector.

pub fn cost(&mut self, cost: O::Float) -> &mut Self

Set the current cost function value. This shifts the stored cost function value to the previous cost function value.

pub fn best_cost(&mut self, cost: O::Float) -> &mut Self

Set the current best cost function value. This shifts the stored best cost function value to the previous cost function value.

pub fn grad(&mut self, grad: O::Param) -> &mut Self

Set gradient. This shifts the stored gradient to the previous gradient.

pub fn hessian(&mut self, hessian: O::Hessian) -> &mut Self

Set Hessian. This shifts the stored Hessian to the previous Hessian.

pub fn inv_hessian(&mut self, inv_hessian: O::Hessian) -> &mut Self

Set inverse Hessian. This shifts the stored inverse Hessian to the previous inverse Hessian.

pub fn jacobian(&mut self, jacobian: O::Jacobian) -> &mut Self

Set Jacobian. This shifts the stored Jacobian to the previous Jacobian.

pub fn population(&mut self, population: Vec<(O::Param, O::Float)>) -> &mut Self

Set population

pub fn target_cost(&mut self, target_cost: O::Float) -> &mut Self

Set target cost value

pub fn max_iters(&mut self, max_iters: u64) -> &mut Self

Set maximum number of iterations

pub fn last_best_iter(&mut self, last_best_iter: u64) -> &mut Self

Set iteration number where the previous best parameter vector was found

pub fn termination_reason(
    &mut self,
    termination_reason: TerminationReason
) -> &mut Self

Set termination_reason

pub fn time(&mut self, time: Option<Duration>) -> &mut Self

Set time required so far

pub fn get_param(&self) -> O::Param

Returns current parameter vector

pub fn get_prev_param(&self) -> O::Param

Returns previous parameter vector

pub fn get_best_param(&self) -> O::Param

Returns best parameter vector

pub fn get_prev_best_param(&self) -> O::Param

Returns previous best parameter vector

pub fn get_cost(&self) -> O::Float

Returns current cost function value

pub fn get_prev_cost(&self) -> O::Float

Returns previous cost function value

pub fn get_best_cost(&self) -> O::Float

Returns current best cost function value

pub fn get_prev_best_cost(&self) -> O::Float

Returns previous best cost function value

pub fn get_target_cost(&self) -> O::Float

Returns target cost

pub fn get_cost_func_count(&self) -> u64

Returns current cost function evaluation count

pub fn get_grad_func_count(&self) -> u64

Returns current gradient function evaluation count

pub fn get_hessian_func_count(&self) -> u64

Returns current Hessian function evaluation count

pub fn get_jacobian_func_count(&self) -> u64

Returns current Jacobian function evaluation count

pub fn get_modify_func_count(&self) -> u64

Returns current Modify function evaluation count

pub fn get_last_best_iter(&self) -> u64

Returns iteration number where the last best parameter vector was found

pub fn get_termination_reason(&self) -> TerminationReason

Get termination_reason

pub fn get_time(&self) -> Option<Duration>

Get time required so far

pub fn get_grad(&self) -> Option<O::Param>

Returns gradient

pub fn get_prev_grad(&self) -> Option<O::Param>

Returns previous gradient

pub fn get_hessian(&self) -> Option<O::Hessian>

Returns current Hessian

pub fn get_prev_hessian(&self) -> Option<O::Hessian>

Returns previous Hessian

pub fn get_inv_hessian(&self) -> Option<O::Hessian>

Returns current inverse Hessian

pub fn get_prev_inv_hessian(&self) -> Option<O::Hessian>

Returns previous inverse Hessian

pub fn get_jacobian(&self) -> Option<O::Jacobian>

Returns current Jacobian

pub fn get_prev_jacobian(&self) -> Option<O::Jacobian>

Returns previous Jacobian

pub fn get_iter(&self) -> u64

Returns current number of iterations

pub fn get_max_iters(&self) -> u64

Returns maximum number of iterations

pub fn get_population(&self) -> Option<&Vec<(O::Param, O::Float)>>

Returns population

pub fn increment_iter(&mut self)

Increment the number of iterations by one

pub fn increment_func_counts(&mut self, op: &OpWrapper<O>)

Increment all function evaluation counts by the evaluation counts of another operator wrapped in OpWrapper.

pub fn set_func_counts(&mut self, op: &OpWrapper<O>)

Set all function evaluation counts to the evaluation counts of another operator wrapped in OpWrapper.

pub fn increment_cost_func_count(&mut self, num: u64)

Increment cost function evaluation count by num

pub fn increment_grad_func_count(&mut self, num: u64)

Increment gradient function evaluation count by num

pub fn increment_hessian_func_count(&mut self, num: u64)

Increment Hessian function evaluation count by num

pub fn increment_jacobian_func_count(&mut self, num: u64)

Increment Jacobian function evaluation count by num

pub fn increment_modify_func_count(&mut self, num: u64)

Increment modify function evaluation count by num

pub fn new_best(&mut self)

Indicate that a new best parameter vector was found

pub fn is_best(&self) -> bool

Returns whether the current parameter vector is also the best parameter vector found so far.

pub fn terminated(&self) -> bool

Return whether the algorithm has terminated or not

Trait Implementations

impl<O: Clone + ArgminOp> Clone for IterState<O> where
    O::Param: Clone,
    O::Param: Clone,
    O::Param: Clone,
    O::Param: Clone,
    O::Float: Clone,
    O::Float: Clone,
    O::Float: Clone,
    O::Float: Clone,
    O::Float: Clone,
    O::Param: Clone,
    O::Param: Clone,
    O::Hessian: Clone,
    O::Hessian: Clone,
    O::Hessian: Clone,
    O::Hessian: Clone,
    O::Jacobian: Clone,
    O::Jacobian: Clone,
    O::Param: Clone,
    O::Float: Clone, 

fn clone(&self) -> IterState<O>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<O: Debug + ArgminOp> Debug for IterState<O> where
    O::Param: Debug,
    O::Param: Debug,
    O::Param: Debug,
    O::Param: Debug,
    O::Float: Debug,
    O::Float: Debug,
    O::Float: Debug,
    O::Float: Debug,
    O::Float: Debug,
    O::Param: Debug,
    O::Param: Debug,
    O::Hessian: Debug,
    O::Hessian: Debug,
    O::Hessian: Debug,
    O::Hessian: Debug,
    O::Jacobian: Debug,
    O::Jacobian: Debug,
    O::Param: Debug,
    O::Float: Debug, 

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

Formats the value using the given formatter.

impl<O: ArgminOp> Default for IterState<O> where
    O::Param: Default, 

fn default() -> Self

Returns the “default value” for a type.

impl<'de, O: ArgminOp> Deserialize<'de> for IterState<O> where
    O::Param: Deserialize<'de>,
    O::Param: Deserialize<'de>,
    O::Param: Deserialize<'de>,
    O::Param: Deserialize<'de>,
    O::Float: Deserialize<'de>,
    O::Float: Deserialize<'de>,
    O::Float: Deserialize<'de>,
    O::Float: Deserialize<'de>,
    O::Float: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<O: ArgminOp> KV for IterState<O>

fn serialize(
    &self,
    _record: &Record<'_>,
    serializer: &mut dyn Serializer
) -> Result

Serialize self into Serializer

impl<O: ArgminOp> Serialize for IterState<O> where
    O::Param: Serialize,
    O::Param: Serialize,
    O::Param: Serialize,
    O::Param: Serialize,
    O::Float: Serialize,
    O::Float: Serialize,
    O::Float: Serialize,
    O::Float: Serialize,
    O::Float: Serialize, 

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

Serialize this value into the given Serde serializer.