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 resource limit GAMS reslim
special options passed unseen to CBC
writemps create MPS file for problem

## LP Options

Option Description Default
crash use crash method to get dual feasible off
crossover crossover to simplex algorithm after barrier 1
dualpivot dual pivot choice algorithm auto
idiotcrash idiot crash -1
iterlim iteration limit GAMS iterlim
maxfactor maximum number of iterations between refactorizations 200
passpresolve how many passes to do in presolve 5
perturbation perturbation of problem 1
presolve switch for initial presolve of LP 1
primalpivot primal pivot choice algorithm auto
randomseedclp random seed for CLP -1
scaling scaling method auto
sprintcrash sprint crash -1
startalg LP solver for root node dual
tol_dual dual feasibility tolerance 1e-7
tol_presolve tolerance used in presolve 1e-8
tol_primal primal feasibility tolerance 1e-7

## MIP Options

Option Description Default
coststrategy how to use costs as priorities off
cutoff cutoff for objective function value GAMS cutoff
cutoffconstraint whether to add a constraint from the objective function 0
dumpsolutions name of solutions index gdx file for writing alternate solutions
dumpsolutionsmerged name of gdx file for writing all alternate solutions
extravariables group together variables with same cost 0
increment increment of cutoff when new incumbent GAMS cheat
loglevel CBC loglevel 1
maxsol maximal number of solutions to store during search 100
mipstart whether it should be tried to use the initial variable levels as initial MIP solution 0
multiplerootpasses runs multiple copies of the solver at the root node 0
nodelim node limit GAMS nodlim
nodestrategy how to select nodes fewest
nodlim node limit GAMS nodlim
optca absolute stopping tolerance GAMS optca
optcr relative stopping tolerance GAMS optcr
parallelmode whether to run opportunistic or deterministic deterministic
preprocess integer presolve on
printfrequency frequency of status prints 0
randomseedcbc random seed for CBC -1
sollim limit on number of solutions -1
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
strategy switches on groups of features 1
strongbranching strong branching 5
threads number of threads to use GAMS threads
tol_integer tolerance for integrality 1e-6
trustpseudocosts after howmany nodes we trust the pseudo costs 5

## MIP Options for Cutting Plane Generators

Option Description Default
cliquecuts Clique Cuts ifmove
conflictcuts Conflict Cuts 0
cutdepth depth in tree at which cuts are applied -1
cuts global switch for cutgenerators on
cut_passes_root number of cut passes at root node 20 or 100
cut_passes_slow number of cut passes for slow cut generators 10
cut_passes_tree number of cut passes at nodes in the tree 1
flowcovercuts Flow Cover Cuts ifmove
gomorycuts Gomory Cuts ifmove
gomorycuts2 Gomory Cuts 2nd implementation off
knapsackcuts Knapsack Cover Cuts ifmove
liftandprojectcuts Lift and Project Cuts off
mircuts Mixed Integer Rounding Cuts ifmove
probingcuts Probing Cuts ifmove
reduceandsplitcuts Reduce and Split Cuts off
reduceandsplitcuts2 Reduce and Split Cuts 2nd implementation off
residualcapacitycuts Residual Capacity Cuts off
twomircuts Two Phase Mixed Integer Rounding Cuts root
zerohalfcuts Zero-Half Cuts ifmove

## MIP Options for Heuristics

Option Description Default
combinesolutions combine solutions heuristic 1
dins distance induced neighborhood search 0
divingcoefficient coefficient diving heuristic 1
divingfractional fractional diving heuristic 0
divingguided guided diving heuristic 0
divinglinesearch line search diving heuristic 0
divingpseudocost pseudo cost diving heuristic 0
divingrandom turns on random diving heuristic 0
divingvectorlength vector length diving heuristic 0
feaspump feasibility pump 1
feaspump_passes number of feasibility passes 20
greedyheuristic greedy heuristic on
heuristics global switch for heuristics 1
localtreesearch local tree search heuristic 0
naiveheuristics naive heuristics 0
pivotandfix pivot and fix heuristic 0
proximitysearch proximity search heuristic 0
randomizedrounding randomized rounding heuristis 0
rens relaxation enforced neighborhood search 0
rins relaxed induced neighborhood search 0
roundingheuristic rounding heuristic 1
vubheuristic VUB heuristic

# Detailed Options Description

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

cliquecuts (string): Clique Cuts

Determines whether and when CBC should try to generate clique cuts. See cuts for an explanation on the different values. Clique cuts are of the form "sum of a set of variables <= 1". Reference: M. Eso, Parallel branch and cut for set partitioning, Cornell University, 1999.

Default: ifmove

clocktype (string): type of clock for time measurement

Default: wall

valuemeaning
cpu
wall

combinesolutions (boolean): combine solutions heuristic

This parameter control the use of a heuristic which does branch and cut on the given problem by just using variables which have appeared in one or more solutions. It is obviously only tried after two or more solutions.

Default: 1

valuemeaning
0 Turns the combine solutions heuristic off.
1 Turns the combine solutions heuristic on.

conflictcuts (boolean): Conflict Cuts

Default: 0

coststrategy (string): how to use costs as priorities

This parameter influence the branching variable selection. If turned on, then the variables are sorted in order of their absolute costs, and branching is done first on variables with largest cost. This primitive strategy can be surprisingly effective.

Default: off

valuemeaning
off Turns off a specific cost strategy.
priorities Assigns highest priority to variables with largest absolute cost.
columnorder Assigns the priorities 1, 2, 3,.. with respect to the column ordering.
binaryfirst Handles two sets of priorities such that binary variables get high priority.
binarylast Handles two sets of priorities such that binary variables get low priority.
length Assigns high priority to variables that are at most nonzero.

crash (string): use crash method to get dual feasible

Determines whether CLP should use a crash algorithm to find a dual feasible basis.

Default: off

valuemeaning
off Switch off the creation of dual feasible basis by the crash method.
on Switch on the creation of dual feasible basis by the crash method.
solow_halim Switch on a crash variant due to Solow and Halim.
halim_solow Switch on a crash variant due to Solow and Halim with modifications of John J. Forrest.

crossover (boolean): crossover to simplex algorithm after barrier

Determines whether CLP should crossover to 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: 1

valuemeaning
0 Turn off crossover to simplex algorithm after barrier algorithm finished.
1 Turn on crossover to simplex algorithm after barrier algorithm finished.

cutdepth (integer): depth in tree at which cuts are applied

If the depth in the tree is a multiple of cutdepth, then cut generators are applied. Cut generators may be off, on only at the root, on if they look useful, or on at some interval. 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.

Default: -1

valuemeaning
-1 Does not turn on cut generators because the depth of the tree is a multiple of a value.

cutoff (real): cutoff for objective function value

CBC stops if the objective function values exceeds (in case of maximization) or falls below (in case of minimization) this value.

Range: [-∞, ∞]

Default: GAMS cutoff

cutoffconstraint (boolean): whether to add a constraint from the objective function

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 set, 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: 0

valuemeaning
0 do not add extra constraint
1 add extra constraint

cuts (string): global switch for cutgenerators

A global switch to turn on or off the cutgenerators. This can be used to switch on or off all default cut generators. Then you can set individual ones off or on using the specific options.

Default: on

valuemeaning
off Turns off all cut generators.
on Turns on all default cut generators and CBC will try them in the branch and cut tree (see cutdepth on how to fine tune the behavior).
root Let CBC generate cuts only at the root node.
ifmove Let CBC use cut generators in the tree if they look as if they are doing some good and moving the objective value.
forceon Turns on all default cut generators and force CBC to use the cut generator at every node.

cut_passes_root (integer): number of cut passes at root node

Determines the number of rounds that the cut generators are applied in the root node. A negative value -n means that n passes are also applied if the objective does not drop. The default is to do 100 passes if the MIP has less than 500 columns, 100 passes (but stop if the drop in the objective function value is small) if it has less than 5000 columns, and 20 passes otherwise.

cut_passes_tree Determines the number of rounds that the cut generators are applied in the nodes of the tree other than the root node. A negative value -n means that n passes are also applied if the objective does not drop.

Range: [-9999999, 9999999]

Default: 20 or 100

cut_passes_slow (integer): number of cut passes for slow cut generators

Determines the number of rounds that slow cut generators should be applied. The idea is that the code does these cuts just a few times - less than the more usual cuts. The cut generators identified by "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 cut passes at nodes in the tree

Range: [-9999999, 9999999]

Default: 1

dins (boolean): distance induced neighborhood search

This parameter control the use of the distance induced neighborhood search heuristic.

Default: 0

valuemeaning
0 Turns the distance induced neighborhood search off.
1 Turns the distance induced neighborhood search on.

divingcoefficient (boolean): coefficient diving heuristic

This switches on the coefficient diving heuristic.

Default: 1

valuemeaning
0 Turns the coefficient diving heuristics off.
1 Turns the coefficient diving heuristics on.

divingfractional (boolean): fractional diving heuristic

This switches on the fractional diving heuristic.

Default: 0

valuemeaning
0 Turns the fractional diving heuristics off.
1 Turns the fractional diving heuristics on.

divingguided (boolean): guided diving heuristic

This switches on the guided diving heuristic.

Default: 0

valuemeaning
0 Turns the guided diving heuristics off.
1 Turns the guided diving heuristics on.

divinglinesearch (boolean): line search diving heuristic

This switches on the line search diving heuristic.

Default: 0

valuemeaning
0 Turns the line search diving heuristics off.
1 Turns the linesearch diving heuristics on.

divingpseudocost (boolean): pseudo cost diving heuristic

This switches on the pseudo costs diving heuristic.

Default: 0

valuemeaning
0 Turns the pseudo costs diving heuristics off.
1 Turns the pseudo costs diving heuristics on.

divingrandom (boolean): turns on random diving heuristic

This switches on a random diving heuristic at various times.

Default: 0

valuemeaning
0 Turns the random diving heuristics off.
1 Turns the random diving heuristics on.

divingvectorlength (boolean): vector length diving heuristic

This switches on the vector length diving heuristic.

Default: 0

valuemeaning
0 Turns the vector length diving heuristics off.
1 Turns the vector length diving heuristics on.

dualpivot (string): dual pivot choice algorithm

Choice of the pivoting strategy in the dual simplex algorithm.

Default: auto

valuemeaning
auto Let CLP use a variant of the steepest choice method which starts like partial, i.e., scans only a subset of the primal infeasibilities, and later changes to full pricing when the factorization becomes denser.
dantzig Let CLP use the pivoting strategy due to Dantzig.
steepest Let CLP use the steepest choice method.
partial Let CLP use a variant of the steepest choice method which scans only a subset of the primal infeasibilities to select the pivot step.

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

extravariables (integer): group together variables with same cost

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

Default: 0

feaspump (boolean): feasibility pump

This parameter control the use of the feasibility pump heuristic at the 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 feaspump_passes. Reference: M. Fischetti, F. Glover, and A. Lodi, The feasibility pump, Math. Programming, 104 (2005), pp. 91-104.

Default: 1

valuemeaning
0 Turns the feasibility pump off.
1 Turns the feasibility pump on.

feaspump_passes (integer): number of feasibility passes

This fine tunes the feasibility pump heuristic by setting the number of passes.

Range: [0, 10000]

Default: 20

flowcovercuts (string): Flow Cover Cuts

Determines whether and when CBC should try to generate flow cover cuts. See cuts for an explanation on the different values. The flow cover cut generator generates lifted simple generalized flow cover inequalities. Since flow cover inequalities are generally not facet-defining, they are lifted to obtain stronger inequalities. Although flow cover inequalities requires a special problem structure to be generated, they are quite useful for solving general mixed integer linear programs. Reference: Z. Gu, G.L. Nemhauser, M.W.P. Savelsbergh, Lifted flow cover inequalities for mixed 0-1 integer programs, Math. Programming A 85 (1999) 439-467.

Default: ifmove

gomorycuts (string): Gomory Cuts

Determines whether and when CBC should try to generate mixed-integer Gomory cuts. See cuts for an explanation on the different values. Reference: Laurence A. Wolsey, Integer Programming, Wiley, John & Sons, (1998) 124-132.

Default: ifmove

gomorycuts2 (string): Gomory Cuts 2nd implementation

Determines whether and when CBC should try to generate mixed-integer Gomory cuts using the alternative robust implementation. Reference: G. Cornuejols, F. Margot, and G. Nannicini, On the safety of Gomory cut generators, submitted (2012)

Default: off

valuemeaning
off Turns off the cut generators.
on Turns on the cut generator and CBC will try it in the branch and cut tree (see cutdepth on how to fine tune the behavior).
root Let CBC generate gomory cuts only at the root node.
ifmove Let CBC use this cut generator in the tree if it looks as if it is doing some good and moves the objective value.
forceon Turns on the cut generator and forces CBC to use it at every node.
longroot
endonly
long
longifmove
forcelongon
longendonly

greedyheuristic (string): greedy heuristic

This parameter control the use of a pair of greedy heuristic which will try to obtain a solution. It may just fix a percentage of variables and then try a small branch and cut run.

Default: on

valuemeaning
off Turns off the greedy heuristic.
on Turns on the greedy heuristic.
root Turns on the greedy heuristic only for the root node.

heuristics (boolean): global switch for heuristics

This parameter can be used to switch on or off all heuristics, except for the local tree search as it dramatically alters the search. Then you can set individual ones off or on.

Default: 1

valuemeaning
0 Turns all MIP heuristics off.
1 Turns all MIP heuristics on (except local tree search).

idiotcrash (integer): idiot crash

This is a type of crash' which works well on some homogeneous problems. It works best on problems with unit elements and right hand sides but will do something to any model. It should only be used before the primal simplex algorithm. A positive number determines the number of passes that idiotcrash is called.

Default: -1

valuemeaning
-1 Let CLP decide by itself whether to use it.
0 Switch this method off.

increment (real): increment of cutoff when new incumbent

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.

Default: GAMS cheat

iterlim (integer): iteration limit

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

Default: GAMS iterlim

knapsackcuts (string): Knapsack Cover Cuts

Determines whether and when CBC should try to generate knapsack cover cuts. See cuts for an explanation on the different values. The knapsack cover cut generator looks for a series of different types of minimal covers. If a minimal cover is found, it lifts the associated minimal cover inequality and adds the lifted cut to the cut set. Reference: S. Martello, and P. Toth, Knapsack Problems, Wiley, 1990, p30.

Default: ifmove

liftandprojectcuts (string): Lift and Project Cuts

Determines whether and when CBC should try to generate lift and project cuts. They might be expensive to compute, thus they are switched off by default. See cuts for an explanation on the different values. Reference: E. Balas and M. Perregaard, A precise correspondence between lift-and-project cuts, simple disjunctive cuts, and mixed integer Gomory cuts for 0-1 programming. Math. Program., 94(203,Ser. B):221-245,2003.

Default: off

localtreesearch (boolean): local tree search heuristic

This parameter control the use of a local search algorithm when a solution is found. It is from Fischetti and Lodi and is not really a heuristic although it can be used as one (with limited functionality). This heuristic is not controlled by heuristics. Reference: M. Fischetti and A. Lodi, Local Branching, Math. Programming B, 98 (2003), pp. 23-47.

Default: 0

valuemeaning
0 Turns the local tree search off.
1 Turns the local tree search on.

loglevel (integer): CBC loglevel

Amount of output to print by CBC.

Default: 1

maxfactor (integer): maximum number of iterations between refactorizations

Maximum number of iterations between refactorizations in CLP. If this is left at the default value of 200 then CLP will guess at a value to use. CLP may decide to refactorize earlier for accuracy.

Range: [1, 999999]

Default: 200

maxsol (integer): maximal number of solutions to store during search

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

valuemeaning
0 Do not use the initial variable levels.
1 Try to use the initial variable levels as a MIP starting solution.

mircuts (string): Mixed Integer Rounding Cuts

Determines whether and when CBC should try to generate mixed integer rounding cuts. See cuts for an explanation on the different values. Reference: H. Marchand and L. A. Wolsey, Aggregation and Mixed Integer Rounding to Solve MIPs, Operations Research, 49(3), (2001).

Default: ifmove

multiplerootpasses (integer): runs multiple copies of the solver at the root node

Solves the root node with multiple copies of the solver, each with its own different seed and collects the solutions and cuts so that the main solver has a richer set of solutions and possibly stronger cuts. If threads are enabled, then this is done in parallel (Attention: doing this in parallel is experimental). If the number is below 100, then the option gives the number of times the root is solved. The actual format is aabbcc where aa is number of extra passes, if bb is non zero then it is number of threads to use (otherwise uses threads setting) and cc is 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.

Range: [0, 100000000]

Default: 0

naiveheuristics (boolean): naive heuristics

This parameter controls the use of some naive heuristics, e.g., fixing of all integers with costs to zero.

Default: 0

valuemeaning
0 Turns the naive heuristics off.
1 Turns the naive heuristics on.

nodelim (integer): node limit

Maximum number of nodes that are considered in the Branch and Bound.

Default: GAMS nodlim

nodestrategy (string): how to select nodes

This determines the strategy used to select the next node from the branch and cut tree.

Default: fewest

valuemeaning
hybrid Let CBC do first a breath search on nodes with a small depth in the tree and then switch to choose nodes with fewest infeasibilities.
fewest This will let CBC choose the node with the fewest infeasibilities.
depth This will let CBC always choose the node deepest in tree. It gives minimum tree size but may take a long time to find the best solution.
upfewest This will let CBC choose the node with the fewest infeasibilities and do up branches first.
downfewest This will let CBC choose the node with the fewest infeasibilities and do down branches first.
updepth This will let CBC choose the node deepest in tree and do up branches first.
downdepth This will let CBC choose the node deepest in tree and do down branches first.

nodlim (integer): node limit

Maximum number of nodes that are considered in the Branch and Bound. This option is overwritten by nodelim, if set.

Default: GAMS nodlim

optca (real): absolute stopping tolerance

Absolute optimality criterion for a MIP. CBC stops if the gap between the best known solution and the best possible solution is less than this value.

Default: GAMS optca

optcr (real): relative stopping tolerance

Relative optimality criterion for a MIP. CBC stops if the relative gap between the best known solution and the best possible solution is less than this value.

Default: GAMS optcr

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

valuemeaning
opportunistic
deterministic

passpresolve (integer): how many passes to do in presolve

Normally Presolve does 5 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): perturbation of problem

Determines whether CLP should perturb the problem before starting. 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 you can switch this off.

Default: 1

valuemeaning
0 Turns off perturbation of LP.
1 Turns on perturbation of LP.

pivotandfix (boolean): pivot and fix heuristic

This parameter controls the use of the pivot and fix heuristic.

Default: 0

valuemeaning
0 Turns the naive pivot and fix heuristic off.
1 Turns the naive pivot and fix heuristic on.

preprocess (string): integer presolve

This option controls the MIP specific presolve routines. They try to reduce the size of the model in a similar way to presolve and also try to strengthen the model. This can be very useful and is worth trying.

Default: on

valuemeaning
off Turns off the presolve routines.
on Turns on the presolve routines.
equal Turns on the presolve routines and let CBC turn inequalities with more than 5 elements into equalities (cliques) by adding slack variables.
equalall Turns on the presolve routines and let CBC turn all inequalities into equalities by adding slack variables.
sos This option let 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.
trysos This option is similar to sos, but allows any number integer variables to be outside of the sets.

presolve (boolean): switch for initial presolve of LP

Presolve analyzes the model to find such things as redundant constraints, constraints which fix some variables, constraints which can be transformed into bounds, etc. For the initial solve of any problem this is worth doing unless you know that it will have no effect.

Default: 1

valuemeaning
0 Turns off the initial presolve.
1 Turns on the initial presolve.

primalpivot (string): primal pivot choice algorithm

Choice of the pivoting strategy in the primal simplex algorithm.

Default: auto

valuemeaning
auto Let CLP use a variant of the exact devex method.
dantzig Let CLP use the pivoting strategy due to Dantzig.
steepest Let CLP use the steepest choice method.
partial Let CLP use a variant of the exact devex method which scans only a subset of the primal infeasibilities to select the pivot step.
exact Let CLP use the exact devex method.
change Let CLP initially use Dantzig pivot method until the factorization becomes denser.

printfrequency (integer): frequency of status prints

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

Default: 0

valuemeaning
0 Automatic choice, which is 100 for large problems and 1000 for small problems.

probingcuts (string): Probing Cuts

Determines whether and when CBC should try to generate cuts based on probing. Additional to the values for cuts option three more values are possible here. Reference: M. Savelsbergh, Preprocessing and Probing Techniques for Mixed Integer Programming Problems, ORSA Journal on Computing 6 (1994), 445.

Default: ifmove

valuemeaning
off Turns off Probing.
on Turns on Probing and CBC will try it in the branch and cut tree (see cutdepth how to fine tune this behavior).
root Let CBC do Probing only at the root node.
ifmove Let CBC do Probing in the tree if it looks as if it is doing some good and moves the objective value.
forceon Turns on Probing and forces CBC to do Probing at every node.
forceonbut Turns on Probing and forces CBC to call the cut generator at every node, but does only probing, not strengthening etc.
forceonstrong If CBC is forced to turn Probing on at every node (by setting this option to force), but this generator produces no cuts, then it is actually turned on only weakly (i.e., just every now and then). Setting forceonstrong forces CBC strongly to do probing at every node.
forceonbutstrong This is like forceonstrong, but does only probing (column fixing) and turns off row strengthening, so the matrix will not change inside the branch and bound.

proximitysearch (integer): proximity search heuristic

This parameter controls the use of the "No-Neighborhood Search" 0-1 MIP refinement heuristic proposed by Fischetti 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.

Default: 0

valuemeaning
0 Turns the proximity heuristic off.
1 Turns the proximity heuristic on.

randomizedrounding (boolean): randomized rounding heuristis

This parameter controls the use of the randomized rounding heuristic.

Default: 0

valuemeaning
0 Turns the randomized rounding heuristic off.
1 Turns the randomized rounding heuristic on.

randomseedcbc (integer): random seed for CBC

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

Allows 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.

Range: [-1, ∞]

Default: -1

reduceandsplitcuts (string): Reduce and Split Cuts

Determines whether and when CBC should try to generate reduced and split cuts. See cuts for an explanation on the different values. Reduce and split cuts are variants of Gomory cuts. Starting from the current optimal tableau, linear combinations of the rows of the current optimal simplex tableau are used for generating Gomory cuts. The choice of the linear combinations is driven by the objective of reducing the coefficients of the non basic continuous variables in the resulting row. Reference: K. Anderson, G. Cornuejols, and Yanjun Li, Reduce-and-Split Cuts: Improving the Performance of Mixed Integer Gomory Cuts, Management Science 51 (2005).

Default: off

reduceandsplitcuts2 (string): Reduce and Split Cuts 2nd implementation

Determines whether and when CBC should try to generate reduced and split cuts using the 2nd implementation. Reduce and split cuts are variants of Gomory cuts. Reference: G. Cornuejols and G. Nannicini, Practical strategies for generating rank-1 split cuts in mixed-integer linear programming, Mathematical Programming Computation 3 (2011), 281-318.

Default: off

valuemeaning
off Turns off all cut generators.
on Turns on all default cut generators and CBC will try them in the branch and cut tree (see cutdepth on how to fine tune the behavior).
root Let CBC generate cuts only at the root node.
longon
longroot

rens (boolean): relaxation enforced neighborhood search

This parameter controls the use of the relaxation enforced neighborhood search heuristic.

Default: 0

valuemeaning
0 Turns the relaxation enforced neighborhood search off.
1 Turns the relaxation enforced neighborhood search on.

residualcapacitycuts (string): Residual Capacity Cuts

Determines whether and when CBC should try to generate residual capacity cuts. See cuts for an explanation on the different values. These inequalities are particularly useful for Network Design and Capacity Planning models. References: T.L. Magnanti, P. Mirchandani, and R. Vachani, The convex hull of two core capacitated network design problems, Math. Programming, 60 (1993), pp. 233-250. A. Atamturk and D. Rajan, On splittable and unsplittable flow capacitated network design arc-set polyhedra, Math. Programming, 92 (2002), pp. 315-333.

Default: off

reslim (real): resource limit

Maximum time in seconds.

Default: GAMS reslim

rins (boolean): relaxed induced neighborhood search

This parameter controls the use of the relaxed induced neighborhood search heuristic. This heuristic compares the current solution with the best incumbent, fixes all discrete variables with the same value, presolves the problem, and does a branch and bound for 200 nodes. Reference: E. Danna, E. Rothberg, and C. Le Pape, Exploring relaxation induced neighborhoods to improve MIP solutions, Math. Programming, 102 (1) (2005), pp. 71-91.

Default: 0

valuemeaning
0 Turns the relaxed induced neighborhood search off.
1 Turns the relaxed induced neighborhood search on.

roundingheuristic (boolean): rounding heuristic

This parameter control the use of a simple (but effective) rounding heuristic at each node of tree.

Default: 1

valuemeaning
0 Turns the rounding heuristic off.
1 Turns the rounding heuristic on.

scaling (string): scaling method

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. Both methods do several passes alternating between rows and columns using current scale factors from one and applying them to the other.

Default: auto

valuemeaning
off Turns off scaling.
auto Let CLP choose the scaling method automatically. It decides for one of these methods depending on which gives the better ratio of the largest element to the smallest one.
equilibrium Let CLP use an equilibrium based scaling method which uses the largest scaled element.
geometric Let CLP use a geometric based scaling method which uses the squareroot of the product of largest and smallest element.

sollim (integer): limit on number of solutions

A limit on number of feasible solutions that CBC should find for a MIP.

Default: -1

valuemeaning
-1 No limit on the number of feasible solutions.

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

valuemeaning
0 Turn off the final LP solve.
1 Turn on the final LP solve.

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

frequency in number of nodes for writing solving progress information

Default: 100

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

frequency in seconds for writing solving progress information

Default: 5

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): 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. Cplex calls it sifting'. A positive number determines the number of passes that sprintcrash is called.

Default: -1

valuemeaning
-1 Let CLP decide by itself whether to use it.
0 Switch this method off.

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
primal Let CLP use the primal simplex algorithm.
dual Let CLP use the dual simplex algorithm.
barrier Let CLP use a primal dual predictor corrector algorithm.

strategy (integer): switches on groups of features

Setting strategy to 1 (the default) uses Gomory cuts using tolerance of 0.01 at root, does a possible restart after 100 nodes if Cbc can fix many variables and activates a diving and RINS heuristic and makes feasibility pump more aggressive.

Default: 1

valuemeaning
0 Use this setting for easy problems.
1 This is the default setting.
2 Use this setting for difficult problems.

strongbranching (integer): strong branching

Determines the 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 and try minimal up and down branches. 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 trustpseudocosts.

Range: [0, 999999]

Default: 5

This option controls the multithreading feature of CBC. A number between 1 and 99 sets the number of threads used for parallel branch and bound.

Range: [0, 99]

Default: GAMS threads

tol_dual (real): dual feasibility tolerance

The maximum amount the dual constraints can be violated and still be considered feasible.

Default: 1e-7

tol_integer (real): tolerance for integrality

For an optimal solution, no integer variable may be farther than this from an integer value.

Default: 1e-6

tol_presolve (real): tolerance used in presolve

The tolerance used in presolve.

Default: 1e-8

tol_primal (real): primal feasibility tolerance

The maximum amount the primal constraints can be violated and still be considered feasible.

Default: 1e-7

trustpseudocosts (integer): after howmany nodes we trust the pseudo costs

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: [-1, 2000000]

Default: 5

twomircuts (string): Two Phase Mixed Integer Rounding Cuts

Determines whether and when CBC should try to generate two phase mixed integer rounding cuts. See cuts for an explanation on the different values. Reference: S. Dash, and O. Guenluek, Valid Inequalities Based on Simple Mixed-integer Sets, to appear in Math. Programming.

Default: root

vubheuristic (integer): VUB heuristic

This parameter control the use of the VUB heuristic. If it is set (between -2 and 20), Cbc will try and fix some integer variables.

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): Zero-Half Cuts

Determines whether and when CBC should try to generate zero-half cuts. So far, they may help only on a small subset of problems and may need some tuning. Reference: G. Andreello, A. Caprara, and M. Fischetti, Embedding Cuts in a Branch and Cut Framework: a Computational Study with {0,1/2}-Cuts, INFORMS Journal on Computing 19 (2007), 229-238.

Default: ifmove

valuemeaning
off Turns off the zero half cuts generators.
on Turns on the zero half cuts cut generators and CBC will try it in the branch and cut tree (see cutdepth on how to fine tune the behavior).
root Let CBC generate zero half cuts only at the root node.
ifmove Let CBC use the zero half cuts generator in the tree if it looks as if it is doing some good and moves the objective value.
forceon Turns on the zero half cuts generator and forces CBC to use it at every node.
onglobal