NAG Library Chapter Introduction

E04 – Minimizing or Maximizing a Function

An optimization problem involves minimizing a function (called the objective function) of several variables, possibly subject to restrictions on the values of the variables defined by a set of constraint functions. Most routines in the Library are concerned with function minimization only, since the problem of maximizing a given objective function F(x) is equivalent to minimizing -Fx. Some routines allow you to specify whether you are solving a minimization or maximization problem, carrying out the required transformation of the objective function in the latter case.

In general routines in this chapter find a local minimum of a function f, that is a point x* s.t. for all x near x* fx≥fx*.

The solution of optimization problems by a single, all-purpose, method is cumbersome and inefficient. Optimization problems are therefore classified into particular categories, where each category is defined by the properties of the objective and constraint functions, as illustrated by some examples below. For instance, a specific problem category involves the minimization of a nonlinear objective function subject to bounds on the variables. In the following sections we define the particular categories of problems that can be solved by routines contained in this chapter. Not every category is given special treatment in the current version of the Library; however, the long-term objective is to provide a comprehensive set of routines to solve problems in all such categories.

In unconstrained minimization problems there are no constraints on the variables. The problem can be stated mathematically as follows: where x∈Rn, that is, x = x1,x2,…,xnT .

Special consideration is given to the problem for which the function to be minimized can be expressed as a sum of squared functions. The least squares problem can be stated mathematically as follows: where the ith element of the m-vector f is the function fix.

These problems differ from the unconstrained problem in that at least one of the variables is subject to a simple bound (or restriction) on its value, e.g., x5≤10, but no constraints of a more general form are present.

The problem can be stated mathematically as follows: subject to li≤xi≤ui, for i=1,2,…,n.

This format assumes that upper and lower bounds exist on all the variables. By conceptually allowing ui=+∞ and li=-∞ all the variables need not be restricted.

A general linear constraint is defined as a constraint function that is linear in more than one of the variables, e.g., 3x1+2x2≥4. The various types of linear constraint are reflected in the following mathematical statement of the problem: subject to the where each ai is a vector of length n; bi, sj and tj are constant scalars; and any of the categories may be empty.

Although the bounds on xi could be included in the definition of general linear constraints, we prefer to distinguish between them for reasons of computational efficiency.

A problem is included in this category if at least one constraint function is nonlinear, e.g., x12+x3+x4-2≥0. The mathematical statement of the problem is identical to that for the linearly-constrained case, except for the addition of the following constraints: where each ci is a nonlinear function; vj and wj are constant scalars; and any category may be empty. Note that we do not include a separate category for constraints of the form cix≤0, since this is equivalent to -cix≥0.

Although the general linear constraints could be included in the definition of nonlinear constraints, again we prefer to distinguish between them for reasons of computational efficiency.

Sometimes a problem may have two or more objective functions which are to be optimized at the same time. Such problems are called multi-object, multi-criteria or multi-attribute optimization. If the constraints are linear and the objectives are all linear then the terminology ‘goal programming’ is also used.

The matrix of second partial derivatives of a function is termed its Hessian matrix. The Hessian matrix of Fx is denoted by Gx, and its i,jth element is given by ∂2Fx/∂xi∂xj. If Fx has continuous second derivatives, then Gx must be positive semidefinite at any unconstrained minimum of F.

In nonlinear least squares problems, the matrix of first partial derivatives of the vector-valued function fx is termed the Jacobian matrix of fx and its i,jth component is ∂fi/∂xj.

All nonlinear functions will be assumed to have continuous second derivatives in the neighbourhood of the solution.

The following conditions are sufficient for the point x* to be an unconstrained local minimum of Fx:

(i)	gx*=0; and
(ii)	Gx* is positive definite,

where g denotes the Euclidean length of g.

At the solution of a bounds-constrained problem, variables which are not on their bounds are termed free variables. If it is known in advance which variables are on their bounds at the solution, the problem can be solved as an unconstrained problem in just the free variables; thus, the sufficient conditions for a solution are similar to those for the unconstrained case, applied only to the free variables.

Sufficient conditions for a feasible point x* to be the solution of a bounds-constrained problem are as follows:

(i)	g-x*=0; and
(ii)	G-x* is positive definite; and
(iii)	gjx*<0,xj=uj; gjx*>0,xj=lj,

where g-x is the gradient of Fx with respect to the free variables, and G-x is the Hessian matrix of Fx with respect to the free variables. The extra condition (iii) ensures that Fx cannot be reduced by moving off one or more of the bounds.

For the sake of simplicity, the following description does not include a specific treatment of bounds or range constraints, since the results for general linear inequality constraints can be applied directly to these cases.

At a solution x*, of a linearly-constrained problem, the constraints which hold as equalities are called the active or binding constraints. Assume that there are t active constraints at the solution x*, and let A^ denote the matrix whose columns are the columns of A corresponding to the active constraints, with b^ the vector similarly obtained from b; then The matrix Z is defined as an n×n-t matrix satisfying: The columns of Z form an orthogonal basis for the set of vectors orthogonal to the columns of A^.

Define

• gZx=ZTgx, the projected gradient vector of Fx;
• GZx=ZTGxZ, the projected Hessian matrix of Fx.

At the solution of a linearly-constrained problem, the projected gradient vector must be zero, which implies that the gradient vector gx* can be written as a linear combination of the columns of A^, i.e., gx*=∑i=1tλi*a^i=A^λ*. The scalar λi* is defined as the Lagrange multiplier corresponding to the ith active constraint. A simple interpretation of the ith Lagrange multiplier is that it gives the gradient of Fx along the ith active constraint normal; a convenient definition of the Lagrange multiplier vector (although not a recommended method for computation) is: Sufficient conditions for x* to be the solution of a linearly-constrained problem are:

(i)	x* is feasible, and A^Tx*=b^; and
(ii)	gZx*=0, or equivalently, gx*=A^λ*; and
(iii)	GZx* is positive definite; and
(iv)	λi*>0 if λi* corresponds to a constraint a^iT x* ≥ b^i ; λi*<0 if λi* corresponds to a constraint a^iT x* ≤ b^i . The sign of λi* is immaterial for equality constraints, which by definition are always active.

For nonlinearly-constrained problems, much of the terminology is defined exactly as in the linearly-constrained case. The set of active constraints at x again means the set of constraints that hold as equalities at x, with corresponding definitions of c^ and A^: the vector c^x contains the active constraint functions, and the columns of A^x are the gradient vectors of the active constraints. As before, Z is defined in terms of A^x as a matrix such that: where the dependence on x has been suppressed for compactness.

The projected gradient vector gZx is the vector ZTgx. At the solution x* of a nonlinearly-constrained problem, the projected gradient must be zero, which implies the existence of Lagrange multipliers corresponding to the active constraints, i.e., gx*=A^x*λ*.

The Lagrangian function is given by: We define gLx as the gradient of the Lagrangian function; GLx as its Hessian matrix, and G^Lx as its projected Hessian matrix, i.e., G^L=ZTGLZ.

Sufficient conditions for x* to be the solution of a nonlinearly-constrained problem are:

(i)	x* is feasible, and c^x*=0; and
(ii)	gZx*=0, or, equivalently, gx*=A^x*λ*; and
(iii)	G^Lx* is positive definite; and
(iv)	λi*>0 if λi* corresponds to a constraint of the form c^i≥0. The sign of λi* is immaterial for equality constraints, which by definition are always active.

Note that condition (ii) implies that the projected gradient of the Lagrangian function must also be zero at x*, since the application of ZT annihilates the matrix A^x*.

The distinctions among methods arise primarily from the need to use varying levels of information about derivatives of Fx in defining the search direction. We describe three basic approaches to unconstrained problems, which may be extended to other problem categories. Since a full description of the methods would fill several volumes, the discussion here can do little more than allude to the processes involved, and direct you to other sources for a full explanation.

(a)	Newton-type Methods (Modified Newton Methods) Newton-type methods use the Hessian matrix Gx k , or a finite difference approximation to Gx k , to define the search direction. The routines in the Library either require a subroutine that computes the elements of Gx k  directly, or they approximate Gx k  by finite differences. Newton-type methods are the most powerful methods available for general problems and will find the minimum of a quadratic function in one iteration. See Sections 4.4 and 4.5.1 of Gill et al. (1981).
(b)	Quasi-Newton Methods Quasi-Newton methods approximate the Hessian Gxk by a matrix Bk which is modified at each iteration to include information obtained about the curvature of F along the current search direction pk. Although not as robust as Newton-type methods, quasi-Newton methods can be more efficient because Gxk is not computed directly, or approximated by finite differences. Quasi-Newton methods minimize a quadratic function in n iterations, where n is the number of variables. See Section 4.5.2 of Gill et al. (1981).
(c)	Conjugate-gradient Methods Unlike Newton-type and quasi-Newton methods, conjugate-gradient methods do not require the storage of an n by n matrix and so are ideally suited to solve large problems. Conjugate-gradient type methods are not usually as reliable or efficient as Newton-type, or quasi-Newton methods. See Section 4.8.3 of Gill et al. (1981).

These methods are similar to those for unconstrained optimization, but exploit the special structure of the Hessian matrix to give improved computational efficiency.

Since the Hessian matrix Gx is of the form where Jx is the Jacobian matrix of fx, and Gix is the Hessian matrix of fix.

Bounds on the variables are dealt with by fixing some of the variables on their bounds and adjusting the remaining free variables to minimize the function. By examining estimates of the Lagrange multipliers it is possible to adjust the set of variables fixed on their bounds so that eventually the bounds active at the solution should be correctly identified. This type of method is called an active set method. One feature of such methods is that, given an initial feasible point, all approximations x k  are feasible. This approach can be extended to general linear constraints. At a point, x, the set of constraints which hold as equalities being used to predict, or approximate, the set of active constraints is called the working set.

Suppose we have objective functions fix, i>1, all of which we need to minimize at the same time. There are two main approaches to this problem:

(a)

Combine the individual objectives into one composite objective. Typically this might be a weighted sum of the objectives, e.g., w1 f1x + w2 f2x + ⋯ + wn fnx Here you choose the weights to express the relative importance of the corresponding objective. Ideally each of the fix should be of comparable size at a solution.

(b)

Order the objectives in order of importance. Suppose fi are ordered such that fix is more important than fi+1x, for i=1,2,…,n-1. Then in the lexicographical approach to multi-objective optimization a sequence of subproblems are solved. Firstly solve the problem for objective function f1x and denote by r1 the value of this minimum. If i-1 subproblems have been solved with results ri-1 then subproblem i becomes minfix subject to rk≤fkx≤rk, for k=1,2,…,i-1 plus the other constraints.

Clearly the bounds on fk might be relaxed at your discretion.

Scaling (in a broadly defined sense) often has a significant influence on the performance of optimization methods. Since convergence tolerances and other criteria are necessarily based on an implicit definition of ‘small’ and ‘large’, problems with unusual or unbalanced scaling may cause difficulties for some algorithms. Although there are currently no user-callable scaling routines in the Library, scaling is automatically performed by default in the routines which solve sparse LP, QP or NLP problems and in some newer dense solver routines. The following sections present some general comments on problem scaling.

One method of scaling is to transform the variables from their original representation, which may reflect the physical nature of the problem, to variables that have certain desirable properties in terms of optimization. It is generally helpful for the following conditions to be satisfied:

(i)	the variables are all of similar magnitude in the region of interest;
(ii)	a fixed change in any of the variables results in similar changes in Fx. Ideally, a unit change in any variable produces a unit change in Fx;
(iii)	the variables are transformed so as to avoid cancellation error in the evaluation of Fx.

Normally, you should restrict yourself to linear transformations of variables, although occasionally nonlinear transformations are possible. The most common such transformation (and often the most appropriate) is of the form where D is a diagonal matrix with constant coefficients. Our experience suggests that more use should be made of the transformation where v is a constant vector.

Consider, for example, a problem in which the variable x3 represents the position of the peak of a Gaussian curve to be fitted to data for which the extreme values are 150 and 170; therefore x3 is known to lie in the range 150–170. One possible scaling would be to define a new variable x-3, given by A better transformation, however, is given by defining x-3 as Frequently, an improvement in the accuracy of evaluation of Fx can result if the variables are scaled before the routines to evaluate Fx are coded. For instance, in the above problem just mentioned of Gaussian curve-fitting, x3 may always occur in terms of the form x3-xm, where xm is a constant representing the mean peak position.

The objective function has already been mentioned in the discussion of scaling the variables. The solution of a given problem is unaltered if Fx is multiplied by a positive constant, or if a constant value is added to Fx. It is generally preferable for the objective function to be of the order of unity in the region of interest; thus, if in the original formulation Fx is always of the order of 10+5 (say), then the value of Fx should be multiplied by 10-5 when evaluating the function within an optimization routine. If a constant is added or subtracted in the computation of Fx, usually it should be omitted, i.e., it is better to formulate Fx as x12+x22 rather than as x12+x22+1000 or even x12+x22+1. The inclusion of such a constant in the calculation of Fx can result in a loss of significant figures.

A ‘well scaled’ set of constraints has two main properties. Firstly, each constraint should be well-conditioned with respect to perturbations of the variables. Secondly, the constraints should be balanced with respect to each other, i.e., all the constraints should have ‘equal weight’ in the solution process.

The solution of a linearly- or nonlinearly-constrained problem is unaltered if the ith constraint is multiplied by a positive weight wi. At the approximation of the solution determined by a Library routine, any active linear constraints will (in general) be satisfied ‘exactly’ (i.e., to within the tolerance defined by machine precision) if they have been properly scaled. This is in contrast to any active nonlinear constraints, which will not (in general) be satisfied ‘exactly’ but will have ‘small’ values (for example, c^1x*=10-8, c^2x*=-10 -6, and so on). In general, this discrepancy will be minimized if the constraints are weighted so that a unit change in x produces a similar change in each constraint.

The convergence criteria inevitably vary from routine to routine, since in some cases more information is available to be checked (for example, is the Hessian matrix positive definite?), and different checks need to be made for different problem categories (for example, in constrained minimization it is necessary to verify whether a trial solution is feasible). Nonetheless, the underlying principles of the various criteria are the same; in non-mathematical terms, they are:

(i)	is the sequence x k  converging?
(ii)	is the sequence F k  converging?
(iii)	are the necessary and sufficient conditions for the solution satisfied?

The decision as to whether a sequence is converging is necessarily speculative. The criterion used in the present routines is to assume convergence if the relative change occurring between two successive iterations is less than some prescribed quantity. Criterion (iii) is the most reliable but often the conditions cannot be checked fully because not all the required information may be available.

Little a priori guidance can be given as to the quality of the solution found by a nonlinear optimization algorithm, since no guarantees can be given that the methods will not fail. Therefore, you should always check the computed solution even if the routine reports success. Frequently a ‘solution’ may have been found even when the routine does not report a success. The reason for this apparent contradiction is that the routine needs to assess the accuracy of the solution. This assessment is not an exact process and consequently may be unduly pessimistic. Any ‘solution’ is in general only an approximation to the exact solution, and it is possible that the accuracy you have specified is too stringent.

Further confirmation can be sought by trying to check whether or not convergence tests are almost satisfied, or whether or not some of the sufficient conditions are nearly satisfied. When it is thought that a routine has returned a nonzero value of IFAIL only because the requirements for ‘success’ were too stringent it may be worth restarting with increased convergence tolerances.

For nonlinearly-constrained problems, check whether the solution returned is feasible, or nearly feasible; if not, the solution returned is not an adequate solution.

Many of the routines in the chapter have facilities to allow you to monitor the progress of the minimization process, and you are encouraged to make use of these facilities. Monitoring information can be a great aid in assessing whether or not a satisfactory solution has been obtained, and in indicating difficulties in the minimization problem or in the ability of the routine to cope with the problem.

The behaviour of the function, the estimated solution and first derivatives can help in deciding whether a solution is acceptable and what to do in the event of a return with a nonzero value of IFAIL.

When estimates of the parameters in a nonlinear least squares problem have been found, it may be necessary to estimate the variances of the parameters and the fitted function. These can be calculated from the Hessian of Fx at the solution.

The choice of routine depends on several factors: the type of problem (unconstrained, etc.); the level of derivative information available (function values only, etc.); your experience (there are easy-to-use versions of some routines); whether or not storage is a problem; whether or not the routine is to be used in a multithreaded environment; and whether computational time has a high priority. Not all choices are catered for in the current version of the Library.

Many routines appear in the Library in two forms: a comprehensive form and an easy-to-use form. The objective in the easy-to-use forms is to make the routine simple to use by including in the calling sequence only those parameters absolutely essential to the definition of the problem, as opposed to parameters relevant to the solution method. If you are an experienced user the comprehensive routines have additional parameters which enable you to improve their efficiency by ‘tuning’ the method to a particular problem. If you are a casual or inexperienced user, this feature is of little value and may in some cases cause a failure because of a poor choice of some parameters.

In the easy-to-use routines, these extra parameters are determined either by fixing them at a known safe and reasonably efficient value, or by an auxiliary routine which generates a ‘good’ value automatically.

For routines introduced since Mark 12 of the Library a different approach has been adopted towards the choice of easy-to-use and comprehensive routines. The optimization routine has an easy-to-use parameter list, but additional parameters may be changed from their default values by calling an ‘option’ setting routine before the call to the main optimization routine. This approach has the advantages of allowing the options to be given in the form of keywords and requiring only those options that are to be different from their default values to be set.

Many of the routines in this chapter come in pairs, with each routine in the pair having exactly the same functionality, except that one of them has additional parameters in order to make it safe for use in multithreaded applications. The routine that is safe for use in multithreaded applicatons has an ‘A’ as the last character in the name, in place of the usual ‘F’.

Most of the routines in this chapter are called just once in order to compute the minimum of a given objective function subject to a set of constraints on the variables. The objective function and nonlinear constraints (if any) are specified by you and written as subroutines to a very rigid format described in the relevant routine document. Such subroutines usually appear in the argument list of the minimization routine.

For the majority of applications this is the simplest and most convenient usage. Sometimes however this approach can be restrictive:

(i)	when the required format of the subroutine does not allow useful information to be passed conveniently to and from your calling program;
(ii)	when the minimization routine is being called from another computer language, such as Visual Basic, which does not fully support procedure arguments in a way that is compatible with the Library.

A way around these problems is to utilize reverse communication routines. Instead of performing complete optimizations, these routines perform one step in the solution process before returning to the calling program with an appropriate flag (IREVCM) set. The value of IREVCM determines whether the minimization process has finished or whether fresh information is required. In the latter case you calculate this information (in the form of a vector or as a scalar, as appropriate) and re-enter the reverse communication routine with the information contained in appropriate arguments. Thus you have the responsibility for providing the iterative loop in the minimization process, but as compensation, you have an extremely flexible and basic user-interface to the reverse communication routine.

One of the most common errors in the use of optimization routines is that user-supplied subroutines do not evaluate the relevant partial derivatives correctly. Because exact gradient information normally enhances efficiency in all areas of optimization, you are encouraged to provide analytical derivatives whenever possible. However, mistakes in the computation of derivatives can result in serious and obscure run-time errors. Consequently, service routines are provided to perform an elementary check on the gradients you supplied. These routines are inexpensive to use in terms of the number of calls they require to user-supplied subroutines.

All the routines for constrained problems will ensure that any evaluations of the objective function occur at points which approximately satisfy any simple bounds or linear constraints. Satisfaction of such constraints is only approximate because routines which estimate derivatives by finite differences may require function evaluations at points which just violate such constraints even though the current iteration just satisfies them.

There is no attempt to ensure that the current iteration satisfies any nonlinear constraints. If you wish to prevent your objective function being evaluated outside some known region (where it may be undefined or not practically computable), you may try to confine the iteration within this region by imposing suitable simple bounds or linear constraints (but beware as this may create new local minima where these constraints are active).

Note also that some routines allow you to return the parameter (IFLAG or MODE) with a negative value to force an immediate clean exit from the minimization routine when the objective function (or nonlinear constraints where appropriate) cannot be evaluated.

Apart from the standard types of optimization problem, there are other related problems which can be solved by routines in this or other chapters of the Library.