/// <summary>
/// Test to see if we can fit a parabola
/// </summary>
public static void SimplexTest1()
{
Console.WriteLine("Starting SimplexTest1");
SimplexConstant[] constants = new SimplexConstant[] { new SimplexConstant(3, 1), new SimplexConstant(5, 1) };
double tolerance = 1e-6;
int maxEvals = 1000;
ObjectiveFunctionDelegate objFunction = new ObjectiveFunctionDelegate(_objFunction1);
RegressionResult result = NelderMeadSimplex.Regress(constants, tolerance, maxEvals, objFunction);
_printResult(result);
}
/// <summary>
/// Test on the Rosenbrock function
/// </summary>
public static void SimplexTest2()
{
Console.WriteLine("\n\nStarting SimplexTest2");
// we are regressing for frequency, amplitude, and phase offset
SimplexConstant[] constants = new SimplexConstant[] { new SimplexConstant(-1.2, .1), new SimplexConstant(1, .1)};
double tolerance = 1e-10;
int maxEvals = 1000;
ObjectiveFunctionDelegate objFunction = new ObjectiveFunctionDelegate(_objFunction2);
RegressionResult result = NelderMeadSimplex.Regress(constants, tolerance, maxEvals, objFunction);
_printResult(result);
}
private static readonly double JITTER = 1e-10d; // a small value used to protect against floating point noise
#endregion Fields
#region Methods
public static RegressionResult Regress(SimplexConstant[] simplexConstants, double convergenceTolerance, int maxEvaluations,
ObjectiveFunctionDelegate objectiveFunction)
{
// confirm that we are in a position to commence
if (objectiveFunction == null)
throw new InvalidOperationException("ObjectiveFunction must be set to a valid ObjectiveFunctionDelegate");
if (simplexConstants == null)
throw new InvalidOperationException("SimplexConstants must be initialized");
#if DEBUG //this is the coniditional compilation symbols in the project property >>build section
Console.Write("inside nelder mead regression:");
#endif
// create the initial simplex
int numDimensions = simplexConstants.Length;
int numVertices = numDimensions + 1;
#if DEBUG
Console.Write("numVertices: {0}", numVertices );
#endif
Vector[] vertices = _initializeVertices(simplexConstants);
double[] errorValues = new double[numVertices];
int evaluationCount = 0;
TerminationReason terminationReason = TerminationReason.Unspecified;
ErrorProfile errorProfile;
errorValues = _initializeErrorValues(vertices, objectiveFunction);
#if DEBUG || LOG_MODE
Console.WriteLine("\n=====Start the Nelder-Mead Algorithm for Optimization..........");
#endif
// iterate until we converge, or complete our permitted number of iterations
while (true)
{
#if LOG_MODE
if (evaluationCount % 100 == 0)
{
Console.Write("......"+evaluationCount+ "/"+maxEvaluations );
}
#endif
errorProfile = _evaluateSimplex(errorValues);
// see if the range in point heights is small enough to exit
if (_hasConverged(convergenceTolerance, errorProfile, errorValues))
{
terminationReason = TerminationReason.Converged;
break;
}
#if DEBUG
Console.WriteLine("not converged");
#endif
// attempt a reflection of the simplex
double reflectionPointValue = _tryToScaleSimplex(-1.0, ref errorProfile, vertices, errorValues, objectiveFunction);
++evaluationCount;
#if DEBUG
Console.WriteLine("Got a reflection point");
#endif
if (reflectionPointValue <= errorValues[errorProfile.LowestIndex])
{
// it's better than the best point, so attempt an expansion of the simplex
double expansionPointValue = _tryToScaleSimplex(2.0, ref errorProfile, vertices, errorValues, objectiveFunction);
++evaluationCount;
}
else if (reflectionPointValue >= errorValues[errorProfile.NextHighestIndex])
{
// it would be worse than the second best point, so attempt a contraction to look
// for an intermediate point
double currentWorst = errorValues[errorProfile.HighestIndex];
double contractionPointValue = _tryToScaleSimplex(0.5, ref errorProfile, vertices, errorValues, objectiveFunction);
++evaluationCount;
if (contractionPointValue >= currentWorst)
{
// that would be even worse, so let's try to contract uniformly towards the low point;
// don't bother to update the error profile, we'll do it at the start of the
// next iteration
_shrinkSimplex(errorProfile, vertices, errorValues, objectiveFunction);
evaluationCount += numVertices; // that required one function evaluation for each vertex; keep track
}
}
// check to see if we have exceeded our alloted number of evaluations
if (evaluationCount >= maxEvaluations)
{
terminationReason = TerminationReason.MaxFunctionEvaluations;
break;
}
}
#if LOG_MODE
Console.WriteLine("Done!!");
#endif
RegressionResult regressionResult = new RegressionResult(terminationReason,
vertices[errorProfile.LowestIndex].Components, errorValues[errorProfile.LowestIndex], evaluationCount);
return regressionResult;
}
/// <summary>
/// Construct an initial simplex, given starting guesses for the constants, and
/// initial step sizes for each dimension
/// </summary>
/// <param name="simplexConstants"></param>
/// <returns></returns>
private static Vector[] _initializeVertices(SimplexConstant[] simplexConstants)
{
int numDimensions = simplexConstants.Length;
Vector[] vertices = new Vector[numDimensions + 1];
// define one point of the simplex as the given initial guesses
Vector p0 = new Vector(numDimensions);
for (int i = 0; i < numDimensions; i++)
{
p0[i] = simplexConstants[i].Value;
}
// now fill in the vertices, creating the additional points as:
// P(i) = P(0) + Scale(i) * UnitVector(i)
vertices[0] = p0;
for (int i = 0; i < numDimensions; i++)
{
double scale = simplexConstants[i].InitialPerturbation;
Vector unitVector = new Vector(numDimensions);
unitVector[i] = 1;
vertices[i + 1] = p0.Add(unitVector.Multiply(scale));
#if DEBUG
Console.Write(i+":" + vertices[i + 1].ToString() + "==");
#endif
}
#if DEBUG
Console.WriteLine("");
#endif
return vertices;
}
public void Minimize()
{
SetCoefficients();
Console.WriteLine("Starting minimization...");
SimplexConstant[] constants = new SimplexConstant[Coefficients.Length];
for (int i = 0; i < Coefficients.Length; i++)
{
constants[i] = new SimplexConstant(Coefficients[i], Math.Abs(Coefficients[i]) / 2);
}
double tolerance = 1e-6;
int maxEvals = 1000;
ObjectiveFunctionDelegate objFunction = new ObjectiveFunctionDelegate(SpiderObjectiveFunction);
RegressionResult result = NelderMeadSimplex.Regress(constants, tolerance, maxEvals, objFunction);
Coefficients = result.Constants;
PrintCoefficients(Coefficients);
}
