SMDSearch

class SMDSearch : public SimplexSearch

Declarations of Sequential version of Torczon's Multi-Directional Search

Inheritance:

Public

Constructors and destructor

SMDSearch(long dim, Vector<double> &startPoint): Constructor
SMDSearch(const SMDSearch& Original): Copy constructor
SMDSearch(long dim, Vector<double> &startPoint, double NewSigma): Constructor which allows shrinking coefficient initialization
SMDSearch(long dim, Vector<double> &startPoint, double NewSigma, Vector<double> &lengths): Constructor which allows shrinking coefficient initialization and specification of starting_edgeLengths
SMDSearch(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
virtual ~SMDSearch(): Destructor

Other public methods

SMDSearch& operator= (const SMDSearch& A): Overloaded assigment operator
void BeginSearch(): Sets the search in motion
void ChooseRegularSimplex(): Deletes any existing simplex and replaces it with a regular triangular simplex
void ChooseRightSimplex(): Deletes any existing simplex and replaces it with a right-angle simplex
void ReadInFile(istream& fp): May also pass cin as input stream if desired
void GetCurrentSimplexVBits(long* &simVBits) const: Performs a deep copy of the simplexVBits array to a long pointer
void PrintDesign() const: Prints out the primary simplex points by row
void printRefSimplex() const: Prints out the reflection simplex points by row

Protected Fields
long* simplexVBits: Valid bits for the simplex values
long currentIndex: Used to step through the arrays
long refCurrentIndex: Used to step through the arrays
Matrix <double> * refSimplex: The reflection simplex
double* refSimplexValues: f(x) values corresponding to the simplex points
long* refSimplexVBits: Valid bits for the simplex values

Protected Methods
void ExploratoryMoves(): This method does the actual work of the search
bool Stop(): Returns true if the stopping criteria have been satisfied
void InitRegSimplex(): Inititializes a regular simplex, following an algorithm given by Jacoby, Kowalik, and Pizzo in "Iterative Methods for Nonlinear Optimization Problems," Prentice-Hall (1972)
void InitRightSimplex(): Inititializes a right simplex
void InitGeneralSimplex(Matrix<double> *plex): Deletes any existing design matrix and replaces it with one pointed to by plex
void CopySearch(const SMDSearch & Original): Used to implement the overloaded assignment operator
void CreateRefSimplex(): Creates a reflection simplex from the primary simplex
void SwitchSimplices(): Swaps the primary and reflection simplices
void ShrinkSimplex(): This function goes through the primary simplex and reduces the lengths of the edges adjacent to the best vertex
long GetAnotherIndex(long& index, long*& validBits): This is used to find another INVALID point in the simplex
void CalculateRefFunctionValue(long index): Like CalculateFunctionValue(), but for the Reflection Simplex (A user should not directly manipulate the reflection simplex, hence the private status of this function)

Inherited from SimplexSearch:

Public Fields
static const int def_Length

Public
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

Declarations of Sequential version of Torczon's Multi-Directional Search

Constructors and destructor

SMDSearch(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 and SimplexSearch classses.

delta = -1.0
memory is allocated for fields simplexVBits, refSimplex, refSimplexValues, and refSimplexVBits.
IDnumber = 3300

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

SMDSearch(const SMDSearch& Original)
Copy constructor
Parameters:
Original - a reference to the object from which to construct *this

SMDSearch(long dim, Vector<double> &startPoint, double NewSigma)
Constructor which allows shrinking coefficient initialization. sigma will be set to the value of sig by the SimplexSearch constructor with the same signature. Other fields will be assigned as in SMDSearch(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.

SMDSearch(long dim, Vector<double> &startPoint, double NewSigma, Vector<double> &lengths)
Constructor which allows shrinking coefficient initialization and specification of starting_edgeLengths. sigma will be set to the value of sig by SimplexSearch constructor with the same signature, and starting_edgeLengths will be initialized from lengths. Other fields will be assigned as in SMDSearch(long dim, Vector<double> &startPoint).

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

SMDSearch(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. The objective function can be sent in as the fourth parameter here; the last parameter is used for any other information that may be necessary; it is used in MAPS, for example, to send in an object from an outside class Usually, though, the final parameter will simply be set to NULL.
This constructor takes six input parameters. All are sent to the SimplexSearch constructor with the same signature. Other fields are set by default as in SMDSearch(long dim, Vector<double> &startPoint).

Parameters:
dim - the dimension of the problem
startPoint - a Vector of doubles, the starting point for the search
startStep - will be used as the edge length of a fixed-length right simplex.
stopStep - the stopping step length for the search
objective - a pointer to the function to be minimized
input_obj - used to send additional data as needed--will normally be set to NULL.

virtual ~SMDSearch()
Destructor. Note that Matrix and Vector classes have their own destructors.

Other public methods

SMDSearch& operator= (const SMDSearch& A)
Overloaded assigment operator
Returns:
SMDSearch&
Parameters:
A - search to assign to *this.

void BeginSearch()
Sets the search in motion.
Returns:
void

void ChooseRegularSimplex()
Deletes any existing simplex and replaces it with a regular triangular simplex.
edgelengths[] represents the length of each edge of the "triangle": in this case, all entries of edgelengths[] should be equal.
functionCalls is reset to 0 delta is set to edgeLengths[0]
Returns:
void

void ChooseRightSimplex()
Deletes any existing simplex and replaces it with a right-angle simplex.
The starting point will be the "origin" of the simplex points (it will be a part of the simplex and its function value is found here) edgeLengths points to an array of n doubles, where n is the dimension of the given search. x_1 will then be located a distance of edgeLengths[0] away from the basepoint along the the x_1 axis, x_2 is edgeLengths[1] away on the x_2 axis, etc.
functionCalls is reset to 0 delta is set to the largest value in edgeLengths[]
Returns:
void

void ReadInFile(istream& fp)
May also pass cin as input stream if desired. Input the values of each trial point NOTE: THIS FUNCTION WILL ONLY ACCEPT n+1 POINTS
NOTE: assumes that the basePoint(which will be initialized as the minPoint) is the last point entered
functionCalls is reset to 0 delta is set to the length of the longest simplex side.
Returns:
void
Parameters:
fp - reference to an input stream

void GetCurrentSimplexVBits(long* &simVBits) const
Performs a deep copy of the simplexVBits array to a long pointer. Points to a newly allocated chunk of memory upon return USER SHOULD PASS JUST A NULL POINTER, WITHOUT PREALLOCATED MEMORY.
Returns:
void
Parameters:
simVBits - a reference to a pointer of type long int.

void PrintDesign() const
Prints out the primary simplex points by row. Also prints the corresponding f(x) values and validity status of each point, and the number of function calls thus far.
Returns:
void

void printRefSimplex() const
Prints out the reflection simplex points by row. Also prints the corresponding f(x) values and validity status of each point, and the number of function calls thus far.
Returns:
void

void ExploratoryMoves()

This method does the actual work of the search. It uses the SMD algorithm to find the function minimum.

Returns:: void

bool Stop()

Returns true if the stopping criteria have been satisfied

Returns:: bool

void InitRegSimplex()

Inititializes a regular simplex, following an algorithm given by Jacoby, Kowalik, and Pizzo in "Iterative Methods for Nonlinear Optimization Problems," Prentice-Hall (1972). This algorithm also appears in Spendley, Hext, and Himsworth, "Sequential Application of Simplex Designs in Optimisation and Evolutionary Operation," Technometrics, Vol. 4, No. 4, November 1962, pages 441--461. Note that Input matrix plex must be of the correct dimensions.

Returns:: void
Parameters:: plex - pointer to a Matrix of doubles, of appropriate size.

void InitRightSimplex()

Inititializes a right simplex. Input matrix plex must be of the correct dimensions.

Returns:: void
Parameters:: plex - pointer to a Matrix of doubles, of appropriate size.

void InitGeneralSimplex(Matrix<double> *plex)

Deletes any existing design matrix and replaces it with one pointed to by plex. functionCalls is set to 0. The basePoint is the minPoint and will be the "origin" of the simplex points (it will be a part of the simplex and its function value is calculated here).

Returns:: void
Parameters:: plex - pointer to a Matrix of doubles, from which design will be initialized.

void CopySearch(const SMDSearch & Original)

Used to implement the overloaded assignment operator

Returns:: void
Parameters:: Original - reference to the search to be copied

void CreateRefSimplex()

Creates a reflection simplex from the primary simplex

Returns:: void

void SwitchSimplices()

Swaps the primary and reflection simplices. This method removes the need to delete and reallocate memory by simply swapping pointers and using the same two "simplex memory slots" for the entire search.

Returns:: void

void ShrinkSimplex()

This function goes through the primary simplex and reduces the lengths of the edges adjacent to the best vertex

Returns:: void

long GetAnotherIndex(long& index, long*& validBits)

This is used to find another INVALID point in the simplex. if all points are VALID, returns 0, otherwise 1.

Parameters:: index - a reference to a long, representing the current index
validBits - reference to a pointer to an array of longs, here representing a validity array.

void CalculateRefFunctionValue(long index)