# CONMIN USER'S MANUAL

## NASA Technical Memorandum X-62282, 1978

###

  Addendum to Technical Memorandum, 1978
  Original Technical Memorandum, 1973

[Cover]

       NASA TECHNICAL                                 NASA TM X-62,282
    	MEMORANDUM

       CONMIN - A FORTRAN PROGRAM FOR CONSTRAINED

       FUNCTION MINIMIZATION

       USER'S MANUAL

       Garret N. Vanderplaats

       Ames Research Center and U.S. Army Air Mobility
       R&D Laboratory, Moffett Field, Calif.  94035

       August 1973
       [Reprinted 1991]

### CONMIN USER'S MANUAL ADDENDUM
by G. N. VANDERPLAATS
May, 1978

Since the original release of the CONMIN program, numerous modifications and improvements have been made. These include changes to the program organization, COMMON block structures, array dimensions and control parameters. An understanding of these changes is necessary for the operation of the current version of the program and these are outlined in the following sections.

This version of CONMIN is identified by a comment card near the beginning of subroutine CONMIN:

`C * * MAY, 1978 VERSION * *` .

### PROGRAM ORGANIZATION

The original version of CONMIN was written such that a user-supplied subroutine was called by CONMIN for function and gradient calculations. The current version is organized such that the function evaluation routine is contained in, or is called by, the main program. CONMIN executes according to the parameter IGOTO which must be initialized to zero. Figure A1 shows the required program organization. The purpose of this new logic is so that the program can be used in an overlay system or can be restarted in mid-execution.

### COMMON BLOCKS

`CNMN2, CNMN3` and `CNMN4` as originally defined are no longer required. However, the arrays contained in these common blocks must still be dimensioned in the main program. Common block name CONSAV is now used for internal storage by CONMIN and this name must not be used elsewhere. The information in common block `CNMN1` has been changed, and is now:

`COMMON /CNMN1/ DELFUN, DABFUN, FDCH, FDCHM, CT, CTMIN, CTL, CTLMIN, ALPHAX, ABOBJ1, THETA, obj, NDV, NCON, NSIDE, IPRINT, NFDG, NSCAL, LINOBJ, ITMAX, ITRM, ICNDIR, IGOTO, nac, info, infog, iter.`

NOTE: The parameters typed in upper case must be initialized before the first call to CONMIN. The parameters typed in `bold` characters are calculated by the user during execution, depending on the value of `info`; `nac` will be calculated by the user only if `NFDG = 1`.

### ARRAY DIMENSIONS

The storage requirements for the arrays used in CONMIN have changed. The current storage requirements are:

`DIMENSION X(N1), VLB(N1), VUB(N1), g(N2), SCAL(N1), df(N1), a(N1,N3), s(N1), g1(N2), g2(N2), b(N3,N3), c(N4), ISC(N2), ic(N3), ms1(N5)`

where

`
  N1 = NDV + 2
  N2 = NCON + 2*NDV
  N3 = NACMX1
  N4 = MAX (N3,NDV)
  N5 = 2*N4
`

Note that these are minimum dimensions. The arrays may be dimensioned larger than this at the user's option.

NOTE: Uppercase denotes arrays which must be initialized before the first call to CONMIN. `VLB, VUB, ISC` and `SCAL` must be initialized only if they will be used: `VLB` and `VUB` if `NSIDE.GT.0`, `ISC` if `NCON.GT.0` and `SCAL` if `NSCAL.LT.0.`

During execution, the arrays `g`, `a`, and `isc` must be calculated by the user, depending on the value of `NFDG`. If `NFDG` = 0, only array `g` is calculated. If `NFDG` = 2, only arrays `g` and `df` are calculated. The remaining arrays are used internally by CONMIN.

### CALLING STATEMENT

CONMIN is now called by the FORTRAN statement:

`CALL CONMIN (X, VLB, VUB, G, SCAL, DF, A, S, G1, G2, B, C, ISC, IC, MS1, N1, N2, N3, N4, N5)`.

CAUTION: Check that the values of `N1, N2, N3, N4` and `N5` in the calling statement are consistent with the array dimensions discussed above.

### PARAMETER CHANGES

Variable `NACMX1` defined in common block `CNMN1` is replaced by `N3` in the parameter list.

A new parameter, `INFOG`, has been added:

         INFOG = 0:   same as when INFOG was not used.

         INFOG = 1:   only those constraints identified as active or violated
                      in array IC(I), I = 1, NAC need be evaluated.  This is
                      only meaningful if finite difference gradients are
                      calculated, and allows the user to avoid
                      calculating non-essential information.  If it is
                      convenient to evaluate all constraints each time,
                      variable INFOG may be ignored.

The parameters `ALPHAX` and `ABOBJ1` have been added to `CNMN1`.

`ALPHAX` (default = 0.1) is the maximum fractional change in any component of `X` as an initial estimate for `ALPHA` in the one-dimensional search. That is, the initial `ALPHA` will be such that no component of `X` is changed by more than this amount. This only applies to those `X(i)` of magnitude greater than 0.1. If an optimization run shows numerous `ALPHA` = 0 results for the one-dimensional search, it may help to try `ALPHAX` less than the default. `ALPHAX` is changed by CONMIN depending on the progress of the optimization.

`ABOBJ1` (default = 0.1) is the fractional change attempted as a first step in the one-dimensional search and is based on a linear approximation. `ABOBJ1` is updated during the optimization, depending on progress. The initial step in the one-dimensional search is taken as the amount necessary to change `OBJ` by `ABOBJ1*ABS(OBJ)` or to change some `X(i)` by `ALPHAX*ABS( X(i) )`, whichever is less.

The definition of parameter INFO has changed. The current definition is:

        INFO = 1:  calculate OBJ and G(I), I = 1, NCON

        INFO = 2:  calculate NAC, IC(I), I = 1,NAC, the gradient of OBJ, and
                   the gradient of G(J), where J = IC(I), I = 1,NAC.
                   Store the gradients of G in columns of A.

The definition of the finite difference gradient parameter, `NFDG` has changed. The current definition is:

        NFDG = 0:  all gradient information is calculated by finite difference
                   within CONMIN.

        NFDG = 1:  all gradient information is supplied by the user.

        NFDG = 2:  the gradient of OBJ is supplied by the user and the
                   gradients of constraints are calculated by finite
                   difference within CONMIN.

Additional printing is now available using the IPRINT parameter:

        IPRINT = 1, 2, 3, 4:  same as before.

        IPRINT = 5:  all of above plus each proposed design vector, objective
                     and constraints during the one-dimensional search.

### GRADIENT STORAGE

The gradients of active or violated constraints are now stored in the columns of array [`A`], instead of the rows of [`A`]. This is for computational efficiency and convenience. Also, it sometimes simplifies programming associated with user-supplied gradients (`NFDG` = 1). This change only effects those users who use the `NFDG` = 1 option. If gradients of constraints are calculated by CONMIN the user only needs to be sure that array [`A`] is correctly dimensioned in the calling program.

### OVERLAY/RESTART CAPABILITY

CONMIN can now be in its own overlay. It is only required that the arrays be saved in overlay zero as well as the contents of common blocks `CNMN1` and `CONSAV`. `CONSAV` contains 50 real parameters followed by 25 integer parameters:

`COMMON /CONSAV/ REAL(50), INT(25)`

This also allows the user to restart CONMIN at any point during the optimization. Upon return from CONMIN it is only necessary to write the information in the parameter list (all arrays plus `N1 - N5`) on disc, together with the contents of `CNMN1` and `CONSAV`. The program can be restarted by reading this information back from disc and continuing the program execution from this point.

### DOUBLE PRECISION OPERATIONS

Occasionally it is desirable to use CONMIN in double precision, usually on an IBM machine. To do this, add implicit `READ*8 A-H, O-Z` cards at the beginning of each routine.

NOTE: This has not been tested because on unavailability of an IBM computer, but care has been taken to insure that no parity errors will occur. If you use double precision please inform the author of success or failure so other users can be assured of the operational status of this option.

[Original NASA TM]

    NASA TECHNICAL                                       NASA TM X-62,282
         MEMORANDUM

    CONMIN - A FORTRAN PROGRAM FOR CONSTRAINED FUNCTION MINIMIZATION
    USER'S MANUAL

    Garret N. Vanderplaats

## CONTENTS

  SUMMARY

  I. INTRODUCTION

  II. MAKING CONMIN OPERATIONAL

  III. PROGRAM ORGANIZATION

  IV. PARAMETERS DEFINED IN MAIN PROGRAM

  V. PARAMETERS DEFINED IN EXTERNAL ROUTINE

  VI. PARAMETERS DEFINED IN CONMIN AND ASSOCIATED ROUTINES

  VII. REQUIRED DIMENSIONS OF ARRAYS

  VIII. EXAMPLES

  Appendices
  A. SUMMARY OF PARAMETERS USED BY CONMIN
  B. CONMIN SUBROUTINE DESCRIPTIONS

  REFERENCES

  LIST OF EXAMPLES

  LISTING NO.
  1. Main Program, Examples 1 and 2.
  2. Analysis Routine for Example 1.
  3. Optimization Results for Example 1.
  4. Analysis Routine for Example 2.
  5. Optimization Results for Example 2.
  6. Main Program and Analysis For Example 3.
  7. Optimization Results For Example 3.

  ADDENDUM (1978)

### SUMMARY

CONMIN is a FORTRAN program, in subroutine form, for the solution of linear or nonlinear constrained optimization problems. The basic optimization algorithm is the Method of Feasible Directions. The user must provide a main calling program and an external routine to evaluate the objective and constraint functions and to provide gradient information. If analytic gradients of the objective or constraint functions are not available, this information is calculated by finite difference. While the program is intended primarily for efficient solution of constrained problems, unconstrained function minimization problems may also be solved, and the conjugate direction method of Fletcher and Reeves is used for this purpose. This manual describes the use of CONMIN and defines all necessary parameters. Sufficient information is provided so that the program can be used without special knowledge of optimization techniques. Sample problems are included to help the user become familiar with CONMIN and to make the program operational.

### SECTION I

### INTRODUCTION

In many mathematical problems, it is necessary to determine the minimum or maximum of a function of several variables, limited by various linear and nonlinear inequality constraints. It is seldom possible, in practical applications, to solve these problems directly, and iterative methods are used to obtain the numerical solution. Machine-calculation of this solution is, of course, desirable and the CONMIN program has been developed to solve a wide variety of such problems.

CONMIN is a FORTRAN program, in subroutine form, for the minimization of a multi-variable function subject to a set of inequality constraints. The general minimization problem is: Find values for the set of variables, `X(I)`, to

         Minimize    OBJ

         Subject to:

              G(J).LE.0                          J = 1,NCON

              VLB(I).LE.X(I).LE.VUB(I)           I = 1,NDV      NSIDE.GT.0

where `OBJ` is a general function (objective function) of the variables, `X(I)` referred to hereafter as decision variables. `OBJ` need not be a simple analytic function, and may be any function which can be numerically evaluated.

`G(J)` is the value of the `J`th inequality constraint, which is also a function of the `X(I)`. `NCON` is the number of constraints, `G(J)`. `NCON` may be zero. `VLB(I)` and `VUB(I)` are lower and upper bounds respectively on variable `X(I)`, and are referred to as side constraints. `NSIDE` = 0 indicates that no lower or upper bounds are prescribed. If `NCON` = 0 and `NSIDE` = 0, the objective function is said to be unconstrained. `NDV` is the total number of decision variables, `X(I)`.

Constraint `G(J)` is defined as active if `CT.LE.G(J).LE.ABS(CT)` and violated if `G(J).GT.ABS(CT)`, where constraint thickness, `CT`, is a small specified negative number. The numerical significance of `CT` may be understood by referring to Fig. 1, which shows a single constraint in a two variable design space. Constraint `G(J)` is mathematically equal to zero along a single curve in design space. However, on a digital computer, the exact value of `G(J)` = 0 can seldom be obtained. Therefore, the "curve" becomes a thick band with constraint thickness of `2*ABS(CT)` over which `G(J)` is assumed to be zero. Because all `G(J)` must be negative, `CT` is taken as a negative number for consistency so that any `G(J).GT.CT` is defined as active (or violated) if `G(J).GT.ABS(CT)`. While it may seem logical to choose a very small value (in magnitude) for `CT` (say -1.0E-6), the nature of the optimization algorithm used by CONMIN is such that more numerical stability can be achieved by taking `CT` = -0.1 or even -0.2. `CT` is used for numerical stability only, and when the optimization is complete, one or more constraints, `G(J)`, will usually be very near zero, as seen in the examples in SECTION VIII.

It is desirable that `G(J)` be normalized so that

         -1 .LE. G(J) .LE. 1             J = 1, NCON

In this way the constraint thickness, `CT`, has the same numerical significance for all `G(J)`. It is not necessary that all `G(J)` be precisely in this form, and such normalization may not be possible. However, it is important that all `G(J)` at least be of the same order of magnitude. For example, assume that some `G(J) = X(1)**2-X(2)`. If `X(1)` and `X(2)` are expected to be of order 100 for the particular problem under consideration, `G(J)` may be scaled by dividing by 10,000 to provide a value for `G(J)` of order one.

The basic analytic technique used by CONMIN is to minimize `OBJ` until one or more constraints, `G(J)`, become active. The minimization process then continues by following the constraint boundaries in a direction such that the value of `OBJ` continues to decrease. When a point is reached such that no further decrease in `OBJ` can be obtained, the process is terminated. The value of the constraint thickness parameter, `CT`, and the normalization of the constraints, `G(J)`, have considerable effect on the numerical stability and rate of convergence of the optimization process.

An example of a constrained nonlinear problem is the minimization of the four variable Rosen-Suzuki function (ref. 1):

         MINIMIZE OBJ = X(1)**2 - 5*X(1) + X(2)**2 - 5*X(2) +
                        2*X(3)**2 - 21*X(3) + X(4)**2 + 7*X(4) + 50

         Subject to:

             G(1) = X(1)**2 + X(1) + X(2)**2 - X(2) +
                    X(3)**2 + X(3) + X(4)**2 - X(4) - 8  .LE. 0

             G(2) = X(1)**2 - X(1) + 2*X(2)**2 + X(3)**2 +
                    2*X(4)**2 - X(4) - 10                .LE. 0

             G(3) = 2*X(1)**2 + 2*X(1) + X(2)**2 - X(2) +
                    X(3)**2 - X(4) - 5                   .LE. 0

This problem has four decision variables and three constraints, (`NDV = 4, NCON = 3`). No lower or upper bounds `VLB(I)` or `VUB(I)` are prescribed so control parameter `NSIDE` is specified as `NSIDE = 0` to indicate this. It is necessary to provide a set of initial values for `X(I)`, and from this the constrained optimum is obtained by CONMIN and its associated routines. This problem will be solved using CONMIN in SECTION VIII.

The minimization algorithm is based on Zoutendijk's method of feasible directions (ref. 2). The algorithm has been modified to improve efficiency and numerical stability and to solve optimization problems in which one or more constraints, `G(J)`, are initially violated (ref. 3). While the program is intended primarily for the efficient solution of constrained functions, unconstrained functions may also be minimized (`NCON = 0` and `NSIDE = 0`), and the conjugate direction method of Fletcher and Reeves (ref. 4) is used for this purpose. If a function is to be maximized, this may be achieved by minimizing the negative of the function.

For constrained minimization problems, the initial design need not be feasible (one or more `G(J)` may be greater than `ABS(CT)`), and a feasible solution (if one exists) is obtained with a minimal increase in the value of the objective function.

The user must supply a main program to call subroutine CONMIN along with an external subroutine to evaluate the objective function, constraint functions and the analytic gradient of the objective and currently active or violated constraint functions. At any given time in the minimization process, gradient information is required only for constraints which are active or violated (`G(J).GE.CT`). Gradients are calculated by finite difference if this information is not directly obtainable, and a subroutine is included with CONMIN for this purpose.

The basic program organization is described here, and sufficient information is provided so that the program may be used without special knowledge of optimization techniques. The various control parameters are described and the required dimensions of all arrays are given so that the user can limit storage requirements to that necessary to solve his particular problems. Sample problems are included to aid the user in making the program operational and to gain familiarity with its use.

A summary of all parameters used by CONMIN and its associated routines is given in APPENDIX A for convenient reference.

APPENDIX B contains a brief description of the subroutines associated with CONMIN.

### SECTION II

### MAKING CONMIN OPERATIONAL

CONMIN utilizes iterative techniques to numerically obtain the minimum of a general function, subject to a prescribed set of linear and/or nonlinear constraints. Because of the nature of these techniques, the efficiency of the optimization process (the number of times the functions must be evaluated) can often be improved by the proper choice of control parameters to deal effectively with a given problem. For this reason, it is particularly desirable that the new user solve several simple two to five variable problems, experimenting with different control parameters. The following steps are suggested to help the user make CONMIN operational and to gain the familiarity necessary for its efficient application to a particular problem.

1. Obtain the source code, including example problems.

2. Read SECTION VIII (EXAMPLES) of this manual.

3. Solve the example problems using CONMIN, and verify the results by comparison with the output listed in this manual. Note that the precise numerical values may differ slightly on different computers.

4. Read this entire manual carefully.

5. Devise several two to five variable unconstrained and constrained minimization problems and solve them using CONMIN. If the precise optimum can be determined analytically, compare this with the optimums obtained using CONMIN.

6. Experiment by starting from several different initial points (different initial `X` vectors). This is good practice in all optimization problems, since it improves the chances that the absolute minimum is obtained (instead of a relative minimum).

7. Experiment with various analytic gradient options by solving the same problems with and without calculating precise analytic gradients (see examples 1 and 2 of SECTION VIII).

8. Experiment with various convergence criteria, `DELFUN, DABFUN and ITRM`.

9. Experiment with various constraint thickness parameters, `CT, CTMIN, CTL` and `CTLMIN` to understand the effect of these parameters on constrained minimization problems.

10. Experiment with various values of the push-off factor, `THETA`, on several constrained minimization problems. Small values of `THETA` may be used if constraints, `G(J)`, are nearly linear functions of the decision variables, `X(I)`, and larger values should be used if one or more `G(J)` are highly nonlinear.

11. Experiment with scaling options by using no scaling, automatic scaling, or user provided scaling options.

12. Experiment with various conjugate direction restart parameters, `ICNDIR`, using examples of unconstrained minimization. Note that if `ICNDIR = 1`, the steepest descent method will be used throughout the optimization process.

13. Re-read this entire manual.

The default options on the various control parameters have been chosen as reasonable values for most optimization problems. The steps listed above are intended to provide the user with the experience necessary to change these parameters as required to efficiently solve new optimization problems of special interest.

### SECTION III

### PROGRAM ORGANIZATION
[ENTIRE SECTION SUPERCEDED BY THE ADDENDUM]

The overall program organization is shown in Fig. 2 [SUPERCEDED]. The variables are initialized in the main program. The vector `X` is changed in subroutine CONMIN and its associated routines, and external routine `SUB1` calculates the required function values and gradient information.

Subroutine CONMIN is called by the main program by the call statement:

         CALL CONMIN (SUB1,OBJ)

where `SUB1` is the name of the user supplied external subroutine and `OBJ` is the optimum value of the objective function upon return from CONMIN. The variables, `X(I)`, contained in vector `X` and constraint values, `G(J)`, contained in vector `G` will correspond to this optimum upon return. If additional information calculated in external routine `SUB1` is required, the routine should be called again upon return from CONMIN to insure that this information corresponds to the final values of `X(I)`.

Subroutine `SUB1` is called by CONMIN and its associated routines by the call statement:

         CALL SUB1(INFO,OBJ)

where `INFO` is a control parameter defining which information must be supplied, and `OBJ` is the value of the objective function to be calculated corresponding to the current decision variables contained in `X`. `INFO` will have a value of from 1 to 4 to identify what information must be supplied by `SUB1`.

         INFO = 1   Calculate objective function value, OBJ, for current
                    variables X.

         INFO = 2   Calculate objective function value, OBJ, and constraint
                    values, G(J), J = 1, NCON for current variables, X.

         INFO = 3   Calculate analytic gradient of objective function
                    corresponding to current variables, X.  The objective
                    function and constraint values already correspond to the
                    current values of X and need not be recalculated.
                    However, other information obtained in SUB1 when
                    calculating OBJ and G(J) may not correspond to X and must
                    be calculated again here if it is used in gradient
                    computations.  If finite difference control parameter,
                    NFDG, is set to NFDG = 1 in the main program this value
                    of INFO will never be considered.

         INFO = 4   For current variables, X, determine which constraints
                    are active and which are violated (G(J).GE.CT) and how
                    many such constraints there are (NAC = Number of active
                    and violated constraints).  Calculate the analytic
                    gradients of the objective function and all active or
                    violated constraints.  Values of the objective function,
                    OBJ, and constraints, G(J), already correspond to the
                    current variables, X, and need not be recalculated.
                    As in the case of INFO = 3, all other information used
                    in gradient computations must be calculated for the
                    current variables, X.  If finite difference control
                    parameter NFDG, defined in the main program, is not zero,
                    this value of INFO will never be considered.

Note that `INFO = 3` and `INFO = 4` are considered only if gradient information is calculated in the user supplied subroutine, `SUB1`.

With the exception of the external subroutine name, `SUB1`, the objective function value, `OBJ`, and the control parameter, `INFO`, all information used in the optimization process is transferred by means of the following labeled common blocks.

         COMMON/CNMN1/IPRINT, NDV, ITMAX, NCON, NSIDE, ICNDIR, NSCAL, NFDG,
         1 FDCH, FDCHM, CT, CTMIN, CTL, CTLMIN, THETA, PHI, NAC, NACMX1, DELFUN,
         2 DABFUN, LINOBJ, ITRM, ITER, NCAL(4)

         COMMON/CNMN2/X(N1), DF(N1), G(N2), ISC(N8), IC(N4), A(N4,N3)

         COMMON/CNMN3/S(N3), G1(N7), G2(N2), C(N9), MS1(N6), B(N4,N4)

         COMMON/CNMN4/VLB(N1), VUB(N1), SCAL(N5)

The parameters and arrays used in the minimization process will now be defined, followed by the required array dimensions, `N1` through `N9`. If a default value is listed, this value will be used if a zero value is transferred from the main program.

### SECTION IV

### PARAMETERS DEFINED IN MAIN PROGRAM

    IPRINT   Print control.  All printing is done on unit number 6.

             0:  Print nothing.

             1:  Print initial and final function information.

             2:  1st debug level.  Print all of above plus control
                 parameters.  Print function value and X-vector at each
                 iteration.

             3:  2nd. debug level.  Print all of above plus all constraint
                 values, numbers of active or violated constraints, direction
                 vectors, move parameters and miscellaneous information.  The
                 constraint parameter, BETA, printed under this option
                 approaches zero as the optimum objective is achieved.

             4:  Complete debug.  Print all of above plus gradients of
                 objective function, active or violated constraint functions
                 and miscellaneous information.

    NDV      Number of decision variables, X(I), contained in vector X.

    ITMAX    Default value = 10.  Maximum number of iterations in the
             minimization process.  If NFDG.EQ.0 each iteration requires one
             set of gradient computations (INFO = 3 or 4) and approximately
             three function evaluations (INFO = 1 or 2).  If NFDG.GT.0
             each iteration requires approximately NDV + 3 function
             evaluations (INFO = 1 or 2).

    NCON     Number of constraint functions, G(J).  NCON may be zero.

    NSIDE    Side constraint parameter.  NSIDE = 0 signifies that the
             variables X(I) do not have lower or upper bounds.  NSIDE.GT.0
             signifies that all variables X(I) have lower and upper bounds
             defined by VLB(I) and VUB(I) respectively.  If one or more
             variables are not bounded while others are, the values of the
             lower and upper bounds on the unbounded variables must be taken
             as very large negative and positive values respectively
             (i.e., VLB(I) = -1.0E+10, VUB(I) = 1.0E+10).

    ICNDIR   Default value = NDV + 1.  Conjugate direction restart parameter.
             If the function is currently unconstrained, (all G(J).LT.CT or
             NCON = NSIDE = 0), Fletcher-Reeves conjugate direction method will
             be restarted with a steepest descent direction every ICNDIR
             iterations.  If ICNDIR = 1 only steepest descent will be used.

    NSCAL    Scaling control parameter.  The decision variables will be
             scaled linearly.

             NSCAL.LT.0:  Scale variables X(I) by dividing by SCAL(I), where
                          vector SCAL is defined by the user.

             NSCAL.EQ.0:  Do not scale the variables.

             NSCAL.GT.0:  Scale the variables every NSCAL iterations.
                          Variables are normalized so that scaled
                          X(I) = X(I)/ABS(X(I)).  When using this option, it
                          is desirable that NSCAL = ICNDIR if ICNDIR is input
                          as nonzero, and NSCAL = NDV + 1 in ICNDIR is input
                          as zero.

    NFDG     Gradient calculation control parameter. [SEE ADDENDUM]

             NFDG = 0:  All gradient information is provided by external
                        routine SUB1.  This information may be calculated
                        analytically, or by finite difference, at the user's
                        discretion.

             NFDG = 1:  All gradient information will be calculated by finite
                        difference in CONMIN.  SUB1 provides only function
                        values, OBJ and G(J), J = 1, NCON.

             NFDG = 2:  Gradient of objective function is provided by external
                        routine SUB1, and gradients of active and violated
                        constraints are calculated by finite difference in
                        CONMIN.  This option is desirable if the gradient of
                        the objective function is easily obtained in closed
                        form, but gradients of constraint functions, G(J), are
                        unobtainable.  This option may improve efficiency if
                        several variables are limited by lower or upper bounds.

    FDCH     Default value = 0.01.  Not used if NFDG = 0.  Relative change in
             decision variable X(I) in calculating finite difference
             gradients.  For example, FDCH = 0.01 corresponds to a finite
             difference step of one percent of the value of the decision
             variable.

    FDCHM    Default value = 0.01.  Not used if NFDG = 0.  Minimum absolute
             step in finite difference gradient calculations.  FDCHM applies
             to the unscaled variable values.

    CT       Default value = -0.1.  Not used if NCON = NSIDE = 0.
             Constraint thickness parameter.  If CT.LE.G(J).LE.ABS(CT),
             G(J) is defined as active.  If G(J).GT.ABS(CT), G(J) is said to
             be violated.  If G(J).LT.CT, G(J) is not active.  CT is
             sequentially reduced in magnitude during the optimization
             process.  If ABS(CT) is very small, one or more constraints
             may be active on one iteration and inactive on the next,
             only to become active again on a subsequent iteration.
             This is often referred to as "zigzagging" between constraints.
             A wide initial value of the constraint thickness is desirable
             for highly nonlinear problems so that when a constraint
             becomes active it tends to remain active, thus reducing the
             zigzagging problem.  The default value is usually adequate.

    CTMIN    Default value = 0.004.  Not used if NCON = NSIDE = 0.  Minimum
             absolute value of CT considered in the optimization process.
             CTMIN may be considered as "numerical zero" since it may not be
             meaningful to compare numbers smaller than CTMIN.  The value of
             CTMIN is chosen to indicate that satisfaction of a constraint
             within this tolerance is acceptable.  The default value is usually
             adequate.

    CTL      Default value = -0.01.  Not used if NCON = NSIDE = 0.
             Constraint thickness parameter for linear and side constraints.
             CTL is smaller in magnitude than CT because the zigzagging
             problem is avoided with linear and side constraints.  The default
             value is usually adequate.

    CTLMIN   Default value = 0.001.  Not used if NCON = NSIDE = 0.  Minimum
             absolute value of CTL considered in the optimization process.
             The default value is usually adequate.

    THETA    Default value = 1.0.  Not used if NCON = NSIDE = 0.  Mean value
             of the push-off factor in the method of feasible directions.
             A larger value of THETA is desirable if the constraints, G(J),
             are known to be highly nonlinear, and a smaller value may be
             used if all G(J) are known to be nearly linear.  The actual
             value of the push-off factor used in the program is a quadratic
             function of each G(J), varying from 0.0 for G(J) = CT to 4.0*THETA
             for G(J) = ABS(CT).  A value of THETA = 0.0 is used in the
             program for constraints which are identified by the user to be
             strictly linear.  THETA is called a "push-off" factor because
             it pushes the design away from the active constraints into the
             feasible region.  The default value is usually adequate.

    PHI      Default value = 5.0.  Not used if NCON = NSIDE = 0.
             Participation coefficient, used if a design is infeasible
             (one or more G(J).GT.ABS(CT)).  PHI is a measure of how hard
             the design will be "pushed" towards the feasible region and
             is, in effect, a penalty parameter.  If in a given problem, a
             feasible solution cannot be obtained with the default value,
             PHI should be increased, and the problem run again.  If a
             feasible solution cannot be obtained with PHI = 100, it is
             probable that no feasible solution exists.  The default value
             is usually adequate.

    NACMX1   Not used if NSIDE = NCON = 0.  1 plus user's best estimate of
             the maximum number of constraints (including side constraints,
             VLB(I) and VUB(I)) which will be active at any given time in
             the minimization process.  NACMX1 = number of rows in array A.
             If NAC + 1 ever exceeds this value, the minimization process will
             be terminated, an error message will be printed, and control
             will return to the main program.  NACMX1 will never exceed
             NDV + 1 if all constraints G(J) and bounds VLB(I) and VUB(I)
             are independent.  A reasonable value for NACMX1 (and the
             corresponding dimension of array A) is MIN(40, NDV + 1),
             where the minimum of 40 will only apply for large problems
             and is arbitrary, based on the observation that even for very
             large problems (over a hundred X(I) and several thousand G(J)),
             it is uncommon for many constraints to be active at any time
             in the minimization process (the optimum solution is seldom
             "fully constrained" for very large nonlinear problems).

    DELFUN   Default value = 0.001.  Minimum relative change in the objective
             function to indicate convergence.  If in ITRM consecutive
             iterations, ABS(1.0-OBJ(J-1)/OBJ(J)).LT.DELFUN and the current
             design is feasible (all G(J).LE.ABS(CT)), the minimization
             process is terminated.  If the current design is infeasible
             (some G(J).GT.ABS(CT)), five iterations are required to
             terminate and this situation indicates that a feasible design
             may not exist.

    DABFUN   Default value = 0.001 times the initial function value.  Same
             as DELFUN except comparison is on absolute change in the
             objective function, ABS(OBJ(J)-OBJ(J-1)), instead of relative
             change.

    LINOBJ   Not used if NCON = NSIDE = 0.  Linear objective function
             identifier.  If the objective, OBJ, is specifically known to
             be a strictly linear function of the decision variables, X(I),
             set LINOBJ = 1.  If OBJ is a general nonlinear function, set
             LINOBJ = 0.

    ITRM     Default value = 3.  Number of consecutive iterations to indicate
             convergence by relative or absolute changes, DELFUN or DABFUN.

    X(N1)    Vector of decision variables, X(I), I = 1, NDV.  The initial
             X-vector contains the user's best estimate of the set of optimum
             design variables.

    VLB(N1)  Used only if NSIDE.NE.0.  VLB(I) is the lower allowable value
             (lower bound) of variable X(I).  If one or more variables, X(I),
             do not have lower bounds, the corresponding VLB(I) must be
              initialized to a very large negative number (say -1.0E+10).

    VUB(N1)  Used only if NSIDE.NE.0.  VUB(I) is the maximum allowable value
             (upper bound) of X(I).  If one or more variables, X(I), do not
             have upper bounds, the corresponding VUB(I) must be initialized
             to a very large positive number (say 1.0E+10).

    SCAL(N5) Not used if NSCAL = 0.  Vector of scaling parameters.  If
             NSCAL.GT.0 vector SCAL need not be initialized since SCAL will
             be defined in CONMIN and its associated routines.  If NSCAL.LT.0,
             vector SCAL is initialized in the main program, and the scaled
             variables X(I) = X(I)/SCAL(I).  Efficiency of the optimization
             process can sometimes be improved if the variables are either
             normalized or are scaled in such a way that the partial deri-
             vative of the objective function, OBJ, with respect to variable
             X(I) is of the same order of magnitude for all X(I).  SCAL(I)
             must be greater than zero because a negative value of SCAL(I)
             will result in a change of sign of X(I) and possibly yield
             erroneous optimization results.  The decision of if, and how, the
             variables should be scaled is highly problem dependent, and some
             experimentation is desirable for any given class of problems.

    ISC(N8)  Not used if NCON = 0.  Linear constraint identification vector.
             If constraint G(J) is known to be a linear function of the
             decision variables, X(I), ISC(I) should be initialized to
             ISC(I) = 1.  If constraint G(J) is nonlinear ISC(I) is initialized
             to ISC(I) = 0.  Identification of linear constraints may improve
             efficiency of the optimization process and is therefore desirable,
             but is not essential.  If G(J) is not specifically known to be
             linear, set ISC(I) = 0.

### SECTION V

### PARAMETERS DEFINED IN EXTERNAL ROUTINE SUB1.

    OBJ       Value of objective function for the current decision variables,
              X(I), I = 1, NDV contained in vector X.  Calculate OBJ if
              INFO = 1 or INFO = 2.

    G(N2)     Not used if NCON = NSIDE = 0.  Vector containing all constraint
              functions, G(J), J = 1, NCON for current decision variables, X.
              Calculate G(J), J = 1, NCON if INFO = 2.

    DF(N1)    Analytic gradient of the objective function for the current
              decision variables, X(I).  DF(I) contains the partial derivative
              of OBJ with respect to X(I).  Calculate DF(I), I = 1,
              NDV if INFO = 3 or INFO = 4 and if NFDG = 0 or NFDG = 2.

    NAC       Number of active and violated constraints (G(J).GE.CT).
              Calculate NAC if INFO = 4 and NFDG = 0.

    A(N4,N3)  Not used if NCON = NSIDE = 0.  Gradients of active or violated
              constraints, for current decision variables, X(I).
              A(J,I) contains the gradient of the Jth active or violated
              constraint, G(J), with respect to the Ith decision variable,
              X(I) for J = 1, NAC and I = 1, NDV.  Calculate if INFO = 4
              and NFDG = 0.  [SEE ADDENDUM]

    IC(N4)    Identifies which constraints are active or violated.  IC(J)
              contains the number of the Jth active or violated constraint
              for J = 1, NAC.  For example, if G(10) is the first active
              or violated constraint (G(J).LT.CT, J = 1,9), set IC(1) = 10.
              Calculate if INFO = 4 and NFDG = 0.

If it is convenient to calculate more information than is required by the information control parameter, `INFO`, this may be done. `INFO` identifies the minimum amount of information which is necessary at a given time in the optimization process. It is never necessary to determine which bounds (side constraints) `VLB(I)` and `VUB(I)` are active because this information is determined by CONMIN.

The required organization of SUB1 is shown in Fig. 3. Note that if `NCON = 0`, `NFDG = 1`, or `NFDG = 2`, much of Fig. 3 is inapplicable and can be omitted.

### SECTION VI

### PARAMETERS DEFINED IN CONMIN AND ASSOCIATED ROUTINES

    ITER     Iteration number.  The optimization process is iterative so
             that the vector of decision variables at the Kth iteration
             is defined by X(K) = X(K - 1) + ALPHA*S(K), where in this case
             K refers to the iteration number and the components X(I) are
             all changed simultaneously.  ALPHA is defined as the move
             parameter and is printed if the print control IPRINT.GE.3.
             S is the move direction.

    NCAL(4)  Bookkeeping information.  NCAL(1) gives the number of times
             external routine SUB1 was called with INFO = 1.  NCAL(2) gives
             the number of times INFO = 2.  NCAL(3) gives the number of times
             INFO = 3 and NCAL(4) gives the number of times INFO = 4.

    S(N3)    Move direction in the NDV-dimensional optimization space.  S(I)
             gives the rate at which variable X(I) changes with respect to
             ALPHA.

    G1(N7)   Not used if NCON = NSIDE = NSCAL = 0.  Used for temporary
             storage of constraint values G(J), J = 1, NCON and decision
             variables X(I), I = 1, NDV.

    G2(N2)   Not used if NCON = NSIDE = 0.  Used for temporary storage of
             constraint values G(J), J = 1, NCON.

    B(N4,N4) Not used if NCON = NSIDE = 0.  Used in determining direction
             vector S for constrained minimization problems.  Array B may
             be used for temporary storage in external routine SUB1.

    C(N9)    Not used in NCON = NSIDE = 0.  Used with array B in determining
             direction vector S for constrained minimization problems.  Used
             for temporary storage of vector X if NSCAL.NE.0. routine SUB1.

    MS1(N6)  Not used if NCON = NSIDE = 0.  Used with array B in determining
             direction vector S for constrained minimization problems.  Array
             MS1 may be used for temporary storage in external routine SUB1.

### SECTION VII

### REQUIRED DIMENSIONS OF ARRAYS
[ENTIRE SECTION SUPERCEDED BY THE ADDENDUM]

    COMMON/CNMN2/X(N1), DF(N1), G(N2), ISC(N8), IC(N4), A(N4,N3)
    COMMON/CNMN3/S(N3), G1(N7), G2(N2), C(N9), MS1(N6), B(N4,N4)
    COMMON/CNMN4/VLB(N1), VUB(N1), SCAL(N5)

Dimensions `N1` through `N7` are minimum dimensions on the arrays and are defined by:

         N1 = NDV

         N2 = 1 if NCON = NSIDE = 0
            = NCON if NCON.GT.0 and NSIDE = 0
            = 2*NDV if NCON = 0 and NSIDE.GT.0
            = NCON + 2*NDV is NCON.GT.0 and NSIDE.GT.0

         N3 = NDV + 2

         N4 = 1 if NCON = NSIDE = 0
              NACMX1 if NCON.GT.0 or NSIDE.GT.0

         N5 = 1 if NSCAL = 0
            = N1 if NSCAL.NE.0

         N6 = 1 if NCON = NSIDE = 0
            = 2*N4 if NCON.GT.0 or NSIDE.GT.0

         N7 = N2 if NSCAL = 0
            = MAX(N2, NDV) if NSCAL.NE.0

         N8 = 1 if NCON = 0
            = NCON if NCON.GT.0

         N9 = N4 if NFDG.EQ.0
            = MAX(N4, NDV) if NFDG.GT.0

### SECTION VIII

### EXAMPLES
[These examples have been revised to use the MAY 1978 version of CONMIN]

In this section several examples are presented, together with results, to provide a better understanding of the program organization. In each case the default values are used for control parameters unless otherwise noted.

The examples were solved using a CDC 7600 computer. The numerical results obtained using other computers may differ slightly from those obtained here.

EXAMPLE 1 - CONSTRAINED ROSEN-SUZUKI FUNCTION. NO GRADIENT INFORMATION.

Consider the minimization problem discussed in SECTION I:

         MINIMIZE OBJ = X(1)**2 - 5*X(1) + X(2)**2 - 5*X(2) +
                        2*X(3)**2 - 21*X(3) + X(4)**2 + 7*X(4) + 50

         Subject to:

              G(1) = X(1)**2 + X(1) + X(2)**2 - X(2) +
                     X(3)**2 + X(3) + X(4)**2 - X(4) - 8   .LE.0

              G(2) = X(1)**2 - X(1) + 2*X(2)**2 + X(3)**2 +
                     2*X(4)**2 - X(4) - 10                  .LE.0

              G(3) = 2*X(1)**2 + 2*X(1) + X(2)**2 - X(2) +
                     X(3)**2 - X(4) - 5                     .LE.0

This problem is solved beginning with an initial `X`-vector of

         X = (1.0, 1.0, 1.0, 1.0)

The optimum design is known to be

         OBJ = 6.000

and the corresponding `X`-vector is

         X = (0.0, 1.0, 2.0, -1.0)

The print control parameter of `IPRINT = 2` is used and all gradients are calculated by finite difference. The maximum number of iterations is taken as `ITMAX = 40` to insure normal termination. The variables are not scaled, so `NSCAL = 0`. The objective function is nonlinear, so `LINOBJ = 0`. The control parameters are defined as:

         IPRINT = 2, NDV = 4, ITMAX = 40, NCON = 3
         NSIDE=ICNDIR=NSCAL=LINOBJ=ITRM = 0.
         FDCH=FDCHM=CT=CTMIN=CTL=CTLMIN=THETA=PHI=DELFUN=DABFUN = 0.

All constraints are nonlinear so the linear constraint identification vector contains all zeros:

ISC(J) = 0 J = 1, NCON The main program and analysis subroutine `ANALYS` are listed in Listing 1 and Listing 2 respectively, with the optimization results in Listing 3. An optimum design of `OBJ = 6.01` is obtained with the corresponding decision variables:

         X = (0.0194, 0.995, 1.99, -1.01)

Note that the unconstrained minimum of this function may be found by setting `NCON = 0` in the main program. The unconstrained minimum of `OBJ = -30.0` may be found in this way, and this is left as an exercise.

An additional problem of interest is to set `NCON = 2` and, having found the optimum subject to these first two constraints only, increase `NCON` to 3 and call CONMIN again, to obtain the final optimum design. This is easily done by initially setting `NCON = 2` in the main program, then immediately after returning from CONMIN, set `NCON = 3` and call CONMIN again. It is not necessary to reinitialize the control parameters. This exercise demonstrates the capability of CONMIN to deal with initially infeasible designs, and such an option may be desirable when minimizing functions for which one or more constraints are difficult or time-consuming to evaluate. In this way, the optimization problem may be first solved by ignoring constraints which are particularly complex. These constraints are then checked to determine if they are violated. If not, the optimization is complete. If one or more such constraints are violated, they are added to the set of constraints, `G(J)`, and CONMIN is called again to obtain the final optimum design. This approach cannot always be expected to be most efficient, but does merit consideration, especially when only moderate constraint violations are expected.

EXAMPLE 2 - CONSTRAINED ROSEN-SUZUKI FUNCTION WITH ANALYTIC GRADIENTS

The function minimized in EXAMPLE 1 is now solved by computing all analytic gradients in closed form. All control parameters are the same as before except for NFDG and IPRINT. The gradient of the objective function with respect to the decision variables is:

                     | 2*X(1) -  5 |
        grad(OBJ) =  | 2*X(2) -  5 |
                     | 4*X(3) - 21 |
                     | 2*X(4) +  7 |

The gradients of the constraint functions are:

                      | 2*X(1) + 1 |                     | 2*X(1) - 1 |
        grad(G(1)) =  | 2*X(2) - 1 |        grad(G(2)) = | 4*X(2)     |
                      | 2*X(3) + 1 |                     | 2*X(3)     |
                      | 2*X(4) - 1 |                     | 4*X(4) - 1 |

                      | 4*X(1) + 2 |
        grad(G(3)) =  | 2*X(2) - 1 |
                      | 2*X(3)     |
                      |   - 1      |

The main program is the same as before (Listing 1). The subroutine is in Listing 4 and the optimization results in Listing 5, where an optimum design of `OBJ = 6.01` is obtained with

         X = (0.027, 0.995, 1.98, -1.01)

The additional exercises described in example 1 may also be solved here, just as before.

EXAMPLE 3 - 3-BAR TRUSS.

As a final example, consider the 3-bar truss shown in Fig. 9. The structure is subjected to two symmetric, but independent load conditions, P1 and P2, as shown. The truss is to be designed for minimum weight, subject to stress limitations only, so that:

         -15 KSI .LE. SIGIJ .LE. 20 KSI     I = 1,3     J = 1,2

where `SIGIJ` is the stress in member `I` under load condition `J`. While this is a very simple structure, it is of particular historical significance in the field of automated structural design, having been first used by Schmit (ref. 5) to demonstrate that an optimally designed structure may not be fully stressed. That is, one or more members may not be stressed to their maximum design stress under any of the applied load conditions.

The design variables are chosen as the member cross-sectional areas, `A1` and `A2`, where `A3 = A1` due to symmetry. Then the objective function is:

         OBJ = 10*RHO*(2*SQRT(2)*A1 + A2)

where `RHO` is the material density (`RHO = 0.1`). The stress state is defined by:

         SIG11 = SIG32 = 20.*(SQRT(2.)*A1 + A2)/(2.*A1*A2 + SQRT(2.)*A1*A1)

         SIG21 = SIG22 = 20.*SQRT(2.)*A1/(2.*A1*A2+SQRT(2.)*A1*A1)

         SIG31 = SIG13 = -20.*A2/(2.*A1*A2+SQRT(2.)*A1*A1)

Remembering that `-15 KSI .LE. SIGIJ .LE. 20 KSI,` there are six independent nonlinear constraints. The compressive stress constraint on member 1 under load condition 1 is given as:

         -SIG11 - 15.0 .LE. 0

or in normalized form:

         -SIG11/15.0 -1 .LE. 0

Similarly:

          SIG11/20.0 -1 .LE. 0

         -SIG21/15.0 -1 .LE. 0

          SIG21/20.0 -1 .LE. 0

         -SIG31/15.0 -1 .LE. 0

          SIG31/20.0 -1 .LE. 0

Because negative member areas are not physically meaningful, lower bounds of zero must be imposed on the design variables. However, noting that the stress, `SIGIJ`, is undefined if `A1` equals zero, lower bounds of 0.001 will be prescribed. The upper bounds are taken as 1.0E + 10 to insure that these bounds will never be active.

The objective function is linear in `A1` and `A2` so the linear objective function identifier is taken as `LINOBJ = 1`.

The gradient of `OBJ` is easily calculated so this will be done analytically, while the gradients of the constraint functions are calculated by finite difference. Then the gradient of `OBJ` is defined by:

                       | 20.0*SQRT(2.0)*RHO |
         grad(OBJ)  =  |                    |
                       | 10.0*RHO           |

The print control will be taken as `IPRINT = 1` and the default values are used for all other control parameters. Then the control parameters are defined as:

         IPRINT = 1, NDV = 2, NCON = 6, NSIDE = 1, NFDG = 2, LINOBJ = 1,
         ITMAX = ICNDIR = NSCAL = ITRM = DABFUN = 0,
         FDCH = FDCHM = CT = CTMIN = CTL = CTLMIN = THETA = PHI = DELFUN = 0.

All constraints are nonlinear so the linear constraint identification vector contains all zeros:

         ISC(J) = 0     J = 1, NCON

The lower and upper bounds are defined as:

         VLB(I) = 0.001     VUB(I) = 1.0E+10     I = 1, NDV

The optimum design is known to be

         OBJ = 2.639

where

         X = (0.789, 0.408)

The main program and analysis subroutine for this example is in Listing 6 The optimization results are given in Listing 7, where:

         OBJ = 2.63

and

         X = (0.78, 0.43)

Note that only constraint number 2 (the tensile stress constraint in member 1 under load condition 1) is active. These results were produced on a MicroVAX workstation using single precision arithmetic.

### APPENDIX A

### SUMMARY OF PARAMETERS USED BY CONMIN

COMMON BLOCKS:

         COMMON /CNMN1/ IPRINT, NDV, ITMAX, NCON, NSIDE, ICNDIR, NSCAL, NFDG,
        1 FDCH, FDCHM, CT, CTMIN, CTL, CTLMIN, THETA, PHI, NAC, NACMX1, DELFUN,
        2 DABFUN, LINOBJ, ITRM, ITER, NCAL(4)

         COMMON /CNMN2/ X(N1), DF(N1), G(N2), ISC(N8), IC(N4), A(N4,N3)

         COMMON /CNMN3/ S(N3), G1(N7), G2(N2), C(N9), MS1(N6), B(N4,N4)

         COMMON /CNMN4/ VLB(N1), VUB(N1), SCAL(N5)

CALL STATEMENTS:

         CALL CONMIN (SUB1, OBJ)

         CALL SUB1(INFO, OBJ)

PARAMETERS DEFINED IN THE MAIN PROGRAM:

    PARAMETERS  DEFAULT          DEFINITION

      IPRINT                Print control.

      NDV                   Number of decision variables, X(I).

      ITMAX     10          Maximum number of iterations in the
                            minimization process.

      NCON                  Number of constraint functions, G(J).

      NSIDE                 Side constraint parameter.
                            NSIDE.GT.0 indicates that lower and upper
                            bounds are imposed on the decision variables.

      ICNDIR   NDV + 1      Conjugate direction restart parameter.
                            Restart with steepest descent move every
                            ICNDIR iterations.

      NSCAL                 Scaling control parameter.
                            NSCAL.LT.0, user supplies scaling vector.
                            NSCAL.EQ.0, no scaling, NSCAL.GT.0, automatic
                            linear scaling every NSCAL iterations.

      NFDG                  Gradient calculation control parameter.

      FDCH       0.01       Relative change in decision variable, X(I),
                            in calculating finite difference gradients.

      FDCHM      0.01       Minimum absolute step in finite difference
                            gradient calculations.

      CT        -0.1        Constraint thickness parameter.

      CTMIN      0.004      Minimum absolute value of CT considered
                            in optimization process.

      CTL       -0.01       Constraint thickness parameter for linear
                            and side constraints.

      CTLMIN     0.001      Minimum absolute value of CTL considered
                            in optimization process.

      THETA      1.0        Mean value of push-off factor in method
                            of feasible directions.

      PHI        5.0        Participation coefficient, used if one or more
                            constraints are violated.

      NACMX1                1 plus user's best estimate of the maximum
                            number of constraints (including side constraints)
                            which will be active or violated at any time
                            in the minimization process.

      DELFUN     0.001      Minimum relative change in objective function,
                            OBJ, to indicate convergence.

      DABFUN     0.001*initial OBJ   Minimum absolute change in objective
    				 function, OBJ, to indicate convergence.

      LINOBJ                Linear objective function identifier.
                            LINOBJ = 1 if OBJ is specifically known to be
                            linear in X(I).  LINOBJ = 0 if OBJ is nonlinear.

      ITRM       3          Number of consecutive iterations to indicate
                            convergence by relative or absolute changes,
                            DELFUN or DABFUN.

      X                     Vector of decision variables.

      VLB                   Vector of lower bounds on decision variables.

      VUB                   Vector of upper bounds on decision variables.

      SCAL                  Vector of scaling parameters.

      ISC                   Linear constraint identification vector.

PARAMETERS DEFINED IN EXTERNAL ROUTINE SUB1:

    PARAMETER            DEFINITION

      OBJ          Value of objective function.

      G            Vector of constraint values.

      DF           Analytic gradient of objective function.

      NAC          Number of active and violated constraints (G(J).GE.CT).

      A            Matrix containing analytic gradients of active
                   or violated constraints.

      IC           Identifies which constraints are active or violated.

PARAMETERS DEFINED IN CONMIN AND ASSOCIATED ROUTINES

    PARAMETER            DEFINITION

      ITER         Iteration number.

      NCAL(4)      Bookkeeping information.  NCAL(I) gives number of
                   times that INFO = I during optimization process.

      S            Direction vector.

      G1           Temporary storage of vectors G and X.

      G2           Temporary storage of vector G.

      B            Used in finding usable-feasible direction.

      C            Used in finding usable-feasible direction and for
                   temporary storage of vector X.

### APPENDIX B

### CONMIN SUBROUTINE DESCRIPTIONS

Following is a list of the subroutines associated with CONMIN. If the array dimensions are changed from those currently used, the common blocks in each routine must be changed accordingly.

    CONMIN    Main optimization routine.

    CNMN01    Routine to calculate gradient information by finite
              difference.

    CNMN02    Calculate direction of steepest descent, or conjugate
              direction in unconstrained function minimization.

    CNMN03    Solve one-dimensional search in unconstrained function
              minimization.

    CNMN04    Find minimum of one-dimensional function by polynomial
              interpolation.

    CNMN05    Determine usable-feasible, or modified usable-feasible,
              direction in constrained function minimization.

    CNMN06    Solve one-dimensional search for constrained function
              minimization.

    CNMN07    Find zero of one-dimensional function by polynomial
              interpolation.

    CNMN08    Solve special linear programming problem in determination
              of usable-feasible, or modified usable-feasible direction
              in constrained function minimization.

    CNMN09    Unscale and rescale decision variables before and after
              function evaluation.

###

###

###

###

###

###

###

###

###

###

###

###

###

###

###

    LISTING 1
    MAIN PROGRAM FOR EXAMPLES 1 & 2

    CCCCC
          PROGRAM EXAMPL1
          DIMENSION S(6),G1(11),G2(11),B(11,11),C(11),MS1(22)
          DIMENSION VLB(6),VUB(6),SCAL(6),DF(6),A(6,11),
         .              ISC(11),IC(11)
          COMMON /CNMN1/ DELFUN,DABFUN,FDCH,FDCHM,CT,CTMIN,CTL,CTLMIN,
         .               ALPHAX,ABOBJ1,THETA,OBJ,NDV,NCON,NSIDE,IPRINT,
         .               NFDG,NSCAL,LINOBJ,ITMAX,ITRM,ICNDIR,IGOTO,NAC,
         .               INFO,INFOG,ITER
          COMMON /VARABLE/ AOBJ,X(6),G(11)
          COMMON /ANDATA/ LOOPCNT
          NAMELIST /CONPAR/ INFOG,INFO,NFDG,IPRINT,NDV,ITMAX,NCON,NSIDE,
         .                  ICNDIR,NSCAL,FDCH,FDCHM,CT,CTMIN,CTLMIN,THETA,
         .                  PHI,DELFUN,DABFUN,LINOBJ,ITRM,X,VLB,VUB,
         .                  N1,N2,N3,N4,N5,ALPHAX,ABOBJ1,CTL,ISC,SCAL
    C
    C     THIS PROGRAM EXECUTES THE EXAMPLE PROBLEM ONE OF THE CONMIN
    C     MANUAL.
    C
    C
    C  INITIALIZE
    C
          INFOG=0
          INFO=0
          NFDG=0
          IPRINT=2
          NDV=4
          ITMAX=40
          NCON=3
          NSIDE=0
          ICNDIR=0
          NSCAL=0
          FDCH=0.0
          FDCHM=0.0
          CT=0.0
          CTMIN=0.0
          CTL=0.0
          CTLMIN=0.0
          THETA=0.0
          PHI=0.0
          DELFUN=0.0
          DABFUN=0.0
          LINOBJ=0.0
          ITRM=0
          N1=6
          N2=11
          N3=11
          N4=11
          N5=22
          ALPHAX=0.0
          ABOBJ1=0.0
          CTL=0.0
          DO 5 I=1,NDV
            X(I)=1.0
            VLB(I)=-99999.
            VUB(I)= 99999.
        5 CONTINUE
    C
          DO 6 J=1,NCON
            ISC(J)=0
        6 CONTINUE
    C
    C     READ THE PARAMETERS FOR CONMIN
    C
    CCC   READ(5,CONPAR)                  USE DEFAULT VALUES
          WRITE(6,CONPAR)
          NLIM=ITMAX*(NDV+5)
    C
    C     NON-ITERATIVE PART OF ANALYSIS
    C
          IGOTO = 0
    C
    C     ITERATIVE PART OF ANALYSIS
    C
          DO 1000 I = 1,NLIM
            LOOPCNT=I
    C
    C       CALL THE OPTIMIZATION ROUTINE CONMIN
    C
            CALL CONMIN(X,VLB,VUB,G,SCAL,DF,A,S,G1,G2,B,C,ISC,IC,MS1,N1,N2,
         .              N3,N4,N5)
    C
            IF(IGOTO.EQ.0) LOOPCNT=-999
    C
    C       ANALYSIS MODULE
    C
            CALL ANALYS
            OBJ=AOBJ
            IF (IGOTO.EQ.0) GO TO 1100
     1000 CONTINUE
    C
    C
     1100 CONTINUE
          STOP
          END
    CCCCC

    LISTING 2
    ANALYSIS SUBROUTINE FOR EXAMPLE 1

    CCCCC
          SUBROUTINE ANALYS
          COMMON /VARABLE/ AOBJ,X(6),G(11)
    C
    C   ROUTINE TO CALCULATE OBJECTIVE FUNCTION AND
    C   CONSTRAINTS
    C
    C
    C  OBJECTIVE FUNCTION
    C
          AOBJ = X(1)**2 - 5.*X(1) + X(2)**2 - 5.*X(2) + 2.*X(3)**2
         .       - 21.*X(3) + X(4)**2 + 7.0*X(4) + 50.
    C
    C
    C   CONSTRAINT VALUES
    C
          G(1) = X(1)**2 + X(1) + X(2)**2 - X(2) + X(3)**2 + X(3)
         .       + X(4)**2 - X(4) - 8.0
    C
          G(2) = X(1)**2 - X(1) + 2. * X(2)**2 + X(3)**2 + 2.*X(4)**2
         .       - X(4) - 10.0
    C
          G(3) = 2.*X(1)**2 + 2.*X(1) + X(2)**2 - X(2) + X(3)**2 - X(4) -5.0
    C
          RETURN
          END
    CCCCC

    LISTING 3
    OPTIMIZATION RESULTS FOR EXAMPLE 1

    1$CONPAR
    INFOG   = 0,
    INFO    = 0,
    NFDG    = 0,
    IPRINT  = 2,
    NDV     = 4,
    ITMAX   = 40,
    NCON    = 3,
    NSIDE   = 0,
    ICNDIR  = 0,
    NSCAL   = 0,
    FDCH    = 0.0,
    FDCHM   = 0.0,
    CT      = 0.0,
    CTMIN   = 0.0,
    CTLMIN  = 0.0,
    THETA   = 0.0,
    PHI     = 0.0,
    DELFUN  = 0.0,
    DABFUN  = 0.0,
    LINOBJ  = 0,
    ITRM    = 0,
    X       = .1E+01, .1E+01, .1E+01, .1E+01, 0.0, 0.0,
    VLB     = -.99999E+05, -.99999E+05, -.99999E+05, -.99999E+05, 0.0, 0.0,
    VUB     = .99999E+05, .99999E+05, .99999E+05, .99999E+05, 0.0, 0.0,
    N1      = 6,
    N2      = 11,
    N3      = 11,
    N4      = 11,
    N5      = 22,
    ALPHAX  = 0.0,
    ABOBJ1  = 0.0,
    CTL     = 0.0,
    ISC     = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    SCAL    = 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
    $END

                * * * * * * * * * * * * * * * * * * * * * * * * * * *
                *                                                   *
                *                    C O N M I N                    *
                *                                                   *
                *                FORTRAN PROGRAM FOR                *
                *                                                   *
                *         CONSTRAINED FUNCTION MINIMIZATION         *
                *                                                   *
                * * * * * * * * * * * * * * * * * * * * * * * * * * *

         CONSTRAINED FUNCTION MINIMIZATION

         CONTROL PARAMETERS

         IPRINT  NDV    ITMAX    NCON    NSIDE  ICNDIR   NSCAL   NFDG
           2       4      40       3       0       5       0       0

         LINOBJ  ITRM     N1      N2      N3      N4      N5
           0       3       6      11      11      11      22

             CT              CTMIN           CTL             CTLMIN
          -.10000E+00      .40000E-02     -.10000E-01      .10000E-02

             THETA           PHI             DELFUN          DABFUN
           .10000E+01      .50000E+01      .10000E-03      .31000E-01

             FDCH            FDCHM           ALPHAX          ABOBJ1
           .10000E-01      .10000E-01      .10000E+00      .10000E+00

         ALL CONSTRAINTS ARE NON-LINEAR

         INITIAL FUNCTION INFORMATION

         OBJ =    .310000E+02

         DECISION VARIABLES (X-VECTOR)
           1)     .10000E+01   .10000E+01   .10000E+01   .10000E+01

         CONSTRAINT VALUES (G-VECTOR)
           1)    -.40000E+01  -.60000E+01  -.10000E+01

         ITER =    1     OBJ =    .25484E+02

         DECISION VARIABLES (X-VECTOR)
           1)     .10436E+01   .10436E+01   .12479E+01   .86847E+00

         CONSTRAINT VALUES (G-VECTOR)
           1)    -.31307E+01  -.55788E+01  -.56843E-13

         ITER =    2     OBJ =    .12204E+02

         DECISION VARIABLES (X-VECTOR)
           1)    -.65498E+00   .10325E+01   .23572E+01   .13804E+00

         CONSTRAINT VALUES (G-VECTOR)
           1)    -.39775E+00  -.13275E+01  -.76739E-12

         ITER =    3     OBJ =    .83763E+01

         DECISION VARIABLES (X-VECTOR)
           1)     .22440E+00   .99268E+00   .20345E+01  -.31841E+00

         CONSTRAINT VALUES (G-VECTOR)
           1)    -.11388E+01  -.35427E+01  -.85265E-13

         ITER =    4     OBJ =    .69420E+01

         DECISION VARIABLES (X-VECTOR)
           1)    -.34392E+00   .10043E+01   .21498E+01  -.80388E+00

         CONSTRAINT VALUES (G-VECTOR)
           1)    -.11369E-12  -.80266E+00  -.21613E-01

         ITER =    5     OBJ =    .63271E+01

         DECISION VARIABLES (X-VECTOR)
           1)    -.67566E-01   .10136E+01   .20734E+01  -.81323E+00

         CONSTRAINT VALUES (G-VECTOR)
           1)    -.20225E+00  -.14382E+01   .28422E-13

         ITER =    6     OBJ =    .61723E+01

         DECISION VARIABLES (X-VECTOR)
           1)    -.94581E-01   .99247E+00   .20400E+01  -.96346E+00

         CONSTRAINT VALUES (G-VECTOR)
           1)    -.56843E-13  -.94507E+00  -.53852E-01

         ITER =    7     OBJ =    .60706E+01

         DECISION VARIABLES (X-VECTOR)
           1)     .74640E-01   .98928E+00   .19478E+01  -.10562E+01

         CONSTRAINT VALUES (G-VECTOR)
           1)    -.16766E-01  -.10302E+01  -.28422E-13

         ITER =    8     OBJ =    .60218E+01

         DECISION VARIABLES (X-VECTOR)
           1)    -.17653E-01   .10038E+01   .20139E+01  -.97523E+00

         CONSTRAINT VALUES (G-VECTOR)
           1)    -.17726E-01  -.10338E+01  0.

         ITER =    9     OBJ =    .60182E+01

         DECISION VARIABLES (X-VECTOR)
           1)     .23921E-01   .99428E+00   .19869E+01  -.10102E+01

         CONSTRAINT VALUES (G-VECTOR)
           1)    -.15891E-01  -.10472E+01   .11747E-02

         ITER =   10     OBJ =    .60133E+01

         DECISION VARIABLES (X-VECTOR)
           1)    -.17147E-01   .10055E+01   .20139E+01  -.97533E+00

         CONSTRAINT VALUES (G-VECTOR)
           1)    -.15050E-01  -.10270E+01   .29211E-02

         ITER =   11     OBJ =    .60098E+01

         DECISION VARIABLES (X-VECTOR)
           1)     .19441E-01   .99482E+00   .19908E+01  -.10058E+01

         CONSTRAINT VALUES (G-VECTOR)
           1)    -.13894E-01  -.10474E+01   .34703E-02

        FINAL OPTIMIZATION INFORMATION

         OBJ =    .600982E+01

         DECISION VARIABLES (X-VECTOR)
           1)     .19441E-01   .99482E+00   .19908E+01  -.10058E+01

         CONSTRAINT VALUES (G-VECTOR)
           1)    -.13894E-01  -.10474E+01   .34703E-02

         THERE ARE    2 ACTIVE CONSTRAINTS
         CONSTRAINT NUMBERS ARE
             1    3

         THERE ARE    0 VIOLATED CONSTRAINTS

         TERMINATION CRITERION
              ABS(OBJ(I)-OBJ(I-1))   LESS THAN DABFUN FOR  3 ITERATIONS

         NUMBER OF ITERATIONS =   11

         OBJECTIVE FUNCTION WAS EVALUATED           78  TIMES

         CONSTRAINT FUNCTIONS WERE EVALUATED        78  TIMES

    LISTING 4
    ANALYSIS SUBROUTINE FOR EXAMPLE 2

    CCCCC
          PROGRAM EXAMPL2
          DIMENSION S(6),G1(11),G2(11),B(11,11),C(11),MS1(22)
          DIMENSION VLB(6),VUB(6),SCAL(6)
          COMMON/GRAD/ ISC(11),IC(11),DF(6),A(6,11)
          COMMON /CNMN1/ DELFUN,DABFUN,FDCH,FDCHM,CT,CTMIN,CTL,CTLMIN,
         .               ALPHAX,ABOBJ1,THETA,OBJ,NDV,NCON,NSIDE,IPRINT,
         .               NFDG,NSCAL,LINOBJ,ITMAX,ITRM,ICNDIR,IGOTO,NAC,
         .               INFO,INFOG,ITER
          COMMON /VARABLE/ AOBJ,X(6),G(11)
          COMMON /ANDATA/ LOOPCNT
          NAMELIST /CONPAR/ INFOG,INFO,NFDG,IPRINT,NDV,ITMAX,NCON,NSIDE,
         .                  ICNDIR,NSCAL,FDCH,FDCHM,CT,CTMIN,CTLMIN,THETA,
         .                  PHI,DELFUN,DABFUN,LINOBJ,ITRM,X,VLB,VUB,
         .                  N1,N2,N3,N4,N5,ALPHAX,ABOBJ1,CTL,ISC,SCAL
    C
    C     THIS PROGRAM EXECUTES THE EXAMPLE PROBLEM TWO OF THE CONMIN MANUAL.

          OPEN( UNIT=6,FILE='EXOUT2.TXT',STATUS='NEW')
    C
    C
    C  INITIALIZE
    C
          INFOG=0
          INFO=0
          NFDG=1
          IPRINT=1
          NDV=4
          ITMAX=40
          NCON=3
          NSIDE=0
          ICNDIR=0
          NSCAL=0
          FDCH=0.0
          FDCHM=0.0
          CT=0.0
          CTMIN=0.0
          CTL=0.0
          CTLMIN=0.0
          THETA=0.0
          PHI=0.0
          DELFUN=0.0
          DABFUN=0.0
          LINOBJ=0.0
          ITRM=0
          N1=6
          N2=11
          N3=11
          N4=11
          N5=22
          ALPHAX=0.0
          ABOBJ1=0.0
          CTL=0.0
          DO 5 I=1,NDV
            X(I)=1.0
            VLB(I)=-99999.
            VUB(I)= 99999.
        5 CONTINUE
    C
          DO 6 J=1,NCON
            ISC(J)=0
        6 CONTINUE
    C
    C     READ THE PARAMETERS FOR CONMIN
    C
    CCC   READ(5,CONPAR)      USE DEFAULT VALUES
          WRITE(6,CONPAR)
          NLIM=ITMAX*(NDV+5)
    C
    C     NON-ITERATIVE PART OF ANALYSIS
    C
          IGOTO = 0
    C
    C     ITERATIVE PART OF ANALYSIS
    C
          DO 1000 I = 1,NLIM
            LOOPCNT=I
    C
    C       CALL THE OPTIMIZATION ROUTINE CONMIN
    C
            CALL CONMIN(X,VLB,VUB,G,SCAL,DF,A,S,G1,G2,B,C,ISC,IC,MS1,N1,N2,
         .              N3,N4,N5)
    C
            IF(IGOTO.EQ.0) LOOPCNT=-999
    C
    C       ANALYSIS MODULE
    C
            CALL ANALYS
            OBJ=AOBJ
            IF (IGOTO.EQ.0) GO TO 1100
     1000 CONTINUE
    C
    C
     1100 CONTINUE
          STOP
          END

          SUBROUTINE ANALYS
          COMMON /VARABLE/ AOBJ,X(6),G(11)
          COMMON/GRAD/ ISC(11),IC(11),DF(6),A(6,11)
          COMMON /CNMN1/ DELFUN,DABFUN,FDCH,FDCHM,CT,CTMIN,CTL,CTLMIN,
         .               ALPHAX,ABOBJ1,THETA,OBJ,NDV,NCON,NSIDE,IPRINT,
         .               NFDG,NSCAL,LINOBJ,ITMAX,ITRM,ICNDIR,IGOTO,NAC,
         .               INFO,INFOG,ITER
    C
    C   ROUTINE TO CALCULATE OBJECTIVE FUNCTION AND
    C   CONSTRAINT  VALUES FOR OPTIMIZATION OF CONSTRAINED ROSEN-SUZUKI
    C   FUNCTION.
    C
    C
          IF(INFO.GE.2) GO TO 10
    C
    C  OBJECTIVE FUNCTION
    C
          AOBJ = X(1)**2 - 5.*X(1) + X(2)**2 - 5.*X(2) + 2.*X(3)**2
         .       - 21.*X(3) + X(4)**2 + 7.0*X(4) + 50.
    C
    C
    C   CONSTRAINT VALUES
    C
          G(1) = X(1)**2 + X(1) + X(2)**2 - X(2) + X(3)**2 + X(3)
         .       + X(4)**2 - X(4) - 8.0
    C
          G(2) = X(1)**2 - X(1) + 2. * X(2)**2 + X(3)**2 + 2.*X(4)**2
         .       - X(4) - 10.0
    C
          G(3) = 2.*X(1)**2 + 2.*X(1) + X(2)**2 - X(2) + X(3)**2 - X(4) -5.0
    C
          GO TO 999
       10 CONTINUE
    C
    C
    C    GRADIENT INFORMATION
    C
          DF(1)=2.0*X(1) - 5.0
          DF(2)=2.0*X(2) - 5.0
          DF(3)=4.0*X(3) - 21.
          DF(4)=2.0*X(4) + 7.
    C
    C  GRADIENTS OF ACTIVE AND VIOLATED CONSTRAINTS
    C
          NAC=0
          IF(G(1).LT.CT) GO TO 20
          NAC=1
          IC(1)=1
          A(1,1)=2.*X(1)+1.
          A(2,1)=2.*X(2)-1.
          A(3,1)=2.*X(3)+1.
          A(4,1)=2.*X(4)-1.
    C
       20 IF(G(2).LT.CT) GO TO 30
          NAC=NAC+1
          IC(NAC)=2
          A(1,NAC)=2.*X(1)-1.0
          A(2,NAC)=4.*X(2)
          A(3,NAC)=2.*X(3)
          A(4,NAC)=4.*X(4)-1.0
    C
       30 IF(G(3).LT.CT) GO TO 999
          NAC=NAC+1
          IC(NAC)=3
          A(1,NAC)=4.*X(1)+2.
          A(2,NAC)=2.*X(2)-1.
          A(3,NAC)=2.*X(3)
          A(4,NAC)=-1.
      999 RETURN
          END

    CCCCC

    LISTING 5
    OPTIMIZATION RESULTS FOR EXAMPLE 2

     $CONPAR
     INFOG   =           0,
     INFO    =           0,
     NFDG    =           1,
     IPRINT  =           1,
     NDV     =           4,
     ITMAX   =          40,
     NCON    =           3,
     NSIDE   =           0,
     ICNDIR  =           0,
     NSCAL   =           0,
     FDCH    =  0.0000000E+00,
     FDCHM   =  0.0000000E+00,
     CT      =  0.0000000E+00,
     CTMIN   =  0.0000000E+00,
     CTLMIN  =  0.0000000E+00,
     THETA   =  0.0000000E+00,
     PHI     =  0.0000000E+00,
     DELFUN  =  0.0000000E+00,
     DABFUN  =  0.0000000E+00,
     LINOBJ  =           0,
     ITRM    =           0,
     X       = 4*1.000000    , 2*0.0000000E+00,
     VLB     = 4*-99999.00    , 2*0.0000000E+00,
     VUB     = 4*99999.00    , 2*0.0000000E+00,
     N1      =           6,
     N2      =          11,
     N3      =          11,
     N4      =          11,
     N5      =          22,
     ALPHAX  =  0.0000000E+00,
     ABOBJ1  =  0.0000000E+00,
     CTL     =  0.0000000E+00,
     ISC     = 11*0,
     SCAL    = 6*0.0000000E+00
     $END

                * * * * * * * * * * * * * * * * * * * * * * * * * * *
                *                                                   *
                *                    C O N M I N                    *
                *                                                   *
                *                FORTRAN PROGRAM FOR                *
                *                                                   *
                *         CONSTRAINED FUNCTION MINIMIZATION         *
                *                                                   *
                * * * * * * * * * * * * * * * * * * * * * * * * * * *

         INITIAL FUNCTION INFORMATION

         OBJ =   0.310000E+02

         DECISION VARIABLES (X-VECTOR)
           1)    0.10000E+01  0.10000E+01  0.10000E+01  0.10000E+01

         CONSTRAINT VALUES (G-VECTOR)
           1)   -0.40000E+01 -0.60000E+01 -0.10000E+01

        FINAL OPTIMIZATION INFORMATION

         OBJ =   0.601078E+01

         DECISION VARIABLES (X-VECTOR)
           1)    0.26916E-01  0.99458E+00  0.19848E+01 -0.10128E+01

         CONSTRAINT VALUES (G-VECTOR)
           1)   -0.14837E-01 -0.10438E+01  0.21458E-02

         THERE ARE    2 ACTIVE CONSTRAINTS
         CONSTRAINT NUMBERS ARE
             1    3

         THERE ARE    0 VIOLATED CONSTRAINTS

         TERMINATION CRITERION
              ABS(OBJ(I)-OBJ(I-1))   LESS THAN DABFUN FOR  3 ITERATIONS

         NUMBER OF ITERATIONS =   11

         OBJECTIVE FUNCTION WAS EVALUATED           34  TIMES

         CONSTRAINT FUNCTIONS WERE EVALUATED        34  TIMES

         GRADIENT OF OBJECTIVE WAS CALCULATED       11  TIMES

         GRADIENTS OF CONSTRAINTS WERE CALCULATED   11  TIMES

    LISTING 6
    MAIN PROGRAM AND ANALYSIS SUBROUTINE FOR EXAMPLE 3

    ccccc
          PROGRAM EXAMPL3
          DIMENSION S(4),G1(10),G2(10),B(10,10),C(10),MS1(20)
          DIMENSION VLB(4),VUB(4),SCAL(4)
          COMMON /VARABLE/ AOBJ,X(4),G(10)
          COMMON/GRAD/ ISC(10),IC(10),DF(4),A(4,10)
          COMMON/CONSAV/ RNUM(50),INUM(25)
          COMMON /CNMN1/ DELFUN,DABFUN,FDCH,FDCHM,CT,CTMIN,CTL,CTLMIN,
         .               ALPHAX,ABOBJ1,THETA,OBJ,NDV,NCON,NSIDE,IPRINT,
         .               NFDG,NSCAL,LINOBJ,ITMAX,ITRM,ICNDIR,IGOTO,NAC,
         .               INFO,INFOG,ITER
          COMMON /ANDATA/ LOOPCNT
          NAMELIST /CONPAR/ INFOG,INFO,NFDG,IPRINT,NDV,ITMAX,NCON,NSIDE,
         .                  ICNDIR,NSCAL,FDCH,FDCHM,CT,CTMIN,CTLMIN,THETA,
         .                  PHI,DELFUN,DABFUN,LINOBJ,ITRM,X,VLB,VUB,
         .                  N1,N2,N3,N4,N5,ALPHAX,ABOBJ1,CTL,ISC,SCAL
    C
          OPEN(UNIT=6,FILE='EXOUT3.TXT',STATUS='NEW')
    C
    C     THIS PROGRAM EXECUTES THE EXAMPLE PROBLEM THREE OF THE CONMIN MANUAL.
    C
    C
    C  INITIALIZE
    C
          INFOG=0
          INFO=0
          NFDG=2
          IPRINT=1
          NDV=2
          ITMAX=40
          NCON=6
          NSIDE=1
          ICNDIR=0
          NSCAL=0
          FDCH=0.0
          FDCHM=0.0
          CT=0.0
          CTMIN=0.0
          CTL=0.0
          CTLMIN=0.0
          THETA=0.0
          PHI=0.0
          DELFUN=0.0
          DABFUN=0.0
          LINOBJ=1
          ITRM=0
          N1=4
          N2=10
          N3=10
          N4=10
          N5=20
          ALPHAX=0.0
          ABOBJ1=0.0
          CTL=0.0
          DO 5 I=1,NDV
            X(I)=1.0
            VLB(I)=0.001
            VUB(I)= 1.0E+10
        5 CONTINUE
    C
          DO 6 J=1,NCON
            ISC(J)=0
        6 CONTINUE
    C
    C     READ THE PARAMETERS FOR CONMIN
    C
    CCC   READ(5,CONPAR)      USE DEFAULT VALUES
          WRITE(6,CONPAR)
          NLIM=ITMAX*(NDV+5)
    C
    C     NON-ITERATIVE PART OF ANALYSIS
    C
          IGOTO = 0
    C
    C     ITERATIVE PART OF ANALYSIS
    C
          DO 1000 I = 1,NLIM
            LOOPCNT=I
    C
    C       CALL THE OPTIMIZATION ROUTINE CONMIN
    C
            CALL CONMIN(X,VLB,VUB,G,SCAL,DF,A,S,G1,G2,B,C,ISC,IC,MS1,N1,N2,
         .              N3,N4,N5)
    C
            IF(IGOTO.EQ.0) LOOPCNT=-999
    C
    C       ANALYSIS MODULE
    C
            CALL ANALYS
            OBJ=AOBJ
            IF (IGOTO.EQ.0) GO TO 1100
     1000 CONTINUE
    C
    C
     1100 CONTINUE
          CLOSE(6)
          STOP
          END

          SUBROUTINE ANALYS
          COMMON /VARABLE/ AOBJ,X(4),G(10)
          COMMON/GRAD/ ISC(10),IC(10),DF(4),A(4,10)
          COMMON /CNMN1/ DELFUN,DABFUN,FDCH,FDCHM,CT,CTMIN,CTL,CTLMIN,
         .               ALPHAX,ABOBJ1,THETA,OBJ,NDV,NCON,NSIDE,IPRINT,
         .               NFDG,NSCAL,LINOBJ,ITMAX,ITRM,ICNDIR,IGOTO,NAC,
         .               INFO,INFOG,ITER
    C
    C   ROUTINE TO CALCULATE OBJECTIVE FUNCTION AND
    C   CONSTRAINT  VALUES FOR OPTIMIZATION OF CONSTRAINED ROSEN-SUZUKI
    C   FUNCTION.
    C
    C
          RHO= 0.1
          A1= X(1)
          A2= X(2)
    C
          IF(INFO.GE.2) GO TO 10
    C
    C  OBJECTIVE FUNCTION
    C
          AOBJ= 10.*RHO*(2.*SQRT(2.)*A1+A2)
    C
    C
    C   CONSTRAINT VALUES
    C
          DENOM= 2.*A1*A2 + SQRT(2.)*A1*A1
          SIG11= 20.*(SQRT(2.)*A1+A2)/DENOM
          SIG21= 20.*SQRT(2.)*A1/DENOM
          SIG31= -20.*A2/DENOM
    C
          G(1)= -SIG11/15.-1.
          G(2)= SIG11/20.-1.
          G(3)= -SIG21/15.-1.
          G(4)= SIG21/20.-1.
          G(5)= -SIG31/15.-1.
          G(6)= SIG31/20.-1.
    C
          GO TO 999
       10 CONTINUE
    C
    C
    C    GRADIENT INFORMATION
    C
          DF(1)=20.*SQRT(2.)*RHO
          DF(2)=10.*RHO
    C
    C  GRADIENTS OF ACTIVE AND VIOLATED CONSTRAINTS
    C  WILL BE CALCULATED BY FINITE DIFFERENCE WITHIN
    C  CONMIN
    C
    C
      999 RETURN
          END
    ccccc

    LISTING 7
    OPTIMIZATION RESULTS FOR EXAMPLE 3

     $CONPAR
     INFOG   =           0,
     INFO    =           0,
     NFDG    =           2,
     IPRINT  =           1,
     NDV     =           2,
     ITMAX   =          40,
     NCON    =           6,
     NSIDE   =           1,
     ICNDIR  =           0,
     NSCAL   =           0,
     FDCH    =  0.0000000E+00,
     FDCHM   =  0.0000000E+00,
     CT      =  0.0000000E+00,
     CTMIN   =  0.0000000E+00,
     CTLMIN  =  0.0000000E+00,
     THETA   =  0.0000000E+00,
     PHI     =  0.0000000E+00,
     DELFUN  =  0.0000000E+00,
     DABFUN  =  0.0000000E+00,
     LINOBJ  =           1,
     ITRM    =           0,
     X       = 2*1.000000    , 2*0.0000000E+00,
     VLB     = 2*1.0000000E-03, 2*0.0000000E+00,
     VUB     = 2*1.0000000E+10, 2*0.0000000E+00,
     N1      =           4,
     N2      =          10,
     N3      =          10,
     N4      =          10,
     N5      =          20,
     ALPHAX  =  0.0000000E+00,
     ABOBJ1  =  0.0000000E+00,
     CTL     =  0.0000000E+00,
     ISC     = 10*0,
     SCAL    = 4*0.0000000E+00
     $END

                * * * * * * * * * * * * * * * * * * * * * * * * * * *
                *                                                   *
                *                    C O N M I N                    *
                *                                                   *
                *                FORTRAN PROGRAM FOR                *
                *                                                   *
                *         CONSTRAINED FUNCTION MINIMIZATION         *
                *                                                   *
                * * * * * * * * * * * * * * * * * * * * * * * * * * *

         INITIAL FUNCTION INFORMATION

         OBJ =   0.382843E+01

         DECISION VARIABLES (X-VECTOR)
           1)    0.10000E+01  0.10000E+01

         CONSTRAINT VALUES (G-VECTOR)
           1)   -0.19428E+01 -0.29289E+00 -0.15523E+01 -0.58579E+00 -0.60948E+00 -0.12929E+01

        FINAL OPTIMIZATION INFORMATION

         OBJ =   0.263281E+01

         DECISION VARIABLES (X-VECTOR)
           1)    0.77853E+00  0.43079E+00

         CONSTRAINT VALUES (G-VECTOR)
           1)   -0.23367E+01  0.25257E-02 -0.19608E+01 -0.27942E+00 -0.62408E+00 -0.12819E+01

         THERE ARE    1 ACTIVE CONSTRAINTS
         CONSTRAINT NUMBERS ARE
             2

         THERE ARE    0 VIOLATED CONSTRAINTS

         THERE ARE    0 ACTIVE SIDE CONSTRAINTS

         TERMINATION CRITERION
              ABS(OBJ(I)-OBJ(I-1))   LESS THAN DABFUN FOR  3 ITERATIONS

         NUMBER OF ITERATIONS =    7

         OBJECTIVE FUNCTION WAS EVALUATED           32  TIMES

         CONSTRAINT FUNCTIONS WERE EVALUATED        32  TIMES

         GRADIENT OF OBJECTIVE WAS CALCULATED        6  TIMES

    REFERENCES

        Lund, S., "Direct Search Program for Optimization of Non-linear
        Functions with Non-linear Constraints," Users Manual SK/P13, NTH,
        Trondheim, Norway, 1971.

        Zoutendijk, G., "Methods of Feasible Directions," Elsevier Publishing
        Co., Amsterdam, 1960.

        Vanderplaats, G. N., and Moses, F., "Structural Optimization by
        Methods of Feasible Directions," National Symposium on Computerized
        Structural Analysis and Design, Washington, D.C., March 1972.

        Fletcher, R. and Reeves, C. M., "Function Minimization by Conjugate
        Gradients," British Computer J., Vol. 7, No. 2, 1964.

        Schmit, L. A., Jr., "Structural Design by Systematic Synthesis,"
        Proceedings of the Second National Conference on Electronic Computation,
        Structural Division, ASCE, Pittsburgh, PA, Sept. 1960.