### Table of Contents

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 | `off` |

## 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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `-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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `-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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `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`

value meaning `-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`

value meaning `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`

value meaning `-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`

value meaning `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`

value meaning `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`

**threads** *(integer)*: number of threads to use ↵

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:

`off`

value meaning `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`