Struct argmin::solver::neldermead::NelderMead

pub struct NelderMead<P, F> { /* fields omitted */ }

Nelder-Mead method

The Nelder-Mead method a heuristic search method for nonlinear optimization problems which does not require derivatives.

The method is based on simplices which consist of n+1 vertices for an optimization problem with n dimensions. The function to be optimized is evaluated at all vertices. Based on these cost function values the behaviour of the cost function is extrapolated in order to find the next point to be evaluated.

The following actions are possible:

1. Reflection: (Parameter alpha, default 1)
2. Expansion: (Parameter gamma, default 2)
3. Contraction: (Parameter rho, default 0.5)
4. Shrink: (Parameter sigma, default 0.5)

Example

References:

Wikipedia

Implementations

impl<P, F> NelderMead<P, F> where
    P: Clone + ArgminAdd<P, P> + ArgminSub<P, P> + ArgminMul<F, P>,
    F: ArgminFloat, 

pub fn new() -> Self

Constructor

pub fn with_initial_params(self, params: Vec<P>) -> Self

Add initial parameters

pub fn sd_tolerance(self, tol: F) -> Self

Set Sample standard deviation tolerance

pub fn alpha(self, alpha: F) -> Result<Self, Error>

set alpha

pub fn gamma(self, gamma: F) -> Result<Self, Error>

set gamma

pub fn rho(self, rho: F) -> Result<Self, Error>

set rho

pub fn sigma(self, sigma: F) -> Result<Self, Error>

set sigma

Trait Implementations

impl<P: Clone, F: Clone> Clone for NelderMead<P, F>

fn clone(&self) -> NelderMead<P, F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P, F> Default for NelderMead<P, F> where
    P: Clone + ArgminAdd<P, P> + ArgminSub<P, P> + ArgminMul<F, P>,
    F: ArgminFloat, 

fn default() -> NelderMead<P, F>

Returns the “default value” for a type.

impl<'de, P, F> Deserialize<'de> for NelderMead<P, F> where
    P: Deserialize<'de>,
    F: Deserialize<'de>, 

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

Deserialize this value from the given Serde deserializer.

impl<P, F> Serialize for NelderMead<P, F> where
    P: Serialize,
    F: Serialize, 

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

Serialize this value into the given Serde serializer.

impl<O, P, F> Solver<O> for NelderMead<P, F> where
    O: ArgminOp<Output = F, Param = P, Float = F>,
    P: Clone + Serialize + DeserializeOwned + ArgminScaledSub<O::Param, O::Float, O::Param> + ArgminSub<O::Param, O::Param> + ArgminAdd<O::Param, O::Param> + ArgminMul<O::Float, O::Param>,
    F: ArgminFloat + Sum<O::Float>, 

const NAME: &'static str

Name of the solver

fn init(
    &mut self,
    op: &mut OpWrapper<O>,
    _state: &IterState<O>
) -> Result<Option<ArgminIterData<O>>, Error>

Initializes the algorithm

fn next_iter(
    &mut self,
    op: &mut OpWrapper<O>,
    _state: &IterState<O>
) -> Result<ArgminIterData<O>, Error>

Computes one iteration of the algorithm.

fn terminate(&mut self, _state: &IterState<O>) -> TerminationReason

Checks whether the algorithm must be terminated

fn terminate_internal(&mut self, state: &IterState<O>) -> TerminationReason

Checks whether basic termination reasons apply.