Coin Cbc and Clp Solver version 1.01.00, build Feb 21 2006
command line - solve -verbose 7 -? 
verbose was changed from 0 to 7
Cbc options are set within AMPL with commands like:

         option cbc_options "cuts=root log=2 feas=on slog=1"

only maximize, dual, primal, help and quit are recognized without =

Double parameters:

Command dualB(ound)  Initially algorithm acts as if no gap between bounds exceeds this value
---- description
The dual algorithm in Clp is a single phase algorithm as opposed to
a two phase algorithm where you first get feasible then optimal. 
If a problem has both upper and lower bounds then it is trivial to
get dual feasible by setting non basic variables to correct bound.
If the gap between the upper and lower bounds of a variable is more
than the value of dualBound Clp introduces fake bounds so that it
can make the problem dual feasible.  This has the same effect as a
composite objective function in the primal algorithm.  Too high a
value may mean more iterations, while too low a bound means the code
may go all the way and then have to increase the bounds.  OSL had
a heuristic to adjust bounds, maybe we need that here.
<Range of values is 1e-20 to 1e+12;
        current 1e+10>
----

Command dualT(olerance)  For an optimal solution no dual infeasibility may exceed this value
---- description
Normally the default tolerance is fine, but you may want to increase
it a bit if a dual run seems to be having a hard time.  One method
which can be faster is to use a large tolerance e.g. 1.0e-4 and dual
and then clean up problem using primal and the correct tolerance (remembering
to switch off presolve for this final short clean up phase).
<Range of values is 1e-20 to 1e+12;
        current 1e-07>
----

Command primalT(olerance)  For an optimal solution no primal infeasibility may exceed this value
---- description
Normally the default tolerance is fine, but you may want to increase
it a bit if a primal run seems to be having a hard time
<Range of values is 1e-20 to 1e+12;
        current 1e-07>
----

Command primalW(eight)  Initially algorithm acts as if it costs this much to be infeasible
---- description
The primal algorithm in Clp is a single phase algorithm as opposed
to a two phase algorithm where you first get feasible then optimal.
So Clp is minimizing this weight times the sum of primal infeasibilities
plus the true objective function (in minimization sense).  Too high
a value may mean more iterations, while too low a bound means the
code may go all the way and then have to increase the weight in order
to get feasible.  OSL had a heuristic to adjust bounds, maybe we need
that here.
<Range of values is 1e-20 to 1e+20;
        current 1e+10>
----


Branch and Cut double parameters:

Command allow(ableGap)  Stop when gap between best possible and best less than this
---- description
If the gap between best solution and best possible solution is less
than this then the search will be terminated.  Also see gapRatio.
<Range of values is 0 to 1e+20;
        current 0>
----

Command cuto(ff)  All solutions must be better than this
---- description
All solutions must be better than this value (in a minimization sense).
This is also set by code whenever it obtains a solution and is set
to value of objective for solution minus cutoff increment.
<Range of values is -1e+60 to 1e+60;
        current 1e+50>
----

Command gap(Ratio)  Stop when gap between best possible and best less than this fraction of larger of two
---- description
If the gap between best solution and best possible solution is less
than this fraction of the objective value at the root node then the
search will terminate.  See 'allowableGap' for a way of using absolute
value rather than fraction.
<Range of values is 0 to 1e+20;
        current 0>
----

Command inc(rement)  A valid solution must be at least this much better than last integer solution
---- description
Whenever a solution is found the bound on solutions is set to solution
(in a minimizationsense) plus this.  If it is not set then the code
will try and work one out e.g. if all objective coefficients are multiples
of 0.01 and only integer variables have entries in objective then
this can be set to 0.01.  Be careful if you set this negative!
<Range of values is -1e+20 to 1e+20;
        current 1e-05>
----

Command inf(easibilityWeight)  Each integer infeasibility is expected to cost this much
---- description
A primitive way of deciding which node to explore next.  Satisfying
each integer infeasibility is expected to cost this much.
<Range of values is 0 to 1e+20;
        current 0>
----

Command integerT(olerance)  For an optimal solution no integer variable may be this away from an integer value
---- description
Beware of setting this smaller than the primal tolerance.
<Range of values is 1e-20 to 0.5;
        current 1e-06>
----

Command preT(olerance)  Tolerance to use in presolve
---- description
The default is 1.0e-8 - you may wish to try 1.0e-7 if presolve says
the problem is infeasible and you have awkward numbers and you are
sure the problem is really feasible.
<Range of values is 1e-20 to 1e+12;
        current 1e-08>
----

Command sec(onds)  maximum seconds
---- description
After this many seconds coin solver will act as if maximum nodes had
been reached.
<Range of values is -1 to 1e+12;
        current 1e+08>
----


Integer parameters:

Command idiot(Crash)  Whether to try idiot crash
---- description
This is a type of 'crash' which works well on some homogeneous problems.
It works best on problems with unit elements and rhs but will do something
to any model.  It should only be used before primal.  It can be set
to -1 when the code decides for itself whether to use it, 0 to switch
off or n > 0 to do n passes.
<Range of values is -1 to 999999;
        current -1>
----

Command maxF(actor)  Maximum number of iterations between refactorizations
---- description
If this is at its initial value of 200 then in this executable clp
will guess at a value to use.  Otherwise the user can set a value.
The code may decide to re-factorize earlier for accuracy.
<Range of values is 1 to 999999;
        current 200>
----

Command maxIt(erations)  Maximum number of iterations before stopping
---- description
This can be used for testing purposes.  The corresponding library
call
        setMaximumIterations(value)
can be useful.  If the code stops on seconds or by an interrupt this
will be treated as stopping on maximum iterations
<Range of values is 0 to 2147483647;
        current 2147483647>
----

Command output(Format)  Which output format to use
---- description
Normally export will be done using normal representation for numbers
and two values per line.  You may want to do just one per line (for
grep or suchlike) and you may wish to save with absolute accuracy
using a coded version of the IEEE value. A value of 2 is normal. otherwise
odd values gives one value per line, even two.  Values 1,2 give normal
format, 3,4 gives greater precision, while 5,6 give IEEE values. 
When used for exporting a basis 1 does not save values, 2 saves values,
3 with greater accuracy and 4 in IEEE.
<Range of values is 1 to 6;
        current 2>
----

Command slog(Level)  Level of detail in Solver output
---- description
If 0 then there should be no output in normal circumstances.  1 is
probably the best value for most uses, while 2 and 3 give more information.
<Range of values is -1 to 63;
        current 0>
----

Command sprint(Crash)  Whether to try sprint crash
---- description
For long and thin problems this program may solve a series of small
problems created by taking a subset of the columns.  I introduced
the idea as 'Sprint' after an LP code of that name of the 60's which
tried the same tactic (not totally successfully).  Cplex calls it
'sifting'.  -1 is automatic choice, 0 is off, n is number of passes
<Range of values is -1 to 500;
        current -1>
----


Branch and Cut integer parameters:

Command cutD(epth)  Depth in tree at which to do cuts
---- description
Cut generators may be - off, on only at root, on if they look possible
and on.  If they are done every node then that is that, but it may
be worth doing them every so often.  The original method was every
so many nodes but it is more logical to do it whenever depth in tree
is a multiple of K.  This option does that and defaults to -1 (off).
<Range of values is -1 to 999999;
        current -1>
----

Command log(Level)  Level of detail in Coin branch and Cut output
---- description
If 0 then there should be no output in normal circumstances.  1 is
probably the best value for most uses, while 2 and 3 give more information.
<Range of values is -1 to 63;
        current 1>
----

Command maxN(odes)  Maximum number of nodes to do
---- description
This is a repeatable way to limit search.  Normally using time is
easier but then the results may not be repeatable.
<Range of values is 1 to 2147483647;
        current 2147483647>
----

Command passC(uts)  Number of cut passes at root node
---- description
The default is 100 passes if less than 500 columns, 100 passes (but
stop if drop small if less than 5000 columns, 20 otherwise
<Range of values is -999999 to 999999;
        current -1>
----

Command passF(easibilityPump)  How many passes in feasibility pump
---- description
This fine tunes Feasibility Pump by doing more or fewer passes.
<Range of values is 0 to 10000;
        current 20>
----

Command strong(Branching)  Number of variables to look at in strong branching
---- description
In order to decide which variable to branch on, the code will choose
up to this number of unsatisfied variables to do mini up and down
branches on.  Then the most effective one is chosen. If a variable
is branched on many times then the previous average up and down costs
may be used - see number before trust.
<Range of values is 0 to 999999;
        current 5>
----

Command trust(PseudoCosts)  Number of branches before we trust pseudocosts
---- description
Using strong branching computes pseudo-costs.  After this many times
for a variable we just trust the pseudo costs and do not do any more
strong branching.
<Range of values is -1 to 2000000;
        current 5>
----


Keyword parameters:

Command chol(esky)  Which cholesky algorithm
---- description
For a barrier code to be effective it needs a good Cholesky ordering
and factorization.  You will need to link in one from another source.
See Makefile.locations for some possibilities.
<Possible options for cholesky are: native dense fudge(Long_dummy) wssmp_dummy Uni(versityOfFlorida) Taucs_dummy;
        current  native>
----

Command crash  Whether to create basis for problem
---- description
If crash is set on and there is an all slack basis then Clp will flip
or put structural variables into basis with the aim of getting dual
feasible.  On the whole dual seems to be better without it and there
alernative types of 'crash' for primal e.g. 'idiot' or 'sprint'. I
have also added a variant due to Solow and Halim which is as on but
just flip.
<Possible options for crash are: off on so(low_halim) ha(lim_solow(JJF mods));
        current  off>
----

Command cross(over)  Whether to get a basic solution after barrier
---- description
Interior point algorithms do not obtain a basic solution (and the
feasibility criterion is a bit suspect (JJF)).  This option will crossover
to a basic solution suitable for ranging or branch and cut.  With
the current state of quadratic it may be a good idea to switch off
crossover for quadratic (and maybe presolve as well) - the option
maybe does this.
<Possible options for crossover are: on off maybe presolve;
        current  on>
----

Command direction  Minimize or Maximize
---- description
The default is minimize - use 'direction maximize' for maximization.
You can also use the parameters 'maximize' or 'minimize'.
<Possible options for direction are: min(imize) max(imize) zero;
        current  min(imize)>
----

Command dualP(ivot)  Dual pivot choice algorithm
---- description
Clp can use any pivot selection algorithm which the user codes as
long as it implements the features in the abstract pivot base class.
The Dantzig method is implemented to show a simple method but its
use is deprecated.  Steepest is the method of choice and there are
two variants which keep all weights updated but only scan a subset
each iteration. Partial switches this on while automatic decides at
each iteration based on information about the factorization.
<Possible options for dualPivot are: auto(matic) dant(zig) partial steep(est);
        current  auto(matic)>
----

Command keepN(ames)  Whether to keep names from import
---- description
It saves space to get rid of names so if you need to you can set this
to off.  This needs to be set before the import of model - so -keepnames
off -import xxxxx.mps.
<Possible options for keepNames are: on off;
        current  on>
----

Command mess(ages)  Controls if Clpnnnn is printed
---- description
The default behavior is to put out messages such as:
Clp0005 2261  Objective 109.024 Primal infeas 944413 (758)
but this program turns this off to make it look more friendly.  It
can be useful to turn them back on if you want to be able to 'grep'
for particular messages or if you intend to override the behavior
of a particular message.
<Possible options for messages are: off on;
        current  off>
----

Command perturb(ation)  Whether to perturb problem
---- description
Perturbation helps to stop cycling, but Clp uses other measures for
this.  However large problems and especially ones with unit elements
and unit rhs or costs benefit from perturbation.  Normally Clp tries
to be intelligent, but you can switch this off.  The Clp library has
this off by default.  This program has it on by default.
<Possible options for perturbation are: on off;
        current  on>
----

Command presolve  Whether to presolve problem
---- description
Presolve analyzes the model to find such things as redundant equations,
equations which fix some variables, equations which can be transformed
into bounds etc etc.  For the initial solve of any problem this is
worth doing unless you know that it will have no effect.  on will
normally do 5 passes while using 'more' will do 10.  If the problem
is very large you may need to write the original to file using 'file'.
<Possible options for presolve are: on off more file;
        current  on>
----

Command primalP(ivot)  Primal pivot choice algorithm
---- description
Clp can use any pivot selection algorithm which the user codes as
long as it implements the features in the abstract pivot base class.
The Dantzig method is implemented to show a simple method but its
use is deprecated.  Exact devex is the method of choice and there
are two variants which keep all weights updated but only scan a subset
each iteration. Partial switches this on while change initially does
dantzig until the factorization becomes denser.  This is still a work
in progress.
<Possible options for primalPivot are: auto(matic) exa(ct) dant(zig) part(ial) steep(est) change sprint;
        current  auto(matic)>
----

Command scal(ing)  Whether to scale problem
---- description
Scaling can help in solving problems which might otherwise fail because
of lack of accuracy.  It can also reduce the number of iterations.
It is not applied if the range of elements is small.  When unscaled
it is possible that there may be small primal and/or infeasibilities.
<Possible options for scaling are: off equi(librium) geo(metric) auto(matic);
        current  auto(matic)>
----


Branch and Cut keyword parameters:

Command clique(Cuts)  Whether to use Clique cuts
---- description
This switches on clique cuts (either at root or in entire tree) See
branchAndCut for information on options.
<Possible options for cliqueCuts are: off on root ifmove;
        current  ifmove>
----

Command combine(Solutions)  Whether to use combine solution heuristic
---- description
This switches on a heuristic which does branch and cut on the problem
given by just using variables which have appeared in one or more solutions.
It is obviously only tries after two or more solutions.
<Possible options for combineSolutions are: off on;
        current  on>
----

Command cost(Strategy)  How to use costs as priorities
---- description
This orders the variables in order of their absolute costs - with
largest cost ones being branched on first.  This primitive strategy
can be surprsingly effective.
<Possible options for costStrategy are: off pri(orities) pseudo(costs(not implemented yet));
        current  off>
----

Command cuts(OnOff)  Switches all cuts on or off
---- description
This can be used to switch on or off all cuts (apart from Reduce and
Split).  Then you can do individual ones off or on See branchAndCut
for information on options.
<Possible options for cutsOnOff are: off on root ifmove;
        current  on>
----

Command feas(ibilityPump)  Whether to try Feasibility Pump
---- description
This switches on feasibility pump heuristic at root. This is due to
Fischetti and Lodi and uses a sequence of Lps to try and get an integer
feasible solution. Some fine tuning is available by passFeasibilityPump.
<Possible options for feasibilityPump are: off on;
        current  on>
----

Command flow(CoverCuts)  Whether to use Flow Cover cuts
---- description
This switches on flow cover cuts (either at root or in entire tree)
See branchAndCut for information on options.
<Possible options for flowCoverCuts are: off on root ifmove;
        current  ifmove>
----

Command gomory(Cuts)  Whether to use Gomory cuts
---- description
The original cuts - beware of imitations!  Having gone out of favor,
they are now more fashionable as LP solvers are more robust and they
interact well with other cuts.  They will almost always give cuts
(although in this executable they are limited as to number of variables
in cut).  However the cuts may be dense so it is worth experimenting.
See branchAndCut for information on options.
<Possible options for gomoryCuts are: off on root ifmove;
        current  ifmove>
----

Command greedy(Heuristic)  Whether to use a greedy heuristic
---- description
Switches on a greedy heuristic which will try and obtain a solution.
It may just fix a percentage of variables and then try a small branch
and cut run.
<Possible options for greedyHeuristic are: off on root;
        current  on>
----

Command heur(isticsOnOff)  Switches most heuristics on or off
---- description
This can be used to switch on or off all heuristics.  Then you can
do individual ones off or on.  CbcTreeLocal is not included as it
dramatically alters search.
<Possible options for heuristicsOnOff are: off on;
        current  on>
----

Command knapsack(Cuts)  Whether to use Knapsack cuts
---- description
This switches on knapsack cuts (either at root or in entire tree)
See branchAndCut for information on options.
<Possible options for knapsackCuts are: off on root ifmove;
        current  ifmove>
----

Command local(TreeSearch)  Whether to use local treesearch
---- description
This switches on a local search algorithm when a solution is found.
This is from Fischetti and Lodi and is not really a heuristic although
it can be used as one. When used from Coin solve it has limited functionality.
It is not switched on when heuristics are switched on.
<Possible options for localTreeSearch are: off on;
        current  off>
----

Command mixed(IntegerRoundingCuts)  Whether to use Mixed Integer Rounding cuts
---- description
This switches on mixed integer rounding cuts (either at root or in
entire tree) See branchAndCut for information on options.
<Possible options for mixedIntegerRoundingCuts are: off on root ifmove;
        current  ifmove>
----

Command preprocess  Whether to use integer preprocessing
---- description
This tries to reduce size of model in a similar way to presolve and
it also tries to strengthen the model - this can be very useful and
is worth trying.  Save option saves on file presolved.mps.  equal
will turn <= cliques into ==.  sos will create sos sets if all 0-1
in sets (well one extra is allowed) and no overlaps.  trysos is same
but allows any number extra.
<Possible options for preprocess are: off on save equal sos trysos;
        current  sos>
----

Command probing(Cuts)  Whether to use Probing cuts
---- description
This switches on probing cuts (either at root or in entire tree) See
branchAndCut for information on options.
<Possible options for probingCuts are: off on root ifmove;
        current  ifmove>
----

Command reduce(AndSplitCuts)  Whether to use Reduce-and-Split cuts
---- description
This switches on reduce and split  cuts (either at root or in entire
tree) See branchAndCut for information on options.
<Possible options for reduceAndSplitCuts are: off on root ifmove;
        current  root>
----

Command round(ingHeuristic)  Whether to use Rounding heuristic
---- description
This switches on a simple (but effective) rounding heuristic at each
node of tree.
<Possible options for roundingHeuristic are: off on;
        current  on>
----

Command two(MirCuts)  Whether to use Two phase Mixed Integer Rounding cuts
---- description
This switches on two phase mixed integer rounding  cuts (either at
root or in entire tree) See branchAndCut for information on options.
<Possible options for twoMirCuts are: off on root ifmove;
        current  root>
----


Actions or string parameters:

Command barr(ier)  Solve using primal dual predictor corrector algorithm
---- description
This command solves the current model using the  primal dual predictor
corrector algorithm.  You will probably want to link in and choose
a better ordering and factorization than the default ones provided.
It will also solve models with quadratic objectives.
----

Command basisO(ut)  Export basis as bas file
---- description
This will write an MPS format basis file to the given file name. 
It will use the default directory given by 'directory'.  A name of
'$' will use the previous value for the name.  This is initialized
to 'default.bas'.
----

Command directory  Set Default directory for import etc.
---- description
This sets the directory which import, export, saveModel, restoreModel
etc will use.  It is initialized to './'
----

Command dualS(implex)  Do dual simplex algorithm
---- description
This command solves the current model using the dual steepest edge
algorithm.The time and iterations may be affected by settings such
as presolve, scaling, crash and also by dual pivot method, fake bound
on variables and dual and primal tolerances.
----

Command either(Simplex)  Do dual or primal simplex algorithm
---- description
This command solves the current model using the dual or primal algorithm,
based on a dubious analysis of model.
----

Command end  Stops clp execution
---- description
This stops execution ; end, exit, quit and stop are synonyms
----

Command exit  Stops clp execution
---- description
This stops the execution of Clp, end, exit, quit and stop are synonyms
----

Command export  Export model as mps file
---- description
This will write an MPS format file to the given file name.  It will
use the default directory given by 'directory'.  A name of '$' will
use the previous value for the name.  This is initialized to 'default.mps'.
----

Command initialS(olve)  Solve to continuous
---- description
This just solves the problem to continuous - without adding any cuts
----

Command max(imize)  Set optimization direction to maximize
---- description
The default is minimize - use 'maximize' for maximization.
You can also use the parameters 'direction maximize'.
----

Command min(imize)  Set optimization direction to minimize
---- description
The default is minimize - use 'maximize' for maximization.
This should only be necessary if you have previously set maximization
You can also use the parameters 'direction minimize'.
----

Command primalS(implex)  Do primal simplex algorithm
---- description
This command solves the current model using the primal algorithm.
The default is to use exact devex. The time and iterations may be
affected by settings such as presolve, scaling, crash and also by
column selection  method, infeasibility weight and dual and primal
tolerances.
----

Command quit  Stops clp execution
---- description
This stops the execution of Clp, end, exit, quit and stop are synonyms
----

Command restore(Model)  Restore model from binary file
---- description
This reads data save by saveModel from the given file.  It will use
the default directory given by 'directory'.  A name of '$' will use
the previous value for the name.  This is initialized to 'default.prob'.
----

Command saveM(odel)  Save model to binary file
---- description
This will save the problem to the given file name for future use by
restoreModel.  It will use the default directory given by 'directory'.
A name of '$' will use the previous value for the name.  This is initialized
to 'default.prob'.
----

Command saveS(olution)  saves solution to file
---- description
This will write a binary solution file to the given file name.  It
will use the default directory given by 'directory'.  A name of '$'
will use the previous value for the name.  This is initialized to
'solution.file'.  To read the file use fread(int) twice to pick up
number of rows and columns, then fread(double) to pick up objective
value, then pick up row activities, row duals, column activities and
reduced costs - see bottom of CbcOrClpParam.cpp for code that writes
file.
----

Command solu(tion)  Prints solution to file
---- description
This will write a primitive solution file to the given file name.
It will use the default directory given by 'directory'.  A name of
'$' will use the previous value for the name.  This is initialized
to 'stdout'.  The amount of output can be varied using printi!ngOptions
or printMask.
----

Command stat(istics)  Print some statistics
---- description
This command prints some statistics for the current model. If log
level >1 then more is printed. These are for presolved model if presolve
on (and unscaled).
----

Command stop  Stops clp execution
---- description
This stops the execution of Clp, end, exit, quit and stop are synonyms
----


Branch and Cut actions:

Command branch(AndCut)  Do Branch and Cut
---- description
This does branch and cut.  There are many parameters which can affect
the performance.  First just try with default settings and look carefully
at the log file.  Did cuts help?  Did they take too long?  Look at
output to see which cuts were effective and then do some tuning. 
You will see that the options for cuts are off, on, root and ifmove.
Off is obvious, on means that this cut generator will be tried in
the branch and cut tree (you can fine tune using 'depth').  Root means
just at the root node while 'ifmove' means that cuts will be used
in the tree if they look as if they are doing some good and moving
the objective value.  If pre-processing reduced the size of the problem
or strengthened many coefficients then it is probably wise to leave
it on.  Switch off heuristics which did not provide solutions.  The
other major area to look at is the search.  Hopefully good solutions
were obtained fairly early in the search so the important point is
to select the best variable to branch on.  See whether strong branching
did a good job - or did it just take a lot of iterations.  Adjust
the strongBranching and trustPseudoCosts parameters.
----

Command solv(e)  Solve problem
---- description
If there are no integer variables then this just solves LP.  If there
are integer variables this does branch and cut.
----