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);
}
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="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="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);
}
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="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);
}
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;
}
/// <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 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);
}
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;
}
