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

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

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

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

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

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

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

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

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

Default:

`off`

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

Default:

`off`

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

Default:

`off`

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

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

Default:

`off`

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

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

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

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

Default:

`off`

Values:

`before`

,`both`

,`off`

,`on`

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

Default:

`off`

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

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

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

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

Default:

`off`

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

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

Default:

`off`

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

Default:

`on`

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

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

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

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`