Hybrid_NMSearch

class Hybrid_NMSearch : public NMSearch

Hybrid_NMSearch class

Inheritance:

Public

constructors and destructors

Hybrid_NMSearch(long dim, Vector<double> &startPoint ): Constructor
Hybrid_NMSearch(long dim, Vector<double> &startPoint, double sig, Vector<double> &lengths): Constructor which allows shrinking coefficient initialization and specification of starting_edgeLengths (for the NMSearch portion of the search)
Hybrid_NMSearch(long dim, Vector<double> &startPoint, double NewSigma, double NewAlpha, double NewBeta, double NewGamma): Constructor which allows initialization of all four coefficients used in the NMSearch portion of the search
Hybrid_NMSearch(long dim, Vector<double> &startPoint, double NewSigma, double NewAlpha, double NewBeta, double NewGamma, double startStep, double stopStep, double EdHJStop, void (*objective)(long vars, Vector<double> &x, double & func, bool& flag, void* an_obj), void * input_obj): Adds one more parameter to the long NMSearch constructor, for the EdHJSearch stopping step length
~Hybrid_NMSearch(): Destructor

other public methods

void BeginSearch(): This method starts the actual searching
long GetFunctionCalls() const: This is overloaded to return TotalCalls
long GetNSearchCalls(): Returns the value of NSearchCalls
long GetESearchCalls(): Returns the value of ESearchCalls
long GetTotalCalls(): Returns the value of TotalCalls

Protected Fields
double ESearchStoplength: stoppingStepLength for the EdHJSearch phase
long NSearchCalls: the number of calls made during the NMSearch phase
long ESearchCalls: the number of calls made during the EdHJSearch phase
long TotalCalls: the total number of calls made

Inherited from NMSearch:

Protected Fields
double alpha
double beta
double gamma
long maxIndex
Vector <double> * reflectionPt
double reflectionPtValue
Vector <double> * expansionPt
double expansionPtValue
Vector <double> * contractionPt
double contractionPtValue
double maxPrimePtValue
long maxPrimePtId
double NMdelta

Protected Methods
void ExploratoryMoves()
void InitRegSimplex()
void InitRightSimplex()
void InitGeneralSimplex(const Matrix<double> *plex)
bool Stop()
void CalculateNMDelta()
void CopySearch(const NMSearch & Original)
void FindMinMaxIndices()
long SecondHighestPtIndex()
void FindCentroid()
void FindReflectionPt()
void FindExpansionPt()
void FindContractionPt()

Inherited from SimplexSearch:

Public Fields
static const int def_Length

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
void fcnCall(long n, Vector<double> &x, double & f, bool& flag, void * nothing)
bool BreakOnExact()
void (*fcn_name)(long dim, Vector<double> &x, double & function, bool & success, void* an_object)

Documentation

Hybrid_NMSearch class. Comprises a Nelder-Mead search (NMSearch) up to the point where the standard deviation test is satisfied. Then it switches over to an EdHJSearch. This avoids the expense of finding NMdelta (See discussion in design document and user's manual.)

constructors and destructors

Hybrid_NMSearch(long dim, Vector<double> &startPoint )
Constructor. This constructor has two parameters. Other data members will be set to default values, as follows. This is of course in addition to assignments and initializations made in DirectSearch, SimplexSearch, and NMSearch classes.

ESearchStoplength = 10e-8;
NSearchCalls = 0;
ESearchCalls = 0;
TotalCalls = 0;
Stop_on_std = true;
IDnumber = 3210

Parameters:
dim - the dimension of the problem
startpoint - the start point for the search. This will be initialized as the minPoint.

Hybrid_NMSearch(long dim, Vector<double> &startPoint, double sig, Vector<double> &lengths)
Constructor which allows shrinking coefficient initialization and specification of starting_edgeLengths (for the NMSearch portion of the search). These arguments are sent to the NMSearch constructor. Other fields will be assigned as in HybridNMSearch(long dim, Vector<double> &startPoint).

Parameters:
dim - the dimension of the problem.
startpoint - the start point for the search. This will be initialized as the minPoint.
sig - the user-defined value for sigma, the shrinking coefficient.
lengths - reference to a Vector of doubles representing the desired edgelengths of the simplex.

Hybrid_NMSearch(long dim, Vector<double> &startPoint, double NewSigma, double NewAlpha, double NewBeta, double NewGamma)
Constructor which allows initialization of all four coefficients used in the NMSearch portion of the search. Again, most of the work is done by the NMSearch constructor. Other fields will be assigned as in Hybrid_NMSearch(long dim, Vector<double> &startPoint).

Parameters:
dim - the dimension of the problem.
startpoint - the start point for the search. This will be initialized as the minPoint.
NewSigma - the user-defined value for sigma, the shrinking coefficient.
NewAlpha - the user-defined value for alpha, the reflection coefficient.
NewBeta - the user-defined value for beta, the contraction coefficient.
NewGamma - the user-defined value for gamma, the expansion coefficient.

Hybrid_NMSearch(long dim, Vector<double> &startPoint, double NewSigma, double NewAlpha, double NewBeta, double NewGamma, double startStep, double stopStep, double EdHJStop, void (*objective)(long vars, Vector<double> &x, double & func, bool& flag, void* an_obj), void * input_obj)
Adds one more parameter to the long NMSearch constructor, for the EdHJSearch stopping step length
Parameters:
dim - the dimension of the problem.
startpoint - the start point for the search. This will be initialized as the minPoint.
NewSigma - the user-defined value for sigma, the shrinking coefficient.
NewAlpha - the user-defined value for alpha, the reflection coefficient.
NewBeta - the user-defined value for beta, the contraction coefficient.
NewGamma - the user-defined value for gamma, the expansion coefficient.
startStep - will be used as the edge length of a fixed-length right simplex.
stopStep - the stopping step length for the search
EdHJStop - the stopping step length forthe EdHJSearch
objective - a pointer to the function to be minimized
input_obj - used to send additional data as needed--will normally be set to NULL.

~Hybrid_NMSearch()
Destructor

other public methods

void BeginSearch()
This method starts the actual searching.
Returns:
void

long GetFunctionCalls() const
This is overloaded to return TotalCalls.
Returns:
long

long GetNSearchCalls()
Returns the value of NSearchCalls.
Returns:
long

long GetESearchCalls()
Returns the value of ESearchCalls.
Returns:
long

long GetTotalCalls()
Returns the value of TotalCalls.
Returns:
long

double ESearchStoplength