CBC

CBC (COIN-OR Branch and Cut) is an open-source mixed integer programming solver working with the COIN-OR LP solver CLP and the COIN-OR Cut generator library Cgl. The code has been written primarily by John J. Forrest. Most of the CBC documentation in the section was copied from the help in the CBC standalone version.

The CBC link in GAMS supports continuous, binary, integer, semicontinuous, semiinteger variables, special ordered sets of type 1 and 2, and branching priorities.

Usage

The following statement can be used inside your GAMS program to specify using CBC

Option LP = CBC;     { or MIP or RMIP }

The above statement should appear before the Solve statement. If CBC was specified as the default solver during GAMS installation, the above statement is not necessary.

For usage and syntax of solver options file, see Section The Solver Option File. Following is an example options file cbc.opt.

cuts root
perturbation off

It will cause CBC to use cut generators only in the root node and turns off the perturbation of the LP relaxation.

GAMS/CBC currently does not support the GAMS Branch-and-Cut-and-Heuristic (BCH) Facility. If you need to use GAMS/CBC with BCH, please consider to use a GAMS system of version ≤ 23.3.

The following GAMS parameters are currently supported by GAMS/CBC: reslim, iterlim, nodlim, optca, optcr, cheat, cutoff, and threads.

List of Options

There are many parameters which can affect the performance the CBCs Branch and Cut Algorithm. First just try with default settings and look carefully at the log file. Did cuts help? Did they take too long? Look at the output to see which cuts were effective and then do some tuning (see the option cuts). If the preprocessing 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 options strongBranching and trustpseudocosts.

In the following, we summarize all available CBC options.

General Options

Option Description Default
clocktype type of clock for time measurement wall
reslim maximum seconds GAMS reslim
special options passed unseen to CBC
writemps create MPS file for problem

LP Options

Option Description Default
autoScale Whether to scale objective, rhs and bounds of problem if they look odd (experimental) 0
biasLU Whether factorization biased towards U LX
bscale Whether to scale in barrier (and ordering speed) off
crash Whether to create basis for problem off
crossover Whether to get a basic solution with the simplex algorithm after the barrier algorithm finished on
denseThreshold Threshold for using dense factorization -1
dualPivot Dual pivot choice algorithm automatic
factorization Which factorization to use normal
gamma Whether to regularize barrier off
idiotCrash Whether to try idiot crash -1
iterlim Maximum number of iterations before stopping GAMS iterlim
KKT Whether to use KKT factorization in barrier 0
maxFactor Maximum number of iterations between refactorizations 200
passPresolve How many passes in presolve 5
perturbation Whether to perturb the problem 1
presolve Whether to presolve problem on
primalPivot Primal pivot choice algorithm automatic
primalWeight Initially algorithm acts as if it costs this much to be infeasible 1e+10
psi Two-dimension pricing factor for Positive Edge criterion -0.5
randomSeedClp Random seed for Clp 1234567
scaling Whether to scale problem automatic
smallFactorization Threshold for using small factorization -1
sparseFactor Whether factorization treated as sparse 1
sprintCrash Whether to try sprint crash -1
startalg LP solver for root node dual
substitution How long a column to substitute for in presolve 3
tol_dual For an optimal solution no dual infeasibility may exceed this value 1e-07
tol_presolve Tolerance to use in presolve 1e-08
tol_primal For a feasible solution no primal infeasibility, i.e., constraint violation, may exceed this value 1e-07

MIP Options

Option Description Default
costStrategy How to use costs for branching priorities off
cutoff Bound on the objective value for all solutions GAMS cutoff
cutoffConstraint Whether to use cutoff as constraint off
dumpsolutions name of solutions index gdx file for writing alternate solutions
dumpsolutionsmerged name of gdx file for writing all alternate solutions
expensiveStrong Whether to do even more strong branching 0
extraVariables Allow creation of extra integer variables 0
fixOnDj Try heuristic based on fixing variables with reduced costs greater than this -1
increment A valid solution must be at least this much better than last integer solution GAMS cheat
infeasibilityWeight Each integer infeasibility is expected to cost this much 0
loglevel amount of output printed by CBC 1
maxsol Maximum number of solutions to save 100
mipstart whether it should be tried to use the initial variable levels as initial MIP solution 0
multipleRootPasses Do multiple root passes to collect cuts and solutions 0
nodeStrategy What strategy to use to select the next node from the branch and cut tree fewest
nodlim node limit GAMS nodlim
optca Stop when gap between best possible and best less than this GAMS optca
optcr Stop when gap between best possible and best known is less than this fraction of larger of two GAMS optcr
OrbitalBranching Whether to try orbital branching off
parallelmode whether to run opportunistic or deterministic deterministic
preprocess Whether to use integer preprocessing sos
printfrequency frequency of status prints 0
randomSeedCbc Random seed for Cbc -1
sollim Maximum number of feasible solutions to get maxint
solvefinal final solve of MIP with fixed discrete variables 1
solvetrace name of trace file for solving information
solvetracenodefreq frequency in number of nodes for writing to solve trace file 100
solvetracetimefreq frequency in seconds for writing to solve trace file 5
sosPrioritize How to deal with SOS priorities off
strategy Switches on groups of features 1
strongBranching Number of variables to look at in strong branching 5
threads Number of threads to try and use GAMS threads
tol_integer For a feasible solution no integer variable may be more than this away from an integer value 1e-07
trustPseudoCosts Number of branches before we trust pseudocosts 10

MIP Options for Cutting Plane Generators

Option Description Default
cliqueCuts Whether to use Clique cuts ifmove
conflictcuts Conflict Cuts 0
cutDepth Depth in tree at which to do cuts -1
cutLength Length of a cut -1
cuts Switches all cut generators on or off on
cut_passes_root Number of rounds that cut generators are applied in the root node 20 or 100
cut_passes_slow Maximum number of rounds for slower cut generators 10
cut_passes_tree Number of rounds that cut generators are applied in the tree 10
flowCoverCuts Whether to use Flow Cover cuts ifmove
gomoryCuts Whether to use Gomory cuts ifmove
gomorycuts2 Whether to use alternative Gomory cuts off
knapsackCuts Whether to use Knapsack cuts ifmove
lagomoryCuts Whether to use Lagrangean Gomory cuts off
latwomirCuts Whether to use Lagrangean TwoMir cuts off
liftAndProjectCuts Whether to use Lift and Project cuts off
mirCuts Whether to use Mixed Integer Rounding cuts ifmove
probingCuts Whether to use Probing cuts ifmove
reduceAndSplitCuts Whether to use Reduce-and-Split cuts off
reduceAndSplitCuts2 Whether to use Reduce-and-Split cuts - style 2 off
residualCapacityCuts Whether to use Residual Capacity cuts off
twoMirCuts Whether to use Two phase Mixed Integer Rounding cuts root
zeroHalfCuts Whether to use zero half cuts ifmove

MIP Options for Primal Heuristics

Option Description Default
combine2Solutions Whether to use crossover solution heuristic off
combineSolutions Whether to use combine solution heuristic off
Dins Whether to try Distance Induced Neighborhood Search off
diveSolves Diving solve option 100
DivingCoefficient Whether to try Coefficient diving heuristic off
DivingFractional Whether to try Fractional diving heuristic off
DivingGuided Whether to try Guided diving heuristic off
DivingLineSearch Whether to try Linesearch diving heuristic off
DivingPseudoCost Whether to try Pseudocost diving heuristic off
DivingRandom Whether to try Diving heuristics off
DivingVectorLength Whether to try Vectorlength diving heuristic off
dwHeuristic Whether to try Dantzig Wolfe heuristic off
feaspump Whether to try the Feasibility Pump heuristic on
feaspump_artcost Costs ≥ this treated as artificials in feasibility pump 0
feaspump_cutoff Fake cutoff for use in feasibility pump 0
feaspump_fracbab Fraction in feasibility pump 0.5
feaspump_increment Fake increment for use in feasibility pump 0
feaspump_passes How many passes to do in the Feasibility Pump heuristic 20
greedyHeuristic Whether to use a greedy heuristic on
heuristics Switches most primal heuristics on or off 1
hOptions Heuristic options 0
localTreeSearch Whether to use local tree search when a solution is found 0
naiveHeuristics Whether to try some stupid heuristic off
pivotAndComplement Whether to try Pivot and Complement heuristic off
pivotAndFix Whether to try Pivot and Fix heuristic off
proximitySearch Whether to do proximity search heuristic off
randomizedRounding Whether to try randomized rounding heuristic off
Rens Whether to try Relaxation Enforced Neighborhood Search off
Rins Whether to try Relaxed Induced Neighborhood Search off
roundingHeuristic Whether to use simple (but effective) Rounding heuristic on
VndVariableNeighborhoodSearch Whether to try Variable Neighborhood Search off
vubheuristic Type of VUB heuristic -1

Detailed Options Description

In the following, we give a detailed description of all available CBC options.

autoScale (boolean): Whether to scale objective, rhs and bounds of problem if they look odd (experimental)

Default: 0

biasLU (string): Whether factorization biased towards U

Default: LX

Values: ll, lx, uu, ux

bscale (string): Whether to scale in barrier (and ordering speed)

Default: off

Values: off, off1, off2, on, on1, on2

cliqueCuts (string): Whether to use Clique cuts

Value 'on' enables the cut generator and CBC will try it in the branch and cut tree (see cutDepth on how to fine tune the behavior). Value 'root' lets CBC run the cut generator generate only at the root node. Value 'ifmove' lets CBC use the cut generator in the tree if it looks as if it is doing some good and moves the objective value. Value 'forceon' turns on the cut generator and forces CBC to use it at every node. Reference: https://github.com/coin-or/Cgl/wiki/CglClique

Default: ifmove

Values: forceon, ifmove, off, on, onglobal, root

clocktype (string): type of clock for time measurement

Default: wall

valuemeaning
cpu CPU clock
wall Wall clock

combine2Solutions (string): Whether to use crossover solution heuristic

This heuristic does branch and cut on the problem given by fixing variables which have the same value in two or more solutions. It obviously only tries after two or more solutions. Value 'on' means to use the heuristic in each node of the tree, i.e. after preprocessing. Value 'before' means use the heuristic only if option doHeuristics is used. Value 'both' means to use the heuristic if option doHeuristics is used and during solve.

Default: off

Values: before, both, off, on

combineSolutions (string): Whether to use combine solution heuristic

This heuristic does branch and cut on given problem by just using variables which have appeared in one or more solutions. It is obviously only tried after two or more solutions have been found. Value 'on' means to use the heuristic in each node of the tree, i.e. after preprocessing. Value 'before' means use the heuristic only if option doHeuristics is used. Value 'both' means to use the heuristic if option doHeuristics is used and during solve.

Default: off

valuemeaning
0 Same as off. This is a deprecated setting.
1 Same as on. This is a deprecated setting.
before
beforequick
both
bothquick
off
on
onquick

conflictcuts (boolean): Conflict Cuts

Equivalent to setting cutoffconstraint=conflict

Default: 0

costStrategy (string): How to use costs for branching priorities

Value 'priorities' assigns highest priority to variables with largest absolute cost. This primitive strategy can be surprisingly effective. Value 'columnorder' assigns the priorities 1, 2, 3, ... with respect to the column ordering. Value '01first' ('01last') assignes two sets of priorities such that binary variables get high (low) priority. Value 'length' assigns high priority to variables that occur in many equations.

Default: off

valuemeaning
01first
01last
binaryfirst This is a deprecated setting. Please use 01first.
binarylast This is a deprecated setting. Please use 01last.
columnorder
generalforce
length
nonzero
off
priorities
singletons

crash (string): Whether to create basis for problem

If crash is set to 'on' and there is an all slack basis then Clp will flip or put structural variables into the basis with the aim of getting dual feasible. On average, dual simplex seems to perform better without it and there are alternative types of 'crash' for primal simplex, e.g. 'idiot' or 'sprint'. A variant due to Solow and Halim which is as 'on' but just flips is also available.

Default: off

Values: idiot1, idiot2, idiot3, idiot4, idiot5, idiot6, idiot7, lots, off, on, solow_halim

crossover (string): Whether to get a basic solution with the simplex algorithm after the barrier algorithm finished

Interior point algorithms do not obtain a basic solution. This option will crossover to a basic solution suitable for ranging or branch and cut.

Default: on

valuemeaning
0 Same as off. This is a deprecated setting.
1 Same as on. This is a deprecated setting.
off
on
presolve

cutDepth (integer): Depth in tree at which to do cuts

Cut generators may be off, on, on only at the root node, or on if they look useful. Setting this option to a positive value K let CBC call a cutgenerator on a node whenever the depth in the tree is a multiple of K. The default of -1 lets CBC decide.

Range: [-1, ∞]

Default: -1

cutLength (integer): Length of a cut

At present this only applies to Gomory cuts. -1 (default) leaves as is. Any value >0 says that all cuts ≤ this length can be generated both at root node and in tree. 0 says to use some dynamic lengths. If value ≥10,000,000 then the length in tree is value - so 10000100 means unlimited length at root and 100 in tree.

Range: [-1, ∞]

Default: -1

cutoff (real): Bound on the objective value for all solutions

A valid solution must be at least this much better than last integer solution. If this option is not set then it CBC 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.

Range: [-∞, ∞]

Default: GAMS cutoff

cutoffConstraint (string): Whether to use cutoff as constraint

Synonym: constraintfromCutoff

For some problems, cut generators and general branching work better if the problem would be infeasible if the cost is too high. If this option is enabled, the objective function is added as a constraint which right hand side is set to the current cutoff value (objective value of best known solution)

Default: off

valuemeaning
0 Same as off. This is a deprecated setting.
1 Same as on. This is a deprecated setting.
conflict
forcevariable
off
on
variable

cuts (string): Switches all cut generators on or off

Synonym: cutsOnOff

This can be used to switch on or off all cut generators (apart from Reduce and Split). Then one can turn individual ones off or on. Value 'on' enables the cut generator and CBC will try it in the branch and cut tree (see cutDepth on how to fine tune the behavior). Value 'root' lets CBC run the cut generator generate only at the root node. Value 'ifmove' lets CBC use the cut generator in the tree if it looks as if it is doing some good and moves the objective value. Value 'forceon' turns on the cut generator and forces CBC to use it at every node.

Default: on

Values: forceon, ifmove, off, on, root

cut_passes_root (integer): Number of rounds that cut generators are applied in the root node

Synonym: passCuts

The default is to do 100 passes if the problem has less than 500 columns, 100 passes (but stop if the drop in the objective function value is small) if the problem has less than 5000 columns, and 20 passes otherwise. A negative value -n means that n passes are also applied if the objective does not drop.

Range: [-∞, ∞]

Default: 20 or 100

cut_passes_slow (integer): Maximum number of rounds for slower cut generators

Synonym: slowcutpasses

Some cut generators are fairly slow - this limits the number of times they are tried. The cut generators identified as 'may be slow' at present are Lift and project cuts and both versions of Reduce and Split cuts.

Range: [-1, ∞]

Default: 10

cut_passes_tree (integer): Number of rounds that cut generators are applied in the tree

Synonym: passTreeCuts

The default is to do one pass. A negative value -n means that n passes are also applied if the objective does not drop.

Range: [-∞, ∞]

Default: 10

denseThreshold (integer): Threshold for using dense factorization

If processed problem ≤ this use dense factorization

Range: [-1, 10000]

Default: -1

Dins (string): Whether to try Distance Induced Neighborhood Search

Value 'on' means to use the heuristic in each node of the tree, i.e. after preprocessing. Value 'before' means use the heuristic only if option doHeuristics is used. Value 'both' means to use the heuristic if option doHeuristics is used and during solve.

Default: off

valuemeaning
0 Same as off. This is a deprecated setting.
1 Same as on. This is a deprecated setting.
before
both
off
often
on

diveSolves (integer): Diving solve option

If >0 then do up to this many solves. However, the last digit is ignored and used for extra options: 1-3 enables fixing of satisfied integer variables (but not at bound), where 1 switches this off for that dive if the dive goes infeasible, and 2 switches it off permanently if the dive goes infeasible.

Range: [-1, 200000]

Default: 100

DivingCoefficient (string): Whether to try Coefficient diving heuristic

Value 'on' means to use the heuristic in each node of the tree, i.e. after preprocessing. Value 'before' means use the heuristic only if option doHeuristics is used. Value 'both' means to use the heuristic if option doHeuristics is used and during solve.

Default: off

valuemeaning
0 Same as off. This is a deprecated setting.
1 Same as on. This is a deprecated setting.
before
both
off
on

DivingFractional (string): Whether to try Fractional diving heuristic

Value 'on' means to use the heuristic in each node of the tree, i.e. after preprocessing. Value 'before' means use the heuristic only if option doHeuristics is used. Value 'both' means to use the heuristic if option doHeuristics is used and during solve.

Default: off

valuemeaning
0 Same as off. This is a deprecated setting.
1 Same as on. This is a deprecated setting.
before
both
off
on

DivingGuided (string): Whether to try Guided diving heuristic

Value 'on' means to use the heuristic in each node of the tree, i.e. after preprocessing. Value 'before' means use the heuristic only if option doHeuristics is used. Value 'both' means to use the heuristic if option doHeuristics is used and during solve.

Default: off

valuemeaning
0 Same as off. This is a deprecated setting.
1 Same as on. This is a deprecated setting.
before
both
off
on

DivingLineSearch (string): Whether to try Linesearch diving heuristic

Value 'on' means to use the heuristic in each node of the tree, i.e. after preprocessing. Value 'before' means use the heuristic only if option doHeuristics is used. Value 'both' means to use the heuristic if option doHeuristics is used and during solve.

Default: off

valuemeaning
0 Same as off. This is a deprecated setting.
1 Same as on. This is a deprecated setting.
before
both
off
on

DivingPseudoCost (string): Whether to try Pseudocost diving heuristic

Value 'on' means to use the heuristic in each node of the tree, i.e. after preprocessing. Value 'before' means use the heuristic only if option doHeuristics is used. Value 'both' means to use the heuristic if option doHeuristics is used and during solve.

Default: off

valuemeaning
0 Same as off. This is a deprecated setting.
1 Same as on. This is a deprecated setting.
before
both
off
on

DivingRandom (string): Whether to try Diving heuristics

Synonym: DivingSome

This switches on a random diving heuristic at various times. One may prefer to individually turn diving heuristics on or off. Value 'on' means to use the heuristic in each node of the tree, i.e. after preprocessing. Value 'before' means use the heuristic only if option doHeuristics is used. Value 'both' means to use the heuristic if option doHeuristics is used and during solve.

Default: off

valuemeaning
0 Same as off. This is a deprecated setting.
1 Same as on. This is a deprecated setting.
before
both
off
on

DivingVectorLength (string): Whether to try Vectorlength diving heuristic

Value 'on' means to use the heuristic in each node of the tree, i.e. after preprocessing. Value 'before' means use the heuristic only if option doHeuristics is used. Value 'both' means to use the heuristic if option doHeuristics is used and during solve.

Default: off

valuemeaning
0 Same as off. This is a deprecated setting.
1 Same as on. This is a deprecated setting.
before
both
off
on

dualPivot (string): Dual pivot choice algorithm

The Dantzig method is simple 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. The PE variants add the Positive Edge criterion. This selects incoming variables to try to avoid degenerate moves. See also option psi.

Default: automatic

valuemeaning
auto Same as automatic. This is a deprecated setting.
automatic
dantzig
partial
pedantzig
pesteepest
steepest

dumpsolutions (string): name of solutions index gdx file for writing alternate solutions

The name of a solutions index gdx file for writing alternate solutions found by CBC. The GDX file specified by this option will contain a set called index that contains the names of GDX files with the individual solutions.

dumpsolutionsmerged (string): name of gdx file for writing all alternate solutions

dwHeuristic (string): Whether to try Dantzig Wolfe heuristic

This heuristic is very very compute intensive. It tries to find a Dantzig Wolfe structure and use that. Value 'on' means to use the heuristic in each node of the tree, i.e. after preprocessing. Value 'before' means use the heuristic only if option doHeuristics is used. Value 'both' means to use the heuristic if option doHeuristics is used and during solve.

Default: off

Values: before, both, off, on

expensiveStrong (integer): Whether to do even more strong branching

Strategy for extra strong branching. 0 is normal strong branching. 1, 2, 4, and 6 does strong branching on all fractional variables if at the root node (1), at depth less than modifier (2), objective equals best possible (4), or at depth less than modifier and objective equals best possible (6). 11, 12, 14, and 16 are like 1, 2, 4, and 6, respecitively, but do strong branching on all integer (incl. non-fractional) variables. Values ≥ 100 are used to specify a depth limit (value/100), otherwise 5 is used. If the values ≥ 100, then above rules are applied to value.

Default: 0

extraVariables (integer): Allow creation of extra integer variables

Switches on a trivial re-formulation that introduces extra integer variables to group together variables with same cost.

Range: [-∞, ∞]

Default: 0

factorization (string): Which factorization to use

The default is to use the normal CoinFactorization, but other choices are a dense one, OSL's, or one designed for small problems.

Default: normal

Values: dense, normal, osl, simple

feaspump (string): Whether to try the Feasibility Pump heuristic

Synonym: feasibilityPump

This heuristic is due to Fischetti, Glover, and Lodi and uses a sequence of LPs to try and get an integer feasible solution. Some fine tuning is available by options passFeasibilityPump and pumpTune. Value 'on' means to use the heuristic in each node of the tree, i.e. after preprocessing. Value 'before' means use the heuristic only if option doHeuristics is used. Value 'both' means to use the heuristic if option doHeuristics is used and during solve.

Default: on

valuemeaning
0 Same as off. This is a deprecated setting.
1 Same as on. This is a deprecated setting.
before
both
off
on

feaspump_artcost (real): Costs ≥ this treated as artificials in feasibility pump

Synonym: artificialCost

A value of 0.0 means off. Otherwise, variables with costs ≥ this are treated as artificial variables and fixed to lower bound in feasibility pump.

Default: 0

feaspump_cutoff (real): Fake cutoff for use in feasibility pump

Synonym: pumpCutoff

A value of 0.0 means off. Otherwise, add a constraint forcing objective below this value in feasibility pump

Range: [-∞, ∞]

Default: 0

feaspump_fracbab (real): Fraction in feasibility pump

Synonym: fractionforBAB

After a pass in the feasibility pump, variables which have not moved about are fixed and if the preprocessed model is smaller than this fraction of the original problem, a few nodes of branch and bound are done on the reduced problem.

Range: [1e-05, 1.1]

Default: 0.5

feaspump_increment (real): Fake increment for use in feasibility pump

Synonym: pumpIncrement

A value of 0.0 means off. Otherwise use as absolute increment to cutoff when solution found in feasibility pump

Range: [-∞, ∞]

Default: 0

feaspump_passes (integer): How many passes to do in the Feasibility Pump heuristic

Synonym: passFeasibilityPump

Range: [0, 10000]

Default: 20

fixOnDj (real): Try heuristic based on fixing variables with reduced costs greater than this

If this is set integer variables with reduced costs greater than this will be fixed before branch and bound - use with extreme caution!

Range: [-∞, ∞]

Default: -1

flowCoverCuts (string): Whether to use Flow Cover cuts

Value 'on' enables the cut generator and CBC will try it in the branch and cut tree (see cutDepth on how to fine tune the behavior). Value 'root' lets CBC run the cut generator generate only at the root node. Value 'ifmove' lets CBC use the cut generator in the tree if it looks as if it is doing some good and moves the objective value. Value 'forceon' turns on the cut generator and forces CBC to use it at every node. Reference: https://github.com/coin-or/Cgl/wiki/CglFlowCover

Default: ifmove

Values: forceon, ifmove, off, on, onglobal, root

gamma (string): Whether to regularize barrier

Default: off

Values: delta, deltastrong, gamma, gammastrong, off, on, onstrong

gomoryCuts (string): Whether to use Gomory cuts

The original cuts - beware of imitations! Having gone out of favor, they are value. Value 'forceon' turns on the cut generator and forces CBC to use it at 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 (Long allows any length). Value 'on' enables the cut generator and CBC will try it in the branch and cut tree (see cutDepth on how to fine tune the behavior). Value 'root' lets CBC run the cut generator generate only at the root node. Value 'ifmove' lets CBC use the cut generator in the tree if it looks as if it is doing some good and moves the objective

Default: ifmove

Values: forceandglobal, forcelongon, forceon, ifmove, long, off, on, onglobal, root

gomorycuts2 (string): Whether to use alternative Gomory cuts

Synonym: GMICuts

Value 'on' enables the cut generator and CBC will try it in the branch and cut tree (see cutDepth on how to fine tune the behavior). Value 'root' lets CBC run the cut generator generate only at the root node. Value 'ifmove' lets CBC use the cut generator in the tree if it looks as if it is doing some good and moves the objective value. Value 'forceon' turns on the cut generator and forces CBC to use it at every node. This version is by Giacomo Nannicini and may be more robust than gomoryCuts.

Default: off

Values: endonly, forcelongon, forceon, ifmove, long, longendonly, longifmove, longroot, off, on, root

greedyHeuristic (string): Whether to use a greedy heuristic

This heuristic tries to obtain a feasible solution by just fixing a percentage of variables and then try a small branch and cut run. Value 'on' means to use the heuristic in each node of the tree, i.e. after preprocessing. Value 'before' means use the heuristic only if option doHeuristics is used. Value 'both' means to use the heuristic if option doHeuristics is used and during solve.

Default: on

Values: before, both, off, on

heuristics (boolean): Switches most primal heuristics on or off

Synonym: heuristicsOnOff

This option can be used to switch on or off all heuristics that search for feasible solutions, except for the local tree search, as it dramatically alters the search. Then individual heuristics can be turned off or on.

Default: 1

hOptions (integer): Heuristic options

Value 1 stops heuristics immediately if the allowable gap has been reached. Other values are for the feasibility pump - 2 says do exact number of passes given, 4 only applies if an initial cutoff has been given and says relax after 50 passes, while 8 will adapt the cutoff rhs after the first solution if it looks as if the code is stalling.

Range: [-∞, ∞]

Default: 0

idiotCrash (integer): Whether to try idiot crash

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 the primal simplex algorithm. 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: [-1, ∞]

Default: -1

increment (real): A valid solution must be at least this much better than last integer solution

Whenever a solution is found the bound on the objective value for new solutions is set to the objective function of the found solution (in a minimization sense) plus this. If it is not set then CBC will try and work one out, e.g. if all objective coefficients are multiples of 0.01 and only integer variables have entries in the objective function, then the increment can be set to 0.01. Be careful if setting this to a negative value!

Range: [-∞, ∞]

Default: GAMS cheat

infeasibilityWeight (real): Each integer infeasibility is expected to cost this much

A primitive way of deciding which node to explore next. Satisfying each integer infeasibility is expected to cost this much.

Default: 0

iterlim (integer): Maximum number of iterations before stopping

Synonym: maxIterations

For an LP, this is the maximum number of iterations to solve the LP. For a MIP, this option is ignored.

Default: GAMS iterlim

KKT (boolean): Whether to use KKT factorization in barrier

Default: 0

knapsackCuts (string): Whether to use Knapsack cuts

Value 'on' enables the cut generator and CBC will try it in the branch and cut tree (see cutDepth on how to fine tune the behavior). Value 'root' lets CBC run the cut generator generate only at the root node. Value 'ifmove' lets CBC use the cut generator in the tree if it looks as if it is doing some good and moves the objective value. Value 'forceon' turns on the cut generator and forces CBC to use it at every node. Reference: https://github.com/coin-or/Cgl/wiki/CglKnapsackCover

Default: ifmove

Values: forceandglobal, forceon, ifmove, off, on, onglobal, root

lagomoryCuts (string): Whether to use Lagrangean Gomory cuts

This is a gross simplification of 'A Relax-and-Cut Framework for Gomory's Mixed-Integer Cuts' by Matteo Fischetti & Domenico Salvagnin. This simplification just uses original constraints while modifying objective using other cuts. So you don't use messy constraints generated by Gomory etc. A variant is to allow non messy cuts e.g. clique cuts. So 'only' does this while 'clean' also allows integral valued cuts. 'End' is recommended and waits until other cuts have finished before it does a few passes. The length options for gomory cuts are used.

Default: off

Values: bothaswell, bothaswellroot, bothinstead, cleanaswell, cleanaswellroot, cleaninstead, endboth, endclean, endcleanroot, endonly, endonlyroot, off, onlyaswell, onlyaswellroot, onlyinstead, root

latwomirCuts (string): Whether to use Lagrangean TwoMir cuts

This is a Lagrangean relaxation for TwoMir cuts. See lagomoryCuts for description of options.

Default: off

Values: bothaswell, bothinstead, cleanaswell, cleaninstead, endboth, endbothroot, endclean, endcleanroot, endonly, endonlyroot, off, onlyaswell, onlyinstead

liftAndProjectCuts (string): Whether to use Lift and Project cuts

These cuts may be expensive to compute. Value 'on' enables the cut generator and CBC will try it in the branch and cut tree (see cutDepth on how to fine tune the behavior). Value 'root' lets CBC run the cut generator generate only at the root node. Value 'ifmove' lets CBC use the cut generator in the tree if it looks as if it is doing some good and moves the objective value. Value 'forceon' turns on the cut generator and forces CBC to use it at every node. Reference: https://github.com/coin-or/Cgl/wiki/CglLandP

Default: off

Values: forceon, ifmove, off, on, root

localTreeSearch (boolean): Whether to use local tree search when a solution is found

The heuristic is from Fischetti and Lodi and is not really a heuristic although it can be used as one (with limited functionality). It is not switched on when heuristics are switched on.

Default: 0

loglevel (integer): amount of output printed by CBC

Default: 1

maxFactor (integer): Maximum number of iterations between refactorizations

If this is left at its default value of 200 then CLP will guess a value to use. CLP may decide to re-factorize earlier for accuracy.

Range: [1, ∞]

Default: 200

maxsol (integer): Maximum number of solutions to save

Synonym: maxSavedSolutions

Maximal number of solutions to store during search and to dump into gdx files if dumpsolutions options is set.

Default: 100

mipstart (boolean): whether it should be tried to use the initial variable levels as initial MIP solution

This option controls the use of advanced starting values for mixed integer programs. A setting of 1 indicates that the variable level values should be checked to see if they provide an integer feasible solution before starting optimization.

Default: 0

mirCuts (string): Whether to use Mixed Integer Rounding cuts

Synonym: mixedIntegerRoundingCuts

Value 'on' enables the cut generator and CBC will try it in the branch and cut tree (see cutDepth on how to fine tune the behavior). Value 'root' lets CBC run the cut generator generate only at the root node. Value 'ifmove' lets CBC use the cut generator in the tree if it looks as if it is doing some good and moves the objective value. Value 'forceon' turns on the cut generator and forces CBC to use it at every node. Reference: https://github.com/coin-or/Cgl/wiki/CglMixedIntegerRounding2

Default: ifmove

Values: forceon, ifmove, off, on, onglobal, root

multipleRootPasses (integer): Do multiple root passes to collect cuts and solutions

Solve (in parallel, if enabled) the root phase this number of times, each with its own different seed, and collect all solutions and cuts generated. The actual format is aabbcc where aa is the number of extra passes; if bb is non zero, then it is number of threads to use (otherwise uses threads setting); and cc is the number of times to do root phase. The solvers do not interact with each other. However if extra passes are specified then cuts are collected and used in later passes - so there is interaction there. Some parts of this implementation have their origin in idea of Andrea Lodi, Matteo Fischetti, Michele Monaci, Domenico Salvagnin, and Andrea Tramontani.

Default: 0

naiveHeuristics (string): Whether to try some stupid heuristic

This is naive heuristics which, e.g., fix all integers with costs to zero!. Value 'on' means to use the heuristic in each node of the tree, i.e. after preprocessing. Value 'before' means use the heuristic only if option doHeuristics is used. Value 'both' means to use the heuristic if option doHeuristics is used and during solve.

Default: off

valuemeaning
0 Same as off. This is a deprecated setting.
1 Same as on. This is a deprecated setting.
before
both
off
on

nodeStrategy (string): What strategy to use to select the next node from the branch and cut tree

Normally before a feasible solution is found, CBC will choose a node with fewest infeasibilities. Alternatively, one may choose tree-depth as the criterion. This requires the minimal amount of memory, but may take a long time to find the best solution. Additionally, one may specify whether up or down branches must be selected first (the up-down choice will carry on after a first solution has been bound). The default choice 'hybrid' does breadth first on small depth nodes and then switches to 'fewest'.

Default: fewest

Values: depth, downdepth, downfewest, fewest, hybrid, updepth, upfewest

nodlim (integer): node limit

Synonyms: maxNodes nodelim

Maximum number of nodes that are enumerated in the Branch and Bound tree search.

Range: [-1, ∞]

Default: GAMS nodlim

optca (real): Stop when gap between best possible and best less than this

Synonym: allowableGap

If the gap between best known solution and the best possible solution is less than this value, then the search will be terminated. Also see ratioGap.

Default: GAMS optca

optcr (real): Stop when gap between best possible and best known is less than this fraction of larger of two

Synonym: ratioGap

If the gap between the best known solution and the 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.

Default: GAMS optcr

OrbitalBranching (string): Whether to try orbital branching

This switches on Orbital branching. Value 'on' just adds orbital, 'strong' tries extra fixing in strong branching.

Default: off

Values: force, off, on, simple, strong

parallelmode (string): whether to run opportunistic or deterministic

Determines whether a parallel MIP search (threads > 1) should be done in a deterministic (i.e., reproducible) way or in a possibly faster but not necessarily reproducible way

Default: deterministic

Values: deterministic, opportunistic

passPresolve (integer): How many passes in presolve

Normally Presolve does 10 passes but you may want to do less to make it more lightweight or do more if improvements are still being made. As Presolve will return if nothing is being taken out, you should not normally need to use this fine tuning.

Range: [-200, 100]

Default: 5

perturbation (boolean): Whether to perturb the problem

Perturbation helps to stop cycling, but CLP uses other measures for this. However, large problems and especially ones with unit elements and unit right hand sides or costs benefit from perturbation. Normally CLP tries to be intelligent, but one can switch this off.

Default: 1

pivotAndComplement (string): Whether to try Pivot and Complement heuristic

Value 'on' means to use the heuristic in each node of the tree, i.e. after preprocessing. Value 'before' means use the heuristic only if option doHeuristics is used. Value 'both' means to use the heuristic if option doHeuristics is used and during solve.

Default: off

Values: before, both, off, on

pivotAndFix (string): Whether to try Pivot and Fix heuristic

Value 'on' means to use the heuristic in each node of the tree, i.e. after preprocessing. Value 'before' means use the heuristic only if option doHeuristics is used. Value 'both' means to use the heuristic if option doHeuristics is used and during solve.

Default: off

valuemeaning
0 Same as off. This is a deprecated setting.
1 Same as on. This is a deprecated setting.
before
both
off
on

preprocess (string): Whether to use integer preprocessing

This tries to reduce size of model in a similar way to presolve and it also variables. tries to strengthen the model - this can be very useful and is worth trying. Value 'save' saves the presolved problem to a file presolved.mps. Value 'equal' will turn inequality-cliques into equalities. Value 'sos' lets CBC search for rows with upper bound 1 and where all nonzero coefficients are 1 and creates special ordered sets if the sets are not overlapping and all integer variables (except for at most one) are in the sets. Value 'trysos' is same as 'sos', but allows any number of integer variables outside of sets. Value 'equalall' lets CBC turn all valid inequalities into equalities by adding integer slack

Default: sos

Values: aggregate, equal, equalall, forcesos, off, on, save, sos, stopaftersaving, strategy, trysos

presolve (string): Whether to presolve problem

Presolve analyzes the model to find such things as redundant equations, equations which fix some variables, equations which can be transformed into bounds, etc. For the initial solve of any problem this is worth doing unless one knows that it will have no effect. Option 'on' will normally do 5 passes, while using 'more' will do 10.

Default: on

valuemeaning
0 Same as off. This is a deprecated setting.
1 Same as on. This is a deprecated setting.
more
off
on

primalPivot (string): Primal pivot choice algorithm

The Dantzig method is simple 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. The PE variants add the Positive Edge criterion. This selects incoming variables to try to avoid degenerate moves. See also Towhidi, M., Desrosiers, J., Soumis, F., The positive edge criterion within COIN-OR's CLP; Omer, J., Towhidi, M., Soumis, F., The positive edge pricing rule for the dual simplex.

Default: automatic

valuemeaning
auto Same as automatic. This is a deprecated setting.
automatic
change
dantzig
exact
partial
pedantzig
pesteepest
sprint
steepest

primalWeight (real): Initially algorithm acts as if it costs this much to be infeasible

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 value means the algorithm may iterate into the wrong directory for long and then has to increase the weight in order to get feasible.

Range: [1e-20, ∞]

Default: 1e+10

printfrequency (integer): frequency of status prints

Controls the number of nodes that are evaluated between status prints.

Default: 0

probingCuts (string): Whether to use Probing cuts

Value 'on' enables the cut generator and CBC will try it in the branch and cut 'forceonbutstrong' is like 'forceonstrong', but does only probing (column tree (see cutDepth on how to fine tune the behavior). Value 'root' lets CBC run the cut generator generate only at the root node. Value 'ifmove' lets CBC use the cut generator in the tree if it looks as if it is doing some good and moves the objective value. Value 'forceon' turns on the cut generator and forces CBC to use it at every node. Value 'forceOnBut' turns on probing and forces CBC to do probing at every node, but does only probing, not strengthening etc. Value 'strong' forces CBC to strongly do probing at every node, that is, also when CBC would usually turn it off because it hasn't found something. Value

Default: ifmove

Values: forceon, forceonbut, forceonbutstrong, forceonglobal, forceonstrong, ifmove, off, on, onglobal, root, strongroot

proximitySearch (string): Whether to do proximity search heuristic

This heuristic looks for a solution close to the incumbent solution (Fischetti heuristic only if option doHeuristics is used. Value 'both' means to use the and Monaci, 2012). The idea is to define a sub-MIP without additional constraints but with a modified objective function intended to attract the search in the proximity of the incumbent. The approach works well for 0-1 MIPs whose solution landscape is not too irregular (meaning the there is reasonable probability of finding an improved solution by flipping a small number of binary variables), in particular when it is applied to the first heuristic solutions found at the root node. Value 'on' means to use the heuristic in each node of the tree, i.e. after preprocessing. Value 'before' means use the

Default: off

valuemeaning
0 Same as off. This is a deprecated setting.
1 Same as on. This is a deprecated setting.
10
100
300
before
both
off
on

psi (real): Two-dimension pricing factor for Positive Edge criterion

The Positive Edge criterion has been added to select incoming variables to try Soumis, F., The positive edge criterion within COIN-OR's CLP; Omer, J., and avoid degenerate moves. Variables not in the promising set have their infeasibility weight multiplied by psi, so 0.01 would mean that if there were any promising variables, then they would always be chosen, while 1.0 effectively switches the algorithm off. There are two ways of switching this feature on. One way is to set psi to a positive value and then the Positive Edge criterion will be used for both primal and dual simplex. The other way is to select PEsteepest in dualpivot choice (for example), then the absolute value of psi is used. Code donated by Jeremy Omer. See Towhidi, M., Desrosiers, J.,

Range: [-1.1, 1.1]

Default: -0.5

randomizedRounding (string): Whether to try randomized rounding heuristic

Value 'on' means to use the heuristic in each node of the tree, i.e. after preprocessing. Value 'before' means use the heuristic only if option doHeuristics is used. Value 'both' means to use the heuristic if option doHeuristics is used and during solve.

Default: off

valuemeaning
0 Same as off. This is a deprecated setting.
1 Same as on. This is a deprecated setting.
before
both
off
on

randomSeedCbc (integer): Random seed for Cbc

Synonym: randomCbcSeed

Allows initialization of the random seed for pseudo-random numbers used in heuristics such as the Feasibility Pump to decide whether to round up or down. The special value of 0 lets Cbc use the time of the day for the initial seed.

Range: [-1, ∞]

Default: -1

randomSeedClp (integer): Random seed for Clp

Synonym: randomSeed

Initialization of the random seed for pseudo-random numbers used to break ties in degenerate problems. This may yield a different continuous optimum and, in the context of Cbc, different cuts and heuristic solutions. The special value of 0 lets CLP use the time of the day for the initial seed.

Default: 1234567

reduceAndSplitCuts (string): Whether to use Reduce-and-Split cuts

These cuts may be expensive to generate. Value 'on' enables the cut generator and CBC will try it in the branch and cut tree (see cutDepth on how to fine tune the behavior). Value 'root' lets CBC run the cut generator generate only at the root node. Value 'ifmove' lets CBC use the cut generator in the tree if it looks as if it is doing some good and moves the objective value. Value 'forceon' turns on the cut generator and forces CBC to use it at every node. Reference: https://github.com/coin-or/Cgl/wiki/CglRedSplit

Default: off

Values: forceon, ifmove, off, on, root

reduceAndSplitCuts2 (string): Whether to use Reduce-and-Split cuts - style 2

Synonym: reduce2AndSplitCuts

This switches on reduce and split cuts (either at root or in entire tree). This version is by Giacomo Nannicini based on Francois Margot's version. Standard setting only uses rows in tableau ≤ 256, long uses all. These cuts may be expensive to generate. See option cuts for more information on the possible values.

Default: off

Values: longon, longroot, off, on, root

Rens (string): Whether to try Relaxation Enforced Neighborhood Search

Value 'on' means to use the heuristic in each node of the tree, i.e. after preprocessing. Value 'before' means use the heuristic only if option doHeuristics is used. Value 'both' means to use the heuristic if option doHeuristics is used and during solve. Value 'on' just does 50 nodes. 200, 1000, and 10000 does that many nodes.

Default: off

valuemeaning
0 Same as off. This is a deprecated setting.
1 Same as on. This is a deprecated setting.
1000
10000
200
before
both
dj
djbefore
off
on
usesolution

residualCapacityCuts (string): Whether to use Residual Capacity cuts

Value 'on' enables the cut generator and CBC will try it in the branch and cut tree (see cutDepth on how to fine tune the behavior). Value 'root' lets CBC run the cut generator generate only at the root node. Value 'ifmove' lets CBC use the cut generator in the tree if it looks as if it is doing some good and moves the objective value. Value 'forceon' turns on the cut generator and forces CBC to use it at every node. Reference: https://github.com/coin-or/Cgl/wiki/CglResidualCapacity

Default: off

Values: forceon, ifmove, off, on, root

reslim (real): maximum seconds

Synonym: seconds

Range: [-1, ∞]

Default: GAMS reslim

Rins (string): Whether to try Relaxed Induced Neighborhood Search

Value 'on' means to use the heuristic in each node of the tree, i.e. after preprocessing. Value 'before' means use the heuristic only if option doHeuristics is used. Value 'both' means to use the heuristic if option doHeuristics is used and during solve.

Default: off

valuemeaning
0 Same as off. This is a deprecated setting.
1 Same as on. This is a deprecated setting.
before
both
off
often
on

roundingHeuristic (string): Whether to use simple (but effective) Rounding heuristic

Value 'on' means to use the heuristic in each node of the tree, i.e. after preprocessing. Value 'before' means use the heuristic only if option doHeuristics is used. Value 'both' means to use the heuristic if option doHeuristics is used and during solve.

Default: on

valuemeaning
0 Same as off. This is a deprecated setting.
1 Same as on. This is a deprecated setting.
before
both
off
on

scaling (string): Whether to scale problem

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 the solution is evaluated in the unscaled problem, it is possible that small primal and/or dual infeasibilities occur. Option 'equilibrium' uses the largest element for scaling. Option 'geometric' uses the squareroot of the product of largest and smallest element. Option 'auto' let CLP choose a method that gives the best ratio of the largest element to the smallest one.

Default: automatic

valuemeaning
auto Same as automatic. This is a deprecated setting.
automatic
dynamic
equilibrium
geometric
off
rowsonly

smallFactorization (integer): Threshold for using small factorization

If processed problem ≤ this use small factorization

Range: [-1, 10000]

Default: -1

sollim (integer): Maximum number of feasible solutions to get

Synonym: maxSolutions

Range: [1, ∞]

Default: maxint

solvefinal (boolean): final solve of MIP with fixed discrete variables

Whether the MIP with discrete variables fixed to solution values should be solved after CBC finished.

Default: 1

solvetrace (string): name of trace file for solving information

Name of file for writing solving progress information during solve.

solvetracenodefreq (integer): frequency in number of nodes for writing to solve trace file

Default: 100

solvetracetimefreq (real): frequency in seconds for writing to solve trace file

Default: 5

sosPrioritize (string): How to deal with SOS priorities

This sets priorities for SOS. Values 'high' and 'low' just set a priority relative to the for integer variables. Value 'orderhigh' gives first highest priority to the first SOS and integer variables a low priority. Value 'orderlow' gives integer variables a high priority then SOS in order.

Default: off

Values: high, low, off, orderhigh, orderlow

sparseFactor (boolean): Whether factorization treated as sparse

Default: 1

special (string): options passed unseen to CBC

This parameter let you specify CBC options which are not supported by the GAMS/CBC interface. The string value given to this parameter is split up into parts at each space and added to the array of parameters given to CBC (in front of the -solve command). Hence, you can use it like the command line parameters for the CBC standalone version.

sprintCrash (integer): Whether to try sprint crash

Synonym: sifting

For long and thin problems this method may solve a series of small problems created by taking a subset of the columns. The idea as 'Sprint' was introduced by J. Forrest after an LP code of that name of the 60's which tried the same tactic (not totally successfully). CPLEX calls it 'sifting'. -1 lets CLP automatically choose the number of passes, 0 is off, n is number of passes

Range: [-1, ∞]

Default: -1

startalg (string): LP solver for root node

Determines the algorithm to use for an LP or the initial LP relaxation if the problem is a MIP.

Default: dual

valuemeaning
barrier Primal-dual predictor-corrector algorithm
dual Dual Simplex algorithm
primal Primal Simplex algorithm

strategy (integer): Switches on groups of features

This turns on newer features. Use 0 for easy problems, 1 is default, 2 is aggressive. 1 uses Gomory cuts with a tolerance of 0.01 at the root node, does a possible restart after 100 nodes if many variables could be fixed, activates a diving and RINS heuristic, and makes the feasibility pump more aggressive.

Range: [0, 2]

Default: 1

strongBranching (integer): Number of variables to look at in strong branching

In order to decide which variable to branch on, the code will choose up to this number of unsatisfied variables to try minimal 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 also option trustPseudoCosts.

Default: 5

substitution (integer): How long a column to substitute for in presolve

Normally Presolve gets rid of 'free' variables when there are no more than 3 coefficients in a row. If you increase this, the number of rows may decrease but the number of coefficients may increase.

Range: [0, 10000]

Default: 3

threads (integer): Number of threads to try and use

Range: [1, 99]

Default: GAMS threads

tol_dual (real): For an optimal solution no dual infeasibility may exceed this value

Synonym: dualTolerance

Normally the default tolerance is fine, but one may want to increase it a bit if the dual simplex algorithm 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 the dual simplex algorithm and then to clean up the problem using the primal simplex algorithm with the correct tolerance (remembering to switch off presolve for this final short clean up phase).

Range: [1e-20, ∞]

Default: 1e-07

tol_integer (real): For a feasible solution no integer variable may be more than this away from an integer value

Synonym: integerTolerance

Beware of setting this smaller than the primal feasibility tolerance.

Range: [1e-20, 0.5]

Default: 1e-07

tol_presolve (real): Tolerance to use in presolve

Synonym: preTolerance

One may want to increase this tolerance if presolve says the problem is infeasible and one has awkward numbers and is sure that the problem is really feasible.

Range: [1e-20, ∞]

Default: 1e-08

tol_primal (real): For a feasible solution no primal infeasibility, i.e., constraint violation, may exceed this value

Synonym: primalTolerance

Normally the default tolerance is fine, but one may want to increase it a bit if the primal simplex algorithm seems to be having a hard time.

Range: [1e-20, ∞]

Default: 1e-07

trustPseudoCosts (integer): Number of branches before we trust pseudocosts

Using strong branching computes pseudo-costs. This parameter determines after how many branches for a variable we just trust the pseudo costs and do not do any more strong branching.

Range: [-3, ∞]

Default: 10

twoMirCuts (string): Whether to use Two phase Mixed Integer Rounding cuts

Value 'on' enables the cut generator and CBC will try it in the branch and cut tree (see cutDepth on how to fine tune the behavior). Value 'root' lets CBC run the cut generator generate only at the root node. Value 'ifmove' lets CBC use the cut generator in the tree if it looks as if it is doing some good and moves the objective value. Value 'forceon' turns on the cut generator and forces CBC to use it at every node. Reference: https://github.com/coin-or/Cgl/wiki/CglTwomir

Default: root

Values: forceandglobal, forcelongon, forceon, ifmove, off, on, onglobal, root

VndVariableNeighborhoodSearch (string): Whether to try Variable Neighborhood Search

Value 'on' means to use the heuristic in each node of the tree, i.e. after preprocessing. Value 'before' means use the heuristic only if option doHeuristics is used. Value 'both' means to use the heuristic if option doHeuristics is used and during solve.

Default: off

Values: before, both, intree, off, on

vubheuristic (integer): Type of VUB heuristic

This heuristic tries and fix some integer variables.

Range: [-2, 20]

Default: -1

writemps (string): create MPS file for problem

Write the problem formulation in MPS format. The parameter value is the name of the MPS file.

zeroHalfCuts (string): Whether to use zero half cuts

Value 'on' enables the cut generator and CBC will try it in the branch and cut tree (see cutDepth on how to fine tune the behavior). Value 'root' lets CBC run the cut generator generate only at the root node. Value 'ifmove' lets CBC use the cut generator in the tree if it looks as if it is doing some good and moves the objective value. Value 'forceon' turns on the cut generator and forces CBC to use it at every node. This implementation was written by Alberto Caprara.

Default: ifmove

Values: forceon, ifmove, off, on, onglobal, root