private void Initialize(OptMultivariateFunction funk, double initialStep, out double[,] p, out double[] y)
{
#region Valores Iniciales
int ndim = this._SimplexVariableList.Length;
int mpts = ndim + 1;
p = new double[mpts, ndim];
y = new double[mpts];
double[] Variables = new double[ndim];
//Se pone el primer punto iagual al valor inicial
for (int i = 0; i < ndim; i++)
{
Variables[i] = this._SimplexVariableList[i].InitialGuess; //El primer punto es el vector original
//mod
p[0, i] = Variables[i] / this._SimplexVariableList[i].ScaleFactor;
}
this._FunEvaluations++;
y[0] = funk(Variables);
for (int i = 0; i < ndim; i++)
{
//mod
Variables[i] = this._SimplexVariableList[i].InitialGuess + initialStep * this._SimplexVariableList[i].ScaleFactor;
//mod
p[i + 1, i] = Variables[i] / this._SimplexVariableList[i].ScaleFactor;
this._FunEvaluations++;
y[i + 1] = funk(Variables);
}
#endregion
}
public double[] ComputeMin(OptMultivariateFunction function, OptSimplexBoundVariable[] variables, double initialStep, double tolerance, ref int MAXFUN)
{
this.Function = function;
this.MeFunEvaluations = 0;
this.MeSimplexBoundVariableList = OptSimplexBoundVariable.GetClon(variables);
this.MeInitialStep = initialStep;
this.InitializeVariables();
this.InitializeWorkSpace();
if (this.MeNumFreeVariables == 0) return this.MeVariables;
this.MeCOBYLA.Run(this.MeNumFreeVariables, this.MeNumBoundVariables, ref this.MeFreeVariables, 0, initialStep, tolerance, 0, ref MAXFUN, ref W, 0, ref IACT, 0);
int varFreeVarIndex = 0;
for (int i = 0; i < this.MeSimplexBoundVariableList.Length; i++)
{
if (this.MeSimplexBoundVariableList[i].Fixed == false)
{
//mod
this.MeVariables[i] = this.MeFreeVariables[varFreeVarIndex] * this.MeSimplexBoundVariableList[i].ScaleFactor;
varFreeVarIndex++;
}
}
MAXFUN = this.MeFunEvaluations;
return this.MeVariables;
}
private double[] Compute(OptMultivariateFunction function, OptMultivariateGradient gradient, double tolerance, double factr, ref int nMax)
{
double f = 0;
BFGSTask TASK = BFGSTask.START;
BFGSTask Csave = BFGSTask.START;
int iprint = 0;
bool Continue = true;
int funcEvaluations = 0;
while (Continue)
{
this._SETULB.Run(this._NumFreeVariables, this.M, ref this._FreeVariables, 0, this._LowerBounds, 0, this._UpperBounds, 0,
this._NBD, 0, ref f, ref this._GradientArray, 0, factr, tolerance, ref WA, 0, ref IWA, 0, ref TASK, iprint, ref Csave,
ref LSAVE, 0, ref this.ISAVE, 0, ref DSAVE, 0);
if (funcEvaluations <= nMax)
{
if (TASK == BFGSTask.FG || TASK == BFGSTask.FG_LNSRCH || TASK == BFGSTask.FG_ST || TASK == BFGSTask.FG_START)
{
// c the minimization routine has returned to request the
// c function f and gradient g values at the current x.
// c Compute function value f for the sample problem.
this.UpdateExternalVariables();
funcEvaluations++;
f = function(this._ExternalVariables);
this._ExternalGradientArray = gradient(this._ExternalVariables);
this.UpdateInternalGradient();
// c go back to the minimization routine.
Continue = true;
}
else if (TASK == BFGSTask.NEW_X)
{
Continue = true;
}
else
{
Continue = false;
}
}
else
{
Continue = false;
}
}
this.UpdateExternalVariables();
nMax = funcEvaluations;
return(this._ExternalVariables);
}
private void Initialize(OptMultivariateFunction funk, double initialStep, out double[,] p, out double[] y)
{
#region Valores Iniciales
int ndim = this._SimplexVariableList.Length;
int mpts = ndim + 1;
p = new double[mpts, ndim];
y = new double[mpts];
double[] Variables = new double[ndim];
//Se pone el primer punto iagual al valor inicial
for (int i = 0; i < ndim; i++)
{
Variables[i] = this._SimplexVariableList[i].InitialGuess; //El primer punto es el vector original
//mod
p[0, i] = Variables[i] / this._SimplexVariableList[i].ScaleFactor;
}
this._FunEvaluations++;
y[0] = funk(Variables);
for (int i = 0; i < ndim; i++)
{
//mod
Variables[i] = this._SimplexVariableList[i].InitialGuess + initialStep * this._SimplexVariableList[i].ScaleFactor;
//mod
p[i + 1, i] = Variables[i] / this._SimplexVariableList[i].ScaleFactor;
this._FunEvaluations++;
y[i + 1] = funk(Variables);
}
#endregion
}
private double Extrapolate(double[,] p, double[] y, double[] psum, int ndim, OptMultivariateFunction fun, int indexFMax, double fac)
{
int j;
double fac1, fac2, ytry;
double[] ptry = new Double[ndim];
fac1 = (1.0 - fac) / (double)ndim;
fac2 = fac1 - fac;
for (j = 0; j < ndim; j++)
{
ptry[j] = psum[j] * fac1 - p[indexFMax, j] * fac2;
}
ytry = fun(ptry);
if (ytry < y[indexFMax])
{
y[indexFMax] = ytry;
for (j = 0; j < ndim; j++)
{
psum[j] += ptry[j] - p[indexFMax, j];
p[indexFMax, j] = ptry[j];
}
}
return(ytry);
}
public double[] ComputeMin(OptMultivariateFunction function, OptSimplexVariable[] variables, double initialStep, double ftol, ref int nMax)
{
double[,] p;
double[] y;
bool stop = false;
this._Function = function;
this._SimplexVariableList = variables;
this._FunEvaluations = 0;
this._ExternalVariables = new double[variables.Length];
int numFreeVariable = 0;
for (int i = 0; i < this._SimplexVariableList.Length; i++)
{
this._ExternalVariables[i] = this._SimplexVariableList[i].InitialGuess;
if (this._SimplexVariableList[i].Fixed == false)
{
numFreeVariable++;
}
}
if (numFreeVariable == 0)
{
return(this._ExternalVariables);
}
double[] minimum = new double[numFreeVariable];
this.Initialize(function, initialStep, out p, out y);
OptMultivariateFunction internalFunc = new OptMultivariateFunction(InternalFunction);
this._downhill.Run(minimum, p, y, ftol, ref stop, internalFunc, ref nMax);
//Se regresan las variables en escala original
int varFreeVarIndex = 0;
for (int i = 0; i < this._SimplexVariableList.Length; i++)
{
if (this._SimplexVariableList[i].Fixed == false)
{
//mod
this._ExternalVariables[i] = minimum[varFreeVarIndex] * this._SimplexVariableList[i].ScaleFactor;
varFreeVarIndex++;
}
}
nMax = this._FunEvaluations;
return(this._ExternalVariables);
}
private double[] GetMinimum(OptMultivariateFunction function, OptSimplexVariable[] variables, double initialStep, double ftol, ref int nMax)
{
if (this._AmoebaDirver == null)
{
this._AmoebaDirver = new DownhillDirver();
}
double[] minimum = this._AmoebaDirver.ComputeMin(function, variables, initialStep, ftol, ref nMax);
this.FunEvaluations = nMax;
return(minimum);
}
/// <summary>
/// Computes the minimum point of a function of several variables.
/// </summary>
/// <param name="function">The function to minimize.</param>
/// <param name="initialGuess">Array of size N containing the initial guess. N is the number of variables.</param>
/// <param name="initialStep">The initial change of the variables.</param>
/// <returns>Array containing the solution.</returns>
public double[] ComputeMin(OptMultivariateFunction function, double[] initialGuess, double initialStep)
{
if (initialGuess == null) return new double[0];
if (initialGuess.Length == 0) return new double[0];
OptSimplexVariable[] variables = this.GetVariables(initialGuess);
int maxFunc = this._MaxFunEvaluations;
return this.GetMinimum(function, variables, initialStep, this._Tolerance, ref maxFunc);
}
public double[] ComputeMin(OptMultivariateFunction function, OptMultivariateGradient gradient, OptBoundVariable[] variables, double tolerance, double factr, ref int nMax)
{
double[] minimum;
this.Initialize(variables);
if (this._NumFreeVariables == 0) return this._ExternalVariables;
minimum = this.Compute(function, gradient, tolerance, factr, ref nMax);
return minimum;
}
private double[] GetMinimum(OptMultivariateFunction function, OptSimplexBoundVariable[] variables, double initialStep, double tolerance, ref int MAXFUN)
{
if (this._CobylaDriver == null)
{
this._CobylaDriver = new CobylaDriver();
}
double[] minimum = this._CobylaDriver.ComputeMin(function, variables, initialStep, tolerance, ref MAXFUN);
this.FunEvaluations = MAXFUN;
return(minimum);
}
/// <summary>
/// Computes the minimum point of a function of several variables.
/// </summary>
/// <param name="function">The function to minimize.</param>
/// <param name="gradient">A delegate that computes the gradient.</param>
/// <param name="initialGuess">Array of size N containing the initial guess. N is the number of variables.</param>
/// <returns>Array containing the solution.</returns>
public double[] ComputeMin(OptMultivariateFunction function, OptMultivariateGradient gradient, double[] initialGuess)
{
if (initialGuess == null) return new double[0];
if (initialGuess.Length == 0) return new double[0];
OptVariable[] variables = this.GetVariables(initialGuess);
int maxFunc = this._MaxFunEvaluations;
double[] minimum= this._Driver.ComputeMin(function, gradient, variables, this._Tolerance, this._AccuracyFactor, ref maxFunc);
this._FunEvaluations = maxFunc;
return minimum;
}
public double[] ComputeMin(OptMultivariateFunction function, OptMultivariateGradient gradient, OptBoundVariable[] variables, double tolerance, double factr, ref int nMax)
{
double[] minimum;
this.Initialize(variables);
if (this._NumFreeVariables == 0)
{
return(this._ExternalVariables);
}
minimum = this.Compute(function, gradient, tolerance, factr, ref nMax);
return(minimum);
}
/// <summary>
/// Computes the minimum point of a function of several variables.
/// </summary>
/// <param name="function">The function to minimize.</param>
/// <param name="variables">Array of size N containing the varaibles.</param>
/// <param name="initialStep">The initial change of the variables.</param>
/// <returns>Array containing the solution.</returns>
public double[] ComputeMin(OptMultivariateFunction function, OptSimplexBoundVariable[] variables, float initialStep)
{
if (variables == null)
{
return(new double[0]);
}
if (variables.Length == 0)
{
return(new double[0]);
}
int maxFunc = this._MaxFunEvaluations;
return(this.GetMinimum(function, variables, initialStep, this._Tolerance, ref maxFunc));
}
internal SFUN(OptMultivariateFunction function, OptMultivariateGradient gradient, OptBoundVariable[] variables)
{
//this.MeNParameters = nParameters;
this.MeFunction = function;
this.MeGradient = gradient;
this.MeOptVariable = null;
this.MeOptBoundVariable = variables;
this.MeExternalVariables = new double[variables.Length];
this.MeExternalGradientArray = new double[variables.Length];
for (int i = 0; i < variables.Length; i++)
{
this.MeExternalVariables[i] = variables[i].InitialGuess;
}
}
internal SFUN(OptMultivariateFunction function, OptMultivariateGradient gradient, OptBoundVariable[] variables)
{
//this.MeNParameters = nParameters;
this.MeFunction = function;
this.MeGradient = gradient;
this.MeOptVariable = null;
this.MeOptBoundVariable = variables;
this.MeExternalVariables = new double[variables.Length];
this.MeExternalGradientArray = new double[variables.Length];
for (int i = 0; i < variables.Length; i++)
{
this.MeExternalVariables[i] = variables[i].InitialGuess;
}
}
private void Initialize(OptMultivariateFunction function, OptMultivariateGradient gradient, OptBoundVariable[] variables)
{
this.internalFunction = new SFUN(function, gradient, variables);
this.MeOptVariable = null;
this.MeOptBoundVariable = OptBoundVariable.GetClon(variables);
this.CheckAndSetBounds(this.MeOptBoundVariable);
this.MeExternalVariables = new double[this.MeOptBoundVariable.Length];
int numFreeVariable = 0;
for (int i = 0; i < this.MeOptBoundVariable.Length; i++)
{
this.MeExternalVariables[i] = variables[i].InitialGuess;
if (this.MeOptBoundVariable[i].Fixed == false)
{
numFreeVariable++;
}
}
this.MeF = function(this.MeExternalVariables);
this.MeNumFreeVariables = numFreeVariable;
this.MeFreeVariables = new double[numFreeVariable];
this.MeGradientArray = new double[numFreeVariable];
int index = 0;
for (int i = 0; i < this.MeOptBoundVariable.Length; i++)
{
if (this.MeOptBoundVariable[i].Fixed == false)
{
this.MeFreeVariables[index] = this.MeOptBoundVariable[i].InitialGuess;
index++;
}
}
//W - (REAL*8)(REAL*8) WORK VECTOR OF LENGTH AT LEAST 14*N
//LW - (INTEGER) THE DECLARED DIMENSION OF W
this.MeLW = 14 * this.MeNumFreeVariables;
this.MeW = new double[this.MeLW];
this.MeMAXIT = Math.Max(1, this.MeNumFreeVariables / 2);
}
/// <summary>
/// Computes the minimum point of a function of several variables.
/// </summary>
/// <param name="function">The function to minimize.</param>
/// <param name="initialGuess">Array of size N containing the initial guess. N is the number of variables.</param>
/// <param name="initialStep">The initial change of the variables.</param>
/// <returns>Array containing the solution.</returns>
public double[] ComputeMin(OptMultivariateFunction function, double[] initialGuess, double initialStep)
{
if (initialGuess == null)
{
return(new double[0]);
}
if (initialGuess.Length == 0)
{
return(new double[0]);
}
OptSimplexVariable[] variables = this.GetVariables(initialGuess);
int maxFunc = this._MaxFunEvaluations;
return(this.GetMinimum(function, variables, initialStep, this._Tolerance, ref maxFunc));
}
/// <summary>
/// Computes the minimum point of a function of several variables.
/// </summary>
/// <param name="function">The function to minimize.</param>
/// <param name="gradient">A delegate that computes the gradient.</param>
/// <param name="variables">Array of size N containing the varaibles.</param>
/// <returns>Array containing the solution.</returns>
public double[] ComputeMin(OptMultivariateFunction function, OptMultivariateGradient gradient, OptVariable[] variables)
{
if (variables == null)
{
return(new double[0]);
}
if (variables.Length == 0)
{
return(new double[0]);
}
int maxFunc = this._MaxFunEvaluations;
double[] minimum = this._Driver.ComputeMin(function, gradient, variables, this._Tolerance, this._AccuracyFactor, ref maxFunc);
this._FunEvaluations = maxFunc;
return(minimum);
}
public double[] ComputeMin(OptMultivariateFunction function, OptSimplexVariable[] variables, double initialStep, double ftol, ref int nMax)
{
double[,] p;
double[] y;
bool stop = false;
this._Function = function;
this._SimplexVariableList = variables;
this._FunEvaluations = 0;
this._ExternalVariables = new double[variables.Length];
int numFreeVariable = 0;
for (int i = 0; i < this._SimplexVariableList.Length; i++)
{
this._ExternalVariables[i] = this._SimplexVariableList[i].InitialGuess;
if (this._SimplexVariableList[i].Fixed == false) numFreeVariable++;
}
if (numFreeVariable == 0) return this._ExternalVariables;
double[] minimum = new double[numFreeVariable];
this.Initialize(function, initialStep, out p, out y);
OptMultivariateFunction internalFunc = new OptMultivariateFunction(InternalFunction);
this._downhill.Run(minimum, p, y, ftol, ref stop, internalFunc, ref nMax);
//Se regresan las variables en escala original
int varFreeVarIndex = 0;
for (int i = 0; i < this._SimplexVariableList.Length; i++)
{
if (this._SimplexVariableList[i].Fixed == false)
{
//mod
this._ExternalVariables[i] = minimum[varFreeVarIndex] * this._SimplexVariableList[i].ScaleFactor;
varFreeVarIndex++;
}
}
nMax = this._FunEvaluations;
return this._ExternalVariables;
}
/// <summary>
/// Computes the minimum point of a function of several variables.
/// </summary>
/// <param name="function">The function to minimize.</param>
/// <param name="variables">Array of size N containing the varaibles.</param>
/// <returns>Array containing the solution.</returns>
public double[] ComputeMin(OptMultivariateFunction function, OptBoundVariable[] variables)
{
if (variables == null)
{
return(new double[0]);
}
if (variables.Length == 0)
{
return(new double[0]);
}
OptSimplexBoundVariable[] simplexVariables = this.GetVariables(variables);
double initialStep = this.GetAutomaticInitialStep(simplexVariables);
int maxFunc = this._MaxFunEvaluations;
return(this.GetMinimum(function, simplexVariables, initialStep, this._Tolerance, ref maxFunc));
}
/// <summary>
/// Computes the minimum point of a function of several variables.
/// </summary>
/// <param name="function">The function to minimize.</param>
/// <param name="gradient">A delegate that computes the gradient.</param>
/// <param name="variables">Array of size N containing the varaibles.</param>
/// <returns>Array containing the solution.</returns>
public double[] ComputeMin(OptMultivariateFunction function, OptMultivariateGradient gradient, OptBoundVariable[] variables)
{
if (variables == null)
{
return(new double[0]);
}
if (variables.Length == 0)
{
return(new double[0]);
}
int maxFunc = this._MaxFunEvaluations;
this._TNDriver.ETA = this._SearchSeverity;
this._TNDriver.STEPMX = this._MaximunStep;
double[] minimum = this._TNDriver.ComputeMin(function, gradient, variables, this._Tolerance, this._Accuracy, ref maxFunc);
this._FunEvaluations = maxFunc;
return(minimum);
}
public double[] ComputeMin(OptMultivariateFunction function, OptMultivariateGradient gradient, OptBoundVariable[] variables, double tolerance, double ACCRCY, ref int nMax)
{
if (this.MeLMQNBC == null)
{
this.MeLMQNBC = new LMQNBC();
}
this.Initialize(function, gradient, variables);
if (this.MeNumFreeVariables == 0)
{
return(this.MeExternalVariables);
}
int IERROR = 0;
int[] IPIVOT = new int[this.MeNumFreeVariables];
this.MeLMQNBC.Run(ref IERROR, this.MeNumFreeVariables, ref this.MeFreeVariables, 0, ref this.MeF,
ref this.MeGradientArray, 0, ref this.MeW, 0, this.MeLW, this.internalFunction, this.MeLowerBounds, 0, this.MeUpperBounds, 0,
ref this.MeIPIVOT, 0, this.MeMSGLVL, this.MeMAXIT, nMax, this.MeETA, this.MeSTEPMX, ACCRCY, tolerance);
int index = 0;
for (int i = 0; i < variables.Length; i++)
{
if (variables[i].Fixed == false)
{
this.MeExternalVariables[i] = this.MeFreeVariables[index];
index++;
}
}
nMax = this.internalFunction.FunEvaluations;
return(this.MeExternalVariables);
}
public double[] ComputeMin(OptMultivariateFunction function, OptSimplexBoundVariable[] variables, double initialStep, double tolerance, ref int MAXFUN)
{
this.Function = function;
this.MeFunEvaluations = 0;
this.MeSimplexBoundVariableList = OptSimplexBoundVariable.GetClon(variables);
this.MeInitialStep = initialStep;
this.InitializeVariables();
this.InitializeWorkSpace();
if (this.MeNumFreeVariables == 0)
{
return(this.MeVariables);
}
this.MeCOBYLA.Run(this.MeNumFreeVariables, this.MeNumBoundVariables, ref this.MeFreeVariables, 0, initialStep, tolerance, 0, ref MAXFUN, ref W, 0, ref IACT, 0);
int varFreeVarIndex = 0;
for (int i = 0; i < this.MeSimplexBoundVariableList.Length; i++)
{
if (this.MeSimplexBoundVariableList[i].Fixed == false)
{
//mod
this.MeVariables[i] = this.MeFreeVariables[varFreeVarIndex] * this.MeSimplexBoundVariableList[i].ScaleFactor;
varFreeVarIndex++;
}
}
MAXFUN = this.MeFunEvaluations;
return(this.MeVariables);
}
public void Run(double[] Point, double[,] p, double[] y, double ftol, ref bool Stop, OptMultivariateFunction fun, ref int nfun)
{
_nmax = nfun;
nfun = 0;
int ndim = Point.Length;
int mpts = ndim + 1;
//int i;
int indexFMax; //Index para el punto donde la fun es maxima
int indexFMin; //Index para el punto donde la fun es minima
int indexFMax2; //
int j;
double rtol, sum, swap, ysave, ytry;
double[] psum = new Double[ndim]; //
//nfunk = 0;
for (j = 0; j < ndim; j++)
{
sum = 0.0;
for (int i = 0; i < mpts; i++)
{
sum += p[i, j];
}
psum[j] = sum;
}
bool conti = true;
while (conti)
{
#region Maximo, segundo maximo y Minimo de F (ihi, inhi, ilo)
indexFMin = 0;
if (y[0] > y[1])
{
indexFMax2 = 1;
indexFMax = 0;
}
else
{
indexFMax2 = 0;
indexFMax = 1;
}
for (int i = 0; i < mpts; i++)
{
if (y[i] <= y[indexFMin])
{
indexFMin = i; //Se encuentra el minimo de la funcion(punto ilo)
}
if (y[i] > y[indexFMax])
{
indexFMax2 = indexFMax; //Se encuentra el segundo valor maximo de la funcion(punto inhi)
indexFMax = i; //Se encuentra el maximo de la funcion(punto ihi)
}
else if ((y[i] > y[indexFMax2]) && (i != indexFMax))
{
indexFMax2 = i;
}
}
#endregion
rtol = 2.0 * Math.Abs(y[indexFMax] - y[indexFMin]) / (Math.Abs(y[indexFMax]) + Math.Abs(y[indexFMin]) + _tiny);
if (rtol < ftol || Stop == true || nfun >= _nmax)
{
#region Mejor valor en Y[0] y P[0,i]
//Se pone en Y[0] y p[0,i] el mejor valor
swap = y[0];
y[0] = y[indexFMin];
y[indexFMin] = swap;
for (int i = 0; i < ndim; i++)
{
swap = p[0, i];
p[0, i] = p[indexFMin, i];
p[indexFMin, i] = swap;
Point[i] = p[indexFMin, i];
}
#endregion
//if (nfunk >= NMAX)
//{
// nfunk = 0;
// this.InitializeInternal(start, Step, ref p, ref y, funk); //Nunca termina
//}
//else
//{
// break;
//}
conti = false;
break;
}
//if (nfunk >= NMAX) try { throw new Exception(); }
// catch (Exception)
// {
// //MessageBox.Show("NMAX exceeded",
// // "Invalid method", MessageBoxButtons.OK, MessageBoxIcon.Error);
// }
nfun += 2;
ytry = this.Extrapolate(p, y, psum, ndim, fun, indexFMax, _alpha);
if (ytry <= y[indexFMin])
{
ytry = this.Extrapolate(p, y, psum, ndim, fun, indexFMax, _gamma);
}
else if (ytry >= y[indexFMax2])
{
ysave = y[indexFMax];
ytry = this.Extrapolate(p, y, psum, ndim, fun, indexFMax, _beta);
if (ytry >= ysave)
{
for (int i = 0; i < mpts; i++)
{
if (i != indexFMin)
{
for (j = 0; j < ndim; j++)
{
p[i, j] = psum[j] = 0.5 * (p[i, j] + p[indexFMin, j]);
}
y[i] = fun(psum);
}
}
nfun += ndim;
for (j = 0; j < ndim; j++)
{
sum = 0.0;
for (int i = 0; i < mpts; i++)
{
sum += p[i, j];
}
psum[j] = sum;
}
}
}
else
{
--nfun;
}
}
}
public double[] ComputeMin(OptMultivariateFunction function, OptMultivariateGradient gradient, OptBoundVariable[] variables, double tolerance, double ACCRCY, ref int nMax)
{
if (this.MeLMQNBC == null) this.MeLMQNBC = new LMQNBC();
this.Initialize(function, gradient, variables);
if (this.MeNumFreeVariables == 0) return this.MeExternalVariables;
int IERROR = 0;
int[] IPIVOT = new int[this.MeNumFreeVariables];
this.MeLMQNBC.Run(ref IERROR, this.MeNumFreeVariables, ref this.MeFreeVariables, 0, ref this.MeF,
ref this.MeGradientArray, 0, ref this.MeW, 0, this.MeLW, this.internalFunction, this.MeLowerBounds, 0, this.MeUpperBounds, 0,
ref this.MeIPIVOT, 0, this.MeMSGLVL, this.MeMAXIT, nMax,this.MeETA, this.MeSTEPMX, ACCRCY, tolerance);
int index = 0;
for (int i = 0; i < variables.Length; i++)
{
if (variables[i].Fixed == false)
{
this.MeExternalVariables[i] = this.MeFreeVariables[index];
index++;
}
}
nMax = this.internalFunction.FunEvaluations;
return this.MeExternalVariables;
}
private void Initialize(OptMultivariateFunction function, OptMultivariateGradient gradient, OptBoundVariable[] variables)
{
this.internalFunction = new SFUN(function, gradient, variables);
this.MeOptVariable = null;
this.MeOptBoundVariable = OptBoundVariable.GetClon(variables);
this.CheckAndSetBounds(this.MeOptBoundVariable);
this.MeExternalVariables = new double[this.MeOptBoundVariable.Length];
int numFreeVariable = 0;
for (int i = 0; i < this.MeOptBoundVariable.Length; i++)
{
this.MeExternalVariables[i] = variables[i].InitialGuess;
if (this.MeOptBoundVariable[i].Fixed == false) numFreeVariable++;
}
this.MeF = function(this.MeExternalVariables);
this.MeNumFreeVariables = numFreeVariable;
this.MeFreeVariables = new double[numFreeVariable];
this.MeGradientArray = new double[numFreeVariable];
int index = 0;
for (int i = 0; i < this.MeOptBoundVariable.Length; i++)
{
if (this.MeOptBoundVariable[i].Fixed == false)
{
this.MeFreeVariables[index] = this.MeOptBoundVariable[i].InitialGuess;
index++;
}
}
//W - (REAL*8)(REAL*8) WORK VECTOR OF LENGTH AT LEAST 14*N
//LW - (INTEGER) THE DECLARED DIMENSION OF W
this.MeLW = 14 * this.MeNumFreeVariables;
this.MeW = new double[this.MeLW];
this.MeMAXIT = Math.Max(1, this.MeNumFreeVariables / 2);
}
/// <summary>
/// Computes the minimum point of a function of several variables.
/// </summary>
/// <param name="function">The function to minimize.</param>
/// <param name="gradient">A delegate that computes the gradient.</param>
/// <param name="variables">Array of size N containing the varaibles.</param>
/// <returns>Array containing the solution.</returns>
public double[] ComputeMin(OptMultivariateFunction function, OptMultivariateGradient gradient, OptBoundVariable[] variables)
{
if (variables == null) return new double[0];
if (variables.Length == 0) return new double[0];
int maxFunc = this._MaxFunEvaluations;
this._TNDriver.ETA = this._SearchSeverity;
this._TNDriver.STEPMX = this._MaximunStep;
double[] minimum = this._TNDriver.ComputeMin(function, gradient, variables, this._Tolerance, this._Accuracy, ref maxFunc);
this._FunEvaluations = maxFunc;
return minimum;
}
private double[] Compute(OptMultivariateFunction function, OptMultivariateGradient gradient, double tolerance, double factr, ref int nMax)
{
double f = 0;
BFGSTask TASK = BFGSTask.START;
BFGSTask Csave = BFGSTask.START;
int iprint = 0;
bool Continue = true;
int funcEvaluations = 0;
while (Continue)
{
this._SETULB.Run(this._NumFreeVariables, this.M, ref this._FreeVariables, 0, this._LowerBounds, 0, this._UpperBounds, 0,
this._NBD, 0, ref f, ref this._GradientArray, 0, factr, tolerance, ref WA, 0, ref IWA, 0, ref TASK, iprint, ref Csave,
ref LSAVE, 0, ref this.ISAVE, 0, ref DSAVE, 0);
if (funcEvaluations <= nMax)
{
if (TASK == BFGSTask.FG || TASK == BFGSTask.FG_LNSRCH || TASK == BFGSTask.FG_ST || TASK == BFGSTask.FG_START)
{
// c the minimization routine has returned to request the
// c function f and gradient g values at the current x.
// c Compute function value f for the sample problem.
this.UpdateExternalVariables();
funcEvaluations++;
f = function(this._ExternalVariables);
this._ExternalGradientArray = gradient(this._ExternalVariables);
this.UpdateInternalGradient();
// c go back to the minimization routine.
Continue = true;
}
else if (TASK == BFGSTask.NEW_X)
{
Continue = true;
}
else
{
Continue = false;
}
}
else
{
Continue = false;
}
}
this.UpdateExternalVariables();
nMax = funcEvaluations;
return this._ExternalVariables;
}
private double Extrapolate(double[,] p, double[] y, double[] psum, int ndim, OptMultivariateFunction fun, int indexFMax, double fac)
{
int j;
double fac1, fac2, ytry;
double[] ptry = new Double[ndim];
fac1 = (1.0 - fac) / (double)ndim;
fac2 = fac1 - fac;
for (j = 0; j < ndim; j++) ptry[j] = psum[j] * fac1 - p[indexFMax, j] * fac2;
ytry = fun(ptry);
if (ytry < y[indexFMax])
{
y[indexFMax] = ytry;
for (j = 0; j < ndim; j++)
{
psum[j] += ptry[j] - p[indexFMax, j];
p[indexFMax, j] = ptry[j];
}
}
return ytry;
}
private double[] GetMinimum(OptMultivariateFunction function, OptSimplexVariable[] variables, double initialStep, double ftol, ref int nMax)
{
if (this._AmoebaDirver == null) this._AmoebaDirver = new DownhillDirver();
double[] minimum = this._AmoebaDirver.ComputeMin(function, variables, initialStep, ftol, ref nMax);
this.FunEvaluations = nMax;
return minimum;
}
private double[] GetMinimum(OptMultivariateFunction function, OptSimplexBoundVariable[] variables, double initialStep, double tolerance, ref int MAXFUN)
{
if (this._CobylaDriver == null) this._CobylaDriver = new CobylaDriver();
double[] minimum = this._CobylaDriver.ComputeMin(function, variables, initialStep, tolerance, ref MAXFUN);
this.FunEvaluations = MAXFUN;
return minimum;
}
/// <summary>
/// Computes the minimum point of a function of several variables.
/// </summary>
/// <param name="function">The function to minimize.</param>
/// <param name="variables">Array of size N containing the varaibles.</param>
/// <returns>Array containing the solution.</returns>
public double[] ComputeMin(OptMultivariateFunction function, OptSimplexVariable[] variables)
{
if (variables == null) return new double[0];
if (variables.Length == 0) return new double[0];
double initialStep = this.GetAutomaticInitialStep(variables);
int maxFunc = this._MaxFunEvaluations;
return this.GetMinimum(function, variables, initialStep, this._Tolerance, ref maxFunc);
}
public void Run(double[] Point, double[,] p, double[] y, double ftol, ref bool Stop, OptMultivariateFunction fun, ref int nfun)
{
_nmax = nfun;
nfun = 0;
int ndim = Point.Length;
int mpts = ndim + 1;
//int i;
int indexFMax; //Index para el punto donde la fun es maxima
int indexFMin; //Index para el punto donde la fun es minima
int indexFMax2; //
int j;
double rtol, sum, swap, ysave, ytry;
double[] psum = new Double[ndim]; //
//nfunk = 0;
for (j = 0; j < ndim; j++)
{
sum = 0.0;
for (int i = 0; i < mpts; i++) sum += p[i, j];
psum[j] = sum;
}
bool conti = true;
while (conti)
{
#region Maximo, segundo maximo y Minimo de F (ihi, inhi, ilo)
indexFMin = 0;
if (y[0] > y[1])
{
indexFMax2 = 1;
indexFMax = 0;
}
else
{
indexFMax2 = 0;
indexFMax = 1;
}
for (int i = 0; i < mpts; i++)
{
if (y[i] <= y[indexFMin]) indexFMin = i; //Se encuentra el minimo de la funcion(punto ilo)
if (y[i] > y[indexFMax])
{
indexFMax2 = indexFMax; //Se encuentra el segundo valor maximo de la funcion(punto inhi)
indexFMax = i; //Se encuentra el maximo de la funcion(punto ihi)
}
else if ((y[i] > y[indexFMax2]) && (i != indexFMax)) indexFMax2 = i;
}
#endregion
rtol = 2.0 * Math.Abs(y[indexFMax] - y[indexFMin]) / (Math.Abs(y[indexFMax]) + Math.Abs(y[indexFMin]) + _tiny);
if (rtol < ftol || Stop == true || nfun >= _nmax)
{
#region Mejor valor en Y[0] y P[0,i]
//Se pone en Y[0] y p[0,i] el mejor valor
swap = y[0];
y[0] = y[indexFMin];
y[indexFMin] = swap;
for (int i = 0; i < ndim; i++)
{
swap = p[0, i];
p[0, i] = p[indexFMin, i];
p[indexFMin, i] = swap;
Point[i] = p[indexFMin, i];
}
#endregion
//if (nfunk >= NMAX)
//{
// nfunk = 0;
// this.InitializeInternal(start, Step, ref p, ref y, funk); //Nunca termina
//}
//else
//{
// break;
//}
conti = false;
break;
}
//if (nfunk >= NMAX) try { throw new Exception(); }
// catch (Exception)
// {
// //MessageBox.Show("NMAX exceeded",
// // "Invalid method", MessageBoxButtons.OK, MessageBoxIcon.Error);
// }
nfun += 2;
ytry = this.Extrapolate(p, y, psum, ndim, fun, indexFMax, _alpha);
if (ytry <= y[indexFMin]) ytry = this.Extrapolate(p, y, psum, ndim, fun, indexFMax, _gamma);
else if (ytry >= y[indexFMax2])
{
ysave = y[indexFMax];
ytry = this.Extrapolate(p, y, psum, ndim, fun, indexFMax, _beta);
if (ytry >= ysave)
{
for (int i = 0; i < mpts; i++)
{
if (i != indexFMin)
{
for (j = 0; j < ndim; j++) p[i, j] = psum[j] = 0.5 * (p[i, j] + p[indexFMin, j]);
y[i] = fun(psum);
}
}
nfun += ndim;
for (j = 0; j < ndim; j++)
{
sum = 0.0;
for (int i = 0; i < mpts; i++) sum += p[i, j];
psum[j] = sum;
}
}
}
else --nfun;
}
}
/// <summary>
/// Computes the minimum point of a function of several variables.
/// </summary>
/// <param name="function">The function to minimize.</param>
/// <param name="variables">Array of size N containing the varaibles.</param>
/// <param name="initialStep">The initial change of the variables.</param>
/// <returns>Array containing the solution.</returns>
public double[] ComputeMin(OptMultivariateFunction function, OptBoundVariable[] variables, float initialStep)
{
if (variables == null) return new double[0];
if (variables.Length == 0) return new double[0];
OptSimplexBoundVariable[] simplexVariables = this.GetVariables(variables);
int maxFunc = this._MaxFunEvaluations;
return this.GetMinimum(function, simplexVariables, initialStep, this._Tolerance, ref maxFunc);
}
