Parameter Reference

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

All solutions must be better than this value (in a minimization sense). This is also set by cbc whenever it obtains a solution and is set to the value of the objective for the solution minus the cutoff increment.

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

This is a repeatable way to limit search. Normally using time is easier but then the results may not be repeatable.

This criterion specifies that when a feasible solution is available, the search should continue only if better feasible solutions were produced in the last nodes.

With this stopping criterion, after a feasible solution is found, the search should continue only if the incumbent solution was updated recently, the tolerance is specified here. A discussion on why this criterion can be useful is included here: https://yetanothermathprogrammingconsultant.blogspot.com/2019/11/mip-solver-stopping-criteria.html .

You may want to stop after (say) two solutions or an hour. This is checked every node in tree, so it is possible to get more solutions from heuristics.

After this many seconds the program will act as if maximum nodes had been reached. You may wish to also set '-check less' which stops cbc checking time quite as often which reduces system time.

After this many seconds clp will act as if maximum iterations had been reached (if value >=0).

This switches on clique cuts (either at root or in entire tree). An improved version of the Bron-Kerbosch algorithm is used to separate cliques.

This can be used to switch on or off all cuts (apart from Reduce and Split). Then you can set individual ones off or on. See branchAndCut for information on options.

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

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.

The original cuts - beware of imitations! Having gone out of favor, they are now more fashionable as LP solvers are more robust and they interact well with other cuts. They will almost always give cuts (although in this executable they are limited as to number of variables in cut). However the cuts may be dense so it is worth experimenting (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 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/CglGomory

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

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.

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

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

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

This switches on odd-wheel inequalities (either at root or in entire tree).

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. Aggregates rows along paths of continuous variables to generate strong multi-row MIR cuts. Particularly effective on network-flow models.

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 'forceonbutstrong' 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.Reference: https://github.com/coin-or/Cgl/wiki/CglProbing

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

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.

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

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

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.

Controls how cuts are ordered when too many are available and a budget or cap limits how many can be applied. violation: rank by LP violation (default; fast, well understood). fitness: rank by the CoinCutPool fitness score: (viol / activeCols) * 1e5 + (1 / (coefSpread + 1)) * 1e3 where activeCols = variables with |x*| > 1e-8, and coefSpread = |maxCoef-minCoef| + |maxCoef-rhs| + |minCoef-rhs|. Favours sparse, numerically balanced cuts. Affects three sites: the global-pool re-scan at the start of each solveWithCuts pass, and the two dive-conflict-cut selection sites (in-tree and at-root).

When on (default), row cuts generated in each cut-generation round are pre-filtered using the CoinCutPool 'best cut per variable' criterion before ranking and insertion into the LP. The filter keeps a cut only if it has the highest fitness score (see -cutRankingMetric) for at least one variable among all cuts generated in the same round. This removes redundant/duplicated cuts while ensuring every active variable retains its best cut. Filtering is applied to row cuts only; column cuts (bound tightenings) are always kept. No filtering occurs when fewer than 2 row cuts are generated in a round.

When -cutPoolFilter is on, the best-per-variable filter is only applied to a cut generation round that produces at least this many row cuts. Rounds with fewer cuts are left unfiltered, avoiding overhead and inadvertent discarding of useful cuts in low-activity rounds. Default 50.

MixedIntegerRounding2 can work on constraints created by aggregating constraints in model. Although the coding for this has been in for some time, it is being modified and the user may wish to play with this. -1 varies the level at various times.

Cut generators may be off, on only at the root, on if they look useful, and on at some interval. If they are done every node then that is that, but it may be worth doing them every so often. The original method was every so many nodes but it is more logical to do it whenever depth in tree is a multiple of K. This option does that and defaults to -1 (off).

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%10000000 - so 10000100 means unlimited length at root and 100 in tree.

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

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.

If nonnegative, ZeroHalf skips any candidate row whose number of fractional variables in the current LP solution exceeds this threshold. Negative values disable the filter.

If nonnegative, ZeroHalf skips any candidate row whose weakening pair count exceeds this threshold. Negative values disable the filter.

If positive, ZeroHalf will use the sparse separation-graph implementation when the number of active separator nodes exceeds this threshold. A value of 0 forces sparse mode for testing. Negative values disable threshold-based switching, but sparse mode is still used automatically when the dense graph would be unsafe.

At the start of each cut-generation pass, MIPster scans the global cut pool and re-injects any cut whose violation against the current LP solution exceeds this threshold. Lower values let more cuts back in (potentially tightening the bound faster at the cost of a larger LP); higher values are more selective (fewer rows added per pass, faster LP solves but possibly slower convergence). Default: 0.005 (the original hard-coded value, a conservative ~50x multiple of the LP primal tolerance ~1e-7). Tighter values (e.g. 1e-3) can help when the tree is large and global cuts from early root passes are almost-satisfied.

Controls the maximum number of non-zeros that cut rows may add to the LP in each cut-generation round. The budget is: budget = factor × max(currentNZ/10, 2×ncols + 100) where currentNZ is the LP non-zero count and ncols is the column count at the start of the round. The budget is applied in two stages: 1. Global stored cuts are added first (best-scoring first) until the budget is exhausted. If global cuts alone fill the budget, cut generators are skipped for this round. 2. Generator cuts (after the optional pool filter) are scored by the active ranking metric (-cutRankingMetric), sorted best-first, and added greedily until the remaining budget is consumed. Set to -1 to disable the limit (original behaviour); default is 4.0. A factor of 1.0 uses the same formula as the global-cut injection budget, but now also trims generator cuts (which were previously uncapped). Values < 1.0 are more aggressive; values > 1.0 are more permissive.

The default is 100 passes if less than 500 columns, 100 passes (but stop if the drop is small) if less than 5000 columns, 20 otherwise.

Normally the preprocessed model has column names replaced by new names C0000... Setting this option to on keeps original names in variables which still exist in the preprocessed problem

Normally if AMPL says there are SOS variables they should be used, but sometimes they should be turned off - this does so.

When on, prints per-pass diagnostics during CglPreProcess: problem dimensions (rows, cols, integers, NZ) at the start of each major pass; probing settings (maxProbe, maxPass, maxLook, maxElements) and per-generator wall-clock time with cut pool statistics (total/avg/max NZ per cut); LP solve timing and iteration counts for initialSolve, resolve-after-cuts, and resolve-after-row-drop with LP objective value and basis infeasibility counts. Useful for diagnosing slow preprocessing on instances where LP re-optimisation dominates.

When on, applies a GF(2) parity-based presolve pass (parity_action) that identifies linear dependencies modulo 2 among binary variables and uses them to fix or substitute variables. The pass runs in two places: (1) inside OsiPresolve during MIP preprocessing (CglPreProcess), and (2) inside ClpPresolve when ClpPresolve is invoked with integer variables (e.g. during the DW-heuristic integerPresolve pass). Setting 'off' disables both. Disable to investigate correctness issues or to skip on instances where this pass is slow or incorrect.

This tries to reduce size of the model in a similar way to presolve and it also tries to strengthen the model. This can be very useful and is worth trying. save option saves on file presolved.mps. equal will turn <= cliques into ==. sos will create sos sets if all 0-1 in sets (well one extra is allowed) and no overlaps. trysos is same but allows any number extra. equalall will turn all valid inequalities into equalities with integer slacks. strategy is as on but uses CbcStrategy.

Controls how aggressively CglProbing is run during preprocessing. off: no preprocessing probing heavy: heavier probing (more passes, larger element limits) heavier: even heavier probing (full column exploration)

When enabled, variables that behave integrally can be declared integer during preprocessing, potentially tightening the model. off: do not integerize objective: integerize if the variable has a nonzero objective coefficient always: integerize regardless of objective coefficient

When on, the preprocessor tries to identify and extract clique constraints from the model. This can tighten the LP relaxation.

When on and the model has all-+1 rows, the preprocessor uses CglDuplicateRow aggressively to eliminate dominated rows.

When on, the preprocessor uses a relaxed feasibility tolerance of 1e-4 instead of the LP primal tolerance. Can help on numerically difficult instances at the cost of slightly less tight preprocessing.

When on, a round of CglProbing is run before cliqueIt() during preprocessing. The clique model from probing is then used as the starting point for clique extraction, which can find stronger cliques.

Once you like what the stand-alone solver does then this allows you to generate user_driver.cpp which approximates the code. 0 gives simplest driver, 1 generates saves and restores, 2 generates saves and restores even for variables at default value. 4 bit in cbc generates size dependent code rather than computed values.

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

Sets the number of major preprocessing passes (each involving a full presolve cycle). 0 uses the default. Value 99 selects a single simple presolve with no probing or cuts.

Sets the number of minor modification passes performed within each major preprocessing pass. 0 uses the default of 10 passes.

Format aabbcccc - If aa then this is number of major passes (i.e. with presolve) If bb and bb>0 then this is number of minor passes (if unset or 0 then 10) cccc is bit set 0 - 1 Heavy probing 1 - 2 Make variables integer if possible (if obj value) 2 - 4 As above but even if zero objective value 7 - 128 Try and create cliques 8 - 256 If all +1 try hard for dominated rows 9 - 512 Even heavier probing 10 - 1024 Use a larger feasibility tolerance in presolve 11 - 2048 Try probing before creating cliques 12 - 4096 Switch off duplicate column checking for integers 13 - 8192 Allow scaled duplicate column checking Now aa 99 has special meaning i.e. just one simple presolve. Individual bits are also accessible via the named parameters preProbing, preIntegerize, preCliques, preDominatedRows, preLargeFeasibilityTolerance, preProbingBeforeCliques, preMajorPasses, and preMinorPasses.

If set, integer variables with reduced costs greater than the specified value will be fixed before branch and bound - use with extreme caution!

This sleazy trick can help on some problems.

Immediately runs bound propagation on the currently loaded model, applying bound tightenings to the problem in place. The aggression level is controlled by boundPropLevel. After running, use writeModel to save the tightened problem.

When on, singleton rows (rows with a single nonzero) are used to tighten variable bounds before the initial LP solve and conflict graph construction. This is a cheap preprocessing step that can fix variables and reduce the problem size.

Controls how aggressively bound propagation tightens variable bounds before the initial LP solve. off: disabled (falls back to singletonBounds setting). singletons: singleton rows only — same as singletonBounds on. milpbt: singletons then knapsack-based bound propagation for up to boundPropMaxRounds rounds (default 100, effectively fixpoint). fixpoint: singletons then bound propagation until no new fixings are found, regardless of boundPropMaxRounds.

When enabled, runs knapsack-based bound propagation after branching decisions are applied at each node (subject to depth constraints), before the LP is solved. Can detect infeasibility earlier and fix additional variables. Controlled by nodeBoundPropMaxDepth and nodeBoundPropDepthInterval.

Maximum number of CoinBoundPropagation rounds when boundPropLevel is 'milpbt'. Each round re-examines all rows using the bounds fixed in previous rounds; the process stops early if a round produces no new fixings. Has no effect when boundPropLevel is 'fixpoint' (runs until fixpoint regardless) or 'off'/'singletons'.

Node bound propagation is only applied at depths up to this value. Deeper nodes skip bound propagation to reduce overhead.

Node bound propagation is only applied at depths at or above this value. Shallower nodes skip bound propagation.

Node bound propagation is applied at depths that are multiples of this interval (0, interval, 2*interval, ...). For example, with interval 3 bound propagation runs at depths 0, 3, 6, 9, etc.

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. If the problem is very large one can let CLP write the original problem to file by using 'file'.

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.

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.

What rule (if any) to use in prioritizing variables for branching - 'priorities' assigns highest priority to variables with largest absolute cost. This primitive strategy can be surprisingly effective. - 'columnorder' assigns the priorities with respect to the column ordering. - '01first' ('01last') gives highest priority to binary variables. - 'length' assigns high priority to variables that occur in many constraints.

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 choice 'hybrid' does breadth first on small depth nodes and then switches to 'fewest'.

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.

Using strong branching computes pseudo-costs. After this many times for a variable we just trust the pseudo costs and do not do any more strong branching.

In order to decide which variable to branch on, the code will choose up to this number of unsatisfied variables and try mini 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 number before trust.

Whenever a solution is found the bound on future solutions is set to the objective of the solution (in a minimization sense) plus the specified increment. If this option is not specified, the code will try and work out an increment. E.g., if all objective coefficients are multiples of 0.01 and only integer variables have entries in objective then the increment can be set to 0.01. Be careful if you set this negative!

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

When checking a solution for feasibility, if the difference between the value of a variable and the nearest integer is less than the integer tolerance, the value is considered to be integral. Beware of setting this smaller than the primal tolerance.

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

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.

This applies to reading mps files (and also lp files if KILL_ZERO_READLP defined)

This switches the conflict graph-based preprocessing and cut separation routines (CglBKClique, CglOddWheel and CliqueStrengthening) on or off. Values: off: turns these routines off; on: turns these routines on; clq: turns these routines off and enables the cut separator of CglClique.

Sets the method used in the extension module of BK Clique Cut Separation routine: 0=no extension; 1=random; 2=degree; 3=modified degree; 4=reduced cost(inversely proportional); 5=reduced cost(inversely proportional) + modified degree

Sets the method used in the extension module of Odd Wheel Cut Separation routine: 0=no extension; 1=one variable; 2=clique

Selects a preset configuration that adjusts cuts, heuristics, and solver tuning as a group. easy (0): A lighter configuration. Uses Gomory cuts with a looser tolerance (0.01 at root), shorter FPump runs (20 passes, tune=1003), no preprocessing tuning, and disables RINS and DivingCoefficient. default (1): The recommended configuration. Tightens Gomory and TwoMir cut tolerances, runs FPump more aggressively (30 passes, tune=1005043), enables DivingCoefficient and RINS heuristics, and activates probing cuts (ifmove). This is what runs when no -strategy flag is given. aggressive (2): Reserved for future use; currently identical to default.

Defines how adventurous you want to be in using new ideas. 0 then no new ideas, 1 fairly sensible, 2 a bit dubious, 3 you are on your own!

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.

If set Or's with specialOptions just before entering branchAndBound.

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

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

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.

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

This just solves the problem to the continuous optimum, without adding any cuts.

This creates a new problem by applying the root node cuts. All tight constraints will be in resulting problem.

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)

Controls which LP algorithm is used when -solve or -initialSolve triggers the root LP relaxation. auto: ML-based automatic selection (default). Random Forest trained on 380 instances; ~1.33x speedup over dual on benchmark set. dual: dual simplex. primal: primal simplex. barrier: interior-point (barrier) method.

Number of solutions to save.

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.

The default is minimize - use 'direction maximize' for maximization. You can also use the parameters_ 'maximize' or 'minimize'.

The default is minimize - use 'maximize' for maximization. A synonym for 'direction maximize'.

The default is minimize - use 'maximize' for maximization. This should only be necessary if you have previously set maximization. A synonym for 'direction minimize'.

Mainly useful for tuning purposes. Normally the first dual or primal will be using an all slack basis anyway.

This command solves the current model using the primal dual predictor corrector algorithm. You may want to link in an alternative ordering and factorization. It will also solve models with quadratic objectives.

This command solves the continuous relaxation of the current model using the dual steepest edge algorithm. The time and iterations may be affected by settings such as presolve, scaling, crash and also by dual pivot method, fake bound on variables and dual and primal tolerances.

This command solves the continuous relaxation of the current model using the dual or primal algorithm, based on a dubious analysis of model.

Clp will go faster if the matrix can be converted to a network. The matrix operations may be a bit faster with more efficient storage, but the main advantage comes from using a network factorization. It will probably not be as fast as a specialized network code.

This will read a file with parametric data from the given file name and then do parametrics. It will use the default directory given by 'directory'. A name of '$' will use the previous value for the name. This is initialized to '', i.e. it must be set. This can not read from compressed files. File is in modified csv format - a line ROWS will be followed by rows data while a line COLUMNS will be followed by column data. The last line should be ENDATA. The ROWS line must exist and is in the format ROWS, inital theta, final theta, interval theta, n where n is 0 to get CLPI0062 message at interval or at each change of theta and 1 to get CLPI0063 message at each iteration. If interval theta is 0.0 or >= final theta then no interval reporting. n may be missed out when it is taken as 0. If there is Row data then there is a headings line with allowed headings - name, number, lower(rhs change), upper(rhs change), rhs(change). Either the lower and upper fields should be given or the rhs field. The optional COLUMNS line is followed by a headings line with allowed headings - name, number, objective(change), lower(change), upper(change). Exactly one of name and number must be given for either section and missing ones have value 0.0.

Clp will go slightly faster if the matrix can be converted so that the elements are not stored and are known to be unit. The main advantage is memory use. Clp may automatically see if it can convert the problem so you should not need to use this.

This command solves the continuous relaxation of the current model using the primal algorithm. The default is to use exact devex. The time and iterations may be affected by settings such as presolve, scaling, crash and also by column selection method, infeasibility weight and dual and primal tolerances.

Useful for testing if maximization works correctly

The default is minimize - use 'direction maximize' for maximization. You can also use the parameters 'maximize' or 'minimize'.

If this is on ClpPackedMatrix uses extra column copy in odd format.

0 - off, 1 choose blocks >1 use as blocks Dantzig Wolfe if primal, Benders if dual - uses sprint pass for number of passes

Don't even think about it.

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.

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.

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.

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.

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

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.

If processed problem <= this use dense factorization

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.

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.

This can be used for testing purposes. The corresponding library call setMaximumIterations(value) can be useful. If the code stops on seconds or by an interrupt this will be treated as stopping on maximum iterations. This is ignored in branchAndCut - use maxN!odes.

See ClpSimplex.hpp.

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

If you are solving a quadratic problem using primal then it may be helpful to do some sequential Lps to get a good approximate solution.

If processed problem <= this use small factorization

The dual algorithm in Clp is a single phase algorithm as opposed to a two phase algorithm where you first get feasible then optimal. If a problem has both upper and lower bounds then it is trivial to get dual feasible by setting non basic variables to correct bound. If the gap between the upper and lower bounds of a variable is more than the value of dualBound Clp introduces fake bounds so that it can make the problem dual feasible. This has the same effect as a composite objective function in the primal algorithm. Too high a value may mean more iterations, while too low a bound means the code may go all the way and then have to increase the bounds. OSL had a heuristic to adjust bounds, maybe we need that here.

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.

The Positive Edge criterion has been added to select incoming variables to try 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., 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.

For a barrier code to be effective it needs a good Cholesky ordering and factorization. The native ordering and factorization is not state of the art, although acceptable. You may want to link in one from another source. See Makefile.locations for some possibilities.

Interior point algorithms do not obtain a basic solution. This option will crossover to a basic solution suitable for ranging or branch and cut. With the current state of the solver for quadratic programs it may be a good idea to switch off crossover for this case (and maybe presolve as well) - the option 'maybe' does this.

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. - 'equilibrium' uses the largest element for scaling. - 'geometric' uses the squareroot of the product of largest and smallest element. - 'auto' lets CLP choose a method that gives the best ratio of the largest element to the smallest one.

If the objective function has some very large values, you may wish to scale them internally by this amount. It can also be set by autoscale. It is applied after scaling. You are unlikely to need this.

You can set this to -1.0 to test maximization or other to stress code

If the rhs or bounds have some very large meaningful values, you may wish to scale them internally by this amount. It can also be set by autoscale. This should not be needed.

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

If set then only those names which match mask are printed in a solution. '?' matches any character and '*' matches any set of characters. The default is '' (unset) so all variables are printed. This is only active if model has names.

Precision: %.nf -> n digits after decimal; %.ng -> n significant digits; Width: %mw -> minimum field width, padded with spaces by default. Remember the f or g at end as %18.5 by itself gives garbage.

By default, messages have a standard prefix, such as: Cbc0005 2261 Objective 109.024 Primal infeas 944413 (758) but this program turns this off to make it look more friendly. It can be useful to turn them back on if you want to be able to 'grep' for particular messages or if you intend to override the behavior of a particular message.

This switches the printing of heuristic statistics summary at the end of the solve on or off.

Checking the time costs more than one might think. In cbc one does not normally need to stop after generating a cut or doing an iteration. So less checks less often and often is more likely to check every iteration.

This changes the amount and format of printing a solution: normal - nonzero column variables integer - nonzero integer column variables special - in format suitable for OsiRowCutDebugger rows - nonzero column variables and row activities all - all column variables and row activities. For non-integer problems 'integer' and 'special' act like 'normal'. Also see printMask for controlling output.

If set to 0 then there should be no output in normal circumstances. A value of 1 is probably the best value for most uses, while 2 and 3 give more information.

If set to 0 then there should be no output in normal circumstances. A value of 1 is probably the best value for most uses, while 2 and 3 give more information.

When set to 1 (default), each output line is flushed immediately. This is already the default behaviour of CoinMessageHandler (which calls fflush after every CoinMessageEol). Setting to 0 is reserved for future use to allow batching of output for performance in non-interactive scenarios.

Controls whether UTF-8 characters (∈, κ, —) are used in solver output. -1 (default) auto-detects from the locale (LANG/LC_ALL environment variables). 0 forces ASCII-only output. 1 forces UTF-8 output.

Controls the table style used for progress tables (LP relaxation, preprocessing, feasibility pump, cut generation, branch-and-bound). 1 (default) uses a compact style: no column borders, columns separated by spaces, and a single thin rule under the header (a continuous line in UTF-8 mode, per-column dashes in ASCII mode). 0 uses the full bordered box-drawing style.

When solving the LP relaxation at the root node, print a progress row every N iterations. Set to 0 to disable iteration-based printing. Use lpTimeFreq for time-based printing.

Normally export will be done using normal representation for numbers and two values per line. You may want to do just one per line (for grep or suchlike) and you may wish to save with absolute accuracy using a coded version of the IEEE value. A value of 2 is normal. Otherwise, odd values give one value per line, even values two. Values of 1 and 2 give normal format, 3 and 4 give greater precision, 5 and 6 give IEEE values. When exporting a basis, 1 does not save values, 2 saves values, 3 saves with greater accuracy and 4 saves in IEEE format.

If this is greater than 0 then presolve will give more information and branch and cut will give statistics

When solving the LP relaxation at the root node, print a progress row every N seconds. Set to 0 to disable time-based printing. Use lpIterFreq for iteration-based printing.

Default is on, off switches on unbuffered output

The default behavior is to put out messages such as: Clp0005 2261 Objective 109.024 Primal infeas 944413 (758) but this program turns this off to make it look more friendly. It can be useful to turn them back on if you want to be able to 'grep' for particular messages or if you intend to override the behavior of a particular message.

For the sake of your sanity, only the more useful and simple commands are printed out on ?.

This changes the amount and format of printing a solution: normal - nonzero column variables integer - nonzero integer column variables special - in format suitable for OsiRowCutDebugger rows - nonzero column variables and row activities all - all column variables and row activities. For non-integer problems 'integer' and 'special' act like 'normal'. Also see printMask for controlling output.

Once you like what the stand-alone solver does then this allows you to generate user_driver.cpp which approximates the code. 0 gives simplest driver, 1 generates saves and restores, 2 generates saves and restores even for variables at default value. 4 bit in cbc generates size dependent code rather than computed values. This is now deprecated as you can call stand-alone solver - see Cbc/examples/driver4.cpp.

This sets a minimum interval for some printing - elapsed seconds

This will write an MPS format file to the given file name. It will use the default directory given by 'directory'. A name of '$' will use the previous value for the name. This is initialized to 'default.mps'. It can be useful to get rid of the original names and go over to using Rnnnnnnn and Cnnnnnnn. This can be done by setting 'keepnames' off before importing mps file.

This will read an MPS format file from the given file name. It will use the default directory given by 'directory'. A name of '$' will use the previous value for the name. This is initialized to '', i.e., it must be set. If you have libgz then it can read compressed files 'xxxxxxxx.gz'.

This will write a binary solution file to the file set by solFile.

The MIPStart allows one to enter an initial integer feasible solution to CBC. Values of the main decision variables which are active (have non-zero values) in this solution are specified in a text file. The text file format used is the same of the solutions saved by CBC, but not all fields are required to be filled. First line may contain the solution status and will be ignored, remaining lines contain column indexes, names and values as in this example: Stopped on iterations - objective value 57597.00000000 0 x(1,1,2,2) 1 1 x(3,1,3,2) 1 5 v(5,1) 2 33 x(8,1,5,2) 1 ... Column indexes are also ignored since pre-processing can change them. There is no need to include values for continuous or integer auxiliary variables, since they can be computed based on main decision variables. Starting CBC with an integer feasible solution can dramatically improve its performance: several MIP heuristics (e.g. RINS) rely on having at least one feasible solution available and can start immediately if the user provides one. Feasibility Pump (FP) is a heuristic which tries to overcome the problem of taking too long to find feasible solution (or not finding at all), but it not always succeeds. If you provide one starting solution you will probably save some time by disabling FP. Knowledge specific to your problem can be considered to write an external module to quickly produce an initial feasible solution - some alternatives are the implementation of simple greedy heuristics or the solution (by CBC for example) of a simpler model created just to find a feasible solution. Silly options added. If filename ends .low then integers not mentioned are set low - also .high, .lowcheap, .highcheap, .lowexpensive, .highexpensive where .lowexpensive sets costed ones to make expensive others low. Also if filename starts empty. then no file is read at all - just actions done. Question and suggestions regarding MIPStart can be directed to haroldo.santos@gmail.com.

Read priorities from the file name designated by PRIORITYFILE. File is in csv format with allowed headings - name, number, priority, direction, up, down, solution. Exactly one of name and number must be given.

This will read the problem saved by 'writeModel' from the file name set by 'modelFile'.

This will write the problem in binary foramt to the file name set by 'modelFile' for future use by readModel.

To write best solution, just use writeSolution. This prints next best (if exists) and then deletes it. This will write a primitive solution file to the file name set by 'nextBestSolutionFile'. The amount of output can be varied using 'printingOptions' or 'printMask'.

This will write a primitive solution file to the file set by 'solFile'. The amount of output can be varied using 'printingOptions' or 'printMask'.

This will write a primitive solution file to the file set by 'solFile'. The amount of output can be varied using 'printingOptions' or 'printMask'.

This will write a binary solution file to the file set by 'solBinaryFile'. To read the file use fread(int) twice to pick up number of rows and columns, then fread(double) to pick up objective value, then pick up row activities, row duals, column activities and reduced costs - see bottom of ClpParamUtils.cpp for code that reads or writes file. If name contains '_fix_read_', then does not write but reads and will fix all variables

This writes the statistics gathered so far to the file designated by csvStatistics (default 'stats.csv'). If no file name is supplied when the command is run, the previous CSV statistics file name is used.

This extracts all OsiFeatures from the current MIP instance and appends them as a single row to the file designated by csvFeatures (default 'features.csv'). If no file name is supplied the previous value is used. The header row is written automatically when the file is new or empty. A total of 207 numeric features are extracted, covering: - Problem size: number of columns (variables) and rows (constraints), non-zeros, matrix density, columns-per-row ratio. - Variable types: counts and percentages of binary, general integer and continuous variables; unbounded variables. - Constraint classes: partitioning, packing, covering, cardinality, knapsack, integer knapsack, invariant knapsack, singleton, aggregation, precedence, variable-bound and bin-packing rows. - Objective and matrix statistics: min/max/mean/std-dev of non-zero coefficients, objective coefficients and right-hand-side values; column non-zero distribution (fraction of columns with >= k non-zeros for k = 1, 2, 4, ..., 4096). All features are computed in O(nz) time.

Recomputes constraint and bound violations from scratch and writes a machine-readable report to the specified file (default 'sol_validation.txt'). Reports feasibility status, largest primal and dual errors, and identifies the constraint/variable with the largest violation.

Sets the file name used by writeFeatures. If name is not specified the previous value is used. Initialized to 'features.csv'. The header row listing all 207 feature names is written automatically when the file is new or empty; subsequent calls append a new row.

This appends statistics to given file name. If name is not specified, the previous value will be used. This is initialized to '', i.e. it must be set. Adds header if file empty or does not exist.

This will set the name of the model will be written to and read from. This is initialized to 'export.mps'.

This will set the name of the model to be read in with the import command. This is initialized to 'import.mps'

This will set the name the model will be written to and read from. This is initialized to 'prob.mod'.

This will set the name the model will be written to and read from. This is initialized to 'prob.mod'.

This will set the name solutions will be written to and read from. This is initialized to 'next.sol'.

Priorities will be read from the given file name. It will use the default directory given by 'directory'. The default name is priorities.txt and it cannot be a compressed file.File is in csv format with allowed headings - name, number, priority, direction, up, down, solution. Exactly one of name and number must be given.

This will set the name the solution will be saved to and read from. By default, solutions are written to 'opt.sol'. To print to stdout, use printSolution.

This will set the name the solution will be saved to and read from. By default, binary solutions are written to 'solution.file'.use printSolution.

This sets the directory which import, export, saveModel, restoreModel etc. will use. It is initialized to the current directory.

This sets the directory where the COIN-OR sample problems reside. It is used only when -unitTest is passed to cbc. cbc will pick up the test problems from this directory.

This sets the directory where the netlib problems reside. One can get the netlib problems from COIN-OR or from the main netlib site. This parameter is used only when -netlib is passed to cbc. cbc will pick up the netlib problems from this directory. If cbc is built without zlib support then the problems must be uncompressed.

This sets the directory where the miplib 2003 problems reside. One can get the miplib problems from COIN-OR or from the main miplib site. This parameter is used only when -miplib is passed to cbc. cbc will pick up the miplib problems from this directory. If cbc is built without zlib support then the problems must be uncompressed.

The default is not to use any model which had errors when reading the mps file. Setting this to 'on' will allow all errors from which the code can recover simply by ignoring the error. There are some errors from which the code can not recover, e.g., no ENDATA. This has to be set before import, i.e., -errorsAllowed on -import xxxxxx.mps.

This will read an MPS format basis file from the given file name. It will use the default directory given by 'directory'. A name of '$' will use the previous value for the name. This is initialized to '', i.e. it must be set. If you have libz then it can read compressed files 'xxxxxxxx.gz' or xxxxxxxx.bz2.

This will write an MPS format basis file to the given file name. It will use the default directory given by 'directory'. A name of '$' will use the previous value for the name. This is initialized to 'default.bas'.

This will read an MPS format basis file from the given file name. It will use the default directory given by 'directory'. If no name is specified, the previous value will be used. This is initialized to '', i.e. it must be set. If you have libz then it can read compressed files 'xxxxxxxx.gz' or xxxxxxxx.bz2.

This will read a file with parametric data from the given file name and then do parametrics. It will use the default directory given by 'directory'. A name of '$' will use the previous value for the name. This is initialized to '', i.e. it must be set. This can not read from compressed files. File is in modified csv format - a line ROWS will be followed by rows data while a line COLUMNS will be followed by column data. The last line should be ENDATA. The ROWS line must exist and is in the format ROWS, inital theta, final theta, interval theta, n where n is 0 to get CLPI0062 message at interval or at each change of theta and 1 to get CLPI0063 message at each iteration. If interval theta is 0.0 or >= final theta then no interval reporting. n may be missed out when it is taken as 0. If there is Row data then there is a headings line with allowed headings - name, number, lower(rhs change), upper(rhs change), rhs(change). Either the lower and upper fields should be given or the rhs field. The optional COLUMNS line is followed by a headings line with allowed headings - name, number, objective(change), lower(change), upper(change). Exactly one of name and number must be given for either section and missing ones have value 0.0.

The default is not to use any model which had errors when reading the mps file. Setting this to 'on' will allow all errors from which the code can recover simply by ignoring the error. There are some errors from which the code can not recover e.g. no ENDATA. This has to be set before import i.e. -errorsAllowed on -import xxxxxx.mps.

It saves space to get rid of names so if you need to you can set this to off. This needs to be set before the import of model - so -keepnames off -import xxxxx.mps.

When enabled, the root LP relaxation is solved by racing multiple LP method configurations in parallel. The first to reach optimality wins and the others are aborted. The number of racing threads is taken from the -threads parameter: 2 threads uses the K=2 portfolio (dual_pesteep_pertv75 + primal_idiot50, ~1.51x speedup); 3 or more threads uses the K=3 portfolio (dual_pesteep_psineg1_pertv75 + primal_idiot50 + primal_sprint, ~1.63x speedup). Portfolios are data-driven from k-fold cross-validation on MIPLIB 2017+SPP.

To use multiple threads, set threads to number wanted. It may be better to use one or two more than number of cpus available. If 100+n then n threads and search is repeatable (maybe be somewhat slower), if 200+n use threads for root cuts, 400+n threads used in sub-trees.