Using AMPL MINOS - AMPL Modeling Language for Mathematical Programming

12 Pages·1998·0.04 MB·English

____________________________________________________________________________________________________________________________________
Using AMPL/MINOS
MINOSis an optimization package for linear and nonlinear mathematical programs in continu-
ous variables. This supplement to AMPL: A Modeling Language for Mathematical Programming
describes the most important features ofMINOSforAMPLusers. Further information onMINOSis
available from:
Stanford Business Software, Inc.
2672 Bayshore Parkway, Suite 304
Mountain View, CA 94043
415-962-8719; fax [phone]
Section §1 below describes the kinds of problems to which MINOS is applicable, and Section
§2 explains in general terms how solver-specific directives can be passed from AMPL to MINOS.
Sections §3 and §4 then briefly introduce the algorithms thatMINOSuses for linear and for nonlin-
ear programming, respectively, and describe the relevant algorithmic directives. Section §5 pre-
sents directives for controlling listings fromMINOS, and Section §6 discusses options for restarting
from a known solution or basis.
§1 Applicability
MINOSis designed to solve the linear programs described in Chapters 1-8 and 11-12 ofAMPL:
A Modeling Language for Mathematical Programming, as well as the ‘‘smooth’’ nonlinear pro-
grams described in Chapter 13. Smooth nonlinear functions can be accommodated in both the
objective and the constraints; nonlinear equation systems may also be solved by omitting an objec-
tive. Nonsmooth nonlinearities are also accepted, butMINOSis not designed for them and in gen-
eral will not produce reliable results when they are present.
MINOS does not solve integer programs as described in Chapter 15. When presented with an
integer program,MINOSignores the integrality restrictions on the variables, as indicated by a mes-
sage such as
MINOS 5.4: ignoring integrality of 5 variables
It then solves the continuous relaxation of the resulting problem, and returns a solution in which
some of the integer variables may have fractional values.
MINOScan solve piecewise-linear programs, as described in Chapter 14, provided that they sat-
isfy certain rules that permit them to be transformed to linear programs. Any piecewise-linear term
in a minimized objective must be convex, its slopes forming an increasing sequence as in:
<<-1,1,3,5; -5,-1,0,1.5,3>> x[j]
Any piecewise-linear term in a maximized objective must be concave, its slopes forming a decreas-
ing sequence as in:
<<1,3; 1.5,0.5,0.25>> x[j]
2 USING AMPL/MINOS
In the constraints, any piecewise-linear term must be either convex and on the left-hand side of a£
constraint (or equivalently, the right-hand side of a‡ constraint), or else concave and on the left-
hand side of a‡ constraint (or equivalently, the right-hand side of a£ constraint). AMPLautomati-
cally converts the piecewise-linear program to a linear one, sends the latter toMINOS, and converts
the solution back; the conversion has the effect of adding a variable to correspond to each linear
piece. Piecewise-linear programs that violate the above rules are converted to integer programs,
which are treated as described in the preceding paragraph;MINOSreturns a solution to the continu-
ous relaxation of the equivalent integer program, which in general is not optimal for the original
piecewise-linear problem.
§2 ControllingMINOSfromAMPL
In many instances, you can successfully applyMINOSby simply specifying a model and data,
setting the solver option to minos, and typing solve. For larger linear programs and more
difficult nonlinear programs, however, you may need to pass specific directives toMINOSto obtain
the desired results.
To give directives toMINOS, you must first assign an appropriate character string to theAMPL
option calledminos_options. WhensolveinvokesMINOS, it breaks this string into a series
of individual directives. Here is an example:
ampl: model diet.mod;
ampl: data diet.dat;
ampl: option solver minos;
ampl: option minos_options ’crash_option=0 \
ampl? feasibility_tolerance=1.0e-8 scale=no \
ampl? iterations_limit=100’;
ampl: solve;
MINOS 5.4:
crash_option=0
feasibility_tolerance=1.0e-8
scale=no
iterations_limit=100
MINOS 5.4: optimal solution found.
4 iterations, objective 88.2
MINOSconfirms each directive; it will display an error message if it encounters one that it does not
recognize.
All of the directives described below have the form of an identifier, an = sign, and a value;
unlike AMPL,MINOS treats upper-case and lower-case letters as being the same. You may store
any number of concatenated directives in minos_options. The example above shows how to
type all the directives in one long string, using the\character to indicate that the string continues
on the next line. Alternatively, you can list several strings, which AMPL will automatically con-
catenate:
ampl: option minos_options ’crash_option=0’
ampl? ’ feasibility_tolerance=1.0e-8 scale=no’
ampl? ’ iterations_limit=100’;
In this form, you must take care to supply the space that goes between the directives; here we have
put it beforefeasibility_toleranceanditerations_limit.
If you have specified the directives above, and then want to set optimality_tolerance
to 1.0e–8 and changecrash_optionto 1, you might think to type:
ampl: option minos_options
ampl? ’optimality_tolerance=1.0e-8 crash_option=1’;
USING AMPL/MINOS 3
This will replace the previous minos_options string, however; the other previously specified
directives such as feasibility_tolerance and scale will revert to their default values.
(MINOSsupplies a default value for every directive not explicitly specified; defaults are indicated
in the discussion below.) To append new directives tominos_options, use this form:
ampl: option minos_options $minos_options
ampl? ’ optimality_tolerance=1.0e-8 crash_option=1’;
A$in front of an option name denotes the current value of that option, so this statement appends
more directives to the current directive string. As a result the string contains two directives for
crash_option, but the new one overrides the earlier one.
§3 UsingMINOSfor linear programming
For linear programs, MINOS employs the primal simplex algorithm described in many text-
books. The algorithm maintains a subset ofbasic variables (or, abasis) equal in size to the num-
ber of constraints. A basic solution is obtained by solving for the basic variables, when the
remaining nonbasic variables are fixed at appropriate bounds. Each iteration of the algorithm picks
a new basic variable from among the nonbasic ones, steps to a new basic solution, and drops some
basic variable at a bound.
The coefficients of the variables form a constraint matrix, and the coefficients of the basic
variables form a nonsingular square submatrix called thebasis matrix. At each iteration, the sim-
plex algorithm must solve certain linear systems involving the basis matrix. For this purpose
MINOS maintains a factorization of the basis matrix, which is updated at most iterations, and is
occasionally recomputed.
The sparsity of a matrix is the proportion of its elements that are not zero. The constraint
matrix, basis matrix and factorization are said to be relatively sparse or dense according to their
proportion of nonzeros. Most linear programs of practical interest have many zeros in all the rele-
vant matrices, and the larger ones tend also to be the sparser.
The amount of RAM memory required by MINOS grows with the size of the linear program,
which is a function of the numbers of variables and constraints and the sparsity of the coefficient
matrix. The factorization of the basis matrix also requires an allocation of memory; the amount is
problem-specific, depending on the sparsity of the factorization.
The following MINOS directives apply to the solution of linear programs. The letters i and r
denote integer and real values, respectively. The symbole represents the ‘‘machine precision’’ —
the smallest value such that 1+e can be distinguished from 1; for many machines it is
2- 52 ~~ 2. 22· 10- 16.
Crash_option=i (default 3)
Crash_tolerance=r (default 0.1)
These directives govern the initial determination of the basic variables, except when the basis is
read from a file as described in §6 below.
Fori=0, the initial basis contains a slack or artificial variable thatMINOSautomatically associ-
ates with each constraint; the basis matrix is an identity matrix. Fori>0,MINOSuses a heuristic
‘‘crash procedure’’ to quickly choose a basis matrix that has fewer artificial variables and is likely
to be nonsingular. Since artificial variables are generally not required in an optimal basis, this pro-
cedure tends to reduce the number of iterations to optimality.
When i=1 or 2 (which are equivalent for linear programs), the crash procedure determines a
full initial basis before the first iteration. When i=3, the crash procedure initially determines a
basis for just the equality constraints, and simplex iterations are performed until those constraints
are satisfied (or determined to be infeasible). The crash procedure is then called again to extend
the basis to all constraints.
In each column of the coefficient matrix, the crash procedure looks only at coefficients whose
magnitude is more thanrtimes the largest magnitude in the column. Thus whenr=0 it looks at all
4 USING AMPL/MINOS
coefficients; in such a case it finds a triangular basis matrix that is guaranteed to be nonsingular.
As r is increased the risk of singularity is also increased, but fewer artificial variables may be
included. The default value ofr=0. 1 generally works well, but the best value is highly dependent
on problem structure and can be determined only through experimentation.
Expand_frequency=i (default 10000)
To discourage long series of degenerate iterations, at which no reduction in the objective is
achieved,MINOSemploys a procedure that lets nonbasic variables move beyond their bounds by a
certain tolerance. If feasibility_tolerance (see below) is r, then the tolerance increases
fromr /2 tor(in steps of 0. 5r / i) in the course ofiiterations, after which it is reset and the proce-
dure begins anew. The default setting should be adequate for problems of moderate size.
Factorization_frequency=i (default 100)
The factorization of the basis matrix is updated at mostitimes before it is recomputed directly.
(An update occurs at the end of most iterations, though for some it can be skipped.) Higher values
ofimay be more efficient for dense problems in which the factorization has two or more times as
many nonzeros as the basis matrix, while lower values may be more efficient for very sparse prob-
lems. Lower values also require less memory for storing the updates.
Feasibility_tolerance=r (default 1.0e–6)
A variable or linear constraint is considered to befeasible if it does not lie outside its bounds
by more thanr. IfMINOSdetermines that the sum of all infeasibilities cannot be reduced to zero, it
reports ‘‘no feasible solution’’ and returns the last solution that it found. The sum of infeasibilities
in the reported solution is not necessarily the minimum possible; however, if all the infeasibilities
are quite small, it may be appropriate to raiserby a factor of 10 or 100.
Iterations_limit=i (default 99999999)
MINOSstops afteriiterations, even if it has not yet identified an optimal solution.
LU_factor_tolerance=r (default 100.0)
1
LU_update_tolerance=r (default 10.0)
2
The values ofr andr affect the stability and sparsity of the basis factorization during refac-
1 2
torization and updating, respectively. Smaller values ‡ 1 favor stability, while larger values favor
sparsity; the defaults usually strike a good compromise.
LU_singularity_tolerance=r (default e 2/3~~ 10- 11)
When factoring the basis matrix,MINOSemploysrin a test for singularity; any column where
singularity is detected is arbitrarily replaced by a slack or artificial column. If the basis becomes
nearly singular as the optimum is approached, a larger value ofr<1 may give better performance.
Optimality_tolerance=r (default 1.0e–6)
The value ofrdetermines the exactness ofMINOS’s test for optimality. (In technical terms, at
an optimum the dual variables and constraints may not violate their bounds by more thanrtimes a
measure of the size of the dual solution.) The default setting is usually adequate. A smaller value
ofr>0 may yield a better objective function value, at the cost of more iterations.
Partial_price=i (default 10)
MINOSincorporates a heuristic procedure to search through the nonbasic variables for a good
candidate to enter the basis. (In technical terms,MINOSsearches for a nonbasic variable that has a
sufficiently large reduced cost, where ‘‘sufficiently large’’ is determined by a dynamic tolerance.)
To save computational expense, only about 1/ i times the number of variables are searched at an
iteration, unless more must be searched to find one good candidate.
As i is increased, iterations tend to take less time, but the simplex algorithm tends to require
more iterations; changes inioften have a significant effect on total solution time. The ideal value
of iis highly problem-specific, however, and must be determined by experimentation. For linear
USING AMPL/MINOS 5
programs that have many more variables than constraints, a largeriis usually preferred. A setting
ofi=1, which causes all nonbasic variables to be searched at each iteration, can be the best choice
when the number of variables is small relative to the number of constraints.
Pivot_tolerance=r (default e 2/3~~ 10- 11)
MINOSrejects a nonbasic variable chosen to enter the basis if the resulting basis matrix would
be almost singular, according to a test in which the value of r is employed. A larger value of r
strengthens the test, promoting stability but possibly increasing the number of rejections.
Scale=yes
Scale=no
Scale_option=i (default 2)
Scale_tolerance=r (default 0.9)
MINOSincorporates a heuristic procedure that scales the constraint matrix in a way that usually
brings the elements closer to 1.0, and reduces the ratio between the largest and smallest element.
Scaling merely converts the given linear program to an equivalent one, but it can affect the perfor-
mance of the basis factorization routines, and the choices of nonbasic variables to enter the basis.
In some but not all cases, the simplex method solves a scaled problem more efficiently than its
unscaled counterpart.
Fori=0 no scaling is performed, while fori=1 ori=2 a series of alternating row and column
scalings is carried out. Fori=2 a certain additional scaling is performed that may be helpful if the
right-hand side (constant terms of the constraints) or solution contain large values; it takes into
account columns that are fixed or have positive lower bounds or negative upper bounds.
Scale=yesis the same as the default, whilescale=nosetsi=0.
If i>0, the value of r affects the number of alternate row and column scalings. Raising r to
0.99 (say) may increase the number of scalings and improve the final scaling slightly.
Weight_on_linear_objective=r (default 0.0)
When r=0, MINOS carries out the simplex algorithm in two phases. Phase 1 minimizes the
‘‘sum of infeasibilities’’, which has to be zero in any feasible solution; then phase 2 minimizes or
maximizes the ‘‘true objective’’ supplied by the linear program.
Whenr>0,MINOSinstead minimizes the objective defined by
s r(true objective) + (sum of infeasibilities)
where s is +1 for a minimization problem or –1 for a maximization. If a feasible minimum is
found, then it is also optimal to the original linear program. Otherwiseris reduced by a factor of
10, and another pass is begun;ris set to zero after the fifth reduction, or whenever a feasible solu-
tion is encountered.
The effect of this directive is problem-dependent, and must be determined by experimentation.
A good ‘‘intermediate’’ value ofrmay yield an optimal solution in fewer iterations than the two-
phase approach.
§4 UsingMINOSfor nonlinear programming
For mathematical programs that are nonlinear in the objective but linear in the constraints,
MINOSemploys a reduced gradient approach, which can be viewed as a generalization of the sim-
plex algorithm. In addition to the basic variables, the algorithm maintains a subset of superbasic
variables that also may vary between their bounds. An iteration attempts to reduce the objective
within the subspace of basic and superbasic variables, employing a quasi-Newton algorithm —
adapted from unconstrained nonlinear optimization — to select asearch direction andstep length.
When no further progress can be made with the current collection of basic and superbasic vari-
ables, a new superbasic variable is chosen from among the nonbasic ones; when a basic or superba-
sic variables encounters a bound as a result of a step, it is made nonbasic.
6 USING AMPL/MINOS
To deal with nonlinear constraints,MINOSfurther generalizes its algorithm by means of a pro-
jected Lagrangian approach. At eachmajor iteration, a linear approximation to the nonlinear con-
straints is constructed around the current solution, and the objective is modified by adding two
terms — the Lagrangian and the penalty term — which compensate (in a rough sense) for the
inaccuracy of the linear approximation. The resulting subproblem is then solved by a series of
minor iterations of the reduced gradient algorithm described in the previous paragraph. The opti-
mum of this subproblem becomes the current solution for the next major iteration.
AMPLsendsMINOSthe information it needs to compute the values and partial derivatives of all
nonlinear terms in the objective and constraints. The method of ‘‘automatic differentiation’’ is
employed to compute the derivatives efficiently and exactly (subject to the limitations of computer
arithmetic).
MINOSstores the linear and nonlinear parts of a mathematical program separately. The repre-
sentation of the linear part is essentially the same as for a linear program, while the representation
of the nonlinear part requires an amount ofRAMmemory depending on the complexity of the non-
linear terms. A factorization of the basis matrix is maintained as for linear programs, and has the
same memory requirements. The quasi-Newton algorithm also maintains a factorization of a dense
matrix that occupies memory proportional to the square of the number of superbasic variables.
This number is small is many applications, but it is highly problem-dependent; in general terms, a
problem that is ‘‘more nonlinear’’ will tend to have more superbasics.
The followingMINOSdirectives are useful in solving nonlinear mathematical programs. Since
the reduced gradient method incorporates many of the ideas from the simplex method, many of the
directives for linear programming carry over in a natural way; others address the complications
introduced by a nonlinear objective and constraints.
Completion=partial (default)
Completion=full
When there are nonlinear constraints, this directive determines whether subproblems should be
solved to moderate accuracy (partial completion), or to full accuracy (full completion). Partial
completion may reduce the work during early major iterations; an automatic switch to full comple-
tion occurs when several numerical tests indicate that the sequence of major iterations is converg-
ing. Full completion from the outset may lead to fewer major iterations, but may result in more
minor iterations.
Crash_option=i (default 3)
Crash_tolerance=r (default 0.1)
Crash_optionvalues 0 and 1, and the crash_tolerance, work the same as for linear
programs. Acrash_optionof 2 first finds a basis for the linear constraints; after the first major
iteration has found a solution that satisfies the linear constraints, the crash heuristic is called again
to extend the basis to the nonlinear constraints. A value of 3 is similar except that linear equalities
and linear inequalities are processed by separate passes of the crash routine, in the same way as for
linear programs.
Expand_frequency=i (default 10000)
This directive works the same as for linear programming, but takes effect only when there is
currently just one superbasic variable.
Factorization_frequency=i (default 100)
The basis is refactorized everyiminor iterations, as in linear programming. If there are nonlin-
ear constraints, the computation of a new linear approximation necessitates a refactorization at the
start of each major iteration; thus theminor_iterationsdirective normally takes precedence
over this one.
Feasibility_tolerance=r (default 1.0e–6)
Essentially the same as for linear programming.
USING AMPL/MINOS 7
MINOS allows nonlinear functions to be evaluated at points that satisfy the linear constraints
and bounds to within the tolerance r. Thus every attempt should be made to bound the variables
strictly away from regions where nonlinear functions are undefined. As an example, if the function
sqrt(X)appears, it is essential to enforce a positive lower bound onX; forrat its default value
of 1.0e–6, the constraintX>=1.0e-5might be appropriate. (Note thatX>=0does not suffice.)
When there are nonlinear constraints, this tolerance applies to each linear approximation. Fea-
sibility with respect to the nonlinear constraints themselves is governed by the setting of the
row_tolerancedirective.
Hessian_dimension=r (default 50 or superbasics_limit)
Memory proportional tor2 is set aside for the factorization of the dense matrix required by the
quasi-Newton method, limiting the size of the matrix tor· r. To promote rapid convergence as the
optimum is approached, r should be greater than the expected number of superbasic variables
whenever available memory permits. It need never be larger than 1 + the number of variables
appearing in nonlinear terms, and for many problems it can be much less.
Iterations_limit=i (default 99999999)
MINOSstops after a total ofiminor iterations, even if an optimum has not been indicated.
Lagrangian=yes (default)
Lagrangian=no
This directive determines the form of the objective function used for the linearized subprob-
lems. The default value yes is highly recommended. The penalty_parameter directive is
then also relevant.
If no is specified, the nonlinear constraint functions will be evaluated only twice per major
iteration. Hence this option may be useful if the nonlinear constraints are very expensive to evalu-
ate. However, in general there is a great risk that convergence may not be achieved.
Linesearch_tolerance=r (default 0.1)
After the quasi-Newton method has determined a search direction at a minor iteration, r con-
trols the accuracy with which the objective function is minimized in that direction. The default
valuer=0. 1 requests a moderately accurate search, which should be satisfactory in most cases.
If the nonlinear functions are cheap to evaluate, a more accurate search may be appropriate; try
r=0. 01 orr=0. 001. The number of iterations should decrease, and this will reduce total run time
if there are many constraints.
If the nonlinear functions are expensive to evaluate, a less accurate search may be appropriate;
tryr=0. 5 or perhapsr=0. 9. The number of iterations will probably increase, but the total number
of function evaluations may decrease enough to compensate.
LU_factor_tolerance=r (default 100.0)
1
LU_update_tolerance=r (default 10.0)
2
Same as for linear programming.
LU_singularity_tolerance=r (default e 2/3~~ 10- 11)
LU_swap_tolerance=r 1 (default e 1/4~~ 10- 4)
2
When the problem is nonlinear, these directives influence tests for singularity after refactoriza-
tion of the basis matrix. TheLU_singularity_toleranceworks the same as for linear pro-
gramming. TheLU_swap_toleranceis employed by a test to determine when a basic variable
should be swapped with a superbasic variable to discourage singularity. A smaller value of r
2
tends to discourage this swapping.
Major_damping_parameter=r (default 2.0)
This directive may assist convergence on problems that have highly nonlinear constraints. It is
intended to prevent large relative changes between solutions (both the primal variables and the dual
multipliers in the Lagrangian term) at successive subproblems; for example, the default value 2.0
8 USING AMPL/MINOS
prevents the relative change from exceeding 200 percent. This is accomplished by picking the
actual new solution to lie somewhere on the line connecting the previous solution to the proposed
new solution determined by the algorithm.
This is a very crude control. If the sequence of major iterations does not appear to be converg-
ing, first re-run the problem with a higher penalty_parameter (say 2, 4 or 10). If the sub-
problem solutions continue to change violently, try reducingrto a value such as 0.2 or 0.1.
Major_iterations=i (default 50)
MINOSstops afterimajor iterations, even if an optimum has not been indicated.
Minor_damping_parameter=r (default=2.0)
This directive limits the change in the variables during the determination of the step length in a
minor iteration. The default value should not affect progress on well behaved problems, but setting
r=0. 1 or 0.01 may be helpful when rapidly varying functions are present. (In the case of functions
that increase or decrease rapidly to infinite values, upper and lower bounds should also be supplied
wherever possible to avoid evaluation of the function at points where overflow will occur.)
In cases where several local optima exist, specifying a small value for r may help locate an
optimum near the starting point.
Minor_iterations=i (default 40)
At a major iteration,MINOSallows any number of minor iterations for the purpose of finding a
point that is feasible in the linearized constraints. Once such a feasible point has been found, at
mostiadditional minor iterations are carried out. A moderate value (say, 30£ i£ 100) prevents
excessive effort being expended at early major iterations, but allows later subproblems to be solved
to completion.
The first major iteration is special: it terminates as soon as the linear constraints and bounds are
satisfied.
Multiple_price=i (default 1)
This directive specifies the number of nonbasic variables that are chosen to become superbasic
at one time. Normally the default of i=1 yields good results, but it may help to set i>1 if the
number of superbasic variables at the starting point is much less than the number expected at the
optimum.
For linear programs, i>1 will cause the reduced-gradient algorithm to be applied in place of
the simplex algorithm, but generally with inferior results. This differs from the ‘‘multiple pricing’’
designed to accelerate the choice of an entering variable in other large-scale simplex implementa-
tions.
Optimality_tolerance=r (default 1.0e-6)
Same as for linear programming.
Partial_price=i (default 1)
Same as for linear programming, except for the default value.
Penalty_parameter=r (default 1.0)
When there are nonlinear constraints, r determines the magnitude of the penalty term that is
appended to the objective. For early runs on a problem with unknown characteristics, the default
value should be acceptable. If the problem is highly nonlinear and the major iterations do not con-
verge, a larger value such as 2 or 5 may help; but ifris too large, the rate of convergence may be
unnecessarily slow. On the other hand, if the functions are nearly linear or a good starting point is
known, it will often be safe to specify r=0. 0, although in general a positive r is necessary to
ensure convergence.
Pivot_tolerance=r (default e 2/3~~ 10- 11)
Same as for linear programming.
USING AMPL/MINOS 9
Radius_of_convergence=r (default 0.01)
When there are nonlinear constraints, MINOS employs a heuristic test to determine when the
solution may have entered a region of fast convergence near the optimum. At this stage the penalty
parameter is reduced and full completion is chosen (see directives completion and
penalty_parameter). A smaller value ofrdelays entry into this stage.
Row_tolerance=r (default 1.0e–6)
This directive specifies how accurately the nonlinear constraints should be satisfied at an opti-
mal solution, relative to the magnitudes of the variables. A larger value may be appropriate if the
problem functions involve data known to be of low accuracy.
Scale=yes
Scale=no
Scale_option=i (default 1)
Scale_tolerance=r (default 0.9)
Mostly the same as for linear programming. The default of i=1 causes only the linear vari-
ables and constraints to be scaled, and should generally be tried first. Wheni=2 all variables are
scaled; the result depends on the initial linear approximation, and should therefore be used only if a
good starting point is provided, and the problem is not highly nonlinear.
Subspace_tolerance=r (default 0.5)
This directive controls the extent to which optimization is confined to the current subset of
basic and superbasic variables, before one or more nonbasic variables are added to the superbasic
set. A smaller value ofrtends to prolong optimization over the current subset, possibly increasing
the number of iterations but reducing the number of basis changes.
A large value such asr=0. 9 may sometimes lead to improved overall efficiency, if the number
of superbasic variables has to increase substantially between the starting point and an optimal solu-
tion.
Superbasics_limit=i (default 50 or hessian_dimension)
The number of superbasic variables is limited to i. (See also the comments on the
hessian_dimensiondirective.)
Unbounded_objective_value=r (default 1.0e+20)
1
Unbounded_step_size=r (default 1.0e+10)
2
A nonlinear program is reported as unbounded if, in the quasi-Newton algorithm carrying out a
minor iteration, the function value exceeds r in magnitude or the length of the step exceeds r .
1 2
Unboundedness may occur even though there exists a finite local optimum of interest; it is best pre-
vented by bounding the variables to keep them within a meaningful region.
§5 Output fromMINOS
When invoked bysolve,MINOSnormally returns just a few lines to your screen to summa-
rize its performance. The directives described below let you choose more output, either to the
screen or to a file. This may be useful for monitoring the progress of a long run, or for comparing
in detail the effects of selected algorithmic directives.
BecauseMINOSis a Fortran program that adheres to certain Fortran conventions, the treatment
of file specifications is somewhat different from that of mostMS-DOSorUNIXprograms. As indi-
cated below, MINOS directives refer to files by file unit numbers, and an additional directive is
needed to associate a file number with a file name of your choosing.
Summary_file=f (default 0)
Summary_level=i (default 0)
1
Summary_frequency=i (default 100)
2
f=filename
10 USING AMPL/MINOS
These directives control a summary listing ofMINOS’s progress. The default settingf=0 sup-
presses the listing; any valuef=1, 2, 3, 4 or 6 through 99 causes the listing to be written to a file
namedfort.fin the current directory, or to the named file if the directivef=filenameis present.
Thus to send the summary listing tofort.9in the current directory, you would say
ampl: option minos_options ’summary_file=9’;
or to send the listing tosteel3.sum,you could use
ampl: option minos_options ’summary_file=9 9=steel3.sum’;
A value off=5 is not allowed. A value of f=6 causes the listing to be written to the ‘‘standard
output’’, which in interactive operation is your screen unless you have redirected it with a com-
mand of the form solve >filename. For mathematical programs that take a long time to solve,
summary_file=6is recommended to help you track the algorithm’s progress.
For linear programs,MINOSwrites a ‘‘log line’’ to the summary listing everyi iterations, as
2
well as some statistics on the entire run at the end. For example:
ampl: model steelT3.mod; data steelT3.dat;
ampl: option minos_options ’summary_file=6 summary_frequency=5’;
ampl: solve;
MINOS 5.4:
summary_file=6
summary_frequency=5
Itn dj ninf sinf objective
1 -9.5E-01 1 3.429E+00 -9.99999859E+01
Itn 2 -- feasible solution. Objective = 2.499999647E+02
5 -5.1E+01 0 0.000E+00 1.14300000E+05
10 -4.9E+01 0 0.000E+00 3.04350000E+05
15 -4.0E+01 0 0.000E+00 4.05892857E+05
20 1.4E+01 0 0.000E+00 5.11953143E+05
25 -5.5E-01 0 0.000E+00 5.14521714E+05
EXIT -- optimal solution found
No. of iterations 25 Objective value 5.1452171425E+05
No. of degenerate steps 1 Percentage 4.00
Norm of x 5.153E+03 Norm of pi 2.391E+02
Norm of x (unscaled) 8.159E+04 Norm of pi (unscaled) 3.375E+03
The items in the log line are the iteration number, the reduced cost of the variable chosen to enter
the basis, the number and sum of infeasibilities in the current solution, and the value of the objec-
tive.
When there are nonlinearities in the objective but linear constraints, the reduced cost in the log
lines is replaced by the more general reduced gradient, and two items are added at the end: the
cumulative number of evaluations of the objective function, and the number of superbasic vari-
ables.
If there are nonlinearities in the constraints, MINOS writes a log line at each major iteration,
and ifi >0 also a log line after everyi minor iterations.
1 2
Print_file=f (default 0)
Print_level=i (default 0)
1
Print_frequency=i (default 100)
2
f=filename
These directives are essentially the same as the preceding ones, except that they produce more
extensive listings. Details are provided in theMINOSUser’s Guide.
timing=i (default 0)
When this directive is changed to 1 from its default value of 0, a summary of processing times
is displayed: