SimplexSearch

class SimplexSearch : public DirectSearch

Abstract Base Class for the simplex searches

Inheritance:

Public Fields
static const int def_Length: Default edgelength for the constructors

Public

Constructors and destructor

SimplexSearch(long dim, Vector<double> &startPoint): Constructor
SimplexSearch(const SimplexSearch& Original): Copy constructor
SimplexSearch(long dim, Vector<double> &startPoint, double sig): Constructor which allows shrinking coefficient initialization
SimplexSearch(long dim, Vector<double> &startPoint, double sig, const Vector<double> &lengths): Constructor which allows shrinking coefficient initialization and specification of starting_edgeLengths
SimplexSearch(long dim, Vector<double> &startPoint, double startStep, double stopStep, void (*objective)(long vars, Vector<double> &x, double & func, bool& flag, void* an_obj), void * input_obj): Special constructor using void function and object pointers

Other public methods

virtual SimplexSearch& operator= (const SimplexSearch& A): Overloaded assignment operator
virtual void BeginSearch(): This method begins the actual searching in the concrete classes
virtual void ChooseRegularSimplex(): Allows the user to choose a regular simplex for the search
virtual void ChooseRightSimplex(): Virtual void function, unimplemented in this absstract base class
virtual void ReadInFile(istream& fp): Pure virtual in this abstract base class
virtual void PrintDesign() const: Prints out the simplex points by row, their corresponding f(x) values, and the number of function calls thus far

Accessor and mutator methods

long GetReplacementIndex() const: Returns replacementIndex
void SetStartingEdgeLengths(const Vector<double> & lengths): Sets starting_edgeLengths to equal lengths
void GetStartingEdgeLengths(Vector<double> & lengths): Assigns the input Vector lengths the values of the member field starting_edgeLengths
void SetSigma(double newSigma): Allows the user to set a new value for the shrinking coefficient
double GetSigma(): Returns the value of sigma
void GetCurrentSimplexValues(double* &simValues) const: performs a deep copy of the simplexValues array to a double pointer points to a newly allocated chunk of memory upon return USER SHOULD PASS JUST A NULL POINTER, WITHOUT PREALLOCATED MEMORY
int GetTolHit() const: Returns toleranceHit, which indicates whether the simplex size has refined down to the value of stoppingStepLength
long GetMinIndex() const: Returns minIndex
void GetCentroid(Vector<double>* &troid): Upon return the input Vector* troid will point to a newly allocated Vector of doubles representing the centroid of the simplex
double GetDelta(): Returns delta, the length of the longest simplex edge
bool Is_Stop_on_std() const: Returns value of the Stop_on_std field
void Set_Stop_on_std(): Allows user to specify that the standard Nelder-Mead stopping criterion will be used
void Set_Stop_on_delta(): Allows users to specify that the search will terminated based on delta

protected methods

virtual void ExploratoryMoves(): Pure virtual in this abstract base class
virtual void CalculateFunctionValue(long index): Finds the f(x) value for the simplex point indexed at index and replaces the proper value in simplexValues
virtual bool Stop(): returns true if the stopping criteria have been satisfied
virtual void CopySearch(const SimplexSearch & Original): Used to implement the overloaded assignment operator
virtual void Initialize_Right(Matrix<double> *plex): Inititializes a right simplex
virtual void Initialize_Regular(Matrix<double> *plex): Inititializes a regular simplex, following an algorithm given by Jacoby, Kowalik, and Pizzo in "Iterative Methods for Nonlinear Optimization Problems," Prentice-Hall (1972)
virtual void InitGeneralSimplex(const Matrix<double> *plex): Deletes any existing design matrix and replaces it with one pointed to by plex
virtual void SetReplacementIndex(long newIndex): Sets replacementIndex to the value of newIndex
virtual void FindCentroid(): Finds the centroid and assigns the value to the member field centroid
virtual void ShrinkSimplex(): Goes through the simplex and reduces the lengths of the edges adjacent to the best vertex
virtual void ReplaceSimplexPoint(long index, const Vector<double>& newPoint): Replaces simplex point indexed at index with parameter newPoint

Protected fields

double* simplexValues: f(x) values of the points corresponding to the rows of the design matrix
Vector <double> * starting_edgeLengths: The edgelengths of the simplex that will be represented by the design matrix
double sigma: The shrinking coefficient
long minIndex: Index of point generating min f(x)
long replacementIndex: Index of point to be replaced
Vector <double> * centroid: The current centroid
int toleranceHit: Flag to indicate the reason for stopping the search
bool SimplexSpecified: Flag to indicate whether a specific simplex type has been chosen
bool Stop_on_std: Flag to indicate that the user has chosen (where available) to use the standard-deviation (i
double delta: Named to recall the "delta" of the pattern searches, this is generally the length of (at the start) the longest edge of the simplex; it is used for the stopping test where Stop_on_std is false (as it is by default)
Vector <double> * scratch: The two scratch vectors are simply extra storage space to be used by methods that require a vector of size = dimensions

Inherited from DirectSearch:

Public Fields
static const long NO_MAX

Public
Other initialization methods

virtual void ReadInFile(istream & fp)
Reads the design in from a file supplied by the user
virtual void CleanSlate(long dim, Vector<double> & startPoint)
Reinitializes values in order to reuse the same search object
virtual void CleanSlate(long dim, Vector<double> &startPoint, double stopStep, void (*objective)(long vars, Vector<double> &x, double &func, bool &flag, void* an_obj), void * input_obj)
overloaded version of CleanSlate using void function and object pointers
void InitializeDesign(const Matrix<double> *designPtr)
Deletes any existing pattern and replaces it with the one pointed to by designPtr
virtual void PrintDesign() const
Prints out search information
Search method

virtual void BeginSearch()
BeginSearch() is an unimplemented virtual void method in the abstract base classes
Accessors and Mutators

long GetFunctionCalls() const
Returns number of objective function evaluations so far
void SetFunctionCalls(long newCalls)
Sets number of function calls already used--useful for times when you are using multiple searches for the same optimization; for example, if you wanted to do 100 function calls worth of SMDSearch followed by 100 calls (max) of HJSearch
int GetID() const
Returns the ID Number of the search
void GetMinPoint(Vector<double> & minimum) const
Retrieves the minimum point and assigns it to minimum The vector minimum should be of the correct dimension
void SetMinPoint(Vector<double> & minimum) const
Resets minPoint to the point represented by the input parameter minimum
void GetMinVal(double & value) const
Retrieves the best objective function value found thus far
void SetMinVal(double & value)
Resets the minimum value to the value of the input parameter
long GetDimension() const
Returns the dimension of the problem
long GetMaxCalls() const
Returns the number of function calls in the budget; if the value is equal to NO_MAX, will terminate based only on refinement of the design
void SetMaxCalls(long calls)
Use to set a function call budget; by default set to the value of NO_MAX, which indicates no budget, in which case the search will terminate based only upon grid refinement
void SetMaxCallsExact(long calls)
Sets maxCalls to the value of calls, and sets exact_count to true, so search will terminate precisely when the call budget runs out
Matrix <double> * GetDesign()
Returns a pointer to a matrix initialized from the design matrix
void CopyDesign(Matrix<double>* &designPtr) const
Deep copy of the pattern to a Matrix pointer
double GetStoppingStepLength() const
Returns stoppingStepLength, the smallest step length allowed in the search
void SetStoppingStepLength(double len)
Sets stoppingStepLength, the smallest step length allowed in the search, to the value of the input parameter
virtual void SetExact()
Allows the user to specify that the search will terminate precicely upon completion of maxCalls number of function calls
virtual void SetInexact()
Allows the user to specify that the search will terminate upon completion of roughly maxCalls number of function calls, but only after a pattern decrease or "shrink" step
virtual bool IsExact()
Returns the value of exact_count(q

Protected Fields
Matrix <double> * design
long dimension
Vector <double> * minPoint
double minValue
long functionCalls
long maxCalls
double stoppingStepLength
void* some_object
bool exact_count
int IDnumber

Protected Methods
virtual void ExploratoryMoves()
virtual bool Stop()
void fcnCall(long n, Vector<double> &x, double & f, bool& flag, void * nothing)
virtual void CopySearch(const DirectSearch & Original)
bool BreakOnExact()
void (*fcn_name)(long dim, Vector<double> &x, double & function, bool & success, void* an_object)