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,
Func<double[], double> 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");
// create the initial simplex
int numDimensions = simplexConstants.Length;
int numVertices = numDimensions + 1;
Vector[] vertices = _initializeVertices(simplexConstants);
double[] errorValues = new double[numVertices];
int evaluationCount = 0;
TerminationReason terminationReason = TerminationReason.Unspecified;
ErrorProfile errorProfile;
errorValues = _initializeErrorValues(vertices, objectiveFunction);
// iterate until we converge, or complete our permitted number of iterations
while (true)
{
errorProfile = _evaluateSimplex(errorValues);
// see if the range in point heights is small enough to exit
if (_hasConverged(convergenceTolerance, errorProfile, errorValues))
{
terminationReason = TerminationReason.Converged;
break;
}
// attempt a reflection of the simplex
double reflectionPointValue = _tryToScaleSimplex(-1.0, ref errorProfile, vertices, errorValues, objectiveFunction);
++evaluationCount;
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;
}
}
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));
}
return vertices;
}