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; } }
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; }