class Simplex : public NonQuadraticOptima

non-gradient based optimizer

Inheritance:


public members:

int maxiters
maximum number of iterations
double alpha
reflection parameter (recommend value alpha = 1)
double beta
contraction parameter (recommend value beta = .5)
double gamma
expansion parameter (recommended value gamma = 2)
Simplex ( ObjectiveFunction * f, Model <double>* models, int iter , double alpha , double beta, double gamma , int verbose)
constructor
ObjectiveFunction * f
pointer to the objective function
Model <double>* models
a pointer to the $n+1$ initial models, where $n$ is dimension of model space
int iter
maximum number of iterations
double alpha
reflection parameter (recommend value, alpha = 1)
double beta
contraction parameter (recommend value, beta = .5)
double gamma
expansion parameter (recommend value, gamma = 2)
int verbose
vebose or quiet
Simplex ( ObjectiveFunction * f, Model <double>* models, int iter , double alpha , double beta, double gamma )
constructor
Model <double> optimizer (const double atol)
search with Simplex with stopping criterion
Model <double> optimizer ( Vector <double>& atollist)
search with Simplex with stopping criterion
double bestValue ()
int evaluations ()
void reset ( Vector <double>& lambda)

Inherited from NonQuadraticOptima:


Inherited from Optima:

protected members:

int iterMax
double tol
List <double>* residue
ObjectiveFunction * fp
int isVerbose
int isSuccess
List <double> appendResidue(double res)

Documentation

The downhill simplex. Do not confuse this one with the simplex algorithm used in linear programming- is a direct search method that do not require information on the derivatives of the objective function (Nelder, J. and Mead, R., The SIMPLEX method, Computer Journal, 7, 1087 - 1092). The basic idea is to build a polyhedron of dimension n+1, where n is the dimension of the objective function, with trial solutions to the problem assigned to each one of its vertexes. During the optimization process this polyhedron is distorted to "move" in the direction of the best solution.

The fact that n+1 initial guesses have to be provided to the Simplex algorithm almost rules out its application in large optimization problems. Also the Powell's derivative-free conjugate gradient tend to be a more efficient algorithm. The inclusion of the Simplex algorithm in the COOOL library is mainly for completeness purposes.

Model <double> optimizer (const double atol)
$atol$ defines the mimimum size of the polyhedron around the optimum solution. Notice that as the optimization go the polyhedron tends to shrink arounf the minimizer.

Model <double> optimizer ( Vector <double>& atollist)
$atollist$ defines the mimimum sizes of the polyhedron around the optimum solution. Notice that as the optimization go the polyhedron tends to shrink arounf the minimizer.


this class has no child classes.

alphabetic index hierarchy of classes


this page has been generated automatically by doc++

(c)opyright by Malte Zöckler, Roland Wunderling