com.itemanalysis.psychometrics.uncmin

Class Uncmin

java.lang.Object

com.itemanalysis.psychometrics.uncmin.Uncmin

public class Uncmin
extends java.lang.Object

Constructor Summary

Constructors

Constructor and Description
Uncmin()

Method Summary

Modifier and Type	Method and Description
void	addUncminStatusListener(UncminStatusListener listener)
void	bakslv_f77(int n, double[][] a, double[] x, double[] b) The bakslv_f77 method solves Ax = b where A is an upper triangular matrix.
void	chlhsn_f77(int n, double[][] a, double epsm, double[] sx, double[] udiag) The chlhsn_f77 method finds "THE L(L-TRANSPOSE) [WRITTEN LL+] DECOMPOSITION OF THE PERTURBED MODEL HESSIAN MATRIX A+MU*I(WHERE MU\0 AND I IS THE IDENTITY MATRIX) WHICH IS SAFELY POSITIVE DEFINITE.
void	choldc_f77(int n, double[][] a, double diagmx, double tol, double[] addmax) The choldc_f77 method finds "THE PERTURBED L(L-TRANSPOSE) [WRITTEN LL+] DECOMPOSITION OF A+D, WHERE D IS A NON-NEGATIVE DIAGONAL MATRIX ADDED TO A IF NECESSARY TO ALLOW THE CHOLESKY DECOMPOSITION TO CONTINUE." Translated by Steve Verrill, April 15, 1998.
void	dfault_f77(int n) The dfault_f77 method sets default values for each input variable to the minimization algorithm.
void	dogdrv_f77(int n, double[] x, double[] f, double[] g, double[][] a, double[] p, double[] xpls, double[] fpls, Uncmin_methods minclass, double[] sx, double[] stepmx, double[] steptl, double[] dlt, int[] iretcd, boolean[] mxtake, double[] sc, double[] wrk1, double[] wrk2, double[] wrk3) The dogdrv_f77 method finds the next Newton iterate (xpls) by the double dogleg method.
void	dogstp_f77(int n, double[] g, double[][] a, double[] p, double[] sx, double rnwtln, double[] dlt, boolean[] nwtake, boolean[] fstdog, double[] ssd, double[] v, double[] cln, double[] eta, double[] sc, double[] stepmx) The dogstp_f77 method finds the new step by the double dogleg appproach.
void	fireUncminDetailsEvent(java.lang.String message) Show detailed information about teh optimizer.
void	fireUncminStatusEvent(int terminationCode)
void	forslv_f77(int n, double[][] a, double[] x, double[] b) The forslv_f77 method solves Ax = b where A is a lower triangular matrix.
void	fstocd_f77(int n, double[] x, Uncmin_methods minclass, double[] sx, double rnoise, double[] g) The fstocd_f77 method finds a central difference approximation to the gradientAt of the function to be minimized.
void	fstofd_f77(int n, double[] xpls, Uncmin_methods minclass, double[] fpls, double[][] a, double[] sx, double rnoise, double[] fhat) This version of the fstofd_f77 method finds a finite difference approximation to the Hessian.
void	fstofd_f77(int n, double[] xpls, Uncmin_methods minclass, double[] fpls, double[] g, double[] sx, double rnoise) This version of the fstofd_f77 method finds first order finite difference approximations for gradients.
void	grdchk_f77(int n, double[] x, Uncmin_methods minclass, double[] f, double[] g, double[] typsiz, double[] sx, double[] fscale, double rnf, double analtl, double[] gest) The grdchk_f77 method checks the analytic gradientAt supplied by the user.
void	heschk_f77(int n, double[] x, Uncmin_methods minclass, double[] f, double[] g, double[][] a, double[] typsiz, double[] sx, double rnf, double analtl, int[] iagflg, double[] udiag, double[] wrk1, double[] wrk2) The heschk_f77 method checks the analytic Hessian supplied by the user.
void	hookdr_f77(int n, double[] x, double[] f, double[] g, double[][] a, double[] udiag, double[] p, double[] xpls, double[] fpls, Uncmin_methods minclass, double[] sx, double[] stepmx, double[] steptl, double[] dlt, int[] iretcd, boolean[] mxtake, double[] amu, double[] dltp, double[] phi, double[] phip0, double[] sc, double[] xplsp, double[] wrk0, double epsm, int[] itncnt) The hookdr_f77 method finds a next Newton iterate (xpls) by the More-Hebdon technique.
void	hookst_f77(int n, double[] g, double[][] a, double[] udiag, double[] p, double[] sx, double rnwtln, double[] dlt, double[] amu, double[] dltp, double[] phi, double[] phip0, boolean[] fstime, double[] sc, boolean[] nwtake, double[] wrk0, double epsm) The hookst_f77 method finds a new step by the More-Hebdon algorithm.
void	hsnint_f77(int n, double[][] a, double[] sx, int[] method) The hsnint_f77 method provides the initial Hessian when secant updates are being used.
void	lltslv_f77(int n, double[][] a, double[] x, double[] b) The lltslv_f77 method solves Ax = b where A has the form L(L transpose) but only the lower triangular part, L, is stored.
void	lnsrch_f77(int n, double[] x, double[] f, double[] g, double[] p, double[] xpls, double[] fpls, Uncmin_methods minclass, boolean[] mxtake, int[] iretcd, double[] stepmx, double[] steptl, double[] sx) The lnsrch_f77 method finds a next Newton iterate by line search.
void	mvmltl_f77(int n, double[][] a, double[] x, double[] y) The mvmltl_f77 method computes y = Lx where L is a lower triangular matrix stored in A.
void	mvmlts_f77(int n, double[][] a, double[] x, double[] y) The mvmlts_f77 method computes y = Ax where A is a symmetric matrix stored in its lower triangular part.
void	mvmltu_f77(int n, double[][] a, double[] x, double[] y) The mvmltu_f77 method computes Y = (L transpose)X where L is a lower triangular matrix stored in A (L transpose is taken implicitly).
void	optchk_f77(int n, double[] x, double[] typsiz, double[] sx, double[] fscale, double[] gradtl, int[] itnlim, int[] ndigit, double epsm, double[] dlt, int[] method, int[] iexp, int[] iagflg, int[] iahflg, double[] stepmx, int[] msg) The optchk_f77 method checks the input for reasonableness.
void	optdrv_f77(int n, double[] x, Uncmin_methods minclass, double[] typsiz, double[] fscale, int[] method, int[] iexp, int[] msg, int[] ndigit, int[] itnlim, int[] iagflg, int[] iahflg, double[] dlt, double[] gradtl, double[] stepmx, double[] steptl, double[] xpls, double[] fpls, double[] gpls, int[] itrmcd, double[][] a, double[] udiag, double[] g, double[] p, double[] sx, double[] wrk0, double[] wrk1, double[] wrk2, double[] wrk3) The optdrv_f77 method is the driver for the nonlinear optimization problem.
void	optif0_f77(int n, double[] x, Uncmin_methods minclass, double[] xpls, double[] fpls, double[] gpls, int[] itrmcd, double[][] a, double[] udiag) The optif0_f77 method minimizes a smooth nonlinear function of n variables.
void	optif9_f77(int n, double[] x, Uncmin_methods minclass, double[] typsiz, double[] fscale, int[] method, int[] iexp, int[] msg, int[] ndigit, int[] itnlim, int[] iagflg, int[] iahflg, double[] dlt, double[] gradtl, double[] stepmx, double[] steptl, double[] xpls, double[] fpls, double[] gpls, int[] itrmcd, double[][] a, double[] udiag) The optif9_f77 method minimizes a smooth nonlinear function of n variables.
void	optstp_f77(int n, double[] xpls, double[] fpls, double[] gpls, double[] x, int[] itncnt, int[] icscmx, int[] itrmcd, double[] gradtl, double[] steptl, double[] sx, double[] fscale, int[] itnlim, int[] iretcd, boolean[] mxtake, int[] msg) The optstp_f77 method determines whether the algorithm should terminate due to any of the following: 1) problem solved within user tolerance 2) convergence within user tolerance 3) iteration limit reached 4) divergence or too restrictive maximum step (stepmx) suspected Translated by Steve Verrill, May 12, 1998.
void	qraux1_f77(int n, double[][] r, int i) The qraux1_f77 method interchanges rows i,i+1 of the upper Hessenberg matrix r, columns i to n.
void	qraux2_f77(int n, double[][] r, int i, double a, double b) The qraux2_f77 method pre-multiplies r by the Jacobi rotation j(i,i+1,a,b).
void	qrupdt_f77(int n, double[][] a, double[] u, double[] v) The qrupdt_f77 method finds an orthogonal n by n matrix, Q*, and an upper triangular n by n matrix, R*, such that (Q*)(R*) = R+U(V+).
void	removeUncminStatusListener(UncminStatusListener listener)
void	result_f77(int n, double[] x, double[] f, double[] g, double[][] a, double[] p, int[] itncnt, int iflg) The result_f77 method prints information.
void	sclmul_f77(int n, double s, double[] v, double[] z) The sclmul_f77 method multiplies a vector by a scalar.
void	secfac_f77(int n, double[] x, double[] g, double[][] a, double[] xpls, double[] gpls, double epsm, int[] itncnt, double rnf, int[] iagflg, boolean[] noupdt, double[] s, double[] y, double[] u, double[] w) The secfac_f77 method updates the Hessian by the BFGS factored technique.
void	secunf_f77(int n, double[] x, double[] g, double[][] a, double[] udiag, double[] xpls, double[] gpls, double epsm, int[] itncnt, double rnf, int[] iagflg, boolean[] noupdt, double[] s, double[] y, double[] t) The secunf_f77 method updates the Hessian by the BFGS unfactored approach.
void	showDetails(boolean showDetails) Show detailed information about teh optimizer.
void	sndofd_f77(int n, double[] xpls, Uncmin_methods minclass, double[] fpls, double[][] a, double[] sx, double rnoise, double[] stepsz, double[] anbr) The sndofd_f77 method finds second order forward finite difference approximations to the Hessian.
void	tregup_f77(int n, double[] x, double[] f, double[] g, double[][] a, Uncmin_methods minclass, double[] sc, double[] sx, boolean[] nwtake, double[] stepmx, double[] steptl, double[] dlt, int[] iretcd, double[] xplsp, double[] fplsp, double[] xpls, double[] fpls, boolean[] mxtake, int method, double[] udiag) The tregup_f77 method decides whether to accept xpls = x + sc as the next iterate and update the trust region dlt.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Uncmin

public Uncmin()

Method Detail

addUncminStatusListener

public void addUncminStatusListener(UncminStatusListener listener)

removeUncminStatusListener

public void removeUncminStatusListener(UncminStatusListener listener)

fireUncminStatusEvent

public void fireUncminStatusEvent(int terminationCode)

showDetails

public void showDetails(boolean showDetails)

Show detailed information about teh optimizer. This is mainly available for debugging.

fireUncminDetailsEvent

public void fireUncminDetailsEvent(java.lang.String message)

Show detailed information about teh optimizer. This is mainly available for debugging. It could be extended to allow for other listeners if additional processing were needed. The details provided by fireUncminDetailsEvent are extensive and could lead to overflow for large optimization problems. Therefore, better to just show the message when debugging and not save it.

optif0_f77

public final void optif0_f77(int n,
                             double[] x,
                             Uncmin_methods minclass,
                             double[] xpls,
                             double[] fpls,
                             double[] gpls,
                             int[] itrmcd,
                             double[][] a,
                             double[] udiag)
                      throws UncminException

The optif0_f77 method minimizes a smooth nonlinear function of n variables. A method that computes the function value at any point must be supplied. (See Uncmin_methods.java and UncminTest.java.) Derivative values are not required. The optif0_f77 method provides the simplest user access to the UNCMIN minimization routines. Without a recompile, the user has no control over options. For details, see the Schnabel et al reference and the comments in the code. Translated by Steve Verrill, August 4, 1998.

Parameters:

n - The number of arguments of the function to minimize

x - The initial estimate of the minimum point

minclass - A class that implements the Uncmin_methods interface (see the definition in Uncmin_methods.java). See UncminTest_f77.java for an example of such a class. The class must define: 1.) a method, f_to_minimize, to minimize. f_to_minimize must have the form public double f_to_minimize(double x[]) where x is the vector of arguments to the function and the return value is the value of the function evaluated at x. 2.) a method, gradientAt, that has the form public void gradientAt(double x[], double g[]) where g is the gradientAt of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the gradientAt. 3.) a method, hessian, that has the form public void hessian(double x[], double h[][]) where h is the Hessian of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the Hessian. If the user wants Uncmin to check the Hessian, then the hessian method should only fill the lower triangle (and diagonal) of h.

xpls - The final estimate of the minimum point

fpls - The value of f_to_minimize at xpls

gpls - The gradientAt at the local minimum xpls

itrmcd - Termination code ITRMCD = 0: Optimal solution found ITRMCD = 1: Terminated with gradientAt small, xpls is probably optimal ITRMCD = 2: Terminated with stepsize small, xpls is probably optimal ITRMCD = 3: Lower point cannot be found, xpls is probably optimal ITRMCD = 4: Iteration limit (150) exceeded ITRMCD = 5: Too many large steps, function may be unbounded

a - Workspace for the Hessian (or its estimate) and its Cholesky decomposition

udiag - Workspace for the diagonal of the Hessian

Throws:

UncminException

optif9_f77

public final void optif9_f77(int n,
                             double[] x,
                             Uncmin_methods minclass,
                             double[] typsiz,
                             double[] fscale,
                             int[] method,
                             int[] iexp,
                             int[] msg,
                             int[] ndigit,
                             int[] itnlim,
                             int[] iagflg,
                             int[] iahflg,
                             double[] dlt,
                             double[] gradtl,
                             double[] stepmx,
                             double[] steptl,
                             double[] xpls,
                             double[] fpls,
                             double[] gpls,
                             int[] itrmcd,
                             double[][] a,
                             double[] udiag)
                      throws UncminException

The optif9_f77 method minimizes a smooth nonlinear function of n variables. A method that computes the function value at any point must be supplied. (See Uncmin_methods.java and UncminTest.java.) Derivative values are not required. The optif9 method provides complete user access to the UNCMIN minimization routines. The user has full control over options. For details, see the Schnabel et al reference and the comments in the code. Translated by Steve Verrill, August 4, 1998.

Parameters:

n - The number of arguments of the function to minimize

x - The initial estimate of the minimum point

minclass - A class that implements the Uncmin_methods interface (see the definition in Uncmin_methods.java). See UncminTest_f77.java for an example of such a class. The class must define: 1.) a method, f_to_minimize, to minimize. f_to_minimize must have the form public double f_to_minimize(double x[]) where x is the vector of arguments to the function and the return value is the value of the function evaluated at x. 2.) a method, gradientAt, that has the form public void gradientAt(double x[], double g[]) where g is the gradientAt of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the gradientAt. 3.) a method, hessian, that has the form public void hessian(double x[], double h[][]) where h is the Hessian of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the Hessian. If the user wants Uncmin to check the Hessian, then the hessian method should only fill the lower triangle (and diagonal) of h.

typsiz - Typical size for each component of x

fscale - Estimate of the scale of the objective function

method - Algorithm to use to solve the minimization problem = 1 line search = 2 double dogleg = 3 More-Hebdon

iexp - = 1 if the optimization function f_to_minimize is expensive to evaluate, = 0 otherwise. If iexp = 1, then the Hessian will be evaluated by secant update rather than analytically or by finite differences.

msg - Message to inhibit certain automatic checks and output

ndigit - Number of good digits in the minimization function

itnlim - Maximum number of allowable iterations

iagflg - = 0 if an analytic gradientAt is not supplied

iahflg - = 0 if an analytic Hessian is not supplied

dlt - Trust region radius

gradtl - Tolerance at which the gradientAt is considered close enough to zero to terminate the algorithm

stepmx - Maximum allowable step size

steptl - Relative step size at which successive iterates are considered close enough to terminate the algorithm

xpls - The final estimate of the minimum point

fpls - The value of f_to_minimize at xpls

gpls - The gradientAt at the local minimum xpls

itrmcd - Termination code ITRMCD = 0: Optimal solution found ITRMCD = 1: Terminated with gradientAt small, X is probably optimal ITRMCD = 2: Terminated with stepsize small, X is probably optimal ITRMCD = 3: Lower point cannot be found, X is probably optimal ITRMCD = 4: Iteration limit (150) exceeded ITRMCD = 5: Too many large steps, function may be unbounded

a - Workspace for the Hessian (or its estimate) and its Cholesky decomposition

udiag - Workspace for the diagonal of the Hessian

Throws:

UncminException

bakslv_f77

public final void bakslv_f77(int n,
                             double[][] a,
                             double[] x,
                             double[] b)

The bakslv_f77 method solves Ax = b where A is an upper triangular matrix. Note that A is input as a lower triangular matrix and this method takes its transpose implicitly. Translated by Steve Verrill, April 14, 1998.

Parameters:

n - Dimension of the problem

a - n by n lower triangular matrix (preserved)

x - The solution vector

b - The right-hand side vector

chlhsn_f77

public final void chlhsn_f77(int n,
                             double[][] a,
                             double epsm,
                             double[] sx,
                             double[] udiag)

The chlhsn_f77 method finds "THE L(L-TRANSPOSE) [WRITTEN LL+] DECOMPOSITION OF THE PERTURBED MODEL HESSIAN MATRIX A+MU*I(WHERE MU\0 AND I IS THE IDENTITY MATRIX) WHICH IS SAFELY POSITIVE DEFINITE. IF A IS SAFELY POSITIVE DEFINITE UPON ENTRY, THEN MU=0." Translated by Steve Verrill, April 14, 1998.

Parameters:

n - Dimension of the problem

a - On entry: A is the model Hessian (only the lower triangle and diagonal stored) On exit: A contains L of the LL+ decomposition of the perturbed model Hessian in the lower triangle and diagonal, and contains the Hessian in the upper triangle and udiag

epsm - Machine epsilon

sx - Scaling vector for x

udiag - On exit: Contains the diagonal of the Hessian

choldc_f77

public final void choldc_f77(int n,
                             double[][] a,
                             double diagmx,
                             double tol,
                             double[] addmax)

The choldc_f77 method finds "THE PERTURBED L(L-TRANSPOSE) [WRITTEN LL+] DECOMPOSITION OF A+D, WHERE D IS A NON-NEGATIVE DIAGONAL MATRIX ADDED TO A IF NECESSARY TO ALLOW THE CHOLESKY DECOMPOSITION TO CONTINUE." Translated by Steve Verrill, April 15, 1998.

Parameters:

n - Dimension of the problem

a - On entry: matrix for which to find the perturbed Cholesky decomposition On exit: contains L of the LL+ decomposition in lower triangle

diagmx - Maximum diagonal element of "A"

tol - Tolerance

addmax - Maximum amount implicitly added to diagonal of "A" in forming the Cholesky decomposition of A+D

dfault_f77

public final void dfault_f77(int n)

The dfault_f77 method sets default values for each input variable to the minimization algorithm. Translated by Steve Verrill, August 4, 1998.

Parameters:

n - Dimension of the problem // *@param x Initial estimate of the solution (to compute max step size) // *@param typsiz Typical size for each component of x // *@param fscale Estimate of the scale of the minimization function // *@param method Algorithm to use to solve the minimization problem // *@param iexp = 0 if the minimization function is not expensive to evaluate // *@param msg Message to inhibit certain automatic checks and output // *@param ndigit Number of good digits in the minimization function // *@param itnlim Maximum number of allowable iterations // *@param iagflg = 0 if an analytic gradientAt is not supplied // *@param iahflg = 0 if an analytic Hessian is not supplied // *@param dlt Trust region radius // *@param gradtl Tolerance at which the gradientAt is considered close enough // * to zero to terminate the algorithm // *@param stepmx "Value of zero to trip default maximum in optchk" // *@param steptl Tolerance at which successive iterates are considered // * close enough to terminate the algorithm

dogdrv_f77

public final void dogdrv_f77(int n,
                             double[] x,
                             double[] f,
                             double[] g,
                             double[][] a,
                             double[] p,
                             double[] xpls,
                             double[] fpls,
                             Uncmin_methods minclass,
                             double[] sx,
                             double[] stepmx,
                             double[] steptl,
                             double[] dlt,
                             int[] iretcd,
                             boolean[] mxtake,
                             double[] sc,
                             double[] wrk1,
                             double[] wrk2,
                             double[] wrk3)

The dogdrv_f77 method finds the next Newton iterate (xpls) by the double dogleg method. It drives dogstp_f77. Translated by Steve Verrill, April 15, 1998.

Parameters:

n - Dimension of the problem

x - The old iterate

f - Function value at the old iterate

g - Gradient or approximation at the old iterate

a - Cholesky decomposition of Hessian in lower triangular part and diagonal

p - Newton step

xpls - The new iterate

fpls - Function value at the new iterate

minclass - A class that implements the Uncmin_methods interface (see the definition in Uncmin_methods.java). See UncminTest_f77.java for an example of such a class. The class must define: 1.) a method, f_to_minimize, to minimize. f_to_minimize must have the form public double f_to_minimize(double x[]) where x is the vector of arguments to the function and the return value is the value of the function evaluated at x. 2.) a method, gradientAt, that has the form public void gradientAt(double x[], double g[]) where g is the gradientAt of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the gradientAt. 3.) a method, hessian, that has the form public void hessian(double x[], double h[][]) where h is the Hessian of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the Hessian. If the user wants Uncmin to check the Hessian, then the hessian method should only fill the lower triangle (and diagonal) of h.

sx - Scaling vector for x

stepmx - Maximum allowable step size

steptl - Relative step size at which successive iterates are considered close enough to terminate the algorithm

dlt - Trust region radius (value needs to be retained between successive calls)

iretcd - Return code: 0 --- satisfactory xpls found 1 --- failed to find satisfactory xpls sufficently distinct from x

mxtake - Boolean flag indicating that a step of maximum length was used length

sc - Workspace (current step)

wrk1 - Workspace (and place holding argument to tregup)

wrk2 - Workspace

wrk3 - Workspace

dogstp_f77

public final void dogstp_f77(int n,
                             double[] g,
                             double[][] a,
                             double[] p,
                             double[] sx,
                             double rnwtln,
                             double[] dlt,
                             boolean[] nwtake,
                             boolean[] fstdog,
                             double[] ssd,
                             double[] v,
                             double[] cln,
                             double[] eta,
                             double[] sc,
                             double[] stepmx)

The dogstp_f77 method finds the new step by the double dogleg appproach. Translated by Steve Verrill, April 21, 1998.

Parameters:

n - DIMENSION OF PROBLEM

g - GRADIENT AT CURRENT ITERATE, G(X)

a - CHOLESKY DECOMPOSITION OF HESSIAN IN LOWER PART AND DIAGONAL

p - NEWTON STEP

sx - Scaling vector for x

rnwtln - NEWTON STEP LENGTH

dlt - TRUST REGION RADIUS

nwtake - BOOLEAN, = true IF NEWTON STEP TAKEN

fstdog - BOOLEAN, = true IF ON FIRST LEG OF DOGLEG

ssd - WORKSPACE [CAUCHY STEP TO THE MINIMUM OF THE QUADRATIC MODEL IN THE SCALED STEEPEST DESCENT DIRECTION] [RETAIN VALUE BETWEEN SUCCESSIVE CALLS]

v - WORKSPACE [RETAIN VALUE BETWEEN SUCCESSIVE CALLS]

cln - CAUCHY LENGTH [RETAIN VALUE BETWEEN SUCCESSIVE CALLS]

eta - [RETAIN VALUE BETWEEN SUCCESSIVE CALLS]

sc - CURRENT STEP

stepmx - MAXIMUM ALLOWABLE STEP SIZE

forslv_f77

public final void forslv_f77(int n,
                             double[][] a,
                             double[] x,
                             double[] b)

The forslv_f77 method solves Ax = b where A is a lower triangular matrix. Translated by Steve Verrill, April 21, 1998.

Parameters:

n - The dimension of the problem

a - The lower triangular matrix (preserved)

x - The solution vector

b - The right-hand side vector

fstocd_f77

public final void fstocd_f77(int n,
                             double[] x,
                             Uncmin_methods minclass,
                             double[] sx,
                             double rnoise,
                             double[] g)

The fstocd_f77 method finds a central difference approximation to the gradientAt of the function to be minimized. Translated by Steve Verrill, April 21, 1998.

Parameters:

n - The dimension of the problem

x - The point at which the gradientAt is to be approximated

minclass - A class that implements the Uncmin_methods interface (see the definition in Uncmin_methods.java). See UncminTest_f77.java for an example of such a class. The class must define: 1.) a method, f_to_minimize, to minimize. f_to_minimize must have the form public double f_to_minimize(double x[]) where x is the vector of arguments to the function and the return value is the value of the function evaluated at x. 2.) a method, gradientAt, that has the form public void gradientAt(double x[], double g[]) where g is the gradientAt of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the gradientAt. 3.) a method, hessian, that has the form public void hessian(double x[], double h[][]) where h is the Hessian of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the Hessian. If the user wants Uncmin to check the Hessian, then the hessian method should only fill the lower triangle (and diagonal) of h.

sx - Scaling vector for x

rnoise - Relative noise in the function to be minimized

g - A central difference approximation to the gradientAt

fstofd_f77

public final void fstofd_f77(int n,
                             double[] xpls,
                             Uncmin_methods minclass,
                             double[] fpls,
                             double[][] a,
                             double[] sx,
                             double rnoise,
                             double[] fhat)

This version of the fstofd_f77 method finds a finite difference approximation to the Hessian. Translated by Steve Verrill, April 22, 1998.

Parameters:

n - The dimension of the problem

xpls - New iterate

minclass - A class that implements the Uncmin_methods interface (see the definition in Uncmin_methods.java). See UncminTest_f77.java for an example of such a class. The class must define: 1.) a method, f_to_minimize, to minimize. f_to_minimize must have the form public double f_to_minimize(double x[]) where x is the vector of arguments to the function and the return value is the value of the function evaluated at x. 2.) a method, gradientAt, that has the form public void gradientAt(double x[], double g[]) where g is the gradientAt of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the gradientAt. 3.) a method, hessian, that has the form public void hessian(double x[], double h[][]) where h is the Hessian of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the Hessian. If the user wants Uncmin to check the Hessian, then the hessian method should only fill the lower triangle (and diagonal) of h.

fpls - fpls[1] -- fpls[n] contains the gradientAt of the function to minimize

a - "FINITE DIFFERENCE APPROXIMATION. ONLY LOWER TRIANGULAR MATRIX AND DIAGONAL ARE RETURNED"

sx - Scaling vector for x

rnoise - Relative noise in the function to be minimized

fhat - Workspace

fstofd_f77

public final void fstofd_f77(int n,
                             double[] xpls,
                             Uncmin_methods minclass,
                             double[] fpls,
                             double[] g,
                             double[] sx,
                             double rnoise)

This version of the fstofd_f77 method finds first order finite difference approximations for gradients. Translated by Steve Verrill, April 22, 1998.

Parameters:

n - The dimension of the problem

xpls - New iterate

minclass - A class that implements the Uncmin_methods interface (see the definition in Uncmin_methods.java). See UncminTest_f77.java for an example of such a class. The class must define: 1.) a method, f_to_minimize, to minimize. f_to_minimize must have the form public double f_to_minimize(double x[]) where x is the vector of arguments to the function and the return value is the value of the function evaluated at x. 2.) a method, gradientAt, that has the form public void gradientAt(double x[], double g[]) where g is the gradientAt of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the gradientAt. 3.) a method, hessian, that has the form public void hessian(double x[], double h[][]) where h is the Hessian of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the Hessian. If the user wants Uncmin to check the Hessian, then the hessian method should only fill the lower triangle (and diagonal) of h.

fpls - fpls contains the value of the function to minimize at the new iterate

g - finite difference approximation to the gradientAt

sx - Scaling vector for x

rnoise - Relative noise in the function to be minimized

grdchk_f77

public final void grdchk_f77(int n,
                             double[] x,
                             Uncmin_methods minclass,
                             double[] f,
                             double[] g,
                             double[] typsiz,
                             double[] sx,
                             double[] fscale,
                             double rnf,
                             double analtl,
                             double[] gest)
                      throws UncminException

The grdchk_f77 method checks the analytic gradientAt supplied by the user. Translated by Steve Verrill, April 22, 1998.

Parameters:

n - The dimension of the problem

x - The location at which the gradientAt is to be checked

minclass - A class that implements the Uncmin_methods interface (see the definition in Uncmin_methods.java). See UncminTest_f77.java for an example of such a class. The class must define: 1.) a method, f_to_minimize, to minimize. f_to_minimize must have the form public double f_to_minimize(double x[]) where x is the vector of arguments to the function and the return value is the value of the function evaluated at x. 2.) a method, gradientAt, that has the form public void gradientAt(double x[], double g[]) where g is the gradientAt of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the gradientAt. 3.) a method, hessian, that has the form public void hessian(double x[], double h[][]) where h is the Hessian of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the Hessian. If the user wants Uncmin to check the Hessian, then the hessian method should only fill the lower triangle (and diagonal) of h.

f - Function value

g - Analytic gradientAt

typsiz - Typical size for each component of x

sx - Scaling vector for x: sx[i] = 1.0/typsiz[i]

fscale - Estimate of scale of f_to_minimize

rnf - Relative noise in f_to_minimize

analtl - Tolerance for comparison of estimated and analytical gradients

gest - Finite difference gradientAt

Throws:

UncminException

heschk_f77

public final void heschk_f77(int n,
                             double[] x,
                             Uncmin_methods minclass,
                             double[] f,
                             double[] g,
                             double[][] a,
                             double[] typsiz,
                             double[] sx,
                             double rnf,
                             double analtl,
                             int[] iagflg,
                             double[] udiag,
                             double[] wrk1,
                             double[] wrk2)
                      throws UncminException

The heschk_f77 method checks the analytic Hessian supplied by the user. Translated by Steve Verrill, April 23, 1998.

Parameters:

n - The dimension of the problem

x - The location at which the Hessian is to be checked

minclass - A class that implements the Uncmin_methods interface (see the definition in Uncmin_methods.java). See UncminTest_f77.java for an example of such a class. The class must define: 1.) a method, f_to_minimize, to minimize. f_to_minimize must have the form public double f_to_minimize(double x[]) where x is the vector of arguments to the function and the return value is the value of the function evaluated at x. 2.) a method, gradientAt, that has the form public void gradientAt(double x[], double g[]) where g is the gradientAt of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the gradientAt. 3.) a method, hessian, that has the form public void hessian(double x[], double h[][]) where h is the Hessian of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the Hessian. If the user wants Uncmin to check the Hessian, then the hessian method should only fill the lower triangle (and diagonal) of h.

f - Function value

g - Gradient

a - On exit: Hessian in lower triangle

typsiz - Typical size for each component of x

sx - Scaling vector for x: sx[i] = 1.0/typsiz[i]

rnf - Relative noise in f_to_minimize

analtl - Tolerance for comparison of estimated and analytic gradients

iagflg - = 1 if an analytic gradientAt is supplied

udiag - Workspace

wrk1 - Workspace

wrk2 - Workspace

Throws:

UncminException

hookdr_f77

public final void hookdr_f77(int n,
                             double[] x,
                             double[] f,
                             double[] g,
                             double[][] a,
                             double[] udiag,
                             double[] p,
                             double[] xpls,
                             double[] fpls,
                             Uncmin_methods minclass,
                             double[] sx,
                             double[] stepmx,
                             double[] steptl,
                             double[] dlt,
                             int[] iretcd,
                             boolean[] mxtake,
                             double[] amu,
                             double[] dltp,
                             double[] phi,
                             double[] phip0,
                             double[] sc,
                             double[] xplsp,
                             double[] wrk0,
                             double epsm,
                             int[] itncnt)

The hookdr_f77 method finds a next Newton iterate (xpls) by the More-Hebdon technique. It drives hookst_f77. Translated by Steve Verrill, April 23, 1998.

Parameters:

n - The dimension of the problem

x - The old iterate

f - The function value at the old iterate

g - Gradient or approximation at old iterate

a - Cholesky decomposition of Hessian in lower triangle and diagonal. Hessian in upper triangle and udiag.

udiag - Diagonal of Hessian in a

p - Newton step

xpls - New iterate

fpls - Function value at the new iterate

minclass - A class that implements the Uncmin_methods interface (see the definition in Uncmin_methods.java). See UncminTest_f77.java for an example of such a class. The class must define: 1.) a method, f_to_minimize, to minimize. f_to_minimize must have the form public double f_to_minimize(double x[]) where x is the vector of arguments to the function and the return value is the value of the function evaluated at x. 2.) a method, gradientAt, that has the form public void gradientAt(double x[], double g[]) where g is the gradientAt of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the gradientAt. 3.) a method, hessian, that has the form public void hessian(double x[], double h[][]) where h is the Hessian of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the Hessian. If the user wants Uncmin to check the Hessian, then the hessian method should only fill the lower triangle (and diagonal) of h.

sx - Scaling vector for x

stepmx - Maximum allowable step size

steptl - Relative step size at which consecutive iterates are considered close enough to terminate the algorithm

dlt - Trust region radius

iretcd - Return code = 0 satisfactory xpls found = 1 failed to find satisfactory xpls sufficiently distinct from x

mxtake - Boolean flag indicating step of maximum length used

amu - [Retain value between successive calls]

dltp - [Retain value between successive calls]

phi - [Retain value between successive calls]

phip0 - [Retain value between successive calls]

sc - Workspace

xplsp - Workspace

wrk0 - Workspace

epsm - Machine epsilon

itncnt - Iteration count

hookst_f77

public final void hookst_f77(int n,
                             double[] g,
                             double[][] a,
                             double[] udiag,
                             double[] p,
                             double[] sx,
                             double rnwtln,
                             double[] dlt,
                             double[] amu,
                             double[] dltp,
                             double[] phi,
                             double[] phip0,
                             boolean[] fstime,
                             double[] sc,
                             boolean[] nwtake,
                             double[] wrk0,
                             double epsm)

The hookst_f77 method finds a new step by the More-Hebdon algorithm. It is driven by hookdr_f77. Translated by Steve Verrill, April 24, 1998.

Parameters:

n - The dimension of the problem

g - The gradientAt at the current iterate

a - Cholesky decomposition of the Hessian in the lower triangle and diagonal. Hessian or approximation in upper triangle (and udiag).

p - Newton step

sx - Scaling vector for x

rnwtln - Newton step length

dlt - Trust region radius

amu - Retain value between successive calls

dltp - Trust region radius at last exit from this routine

phi - Retain value between successive calls

phip0 - Retain value between successive calls

fstime - "= true if first entry to this routine during the k-th iteration"

sc - Current step

nwtake - = true if Newton step taken

wrk0 - Workspace

epsm - Machine epsilon

hsnint_f77

public final void hsnint_f77(int n,
                             double[][] a,
                             double[] sx,
                             int[] method)

The hsnint_f77 method provides the initial Hessian when secant updates are being used. Translated by Steve Verrill, April 27, 1998.

Parameters:

n - The dimension of the problem

a - Initial Hessian (lower triangular matrix)

sx - Scaling vector for x

method - Algorithm to use to solve the minimization problem 1,2 --- factored secant method 3 --- unfactored secant method

lltslv_f77

public final void lltslv_f77(int n,
                             double[][] a,
                             double[] x,
                             double[] b)

The lltslv_f77 method solves Ax = b where A has the form L(L transpose) but only the lower triangular part, L, is stored. Translated by Steve Verrill, April 27, 1998.

Parameters:

n - The dimension of the problem

a - Matrix of form L(L transpose). On return a is unchanged.

x - The solution vector

b - The right-hand side vector

lnsrch_f77

public final void lnsrch_f77(int n,
                             double[] x,
                             double[] f,
                             double[] g,
                             double[] p,
                             double[] xpls,
                             double[] fpls,
                             Uncmin_methods minclass,
                             boolean[] mxtake,
                             int[] iretcd,
                             double[] stepmx,
                             double[] steptl,
                             double[] sx)

The lnsrch_f77 method finds a next Newton iterate by line search. Translated by Steve Verrill, May 15, 1998.

Parameters:

n - The dimension of the problem

x - Old iterate

f - Function value at old iterate

g - Gradient or approximation at old iterate

p - Non-zero Newton step

xpls - New iterate

fpls - Function value at new iterate

minclass - A class that implements the Uncmin_methods interface (see the definition in Uncmin_methods.java). See UncminTest_f77.java for an example of such a class. The class must define: 1.) a method, f_to_minimize, to minimize. f_to_minimize must have the form public double f_to_minimize(double x[]) where x is the vector of arguments to the function and the return value is the value of the function evaluated at x. 2.) a method, gradientAt, that has the form public void gradientAt(double x[], double g[]) where g is the gradientAt of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the gradientAt. 3.) a method, hessian, that has the form public void hessian(double x[], double h[][]) where h is the Hessian of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the Hessian. If the user wants Uncmin to check the Hessian, then the hessian method should only fill the lower triangle (and diagonal) of h.

mxtake - Boolean flag indicating whether the step of maximum length was used

iretcd - Return code

stepmx - Maximum allowable step size

steptl - Relative step size at which successive iterates are considered close enough to terminate the algorithm

sx - Scaling vector for x

mvmltl_f77

public final void mvmltl_f77(int n,
                             double[][] a,
                             double[] x,
                             double[] y)

The mvmltl_f77 method computes y = Lx where L is a lower triangular matrix stored in A. Translated by Steve Verrill, April 27, 1998.

Parameters:

n - The dimension of the problem

a - Lower triangular matrix

x - Operand vector

y - Result vector

mvmlts_f77

public final void mvmlts_f77(int n,
                             double[][] a,
                             double[] x,
                             double[] y)

The mvmlts_f77 method computes y = Ax where A is a symmetric matrix stored in its lower triangular part. Translated by Steve Verrill, April 27, 1998.

Parameters:

n - The dimension of the problem

a - The symmetric matrix

x - Operand vector

y - Result vector

mvmltu_f77

public final void mvmltu_f77(int n,
                             double[][] a,
                             double[] x,
                             double[] y)

The mvmltu_f77 method computes Y = (L transpose)X where L is a lower triangular matrix stored in A (L transpose is taken implicitly). Translated by Steve Verrill, April 27, 1998.

Parameters:

n - The dimension of the problem

a - The lower triangular matrix

x - Operand vector

y - Result vector

optchk_f77

public final void optchk_f77(int n,
                             double[] x,
                             double[] typsiz,
                             double[] sx,
                             double[] fscale,
                             double[] gradtl,
                             int[] itnlim,
                             int[] ndigit,
                             double epsm,
                             double[] dlt,
                             int[] method,
                             int[] iexp,
                             int[] iagflg,
                             int[] iahflg,
                             double[] stepmx,
                             int[] msg)
                      throws UncminException

The optchk_f77 method checks the input for reasonableness. Translated by Steve Verrill, May 12, 1998.

Parameters:

n - The dimension of the problem

x - On entry, estimate of the root of f_to_minimize

typsiz - Typical size of each component of x

sx - Scaling vector for x

fscale - Estimate of scale of objective function

gradtl - Tolerance at which the gradientAt is considered close enough to zero to terminate the algorithm

itnlim - Maximum number of allowable iterations

ndigit - Number of good digits in the optimization function

epsm - Machine epsilon

dlt - Trust region radius

method - Algorithm indicator

iexp - Expense flag

iagflg - = 1 if an analytic gradientAt is supplied

iahflg - = 1 if an analytic Hessian is supplied

stepmx - Maximum step size

msg - Message and error code

Throws:

UncminException

optdrv_f77

public final void optdrv_f77(int n,
                             double[] x,
                             Uncmin_methods minclass,
                             double[] typsiz,
                             double[] fscale,
                             int[] method,
                             int[] iexp,
                             int[] msg,
                             int[] ndigit,
                             int[] itnlim,
                             int[] iagflg,
                             int[] iahflg,
                             double[] dlt,
                             double[] gradtl,
                             double[] stepmx,
                             double[] steptl,
                             double[] xpls,
                             double[] fpls,
                             double[] gpls,
                             int[] itrmcd,
                             double[][] a,
                             double[] udiag,
                             double[] g,
                             double[] p,
                             double[] sx,
                             double[] wrk0,
                             double[] wrk1,
                             double[] wrk2,
                             double[] wrk3)
                      throws UncminException

The optdrv_f77 method is the driver for the nonlinear optimization problem. Translated by Steve Verrill, May 18, 1998.

Parameters:

n - The dimension of the problem

x - On entry, estimate of the location of a minimum of f_to_minimize

minclass - A class that implements the Uncmin_methods interface (see the definition in Uncmin_methods.java). See UncminTest_f77.java for an example of such a class. The class must define: 1.) a method, f_to_minimize, to minimize. f_to_minimize must have the form public double f_to_minimize(double x[]) where x is the vector of arguments to the function and the return value is the value of the function evaluated at x. 2.) a method, gradientAt, that has the form public void gradientAt(double x[], double g[]) where g is the gradientAt of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the gradientAt. 3.) a method, hessian, that has the form public void hessian(double x[], double h[][]) where h is the Hessian of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the Hessian. If the user wants Uncmin to check the Hessian, then the hessian method should only fill the lower triangle (and diagonal) of h.

typsiz - Typical size of each component of x

fscale - Estimate of scale of objective function

method - Algorithm indicator 1 -- line search 2 -- double dogleg 3 -- More-Hebdon

iexp - Expense flag. 1 -- optimization function, f_to_minimize, is expensive to evaluate 0 -- otherwise If iexp = 1, the Hessian will be evaluated by secant update rather than analytically or by finite differences.

msg - On input: (> 0) message to inhibit certain automatic checks On output: (< 0) error code (= 0, no error)

ndigit - Number of good digits in the optimization function

itnlim - Maximum number of allowable iterations

iagflg - = 1 if an analytic gradientAt is supplied

iahflg - = 1 if an analytic Hessian is supplied

dlt - Trust region radius

gradtl - Tolerance at which the gradientAt is considered close enough to zero to terminate the algorithm

stepmx - Maximum step size

steptl - Relative step size at which successive iterates are considered close enough to terminate the algorithm

xpls - On exit: xpls is a local minimum

fpls - On exit: function value at xpls

gpls - On exit: gradientAt at xpls

itrmcd - Termination code

a - workspace for Hessian (or its approximation) and its Cholesky decomposition

udiag - workspace (for diagonal of Hessian)

g - workspace (for gradientAt at current iterate)

p - workspace for step

sx - workspace (for scaling vector)

wrk0 - workspace

wrk1 - workspace

wrk2 - workspace

wrk3 - workspace

Throws:

UncminException

optstp_f77

public final void optstp_f77(int n,
                             double[] xpls,
                             double[] fpls,
                             double[] gpls,
                             double[] x,
                             int[] itncnt,
                             int[] icscmx,
                             int[] itrmcd,
                             double[] gradtl,
                             double[] steptl,
                             double[] sx,
                             double[] fscale,
                             int[] itnlim,
                             int[] iretcd,
                             boolean[] mxtake,
                             int[] msg)

The optstp_f77 method determines whether the algorithm should terminate due to any of the following: 1) problem solved within user tolerance 2) convergence within user tolerance 3) iteration limit reached 4) divergence or too restrictive maximum step (stepmx) suspected Translated by Steve Verrill, May 12, 1998.

Parameters:

n - The dimension of the problem

xpls - New iterate

fpls - Function value at new iterate

gpls - Gradient or approximation at new iterate

x - Old iterate

itncnt - Current iteration

icscmx - Number of consecutive steps >= stepmx (retain between successive calls)

itrmcd - Termination code

gradtl - Tolerance at which the relative gradientAt is considered close enough to zero to terminate the algorithm

steptl - Relative step size at which successive iterates are considered close enough to terminate the algorithm

sx - Scaling vector for x

fscale - Estimate of the scale of the objective function

itnlim - Maximum number of allowable iterations

iretcd - Return code

mxtake - Boolean flag indicating step of maximum length was used

msg - If msg includes a term 8, suppress output

qraux1_f77

public final void qraux1_f77(int n,
                             double[][] r,
                             int i)

The qraux1_f77 method interchanges rows i,i+1 of the upper Hessenberg matrix r, columns i to n. Translated by Steve Verrill, April 29, 1998.

Parameters:

n - The dimension of the matrix

r - Upper Hessenberg matrix

i - Index of row to interchange (i < n)

qraux2_f77

public final void qraux2_f77(int n,
                             double[][] r,
                             int i,
                             double a,
                             double b)

The qraux2_f77 method pre-multiplies r by the Jacobi rotation j(i,i+1,a,b). Translated by Steve Verrill, April 29, 1998.

Parameters:

n - The dimension of the matrix

r - Upper Hessenberg matrix

i - Index of row

a - scalar

b - scalar

qrupdt_f77

public final void qrupdt_f77(int n,
                             double[][] a,
                             double[] u,
                             double[] v)

The qrupdt_f77 method finds an orthogonal n by n matrix, Q*, and an upper triangular n by n matrix, R*, such that (Q*)(R*) = R+U(V+). Translated by Steve Verrill, May 11, 1998.

Parameters:

n - The dimension of the problem

a - On input: contains R On output: contains R*

u - Vector

v - Vector

result_f77

public final void result_f77(int n,
                             double[] x,
                             double[] f,
                             double[] g,
                             double[][] a,
                             double[] p,
                             int[] itncnt,
                             int iflg)

The result_f77 method prints information. Translated by Steve Verrill, May 11, 1998.

Parameters:

n - The dimension of the problem

x - Estimate of the location of a minimum at iteration k

f - function value at x

g - gradientAt at x

a - Hessian at x

p - Step taken

itncnt - Iteration number (k)

iflg - Flag controlling the information to print

sclmul_f77

public final void sclmul_f77(int n,
                             double s,
                             double[] v,
                             double[] z)

The sclmul_f77 method multiplies a vector by a scalar. Translated by Steve Verrill, May 8, 1998.

Parameters:

n - The dimension of the problem

s - The scalar

v - Operand vector

z - Result vector

secfac_f77

public final void secfac_f77(int n,
                             double[] x,
                             double[] g,
                             double[][] a,
                             double[] xpls,
                             double[] gpls,
                             double epsm,
                             int[] itncnt,
                             double rnf,
                             int[] iagflg,
                             boolean[] noupdt,
                             double[] s,
                             double[] y,
                             double[] u,
                             double[] w)

The secfac_f77 method updates the Hessian by the BFGS factored technique. Translated by Steve Verrill, May 14, 1998.

Parameters:

n - The dimension of the problem

x - Old iterate

g - Gradient or approximation at the old iterate

a - On entry: Cholesky decomposition of Hessian in lower triangle and diagonal On exit: Updated Cholesky decomposition of Hessian in lower triangle and diagonal

xpls - New iterate

gpls - Gradient or approximation at the new iterate

epsm - Machine epsilon

itncnt - Iteration count

rnf - Relative noise in optimization function f_to_minimize

iagflg - 1 if an analytic gradientAt is supplied, 0 otherwise

noupdt - Boolean: no update yet (retain value between successive calls)

s - Workspace

y - Workspace

u - Workspace

w - Workspace

secunf_f77

public final void secunf_f77(int n,
                             double[] x,
                             double[] g,
                             double[][] a,
                             double[] udiag,
                             double[] xpls,
                             double[] gpls,
                             double epsm,
                             int[] itncnt,
                             double rnf,
                             int[] iagflg,
                             boolean[] noupdt,
                             double[] s,
                             double[] y,
                             double[] t)

The secunf_f77 method updates the Hessian by the BFGS unfactored approach. Translated by Steve Verrill, May 8, 1998.

Parameters:

n - The dimension of the problem

x - The old iterate

g - The gradientAt or an approximation at the old iterate

a - On entry: Approximate Hessian at the old iterate in the upper triangular part (and udiag) On exit: Updated approximate Hessian at the new iterate in the lower triangular part and diagonal

udiag - On entry: Diagonal of Hessian

xpls - New iterate

gpls - Gradient or approximation at the new iterate

epsm - Machine epsilon

itncnt - Iteration count

rnf - Relative noise in the optimization function, f_to_minimize

iagflg - = 1 if an analytic gradientAt is supplied, = 0 otherwise

noupdt - Boolean: no update yet (retain value between calls)

s - workspace

y - workspace

t - workspace

sndofd_f77

public final void sndofd_f77(int n,
                             double[] xpls,
                             Uncmin_methods minclass,
                             double[] fpls,
                             double[][] a,
                             double[] sx,
                             double rnoise,
                             double[] stepsz,
                             double[] anbr)

The sndofd_f77 method finds second order forward finite difference approximations to the Hessian. For optimization use this method to estimate the Hessian of the optimization function if no analytical user function has been supplied for either the gradientAt or the Hessian, and the optimization function is inexpensive to evaluate. Translated by Steve Verrill, May 8, 1998.

Parameters:

n - The dimension of the problem

xpls - New iterate

minclass - A class that implements the Uncmin_methods interface (see the definition in Uncmin_methods.java). See UncminTest_f77.java for an example of such a class. The class must define: 1.) a method, f_to_minimize, to minimize. f_to_minimize must have the form public double f_to_minimize(double x[]) where x is the vector of arguments to the function and the return value is the value of the function evaluated at x. 2.) a method, gradientAt, that has the form public void gradientAt(double x[], double g[]) where g is the gradientAt of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the gradientAt. 3.) a method, hessian, that has the form public void hessian(double x[], double h[][]) where h is the Hessian of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the Hessian. If the user wants Uncmin to check the Hessian, then the hessian method should only fill the lower triangle (and diagonal) of h.

fpls - Function value at the new iterate

a - "FINITE DIFFERENCE APPROXIMATION TO HESSIAN. ONLY LOWER TRIANGULAR MATRIX AND DIAGONAL ARE RETURNED"

sx - Scaling vector for x

rnoise - Relative noise in the function to be minimized

stepsz - Workspace (stepsize in i-th component direction)

anbr - Workspace (neighbor in i-th direction)

tregup_f77

public final void tregup_f77(int n,
                             double[] x,
                             double[] f,
                             double[] g,
                             double[][] a,
                             Uncmin_methods minclass,
                             double[] sc,
                             double[] sx,
                             boolean[] nwtake,
                             double[] stepmx,
                             double[] steptl,
                             double[] dlt,
                             int[] iretcd,
                             double[] xplsp,
                             double[] fplsp,
                             double[] xpls,
                             double[] fpls,
                             boolean[] mxtake,
                             int method,
                             double[] udiag)

The tregup_f77 method decides whether to accept xpls = x + sc as the next iterate and update the trust region dlt. Translated by Steve Verrill, May 11, 1998.

Parameters:

n - The dimension of the problem

x - Old iterate

f - Function value at old iterate

g - Gradient or approximation at old iterate

a - Cholesky decomposition of Hessian in lower triangular part and diagonal. Hessian or approximation in upper triangular part.

minclass - A class that implements the Uncmin_methods interface (see the definition in Uncmin_methods.java). See UncminTest_f77.java for an example of such a class. The class must define: 1.) a method, f_to_minimize, to minimize. f_to_minimize must have the form public double f_to_minimize(double x[]) where x is the vector of arguments to the function and the return value is the value of the function evaluated at x. 2.) a method, gradientAt, that has the form public void gradientAt(double x[], double g[]) where g is the gradientAt of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the gradientAt. 3.) a method, hessian, that has the form public void hessian(double x[], double h[][]) where h is the Hessian of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the Hessian. If the user wants Uncmin to check the Hessian, then the hessian method should only fill the lower triangle (and diagonal) of h.

sc - Current step

sx - Scaling vector for x

nwtake - Boolean, = true if Newton step taken

stepmx - Maximum allowable step size

steptl - Relative step size at which successive iterates are considered close enough to terminate the algorithm

dlt - Trust region radius

iretcd - Return code = 0 xpls accepted as next iterate, dlt is the trust region radius for the next iteration = 1 xpls unsatisfactory but accepted as next iterate because xpls - x is less than the smallest allowable step length = 2 f(xpls) too large. Continue current iteration with new reduced dlt. = 3 f(xpls) sufficiently small, but quadratic model predicts f(xpls) sufficiently well to continue current iteration with new doubled dlt.

xplsp - Workspace (value needs to be retained between successive calls of k-th global step)

fplsp - Retain between successive calls

xpls - New iterate

fpls - Function value at new iterate

mxtake - Boolean flag indicating step of maximum length used

method - Algorithm to use to solve minimization problem = 1 Line search = 2 Double dogleg = 3 More-Hebdon

udiag - Diagonal of Hessian in a