Class container for the Nelder-Mead's method. More...

#include <NelderMead.hh>

Inherits Optimist::Optimizer::Optimizer< Vector, NelderMead< Vector > >.

Public Types
using	VectorTrait = TypeTrait<Vector>
using	Scalar = typename Vector::Scalar
using	Costs
using	MatrixX
using	Simplex
using	MatrixD
using	Factorization
using	Move
using	Method
Public Types inherited from Optimist::Optimizer::Optimizer< Vector, NelderMead< Vector > >
using	Scalar
using	Input
using	Output
Public Types inherited from Optimist::SolverBase< Vector, TypeTrait< Vector >::Scalar, NelderMead< Vector > >
using	InputTrait
using	OutputTrait
using	Scalar
using	FirstDerivative
using	SecondDerivative

Public Member Functions
	NelderMead ()
	NelderMead (const Scalar delta)
constexpr std::string	name_impl () const
Method	method () const
void	method (const Method t_method)
Scalar	delta () const
void	delta (const Scalar t_delta)
Scalar	rho () const
void	rho (const Scalar t_rho)
Scalar	chi () const
void	chi (const Scalar t_chi)
Scalar	gamma () const
void	gamma (const Scalar t_gamma)
Scalar	sigma () const
void	sigma (const Scalar t_sigma)
Scalar	volume_tolerance () const
void	volume_tolerance (const Scalar t_volume_tolerance)
template<typename FunctionLambda>
bool	solve_impl (FunctionLambda &&function, const Vector &x_ini, Vector &x_sol)
Public Member Functions inherited from Optimist::Optimizer::Optimizer< Vector, NelderMead< Vector > >
	Optimizer ()
constexpr std::string	name () const
Integer	gradient_evaluations () const
Integer	max_gradient_evaluations () const
Integer	hessian_evaluations () const
Integer	max_hessian_evaluations () const
Public Member Functions inherited from Optimist::SolverBase< Vector, TypeTrait< Vector >::Scalar, NelderMead< Vector > >
	SolverBase ()
void	reset_bounds (const Integer n=InputTrait::IsDynamic ? 0 :InputTrait::Dimension)
const Vector &	lower_bound () const
const Vector &	upper_bound () const
void	bounds (const Vector &t_lower_bound, const Vector &t_upper_bound)
constexpr Integer	input_dimension () const
constexpr Integer	output_dimension () const
Integer	function_evaluations () const
void	max_function_evaluations (const Integer t_max_function_evaluations)
Integer	iterations () const
Integer	max_iterations () const
Scalar	alpha () const
Integer	relaxations () const
Integer	max_relaxations () const
Scalar	tolerance () const
void	verbose_mode (bool t_verbose)
void	enable_verbose_mode ()
void	disable_verbose_mode ()
void	damped_mode (bool t_damped)
void	enable_damped_mode ()
void	disable_damped_mode ()
std::string	task () const
bool	converged () const
std::ostream &	ostream () const
bool	solve (FunctionLambda &&function, const Vector &x_ini, Vector &x_sol)
bool	rootfind (const FunctionBase< FunctionInput, FunctionOutput, DerivedFunction > &function, const Vector &x_ini, Vector &x_sol)
bool	optimize (const FunctionBase< FunctionInput, FunctionOutput, DerivedFunction > &function, const Vector &x_ini, Vector &x_sol)
constexpr std::string	name () const

Static Public Attributes
static constexpr bool	RequiresFunction {true}
static constexpr bool	RequiresFirstDerivative {false}
static constexpr bool	RequiresSecondDerivative {false}
Static Public Attributes inherited from Optimist::Optimizer::Optimizer< Vector, NelderMead< Vector > >
static constexpr bool	IsRootFinder
static constexpr bool	IsOptimizer

Private Member Functions
void	replace_point (const Scalar f, const Vector &p, const Integer j)
template<typename FunctionLambda>
void	spendley (FunctionLambda &&function, const Vector x, const Scalar delta)
template<typename FunctionLambda>
void	diamond (FunctionLambda &&function, const Vector x, const Scalar delta)
void	simplex_volume (Integer k)
void	dist_init ()
void	dist_update (Integer j)
template<typename FunctionLambda>
void	shrink (FunctionLambda &&function)
template<typename FunctionLambda>
Scalar	extrapolate (FunctionLambda &&function, const Scalar alpha, const Integer j, Vector &p)
template<typename FunctionLambda>
Scalar	reflect (FunctionLambda &&function, Vector &p)
template<typename FunctionLambda>
Scalar	expand (FunctionLambda &&function, Vector &p)
template<typename FunctionLambda>
Scalar	outside (FunctionLambda &&function, Vector &p)
template<typename FunctionLambda>
Scalar	inside (FunctionLambda &&function, Vector &p)

Private Attributes
Method	m_method {Method::STANDARD}
Scalar	m_delta {1.0}
Scalar	m_rho {1.0}
Scalar	m_chi {2.0}
Scalar	m_gamma {0.5}
Scalar	m_sigma {0.25}
Scalar	m_volume_tolerance
Integer	m_dim {0}
Scalar	m_dim_factorial {0}
Scalar	m_regular_simplex_volume {0}
Integer	m_low {0}
Integer	m_mid {0}
Integer	m_high {0}
Costs	m_f
Simplex	m_p
MatrixD	m_dist
Vector	m_f_work
Simplex	m_p_work
Vector	m_p_sum
Vector	m_p_r
Vector	m_p_e
Vector	m_p_c
Scalar	m_diameter {0}
Scalar	m_simplex_volume {0}

Additional Inherited Members
Protected Member Functions inherited from Optimist::Optimizer::Optimizer< Vector, NelderMead< Vector > >
bool	evaluate_gradient (GradientLambda &&gradient, const Input &x, FirstDerivative &out)
bool	evaluate_hessian (HessianLambda &&hessian, const Input &x, SecondDerivative &out)
bool	solve (FunctionLambda &&function, const Input &x_ini, Output &x_sol)
Protected Member Functions inherited from Optimist::SolverBase< Vector, TypeTrait< Vector >::Scalar, NelderMead< Vector > >
Integer	first_derivative_evaluations () const
Integer	max_first_derivative_evaluations () const
Integer	second_derivative_evaluations () const
Integer	max_second_derivative_evaluations () const
void	reset_counters ()
bool	evaluate_function (FunctionLambda &&function, const Vector &x, TypeTrait< Vector >::Scalar &out)
bool	evaluate_first_derivative (FirstDerivativeLambda &&function, const Vector &x, FirstDerivative &out)
bool	evaluate_second_derivative (SecondDerivativeLambda &&function, const Vector &x, SecondDerivative &out)
bool	damp (FunctionLambda &&function, const Vector &x_old, const Vector &function_old, const Vector &step_old, Vector &x_new, Vector &function_new, Vector &step_new)
void	header ()
void	bottom ()
void	info (Scalar residuals, const std::string &notes="-")
Protected Attributes inherited from Optimist::SolverBase< Vector, TypeTrait< Vector >::Scalar, NelderMead< Vector > >
Vector	m_lower_bound
Vector	m_upper_bound
Integer	m_function_evaluations
Integer	m_first_derivative_evaluations
Integer	m_second_derivative_evaluations
Integer	m_max_function_evaluations
Integer	m_max_first_derivative_evaluations
Integer	m_max_second_derivative_evaluations
Integer	m_iterations
Integer	m_max_iterations
Scalar	m_alpha
Integer	m_relaxations
Integer	m_max_relaxations
Scalar	m_tolerance
bool	m_verbose
bool	m_damped
std::ostream *	m_ostream
std::string	m_task
bool	m_converged

Detailed Description

template<typename Vector>
requires TypeTrait<Vector>::IsEigen && (!TypeTrait<Vector>::IsFixed || TypeTrait<Vector>::Dimension > 0)
class Optimist::Optimizer::NelderMead< Vector >

Template Parameters

Vector Eigen vector type.

Member Typedef Documentation

◆ Costs

template<typename Vector>

using Optimist::Optimizer::NelderMead< Vector >::Costs

Initial value:

std::conditional_t<
         VectorTrait::IsFixed,
         Eigen::Vector<Scalar, VectorTrait::Dimension + 1>,
         std::conditional_t<VectorTrait::IsDynamic,
                            Eigen::Vector<Scalar, Eigen::Dynamic>,
                            Eigen::SparseVector<Scalar>>>

◆ Factorization

template<typename Vector>

using Optimist::Optimizer::NelderMead< Vector >::Factorization

Initial value:

std::conditional_t<VectorTrait::IsSparse,
                                              Eigen::SparseLU<Simplex>,
                                              Eigen::FullPivLU<Simplex>>

◆ MatrixD

template<typename Vector>

using Optimist::Optimizer::NelderMead< Vector >::MatrixD

Initial value:

std::conditional_t<
         VectorTrait::IsFixed,
         Eigen::Matrix<Scalar,
                       VectorTrait::Dimension + 1,
                       VectorTrait::Dimension + 1>,
         std::conditional_t<
             VectorTrait::IsDynamic,
             Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic>,
             Eigen::SparseMatrix<Scalar>>>

◆ MatrixX

template<typename Vector>

using Optimist::Optimizer::NelderMead< Vector >::MatrixX

Initial value:

std::conditional_t<
         VectorTrait::IsFixed,
         Eigen::Matrix<Scalar, VectorTrait::Dimension, VectorTrait::Dimension>,
         std::conditional_t<
             VectorTrait::IsDynamic,
             Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic>,
             Eigen::SparseMatrix<Scalar>>>

◆ Method

template<typename Vector>

using Optimist::Optimizer::NelderMead< Vector >::Method

Initial value:

enum class Method : Integer {
       STANDARD = 0,
       SPENDLEY = 1
     }

NelderMead solver type enumeration.

◆ Move

template<typename Vector>

using Optimist::Optimizer::NelderMead< Vector >::Move

Initial value:

enum class Move : Integer {
       INITIALIZE = 0,
       REFLECT    = 1,
       EXPAND_E   = 2,
       EXPAND_R   = 3,
       CONTRACT_O = 4,
       CONTRACT_I = 5,
       SHRINK     = 6,
       RESTART    = 7
     }

NelderMead move type enumeration.

◆ Scalar

template<typename Vector>

using Optimist::Optimizer::NelderMead< Vector >::Scalar = typename Vector::Scalar

◆ Simplex

template<typename Vector>

using Optimist::Optimizer::NelderMead< Vector >::Simplex

Initial value:

std::conditional_t<
         VectorTrait::IsFixed,
         Eigen::Matrix<Scalar,
                       VectorTrait::Dimension,
                       VectorTrait::Dimension + 1>,
         std::conditional_t<
             VectorTrait::IsDynamic,
             Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic>,
             Eigen::SparseMatrix<Scalar>>>

◆ VectorTrait

template<typename Vector>

using Optimist::Optimizer::NelderMead< Vector >::VectorTrait = TypeTrait<Vector>

Constructor & Destructor Documentation

◆ NelderMead() [1/2]

template<typename Vector>

Optimist::Optimizer::NelderMead< Vector >::NelderMead ( )

inline

Class constructor for the NelderMead solver.

◆ NelderMead() [2/2]

template<typename Vector>

Optimist::Optimizer::NelderMead< Vector >::NelderMead ( const Scalar delta )

inline

Class constructor for the NelderMead solver.

Parameters

[in] delta Initial simplex size.

Member Function Documentation

◆ chi() [1/2]

template<typename Vector>

Scalar Optimist::Optimizer::NelderMead< Vector >::chi ( ) const

inline

Get the expansion coefficient.

Returns: The expansion coefficient.

◆ chi() [2/2]

template<typename Vector>

void Optimist::Optimizer::NelderMead< Vector >::chi ( const Scalar t_chi )

inline

Set the expansion coefficient.

Parameters

[in] t_chi The expansion coefficient.

◆ delta() [1/2]

template<typename Vector>

Scalar Optimist::Optimizer::NelderMead< Vector >::delta ( ) const

inline

Get the initial simplex size.

Returns: The initial simplex size.

◆ delta() [2/2]

template<typename Vector>

void Optimist::Optimizer::NelderMead< Vector >::delta ( const Scalar t_delta )

inline

Set the initial simplex size.

Parameters

[in] t_delta The initial simplex size.

◆ diamond()

template<typename Vector>

template<typename FunctionLambda>

void Optimist::Optimizer::NelderMead< Vector >::diamond	(	FunctionLambda &&	function,
		const Vector	x,
		const Scalar	delta )

inlineprivate

Initialize simplex with Diamond method.

Template Parameters

FunctionLambda Function lambda type.

Parameters

[in]	function	Function lambda.
[in]	x	Initial point.
[in]	delta	Initial simplex size.

◆ dist_init()

template<typename Vector>

void Optimist::Optimizer::NelderMead< Vector >::dist_init ( )

inlineprivate

Initialize distance matrix.

◆ dist_update()

template<typename Vector>

void Optimist::Optimizer::NelderMead< Vector >::dist_update ( Integer j )

inlineprivate

Update distance matrix.

Parameters

[in] j Index of the updated point.

◆ expand()

template<typename Vector>

template<typename FunctionLambda>

Scalar Optimist::Optimizer::NelderMead< Vector >::expand	(	FunctionLambda &&	function,
		Vector &	p )

inlineprivate

Expand simplex point.

Template Parameters

FunctionLambda Function lambda type.

Parameters

[in]	function	Function lambda.
[out]	p	Expanded simplex point.

Returns: Function value at the expanded point.

◆ extrapolate()

template<typename Vector>

template<typename FunctionLambda>

Scalar Optimist::Optimizer::NelderMead< Vector >::extrapolate	(	FunctionLambda &&	function,
		const Scalar	alpha,
		const Integer	j,
		Vector &	p )

inlineprivate

Extrapolate simplex point by a factor alpha through the face of the simplex.

Template Parameters

FunctionLambda Function lambda type.

Parameters

[in]	function	Function lambda.
[in]	alpha	Extrapolation factor.
[in]	j	Index of the point to be extrapolated.
[out]	p	Extrapolated simplex point.

Returns: Function value at the extrapolated point.

◆ gamma() [1/2]

template<typename Vector>

Scalar Optimist::Optimizer::NelderMead< Vector >::gamma ( ) const

inline

Get the contraction coefficient.

Returns: The contraction coefficient.

◆ gamma() [2/2]

template<typename Vector>

void Optimist::Optimizer::NelderMead< Vector >::gamma ( const Scalar t_gamma )

inline

Set the contraction coefficient.

Parameters

[in] t_gamma The contraction coefficient.

◆ inside()

template<typename Vector>

template<typename FunctionLambda>

Scalar Optimist::Optimizer::NelderMead< Vector >::inside	(	FunctionLambda &&	function,
		Vector &	p )

inlineprivate

Inside contraction simplex point.

Template Parameters

FunctionLambda Function lambda type.

Parameters

[in]	function	Function lambda.
[out]	p	Inside contracted simplex point.

Returns: Function value at the inside contracted point.

◆ method() [1/2]

template<typename Vector>

Method Optimist::Optimizer::NelderMead< Vector >::method ( ) const

inline

Get the enumeration type of the NelderMead solver method.

Returns: The NelderMead solver enumeration type.

◆ method() [2/2]

template<typename Vector>

void Optimist::Optimizer::NelderMead< Vector >::method ( const Method t_method )

inline

Set the enumeration type of the NelderMead solver method.

Parameters

[in] t_method The NelderMead solver enumeration type.

◆ name_impl()

template<typename Vector>

std::string Optimist::Optimizer::NelderMead< Vector >::name_impl ( ) const

inlineconstexpr

Get the NelderMead solver name.

Returns: The NelderMead solver name.

◆ outside()

template<typename Vector>

template<typename FunctionLambda>

Scalar Optimist::Optimizer::NelderMead< Vector >::outside	(	FunctionLambda &&	function,
		Vector &	p )

inlineprivate

Outside contraction simplex point.

Template Parameters

FunctionLambda Function lambda type.

Parameters

[in]	function	Function lambda.
[out]	p	Outside contracted simplex point.

Returns: Function value at the outside contracted point.

◆ reflect()

template<typename Vector>

template<typename FunctionLambda>

Scalar Optimist::Optimizer::NelderMead< Vector >::reflect	(	FunctionLambda &&	function,
		Vector &	p )

inlineprivate

Reflect simplex point.

Template Parameters

FunctionLambda Function lambda type.

Parameters

[in]	function	Function lambda.
[out]	p	Reflected simplex point.

Returns: Function value at the reflected point.

◆ replace_point()

template<typename Vector>

void Optimist::Optimizer::NelderMead< Vector >::replace_point	(	const Scalar	f,
		const Vector &	p,
		const Integer	j )

inlineprivate

Replace simplex point.

Parameters

[in]	f	Function value at the new point.
[in]	p	New simplex point.
[in]	j	Index of the point to be replaced.

◆ rho() [1/2]

template<typename Vector>

Scalar Optimist::Optimizer::NelderMead< Vector >::rho ( ) const

inline

Get the reflection coefficient.

Returns: The reflection coefficient.

◆ rho() [2/2]

template<typename Vector>

void Optimist::Optimizer::NelderMead< Vector >::rho ( const Scalar t_rho )

inline

Set the reflection coefficient.

Parameters

[in] t_rho The reflection coefficient.

◆ shrink()

template<typename Vector>

template<typename FunctionLambda>

void Optimist::Optimizer::NelderMead< Vector >::shrink ( FunctionLambda && function )

inlineprivate

Shrink the simplex towards the lowest (best) point.

Template Parameters

FunctionLambda Function lambda type.

Parameters

[in] function Function lambda.

◆ sigma() [1/2]

template<typename Vector>

Scalar Optimist::Optimizer::NelderMead< Vector >::sigma ( ) const

inline

Get the shrink coefficient.

Returns: The shrink coefficient.

◆ sigma() [2/2]

template<typename Vector>

void Optimist::Optimizer::NelderMead< Vector >::sigma ( const Scalar t_sigma )

inline

Set the shrink coefficient.

Parameters

[in] t_sigma The shrink coefficient.

◆ simplex_volume()

template<typename Vector>

void Optimist::Optimizer::NelderMead< Vector >::simplex_volume ( Integer k )

inlineprivate

Compute simplex volume.

Parameters

[in] k Index of the point to be used as reference.

◆ solve_impl()

template<typename Vector>

template<typename FunctionLambda>

bool Optimist::Optimizer::NelderMead< Vector >::solve_impl	(	FunctionLambda &&	function,
		const Vector &	x_ini,
		Vector &	x_sol )

inline

Solve the nonlinear system of equations \( \mathbf{f}(\mathbf{x}) = 0 \), with \(\mathbf{f}: \mathbb{R}^n \rightarrow \mathbb{R}^n \).

Template Parameters

FunctionLambda Function lambda type.

Parameters

[in]	function	Function lambda.
[in]	jacobian	Jacobian lambda.
[in]	x_ini	Initialization point.
[out]	x_sol	Solution point.

Returns: The convergence boolean flag.

◆ spendley()

template<typename Vector>

template<typename FunctionLambda>

void Optimist::Optimizer::NelderMead< Vector >::spendley	(	FunctionLambda &&	function,
		const Vector	x,
		const Scalar	delta )

inlineprivate

Initialize simplex with Spendley method.

Template Parameters

FunctionLambda Function lambda type.

Parameters

[in]	function	Function lambda.
[in]	x	Initial point.
[in]	delta	Initial simplex size.

◆ volume_tolerance() [1/2]

template<typename Vector>

Scalar Optimist::Optimizer::NelderMead< Vector >::volume_tolerance ( ) const

inline

Get the simplex volume tolerance.

Returns: The simplex volume tolerance.

◆ volume_tolerance() [2/2]

template<typename Vector>

void Optimist::Optimizer::NelderMead< Vector >::volume_tolerance ( const Scalar t_volume_tolerance )

inline

Set the simplex volume tolerance.

Parameters

[in] t_volume_tolerance The simplex volume tolerance.

Member Data Documentation

◆ m_chi

template<typename Vector>

Scalar Optimist::Optimizer::NelderMead< Vector >::m_chi {2.0}

private

Expansion coefficient.

◆ m_delta

template<typename Vector>

Scalar Optimist::Optimizer::NelderMead< Vector >::m_delta {1.0}

private

Initial simplex size.

◆ m_diameter

template<typename Vector>

Scalar Optimist::Optimizer::NelderMead< Vector >::m_diameter {0}

private

Simplex diameter.

◆ m_dim

template<typename Vector>

Integer Optimist::Optimizer::NelderMead< Vector >::m_dim {0}

private

Problem dimension.

◆ m_dim_factorial

template<typename Vector>

Scalar Optimist::Optimizer::NelderMead< Vector >::m_dim_factorial {0}

private

Factorial of the problem dimension.

◆ m_dist

template<typename Vector>

MatrixD Optimist::Optimizer::NelderMead< Vector >::m_dist

private

Distance matrix between simplex points.

◆ m_f

template<typename Vector>

Costs Optimist::Optimizer::NelderMead< Vector >::m_f

private

Function values at simplex points.

◆ m_f_work

template<typename Vector>

Vector Optimist::Optimizer::NelderMead< Vector >::m_f_work

private

Work function values.

◆ m_gamma

template<typename Vector>

Scalar Optimist::Optimizer::NelderMead< Vector >::m_gamma {0.5}

private

Contraction coefficient.

◆ m_high

template<typename Vector>

Integer Optimist::Optimizer::NelderMead< Vector >::m_high {0}

private

Index of the highest (worst) point.

◆ m_low

template<typename Vector>

Integer Optimist::Optimizer::NelderMead< Vector >::m_low {0}

private

Index of the lowest (best) point.

◆ m_method

template<typename Vector>

Method Optimist::Optimizer::NelderMead< Vector >::m_method {Method::STANDARD}

private

NelderMead solver method.

◆ m_mid

template<typename Vector>

Integer Optimist::Optimizer::NelderMead< Vector >::m_mid {0}

private

Index of the middle point.

◆ m_p

template<typename Vector>

Simplex Optimist::Optimizer::NelderMead< Vector >::m_p

private

Simplex points.

◆ m_p_c

template<typename Vector>

Vector Optimist::Optimizer::NelderMead< Vector >::m_p_c

private

Contraction point.

◆ m_p_e

template<typename Vector>

Vector Optimist::Optimizer::NelderMead< Vector >::m_p_e

private

Expansion point.

◆ m_p_r

template<typename Vector>

Vector Optimist::Optimizer::NelderMead< Vector >::m_p_r

private

Reflection point.

◆ m_p_sum

template<typename Vector>

Vector Optimist::Optimizer::NelderMead< Vector >::m_p_sum

private

Sum of simplex points.

◆ m_p_work

template<typename Vector>

Simplex Optimist::Optimizer::NelderMead< Vector >::m_p_work

private

Work simplex points.

◆ m_regular_simplex_volume

template<typename Vector>

Scalar Optimist::Optimizer::NelderMead< Vector >::m_regular_simplex_volume {0}

private

Volume of a regular simplex.

◆ m_rho

template<typename Vector>

Scalar Optimist::Optimizer::NelderMead< Vector >::m_rho {1.0}

private

Reflection coefficient.

◆ m_sigma

template<typename Vector>

Scalar Optimist::Optimizer::NelderMead< Vector >::m_sigma {0.25}

private

Shrink coefficient.

◆ m_simplex_volume

template<typename Vector>

Scalar Optimist::Optimizer::NelderMead< Vector >::m_simplex_volume {0}

private

Simplex volume.

◆ m_volume_tolerance

template<typename Vector>

Scalar Optimist::Optimizer::NelderMead< Vector >::m_volume_tolerance

private

Initial value:

{

std::sqrt(this->m_tolerance)}

Optimist::SolverBase< Vector, TypeTrait< Vector >::Scalar, NelderMead< Vector > >::m_tolerance

Scalar m_tolerance

Definition SolverBase.hh:128

Simplex volume tolerance.

◆ RequiresFirstDerivative

template<typename Vector>

bool Optimist::Optimizer::NelderMead< Vector >::RequiresFirstDerivative {false}

staticconstexpr

◆ RequiresFunction

template<typename Vector>

bool Optimist::Optimizer::NelderMead< Vector >::RequiresFunction {true}

staticconstexpr

◆ RequiresSecondDerivative

template<typename Vector>

bool Optimist::Optimizer::NelderMead< Vector >::RequiresSecondDerivative {false}

staticconstexpr

The documentation for this class was generated from the following file:

core/include/Optimist/Optimizer/NelderMead.hh

Public Types

Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Costs

◆ Factorization

◆ MatrixD

◆ MatrixX

◆ Method

◆ Move

◆ Scalar

◆ Simplex

◆ VectorTrait

Constructor & Destructor Documentation

◆ NelderMead() [1/2]

◆ NelderMead() [2/2]

Member Function Documentation

◆ chi() [1/2]

◆ chi() [2/2]

◆ delta() [1/2]

◆ delta() [2/2]

◆ diamond()

◆ dist_init()

◆ dist_update()

◆ expand()

◆ extrapolate()

◆ gamma() [1/2]

◆ gamma() [2/2]

◆ inside()

◆ method() [1/2]

◆ method() [2/2]

◆ name_impl()

◆ outside()

◆ reflect()

◆ replace_point()

◆ rho() [1/2]

◆ rho() [2/2]

◆ shrink()

◆ sigma() [1/2]

◆ sigma() [2/2]

◆ simplex_volume()

◆ solve_impl()

◆ spendley()

◆ volume_tolerance() [1/2]

◆ volume_tolerance() [2/2]

Member Data Documentation

◆ m_chi

◆ m_delta

◆ m_diameter

◆ m_dim

◆ m_dim_factorial

◆ m_dist

◆ m_f

◆ m_f_work

◆ m_gamma

◆ m_high

◆ m_low

◆ m_method

◆ m_mid

◆ m_p

◆ m_p_c

◆ m_p_e

◆ m_p_r

◆ m_p_sum

◆ m_p_work

◆ m_regular_simplex_volume

◆ m_rho

◆ m_sigma

◆ m_simplex_volume

◆ m_volume_tolerance

◆ RequiresFirstDerivative

◆ RequiresFunction

◆ RequiresSecondDerivative