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