SCIP

Table of Contents

SCIP (Solving Constraint Integer Programs) is developed at the Zuse Institute Berlin (ZIB) in cooperation with TU Darmstadt, RWTH Aachen, and University of Erlangen-Nürnberg, see the SCIP webpage for the current list of developers.

SCIP is a framework for Constraint Integer Programming oriented towards the needs of Mathematical Programming experts who want to have total control of the solution process and access detailed information down to the guts of the solver. SCIP can also be used as a pure MIP or MINLP solver or as a framework for branch-cut-and-price. Within GAMS, the MIP and MINLP solving facilities of SCIP are available.

For more detailed information, we refer to [3, 4, 5, 35, 36, 102, 169, 116, 117, 103, 248, 249, 263] and the SCIP web site.

GAMS/SCIP uses CPLEX, if licensed, and otherwise SOPLEX [265] as LP solver, the COIN-OR Interior Point Optimizer IPOPT [254] as nonlinear solver, and CppAD to compute derivatives of nonlinear functions.

SCIP supports continuous, binary, integer, semi-continuous, semi-integer variables, indicator constraints, special ordered sets, and branching priorities for discrete variables.

Usage

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

Option MIP = SCIP;     { or QCP or NLP or MIQCP or MINLP or ... }

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

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

Specification of SCIP Options

GAMS/SCIP supports the GAMS parameters reslim, iterlim, nodlim, optca, optcr, and workspace. Further, the option threads can be used to control the number of threads used in the MILP presolver, the linear algebra routines of IPOPT, and for solving LPs if CPLEX' barrier solver is used.

Options can be specified by a SCIP options file. A SCIP options file consists of one option or comment per line. A pound sign (#) at the beginning of a line causes the entire line to be ignored. Otherwise, the line will be interpreted as an option name and value separated by an equal sign (=) and any amount of white space (blanks or tabs). Further, string values have to be enclosed in quotation marks.

A small example for a scip.opt file is:

propagating/probing/maxprerounds = 0
separating/maxrounds             = 0
separating/maxroundsroot         = 0

It causes GAMS/SCIP to disable probing during presolve and to turn off all cut generators.

Specification of Indicators

Indicators are a modeling tool to specify that certain equations in a model must only be satisfied if certain binary variables take a specified value. Indicators are not supported by the GAMS language, but can be passed to SCIP via a separate file, see Indicator Constraints for more details on its syntax. The name of that file is specified via the option gams/indicatorfile in a SCIP option file. Currently, indicators can only be used for linear equations.

Special Features

SCIP interactive shell

The interactive shell in SCIP is a powerful tool that allows the user to display various information (e.g., branching statistics, presolved model), load emphasis settings, interrupt a solve to change parameters or trigger a restart, write the model in various file formats, start SCIPs solution counter, and many more things.

When setting the option gams/interactive to a nonempty string, the GAMS/SCIP interface opens the interactive shell of SCIP after having load the GAMS problem and parameters and passes the value of the gams/interactive parameter to the SCIP interactive shell.

By default, SCIP behaves as if gams/interactive has been set to "optimize write gamssol quit", that is, SCIP is requested to solve the problem, then to pass the solution back to GAMS, and to quit.

An example use of the SCIP interactive shell feature via GAMS is to add the following line to your SCIP options file:

gams/interactive = "write prob orig.lp presolve write transprob presol.mps opt write gamssol quit"

This instructs SCIP to write the original problem to the file orig.lp in LP format, to presolve the instance, to write the presolved problem to the file presolved.mps in MPS format, to solve the instance, to write the solution out to GAMS, and to finish.

By omitting the quit command, SCIPs interactive shell remains open and awaits user input. The command help prints a list of available commands. Note, that on Windows, GAMS need to be called with the option interactivesolver enabled to allow user input for the solver process.

A tutorial on using the SCIP shell is available at https://www.scipopt.org/doc/html/SHELL.php.

Emphasis Settings

SCIP includes various emphasis settings, which are predefined values for a set of SCIP parameters. Such predefined settings are available for setting the effort that SCIP should spend for, e.g., presolving, separation, or heuristics.

The emphasis settings are not available as single parameters, but can be set via SCIPs interactive shell. E.g., writing set heuristics emphasis in the shell displays the available emphasis settings for heuristics (aggressive, fast, off) and expects the user to input which setting to use. Further, general emphasis settings are available in the set emphasis menu, some of them giving predefined settings similar to the CPLEX option mipemphasis.

Via the gams/interactive option, c.f. Section SCIP interactive shell, emphasis settings can be activated via a SCIP options file. For example, adding the option

gams/interactive = "set emphasis feasibility set loadgams optimize write gamssol quit"

instructs SCIP to load the emphasis setting feasibility prior to optimizing the model and passing the solution back to GAMS. Note, that setting one of the emphasis settings feasibility, hardlp, and optimality resets all previously set parameters to their default values, which includes the ones that are set by the GAMS/SCIP interface or which were loaded from a SCIP options file. Therefore, the command set loadgams has been used above to restore these parameter settings.

The following emphasis settings are available in SCIP:

shell command purpose
set emphasis easycip use for easy problems
set emphasis feasibility emphasize finding a feasible solution
set emphasis hardlp use for problems with a hard LP
set emphasis optimality emphasize proving optimality
set emphasis numerics increase numerical stability
set heuristic emphasis aggressive use primal heuristics aggressively
set heuristic emphasis fast use only fast primal heuristics
set heuristic emphasis off disable all primal heuristics
set presolving emphasis aggressive do aggressive presolving
set presolving emphasis fast use only fast presolving steps
set presolving emphasis off disable presolving
set separating emphasis aggressive use cutting plane separators aggressively
set separating emphasis fast use only fast cutting plane separators
set separating emphasis off disable all cutting plane separators

Starting point

Using the completesol heuristic, SCIP can try to find a feasible solution based on values given by the user for all or some of the variables. The values need to be specified as variable levels in the GAMS model. The heuristic solves a copy of the problem where variables for which values have been provided are restricted to be close to that value. When an integral value is specified for a binary or integer variable, the variable is fixed to that value. See also Section 2.3.2 in [169] for a more detailed description of the heuristic.

For which variables the level values are passed from GAMS to SCIP is controlled by the parameter gams/mipstart. The parameter values have the following meaning:

  • 0: do not pass any variable values to SCIP, the heuristic will not run
  • 1: pass values for all binary and integer variables to SCIP and let SCIP try to find a feasible solution in its neighborhood by using the completesol heuristic
  • 2 (default): pass values for all variables to SCIP and let SCIP check feasibility of the given solution, the heuristic will not run
  • 3: pass values for all variables to SCIP and let SCIP try to find a feasible solution in the neighborhood by using the completesol heuristic
  • 4: pass values for all binary and integer variables to SCIP which fractionality is at most the value of GAMS option tryint (thus, with default tryint=0, only for variables with integral values, the value is passed to SCIP) and let SCIP try to find a feasible solution in the neighborhood by using the completesol heuristic

Note, that the completesol heuristic will not run if there are too many variables with unknown values. This behavior can be adjusted by setting parameter heuristics/completesol/maxunknownrate.

Decomposition Information

SCIP potentially can make use of a user-provided problem decomposition, e.g., in primal heuristics PADM or GINS. Note, that SCIP's Benders Decomposition is not available with GAMS at the moment. A GAMS user can inform SCIP about such a decomposition by using the .stage variable suffix.

In an attempt to following the same convention on interpreting the .stage variable suffix as the GAMS/CPLEX link, variables which .stage suffix is set to an integral value greater than 0 are assigned to a block with this number. Variables which .stage suffix is set to a fractional value or a value smaller than 1 are assigned to no block.

Note, that the default value for the .stage suffix is 1. Therefore, GAMS/SCIP only passes decomposition information to SCIP if at least one variable has its .stage suffix set to a value different than 1. Moreover, in order to receive the .stage values, scaleOpt and priorOpt must be left at their default of 0.

Solution Pool

When SCIP solves a problem, it may find several solutions, whereof only the best one is available to the GAMS user via the variable level values in the GAMS model. If the option gams/dumpsolutions is specified, then all alternative solutions found by SCIP are written into GDX files and an index file with the name given by the this option is written. If the option gams/dumpsolutionsmerged is specified, then all alternative solutions found by SCIP are written into a single GDX file, which name is given by the this option.

The GAMS testlib model dumpsol shows an example use for this option via GUROBI. It can easily be adapted to be used with SCIP.

Solving process tracing

The option gams/solvetrace/file can be used to specify the name of a file where information about the progress of the branch-and-bound tree search in SCIP is stored. The file is created and updated during the solution process, so it may also be used to monitor the progress of SCIP while it still solves the model.

New entries are written periodically, depending on how many nodes have been processed or how much time has been elapsed since the last entry was written. Each entry contains information on the current primal and dual bound.

Notes on solving MINLPs with SCIP

SCIP includes capabilities to handle nonlinear functions that are specified via algebraic expressions. Therefore, neither external/extrinsic functions nor all GAMS operands (e.g., trigonometric ones) are supported yet.

Nonconvex MINLPs are solved via a spatial branch-and-bound algorithm using linear relaxations. The tightness of this relaxation depends heavily on the variable bounds, thus tight bounds for the nonlinear variables are crucial for SCIP.

Special options for convex MINLPs

Convex MINLPs are much easier to solve for SCIP, provided it recognizes the convexity of the model. So far, only a simple convexity check is implemented in SCIP, which may not give a conclusive answer in all cases. However, setting the option constraints/nonlinear/assumeconvex to TRUE can be used to tell SCIP that it should assume all nonlinear constraints to be of convex type. This may help to improve solving times for convex MINLPs considerably.

Another feature that can be especially useful for convex MINLPs is to enable the generation of cuts in the solution of the NLP relaxation in the root node and to consider using these cuts during the whole solution process. This is achieved by the parameters

constraints/quadratic/sepanlpmincont = 0
constraints/soc/sepanlpmincont = 0
constraints/nonlinear/sepanlpmincont = 0
constraints/abspower/sepanlpmincont = 0
separating/poolfreq = 1

However, it has been shown that these settings can also deteriorate performance.

Components

In the following, we list components that are available in SCIP together with some common properties. Some of these properties can be modified with corresponding parameters.

Branching Rules

branching rule priority maxdepth maxbounddist description
relpscost 10000 -1 100 reliability branching on pseudo cost values
pscost 2000 -1 100 branching on pseudo cost values
inference 1000 -1 100 inference history branching
mostinf 100 -1 100 most infeasible branching
leastinf 50 -1 100 least infeasible branching
distribution 0 -1 100 branching rule based on variable influence on cumulative normal distribution of row activities
fullstrong 0 -1 100 full strong branching
cloud 0 -1 100 branching rule that considers several alternative LP optima
lookahead 0 -1 100 full strong branching over multiple levels
multaggr 0 -1 100 fullstrong branching on fractional and multi-aggregated variables
allfullstrong -1000 -1 100 all variables full strong branching
vanillafullstrong -2000 -1 100 vanilla full strong branching
random -100000 -1 100 random variable branching
nodereopt -9000000 -1 100 branching rule for node reoptimization

See https://www.scipopt.org/doc/html/BRANCH.php for a detailed description of the branching rule properties.

Conflict Handler

conflict handler priority description
logicor 800000 conflict handler creating logic or constraints
setppc 700000 conflict handler creating set covering constraints
indicatorconflict 200000 replace slack variables and generate logicor constraints
linear -1000000 conflict handler creating linear constraints
bounddisjunction -3000000 conflict handler creating bound disjunction constraints

Constraint Handler

constraint handler checkprio enfoprio sepaprio sepafreq propfreq eagerfreq presolvetimings description
integral 0 0 0 -1 -1 -1 always integrality constraint
soc -10 -40 10 1 1 100 always constraint handler for second order cone constraints
SOS1 -10 100 1000 10 1 100 medium SOS1 constraint handler
SOS2 -10 100 10 0 1 100 fast SOS2 constraint handler
varbound -500000 -500000 900000 0 1 100 fast medium variable bounds lhs <= x + c*y <= rhs, x non-binary, y non-continuous
knapsack -600000 -600000 600000 0 1 100 always knapsack constraint of the form a^T x <= b, x binary and a >= 0
setppc -700000 -700000 700000 0 1 100 always set partitioning / packing / covering constraints
and -850100 -850100 850100 1 1 100 fast exhaustive constraint handler for AND-constraints: r = and(x1, ..., xn)
linear -1000000 -1000000 100000 0 1 100 fast exhaustive linear constraints of the form lhs <= a^T x <= rhs
orbisack -1005200 -1005200 40100 5 5 -1 exhaustive symmetry breaking constraint handler for orbisacks
orbitope -1005200 -1005200 40100 -1 1 -1 medium symmetry breaking constraint handler relying on (partitioning/packing) orbitopes
symresack -1005200 -1005200 40100 5 5 -1 exhaustive symmetry breaking constraint handler relying on symresacks
logicor -2000000 -2000000 10000 0 1 100 always logic or constraints
bounddisjunction -3000000 -3000000 0 -1 1 100 fast bound disjunction constraints
abspower -3500000 -30 0 1 1 100 fast medium constraint handler for absolute power constraints lhs <= sign(x+offset)abs(x+offset)^n + c*z <= rhs
bivariate -3600000 -55 5 1 1 100 fast constraint handler for constraints of the form lhs <= f(x,y) + c*z <= rhs where f(x,y) is a bivariate function
quadratic -4000000 -50 10 1 1 100 always quadratic constraints of the form lhs <= b' x + x' A x <= rhs
nonlinear -4000010 -60 10 1 1 100 always constraint handler for nonlinear constraints
indicator -6000000 -100 10 10 1 100 fast indicator constraint handler
components -9999999 0 0 -1 1 -1 independent components constraint handler

See https://www.scipopt.org/doc/html/CONS.php for a detailed description of the constraint handler properties.

Display Columns

display column header position width priority status description
solfound 0 1 80000 auto letter that indicates the heuristic which found the solution
time time 50 5 4000 auto total solution time
nnodes node 100 7 100000 auto number of processed nodes
nodesleft left 200 7 90000 auto number of unprocessed nodes
nrank1nodes rank1 500 7 40000 off current number of rank1 nodes left
nnodesbelowinc nbInc 550 6 40000 off current number of nodes with an estimate better than the current incumbent
lpiterations LP iter 1000 7 30000 auto number of simplex iterations
lpavgiterations LP it/n 1400 7 25000 auto average number of LP iterations since the last output line
lpcond LP cond 1450 7 0 auto estimate on condition number of LP solution
memused umem 1500 5 0 auto total number of bytes used in block memory
memtotal mem/heur 1500 8 20000 auto total number of bytes in block memory or the creator name when a new incumbent solution was found
depth depth 2000 5 500 auto depth of current node
maxdepth mdpt 2100 5 5000 auto maximal depth of all processed nodes
plungedepth pdpt 2200 5 10 auto current plunging depth
nfrac frac 2500 5 700 auto number of fractional variables in the current solution
nexternbranchcands extbr 2600 5 650 auto number of extern branching variables in the current node
vars vars 3000 5 3000 auto number of variables in the problem
conss cons 3100 5 3100 auto number of globally valid constraints in the problem
curconss ccons 3200 5 600 auto number of enabled constraints in current node
curcols cols 3300 5 800 auto number of LP columns in current node
currows rows 3400 5 900 auto number of LP rows in current node
cuts cuts 3500 5 2100 auto total number of cuts applied to the LPs
separounds sepa 3600 4 100 auto number of separation rounds performed at the current node
poolsize pool 3700 5 50 auto number of LP rows in the cut pool
conflicts confs 4000 5 2000 auto total number of conflicts found in conflict analysis
strongbranchs strbr 5000 5 1000 auto total number of strong branching calls
pseudoobj pseudoobj 6000 14 300 auto current pseudo objective value
lpobj lpobj 6500 14 300 auto current LP objective value
curdualbound curdualbound 7000 14 400 auto dual bound of current node
estimate estimate 7500 14 200 auto estimated value of feasible solution in current node
avgdualbound avgdualbound 8000 14 40 auto average dual bound of all unprocessed nodes
dualbound dualbound 9000 14 70000 auto current global dual bound
primalbound primalbound 10000 14 80000 auto current primal bound
cutoffbound cutoffbound 10100 14 10 auto current cutoff bound
gap gap 20000 8 60000 auto current (relative) gap using |primal-dual|/MIN(|dual|,|primal|)
primalgap primgap 21000 8 20000 off current (relative) gap using |primal-dual|/|primal|
nsols nsols 30000 5 0 auto current number of solutions found
completed compl. 30100 8 110000 auto completion of search in percent (based on tree size estimation)
nobjleaves objleav 31000 7 0 auto current number of encountered objective limit leaves
ninfeasleaves infleav 32000 7 0 auto number of encountered infeasible leaves
sols sols 100000 7 110000 off number of detected feasible solutions
feasST feasST 110000 6 110000 off number of detected non trivial feasible subtrees

See https://www.scipopt.org/doc/html/DISP.php for a detailed description of the display column properties.

Node Selectors

node selector standard priority memsave priority description
estimate 200000 100 best estimate search
bfs 100000 0 best first search
hybridestim 50000 50 hybrid best estimate / best bound search
restartdfs 10000 50000 depth first search with periodical selection of the best node
uct 10 0 node selector which balances exploration and exploitation
dfs 0 100000 depth first search
breadthfirst -10000 -1000000 breadth first search

See https://www.scipopt.org/doc/html/NODESEL.php for a detailed description of the node selector properties.

Presolvers

presolver priority timing maxrounds description
milp 9999999 medium -1 MILP specific presolving methods
trivial 9000000 fast -1 round fractional bounds on integers, fix variables with equal bounds
boundshift 7900000 fast 0 converts variables with domain [a,b] to variables with domain [0,b-a]
inttobinary 7000000 fast -1 converts integer variables with domain [a,a+1] to binaries
convertinttobin 6000000 fast 0 converts integer variables to binaries
gateextraction 1000000 exhaustive -1 presolver extracting gate(and)-constraints
qpkktref -1 medium -1 adds KKT conditions to (mixed-binary) quadratic programs
dualcomp -50 exhaustive -1 compensate single up-/downlocks by singleton continuous variables
stuffing -100 exhaustive 0 fix redundant singleton continuous variables
domcol -1000 exhaustive -1 dominated column presolver
tworowbnd -2000 exhaustive 0 do bound tigthening by using two rows
dualinfer -3000 exhaustive 0 exploit dual information for fixings and side changes
implics -10000 medium -1 implication graph aggregator
dualagg -12000 exhaustive 0 aggregate variables by dual arguments
sparsify -24000 exhaustive -1 eliminate non-zero coefficients
dualsparsify -240000 exhaustive -1 eliminate non-zero coefficients
redvub -9000000 exhaustive 0 detect redundant variable bound constraints

See https://www.scipopt.org/doc/html/PRESOL.php for a detailed description of the presolver properties.

Primal Heuristics

primal heuristic type priority freq freqoffset description
padm L 70000 0 0 penalty alternating direction method primal heuristic
ofins L 60000 0 0 primal heuristic for reoptimization, objective function induced neighborhood search
trivialnegation p 40000 0 0 negate solution entries if an objective coefficient changes the sign, enters or leaves the objective.
reoptsols p 40000 0 0 primal heuristic updating solutions found in a previous optimization round
trivial t 10000 0 0 start heuristic which tries some trivial solutions
clique p 5000 0 0 LNS heuristic using a clique partition to restrict the search neighborhood
locks p 3000 0 0 heuristic that fixes variables based on their rounding locks
vbounds p 2500 0 0 LNS heuristic uses the variable lower and upper bounds to determine the search neighborhood
shiftandpropagate p 1000 0 0 Pre-root heuristic to expand an auxiliary branch-and-bound tree and apply propagation techniques
zeroobj L 100 -1 0 heuristic trying to solve the problem without objective
completesol L 0 0 0 primal heuristic trying to complete given partial solutions
dualval L 0 -1 0 primal heuristic using dual values
simplerounding r 0 1 0 simple and fast LP rounding heuristic
repair L 0 -1 0 tries to repair a primal infeasible solution
randrounding r -200 20 0 fast LP rounding heuristic
zirounding r -500 1 0 LP rounding heuristic as suggested by C. Wallace taking row slacks and bounds into account
rounding r -1000 1 0 LP rounding heuristic with infeasibility recovering
shifting r -5000 10 0 LP rounding heuristic with infeasibility recovering also using continuous variables
intshifting r -10000 10 0 LP rounding heuristic with infeasibility recovering and final LP solving
oneopt i -20000 1 0 1-opt heuristic which tries to improve setting of single integer variables
twoopt i -20100 -1 0 primal heuristic to improve incumbent solution by flipping pairs of variables
indicator L -20200 1 0 indicator heuristic to create feasible solutions from values for indicator variables
adaptivediving d -70000 5 3 diving heuristic that selects adaptively between the existing, public divesets
fixandinfer p -500000 -1 0 iteratively fixes variables and propagates inferences
farkasdiving d -900000 10 0 LP diving heuristic that tries to construct a Farkas-proof
feaspump o -1000000 20 0 objective feasibility pump 2.0
conflictdiving d -1000100 10 0 LP diving heuristic that chooses fixings w.r.t. conflict locks
coefdiving d -1001000 -1 1 LP diving heuristic that chooses fixings w.r.t. the matrix coefficients
pscostdiving d -1002000 10 2 LP diving heuristic that chooses fixings w.r.t. the pseudo cost values
fracdiving d -1003000 10 3 LP diving heuristic that chooses fixings w.r.t. the fractionalities
nlpdiving d -1003000 10 3 NLP diving heuristic that chooses fixings w.r.t. the fractionalities
veclendiving d -1003100 10 4 LP diving heuristic that rounds variables with long column vectors
distributiondiving d -1003300 10 3 Diving heuristic that chooses fixings w.r.t. changes in the solution density
intdiving d -1003500 -1 9 LP diving heuristic that fixes binary variables with large LP value to one
actconsdiving d -1003700 -1 5 LP diving heuristic that chooses fixings w.r.t. the active constraints
objpscostdiving o -1004000 20 4 LP diving heuristic that changes variable's objective values instead of bounds, using pseudo costs as guide
rootsoldiving o -1005000 20 5 LP diving heuristic that changes variable's objective values using root LP solution as guide
linesearchdiving d -1006000 10 6 LP diving heuristic that chooses fixings following the line from root solution to current solution
guideddiving d -1007000 10 7 LP diving heuristic that chooses fixings in direction of incumbent solutions
octane r -1008000 -1 0 octane primal heuristic for pure {0;1}-problems based on Balas et al.
rens L -1100000 0 0 LNS exploring fractional neighborhood of relaxation's optimum
alns L -1100500 20 0 Large neighborhood search heuristic that orchestrates the popular neighborhoods Local Branching, RINS, RENS, DINS etc.
rins L -1101000 25 0 relaxation induced neighborhood search by Danna, Rothberg, and Le Pape
localbranching L -1102000 -1 0 local branching heuristic by Fischetti and Lodi
trustregion L -1102000 -1 0 LNS heuristic for Benders' decomposition based on trust region methods
gins L -1103000 20 8 gins works on k-neighborhood in a variable-constraint graph
mutation L -1103000 -1 8 mutation heuristic randomly fixing variables
lpface L -1104000 15 0 LNS heuristic that searches the optimal LP face inside a sub-MIP
crossover L -1104000 30 0 LNS heuristic that fixes all variables that are identic in a couple of solutions
dins L -1105000 -1 0 distance induced neighborhood search by Ghosh
bound p -1107000 -1 0 heuristic which fixes all integer variables to a bound and solves the remaining LP
undercover L -1110000 0 0 solves a sub-CIP determined by a set covering approach
proximity L -2000000 -1 0 heuristic trying to improve the incumbent by an auxiliary proximity objective function
subnlp L -2000000 1 0 primal heuristic that performs a local search in an NLP after fixing integer variables and presolving
mpec d -2050000 50 0 regularization heuristic for convex and nonconvex MINLPs
multistart L -2100000 0 0 multistart heuristic for convex and nonconvex MINLPs
trysol t -3000000 1 0 try solution heuristic

See https://www.scipopt.org/doc/html/HEUR.php for a detailed description of the primal heuristic properties.

Propagators

propagator propprio freq presolveprio presolvetiming description
rootredcost 10000000 1 0 always reduced cost strengthening using root node reduced costs and the cutoff bound
dualfix 8000000 0 8000000 fast roundable variables dual fixing
genvbounds 3000000 1 -2000000 fast generalized variable bounds propagator
vbounds 3000000 1 -90000 medium exhaustive propagates variable upper and lower bounds
pseudoobj 3000000 1 6000000 fast pseudo objective function propagator
redcost 1000000 1 0 always reduced cost strengthening propagator
probing -100000d -1 -100000 exhaustive probing propagator on binary variables
symmetry -1000000 1 -10000000 exhaustive propagator for handling symmetry
obbt -1000000d 0 0 always optimization-based bound tightening propagator
nlobbt -1100000d -1 0 always propagator template

See https://www.scipopt.org/doc/html/PROP.php for a detailed description of the propagator properties.

Separators

separator priority freq bounddist description
closecuts 1000000 -1 1 closecuts meta separator
disjunctive 10d 0 0 disjunctive cut separator
convexproj 0d -1 1 separate at projection of point onto convex region
gauge 0 -1 1 gauge separator
impliedbounds -50 10 1 implied bounds separator
intobj -100 -1 0 integer objective value separator
cgmip -1000 -1 0 Chvatal-Gomory cuts via MIPs separator
gomory -1000 10 1 Gomory MIR cuts separator
strongcg -2000 10 1 Strong CG cuts separator (Letchford and Lodi)
aggregation -3000 10 1 aggregation heuristic for complemented mixed integer rounding cuts and flowcover cuts
clique -5000 0 0 clique separator of stable set relaxation
zerohalf -6000 10 1 {0,1/2}-cuts separator
mcf -10000 0 0 multi-commodity-flow network cut separator
eccuts -13000 -1 1 separator for edge-concave functions
oddcycle -15000 -1 1 odd cycle separator
flowcover -100000 10 0 separator for flowcover cuts
cmir -100000 10 0 separator for cmir cuts
rapidlearning -1200000 5 1 rapid learning heuristic and separator

See https://www.scipopt.org/doc/html/SEPA.php for a detailed description of the separator properties.

List of SCIP Options

SCIP supports a large set of options. In the following, we give a detailed list of all SCIP options.

gams

Option Description Default
gams/dumpsolutions name of solutions index gdx file for writing all alternate solutions
Range: string
gams/dumpsolutionsmerged name of gdx file for writing all alternate solutions into a single file
Range: string
gams/indicatorfile name of GAMS options file that contains definitions on indicators
Range: string
gams/interactive command to be issued to the SCIP shell instead of issuing a solve command
Range: string
gams/mipstart how to handle initial variable levels, see also section Starting point
Range: {0, ..., 4}
2
gams/resolvenlp whether to resolve MINLP with fixed discrete variables if best solution violates some constraints
Range: boolean
1

gams/solvetrace

Option Description Default
gams/solvetrace/file name of file where to write branch-and-bound trace information too
Range: string
gams/solvetrace/nodefreq frequency in number of nodes when to write branch-and-bound trace information, 0 to disable
Range: {0, ..., ∞}
100
gams/solvetrace/timefreq frequency in seconds when to write branch-and-bound trace information, 0.0 to disable
Range: [0, ∞]
5

branching

Option Description Default
branching/clamp minimal relative distance of branching point to bounds when branching on a continuous variable
Range: [0, 0.5]
0.2
branching/delaypscostupdate should updating pseudo costs for continuous variables be delayed to the time after separation?
Range: boolean
1
branching/divingpscost should pseudo costs be updated also in diving and probing mode?
Range: boolean
1
branching/lpgainnormalize strategy for normalization of LP gain when updating pseudocosts of continuous variables (divide by movement of 'l'p value, reduction in 'd'omain width, or reduction in domain width of 's'ibling)
Range: d, l, s
s
branching/midpull fraction by which to move branching point of a continuous variable towards the middle of the domain; a value of 1.0 leads to branching always in the middle of the domain
Range: [0, 1]
0.75
branching/midpullreldomtrig multiply midpull by relative domain width if the latter is below this value
Range: [0, 1]
0.5
branching/preferbinary should branching on binary variables be preferred?
Range: boolean
0
Options for expert users
branching/checksol should LP solutions during strong branching with propagation be checked for feasibility?
Range: boolean
1
branching/firstsbchild child node to be regarded first during strong branching (only with propagation): 'u'p child, 'd'own child, 'h'istory-based, or 'a'utomatic
Range: a, d, u, h
a
branching/forceallchildren should all strong branching children be regarded even if one is detected to be infeasible? (only with propagation)
Range: boolean
0
branching/roundsbsol should LP solutions during strong branching with propagation be rounded? (only when checksbsol=TRUE)
Range: boolean
1
branching/scorefac branching score factor to weigh downward and upward gain prediction in sum score function
Range: [0, 1]
0.167
branching/scorefunc branching score function ('s'um, 'p'roduct, 'q'uotient)
Range: s, p, q
p
branching/sumadjustscore score adjustment near zero by adding epsilon (TRUE) or using maximum (FALSE)
Range: boolean
0

branching/allfullstrong

Option Description Default
branching/allfullstrong/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
1
branching/allfullstrong/maxdepth maximal depth level, up to which branching rule <allfullstrong> should be used (-1 for no limit)
Range: {-1, ..., 65534}
-1
branching/allfullstrong/priority priority of branching rule <allfullstrong>
Range: {-536870912, ..., 536870911}
-1000

branching/cloud

Option Description Default
branching/cloud/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
1
branching/cloud/maxdepth maximal depth level, up to which branching rule <cloud> should be used (-1 for no limit)
Range: {-1, ..., 65534}
-1
branching/cloud/maxdepthunion maximum depth for the union
Range: {0, ..., 65000}
65000
branching/cloud/maxpoints maximum number of points for the cloud (-1 means no limit)
Range: {-1, ..., ∞}
-1
branching/cloud/minsuccessrate minimum success rate for the cloud
Range: [0, 1]
0
branching/cloud/minsuccessunion minimum success rate for the union
Range: [0, 1]
0
branching/cloud/onlyF2 should only F2 be used?
Range: boolean
0
branching/cloud/priority priority of branching rule <cloud>
Range: {-536870912, ..., 536870911}
0
branching/cloud/usecloud should a cloud of points be used?
Range: boolean
1
branching/cloud/useunion should the union of candidates be used?
Range: boolean
0

branching/distribution

Option Description Default
branching/distribution/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
1
branching/distribution/maxdepth maximal depth level, up to which branching rule <distribution> should be used (-1 for no limit)
Range: {-1, ..., 65534}
-1
branching/distribution/priority priority of branching rule <distribution>
Range: {-536870912, ..., 536870911}
0
Options for expert users
branching/distribution/onlyactiverows should only rows which are active at the current node be considered?
Range: boolean
0
branching/distribution/scoreparam the score;largest 'd'ifference, 'l'owest cumulative probability,'h'ighest c.p., 'v'otes lowest c.p., votes highest c.p.('w')
Range: d, h, l, v, w
v
branching/distribution/weightedscore should the branching score weigh up- and down-scores of a variable
Range: boolean
0

branching/fullstrong

Option Description Default
branching/fullstrong/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
1
branching/fullstrong/maxdepth maximal depth level, up to which branching rule <fullstrong> should be used (-1 for no limit)
Range: {-1, ..., 65534}
-1
branching/fullstrong/priority priority of branching rule <fullstrong>
Range: {-536870912, ..., 536870911}
0
Options for expert users
branching/fullstrong/forcestrongbranch should strong branching be applied even if there is just a single candidate?
Range: boolean
0
branching/fullstrong/maxproprounds maximum number of propagation rounds to be performed during strong branching before solving the LP (-1: no limit, -2: parameter settings)
Range: {-3, ..., ∞}
-2
branching/fullstrong/probingbounds should valid bounds be identified in a probing-like fashion during strong branching (only with propagation)?
Range: boolean
1
branching/fullstrong/reevalage number of intermediate LPs solved to trigger reevaluation of strong branching value for a variable that was already evaluated at the current node
Range: {0, ..., ∞}
10

branching/inference

Option Description Default
branching/inference/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
1
branching/inference/maxdepth maximal depth level, up to which branching rule <inference> should be used (-1 for no limit)
Range: {-1, ..., 65534}
-1
branching/inference/priority priority of branching rule <inference>
Range: {-536870912, ..., 536870911}
1000
branching/inference/useweightedsum should a weighted sum of inference, conflict and cutoff weights be used?
Range: boolean
1
Options for expert users
branching/inference/conflictweight weight in score calculations for conflict score
Range: [0, ∞]
1000
branching/inference/cutoffweight weight in score calculations for cutoff score
Range: [0, ∞]
1
branching/inference/fractionals should branching on LP solution be restricted to the fractional variables?
Range: boolean
1
branching/inference/inferenceweight weight in score calculations for inference score
Range: real
1
branching/inference/reliablescore weight in score calculations for conflict score
Range: [0, ∞]
0.001

branching/leastinf

Option Description Default
branching/leastinf/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
1
branching/leastinf/maxdepth maximal depth level, up to which branching rule <leastinf> should be used (-1 for no limit)
Range: {-1, ..., 65534}
-1
branching/leastinf/priority priority of branching rule <leastinf>
Range: {-536870912, ..., 536870911}
50

branching/lookahead

Option Description Default
branching/lookahead/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
1
branching/lookahead/maxdepth maximal depth level, up to which branching rule <lookahead> should be used (-1 for no limit)
Range: {-1, ..., 65534}
-1
branching/lookahead/priority priority of branching rule <lookahead>
Range: {-536870912, ..., 536870911}
0
Options for expert users
branching/lookahead/abbreviated toggles the abbreviated LAB.
Range: boolean
1
branching/lookahead/abbrevpseudo if abbreviated: Use pseudo costs to estimate the score of a candidate.
Range: boolean
0
branching/lookahead/addbinconsrow should binary constraints be added as rows to the base LP? (0: no, 1: separate, 2: as initial rows)
Range: {0, ..., 2}
0
branching/lookahead/addclique add binary constraints with two variables found at the root node also as a clique
Range: boolean
0
branching/lookahead/addnonviocons should binary constraints, that are not violated by the base LP, be collected and added?
Range: boolean
0
branching/lookahead/applychildbounds should bounds known for child nodes be applied?
Range: boolean
0
branching/lookahead/deeperscoringfunction scoring function to be used at deeper levels
Range: d, f, s, w, l, c, r, x
x
branching/lookahead/enforcemaxdomreds should the maximum number of domain reductions maxnviolateddomreds be enforced?
Range: boolean
0
branching/lookahead/filterbymaxgain should lookahead branching only be applied if the max gain in level 1 is not uniquely that of the best candidate?
Range: boolean
0
branching/lookahead/level2avgscore should the average score be used for uninitialized scores in level 2?
Range: boolean
0
branching/lookahead/level2zeroscore should uninitialized scores in level 2 be set to 0?
Range: boolean
0
branching/lookahead/maxncands if abbreviated: The max number of candidates to consider at the node.
Range: {1, ..., ∞}
4
branching/lookahead/maxndeepercands if abbreviated: The max number of candidates to consider per deeper node.
Range: {0, ..., ∞}
2
branching/lookahead/maxnviolatedbincons how many binary constraints that are violated by the base lp solution should be gathered until the rule is stopped and they are added? [0 for unrestricted]
Range: {0, ..., ∞}
0
branching/lookahead/maxnviolatedcons how many constraints that are violated by the base lp solution should be gathered until the rule is stopped and they are added? [0 for unrestricted]
Range: {0, ..., ∞}
1
branching/lookahead/maxnviolateddomreds how many domain reductions that are violated by the base lp solution should be gathered until the rule is stopped and they are added? [0 for unrestricted]
Range: {0, ..., ∞}
1
branching/lookahead/maxproprounds maximum number of propagation rounds to perform at each temporary node (-1: unlimited, 0: SCIP default)
Range: {-1, ..., ∞}
0
branching/lookahead/mergedomainreductions should domain reductions of feasible siblings should be merged?
Range: boolean
0
branching/lookahead/minweight if scoringfunction is 's', this value is used to weight the min of the gains of two child problems in the convex combination
Range: [0, ∞]
0.8
branching/lookahead/onlyvioldomreds should only domain reductions that violate the LP solution be applied?
Range: boolean
0
branching/lookahead/prefersimplebounds should domain reductions only be applied if there are simple bound changes?
Range: boolean
0
branching/lookahead/propagate should domain propagation be executed before each temporary node is solved?
Range: boolean
1
branching/lookahead/recursiondepth the max depth of LAB.
Range: {1, ..., ∞}
2
branching/lookahead/reevalage max number of LPs solved after which a previous prob branching results are recalculated
Range: {0, ..., ∞}
10
branching/lookahead/reevalagefsb max number of LPs solved after which a previous FSB scoring results are recalculated
Range: {0, ..., ∞}
10
branching/lookahead/reusebasis if abbreviated: Should the information gathered to obtain the best candidates be reused?
Range: boolean
1
branching/lookahead/scoringfunction scoring function to be used at the base level
Range: d, f, s, w, p, l, c, r, a
a
branching/lookahead/scoringscoringfunction scoring function to be used during FSB scoring
Range: d, f, s, w, l, c, r
d
branching/lookahead/storeunviolatedsol if only non violating constraints are added, should the branching decision be stored till the next call?
Range: boolean
1
branching/lookahead/updatebranchingresults should branching results (and scores) be updated w.r.t. proven dual bounds?
Range: boolean
0
branching/lookahead/usedomainreduction should domain reductions be collected and applied?
Range: boolean
1
branching/lookahead/useimpliedbincons should binary constraints be collected and applied?
Range: boolean
0
branching/lookahead/uselevel2data should branching data generated at depth level 2 be stored for re-using it?
Range: boolean
1
branching/lookahead/worsefactor if the FSB score is of a candidate is worse than the best by this factor, skip this candidate (-1: disable)
Range: [-1, ∞]
-1

branching/mostinf

Option Description Default
branching/mostinf/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
1
branching/mostinf/maxdepth maximal depth level, up to which branching rule <mostinf> should be used (-1 for no limit)
Range: {-1, ..., 65534}
-1
branching/mostinf/priority priority of branching rule <mostinf>
Range: {-536870912, ..., 536870911}
100

branching/multaggr

Option Description Default
branching/multaggr/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
1
branching/multaggr/maxdepth maximal depth level, up to which branching rule <multaggr> should be used (-1 for no limit)
Range: {-1, ..., 65534}
-1
branching/multaggr/priority priority of branching rule <multaggr>
Range: {-536870912, ..., 536870911}
0
Options for expert users
branching/multaggr/maxproprounds maximum number of propagation rounds to be performed during multaggr branching before solving the LP (-1: no limit, -2: parameter settings)
Range: {-2, ..., ∞}
0
branching/multaggr/probingbounds should valid bounds be identified in a probing-like fashion during multaggr branching (only with propagation)?
Range: boolean
1
branching/multaggr/reevalage number of intermediate LPs solved to trigger reevaluation of strong branching value for a variable that was already evaluated at the current node
Range: {0, ..., ∞}
0

branching/nodereopt

Option Description Default
branching/nodereopt/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
1
branching/nodereopt/maxdepth maximal depth level, up to which branching rule <nodereopt> should be used (-1 for no limit)
Range: {-1, ..., 65534}
-1
branching/nodereopt/priority priority of branching rule <nodereopt>
Range: {-536870912, ..., 536870911}
-9000000

branching/pscost

Option Description Default
branching/pscost/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
1
branching/pscost/maxdepth maximal depth level, up to which branching rule <pscost> should be used (-1 for no limit)
Range: {-1, ..., 65534}
-1
branching/pscost/narymaxdepth maximal depth where to do n-ary branching, -1 to turn off
Range: {-1, ..., ∞}
-1
branching/pscost/naryminwidth minimal domain width in children when doing n-ary branching, relative to global bounds
Range: [0, 1]
0.001
branching/pscost/narywidthfactor factor of domain width in n-ary branching when creating nodes with increasing distance from branching value
Range: [1, ∞]
2
branching/pscost/nchildren number of children to create in n-ary branching
Range: {2, ..., ∞}
2
branching/pscost/priority priority of branching rule <pscost>
Range: {-536870912, ..., 536870911}
2000
branching/pscost/strategy strategy for utilizing pseudo-costs of external branching candidates (multiply as in pseudo costs 'u'pdate rule, or by 'd'omain reduction, or by domain reduction of 's'ibling, or by 'v'ariable score)
Range: d, s, u, v
u
Options for expert users
branching/pscost/maxscoreweight weight for maximum of scores of a branching candidate when building weighted sum of min/max/sum of scores
Range: real
1.3
branching/pscost/minscoreweight weight for minimum of scores of a branching candidate when building weighted sum of min/max/sum of scores
Range: real
0.8
branching/pscost/sumscoreweight weight for sum of scores of a branching candidate when building weighted sum of min/max/sum of scores
Range: real
0.1

branching/random

Option Description Default
branching/random/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
1
branching/random/maxdepth maximal depth level, up to which branching rule <random> should be used (-1 for no limit)
Range: {-1, ..., 65534}
-1
branching/random/priority priority of branching rule <random>
Range: {-536870912, ..., 536870911}
-100000
branching/random/seed initial random seed value
Range: {0, ..., ∞}
41

branching/relpscost

Option Description Default
branching/relpscost/initcand maximal number of candidates initialized with strong branching per node
Range: {0, ..., ∞}
100
branching/relpscost/inititer iteration limit for strong branching initializations of pseudo cost entries (0: auto)
Range: {0, ..., ∞}
0
branching/relpscost/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
1
branching/relpscost/maxdepth maximal depth level, up to which branching rule <relpscost> should be used (-1 for no limit)
Range: {-1, ..., 65534}
-1
branching/relpscost/priority priority of branching rule <relpscost>
Range: {-536870912, ..., 536870911}
10000
branching/relpscost/sbiterofs additional number of allowed strong branching LP iterations
Range: {0, ..., ∞}
100000
branching/relpscost/sbiterquot maximal fraction of strong branching LP iterations compared to node relaxation LP iterations
Range: [0, ∞]
0.5
Options for expert users
branching/relpscost/confidencelevel the confidence level for statistical methods, between 0 (Min) and 4 (Max).
Range: {0, ..., 4}
2
branching/relpscost/conflictlengthweight weight in score calculations for conflict length score
Range: real
0
branching/relpscost/conflictweight weight in score calculations for conflict score
Range: real
0.01
branching/relpscost/cutoffweight weight in score calculations for cutoff score
Range: real
0.0001
branching/relpscost/degeneracyaware should degeneracy be taken into account to update weights and skip strong branching? (0: off, 1: after root, 2: always)
Range: {0, ..., 2}
1
branching/relpscost/dynamicweights should the weights of the branching rule be adjusted dynamically during solving based on objective and infeasible leaf counters?
Range: boolean
1
branching/relpscost/filtercandssym Use symmetry to filter branching candidates?
Range: boolean
0
branching/relpscost/higherrortol high relative error tolerance for reliability
Range: [0, ∞]
1
branching/relpscost/inferenceweight weight in score calculations for inference score
Range: real
0.0001
branching/relpscost/lowerrortol low relative error tolerance for reliability
Range: [0, ∞]
0.05
branching/relpscost/maxbdchgs maximal number of bound tightenings before the node is reevaluated (-1: unlimited)
Range: {-1, ..., ∞}
5
branching/relpscost/maxlookahead maximal number of further variables evaluated without better score
Range: {1, ..., ∞}
9
branching/relpscost/maxproprounds maximum number of propagation rounds to be performed during strong branching before solving the LP (-1: no limit, -2: parameter settings)
Range: {-2, ..., ∞}
-2
branching/relpscost/maxreliable maximal value for minimum pseudo cost size to regard pseudo cost value as reliable
Range: [0, ∞]
5
branching/relpscost/minreliable minimal value for minimum pseudo cost size to regard pseudo cost value as reliable
Range: [0, ∞]
1
branching/relpscost/nlscoreweight weight in score calculations for nlcount score
Range: real
0.1
branching/relpscost/probingbounds should valid bounds be identified in a probing-like fashion during strong branching (only with propagation)?
Range: boolean
1
branching/relpscost/pscostweight weight in score calculations for pseudo cost score
Range: real
1
branching/relpscost/randinitorder should candidates be initialized in randomized order?
Range: boolean
0
branching/relpscost/skipbadinitcands should branching rule skip candidates that have a low probability to be better than the best strong-branching or pseudo-candidate?
Range: boolean
1
branching/relpscost/startrandseed start seed for random number generation
Range: {0, ..., ∞}
5
branching/relpscost/storesemiinitcosts should strong branching result be considered for pseudo costs if the other direction was infeasible?
Range: boolean
0
branching/relpscost/transsympscost Transfer pscost information to symmetric variables?
Range: boolean
0
branching/relpscost/usedynamicconfidence should the confidence level be adjusted dynamically?
Range: boolean
0
branching/relpscost/usehyptestforreliability should the strong branching decision be based on a hypothesis test?
Range: boolean
0
branching/relpscost/userelerrorreliability should reliability be based on relative errors?
Range: boolean
0
branching/relpscost/usesblocalinfo should the scoring function use only local cutoff and inference information obtained for strong branching candidates?
Range: boolean
0
branching/relpscost/usesmallweightsitlim should smaller weights be used for pseudo cost updates after hitting the LP iteration limit?
Range: boolean
0

branching/treemodel

Option Description Default
branching/treemodel/enable should candidate branching variables be scored using the Treemodel branching rules?
Range: boolean
0
branching/treemodel/height estimated tree height at which we switch from using the low rule to the high rule
Range: {0, ..., ∞}
10
branching/treemodel/highrule scoring function to use at nodes predicted to be high in the tree ('d'efault, 's'vts, 'r'atio, 't'ree sample)
Range: d, s, r, t
r
branching/treemodel/lowrule scoring function to use at nodes predicted to be low in the tree ('d'efault, 's'vts, 'r'atio, 't'ree sample)
Range: d, s, r, t
r
Options for expert users
branching/treemodel/fallbackinf which method should be used as a fallback if the tree size estimates are infinite? ('d'efault, 'r'atio)
Range: d, r
r
branching/treemodel/fallbacknoprim which method should be used as a fallback if there is no primal bound available? ('d'efault, 'r'atio)
Range: d, r
r
branching/treemodel/filterhigh should dominated candidates be filtered before using the high scoring function? ('a'uto, 't'rue, 'f'alse)
Range: a, t, f
a
branching/treemodel/filterlow should dominated candidates be filtered before using the low scoring function? ('a'uto, 't'rue, 'f'alse)
Range: a, t, f
a
branching/treemodel/maxfpiter maximum number of fixed-point iterations when computing the ratio
Range: {1, ..., ∞}
24
branching/treemodel/maxsvtsheight maximum height to compute the SVTS score exactly before approximating
Range: {0, ..., ∞}
100
branching/treemodel/smallpscost threshold at which pseudocosts are considered small, making hybrid scores more likely to be the deciding factor in branching
Range: [0, ∞]
0.1

branching/vanillafullstrong

Option Description Default
branching/vanillafullstrong/idempotent should strong branching side-effects be prevented (e.g., domain changes, stat updates etc.)?
Range: boolean
0
branching/vanillafullstrong/integralcands should integral variables in the current LP solution be considered as branching candidates?
Range: boolean
0
branching/vanillafullstrong/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
1
branching/vanillafullstrong/maxdepth maximal depth level, up to which branching rule <vanillafullstrong> should be used (-1 for no limit)
Range: {-1, ..., 65534}
-1
branching/vanillafullstrong/priority priority of branching rule <vanillafullstrong>
Range: {-536870912, ..., 536870911}
-2000
Options for expert users
branching/vanillafullstrong/collectscores should strong branching scores be collected?
Range: boolean
0
branching/vanillafullstrong/donotbranch should candidates only be scored, but no branching be performed?
Range: boolean
0
branching/vanillafullstrong/scoreall should strong branching scores be computed for all candidates, or can we early stop when a variable has infinite score?
Range: boolean
0

conflict

Option Description Default
conflict/conflictgraphweight the weight the VSIDS score is weight by updating the VSIDS for a variable if it is part of a conflict graph
Range: [0, 1]
1
conflict/conflictweight the weight the VSIDS score is weight by updating the VSIDS for a variable if it is part of a conflict
Range: [0, 1]
0
conflict/enable should conflict analysis be enabled?
Range: boolean
1
conflict/preferbinary should binary conflicts be preferred?
Range: boolean
0
conflict/restartfac factor to increase restartnum with after each restart
Range: [0, ∞]
1.5
conflict/restartnum number of successful conflict analysis calls that trigger a restart (0: disable conflict restarts)
Range: {0, ..., ∞}
0
conflict/sepaaltproofs apply cut generating functions to construct alternative proofs
Range: boolean
0
conflict/useboundlp should bound exceeding LP conflict analysis be used? ('o'ff, 'c'onflict graph, 'd'ual ray, 'b'oth conflict graph and dual ray)
Range: o, c, d, b
b
conflict/useinflp should infeasible LP conflict analysis be used? ('o'ff, 'c'onflict graph, 'd'ual ray, 'b'oth conflict graph and dual ray)
Range: o, c, d, b
b
conflict/useprop should propagation conflict analysis be used?
Range: boolean
1
conflict/usepseudo should pseudo solution conflict analysis be used?
Range: boolean
1
conflict/usesb should infeasible/bound exceeding strong branching conflict analysis be used?
Range: boolean
1
Options for expert users
conflict/allowlocal should conflict constraints be generated that are only valid locally?
Range: boolean
1
conflict/cleanboundexceedings should conflicts based on an old cutoff bound be removed from the conflict pool after improving the primal bound?
Range: boolean
1
conflict/downlockscorefac score factor for down locks in bound relaxation heuristic
Range: real
0
conflict/dynamic should the conflict constraints be subject to aging?
Range: boolean
1
conflict/fuiplevels number of depth levels up to which first UIP's are used in conflict analysis (-1: use All-FirstUIP rule)
Range: {-1, ..., ∞}
-1
conflict/fullshortenconflict try to shorten the whole conflict set or terminate early (depending on the 'maxvarsdetectimpliedbounds' parameter)
Range: boolean
1
conflict/ignorerelaxedbd should relaxed bounds be ignored?
Range: boolean
0
conflict/interconss maximal number of intermediate conflict constraints generated in conflict graph (-1: use every intermediate constraint)
Range: {-1, ..., ∞}
-1
conflict/keepreprop should constraints be kept for repropagation even if they are too long?
Range: boolean
1
conflict/lpiterations maximal number of LP iterations in each LP resolving loop (-1: no limit)
Range: {-1, ..., ∞}
10
conflict/maxconss maximal number of conflict constraints accepted at an infeasible node (-1: use all generated conflict constraints)
Range: {-1, ..., ∞}
10
conflict/maxlploops maximal number of LP resolving loops during conflict analysis (-1: no limit)
Range: {-1, ..., ∞}
2
conflict/maxstoresize maximal size of conflict store (-1: auto, 0: disable storage)
Range: {-1, ..., ∞}
10000
conflict/maxvarsdetectimpliedbounds maximal number of variables to try to detect global bound implications and shorten the whole conflict set (0: disabled)
Range: {0, ..., ∞}
250
conflict/maxvarsfac maximal fraction of variables involved in a conflict constraint
Range: [0, ∞]
0.15
conflict/minimprove minimal improvement of primal bound to remove conflicts based on a previous incumbent
Range: [0, 1]
0.05
conflict/minmaxvars minimal absolute maximum of variables involved in a conflict constraint
Range: {0, ..., ∞}
0
conflict/prefinfproof prefer infeasibility proof to boundexceeding proof
Range: boolean
1
conflict/proofscorefac score factor for impact on acticity in bound relaxation heuristic
Range: real
1
conflict/reconvlevels number of depth levels up to which UIP reconvergence constraints are generated (-1: generate reconvergence constraints in all depth levels)
Range: {-1, ..., ∞}
-1
conflict/removable should the conflict's relaxations be subject to LP aging and cleanup?
Range: boolean
1
conflict/repropagate should earlier nodes be repropagated in order to replace branching decisions by deductions?
Range: boolean
1
conflict/scorefac factor to decrease importance of variables' earlier conflict scores
Range: [1e-06, 1]
0.98
conflict/separate should the conflict constraints be separated?
Range: boolean
1
conflict/settlelocal should conflict constraints be attached only to the local subtree where they can be useful?
Range: boolean
0
conflict/uplockscorefac score factor for up locks in bound relaxation heuristic
Range: real
0
conflict/uselocalrows use local rows to construct infeasibility proofs
Range: boolean
1
conflict/weightrepropdepth weight of the repropagation depth of a conflict used in score calculation
Range: [0, 1]
0.1
conflict/weightsize weight of the size of a conflict used in score calculation
Range: [0, 1]
0.001
conflict/weightvaliddepth weight of the valid depth of a conflict used in score calculation
Range: [0, 1]
1

conflict/bounddisjunction

Option Description Default
conflict/bounddisjunction/continuousfrac maximal percantage of continuous variables within a conflict
Range: [0, 1]
0.4
Options for expert users
conflict/bounddisjunction/priority priority of conflict handler <bounddisjunction>
Range: {-2147483648, ..., ∞}
-3000000

conflict/graph

Option Description Default
Options for expert users
conflict/graph/depthscorefac score factor for depth level in bound relaxation heuristic
Range: real
1

conflict/indicatorconflict

Option Description Default
Options for expert users
conflict/indicatorconflict/priority priority of conflict handler <indicatorconflict>
Range: {-2147483648, ..., ∞}
200000

conflict/linear

Option Description Default
Options for expert users
conflict/linear/priority priority of conflict handler <linear>
Range: {-2147483648, ..., ∞}
-1000000

conflict/logicor

Option Description Default
Options for expert users
conflict/logicor/priority priority of conflict handler <logicor>
Range: {-2147483648, ..., ∞}
800000

conflict/setppc

Option Description Default
Options for expert users
conflict/setppc/priority priority of conflict handler <setppc>
Range: {-2147483648, ..., ∞}
700000

constraints

Option Description Default
Options for expert users
constraints/agelimit maximum age an unnecessary constraint can reach before it is deleted (0: dynamic, -1: keep all constraints)
Range: {-1, ..., ∞}
0
constraints/disableenfops should enforcement of pseudo solution be disabled?
Range: boolean
0
constraints/obsoleteage age of a constraint after which it is marked obsolete (0: dynamic, -1 do not mark constraints obsolete)
Range: {-1, ..., ∞}
-1

constraints/SOS1

Option Description Default
constraints/SOS1/branchnonzeros Branch on SOS constraint with most number of nonzeros?
Range: boolean
0
constraints/SOS1/branchsos Use SOS1 branching in enforcing (otherwise leave decision to branching rules)? This value can only be set to false if all SOS1 variables are binary
Range: boolean
1
constraints/SOS1/branchweight Branch on SOS cons. with highest nonzero-variable weight for branching (needs branchnonzeros = false)?
Range: boolean
0
constraints/SOS1/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
constraints/SOS1/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
10
Options for expert users
constraints/SOS1/addbdsfeas minimal feasibility value for bound inequalities in order to be added to the branching node
Range: real
1
constraints/SOS1/addcomps if TRUE then add complementarity constraints to the branching nodes (can be used in combination with neighborhood or bipartite branching)
Range: boolean
0
constraints/SOS1/addcompsdepth only add complementarity constraints to branching nodes for predefined depth (-1: no limit)
Range: {-1, ..., ∞}
30
constraints/SOS1/addcompsfeas minimal feasibility value for complementarity constraints in order to be added to the branching node
Range: real
-0.6
constraints/SOS1/addextendedbds should added complementarity constraints be extended to SOS1 constraints to get tighter bound inequalities
Range: boolean
1
constraints/SOS1/autocutsfromsos1 if TRUE then automatically switch to separating initial SOS1 constraints if the SOS1 constraints do not overlap
Range: boolean
1
constraints/SOS1/autosos1branch if TRUE then automatically switch to SOS1 branching if the SOS1 constraints do not overlap
Range: boolean
1
constraints/SOS1/boundcutsdepth node depth of separating bound cuts (-1: no limit)
Range: {-1, ..., ∞}
40
constraints/SOS1/boundcutsfreq frequency for separating bound cuts; zero means to separate only in the root node
Range: {-1, ..., 65534}
10
constraints/SOS1/boundcutsfromgraph if TRUE separate bound inequalities from the conflict graph
Range: boolean
1
constraints/SOS1/boundcutsfromsos1 if TRUE separate bound inequalities from initial SOS1 constraints
Range: boolean
0
constraints/SOS1/branchingrule which branching rule should be applied ? ('n': neighborhood, 'b': bipartite, 's': SOS1/clique) (note: in some cases an automatic switching to SOS1 branching is possible)
Range: n, b, s
n
constraints/SOS1/conflictprop whether to use conflict graph propagation
Range: boolean
1
constraints/SOS1/delayprop should propagation method be delayed, if other propagators found reductions?
Range: boolean
0
constraints/SOS1/delaysepa should separation method be delayed, if other separators found cuts?
Range: boolean
0
constraints/SOS1/depthimplanalysis number of recursive calls of implication graph analysis (-1: no limit)
Range: {-1, ..., ∞}
-1
constraints/SOS1/eagerfreq frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534}
100
constraints/SOS1/fixnonzero if neighborhood branching is used, then fix the branching variable (if positive in sign) to the value of the feasibility tolerance
Range: boolean
0
constraints/SOS1/implcutsdepth node depth of separating implied bound cuts (-1: no limit)
Range: {-1, ..., ∞}
40
constraints/SOS1/implcutsfreq frequency for separating implied bound cuts; zero means to separate only in the root node
Range: {-1, ..., 65534}
0
constraints/SOS1/implprop whether to use implication graph propagation
Range: boolean
1
constraints/SOS1/maxaddcomps maximal number of complementarity constraints added per branching node (-1: no limit)
Range: {-1, ..., ∞}
-1
constraints/SOS1/maxboundcuts maximal number of bound cuts separated per branching node
Range: {0, ..., ∞}
50
constraints/SOS1/maxboundcutsroot maximal number of bound cuts separated per iteration in the root node
Range: {0, ..., ∞}
150
constraints/SOS1/maxextensions maximal number of extensions that will be computed for each SOS1 constraint (-1: no limit)
Range: {-1, ..., ∞}
1
constraints/SOS1/maximplcuts maximal number of implied bound cuts separated per branching node
Range: {0, ..., ∞}
50
constraints/SOS1/maximplcutsroot maximal number of implied bound cuts separated per iteration in the root node
Range: {0, ..., ∞}
150
constraints/SOS1/maxprerounds maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
constraints/SOS1/maxsosadjacency do not create an adjacency matrix if number of SOS1 variables is larger than predefined value (-1: no limit)
Range: {-1, ..., ∞}
10000
constraints/SOS1/maxtightenbds maximal number of bound tightening rounds per presolving round (-1: no limit)
Range: {-1, ..., ∞}
5
constraints/SOS1/nstrongiter maximal number LP iterations to perform for each strong branching round (-2: auto, -1: no limit)
Range: {-2, ..., ∞}
10000
constraints/SOS1/nstrongrounds maximal number of strong branching rounds to perform for each node (-1: auto); only available for neighborhood and bipartite branching
Range: {-1, ..., ∞}
0
constraints/SOS1/perfimplanalysis if TRUE then perform implication graph analysis (might add additional SOS1 constraints)
Range: boolean
0
constraints/SOS1/presoltiming timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
8
constraints/SOS1/proptiming timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15}
1
constraints/SOS1/sosconsprop whether to use SOS1 constraint propagation
Range: boolean
0
constraints/SOS1/strthenboundcuts if TRUE then bound cuts are strengthened in case bound variables are available
Range: boolean
1

constraints/SOS2

Option Description Default
constraints/SOS2/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
constraints/SOS2/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
0
Options for expert users
constraints/SOS2/delayprop should propagation method be delayed, if other propagators found reductions?
Range: boolean
0
constraints/SOS2/delaysepa should separation method be delayed, if other separators found cuts?
Range: boolean
0
constraints/SOS2/eagerfreq frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534}
100
constraints/SOS2/maxprerounds maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
constraints/SOS2/presoltiming timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
4
constraints/SOS2/proptiming timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15}
1

constraints/abspower

Option Description Default
constraints/abspower/branchminconverror whether to compute branching point such that the convexification error is minimized (after branching on 0.0)
Range: boolean
0
constraints/abspower/cutmaxrange maximal coef range of a cut (maximal coefficient divided by minimal coefficient) in order to be added to LP relaxation
Range: [0, ∞]
1e+07
constraints/abspower/dualpresolve should dual presolve be applied?
Range: boolean
1
constraints/abspower/linfeasshift whether to try to make solutions in check function feasible by shifting the linear variable z
Range: boolean
1
constraints/abspower/preferzerobranch how much to prefer branching on 0.0 when sign of variable is not fixed yet: 0 no preference, 1 prefer if LP solution will be cutoff in both child nodes, 2 prefer always, 3 ensure always
Range: {0, ..., 3}
1
constraints/abspower/projectrefpoint whether to project the reference point when linearizing an absolute power constraint in a convex region
Range: boolean
1
constraints/abspower/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
constraints/abspower/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
constraints/abspower/sepainboundsonly whether to separate linearization cuts only in the variable bounds (does not affect enforcement)
Range: boolean
0
constraints/abspower/sepanlpmincont minimal required fraction of continuous variables in problem to use solution of NLP relaxation in root for separation
Range: [0, 2]
1
Options for expert users
constraints/abspower/addvarboundcons should variable bound constraints be added for derived variable bounds?
Range: boolean
1
constraints/abspower/delayprop should propagation method be delayed, if other propagators found reductions?
Range: boolean
0
constraints/abspower/delaysepa should separation method be delayed, if other separators found cuts?
Range: boolean
0
constraints/abspower/eagerfreq frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534}
100
constraints/abspower/enfocutsremovable are cuts added during enforcement removable from the LP in the same node?
Range: boolean
0
constraints/abspower/maxprerounds maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
constraints/abspower/presoltiming timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
12
constraints/abspower/proptiming timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15}
15

constraints/and

Option Description Default
constraints/and/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
constraints/and/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
Options for expert users
constraints/and/aggrlinearization should an aggregated linearization be used?
Range: boolean
0
constraints/and/delayprop should propagation method be delayed, if other propagators found reductions?
Range: boolean
0
constraints/and/delaysepa should separation method be delayed, if other separators found cuts?
Range: boolean
0
constraints/and/dualpresolving should dual presolving be performed?
Range: boolean
1
constraints/and/eagerfreq frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534}
100
constraints/and/enforcecuts should cuts be separated during LP enforcing?
Range: boolean
1
constraints/and/linearize should the AND-constraint get linearized and removed (in presolving)?
Range: boolean
0
constraints/and/maxprerounds maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
constraints/and/presolpairwise should pairwise constraint comparison be performed in presolving?
Range: boolean
1
constraints/and/presoltiming timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
20
constraints/and/presolusehashing should hash table be used for detecting redundant constraints in advance
Range: boolean
1
constraints/and/proptiming timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15}
1
constraints/and/upgraderesultant should all binary resultant variables be upgraded to implicit binary variables?
Range: boolean
1

constraints/bivariate

Option Description Default
constraints/bivariate/linfeasshift whether to try to make solutions in check function feasible by shifting a linear variable (esp. useful if constraint was actually objective function)
Range: boolean
1
constraints/bivariate/maxproprounds limit on number of propagation rounds for a single constraint within one round of SCIP propagation
Range: {0, ..., ∞}
1
constraints/bivariate/ninitlprefpoints number of reference points in each direction where to compute linear support for envelope in LP initialization
Range: {0, ..., ∞}
3
constraints/bivariate/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
constraints/bivariate/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
Options for expert users
constraints/bivariate/cutmaxrange maximal coef range of a cut (maximal coefficient divided by minimal coefficient) in order to be added to LP relaxation
Range: [0, ∞]
1e+07
constraints/bivariate/delayprop should propagation method be delayed, if other propagators found reductions?
Range: boolean
0
constraints/bivariate/delaysepa should separation method be delayed, if other separators found cuts?
Range: boolean
0
constraints/bivariate/eagerfreq frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534}
100
constraints/bivariate/enfocutsremovable are cuts added during enforcement removable from the LP in the same node?
Range: boolean
0
constraints/bivariate/maxprerounds maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
constraints/bivariate/presoltiming timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
4
constraints/bivariate/proptiming timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15}
1

constraints/bounddisjunction

Option Description Default
constraints/bounddisjunction/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
constraints/bounddisjunction/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
-1
Options for expert users
constraints/bounddisjunction/delayprop should propagation method be delayed, if other propagators found reductions?
Range: boolean
0
constraints/bounddisjunction/delaysepa should separation method be delayed, if other separators found cuts?
Range: boolean
0
constraints/bounddisjunction/eagerfreq frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534}
100
constraints/bounddisjunction/maxprerounds maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
constraints/bounddisjunction/presoltiming timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
4
constraints/bounddisjunction/proptiming timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15}
1

constraints/components

Option Description Default
constraints/components/intfactor the weight of an integer variable compared to binary variables
Range: [0, ∞]
1
constraints/components/maxdepth maximum depth of a node to run components detection (-1: disable component detection during solving)
Range: {-1, ..., ∞}
-1
constraints/components/nodelimit maximum number of nodes to be solved in subproblems during presolving
Range: {-1, ..., ∞}
10000
constraints/components/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
constraints/components/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
-1
Options for expert users
constraints/components/delayprop should propagation method be delayed, if other propagators found reductions?
Range: boolean
1
constraints/components/delaysepa should separation method be delayed, if other separators found cuts?
Range: boolean
0
constraints/components/eagerfreq frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534}
-1
constraints/components/feastolfactor factor to increase the feasibility tolerance of the main SCIP in all sub-SCIPs, default value 1.0
Range: [0, 1e+06]
1
constraints/components/maxintvars maximum number of integer (or binary) variables to solve a subproblem during presolving (-1: unlimited)
Range: {-1, ..., ∞}
500
constraints/components/maxprerounds maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
constraints/components/minrelsize minimum relative size (in terms of variables) to solve a component individually during branch-and-bound
Range: [0, 1]
0.1
constraints/components/minsize minimum absolute size (in terms of variables) to solve a component individually during branch-and-bound
Range: {0, ..., ∞}
50
constraints/components/presoltiming timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
32
constraints/components/proptiming timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15}
1

constraints/indicator

Option Description Default
constraints/indicator/maxsepacuts maximal number of cuts separated per separation round
Range: {0, ..., ∞}
100
constraints/indicator/maxsepacutsroot maximal number of cuts separated per separation round in the root node
Range: {0, ..., ∞}
2000
constraints/indicator/maxsepanonviolated maximal number of separated non violated IISs, before separation is stopped
Range: {0, ..., ∞}
3
constraints/indicator/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
constraints/indicator/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
10
Options for expert users
constraints/indicator/addcoupling Add coupling constraints or rows if big-M is small enough?
Range: boolean
1
constraints/indicator/addcouplingcons Add initial variable upper bound constraints, if 'addcoupling' is true?
Range: boolean
0
constraints/indicator/addopposite Add opposite inequality in nodes in which the binary variable has been fixed to 0?
Range: boolean
0
constraints/indicator/branchindicators Branch on indicator constraints in enforcing?
Range: boolean
0
constraints/indicator/conflictsupgrade Try to upgrade bounddisjunction conflicts by replacing slack variables?
Range: boolean
0
constraints/indicator/delayprop should propagation method be delayed, if other propagators found reductions?
Range: boolean
0
constraints/indicator/delaysepa should separation method be delayed, if other separators found cuts?
Range: boolean
0
constraints/indicator/dualreductions Should dual reduction steps be performed?
Range: boolean
1
constraints/indicator/eagerfreq frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534}
100
constraints/indicator/enforcecuts In enforcing try to generate cuts (only if sepaalternativelp is true)?
Range: boolean
0
constraints/indicator/forcerestart Force restart if absolute gap is 1 or enough binary variables have been fixed?
Range: boolean
0
constraints/indicator/generatebilinear Do not generate indicator constraint, but a bilinear constraint instead?
Range: boolean
0
constraints/indicator/genlogicor Generate logicor constraints instead of cuts?
Range: boolean
0
constraints/indicator/maxconditionaltlp maximum estimated condition of the solution basis matrix of the alternative LP to be trustworthy (0.0 to disable check)
Range: [0, ∞]
0
constraints/indicator/maxcouplingvalue maximum coefficient for binary variable in coupling constraint
Range: [0, 1e+09]
10000
constraints/indicator/maxprerounds maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
constraints/indicator/nolinconscont Decompose problem (do not generate linear constraint if all variables are continuous)?
Range: boolean
0
constraints/indicator/presoltiming timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
4
constraints/indicator/proptiming timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15}
1
constraints/indicator/removeindicators Remove indicator constraint if corresponding variable bound constraint has been added?
Range: boolean
0
constraints/indicator/restartfrac fraction of binary variables that need to be fixed before restart occurs (in forcerestart)
Range: [0, 1]
0.9
constraints/indicator/scaleslackvar Scale slack variable coefficient at construction time?
Range: boolean
0
constraints/indicator/sepaalternativelp Separate using the alternative LP?
Range: boolean
0
constraints/indicator/sepacouplingcuts Should the coupling inequalities be separated dynamically?
Range: boolean
1
constraints/indicator/sepacouplinglocal Allow to use local bounds in order to separate coupling inequalities?
Range: boolean
0
constraints/indicator/sepacouplingvalue maximum coefficient for binary variable in separated coupling constraint
Range: [0, 1e+09]
10000
constraints/indicator/sepaperspective Separate cuts based on perspective formulation?
Range: boolean
0
constraints/indicator/sepapersplocal Allow to use local bounds in order to separate perspective cuts?
Range: boolean
1
constraints/indicator/trysolfromcover Try to construct a feasible solution from a cover?
Range: boolean
0
constraints/indicator/trysolutions Try to make solutions feasible by setting indicator variables?
Range: boolean
1
constraints/indicator/updatebounds Update bounds of original variables for separation?
Range: boolean
0
constraints/indicator/upgradelinear Try to upgrade linear constraints to indicator constraints?
Range: boolean
0
constraints/indicator/useobjectivecut Use objective cut with current best solution to alternative LP?
Range: boolean
0
constraints/indicator/useotherconss Collect other constraints to alternative LP?
Range: boolean
0

constraints/integral

Option Description Default
constraints/integral/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
-1
constraints/integral/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
-1
Options for expert users
constraints/integral/delayprop should propagation method be delayed, if other propagators found reductions?
Range: boolean
0
constraints/integral/delaysepa should separation method be delayed, if other separators found cuts?
Range: boolean
0
constraints/integral/eagerfreq frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534}
-1
constraints/integral/maxprerounds maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞}
0
constraints/integral/presoltiming timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
28
constraints/integral/proptiming timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15}
1

constraints/knapsack

Option Description Default
constraints/knapsack/maxrounds maximal number of separation rounds per node (-1: unlimited)
Range: {-1, ..., ∞}
5
constraints/knapsack/maxroundsroot maximal number of separation rounds per node in the root node (-1: unlimited)
Range: {-1, ..., ∞}
-1
constraints/knapsack/maxsepacuts maximal number of cuts separated per separation round
Range: {0, ..., ∞}
50
constraints/knapsack/maxsepacutsroot maximal number of cuts separated per separation round in the root node
Range: {0, ..., ∞}
200
constraints/knapsack/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
constraints/knapsack/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
0
Options for expert users
constraints/knapsack/cliqueextractfactor lower clique size limit for greedy clique extraction algorithm (relative to largest clique)
Range: [0, 1]
0.5
constraints/knapsack/clqpartupdatefac factor on the growth of global cliques to decide when to update a previous (negated) clique partition (used only if updatecliquepartitions is set to TRUE)
Range: [1, 10]
1.5
constraints/knapsack/delayprop should propagation method be delayed, if other propagators found reductions?
Range: boolean
0
constraints/knapsack/delaysepa should separation method be delayed, if other separators found cuts?
Range: boolean
0
constraints/knapsack/detectcutoffbound should presolving try to detect constraints parallel to the objective function defining an upper bound and prevent these constraints from entering the LP?
Range: boolean
1
constraints/knapsack/detectlowerbound should presolving try to detect constraints parallel to the objective function defining a lower bound and prevent these constraints from entering the LP?
Range: boolean
1
constraints/knapsack/disaggregation should disaggregation of knapsack constraints be allowed in preprocessing?
Range: boolean
1
constraints/knapsack/dualpresolving should dual presolving steps be performed?
Range: boolean
1
constraints/knapsack/eagerfreq frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534}
100
constraints/knapsack/maxcardbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for separating knapsack cuts
Range: [0, 1]
0
constraints/knapsack/maxprerounds maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
constraints/knapsack/negatedclique should negated clique information be used in solving process
Range: boolean
1
constraints/knapsack/presolpairwise should pairwise constraint comparison be performed in presolving?
Range: boolean
1
constraints/knapsack/presoltiming timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
28
constraints/knapsack/presolusehashing should hash table be used for detecting redundant constraints in advance
Range: boolean
1
constraints/knapsack/proptiming timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15}
1
constraints/knapsack/sepacardfreq multiplier on separation frequency, how often knapsack cuts are separated (-1: never, 0: only at root)
Range: {-1, ..., 65534}
1
constraints/knapsack/simplifyinequalities should presolving try to simplify knapsacks
Range: boolean
1
constraints/knapsack/updatecliquepartitions should clique partition information be updated when old partition seems outdated?
Range: boolean
0
constraints/knapsack/usegubs should GUB information be used for separation?
Range: boolean
0

constraints/linear

Option Description Default
constraints/linear/maxrounds maximal number of separation rounds per node (-1: unlimited)
Range: {-1, ..., ∞}
5
constraints/linear/maxroundsroot maximal number of separation rounds per node in the root node (-1: unlimited)
Range: {-1, ..., ∞}
-1
constraints/linear/maxsepacuts maximal number of cuts separated per separation round
Range: {0, ..., ∞}
50
constraints/linear/maxsepacutsroot maximal number of cuts separated per separation round in the root node
Range: {0, ..., ∞}
200
constraints/linear/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
constraints/linear/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
0
constraints/linear/separateall should all constraints be subject to cardinality cut generation instead of only the ones with non-zero dual value?
Range: boolean
0
Options for expert users
constraints/linear/aggregatevariables should presolving search for aggregations in equations
Range: boolean
1
constraints/linear/checkrelmaxabs should the violation for a constraint with side 0.0 be checked relative to 1.0 (FALSE) or to the maximum absolute value in the activity (TRUE)?
Range: boolean
0
constraints/linear/delayprop should propagation method be delayed, if other propagators found reductions?
Range: boolean
0
constraints/linear/delaysepa should separation method be delayed, if other separators found cuts?
Range: boolean
0
constraints/linear/detectcutoffbound should presolving try to detect constraints parallel to the objective function defining an upper bound and prevent these constraints from entering the LP?
Range: boolean
1
constraints/linear/detectlowerbound should presolving try to detect constraints parallel to the objective function defining a lower bound and prevent these constraints from entering the LP?
Range: boolean
1
constraints/linear/detectpartialobjective should presolving try to detect subsets of constraints parallel to the objective function?
Range: boolean
1
constraints/linear/dualpresolving should dual presolving steps be performed?
Range: boolean
1
constraints/linear/eagerfreq frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534}
100
constraints/linear/extractcliques should Cliques be extracted?
Range: boolean
1
constraints/linear/maxaggrnormscale maximal allowed relative gain in maximum norm for constraint aggregation (0.0: disable constraint aggregation)
Range: [0, ∞]
0
constraints/linear/maxcardbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for separating knapsack cardinality cuts
Range: [0, 1]
0
constraints/linear/maxdualmultaggrquot maximum coefficient dynamism (ie. maxabsval / minabsval) for dual multiaggregation
Range: [1, ∞]
constraints/linear/maxeasyactivitydelta maximum activity delta to run easy propagation on linear constraint (faster, but numerically less stable)
Range: [0, ∞]
1e+06
constraints/linear/maxmultaggrquot maximum coefficient dynamism (ie. maxabsval / minabsval) for primal multiaggregation
Range: [1, ∞]
1000
constraints/linear/maxprerounds maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
constraints/linear/mingainpernmincomparisons minimal gain per minimal pairwise presolve comparisons to repeat pairwise comparison round
Range: [0, 1]
1e-06
constraints/linear/multaggrremove should multi-aggregations only be performed if the constraint can be removed afterwards?
Range: boolean
0
constraints/linear/nmincomparisons number for minimal pairwise presolve comparisons
Range: {1, ..., ∞}
200000
constraints/linear/presolpairwise should pairwise constraint comparison be performed in presolving?
Range: boolean
1
constraints/linear/presoltiming timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
20
constraints/linear/presolusehashing should hash table be used for detecting redundant constraints in advance
Range: boolean
1
constraints/linear/proptiming timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15}
1
constraints/linear/rangedrowartcons should presolving and propagation extract sub-constraints from ranged rows and equations?
Range: boolean
1
constraints/linear/rangedrowfreq frequency for applying ranged row propagation
Range: {1, ..., 65534}
1
constraints/linear/rangedrowmaxdepth maximum depth to apply ranged row propagation
Range: {0, ..., ∞}
constraints/linear/rangedrowpropagation should presolving and propagation try to improve bounds, detect infeasibility, and extract sub-constraints from ranged rows and equations?
Range: boolean
1
constraints/linear/simplifyinequalities should presolving try to simplify inequalities
Range: boolean
1
constraints/linear/singletonstuffing should stuffing of singleton continuous variables be performed?
Range: boolean
1
constraints/linear/singlevarstuffing should single variable stuffing be performed, which tries to fulfill constraints using the cheapest variable?
Range: boolean
0
constraints/linear/sortvars apply binaries sorting in decr. order of coeff abs value?
Range: boolean
1
constraints/linear/tightenboundsfreq multiplier on propagation frequency, how often the bounds are tightened (-1: never, 0: only at root)
Range: {-1, ..., 65534}
1

constraints/linear/upgrade

Option Description Default
constraints/linear/upgrade/indicator enable linear upgrading for constraint handler <indicator>
Range: boolean
1
constraints/linear/upgrade/knapsack enable linear upgrading for constraint handler <knapsack>
Range: boolean
1
constraints/linear/upgrade/logicor enable linear upgrading for constraint handler <logicor>
Range: boolean
1
constraints/linear/upgrade/setppc enable linear upgrading for constraint handler <setppc>
Range: boolean
1
constraints/linear/upgrade/varbound enable linear upgrading for constraint handler <varbound>
Range: boolean
1
constraints/linear/upgrade/xor enable linear upgrading for constraint handler <xor>
Range: boolean
1

constraints/logicor

Option Description Default
constraints/logicor/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
constraints/logicor/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
0
Options for expert users
constraints/logicor/delayprop should propagation method be delayed, if other propagators found reductions?
Range: boolean
0
constraints/logicor/delaysepa should separation method be delayed, if other separators found cuts?
Range: boolean
0
constraints/logicor/dualpresolving should dual presolving steps be performed?
Range: boolean
1
constraints/logicor/eagerfreq frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534}
100
constraints/logicor/implications should implications/cliques be used in presolving
Range: boolean
1
constraints/logicor/maxprerounds maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
constraints/logicor/negatedclique should negated clique information be used in presolving
Range: boolean
1
constraints/logicor/presolpairwise should pairwise constraint comparison be performed in presolving?
Range: boolean
1
constraints/logicor/presoltiming timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
28
constraints/logicor/presolusehashing should hash table be used for detecting redundant constraints in advance
Range: boolean
1
constraints/logicor/proptiming timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15}
1
constraints/logicor/strengthen should pairwise constraint comparison try to strengthen constraints by removing superflous non-zeros?
Range: boolean
1

constraints/nonlinear

Option Description Default
constraints/nonlinear/cutmaxrange maximal coef range of a cut (maximal coefficient divided by minimal coefficient) in order to be added to LP relaxation
Range: [0, ∞]
1e+07
constraints/nonlinear/linfeasshift whether to try to make solutions in check function feasible by shifting a linear variable (esp. useful if constraint was actually objective function)
Range: boolean
1
constraints/nonlinear/maxproprounds limit on number of propagation rounds for a single constraint within one round of SCIP propagation
Range: {0, ..., ∞}
1
constraints/nonlinear/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
constraints/nonlinear/reformulate whether to reformulate expression graph
Range: boolean
1
constraints/nonlinear/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
constraints/nonlinear/sepanlpmincont minimal required fraction of continuous variables in problem to use solution of NLP relaxation in root for separation
Range: [0, 2]
1
Options for expert users
constraints/nonlinear/assumeconvex whether to assume that nonlinear functions in inequalities (≤) are convex (disables reformulation)
Range: boolean
0
constraints/nonlinear/delayprop should propagation method be delayed, if other propagators found reductions?
Range: boolean
0
constraints/nonlinear/delaysepa should separation method be delayed, if other separators found cuts?
Range: boolean
0
constraints/nonlinear/eagerfreq frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534}
100
constraints/nonlinear/enfocutsremovable are cuts added during enforcement removable from the LP in the same node?
Range: boolean
0
constraints/nonlinear/maxexpansionexponent maximal exponent where still expanding non-monomial polynomials in expression simplification
Range: {1, ..., ∞}
2
constraints/nonlinear/maxprerounds maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
constraints/nonlinear/presoltiming timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
28
constraints/nonlinear/proptiming timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15}
1

constraints/nonlinear/upgrade

Option Description Default
constraints/nonlinear/upgrade/abspower enable nonlinear upgrading for constraint handler <abspower>
Range: boolean
1
constraints/nonlinear/upgrade/and enable nonlinear upgrading for constraint handler <and>
Range: boolean
1
constraints/nonlinear/upgrade/bivariate enable nonlinear upgrading for constraint handler <bivariate>
Range: boolean
0
constraints/nonlinear/upgrade/linear enable nonlinear upgrading for constraint handler <linear>
Range: boolean
1
constraints/nonlinear/upgrade/quadratic enable nonlinear upgrading for constraint handler <quadratic>
Range: boolean
1

constraints/orbisack

Option Description Default
constraints/orbisack/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
5
constraints/orbisack/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
5
Options for expert users
constraints/orbisack/checkpporbisack Upgrade orbisack constraints to packing/partioning orbisacks?
Range: boolean
1
constraints/orbisack/coeffbound Maximum size of coefficients for orbisack inequalities
Range: [0, ∞]
1e+06
constraints/orbisack/coverseparation Separate cover inequalities for orbisacks?
Range: boolean
1
constraints/orbisack/delayprop should propagation method be delayed, if other propagators found reductions?
Range: boolean
0
constraints/orbisack/delaysepa should separation method be delayed, if other separators found cuts?
Range: boolean
0
constraints/orbisack/eagerfreq frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534}
-1
constraints/orbisack/forceconscopy Whether orbisack constraints should be forced to be copied to sub SCIPs.
Range: boolean
0
constraints/orbisack/maxprerounds maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
constraints/orbisack/orbiSeparation Separate orbisack inequalities?
Range: boolean
0
constraints/orbisack/presoltiming timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
16
constraints/orbisack/proptiming timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15}
1

constraints/orbitope

Option Description Default
constraints/orbitope/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
constraints/orbitope/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
-1
Options for expert users
constraints/orbitope/checkpporbitope Strengthen orbitope constraints to packing/partioning orbitopes?
Range: boolean
1
constraints/orbitope/delayprop should propagation method be delayed, if other propagators found reductions?
Range: boolean
0
constraints/orbitope/delaysepa should separation method be delayed, if other separators found cuts?
Range: boolean
0
constraints/orbitope/eagerfreq frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534}
-1
constraints/orbitope/forceconscopy Whether orbitope constraints should be forced to be copied to sub SCIPs.
Range: boolean
0
constraints/orbitope/maxprerounds maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
constraints/orbitope/presoltiming timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
8
constraints/orbitope/proptiming timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15}
1
constraints/orbitope/sepafullorbitope Whether we separate inequalities for full orbitopes?
Range: boolean
0
constraints/orbitope/usedynamicprop Whether we use a dynamic version of the propagation routine.
Range: boolean
1

constraints/quadratic

Option Description Default
constraints/quadratic/binreformbinaryonly whether to consider only binary variables when replacing products with binary variables
Range: boolean
1
constraints/quadratic/checkcurvature whether multivariate quadratic functions should be checked for convexity/concavity
Range: boolean
1
constraints/quadratic/empathy4and empathy level for using the AND constraint handler: 0 always avoid using AND; 1 use AND sometimes; 2 use AND as often as possible
Range: {0, ..., 2}
2
constraints/quadratic/gaugecuts should convex quadratics generated strong cuts via gauge function?
Range: boolean
0
constraints/quadratic/maxdisaggrsize maximum number of created constraints when disaggregating a quadratic constraint (≤ 1: off)
Range: {1, ..., ∞}
1
constraints/quadratic/minscorebilinterms minimal required score in order to use linear inequalities for tighter bilinear relaxations
Range: [0, 1]
0.01
constraints/quadratic/projectedcuts should convex quadratics generated strong cuts via projections?
Range: boolean
0
constraints/quadratic/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
constraints/quadratic/replacebinaryprod max. length of linear term which when multiplied with a binary variables is replaced by an auxiliary variable and a linear reformulation (0 to turn off)
Range: {0, ..., ∞}
constraints/quadratic/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
constraints/quadratic/sepanlpmincont minimal required fraction of continuous variables in problem to use solution of NLP relaxation in root for separation
Range: [0, 2]
1
constraints/quadratic/usebilinineqbranch should linear inequalities be consindered when computing the branching scores for bilinear terms?
Range: boolean
0
Options for expert users
constraints/quadratic/bilinineqmaxseparounds maximum number of separation rounds to use linear inequalities for the bilinear term relaxation in a local node
Range: {0, ..., ∞}
3
constraints/quadratic/binreforminitial whether to make non-varbound linear constraints added due to replacing products with binary variables initial
Range: boolean
0
constraints/quadratic/binreformmaxcoef limit (as factor on 1/feastol) on coefficients and coef. range in linear constraints created when replacing products with binary variables
Range: [0, ∞]
0.0001
constraints/quadratic/branchscoring which score to give branching candidates: convexification 'g'ap, constraint 'v'iolation, 'c'entrality of variable value in domain
Range: c, g, v
g
constraints/quadratic/checkfactorable whether constraint functions should be checked to be factorable
Range: boolean
1
constraints/quadratic/checkquadvarlocks whether quadratic variables contained in a single constraint should be forced to be at their lower or upper bounds ('d'isable, change 't'ype, add 'b'ound disjunction)
Range: b, d, t
t
constraints/quadratic/cutmaxrange maximal coef range of a cut (maximal coefficient divided by minimal coefficient) in order to be added to LP relaxation
Range: [0, ∞]
1e+07
constraints/quadratic/delayprop should propagation method be delayed, if other propagators found reductions?
Range: boolean
0
constraints/quadratic/delaysepa should separation method be delayed, if other separators found cuts?
Range: boolean
0
constraints/quadratic/disaggrmergemethod strategy how to merge independent blocks to reach maxdisaggrsize limit (keep 'b'iggest blocks and merge others; keep 's'mallest blocks and merge other; merge small blocks into bigger blocks to reach 'm'ean sizes)
Range: b, m, s
m
constraints/quadratic/eagerfreq frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534}
100
constraints/quadratic/enfocutsremovable are cuts added during enforcement removable from the LP in the same node?
Range: boolean
0
constraints/quadratic/enfolplimit maximum number of enforcement rounds before declaring the LP relaxation infeasible (-1: no limit); WARNING: changing this parameter might lead to incorrect results!
Range: {-1, ..., ∞}
-1
constraints/quadratic/interiorcomputation how the interior point for gauge cuts should be computed: 'a'ny point per constraint, 'm'ost interior per constraint
Range: a, m
a
constraints/quadratic/linearizeheursol whether linearizations of convex quadratic constraints should be added to cutpool in a solution found by some heuristic
Range: boolean
1
constraints/quadratic/linfeasshift whether to try to make solutions in check function feasible by shifting a linear variable (esp. useful if constraint was actually objective function)
Range: boolean
1
constraints/quadratic/maxprerounds maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
constraints/quadratic/maxproprounds limit on number of propagation rounds for a single constraint within one round of SCIP propagation during solve
Range: {0, ..., ∞}
1
constraints/quadratic/maxproproundspresolve limit on number of propagation rounds for a single constraint within one round of SCIP presolve
Range: {0, ..., ∞}
10
constraints/quadratic/mincurvcollectbilinterms minimal curvature of constraints to be considered when returning bilinear terms to other plugins
Range: real
0.8
constraints/quadratic/presoltiming timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
28
constraints/quadratic/proptiming timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15}
1

constraints/quadratic/upgrade

Option Description Default
constraints/quadratic/upgrade/abspower enable quadratic upgrading for constraint handler <abspower>
Range: boolean
1
constraints/quadratic/upgrade/bivariate enable quadratic upgrading for constraint handler <bivariate>
Range: boolean
0
constraints/quadratic/upgrade/bounddisjunction enable quadratic upgrading for constraint handler <bounddisjunction>
Range: boolean
1
constraints/quadratic/upgrade/linear enable quadratic upgrading for constraint handler <linear>
Range: boolean
1
constraints/quadratic/upgrade/setppc enable quadratic upgrading for constraint handler <setppc>
Range: boolean
1
constraints/quadratic/upgrade/soc enable quadratic upgrading for constraint handler <soc>
Range: boolean
1

constraints/setppc

Option Description Default
constraints/setppc/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
constraints/setppc/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
0
Options for expert users
constraints/setppc/addvariablesascliques should we try to generate extra cliques out of all binary variables to maybe fasten redundant constraint detection
Range: boolean
0
constraints/setppc/cliquelifting should we try to lift variables into other clique constraints, fix variables, aggregate them, and also shrink the amount of variables in clique constraints
Range: boolean
0
constraints/setppc/cliqueshrinking should we try to shrink the number of variables in a clique constraints, by replacing more than one variable by only one
Range: boolean
1
constraints/setppc/delayprop should propagation method be delayed, if other propagators found reductions?
Range: boolean
0
constraints/setppc/delaysepa should separation method be delayed, if other separators found cuts?
Range: boolean
0
constraints/setppc/dualpresolving should dual presolving steps be performed?
Range: boolean
1
constraints/setppc/eagerfreq frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534}
100
constraints/setppc/maxprerounds maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
constraints/setppc/npseudobranches number of children created in pseudo branching (0: disable pseudo branching)
Range: {0, ..., ∞}
2
constraints/setppc/presolpairwise should pairwise constraint comparison be performed in presolving?
Range: boolean
1
constraints/setppc/presoltiming timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
28
constraints/setppc/presolusehashing should hash table be used for detecting redundant constraints in advance
Range: boolean
1
constraints/setppc/proptiming timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15}
1

constraints/soc

Option Description Default
constraints/soc/glineur whether the Glineur Outer Approximation should be used instead of Ben-Tal Nemirovski
Range: boolean
1
constraints/soc/linfeasshift whether to try to make solutions feasible in check by shifting the variable on the right hand side
Range: boolean
1
constraints/soc/nauxvars number of auxiliary variables to use when creating a linear outer approx. of a SOC3 constraint; 0 to turn off
Range: {0, ..., ∞}
0
constraints/soc/nlpform which formulation to use when adding a SOC constraint to the NLP (a: automatic, q: nonconvex quadratic form, s: convex sqrt form, e: convex exponential-sqrt form, d: convex division form)
Range: a, q, s, e, d
a
constraints/soc/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
constraints/soc/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
constraints/soc/sepanlpmincont minimal required fraction of continuous variables in problem to use solution of NLP relaxation in root for separation
Range: [0, 2]
1
Options for expert users
constraints/soc/delayprop should propagation method be delayed, if other propagators found reductions?
Range: boolean
0
constraints/soc/delaysepa should separation method be delayed, if other separators found cuts?
Range: boolean
0
constraints/soc/disaggregate try to completely disaggregate soc?
Range: boolean
1
constraints/soc/eagerfreq frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534}
100
constraints/soc/enfocutsremovable are cuts added during enforcement removable from the LP in the same node?
Range: boolean
0
constraints/soc/generalsocupgrade try to upgrade more general quadratics to soc?
Range: boolean
1
constraints/soc/maxprerounds maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
constraints/soc/presoltiming timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
28
constraints/soc/projectpoint whether the reference point of a cut should be projected onto the feasible set of the SOC constraint
Range: boolean
0
constraints/soc/proptiming timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15}
1
constraints/soc/sparsify whether to sparsify cuts
Range: boolean
0
constraints/soc/sparsifymaxloss maximal loss in cut efficacy by sparsification
Range: [0, 1]
0.2
constraints/soc/sparsifynzgrowth growth rate of maximal allowed nonzeros in cuts in sparsification
Range: [1, ∞]
1.3

constraints/symresack

Option Description Default
constraints/symresack/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
5
constraints/symresack/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
5
Options for expert users
constraints/symresack/checkmonotonicity Check whether permutation is monotone when upgrading to packing/partioning symresacks?
Range: boolean
1
constraints/symresack/delayprop should propagation method be delayed, if other propagators found reductions?
Range: boolean
0
constraints/symresack/delaysepa should separation method be delayed, if other separators found cuts?
Range: boolean
0
constraints/symresack/eagerfreq frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534}
-1
constraints/symresack/forceconscopy Whether symresack constraints should be forced to be copied to sub SCIPs.
Range: boolean
0
constraints/symresack/maxprerounds maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
constraints/symresack/ppsymresack Upgrade symresack constraints to packing/partioning symresacks?
Range: boolean
1
constraints/symresack/presoltiming timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
16
constraints/symresack/proptiming timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15}
1

constraints/varbound

Option Description Default
constraints/varbound/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
constraints/varbound/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
0
constraints/varbound/usebdwidening should bound widening be used in conflict analysis?
Range: boolean
1
Options for expert users
constraints/varbound/delayprop should propagation method be delayed, if other propagators found reductions?
Range: boolean
0
constraints/varbound/delaysepa should separation method be delayed, if other separators found cuts?
Range: boolean
0
constraints/varbound/eagerfreq frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534}
100
constraints/varbound/maxlpcoef maximum coefficient in varbound constraint to be added as a row into LP
Range: [0, ∞]
1e+09
constraints/varbound/maxprerounds maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
constraints/varbound/presolpairwise should pairwise constraint comparison be performed in presolving?
Range: boolean
1
constraints/varbound/presoltiming timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
12
constraints/varbound/proptiming timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15}
1

decomposition

Option Description Default
decomposition/maxgraphedge maximum number of edges in block graph computation, or -1 for no limit
Range: {-1, ..., ∞}
10000

display

Option Description Default
display/allviols display all violations for a given start solution / the best solution after the solving process?
Range: boolean
0
display/freq frequency for displaying node information lines
Range: {-1, ..., ∞}
100
display/headerfreq frequency for displaying header lines (every n'th node information line)
Range: {-1, ..., ∞}
15
display/lpinfo should the LP solver display status messages?
Range: boolean
0
display/relevantstats should the relevant statistics be displayed at the end of solving?
Range: boolean
1
display/statistics whether to print statistics on a solve and a provided decomposition
Range: boolean
0
display/verblevel verbosity level of output
Range: {0, ..., 5}
4
display/width maximal number of characters in a node information line
Range: {0, ..., ∞}
143 (80 for Windows without IDE)

display/avgdualbound

Option Description Default
display/avgdualbound/active display activation status of display column <avgdualbound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/completed

Option Description Default
display/completed/active display activation status of display column <completed> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/concdualbound

Option Description Default
display/concdualbound/active display activation status of display column <concdualbound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/concgap

Option Description Default
display/concgap/active display activation status of display column <concgap> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/concmemused

Option Description Default
display/concmemused/active display activation status of display column <concmemused> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/concprimalbound

Option Description Default
display/concprimalbound/active display activation status of display column <concprimalbound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/concsolfound

Option Description Default
display/concsolfound/active display activation status of display column <concsolfound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/conflicts

Option Description Default
display/conflicts/active display activation status of display column <conflicts> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/conss

Option Description Default
display/conss/active display activation status of display column <conss> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/curcols

Option Description Default
display/curcols/active display activation status of display column <curcols> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/curconss

Option Description Default
display/curconss/active display activation status of display column <curconss> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/curdualbound

Option Description Default
display/curdualbound/active display activation status of display column <curdualbound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/currows

Option Description Default
display/currows/active display activation status of display column <currows> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/cutoffbound

Option Description Default
display/cutoffbound/active display activation status of display column <cutoffbound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/cuts

Option Description Default
display/cuts/active display activation status of display column <cuts> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/depth

Option Description Default
display/depth/active display activation status of display column <depth> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/dualbound

Option Description Default
display/dualbound/active display activation status of display column <dualbound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/estimate

Option Description Default
display/estimate/active display activation status of display column <estimate> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/feasST

Option Description Default
display/feasST/active display activation status of display column <feasST> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
0

display/gap

Option Description Default
display/gap/active display activation status of display column <gap> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/lpavgiterations

Option Description Default
display/lpavgiterations/active display activation status of display column <lpavgiterations> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1 (0 for Windows without IDE)

display/lpcond

Option Description Default
display/lpcond/active display activation status of display column <lpcond> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/lpiterations

Option Description Default
display/lpiterations/active display activation status of display column <lpiterations> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/lpobj

Option Description Default
display/lpobj/active display activation status of display column <lpobj> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/maxdepth

Option Description Default
display/maxdepth/active display activation status of display column <maxdepth> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1 (0 for Windows without IDE)

display/memtotal

Option Description Default
display/memtotal/active display activation status of display column <memtotal> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/memused

Option Description Default
display/memused/active display activation status of display column <memused> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/nexternbranchcands

Option Description Default
display/nexternbranchcands/active display activation status of display column <nexternbranchcands> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1 (2 for nonlinear instances)

display/nfrac

Option Description Default
display/nfrac/active display activation status of display column <nfrac> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1 (2 if discrete variables)

display/ninfeasleaves

Option Description Default
display/ninfeasleaves/active display activation status of display column <ninfeasleaves> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/nnodes

Option Description Default
display/nnodes/active display activation status of display column <nnodes> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/nnodesbelowinc

Option Description Default
display/nnodesbelowinc/active display activation status of display column <nnodesbelowinc> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
0

display/nobjleaves

Option Description Default
display/nobjleaves/active display activation status of display column <nobjleaves> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/nodesleft

Option Description Default
display/nodesleft/active display activation status of display column <nodesleft> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/nrank1nodes

Option Description Default
display/nrank1nodes/active display activation status of display column <nrank1nodes> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
0

display/nsols

Option Description Default
display/nsols/active display activation status of display column <nsols> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/plungedepth

Option Description Default
display/plungedepth/active display activation status of display column <plungedepth> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/poolsize

Option Description Default
display/poolsize/active display activation status of display column <poolsize> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/primalbound

Option Description Default
display/primalbound/active display activation status of display column <primalbound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/primalgap

Option Description Default
display/primalgap/active display activation status of display column <primalgap> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
0

display/pseudoobj

Option Description Default
display/pseudoobj/active display activation status of display column <pseudoobj> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/separounds

Option Description Default
display/separounds/active display activation status of display column <separounds> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/solfound

Option Description Default
display/solfound/active display activation status of display column <solfound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/sols

Option Description Default
display/sols/active display activation status of display column <sols> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
0

display/strongbranchs

Option Description Default
display/strongbranchs/active display activation status of display column <strongbranchs> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

display/time

Option Description Default
display/time/active display activation status of display column <time> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1 (2 for Windows without IDE)

display/vars

Option Description Default
display/vars/active display activation status of display column <vars> (0: off, 1: auto, 2:on)
Range: {0, ..., 2}
1

estimation

Option Description Default
estimation/coefmonossg coefficient of 1 - SSG in monotone approximation of search completion
Range: [0, 1]
0.6333
estimation/coefmonoweight coefficient of tree weight in monotone approximation of search completion
Range: [0, 1]
0.3667
estimation/completiontype approximation of search tree completion: (a)uto, (g)ap, tree (w)eight, (m)onotone regression, (r)egression forest, (s)sg
Range: a, g, m, r, s, w
a
estimation/method tree size estimation method: (c)ompletion, (e)nsemble, time series forecasts on either (g)ap, (l)eaf frequency, (o)open nodes, tree (w)eight, (s)sg, or (t)ree profile or w(b)e
Range: b, c, e, g, l, o, s, t, w
w
estimation/regforestfilename user regression forest in RFCSV format
Range: string
-
Options for expert users
estimation/reportfreq report frequency on estimation: -1: never, 0:always, k ≥ 1: k times evenly during search
Range: {-1, ..., 1073741823}
-1
estimation/useleafts use leaf nodes as basic observations for time series, or all nodes?
Range: boolean
1

estimation/restarts

Option Description Default
estimation/restarts/countonlyleaves should only leaves count for the minnodes parameter?
Range: boolean
0
estimation/restarts/hitcounterlim limit on the number of successive samples to really trigger a restart
Range: {1, ..., ∞}
50
estimation/restarts/minnodes minimum number of nodes before restart
Range: {-1, ..., ∞}
1000
estimation/restarts/restartactpricers whether to apply a restart when active pricers are used
Range: boolean
0
estimation/restarts/restartfactor factor by which the estimated number of nodes should exceed the current number of nodes
Range: [1, ∞]
50
estimation/restarts/restartlimit restart limit
Range: {-1, ..., ∞}
1
estimation/restarts/restartnonlinear whether to apply a restart when nonlinear constraints are present
Range: boolean
0
estimation/restarts/restartpolicy restart policy: (a)lways, (c)ompletion, (e)stimation, (n)ever
Range: a, c, e, n
e

estimation/ssg

Option Description Default
estimation/ssg/nmaxsubtrees the maximum number of individual SSG subtrees; -1: no limit
Range: {-1, ..., 1073741823}
-1
estimation/ssg/nminnodeslastsplit minimum number of nodes to process between two consecutive SSG splits
Range: {0, ..., ∞}
0

estimation/treeprofile

Option Description Default
estimation/treeprofile/enabled should the event handler collect data?
Range: boolean
0
estimation/treeprofile/minnodesperdepth minimum average number of nodes at each depth before producing estimations
Range: [1, ∞]
20

heuristics

Option Description Default
Options for expert users
heuristics/useuctsubscip should setting of common subscip parameters include the activation of the UCT node selector?
Range: boolean
0

heuristics/actconsdiving

Option Description Default
heuristics/actconsdiving/backtrack use one level of backtracking if infeasibility is encountered?
Range: boolean
1
heuristics/actconsdiving/freq frequency for calling primal heuristic <actconsdiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
-1
heuristics/actconsdiving/freqofs frequency offset for calling primal heuristic <actconsdiving>
Range: {0, ..., 65534}
5
heuristics/actconsdiving/lpresolvedomchgquot percentage of immediate domain changes during probing to trigger LP resolve
Range: [0, ∞]
0.15
heuristics/actconsdiving/lpsolvefreq LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
Range: {0, ..., ∞}
0
heuristics/actconsdiving/maxlpiterofs additional number of allowed LP iterations
Range: {0, ..., ∞}
1000
heuristics/actconsdiving/maxlpiterquot maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞]
0.05
heuristics/actconsdiving/onlylpbranchcands should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean
1
Options for expert users
heuristics/actconsdiving/maxdepth maximal depth level to call primal heuristic <actconsdiving> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/actconsdiving/maxdiveavgquot maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞]
0
heuristics/actconsdiving/maxdiveavgquotnosol maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞]
1
heuristics/actconsdiving/maxdiveubquot maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1]
0.8
heuristics/actconsdiving/maxdiveubquotnosol maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1]
1
heuristics/actconsdiving/maxreldepth maximal relative depth to start diving
Range: [0, 1]
1
heuristics/actconsdiving/minreldepth minimal relative depth to start diving
Range: [0, 1]
0
heuristics/actconsdiving/priority priority of heuristic <actconsdiving>
Range: {-536870912, ..., 536870911}
-1003700

heuristics/adaptivediving

Option Description Default
heuristics/adaptivediving/bestsolweight weight of incumbent solutions compared to other solutions in computation of LP iteration limit
Range: [0, ∞]
10
heuristics/adaptivediving/epsilon parameter that increases probability of exploration among divesets (only active if seltype is 'e')
Range: [0, ∞]
1
heuristics/adaptivediving/freq frequency for calling primal heuristic <adaptivediving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
5
heuristics/adaptivediving/freqofs frequency offset for calling primal heuristic <adaptivediving>
Range: {0, ..., 65534}
3
heuristics/adaptivediving/maxlpiterofs additional number of allowed LP iterations
Range: {0, ..., ∞}
1500
heuristics/adaptivediving/maxlpiterquot maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞]
0.1
heuristics/adaptivediving/scoretype score parameter for selection: minimize either average 'n'odes, LP 'i'terations,backtrack/'c'onflict ratio, 'd'epth, 1 / 's'olutions, or 1 / solutions'u'ccess
Range: c, d, i, n, s, u
c
heuristics/adaptivediving/selconfidencecoeff coefficient c to decrease initial confidence (calls + 1.0) / (calls + c) in scores
Range: [1, 2.14748e+09]
10
heuristics/adaptivediving/seltype selection strategy: (e)psilon-greedy, (w)eighted distribution, (n)ext diving
Range: e, n, w
w
Options for expert users
heuristics/adaptivediving/maxdepth maximal depth level to call primal heuristic <adaptivediving> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/adaptivediving/priority priority of heuristic <adaptivediving>
Range: {-536870912, ..., 536870911}
-70000
heuristics/adaptivediving/useadaptivecontext should the heuristic use its own statistics, or shared statistics?
Range: boolean
0

heuristics/alns

Option Description Default
heuristics/alns/freq frequency for calling primal heuristic <alns> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
20
heuristics/alns/freqofs frequency offset for calling primal heuristic <alns>
Range: {0, ..., 65534}
0
heuristics/alns/nodesofs offset added to the nodes budget
Range: {0, ..., ∞}
500
heuristics/alns/nodesquot fraction of nodes compared to the main SCIP for budget computation
Range: [0, 1]
0.1
heuristics/alns/nsolslim limit on the number of improving solutions in a sub-SCIP call
Range: {-1, ..., ∞}
3
heuristics/alns/seed initial random seed for bandit algorithms and random decisions by neighborhoods
Range: {0, ..., ∞}
113
Options for expert users
heuristics/alns/adjustfixingrate should the heuristic adjust the target fixing rate based on the success?
Range: boolean
1
heuristics/alns/adjustminimprove should the factor by which the minimum improvement is bound be dynamically updated?
Range: boolean
0
heuristics/alns/adjusttargetnodes should the target nodes be dynamically adjusted?
Range: boolean
1
heuristics/alns/alpha parameter to increase the confidence width in UCB
Range: [0, 100]
0.0016
heuristics/alns/banditalgo the bandit algorithm: (u)pper confidence bounds, (e)xp.3, epsilon (g)reedy
Range: u, e, g
u
heuristics/alns/beta reward offset between 0 and 1 at every observation for Exp.3
Range: [0, 1]
0
heuristics/alns/copycuts should cutting planes be copied to the sub-SCIP?
Range: boolean
0
heuristics/alns/domorefixings should the ALNS heuristic do more fixings by itself based on variable prioritization until the target fixing rate is reached?
Range: boolean
1
heuristics/alns/eps increase exploration in epsilon-greedy bandit algorithm
Range: [0, 1]
0.468584
heuristics/alns/fixtol tolerance by which the fixing rate may be missed without generic fixing
Range: [0, 1]
0.1
heuristics/alns/gamma weight between uniform (gamma ~ 1) and weight driven (gamma ~ 0) probability distribution for exp3
Range: [0, 1]
0.0704146
heuristics/alns/maxdepth maximal depth level to call primal heuristic <alns> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/alns/maxnodes maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞}
5000
heuristics/alns/minimprovehigh upper bound for the minimal improvement over the incumbent
Range: [0, 1]
0.01
heuristics/alns/minimprovelow lower threshold for the minimal improvement over the incumbent
Range: [0, 1]
0.01
heuristics/alns/minnodes minimum number of nodes required to start a sub-SCIP
Range: {0, ..., ∞}
50
heuristics/alns/priority priority of heuristic <alns>
Range: {-536870912, ..., 536870911}
-1100500
heuristics/alns/resetweights should the bandit algorithms be reset when a new problem is read?
Range: boolean
1
heuristics/alns/rewardbaseline the reward baseline to separate successful and failed calls
Range: [0, 0.99]
0.5
heuristics/alns/rewardcontrol reward control to increase the weight of the simple solution indicator and decrease the weight of the closed gap reward
Range: [0, 1]
0.8
heuristics/alns/rewardfilename file name to store all rewards and the selection of the bandit
Range: string
-
heuristics/alns/scalebyeffort should the reward be scaled by the effort?
Range: boolean
1
heuristics/alns/startminimprove initial factor by which ALNS should at least improve the incumbent
Range: [0, 1]
0.01
heuristics/alns/subsciprandseeds should random seeds of sub-SCIPs be altered to increase diversification?
Range: boolean
0
heuristics/alns/targetnodefactor factor by which target node number is eventually increased
Range: [1, 100000]
1.05
heuristics/alns/unfixtol tolerance by which the fixing rate may be exceeded without generic unfixing
Range: [0, 1]
0.1
heuristics/alns/usedistances distances from fixed variables be used for variable prioritization
Range: boolean
1
heuristics/alns/uselocalredcost should local reduced costs be used for generic (un)fixing?
Range: boolean
0
heuristics/alns/usepscost should pseudo cost scores be used for variable priorization?
Range: boolean
1
heuristics/alns/useredcost should reduced cost scores be used for variable prioritization?
Range: boolean
1
heuristics/alns/usesubscipheurs should the heuristic activate other sub-SCIP heuristics during its search?
Range: boolean
0
heuristics/alns/waitingnodes number of nodes since last incumbent solution that the heuristic should wait
Range: {0, ..., ∞}
25

heuristics/alns/crossover

Option Description Default
Options for expert users
heuristics/alns/crossover/active is this neighborhood active?
Range: boolean
1
heuristics/alns/crossover/maxfixingrate maximum fixing rate for this neighborhood
Range: [0, 1]
0.9
heuristics/alns/crossover/minfixingrate minimum fixing rate for this neighborhood
Range: [0, 1]
0.3
heuristics/alns/crossover/nsols the number of solutions that crossover should combine
Range: {2, ..., 10}
2
heuristics/alns/crossover/priority positive call priority to initialize bandit algorithms
Range: [0.01, 1]
1

heuristics/alns/dins

Option Description Default
Options for expert users
heuristics/alns/dins/active is this neighborhood active?
Range: boolean
1
heuristics/alns/dins/maxfixingrate maximum fixing rate for this neighborhood
Range: [0, 1]
0.9
heuristics/alns/dins/minfixingrate minimum fixing rate for this neighborhood
Range: [0, 1]
0.3
heuristics/alns/dins/npoolsols number of pool solutions where binary solution values must agree
Range: {1, ..., 100}
5
heuristics/alns/dins/priority positive call priority to initialize bandit algorithms
Range: [0.01, 1]
1

heuristics/alns/localbranching

Option Description Default
Options for expert users
heuristics/alns/localbranching/active is this neighborhood active?
Range: boolean
1
heuristics/alns/localbranching/maxfixingrate maximum fixing rate for this neighborhood
Range: [0, 1]
0.9
heuristics/alns/localbranching/minfixingrate minimum fixing rate for this neighborhood
Range: [0, 1]
0.3
heuristics/alns/localbranching/priority positive call priority to initialize bandit algorithms
Range: [0.01, 1]
1

heuristics/alns/mutation

Option Description Default
Options for expert users
heuristics/alns/mutation/active is this neighborhood active?
Range: boolean
1
heuristics/alns/mutation/maxfixingrate maximum fixing rate for this neighborhood
Range: [0, 1]
0.9
heuristics/alns/mutation/minfixingrate minimum fixing rate for this neighborhood
Range: [0, 1]
0.3
heuristics/alns/mutation/priority positive call priority to initialize bandit algorithms
Range: [0.01, 1]
1

heuristics/alns/proximity

Option Description Default
Options for expert users
heuristics/alns/proximity/active is this neighborhood active?
Range: boolean
1
heuristics/alns/proximity/maxfixingrate maximum fixing rate for this neighborhood
Range: [0, 1]
0.9
heuristics/alns/proximity/minfixingrate minimum fixing rate for this neighborhood
Range: [0, 1]
0.3
heuristics/alns/proximity/priority positive call priority to initialize bandit algorithms
Range: [0.01, 1]
1

heuristics/alns/rens

Option Description Default
Options for expert users
heuristics/alns/rens/active is this neighborhood active?
Range: boolean
1
heuristics/alns/rens/maxfixingrate maximum fixing rate for this neighborhood
Range: [0, 1]
0.9
heuristics/alns/rens/minfixingrate minimum fixing rate for this neighborhood
Range: [0, 1]
0.3
heuristics/alns/rens/priority positive call priority to initialize bandit algorithms
Range: [0.01, 1]
1

heuristics/alns/rins

Option Description Default
Options for expert users
heuristics/alns/rins/active is this neighborhood active?
Range: boolean
1
heuristics/alns/rins/maxfixingrate maximum fixing rate for this neighborhood
Range: [0, 1]
0.9
heuristics/alns/rins/minfixingrate minimum fixing rate for this neighborhood
Range: [0, 1]
0.3
heuristics/alns/rins/priority positive call priority to initialize bandit algorithms
Range: [0.01, 1]
1

heuristics/alns/trustregion

Option Description Default
heuristics/alns/trustregion/violpenalty the penalty for each change in the binary variables from the candidate solution
Range: [0, ∞]
100
Options for expert users
heuristics/alns/trustregion/active is this neighborhood active?
Range: boolean
0
heuristics/alns/trustregion/maxfixingrate maximum fixing rate for this neighborhood
Range: [0, 1]
0.9
heuristics/alns/trustregion/minfixingrate minimum fixing rate for this neighborhood
Range: [0, 1]
0.3
heuristics/alns/trustregion/priority positive call priority to initialize bandit algorithms
Range: [0.01, 1]
1

heuristics/alns/zeroobjective

Option Description Default
Options for expert users
heuristics/alns/zeroobjective/active is this neighborhood active?
Range: boolean
1
heuristics/alns/zeroobjective/maxfixingrate maximum fixing rate for this neighborhood
Range: [0, 1]
0.9
heuristics/alns/zeroobjective/minfixingrate minimum fixing rate for this neighborhood
Range: [0, 1]
0.3
heuristics/alns/zeroobjective/priority positive call priority to initialize bandit algorithms
Range: [0.01, 1]
1

heuristics/bound

Option Description Default
heuristics/bound/bound to which bound should integer variables be fixed? ('l'ower, 'u'pper, or 'b'oth)
Range: l, u, b
l
heuristics/bound/freq frequency for calling primal heuristic <bound> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
-1
heuristics/bound/freqofs frequency offset for calling primal heuristic <bound>
Range: {0, ..., 65534}
0
Options for expert users
heuristics/bound/maxdepth maximal depth level to call primal heuristic <bound> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/bound/maxproprounds maximum number of propagation rounds during probing (-1 infinity, -2 parameter settings)
Range: {-1, ..., 536870911}
0
heuristics/bound/onlywithoutsol Should heuristic only be executed if no primal solution was found, yet?
Range: boolean
1
heuristics/bound/priority priority of heuristic <bound>
Range: {-536870912, ..., 536870911}
-1107000

heuristics/clique

Option Description Default
heuristics/clique/freq frequency for calling primal heuristic <clique> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
0
heuristics/clique/freqofs frequency offset for calling primal heuristic <clique>
Range: {0, ..., 65534}
0
heuristics/clique/minintfixingrate minimum percentage of integer variables that have to be fixable
Range: [0, 1]
0.65
heuristics/clique/minmipfixingrate minimum percentage of fixed variables in the sub-MIP
Range: [0, 1]
0.65
heuristics/clique/nodesofs number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞}
500
heuristics/clique/nodesquot contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1]
0.1
Options for expert users
heuristics/clique/copycuts should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean
1
heuristics/clique/maxbacktracks maximum number of backtracks during the fixing process
Range: {-1, ..., 536870911}
10
heuristics/clique/maxdepth maximal depth level to call primal heuristic <clique> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/clique/maxnodes maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞}
5000
heuristics/clique/maxproprounds maximum number of propagation rounds during probing (-1 infinity)
Range: {-1, ..., 536870911}
2
heuristics/clique/minimprove factor by which clique heuristic should at least improve the incumbent
Range: [0, 1]
0.01
heuristics/clique/minnodes minimum number of nodes required to start the subproblem
Range: {0, ..., ∞}
500
heuristics/clique/priority priority of heuristic <clique>
Range: {-536870912, ..., 536870911}
5000
heuristics/clique/uselockfixings should more variables be fixed based on variable locks if the fixing rate was not reached?
Range: boolean
0

heuristics/coefdiving

Option Description Default
heuristics/coefdiving/backtrack use one level of backtracking if infeasibility is encountered?
Range: boolean
1
heuristics/coefdiving/freq frequency for calling primal heuristic <coefdiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
-1
heuristics/coefdiving/freqofs frequency offset for calling primal heuristic <coefdiving>
Range: {0, ..., 65534}
1
heuristics/coefdiving/lpresolvedomchgquot percentage of immediate domain changes during probing to trigger LP resolve
Range: [0, ∞]
0.15
heuristics/coefdiving/lpsolvefreq LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
Range: {0, ..., ∞}
0
heuristics/coefdiving/maxlpiterofs additional number of allowed LP iterations
Range: {0, ..., ∞}
1000
heuristics/coefdiving/maxlpiterquot maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞]
0.05
heuristics/coefdiving/onlylpbranchcands should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean
0
Options for expert users
heuristics/coefdiving/maxdepth maximal depth level to call primal heuristic <coefdiving> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/coefdiving/maxdiveavgquot maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞]
0
heuristics/coefdiving/maxdiveavgquotnosol maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞]
0
heuristics/coefdiving/maxdiveubquot maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1]
0.8
heuristics/coefdiving/maxdiveubquotnosol maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1]
0.1
heuristics/coefdiving/maxreldepth maximal relative depth to start diving
Range: [0, 1]
1
heuristics/coefdiving/minreldepth minimal relative depth to start diving
Range: [0, 1]
0
heuristics/coefdiving/priority priority of heuristic <coefdiving>
Range: {-536870912, ..., 536870911}
-1001000

heuristics/completesol

Option Description Default
heuristics/completesol/beforepresol should the heuristic run before presolving?
Range: boolean
1
heuristics/completesol/freq frequency for calling primal heuristic <completesol> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
0
heuristics/completesol/freqofs frequency offset for calling primal heuristic <completesol>
Range: {0, ..., 65534}
0
heuristics/completesol/ignorecont should number of continuous variables be ignored?
Range: boolean
0
heuristics/completesol/maxcontvars maximal number of continuous variables after presolving
Range: {-1, ..., ∞}
-1
heuristics/completesol/maxlpiter maximal number of LP iterations (-1: no limit)
Range: {-1, ..., ∞}
-1
heuristics/completesol/maxproprounds maximal number of iterations in propagation (-1: no limit)
Range: {-1, ..., ∞}
10
heuristics/completesol/maxunknownrate maximal rate of unknown solution values
Range: [0, 1]
0.85
heuristics/completesol/nodesofs number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞}
500
heuristics/completesol/nodesquot contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1]
0.1
heuristics/completesol/solutions heuristic stops, if the given number of improving solutions were found (-1: no limit)
Range: {-1, ..., ∞}
5
Options for expert users
heuristics/completesol/addallsols should all subproblem solutions be added to the original SCIP?
Range: boolean
0
heuristics/completesol/boundwidening bound widening factor applied to continuous variables (0: fix variables to given solution values, 1: relax to global bounds)
Range: [0, 1]
0.1
heuristics/completesol/lplimfac factor by which the limit on the number of LP depends on the node limit
Range: [1, ∞]
2
heuristics/completesol/maxdepth maximal depth level to call primal heuristic <completesol> (-1: no limit)
Range: {-1, ..., 65534}
0
heuristics/completesol/maxnodes maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞}
5000
heuristics/completesol/minimprove factor by which the incumbent should be improved at least
Range: [0, 1]
0.01
heuristics/completesol/minnodes minimum number of nodes required to start the subproblem
Range: {0, ..., ∞}
50
heuristics/completesol/objweight weight of the original objective function (1: only original objective)
Range: [0.001, 1]
1
heuristics/completesol/priority priority of heuristic <completesol>
Range: {-536870912, ..., 536870911}
0

heuristics/conflictdiving

Option Description Default
heuristics/conflictdiving/backtrack use one level of backtracking if infeasibility is encountered?
Range: boolean
1
heuristics/conflictdiving/freq frequency for calling primal heuristic <conflictdiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
10
heuristics/conflictdiving/freqofs frequency offset for calling primal heuristic <conflictdiving>
Range: {0, ..., 65534}
0
heuristics/conflictdiving/lpresolvedomchgquot percentage of immediate domain changes during probing to trigger LP resolve
Range: [0, ∞]
0.15
heuristics/conflictdiving/lpsolvefreq LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
Range: {0, ..., ∞}
0
heuristics/conflictdiving/maxlpiterofs additional number of allowed LP iterations
Range: {0, ..., ∞}
1000
heuristics/conflictdiving/maxlpiterquot maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞]
0.15
heuristics/conflictdiving/onlylpbranchcands should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean
0
Options for expert users
heuristics/conflictdiving/likecoef perform rounding like coefficient diving
Range: boolean
0
heuristics/conflictdiving/lockweight weight used in a convex combination of conflict and variable locks
Range: [0, 1]
0.75
heuristics/conflictdiving/maxdepth maximal depth level to call primal heuristic <conflictdiving> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/conflictdiving/maxdiveavgquot maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞]
0
heuristics/conflictdiving/maxdiveavgquotnosol maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞]
0
heuristics/conflictdiving/maxdiveubquot maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1]
0.8
heuristics/conflictdiving/maxdiveubquotnosol maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1]
0.1
heuristics/conflictdiving/maxreldepth maximal relative depth to start diving
Range: [0, 1]
1
heuristics/conflictdiving/maxviol try to maximize the violation
Range: boolean
1
heuristics/conflictdiving/minconflictlocks minimal number of conflict locks per variable
Range: {0, ..., ∞}
5
heuristics/conflictdiving/minreldepth minimal relative depth to start diving
Range: [0, 1]
0
heuristics/conflictdiving/priority priority of heuristic <conflictdiving>
Range: {-536870912, ..., 536870911}
-1000100

heuristics/crossover

Option Description Default
heuristics/crossover/bestsollimit limit on number of improving incumbent solutions in sub-CIP
Range: {-1, ..., ∞}
-1
heuristics/crossover/freq frequency for calling primal heuristic <crossover> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
30
heuristics/crossover/freqofs frequency offset for calling primal heuristic <crossover>
Range: {0, ..., 65534}
0
heuristics/crossover/minfixingrate minimum percentage of integer variables that have to be fixed
Range: [0, 1]
0.666
heuristics/crossover/nodesofs number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞}
500
heuristics/crossover/nodesquot contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1]
0.1
heuristics/crossover/nusedsols number of solutions to be taken into account
Range: {2, ..., ∞}
3
Options for expert users
heuristics/crossover/copycuts if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean
1
heuristics/crossover/dontwaitatroot should the nwaitingnodes parameter be ignored at the root node?
Range: boolean
0
heuristics/crossover/lplimfac factor by which the limit on the number of LP depends on the node limit
Range: [1, ∞]
2
heuristics/crossover/maxdepth maximal depth level to call primal heuristic <crossover> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/crossover/maxnodes maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞}
5000
heuristics/crossover/minimprove factor by which Crossover should at least improve the incumbent
Range: [0, 1]
0.01
heuristics/crossover/minnodes minimum number of nodes required to start the subproblem
Range: {0, ..., ∞}
50
heuristics/crossover/nwaitingnodes number of nodes without incumbent change that heuristic should wait
Range: {0, ..., ∞}
200
heuristics/crossover/permute should the subproblem be permuted to increase diversification?
Range: boolean
0
heuristics/crossover/priority priority of heuristic <crossover>
Range: {-536870912, ..., 536870911}
-1104000
heuristics/crossover/randomization should the choice which sols to take be randomized?
Range: boolean
1
heuristics/crossover/uselprows should subproblem be created out of the rows in the LP rows?
Range: boolean
0
heuristics/crossover/useuct should uct node selection be used at the beginning of the search?
Range: boolean
0

heuristics/dins

Option Description Default
heuristics/dins/bestsollimit limit on number of improving incumbent solutions in sub-CIP
Range: {-1, ..., ∞}
3
heuristics/dins/freq frequency for calling primal heuristic <dins> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
-1
heuristics/dins/freqofs frequency offset for calling primal heuristic <dins>
Range: {0, ..., 65534}
0
heuristics/dins/minfixingrate minimum percentage of integer variables that have to be fixable
Range: [0, 1]
0.3
heuristics/dins/minnodes minimum number of nodes required to start the subproblem
Range: {0, ..., ∞}
50
heuristics/dins/neighborhoodsize radius (using Manhattan metric) of the incumbent's neighborhood to be searched
Range: {1, ..., ∞}
18
heuristics/dins/nodesofs number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞}
5000
heuristics/dins/nodesquot contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1]
0.05
heuristics/dins/solnum number of pool-solutions to be checked for flag array update (for hard fixing of binary variables)
Range: {1, ..., ∞}
5
Options for expert users
heuristics/dins/copycuts if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean
1
heuristics/dins/lplimfac factor by which the limit on the number of LP depends on the node limit
Range: [1, ∞]
1.5
heuristics/dins/maxdepth maximal depth level to call primal heuristic <dins> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/dins/maxnodes maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞}
5000
heuristics/dins/minimprove factor by which dins should at least improve the incumbent
Range: [0, 1]
0.01
heuristics/dins/nwaitingnodes number of nodes without incumbent change that heuristic should wait
Range: {0, ..., ∞}
200
heuristics/dins/priority priority of heuristic <dins>
Range: {-536870912, ..., 536870911}
-1105000
heuristics/dins/uselprows should subproblem be created out of the rows in the LP rows?
Range: boolean
0
heuristics/dins/useuct should uct node selection be used at the beginning of the search?
Range: boolean
0

heuristics/distributiondiving

Option Description Default
heuristics/distributiondiving/backtrack use one level of backtracking if infeasibility is encountered?
Range: boolean
1
heuristics/distributiondiving/freq frequency for calling primal heuristic <distributiondiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
10
heuristics/distributiondiving/freqofs frequency offset for calling primal heuristic <distributiondiving>
Range: {0, ..., 65534}
3
heuristics/distributiondiving/lpresolvedomchgquot percentage of immediate domain changes during probing to trigger LP resolve
Range: [0, ∞]
0.15
heuristics/distributiondiving/lpsolvefreq LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
Range: {0, ..., ∞}
0
heuristics/distributiondiving/maxlpiterofs additional number of allowed LP iterations
Range: {0, ..., ∞}
1000
heuristics/distributiondiving/maxlpiterquot maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞]
0.05
heuristics/distributiondiving/onlylpbranchcands should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean
1
Options for expert users
heuristics/distributiondiving/maxdepth maximal depth level to call primal heuristic <distributiondiving> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/distributiondiving/maxdiveavgquot maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞]
0
heuristics/distributiondiving/maxdiveavgquotnosol maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞]
0
heuristics/distributiondiving/maxdiveubquot maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1]
0.8
heuristics/distributiondiving/maxdiveubquotnosol maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1]
0.1
heuristics/distributiondiving/maxreldepth maximal relative depth to start diving
Range: [0, 1]
1
heuristics/distributiondiving/minreldepth minimal relative depth to start diving
Range: [0, 1]
0
heuristics/distributiondiving/priority priority of heuristic <distributiondiving>
Range: {-536870912, ..., 536870911}
-1003300
heuristics/distributiondiving/scoreparam the score;largest 'd'ifference, 'l'owest cumulative probability,'h'ighest c.p., 'v'otes lowest c.p., votes highest c.p.('w'), 'r'evolving
Range: l, v, d, h, w, r
r

heuristics/dualval

Option Description Default
heuristics/dualval/dynamicdepth says if and how the recursion depth is computed at runtime
Range: {0, ..., 1}
0
heuristics/dualval/freq frequency for calling primal heuristic <dualval> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
-1
heuristics/dualval/freqofs frequency offset for calling primal heuristic <dualval>
Range: {0, ..., 65534}
0
heuristics/dualval/heurverblevel verblevel of the heuristic, default is 0 to display nothing
Range: {0, ..., 4}
0
heuristics/dualval/lambdaobj scaling factor for the objective function
Range: [0, 1]
0
heuristics/dualval/lambdaslack value added to objective of slack variables, must not be zero
Range: [0.1, ∞]
1
heuristics/dualval/maxcalls maximal number of recursive calls of the heuristic (if dynamicdepth is off)
Range: {0, ..., ∞}
25
heuristics/dualval/maxequalranks maximal number of variables that may have maximal rank, quit if there are more, turn off by setting -1
Range: {-1, ..., ∞}
50
heuristics/dualval/mingap minimal gap for which we still run the heuristic, if gap is less we return without doing anything
Range: [0, 100]
5
heuristics/dualval/nlpverblevel verblevel of the nlp solver, can be 0 or 1
Range: {0, ..., 1}
0
heuristics/dualval/onlyleaves disable the heuristic if it was not called at a leaf of the B&B tree
Range: boolean
0
heuristics/dualval/rankvalue number of ranks that should be displayed when the heuristic is called
Range: {0, ..., ∞}
10
heuristics/dualval/relaxcontvars relax the continous variables
Range: boolean
0
heuristics/dualval/relaxindicators relax the indicator variables by introducing continuous copies
Range: boolean
0
Options for expert users
heuristics/dualval/forceimprovements exit if objective doesn't improve
Range: boolean
0
heuristics/dualval/maxdepth maximal depth level to call primal heuristic <dualval> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/dualval/onlycheaper add constraint to ensure that discrete vars are improving
Range: boolean
1
heuristics/dualval/priority priority of heuristic <dualval>
Range: {-536870912, ..., 536870911}
0

heuristics/farkasdiving

Option Description Default
heuristics/farkasdiving/backtrack use one level of backtracking if infeasibility is encountered?
Range: boolean
1
heuristics/farkasdiving/freq frequency for calling primal heuristic <farkasdiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
10
heuristics/farkasdiving/freqofs frequency offset for calling primal heuristic <farkasdiving>
Range: {0, ..., 65534}
0
heuristics/farkasdiving/lpresolvedomchgquot percentage of immediate domain changes during probing to trigger LP resolve
Range: [0, ∞]
0.15
heuristics/farkasdiving/lpsolvefreq LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
Range: {0, ..., ∞}
1
heuristics/farkasdiving/maxlpiterofs additional number of allowed LP iterations
Range: {0, ..., ∞}
1000
heuristics/farkasdiving/maxlpiterquot maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞]
0.05
heuristics/farkasdiving/onlylpbranchcands should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean
0
Options for expert users
heuristics/farkasdiving/checkcands should diving candidates be checked before running?
Range: boolean
0
heuristics/farkasdiving/maxdepth maximal depth level to call primal heuristic <farkasdiving> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/farkasdiving/maxdiveavgquot maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞]
0
heuristics/farkasdiving/maxdiveavgquotnosol maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞]
0
heuristics/farkasdiving/maxdiveubquot maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1]
0.8
heuristics/farkasdiving/maxdiveubquotnosol maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1]
0.1
heuristics/farkasdiving/maxobjocc maximal occurance factor of an objective coefficient
Range: [0, 1]
1
heuristics/farkasdiving/maxreldepth maximal relative depth to start diving
Range: [0, 1]
1
heuristics/farkasdiving/minreldepth minimal relative depth to start diving
Range: [0, 1]
0
heuristics/farkasdiving/objdynamism minimal objective dynamism (log) to run
Range: [0, ∞]
0.0001
heuristics/farkasdiving/priority priority of heuristic <farkasdiving>
Range: {-536870912, ..., 536870911}
-900000
heuristics/farkasdiving/rootsuccess should the heuristic only run within the tree if at least one solution was found at the root node?
Range: boolean
1
heuristics/farkasdiving/scalescore should the score be scaled?
Range: boolean
1
heuristics/farkasdiving/scaletype scale score by [f]ractionality or [i]mpact on farkasproof
Range: f, i
i

heuristics/feaspump

Option Description Default
heuristics/feaspump/alpha initial weight of the objective function in the convex combination
Range: [0, 1]
1
heuristics/feaspump/alphadiff threshold difference for the convex parameter to perform perturbation
Range: [0, 1]
1
heuristics/feaspump/beforecuts should the feasibility pump be called at root node before cut separation?
Range: boolean
1
heuristics/feaspump/freq frequency for calling primal heuristic <feaspump> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
20
heuristics/feaspump/freqofs frequency offset for calling primal heuristic <feaspump>
Range: {0, ..., 65534}
0
heuristics/feaspump/maxlpiterofs additional number of allowed LP iterations
Range: {0, ..., ∞}
1000
heuristics/feaspump/maxlpiterquot maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞]
0.01
heuristics/feaspump/neighborhoodsize radius (using Manhattan metric) of the neighborhood to be searched in stage 3
Range: {1, ..., ∞}
18
heuristics/feaspump/objfactor factor by which the regard of the objective is decreased in each round, 1.0 for dynamic
Range: [0, 1]
0.1
heuristics/feaspump/pertsolfound should a random perturbation be performed if a feasible solution was found?
Range: boolean
1
heuristics/feaspump/stage3 should we solve a local branching sub-MIP if no solution could be found?
Range: boolean
0
heuristics/feaspump/usefp20 should an iterative round-and-propagate scheme be used to find the integral points?
Range: boolean
0
Options for expert users
heuristics/feaspump/copycuts should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean
1
heuristics/feaspump/cyclelength maximum length of cycles to be checked explicitly in each round
Range: {1, ..., 100}
3
heuristics/feaspump/maxdepth maximal depth level to call primal heuristic <feaspump> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/feaspump/maxloops maximal number of pumping loops (-1: no limit)
Range: {-1, ..., ∞}
10000
heuristics/feaspump/maxsols total number of feasible solutions found up to which heuristic is called (-1: no limit)
Range: {-1, ..., ∞}
10
heuristics/feaspump/maxstallloops maximal number of pumping rounds without fractionality improvement (-1: no limit)
Range: {-1, ..., ∞}
10
heuristics/feaspump/minflips minimum number of random variables to flip, if a 1-cycle is encountered
Range: {1, ..., ∞}
10
heuristics/feaspump/perturbfreq number of iterations until a random perturbation is forced
Range: {1, ..., ∞}
100
heuristics/feaspump/priority priority of heuristic <feaspump>
Range: {-536870912, ..., 536870911}
-1000000

heuristics/fixandinfer

Option Description Default
heuristics/fixandinfer/freq frequency for calling primal heuristic <fixandinfer> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
-1
heuristics/fixandinfer/freqofs frequency offset for calling primal heuristic <fixandinfer>
Range: {0, ..., 65534}
0
Options for expert users
heuristics/fixandinfer/maxdepth maximal depth level to call primal heuristic <fixandinfer> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/fixandinfer/minfixings minimal number of fixings to apply before dive may be aborted
Range: {0, ..., ∞}
100
heuristics/fixandinfer/priority priority of heuristic <fixandinfer>
Range: {-536870912, ..., 536870911}
-500000
heuristics/fixandinfer/proprounds maximal number of propagation rounds in probing subproblems (-1: no limit, 0: auto)
Range: {-1, ..., ∞}
0

heuristics/fracdiving

Option Description Default
heuristics/fracdiving/backtrack use one level of backtracking if infeasibility is encountered?
Range: boolean
1
heuristics/fracdiving/freq frequency for calling primal heuristic <fracdiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
10
heuristics/fracdiving/freqofs frequency offset for calling primal heuristic <fracdiving>
Range: {0, ..., 65534}
3
heuristics/fracdiving/lpresolvedomchgquot percentage of immediate domain changes during probing to trigger LP resolve
Range: [0, ∞]
0.15
heuristics/fracdiving/lpsolvefreq LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
Range: {0, ..., ∞}
0
heuristics/fracdiving/maxlpiterofs additional number of allowed LP iterations
Range: {0, ..., ∞}
1000
heuristics/fracdiving/maxlpiterquot maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞]
0.05
heuristics/fracdiving/onlylpbranchcands should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean
0
Options for expert users
heuristics/fracdiving/maxdepth maximal depth level to call primal heuristic <fracdiving> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/fracdiving/maxdiveavgquot maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞]
0
heuristics/fracdiving/maxdiveavgquotnosol maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞]
0
heuristics/fracdiving/maxdiveubquot maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1]
0.8
heuristics/fracdiving/maxdiveubquotnosol maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1]
0.1
heuristics/fracdiving/maxreldepth maximal relative depth to start diving
Range: [0, 1]
1
heuristics/fracdiving/minreldepth minimal relative depth to start diving
Range: [0, 1]
0
heuristics/fracdiving/priority priority of heuristic <fracdiving>
Range: {-536870912, ..., 536870911}
-1003000

heuristics/gins

Option Description Default
heuristics/gins/bestsollimit limit on number of improving incumbent solutions in sub-CIP
Range: {-1, ..., ∞}
3
heuristics/gins/freq frequency for calling primal heuristic <gins> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
20
heuristics/gins/freqofs frequency offset for calling primal heuristic <gins>
Range: {0, ..., 65534}
8
heuristics/gins/maxdistance maximum distance to selected variable to enter the subproblem, or -1 to select the distance that best approximates the minimum fixing rate from below
Range: {-1, ..., ∞}
3
heuristics/gins/minfixingrate percentage of integer variables that have to be fixed
Range: [1e-06, 0.999999]
0.66
heuristics/gins/nodesofs number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞}
500
heuristics/gins/nodesquot contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1]
0.15
Options for expert users
heuristics/gins/consecutiveblocks should blocks be treated consecutively (sorted by ascending label?)
Range: boolean
1
heuristics/gins/copycuts if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean
1
heuristics/gins/fixcontvars should continuous variables outside the neighborhoods be fixed?
Range: boolean
0
heuristics/gins/maxdepth maximal depth level to call primal heuristic <gins> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/gins/maxnodes maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞}
5000
heuristics/gins/minimprove factor by which gins should at least improve the incumbent
Range: [0, 1]
0.01
heuristics/gins/minnodes minimum number of nodes required to start the subproblem
Range: {0, ..., ∞}
50
heuristics/gins/nwaitingnodes number of nodes without incumbent change that heuristic should wait
Range: {0, ..., ∞}
100
heuristics/gins/overlap overlap of blocks between runs - 0.0: no overlap, 1.0: shift by only 1 block
Range: [0, 1]
0
heuristics/gins/potential the reference point to compute the neighborhood potential: (r)oot, (l)ocal lp, or (p)seudo solution
Range: l, p, r
r
heuristics/gins/priority priority of heuristic <gins>
Range: {-536870912, ..., 536870911}
-1103000
heuristics/gins/relaxdenseconss should dense constraints (at least as dense as 1 - minfixingrate) be ignored by connectivity graph?
Range: boolean
0
heuristics/gins/rollhorizonlimfac limiting percentage for variables already used in sub-SCIPs to terminate rolling horizon approach
Range: [0, 1]
0.4
heuristics/gins/usedecomp should user decompositions be considered, if available?
Range: boolean
1
heuristics/gins/usedecomprollhorizon should user decompositions be considered for initial selection in rolling horizon, if available?
Range: boolean
0
heuristics/gins/uselprows should subproblem be created out of the rows in the LP rows?
Range: boolean
0
heuristics/gins/userollinghorizon should the heuristic solve a sequence of sub-MIP's around the first selected variable
Range: boolean
1
heuristics/gins/useselfallback should random initial variable selection be used if decomposition was not successful?
Range: boolean
1

heuristics/guideddiving

Option Description Default
heuristics/guideddiving/backtrack use one level of backtracking if infeasibility is encountered?
Range: boolean
1
heuristics/guideddiving/freq frequency for calling primal heuristic <guideddiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
10
heuristics/guideddiving/freqofs frequency offset for calling primal heuristic <guideddiving>
Range: {0, ..., 65534}
7
heuristics/guideddiving/lpresolvedomchgquot percentage of immediate domain changes during probing to trigger LP resolve
Range: [0, ∞]
0.15
heuristics/guideddiving/lpsolvefreq LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
Range: {0, ..., ∞}
0
heuristics/guideddiving/maxlpiterofs additional number of allowed LP iterations
Range: {0, ..., ∞}
1000
heuristics/guideddiving/maxlpiterquot maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞]
0.05
heuristics/guideddiving/onlylpbranchcands should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean
0
Options for expert users
heuristics/guideddiving/maxdepth maximal depth level to call primal heuristic <guideddiving> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/guideddiving/maxdiveavgquot maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞]
0
heuristics/guideddiving/maxdiveavgquotnosol maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞]
1
heuristics/guideddiving/maxdiveubquot maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1]
0.8
heuristics/guideddiving/maxdiveubquotnosol maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1]
1
heuristics/guideddiving/maxreldepth maximal relative depth to start diving
Range: [0, 1]
1
heuristics/guideddiving/minreldepth minimal relative depth to start diving
Range: [0, 1]
0
heuristics/guideddiving/priority priority of heuristic <guideddiving>
Range: {-536870912, ..., 536870911}
-1007000

heuristics/indicator

Option Description Default
heuristics/indicator/freq frequency for calling primal heuristic <indicator> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
1
heuristics/indicator/freqofs frequency offset for calling primal heuristic <indicator>
Range: {0, ..., 65534}
0
Options for expert users
heuristics/indicator/improvesols Try to improve other solutions by one-opt?
Range: boolean
0
heuristics/indicator/maxdepth maximal depth level to call primal heuristic <indicator> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/indicator/oneopt whether the one-opt heuristic should be started
Range: boolean
0
heuristics/indicator/priority priority of heuristic <indicator>
Range: {-536870912, ..., 536870911}
-20200

heuristics/intdiving

Option Description Default
heuristics/intdiving/backtrack use one level of backtracking if infeasibility is encountered?
Range: boolean
1
heuristics/intdiving/freq frequency for calling primal heuristic <intdiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
-1
heuristics/intdiving/freqofs frequency offset for calling primal heuristic <intdiving>
Range: {0, ..., 65534}
9
heuristics/intdiving/maxlpiterofs additional number of allowed LP iterations
Range: {0, ..., ∞}
1000
heuristics/intdiving/maxlpiterquot maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞]
0.05
Options for expert users
heuristics/intdiving/maxdepth maximal depth level to call primal heuristic <intdiving> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/intdiving/maxdiveavgquot maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞]
0
heuristics/intdiving/maxdiveavgquotnosol maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞]
0
heuristics/intdiving/maxdiveubquot maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1]
0.8
heuristics/intdiving/maxdiveubquotnosol maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1]
0.1
heuristics/intdiving/maxreldepth maximal relative depth to start diving
Range: [0, 1]
1
heuristics/intdiving/minreldepth minimal relative depth to start diving
Range: [0, 1]
0
heuristics/intdiving/priority priority of heuristic <intdiving>
Range: {-536870912, ..., 536870911}
-1003500

heuristics/intshifting

Option Description Default
heuristics/intshifting/freq frequency for calling primal heuristic <intshifting> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
10
heuristics/intshifting/freqofs frequency offset for calling primal heuristic <intshifting>
Range: {0, ..., 65534}
0
Options for expert users
heuristics/intshifting/maxdepth maximal depth level to call primal heuristic <intshifting> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/intshifting/priority priority of heuristic <intshifting>
Range: {-536870912, ..., 536870911}
-10000

heuristics/linesearchdiving

Option Description Default
heuristics/linesearchdiving/backtrack use one level of backtracking if infeasibility is encountered?
Range: boolean
1
heuristics/linesearchdiving/freq frequency for calling primal heuristic <linesearchdiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
10
heuristics/linesearchdiving/freqofs frequency offset for calling primal heuristic <linesearchdiving>
Range: {0, ..., 65534}
6
heuristics/linesearchdiving/lpresolvedomchgquot percentage of immediate domain changes during probing to trigger LP resolve
Range: [0, ∞]
0.15
heuristics/linesearchdiving/lpsolvefreq LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
Range: {0, ..., ∞}
0
heuristics/linesearchdiving/maxlpiterofs additional number of allowed LP iterations
Range: {0, ..., ∞}
1000
heuristics/linesearchdiving/maxlpiterquot maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞]
0.05
heuristics/linesearchdiving/onlylpbranchcands should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean
0
Options for expert users
heuristics/linesearchdiving/maxdepth maximal depth level to call primal heuristic <linesearchdiving> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/linesearchdiving/maxdiveavgquot maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞]
0
heuristics/linesearchdiving/maxdiveavgquotnosol maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞]
0
heuristics/linesearchdiving/maxdiveubquot maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1]
0.8
heuristics/linesearchdiving/maxdiveubquotnosol maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1]
0.1
heuristics/linesearchdiving/maxreldepth maximal relative depth to start diving
Range: [0, 1]
1
heuristics/linesearchdiving/minreldepth minimal relative depth to start diving
Range: [0, 1]
0
heuristics/linesearchdiving/priority priority of heuristic <linesearchdiving>
Range: {-536870912, ..., 536870911}
-1006000

heuristics/localbranching

Option Description Default
heuristics/localbranching/bestsollimit limit on number of improving incumbent solutions in sub-CIP
Range: {-1, ..., ∞}
3
heuristics/localbranching/freq frequency for calling primal heuristic <localbranching> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
-1
heuristics/localbranching/freqofs frequency offset for calling primal heuristic <localbranching>
Range: {0, ..., 65534}
0
heuristics/localbranching/neighborhoodsize radius (using Manhattan metric) of the incumbent's neighborhood to be searched
Range: {1, ..., ∞}
18
heuristics/localbranching/nodesofs number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞}
1000
heuristics/localbranching/nodesquot contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1]
0.05
Options for expert users
heuristics/localbranching/copycuts if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean
1
heuristics/localbranching/lplimfac factor by which the limit on the number of LP depends on the node limit
Range: [1, ∞]
1.5
heuristics/localbranching/maxdepth maximal depth level to call primal heuristic <localbranching> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/localbranching/maxnodes maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞}
10000
heuristics/localbranching/minimprove factor by which localbranching should at least improve the incumbent
Range: [0, 1]
0.01
heuristics/localbranching/minnodes minimum number of nodes required to start the subproblem
Range: {0, ..., ∞}
1000
heuristics/localbranching/nwaitingnodes number of nodes without incumbent change that heuristic should wait
Range: {0, ..., ∞}
200
heuristics/localbranching/priority priority of heuristic <localbranching>
Range: {-536870912, ..., 536870911}
-1102000
heuristics/localbranching/uselprows should subproblem be created out of the rows in the LP rows?
Range: boolean
0

heuristics/locks

Option Description Default
heuristics/locks/freq frequency for calling primal heuristic <locks> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
0
heuristics/locks/freqofs frequency offset for calling primal heuristic <locks>
Range: {0, ..., 65534}
0
heuristics/locks/minfixingrate minimum percentage of integer variables that have to be fixable
Range: [0, 1]
0.65
heuristics/locks/nodesofs number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞}
500
heuristics/locks/nodesquot contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1]
0.1
heuristics/locks/roundupprobability probability for rounding a variable up in case of ties
Range: [0, 1]
0.67
Options for expert users
heuristics/locks/copycuts should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean
1
heuristics/locks/maxdepth maximal depth level to call primal heuristic <locks> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/locks/maxnodes maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞}
5000
heuristics/locks/maxproprounds maximum number of propagation rounds to be performed in each propagation call (-1: no limit, -2: parameter settings)
Range: {-2, ..., ∞}
2
heuristics/locks/minfixingratelp minimum fixing rate over all variables (including continuous) to solve LP
Range: [0, 1]
0
heuristics/locks/minimprove factor by which locks heuristic should at least improve the incumbent
Range: [0, 1]
0.01
heuristics/locks/minnodes minimum number of nodes required to start the subproblem
Range: {0, ..., ∞}
500
heuristics/locks/priority priority of heuristic <locks>
Range: {-536870912, ..., 536870911}
3000
heuristics/locks/updatelocks should the locks be updated based on LP rows?
Range: boolean
1
heuristics/locks/usefinalsubmip should a final sub-MIP be solved to costruct a feasible solution if the LP was not roundable?
Range: boolean
1

heuristics/lpface

Option Description Default
heuristics/lpface/freq frequency for calling primal heuristic <lpface> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
15
heuristics/lpface/freqofs frequency offset for calling primal heuristic <lpface>
Range: {0, ..., 65534}
0
heuristics/lpface/minfixingrate required percentage of fixed integer variables in sub-MIP to run
Range: [0, 1]
0.1
heuristics/lpface/nodesofs number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞}
200
heuristics/lpface/nodesquot contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1]
0.1
Options for expert users
heuristics/lpface/copycuts if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean
1
heuristics/lpface/dualbasisequations should dually nonbasic rows be turned into equations?
Range: boolean
0
heuristics/lpface/keepsubscip should the heuristic continue solving the same sub-SCIP?
Range: boolean
0
heuristics/lpface/lplimfac factor by which the limit on the number of LP depends on the node limit
Range: [1, ∞]
2
heuristics/lpface/maxdepth maximal depth level to call primal heuristic <lpface> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/lpface/maxnodes maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞}
5000
heuristics/lpface/minnodes minimum number of nodes required to start the subproblem
Range: {0, ..., ∞}
50
heuristics/lpface/minpathlen the minimum active search tree path length along which lower bound hasn't changed before heuristic becomes active
Range: {0, ..., 65531}
5
heuristics/lpface/priority priority of heuristic <lpface>
Range: {-536870912, ..., 536870911}
-1104000
heuristics/lpface/subscipobjective objective function in the sub-SCIP: (z)ero, (r)oot-LP-difference, (i)nference, LP (f)ractionality, (o)riginal
Range: f, o, r, z, i
z
heuristics/lpface/uselprows should subproblem be created out of the rows in the LP rows?
Range: boolean
1

heuristics/mpec

Option Description Default
heuristics/mpec/freq frequency for calling primal heuristic <mpec> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
50
heuristics/mpec/freqofs frequency offset for calling primal heuristic <mpec>
Range: {0, ..., 65534}
0
heuristics/mpec/inittheta initial regularization right-hand side value
Range: [0, 0.25]
0.125
heuristics/mpec/maxiter maximum number of iterations of the MPEC loop
Range: {0, ..., ∞}
100
heuristics/mpec/maxnlpcost maximum cost available for solving NLPs per call of the heuristic
Range: [0, ∞]
1e+08
heuristics/mpec/maxnlpiter maximum number of NLP iterations per solve
Range: {0, ..., ∞}
500
heuristics/mpec/maxnunsucc maximum number of consecutive calls for which the heuristic did not find an improving solution
Range: {0, ..., ∞}
10
heuristics/mpec/mingapleft minimum amount of gap left in order to call the heuristic
Range: [0, ∞]
0.05
heuristics/mpec/minimprove factor by which heuristic should at least improve the incumbent
Range: [0, 1]
0.01
heuristics/mpec/sigma regularization update factor
Range: [0, 1]
0.5
heuristics/mpec/subnlptrigger maximum number of NLP iterations per solve
Range: [0, 1]
0.001
Options for expert users
heuristics/mpec/maxdepth maximal depth level to call primal heuristic <mpec> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/mpec/priority priority of heuristic <mpec>
Range: {-536870912, ..., 536870911}
-2050000

heuristics/multistart

Option Description Default
heuristics/multistart/freq frequency for calling primal heuristic <multistart> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
0
heuristics/multistart/freqofs frequency offset for calling primal heuristic <multistart>
Range: {0, ..., 65534}
0
heuristics/multistart/gradlimit limit for gradient computations for all improvePoint() calls (0 for no limit)
Range: [0, ∞]
5e+06
heuristics/multistart/maxboundsize maximum variable domain size for unbounded variables
Range: [0, ∞]
20000
heuristics/multistart/maxiter number of iterations to reduce the maximum violation of a point
Range: {0, ..., ∞}
300
heuristics/multistart/maxncluster maximum number of considered clusters per heuristic call
Range: {0, ..., ∞}
3
heuristics/multistart/maxreldist maximum distance between two points in the same cluster
Range: [0, ∞]
0.15
heuristics/multistart/minimprfac minimum required improving factor to proceed in improvement of a single point
Range: real
0.05
heuristics/multistart/minimpriter number of iteration when checking the minimum improvement
Range: {1, ..., ∞}
10
heuristics/multistart/nlpminimpr factor by which heuristic should at least improve the incumbent
Range: [0, ∞]
0
heuristics/multistart/nrndpoints number of random points generated per execution call
Range: {0, ..., ∞}
100
heuristics/multistart/onlynlps should the heuristic run only on continuous problems?
Range: boolean
1
Options for expert users
heuristics/multistart/maxdepth maximal depth level to call primal heuristic <multistart> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/multistart/priority priority of heuristic <multistart>
Range: {-536870912, ..., 536870911}
-2100000

heuristics/mutation

Option Description Default
heuristics/mutation/bestsollimit limit on number of improving incumbent solutions in sub-CIP
Range: {-1, ..., ∞}
-1
heuristics/mutation/freq frequency for calling primal heuristic <mutation> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
-1
heuristics/mutation/freqofs frequency offset for calling primal heuristic <mutation>
Range: {0, ..., 65534}
8
heuristics/mutation/minfixingrate percentage of integer variables that have to be fixed
Range: [1e-06, 0.999999]
0.8
heuristics/mutation/nodesofs number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞}
500
heuristics/mutation/nodesquot contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1]
0.1
Options for expert users
heuristics/mutation/copycuts if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean
1
heuristics/mutation/maxdepth maximal depth level to call primal heuristic <mutation> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/mutation/maxnodes maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞}
5000
heuristics/mutation/minimprove factor by which mutation should at least improve the incumbent
Range: [0, 1]
0.01
heuristics/mutation/minnodes minimum number of nodes required to start the subproblem
Range: {0, ..., ∞}
500
heuristics/mutation/nwaitingnodes number of nodes without incumbent change that heuristic should wait
Range: {0, ..., ∞}
200
heuristics/mutation/priority priority of heuristic <mutation>
Range: {-536870912, ..., 536870911}
-1103000
heuristics/mutation/uselprows should subproblem be created out of the rows in the LP rows?
Range: boolean
0
heuristics/mutation/useuct should uct node selection be used at the beginning of the search?
Range: boolean
0

heuristics/nlpdiving

Option Description Default
heuristics/nlpdiving/backtrack use one level of backtracking if infeasibility is encountered?
Range: boolean
1
heuristics/nlpdiving/fixquot percentage of fractional variables that should be fixed before the next NLP solve
Range: [0, 1]
0.2
heuristics/nlpdiving/freq frequency for calling primal heuristic <nlpdiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
10
heuristics/nlpdiving/freqofs frequency offset for calling primal heuristic <nlpdiving>
Range: {0, ..., 65534}
3
heuristics/nlpdiving/maxfeasnlps maximal number of NLPs with feasible solution to solve during one dive
Range: {1, ..., ∞}
10
heuristics/nlpdiving/maxnlpiterabs minimial absolute number of allowed NLP iterations
Range: {0, ..., ∞}
200
heuristics/nlpdiving/maxnlpiterrel additional allowed number of NLP iterations relative to successfully found solutions
Range: {0, ..., ∞}
10
heuristics/nlpdiving/minsuccquot heuristic will not run if less then this percentage of calls succeeded (0.0: no limit)
Range: [0, 1]
0.1
heuristics/nlpdiving/nlpfastfail should the NLP solver stop early if it converges slow?
Range: boolean
1
heuristics/nlpdiving/prefercover should variables in a minimal cover be preferred?
Range: boolean
1
heuristics/nlpdiving/solvesubmip should a sub-MIP be solved if all cover variables are fixed?
Range: boolean
0
heuristics/nlpdiving/varselrule which variable selection should be used? ('f'ractionality, 'c'oefficient, 'p'seudocost, 'g'uided, 'd'ouble, 'v'eclen)
Range: f, c, p, g, d, v
d
Options for expert users
heuristics/nlpdiving/lp should the LP relaxation be solved before the NLP relaxation?
Range: boolean
0
heuristics/nlpdiving/maxdepth maximal depth level to call primal heuristic <nlpdiving> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/nlpdiving/maxdiveavgquot maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞]
0
heuristics/nlpdiving/maxdiveavgquotnosol maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞]
0
heuristics/nlpdiving/maxdiveubquot maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1]
0.8
heuristics/nlpdiving/maxdiveubquotnosol maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1]
0.1
heuristics/nlpdiving/maxreldepth maximal relative depth to start diving
Range: [0, 1]
1
heuristics/nlpdiving/minreldepth minimal relative depth to start diving
Range: [0, 1]
0
heuristics/nlpdiving/nlpstart which point should be used as starting point for the NLP solver? ('n'one, last 'f'easible, from dive's'tart)
Range: f, n, s
s
heuristics/nlpdiving/preferlpfracs prefer variables that are also fractional in LP solution?
Range: boolean
0
heuristics/nlpdiving/priority priority of heuristic <nlpdiving>
Range: {-536870912, ..., 536870911}
-1003000

heuristics/objpscostdiving

Option Description Default
heuristics/objpscostdiving/freq frequency for calling primal heuristic <objpscostdiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
20
heuristics/objpscostdiving/freqofs frequency offset for calling primal heuristic <objpscostdiving>
Range: {0, ..., 65534}
4
heuristics/objpscostdiving/maxlpiterofs additional number of allowed LP iterations
Range: {0, ..., ∞}
1000
heuristics/objpscostdiving/maxlpiterquot maximal fraction of diving LP iterations compared to total iteration number
Range: [0, 1]
0.01
Options for expert users
heuristics/objpscostdiving/depthfac maximal diving depth: number of binary/integer variables times depthfac
Range: [0, ∞]
0.5
heuristics/objpscostdiving/depthfacnosol maximal diving depth factor if no feasible solution was found yet
Range: [0, ∞]
2
heuristics/objpscostdiving/maxdepth maximal depth level to call primal heuristic <objpscostdiving> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/objpscostdiving/maxreldepth maximal relative depth to start diving
Range: [0, 1]
1
heuristics/objpscostdiving/maxsols total number of feasible solutions found up to which heuristic is called (-1: no limit)
Range: {-1, ..., ∞}
-1
heuristics/objpscostdiving/minreldepth minimal relative depth to start diving
Range: [0, 1]
0
heuristics/objpscostdiving/priority priority of heuristic <objpscostdiving>
Range: {-536870912, ..., 536870911}
-1004000

heuristics/octane

Option Description Default
heuristics/octane/freq frequency for calling primal heuristic <octane> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
-1
heuristics/octane/freqofs frequency offset for calling primal heuristic <octane>
Range: {0, ..., 65534}
0
Options for expert users
heuristics/octane/ffirst number of 0-1-points to be tested at first whether they violate a common row
Range: {1, ..., ∞}
10
heuristics/octane/fmax number of 0-1-points to be tested as possible solutions by OCTANE
Range: {1, ..., ∞}
100
heuristics/octane/maxdepth maximal depth level to call primal heuristic <octane> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/octane/priority priority of heuristic <octane>
Range: {-536870912, ..., 536870911}
-1008000
heuristics/octane/useavgnbray should the weighted average of the nonbasic cone be used as one ray direction?
Range: boolean
1
heuristics/octane/useavgray should the average of the basic cone be used as one ray direction?
Range: boolean
1
heuristics/octane/useavgwgtray should the weighted average of the basic cone be used as one ray direction?
Range: boolean
1
heuristics/octane/usediffray should the difference between the root solution and the current LP solution be used as one ray direction?
Range: boolean
0
heuristics/octane/usefracspace execute OCTANE only in the space of fractional variables (TRUE) or in the full space?
Range: boolean
1
heuristics/octane/useobjray should the inner normal of the objective be used as one ray direction?
Range: boolean
1

heuristics/ofins

Option Description Default
heuristics/ofins/freq frequency for calling primal heuristic <ofins> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
0
heuristics/ofins/freqofs frequency offset for calling primal heuristic <ofins>
Range: {0, ..., 65534}
0
heuristics/ofins/maxchange maximal rate of change per coefficient to get fixed
Range: [0, 1]
0.04
heuristics/ofins/maxchangerate maximal rate of changed coefficients
Range: [0, 1]
0.5
heuristics/ofins/nodesofs number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞}
500
heuristics/ofins/nodesquot contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1]
0.1
Options for expert users
heuristics/ofins/addallsols should all subproblem solutions be added to the original SCIP?
Range: boolean
0
heuristics/ofins/copycuts should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean
1
heuristics/ofins/lplimfac factor by which the limit on the number of LP depends on the node limit
Range: [1, ∞]
2
heuristics/ofins/maxdepth maximal depth level to call primal heuristic <ofins> (-1: no limit)
Range: {-1, ..., 65534}
0
heuristics/ofins/maxnodes maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞}
5000
heuristics/ofins/minimprove factor by which RENS should at least improve the incumbent
Range: [0, 1]
0.01
heuristics/ofins/minnodes minimum number of nodes required to start the subproblem
Range: {0, ..., ∞}
50
heuristics/ofins/priority priority of heuristic <ofins>
Range: {-536870912, ..., 536870911}
60000

heuristics/oneopt

Option Description Default
heuristics/oneopt/freq frequency for calling primal heuristic <oneopt> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
1
heuristics/oneopt/freqofs frequency offset for calling primal heuristic <oneopt>
Range: {0, ..., 65534}
0
Options for expert users
heuristics/oneopt/beforepresol should the heuristic be called before presolving?
Range: boolean
0
heuristics/oneopt/duringroot should the heuristic be called before and during the root node?
Range: boolean
1
heuristics/oneopt/forcelpconstruction should the construction of the LP be forced even if LP solving is deactivated?
Range: boolean
0
heuristics/oneopt/maxdepth maximal depth level to call primal heuristic <oneopt> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/oneopt/priority priority of heuristic <oneopt>
Range: {-536870912, ..., 536870911}
-20000
heuristics/oneopt/useloop should the heuristic continue to run as long as improvements are found?
Range: boolean
1
heuristics/oneopt/weightedobj should the objective be weighted with the potential shifting value when sorting the shifting candidates?
Range: boolean
1

heuristics/padm

Option Description Default
heuristics/padm/assignlinking should linking constraints be assigned?
Range: boolean
1
heuristics/padm/freq frequency for calling primal heuristic <padm> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
0
heuristics/padm/freqofs frequency offset for calling primal heuristic <padm>
Range: {0, ..., 65534}
0
heuristics/padm/original should the original problem be used?
Range: boolean
0
heuristics/padm/timing should the heuristic run before or after the processing of the node? (0: before, 1: after, 2: both)
Range: {0, ..., 2}
0
Options for expert users
heuristics/padm/admiterations maximal number of ADM iterations in each penalty loop
Range: {1, ..., 100}
4
heuristics/padm/gap mipgap at start
Range: [0, 16]
2
heuristics/padm/maxdepth maximal depth level to call primal heuristic <padm> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/padm/maxnodes maximum number of nodes to regard in all subproblems
Range: {0, ..., ∞}
5000
heuristics/padm/minnodes minimum number of nodes to regard in one subproblem
Range: {0, ..., ∞}
50
heuristics/padm/nodefac factor to control nodelimits of subproblems
Range: [0, 0.99]
0.8
heuristics/padm/penaltyiterations maximal number of penalty iterations
Range: {1, ..., 100000}
100
heuristics/padm/priority priority of heuristic <padm>
Range: {-536870912, ..., 536870911}
70000
heuristics/padm/scaling enable sigmoid rescaling of penalty parameters
Range: boolean
1

heuristics/proximity

Option Description Default
heuristics/proximity/freq frequency for calling primal heuristic <proximity> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
-1
heuristics/proximity/freqofs frequency offset for calling primal heuristic <proximity>
Range: {0, ..., 65534}
0
Options for expert users
heuristics/proximity/binvarquot threshold for percentage of binary variables required to start
Range: [0, 1]
0.1
heuristics/proximity/lpitersquot quotient of sub-MIP LP iterations with respect to LP iterations so far
Range: [0, 1]
0.2
heuristics/proximity/maxdepth maximal depth level to call primal heuristic <proximity> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/proximity/maxlpiters maximum number of LP iterations to be performed in the subproblem
Range: {-1, ..., ∞}
100000
heuristics/proximity/maxnodes maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞}
10000
heuristics/proximity/mingap minimum primal-dual gap for which the heuristic is executed
Range: [0, ∞]
0.01
heuristics/proximity/minimprove factor by which proximity should at least improve the incumbent
Range: [0, 1]
0.02
heuristics/proximity/minlpiters minimum number of LP iterations performed in subproblem
Range: {0, ..., ∞}
200
heuristics/proximity/minnodes minimum number of nodes required to start the subproblem
Range: {0, ..., ∞}
1
heuristics/proximity/nodesofs number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞}
50
heuristics/proximity/nodesquot sub-MIP node limit w.r.t number of original nodes
Range: [0, ∞]
0.1
heuristics/proximity/priority priority of heuristic <proximity>
Range: {-536870912, ..., 536870911}
-2000000
heuristics/proximity/restart should the heuristic immediately run again on its newly found solution?
Range: boolean
1
heuristics/proximity/usefinallp should the heuristic solve a final LP in case of continuous objective variables?
Range: boolean
0
heuristics/proximity/uselprows should subproblem be constructed based on LP row information?
Range: boolean
0
heuristics/proximity/useuct should uct node selection be used at the beginning of the search?
Range: boolean
0
heuristics/proximity/waitingnodes waiting nodes since last incumbent before heuristic is executed
Range: {0, ..., ∞}
100

heuristics/pscostdiving

Option Description Default
heuristics/pscostdiving/backtrack use one level of backtracking if infeasibility is encountered?
Range: boolean
1
heuristics/pscostdiving/freq frequency for calling primal heuristic <pscostdiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
10
heuristics/pscostdiving/freqofs frequency offset for calling primal heuristic <pscostdiving>
Range: {0, ..., 65534}
2
heuristics/pscostdiving/lpresolvedomchgquot percentage of immediate domain changes during probing to trigger LP resolve
Range: [0, ∞]
0.15
heuristics/pscostdiving/lpsolvefreq LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
Range: {0, ..., ∞}
0
heuristics/pscostdiving/maxlpiterofs additional number of allowed LP iterations
Range: {0, ..., ∞}
1000
heuristics/pscostdiving/maxlpiterquot maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞]
0.05
heuristics/pscostdiving/onlylpbranchcands should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean
1
Options for expert users
heuristics/pscostdiving/maxdepth maximal depth level to call primal heuristic <pscostdiving> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/pscostdiving/maxdiveavgquot maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞]
0
heuristics/pscostdiving/maxdiveavgquotnosol maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞]
0
heuristics/pscostdiving/maxdiveubquot maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1]
0.8
heuristics/pscostdiving/maxdiveubquotnosol maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1]
0.1
heuristics/pscostdiving/maxreldepth maximal relative depth to start diving
Range: [0, 1]
1
heuristics/pscostdiving/minreldepth minimal relative depth to start diving
Range: [0, 1]
0
heuristics/pscostdiving/priority priority of heuristic <pscostdiving>
Range: {-536870912, ..., 536870911}
-1002000

heuristics/randrounding

Option Description Default
heuristics/randrounding/freq frequency for calling primal heuristic <randrounding> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
20
heuristics/randrounding/freqofs frequency offset for calling primal heuristic <randrounding>
Range: {0, ..., 65534}
0
Options for expert users
heuristics/randrounding/maxdepth maximal depth level to call primal heuristic <randrounding> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/randrounding/maxproprounds limit of rounds for each propagation call
Range: {-1, ..., ∞}
1
heuristics/randrounding/oncepernode should the heuristic only be called once per node?
Range: boolean
0
heuristics/randrounding/priority priority of heuristic <randrounding>
Range: {-536870912, ..., 536870911}
-200
heuristics/randrounding/propagateonlyroot should the probing part of the heuristic be applied exclusively at the root node?
Range: boolean
1
heuristics/randrounding/usesimplerounding should the heuristic apply the variable lock strategy of simple rounding, if possible?
Range: boolean
0

heuristics/rens

Option Description Default
heuristics/rens/bestsollimit limit on number of improving incumbent solutions in sub-CIP
Range: {-1, ..., ∞}
-1
heuristics/rens/freq frequency for calling primal heuristic <rens> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
0
heuristics/rens/freqofs frequency offset for calling primal heuristic <rens>
Range: {0, ..., 65534}
0
heuristics/rens/minfixingrate minimum percentage of integer variables that have to be fixable
Range: [0, 1]
0.5
heuristics/rens/nodesofs number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞}
500
heuristics/rens/nodesquot contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1]
0.1
heuristics/rens/startsol solution that is used for fixing values ('l'p relaxation, 'n'lp relaxation)
Range: n, l
l
Options for expert users
heuristics/rens/addallsols should all subproblem solutions be added to the original SCIP?
Range: boolean
0
heuristics/rens/binarybounds should general integers get binary bounds [floor(.),ceil(.)] ?
Range: boolean
1
heuristics/rens/copycuts if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean
1
heuristics/rens/extratime should the RENS sub-CIP get its own full time limit? This is only for testing and not recommended!
Range: boolean
0
heuristics/rens/fullscale should the RENS sub-CIP be solved with cuts, conflicts, strong branching,... This is only for testing and not recommended!
Range: boolean
0
heuristics/rens/lplimfac factor by which the limit on the number of LP depends on the node limit
Range: [1, ∞]
2
heuristics/rens/maxdepth maximal depth level to call primal heuristic <rens> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/rens/maxnodes maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞}
5000
heuristics/rens/minimprove factor by which RENS should at least improve the incumbent
Range: [0, 1]
0.01
heuristics/rens/minnodes minimum number of nodes required to start the subproblem
Range: {0, ..., ∞}
50
heuristics/rens/priority priority of heuristic <rens>
Range: {-536870912, ..., 536870911}
-1100000
heuristics/rens/uselprows should subproblem be created out of the rows in the LP rows?
Range: boolean
0
heuristics/rens/useuct should uct node selection be used at the beginning of the search?
Range: boolean
0

heuristics/reoptsols

Option Description Default
heuristics/reoptsols/freq frequency for calling primal heuristic <reoptsols> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
0
heuristics/reoptsols/freqofs frequency offset for calling primal heuristic <reoptsols>
Range: {0, ..., 65534}
0
Options for expert users
heuristics/reoptsols/maxdepth maximal depth level to call primal heuristic <reoptsols> (-1: no limit)
Range: {-1, ..., 65534}
0
heuristics/reoptsols/maxruns check solutions of the last k runs. (-1: all)
Range: {-1, ..., ∞}
-1
heuristics/reoptsols/maxsols maximal number solutions which should be checked. (-1: all)
Range: {-1, ..., ∞}
1000
heuristics/reoptsols/priority priority of heuristic <reoptsols>
Range: {-536870912, ..., 536870911}
40000

heuristics/repair

Option Description Default
heuristics/repair/filename file name of a solution to be used as infeasible starting point, [-] if not available
Range: string
-
heuristics/repair/freq frequency for calling primal heuristic <repair> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
-1
heuristics/repair/freqofs frequency offset for calling primal heuristic <repair>
Range: {0, ..., 65534}
0
heuristics/repair/minfixingrate minimum percentage of integer variables that have to be fixed
Range: [0, 1]
0.3
heuristics/repair/nodesofs number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞}
500
heuristics/repair/nodesquot contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1]
0.1
heuristics/repair/roundit True : fractional variables which are not fractional in the given solution are rounded, FALSE : solving process of this heuristic is stopped.
Range: boolean
1
heuristics/repair/useobjfactor should a scaled objective function for original variables be used in repair subproblem?
Range: boolean
0
heuristics/repair/useslackvars should slack variables be used in repair subproblem?
Range: boolean
0
heuristics/repair/usevarfix should variable fixings be used in repair subproblem?
Range: boolean
1
Options for expert users
heuristics/repair/alpha factor for the potential of var fixings
Range: [0, 100]
2
heuristics/repair/maxdepth maximal depth level to call primal heuristic <repair> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/repair/maxnodes maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞}
5000
heuristics/repair/minnodes minimum number of nodes required to start the subproblem
Range: {0, ..., ∞}
50
heuristics/repair/priority priority of heuristic <repair>
Range: {-536870912, ..., 536870911}
0

heuristics/rins

Option Description Default
heuristics/rins/freq frequency for calling primal heuristic <rins> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
25
heuristics/rins/freqofs frequency offset for calling primal heuristic <rins>
Range: {0, ..., 65534}
0
heuristics/rins/minfixingrate minimum percentage of integer variables that have to be fixed
Range: [0, 1]
0.3
heuristics/rins/nodesofs number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞}
500
heuristics/rins/nodesquot contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1]
0.3
Options for expert users
heuristics/rins/copycuts if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean
1
heuristics/rins/lplimfac factor by which the limit on the number of LP depends on the node limit
Range: [1, ∞]
2
heuristics/rins/maxdepth maximal depth level to call primal heuristic <rins> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/rins/maxnodes maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞}
5000
heuristics/rins/minimprove factor by which rins should at least improve the incumbent
Range: [0, 1]
0.01
heuristics/rins/minnodes minimum number of nodes required to start the subproblem
Range: {0, ..., ∞}
50
heuristics/rins/nwaitingnodes number of nodes without incumbent change that heuristic should wait
Range: {0, ..., ∞}
200
heuristics/rins/priority priority of heuristic <rins>
Range: {-536870912, ..., 536870911}
-1101000
heuristics/rins/uselprows should subproblem be created out of the rows in the LP rows?
Range: boolean
0
heuristics/rins/useuct should uct node selection be used at the beginning of the search?
Range: boolean
0

heuristics/rootsoldiving

Option Description Default
heuristics/rootsoldiving/freq frequency for calling primal heuristic <rootsoldiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
20
heuristics/rootsoldiving/freqofs frequency offset for calling primal heuristic <rootsoldiving>
Range: {0, ..., 65534}
5
heuristics/rootsoldiving/maxlpiterofs additional number of allowed LP iterations
Range: {0, ..., ∞}
1000
heuristics/rootsoldiving/maxlpiterquot maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞]
0.01
Options for expert users
heuristics/rootsoldiving/alpha soft rounding factor to fade out objective coefficients
Range: [0, 1]
0.9
heuristics/rootsoldiving/depthfac maximal diving depth: number of binary/integer variables times depthfac
Range: [0, ∞]
0.5
heuristics/rootsoldiving/depthfacnosol maximal diving depth factor if no feasible solution was found yet
Range: [0, ∞]
2
heuristics/rootsoldiving/maxdepth maximal depth level to call primal heuristic <rootsoldiving> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/rootsoldiving/maxreldepth maximal relative depth to start diving
Range: [0, 1]
1
heuristics/rootsoldiving/maxsols total number of feasible solutions found up to which heuristic is called (-1: no limit)
Range: {-1, ..., ∞}
-1
heuristics/rootsoldiving/minreldepth minimal relative depth to start diving
Range: [0, 1]
0
heuristics/rootsoldiving/priority priority of heuristic <rootsoldiving>
Range: {-536870912, ..., 536870911}
-1005000

heuristics/rounding

Option Description Default
heuristics/rounding/freq frequency for calling primal heuristic <rounding> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
1
heuristics/rounding/freqofs frequency offset for calling primal heuristic <rounding>
Range: {0, ..., 65534}
0
Options for expert users
heuristics/rounding/maxdepth maximal depth level to call primal heuristic <rounding> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/rounding/oncepernode should the heuristic only be called once per node?
Range: boolean
0
heuristics/rounding/priority priority of heuristic <rounding>
Range: {-536870912, ..., 536870911}
-1000
heuristics/rounding/successfactor number of calls per found solution that are considered as standard success, a higher factor causes the heuristic to be called more often
Range: {-1, ..., ∞}
100

heuristics/shiftandpropagate

Option Description Default
heuristics/shiftandpropagate/freq frequency for calling primal heuristic <shiftandpropagate> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
0
heuristics/shiftandpropagate/freqofs frequency offset for calling primal heuristic <shiftandpropagate>
Range: {0, ..., 65534}
0
Options for expert users
heuristics/shiftandpropagate/binlocksfirst should binary variables with no locks be preferred in the ordering?
Range: boolean
0
heuristics/shiftandpropagate/collectstats should variable statistics be collected during probing?
Range: boolean
1
heuristics/shiftandpropagate/cutoffbreaker The number of cutoffs before heuristic stops
Range: {-1, ..., 1000000}
15
heuristics/shiftandpropagate/fixbinlocks should binary variables with no locks in one direction be fixed to that direction?
Range: boolean
1
heuristics/shiftandpropagate/impliscontinuous should implicit integer variables be treated as continuous variables?
Range: boolean
1
heuristics/shiftandpropagate/maxcutoffquot maximum percentage of allowed cutoffs before stopping the heuristic
Range: [0, 2]
0
heuristics/shiftandpropagate/maxdepth maximal depth level to call primal heuristic <shiftandpropagate> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/shiftandpropagate/minfixingratelp minimum fixing rate over all variables (including continuous) to solve LP
Range: [0, 1]
0
heuristics/shiftandpropagate/normalize should coefficients and left/right hand sides be normalized by max row coeff?
Range: boolean
1
heuristics/shiftandpropagate/nozerofixing should variables with a zero shifting value be delayed instead of being fixed?
Range: boolean
0
heuristics/shiftandpropagate/nproprounds The number of propagation rounds used for each propagation
Range: {-1, ..., 1000}
10
heuristics/shiftandpropagate/onlywithoutsol Should heuristic only be executed if no primal solution was found, yet?
Range: boolean
1
heuristics/shiftandpropagate/preferbinaries Should binary variables be shifted first?
Range: boolean
1
heuristics/shiftandpropagate/priority priority of heuristic <shiftandpropagate>
Range: {-536870912, ..., 536870911}
1000
heuristics/shiftandpropagate/probing Should domains be reduced by probing?
Range: boolean
1
heuristics/shiftandpropagate/relax Should continuous variables be relaxed?
Range: boolean
1
heuristics/shiftandpropagate/selectbest should the heuristic choose the best candidate in every round? (set to FALSE for static order)?
Range: boolean
0
heuristics/shiftandpropagate/sortkey the key for variable sorting: (n)orms down, norms (u)p, (v)iolations down, viola(t)ions up, or (r)andom
Range: n, r, t, u, v
v
heuristics/shiftandpropagate/sortvars Should variables be sorted for the heuristic?
Range: boolean
1
heuristics/shiftandpropagate/stopafterfeasible Should the heuristic stop calculating optimal shift values when no more rows are violated?
Range: boolean
1
heuristics/shiftandpropagate/updateweights should row weight be increased every time the row is violated?
Range: boolean
0

heuristics/shifting

Option Description Default
heuristics/shifting/freq frequency for calling primal heuristic <shifting> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
10
heuristics/shifting/freqofs frequency offset for calling primal heuristic <shifting>
Range: {0, ..., 65534}
0
Options for expert users
heuristics/shifting/maxdepth maximal depth level to call primal heuristic <shifting> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/shifting/priority priority of heuristic <shifting>
Range: {-536870912, ..., 536870911}
-5000

heuristics/simplerounding

Option Description Default
heuristics/simplerounding/freq frequency for calling primal heuristic <simplerounding> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
1
heuristics/simplerounding/freqofs frequency offset for calling primal heuristic <simplerounding>
Range: {0, ..., 65534}
0
Options for expert users
heuristics/simplerounding/maxdepth maximal depth level to call primal heuristic <simplerounding> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/simplerounding/oncepernode should the heuristic only be called once per node?
Range: boolean
0
heuristics/simplerounding/priority priority of heuristic <simplerounding>
Range: {-536870912, ..., 536870911}
0

heuristics/subnlp

Option Description Default
heuristics/subnlp/forbidfixings whether to add constraints that forbid specific fixings that turned out to be infeasible
Range: boolean
1
heuristics/subnlp/freq frequency for calling primal heuristic <subnlp> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
1
heuristics/subnlp/freqofs frequency offset for calling primal heuristic <subnlp>
Range: {0, ..., 65534}
0
heuristics/subnlp/itermin contingent of NLP iterations in relation to the number of nodes in SCIP
Range: {0, ..., ∞}
300
heuristics/subnlp/iteroffset number of iterations added to the contingent of the total number of iterations
Range: {0, ..., ∞}
500
heuristics/subnlp/iterquotient contingent of NLP iterations in relation to the number of nodes in SCIP
Range: [0, ∞]
0.1
heuristics/subnlp/nlpiterlimit iteration limit of NLP solver; 0 to use solver default
Range: {0, ..., ∞}
0
heuristics/subnlp/nlptimelimit time limit of NLP solver; 0 to use solver default
Range: [0, ∞]
0
heuristics/subnlp/nlpverblevel verbosity level of NLP solver
Range: {0, ..., ∞}
0
heuristics/subnlp/runalways whether to run NLP heuristic always if starting point available (does not use iteroffset,iterquot,itermin)
Range: boolean
0
Options for expert users
heuristics/subnlp/keepcopy whether to keep SCIP copy or to create new copy each time heuristic is applied
Range: boolean
1
heuristics/subnlp/maxdepth maximal depth level to call primal heuristic <subnlp> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/subnlp/maxpresolverounds limit on number of presolve rounds in sub-SCIP (-1 for unlimited, 0 for no presolve)
Range: {-1, ..., ∞}
-1
heuristics/subnlp/minimprove factor by which NLP heuristic should at least improve the incumbent
Range: [0, 1]
0.01
heuristics/subnlp/nlpoptfile name of an NLP solver specific options file
Range: string
heuristics/subnlp/priority priority of heuristic <subnlp>
Range: {-536870912, ..., 536870911}
-2000000
heuristics/subnlp/resolvefromscratch should the NLP resolve be started from the original starting point or the infeasible solution?
Range: boolean
1
heuristics/subnlp/resolvetolfactor if SCIP does not accept a NLP feasible solution, resolve NLP with feas. tolerance reduced by this factor (set to 1.0 to turn off resolve)
Range: [0, 1]
0.001

heuristics/trivial

Option Description Default
heuristics/trivial/freq frequency for calling primal heuristic <trivial> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
0
heuristics/trivial/freqofs frequency offset for calling primal heuristic <trivial>
Range: {0, ..., 65534}
0
Options for expert users
heuristics/trivial/maxdepth maximal depth level to call primal heuristic <trivial> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/trivial/priority priority of heuristic <trivial>
Range: {-536870912, ..., 536870911}
10000

heuristics/trivialnegation

Option Description Default
heuristics/trivialnegation/freq frequency for calling primal heuristic <trivialnegation> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
0
heuristics/trivialnegation/freqofs frequency offset for calling primal heuristic <trivialnegation>
Range: {0, ..., 65534}
0
Options for expert users
heuristics/trivialnegation/maxdepth maximal depth level to call primal heuristic <trivialnegation> (-1: no limit)
Range: {-1, ..., 65534}
0
heuristics/trivialnegation/priority priority of heuristic <trivialnegation>
Range: {-536870912, ..., 536870911}
40000

heuristics/trustregion

Option Description Default
heuristics/trustregion/bestsollimit limit on number of improving incumbent solutions in sub-CIP
Range: {-1, ..., ∞}
3
heuristics/trustregion/freq frequency for calling primal heuristic <trustregion> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
-1
heuristics/trustregion/freqofs frequency offset for calling primal heuristic <trustregion>
Range: {0, ..., 65534}
0
heuristics/trustregion/minbinvars the number of binary variables necessary to run the heuristic
Range: {1, ..., ∞}
10
heuristics/trustregion/nodesofs number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞}
1000
heuristics/trustregion/nodesquot contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1]
0.05
heuristics/trustregion/objminimprove the minimum absolute improvement in the objective function value
Range: [0, ∞]
0.01
heuristics/trustregion/violpenalty the penalty for each change in the binary variables from the candidate solution
Range: [0, ∞]
100
Options for expert users
heuristics/trustregion/copycuts if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean
1
heuristics/trustregion/lplimfac factor by which the limit on the number of LP depends on the node limit
Range: [1, ∞]
1.5
heuristics/trustregion/maxdepth maximal depth level to call primal heuristic <trustregion> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/trustregion/maxnodes maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞}
10000
heuristics/trustregion/minnodes minimum number of nodes required to start the subproblem
Range: {0, ..., ∞}
100
heuristics/trustregion/nwaitingnodes number of nodes without incumbent change that heuristic should wait
Range: {0, ..., ∞}
1
heuristics/trustregion/priority priority of heuristic <trustregion>
Range: {-536870912, ..., 536870911}
-1102000
heuristics/trustregion/uselprows should subproblem be created out of the rows in the LP rows?
Range: boolean
0

heuristics/trysol

Option Description Default
heuristics/trysol/freq frequency for calling primal heuristic <trysol> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
1
heuristics/trysol/freqofs frequency offset for calling primal heuristic <trysol>
Range: {0, ..., 65534}
0
Options for expert users
heuristics/trysol/maxdepth maximal depth level to call primal heuristic <trysol> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/trysol/priority priority of heuristic <trysol>
Range: {-536870912, ..., 536870911}
-3000000

heuristics/twoopt

Option Description Default
heuristics/twoopt/freq frequency for calling primal heuristic <twoopt> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
-1
heuristics/twoopt/freqofs frequency offset for calling primal heuristic <twoopt>
Range: {0, ..., 65534}
0
Options for expert users
heuristics/twoopt/intopt Should Integer-2-Optimization be applied or not?
Range: boolean
0
heuristics/twoopt/matchingrate parameter to determine the percentage of rows two variables have to share before they are considered equal
Range: [0, 1]
0.5
heuristics/twoopt/maxdepth maximal depth level to call primal heuristic <twoopt> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/twoopt/maxnslaves maximum number of slaves for one master variable
Range: {-1, ..., 1000000}
199
heuristics/twoopt/priority priority of heuristic <twoopt>
Range: {-536870912, ..., 536870911}
-20100
heuristics/twoopt/waitingnodes user parameter to determine number of nodes to wait after last best solution before calling heuristic
Range: {0, ..., 10000}
0

heuristics/undercover

Option Description Default
heuristics/undercover/fixingalts prioritized sequence of fixing values used ('l'p relaxation, 'n'lp relaxation, 'i'ncumbent solution)
Range: string
li
heuristics/undercover/freq frequency for calling primal heuristic <undercover> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
0
heuristics/undercover/freqofs frequency offset for calling primal heuristic <undercover>
Range: {0, ..., 65534}
0
heuristics/undercover/nodesofs number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞}
500
heuristics/undercover/nodesquot contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1]
0.1
heuristics/undercover/onlyconvexify should we only fix variables in order to obtain a convex problem?
Range: boolean
0
heuristics/undercover/postnlp should the NLP heuristic be called to polish a feasible solution?
Range: boolean
1
Options for expert users
heuristics/undercover/beforecuts should the heuristic be called at root node before cut separation?
Range: boolean
1
heuristics/undercover/conflictweight weight for conflict score in fixing order
Range: real
1000
heuristics/undercover/copycuts should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean
1
heuristics/undercover/coverbd should bounddisjunction constraints be covered (or just copied)?
Range: boolean
0
heuristics/undercover/coveringobj objective function of the covering problem (influenced nonlinear 'c'onstraints/'t'erms, 'd'omain size, 'l'ocks, 'm'in of up/down locks, 'u'nit penalties)
Range: c, d, l, m, t, u
u
heuristics/undercover/cutoffweight weight for cutoff score in fixing order
Range: [0, ∞]
1
heuristics/undercover/fixingorder order in which variables should be fixed (increasing 'C'onflict score, decreasing 'c'onflict score, increasing 'V'ariable index, decreasing 'v'ariable index
Range: C, c, V, v
v
heuristics/undercover/fixintfirst should integer variables in the cover be fixed first?
Range: boolean
0
heuristics/undercover/inferenceweight weight for inference score in fixing order
Range: real
1
heuristics/undercover/locksrounding shall LP values for integer vars be rounded according to locks?
Range: boolean
1
heuristics/undercover/maxbacktracks maximum number of backtracks in fix-and-propagate
Range: {0, ..., ∞}
6
heuristics/undercover/maxcoversizeconss maximum coversize maximum coversize (as ratio to the percentage of non-affected constraints)
Range: [0, ∞]
heuristics/undercover/maxcoversizevars maximum coversize (as fraction of total number of variables)
Range: [0, 1]
1
heuristics/undercover/maxdepth maximal depth level to call primal heuristic <undercover> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/undercover/maxnodes maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞}
500
heuristics/undercover/maxrecovers maximum number of recoverings
Range: {0, ..., ∞}
0
heuristics/undercover/maxreorders maximum number of reorderings of the fixing order
Range: {0, ..., ∞}
1
heuristics/undercover/mincoveredabs minimum number of nonlinear constraints in the original problem
Range: {0, ..., ∞}
5
heuristics/undercover/mincoveredrel minimum percentage of nonlinear constraints in the original problem
Range: [0, 1]
0.15
heuristics/undercover/minimprove factor by which the heuristic should at least improve the incumbent
Range: [-1, 1]
0
heuristics/undercover/minnodes minimum number of nodes required to start the subproblem
Range: {0, ..., ∞}
500
heuristics/undercover/priority priority of heuristic <undercover>
Range: {-536870912, ..., 536870911}
-1110000
heuristics/undercover/recoverdiv fraction of covering variables in the last cover which need to change their value when recovering
Range: [0, 1]
0.9
heuristics/undercover/reusecover shall the cover be reused if a conflict was added after an infeasible subproblem?
Range: boolean
0

heuristics/vbounds

Option Description Default
heuristics/vbounds/freq frequency for calling primal heuristic <vbounds> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
0
heuristics/vbounds/freqofs frequency offset for calling primal heuristic <vbounds>
Range: {0, ..., 65534}
0
heuristics/vbounds/minintfixingrate minimum percentage of integer variables that have to be fixed
Range: [0, 1]
0.65
heuristics/vbounds/minmipfixingrate minimum percentage of variables that have to be fixed within sub-SCIP (integer and continuous)
Range: [0, 1]
0.65
heuristics/vbounds/nodesofs number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞}
500
heuristics/vbounds/nodesquot contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1]
0.1
Options for expert users
heuristics/vbounds/copycuts should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean
1
heuristics/vbounds/feasvariant which variants of the vbounds heuristic that try to stay feasible should be called? (0: off, 1: w/o looking at obj, 2: only fix to best bound, 4: only fix to worst bound
Range: {0, ..., 7}
6
heuristics/vbounds/maxbacktracks maximum number of backtracks during the fixing process
Range: {-1, ..., 536870911}
10
heuristics/vbounds/maxdepth maximal depth level to call primal heuristic <vbounds> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/vbounds/maxnodes maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞}
5000
heuristics/vbounds/maxproprounds maximum number of propagation rounds during probing (-1 infinity)
Range: {-1, ..., 536870911}
2
heuristics/vbounds/minimprove factor by which vbounds heuristic should at least improve the incumbent
Range: [0, 1]
0.01
heuristics/vbounds/minnodes minimum number of nodes required to start the subproblem
Range: {0, ..., ∞}
500
heuristics/vbounds/priority priority of heuristic <vbounds>
Range: {-536870912, ..., 536870911}
2500
heuristics/vbounds/tightenvariant which tightening variants of the vbounds heuristic should be called? (0: off, 1: w/o looking at obj, 2: only fix to best bound, 4: only fix to worst bound
Range: {0, ..., 7}
7
heuristics/vbounds/uselockfixings should more variables be fixed based on variable locks if the fixing rate was not reached?
Range: boolean
0

heuristics/veclendiving

Option Description Default
heuristics/veclendiving/backtrack use one level of backtracking if infeasibility is encountered?
Range: boolean
1
heuristics/veclendiving/freq frequency for calling primal heuristic <veclendiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
10
heuristics/veclendiving/freqofs frequency offset for calling primal heuristic <veclendiving>
Range: {0, ..., 65534}
4
heuristics/veclendiving/lpresolvedomchgquot percentage of immediate domain changes during probing to trigger LP resolve
Range: [0, ∞]
0.15
heuristics/veclendiving/lpsolvefreq LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
Range: {0, ..., ∞}
0
heuristics/veclendiving/maxlpiterofs additional number of allowed LP iterations
Range: {0, ..., ∞}
1000
heuristics/veclendiving/maxlpiterquot maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞]
0.05
heuristics/veclendiving/onlylpbranchcands should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean
0
Options for expert users
heuristics/veclendiving/maxdepth maximal depth level to call primal heuristic <veclendiving> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/veclendiving/maxdiveavgquot maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞]
0
heuristics/veclendiving/maxdiveavgquotnosol maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞]
0
heuristics/veclendiving/maxdiveubquot maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1]
0.8
heuristics/veclendiving/maxdiveubquotnosol maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1]
0.1
heuristics/veclendiving/maxreldepth maximal relative depth to start diving
Range: [0, 1]
1
heuristics/veclendiving/minreldepth minimal relative depth to start diving
Range: [0, 1]
0
heuristics/veclendiving/priority priority of heuristic <veclendiving>
Range: {-536870912, ..., 536870911}
-1003100

heuristics/zeroobj

Option Description Default
heuristics/zeroobj/freq frequency for calling primal heuristic <zeroobj> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
-1
heuristics/zeroobj/freqofs frequency offset for calling primal heuristic <zeroobj>
Range: {0, ..., 65534}
0
heuristics/zeroobj/nodesofs number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞}
100
heuristics/zeroobj/nodesquot contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1]
0.1
Options for expert users
heuristics/zeroobj/addallsols should all subproblem solutions be added to the original SCIP?
Range: boolean
0
heuristics/zeroobj/maxdepth maximal depth level to call primal heuristic <zeroobj> (-1: no limit)
Range: {-1, ..., 65534}
0
heuristics/zeroobj/maxlpiters maximum number of LP iterations to be performed in the subproblem
Range: {-1, ..., ∞}
5000
heuristics/zeroobj/maxnodes maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞}
1000
heuristics/zeroobj/minimprove factor by which zeroobj should at least improve the incumbent
Range: [0, 1]
0.01
heuristics/zeroobj/minnodes minimum number of nodes required to start the subproblem
Range: {0, ..., ∞}
100
heuristics/zeroobj/onlywithoutsol should heuristic only be executed if no primal solution was found, yet?
Range: boolean
1
heuristics/zeroobj/priority priority of heuristic <zeroobj>
Range: {-536870912, ..., 536870911}
100
heuristics/zeroobj/useuct should uct node selection be used at the beginning of the search?
Range: boolean
0

heuristics/zirounding

Option Description Default
heuristics/zirounding/freq frequency for calling primal heuristic <zirounding> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534}
1
heuristics/zirounding/freqofs frequency offset for calling primal heuristic <zirounding>
Range: {0, ..., 65534}
0
Options for expert users
heuristics/zirounding/maxdepth maximal depth level to call primal heuristic <zirounding> (-1: no limit)
Range: {-1, ..., 65534}
-1
heuristics/zirounding/maxroundingloops determines maximum number of rounding loops
Range: {-1, ..., ∞}
2
heuristics/zirounding/minstopncalls determines the minimum number of calls before percentage-based deactivation of Zirounding is applied
Range: {1, ..., ∞}
1000
heuristics/zirounding/priority priority of heuristic <zirounding>
Range: {-536870912, ..., 536870911}
-500
heuristics/zirounding/stoppercentage if percentage of found solutions falls below this parameter, Zirounding will be deactivated
Range: [0, 1]
0.02
heuristics/zirounding/stopziround flag to determine if Zirounding is deactivated after a certain percentage of unsuccessful calls
Range: boolean
1

history

Option Description Default
history/allowmerge should variable histories be merged from sub-SCIPs whenever possible?
Range: boolean
0
history/allowtransfer should variable histories be transferred to initialize SCIP copies?
Range: boolean
0
history/valuebased should statistics be collected for variable domain value pairs?
Range: boolean
0

limits

Option Description Default
limits/absgap solving stops, if the absolute gap = |primalbound - dualbound| is below the given value
Range: [0, ∞]
GAMS optca
limits/autorestartnodes if solve exceeds this number of nodes for the first time, an automatic restart is triggered (-1: no automatic restart)
Range: {-1, ..., ∞}
-1
limits/bestsol solving stops, if the given number of solution improvements were found (-1: no limit)
Range: {-1, ..., ∞}
-1
limits/gap solving stops, if the relative gap = |primal - dual|/MIN(|dual|,|primal|) is below the given value, the gap is 'Infinity', if primal and dual bound have opposite signs
Range: [0, ∞]
GAMS optcr
limits/maxorigsol maximal number of solutions candidates to store in the solution storage of the original problem
Range: {0, ..., ∞}
10
limits/maxsol maximal number of solutions to store in the solution storage
Range: {1, ..., ∞}
100
limits/memory maximal memory usage in MB; reported memory usage is lower than real memory usage!
Range: [0, 8.79609e+12]
GAMS workspace
limits/nodes maximal number of nodes to process (-1: no limit)
Range: {-1, ..., ∞}
GAMS nodlim, if > 0, otherwise -1
limits/restarts solving stops, if the given number of restarts was triggered (-1: no limit)
Range: {-1, ..., ∞}
-1
limits/softtime soft time limit which should be applied after first solution was found (-1.0: disabled)
Range: [-1, ∞]
-1
limits/solutions solving stops, if the given number of solutions were found (-1: no limit)
Range: {-1, ..., ∞}
-1
limits/stallnodes solving stops, if the given number of nodes was processed since the last improvement of the primal solution value (-1: no limit)
Range: {-1, ..., ∞}
-1
limits/time maximal time in seconds to run
Range: [0, ∞]
GAMS reslim
limits/totalnodes maximal number of total nodes (incl. restarts) to process (-1: no limit)
Range: {-1, ..., ∞}
-1

lp

Option Description Default
lp/alwaysgetduals should the Farkas duals always be collected when an LP is found to be infeasible?
Range: boolean
0
lp/initalgorithm LP algorithm for solving initial LP relaxations (automatic 's'implex, 'p'rimal simplex, 'd'ual simplex, 'b'arrier, barrier with 'c'rossover)
Range: s, p, d, b, c
s
lp/pricing LP pricing strategy ('l'pi default, 'a'uto, 'f'ull pricing, 'p'artial, 's'teepest edge pricing, 'q'uickstart steepest edge pricing, 'd'evex pricing)
Range: l, a, f, p, s, q, d
l
lp/resolvealgorithm LP algorithm for resolving LP relaxations if a starting basis exists (automatic 's'implex, 'p'rimal simplex, 'd'ual simplex, 'b'arrier, barrier with 'c'rossover)
Range: s, p, d, b, c
s
lp/solvedepth maximal depth for solving LP at the nodes (-1: no depth limit)
Range: {-1, ..., 65534}
-1
lp/solvefreq frequency for solving LP at the nodes (-1: never; 0: only root LP)
Range: {-1, ..., 65534}
1
lp/solver LP solver to use (clp, cplex, soplex)
Range: string
cplex, if licensed, otherwise soplex
Options for expert users
lp/checkdualfeas should LP solutions be checked for dual feasibility, resolving LP when numerical troubles occur?
Range: boolean
1
lp/checkfarkas should infeasibility proofs from the LP be checked?
Range: boolean
1
lp/checkprimfeas should LP solutions be checked for primal feasibility, resolving LP when numerical troubles occur?
Range: boolean
1
lp/checkstability should LP solver's return status be checked for stability?
Range: boolean
1
lp/cleanupcols should new non-basic columns be removed after LP solving?
Range: boolean
0
lp/cleanupcolsroot should new non-basic columns be removed after root LP solving?
Range: boolean
0
lp/cleanuprows should new basic rows be removed after LP solving?
Range: boolean
1
lp/cleanuprowsroot should new basic rows be removed after root LP solving?
Range: boolean
1
lp/clearinitialprobinglp should lp state be cleared at the end of probing mode when lp was initially unsolved, e.g., when called right after presolving?
Range: boolean
1
lp/colagelimit maximum age a dynamic column can reach before it is deleted from the LP (-1: don't delete columns due to aging)
Range: {-1, ..., ∞}
10
lp/conditionlimit maximum condition number of LP basis counted as stable (-1.0: no limit)
Range: [-1, ∞]
-1
lp/disablecutoff disable the cutoff bound in the LP solver? (0: enabled, 1: disabled, 2: auto)
Range: {0, ..., 2}
2
lp/fastmip which FASTMIP setting of LP solver should be used? 0: off, 1: low
Range: {0, ..., 1}
1
lp/freesolvalbuffers should the buffers for storing LP solution values during diving be freed at end of diving?
Range: boolean
0
lp/iterlim iteration limit for each single LP solve (-1: no limit)
Range: {-1, ..., ∞}
-1
lp/lexdualalgo should the lexicographic dual algorithm be used?
Range: boolean
0
lp/lexdualbasic choose fractional basic variables in lexicographic dual algorithm?
Range: boolean
0
lp/lexdualmaxrounds maximum number of rounds in the lexicographic dual algorithm (-1: unbounded)
Range: {-1, ..., ∞}
2
lp/lexdualrootonly should the lexicographic dual algorithm be applied only at the root node
Range: boolean
1
lp/lexdualstalling turn on the lex dual algorithm only when stalling?
Range: boolean
1
lp/minmarkowitz minimal Markowitz threshold to control sparsity/stability in LU factorization
Range: [0.0001, 0.9999]
0.01
lp/presolving should presolving of LP solver be used?
Range: boolean
1
lp/refactorinterval LP refactorization interval (0: auto)
Range: {0, ..., ∞}
0
lp/resolveiterfac factor of average LP iterations that is used as LP iteration limit for LP resolve (-1: unlimited)
Range: [-1, ∞]
-1
lp/resolveitermin minimum number of iterations that are allowed for LP resolve
Range: {1, ..., ∞}
1000
lp/resolverestore should the LP be resolved to restore the state at start of diving (if FALSE we buffer the solution values)?
Range: boolean
0
lp/rootiterlim iteration limit for initial root LP solve (-1: no limit)
Range: {-1, ..., ∞}
-1
lp/rowagelimit maximum age a dynamic row can reach before it is deleted from the LP (-1: don't delete rows due to aging)
Range: {-1, ..., ∞}
10
lp/rowrepswitch simplex algorithm shall use row representation of the basis if number of rows divided by number of columns exceeds this value (-1.0 to disable row representation)
Range: [-1, ∞]
1.2
lp/scaling LP scaling (0: none, 1: normal, 2: aggressive)
Range: {0, ..., 2}
1
lp/solutionpolishing LP solution polishing method (0: disabled, 1: only root, 2: always, 3: auto)
Range: {0, ..., 3}
3
lp/threads number of threads used for solving the LP (0: automatic)
Range: {0, ..., 64}
GAMS threads

memory

Option Description Default
memory/savefac fraction of maximal memory usage resulting in switch to memory saving mode
Range: [0, 1]
0.8
Options for expert users
memory/arraygrowfac memory growing factor for dynamically allocated arrays
Range: [1, 10]
1.2
memory/arraygrowinit initial size of dynamically allocated arrays
Range: {0, ..., ∞}
4
memory/pathgrowfac memory growing factor for path array
Range: [1, 10]
2
memory/pathgrowinit initial size of path array
Range: {0, ..., ∞}
256
memory/treegrowfac memory growing factor for tree array
Range: [1, 10]
2
memory/treegrowinit initial size of tree array
Range: {0, ..., ∞}
65536

misc

Option Description Default
misc/allowstrongdualreds should strong dual reductions be allowed in propagation and presolving?
Range: boolean
1
misc/allowweakdualreds should weak dual reductions be allowed in propagation and presolving?
Range: boolean
1
misc/calcintegral should SCIP calculate the primal dual integral value?
Range: boolean
1
misc/catchctrlc should the CTRL-C interrupt be caught by SCIP?
Range: boolean
1
misc/estimexternmem should the usage of external memory be estimated?
Range: boolean
1
misc/finitesolutionstore should SCIP try to remove infinite fixings from solutions copied to the solution store?
Range: boolean
0
misc/improvingsols should only solutions be checked which improve the primal bound
Range: boolean
0
misc/outputorigsol should the best solution be transformed to the orignal space and be output in command line run?
Range: boolean
1
misc/printreason should the reason be printed if a given start solution is infeasible
Range: boolean
0
misc/referencevalue objective value for reference purposes
Range: real
misc/resetstat should the statistics be reset if the transformed problem is freed (in case of a Benders' decomposition this parameter should be set to FALSE)
Range: boolean
1
misc/scaleobj should the objective function be scaled so that it is always integer?
Range: boolean
1
misc/transorigsols should SCIP try to transfer original solutions to the transformed space (after presolving)?
Range: boolean
1
misc/transsolsorig should SCIP try to transfer transformed solutions to the original space (after solving)?
Range: boolean
1
misc/useconstable should a hashtable be used to map from constraint names to constraints?
Range: boolean
1
misc/usesmalltables should smaller hashtables be used? yields better performance for small problems with about 100 variables
Range: boolean
0
misc/usesymmetry bitset describing used symmetry handling technique (0: off; 1: polyhedral (orbitopes and/or symresacks); 2: orbital fixing; 3: orbitopes and orbital fixing)
Range: {0, ..., 3}
3
misc/usevartable should a hashtable be used to map from variable names to variables?
Range: boolean
1

nodeselection

Option Description Default
nodeselection/childsel child selection rule ('d'own, 'u'p, 'p'seudo costs, 'i'nference, 'l'p value, 'r'oot LP value difference, 'h'ybrid inference/root LP value difference)
Range: d, u, p, i, l, r, h
h

nodeselection/bfs

Option Description Default
nodeselection/bfs/stdpriority priority of node selection rule <bfs> in standard mode
Range: {-536870912, ..., 1073741823}
100000
Options for expert users
nodeselection/bfs/maxplungedepth maximal plunging depth, before new best node is forced to be selected (-1 for dynamic setting)
Range: {-1, ..., ∞}
-1
nodeselection/bfs/maxplungequot maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where plunging is performed
Range: [0, ∞]
0.25
nodeselection/bfs/memsavepriority priority of node selection rule <bfs> in memory saving mode
Range: {-536870912, ..., 536870911}
0
nodeselection/bfs/minplungedepth minimal plunging depth, before new best node may be selected (-1 for dynamic setting)
Range: {-1, ..., ∞}
-1

nodeselection/breadthfirst

Option Description Default
nodeselection/breadthfirst/stdpriority priority of node selection rule <breadthfirst> in standard mode
Range: {-536870912, ..., 1073741823}
-10000
Options for expert users
nodeselection/breadthfirst/memsavepriority priority of node selection rule <breadthfirst> in memory saving mode
Range: {-536870912, ..., 536870911}
-1000000

nodeselection/dfs

Option Description Default
nodeselection/dfs/stdpriority priority of node selection rule <dfs> in standard mode
Range: {-536870912, ..., 1073741823}
0
Options for expert users
nodeselection/dfs/memsavepriority priority of node selection rule <dfs> in memory saving mode
Range: {-536870912, ..., 536870911}
100000

nodeselection/estimate

Option Description Default
nodeselection/estimate/bestnodefreq frequency at which the best node instead of the best estimate is selected (0: never)
Range: {0, ..., ∞}
10
nodeselection/estimate/breadthfirstdepth depth until breadth-first search is applied
Range: {-1, ..., ∞}
-1
nodeselection/estimate/plungeoffset number of nodes before doing plunging the first time
Range: {0, ..., ∞}
0
nodeselection/estimate/stdpriority priority of node selection rule <estimate> in standard mode
Range: {-536870912, ..., 1073741823}
200000
Options for expert users
nodeselection/estimate/maxplungedepth maximal plunging depth, before new best node is forced to be selected (-1 for dynamic setting)
Range: {-1, ..., ∞}
-1
nodeselection/estimate/maxplungequot maximal quotient (estimate - lowerbound)/(cutoffbound - lowerbound) where plunging is performed
Range: [0, ∞]
0.25
nodeselection/estimate/memsavepriority priority of node selection rule <estimate> in memory saving mode
Range: {-536870912, ..., 536870911}
100
nodeselection/estimate/minplungedepth minimal plunging depth, before new best node may be selected (-1 for dynamic setting)
Range: {-1, ..., ∞}
-1

nodeselection/hybridestim

Option Description Default
nodeselection/hybridestim/bestnodefreq frequency at which the best node instead of the hybrid best estimate / best bound is selected (0: never)
Range: {0, ..., ∞}
1000
nodeselection/hybridestim/stdpriority priority of node selection rule <hybridestim> in standard mode
Range: {-536870912, ..., 1073741823}
50000
Options for expert users
nodeselection/hybridestim/estimweight weight of estimate value in node selection score (0: pure best bound search, 1: pure best estimate search)
Range: [0, 1]
0.1
nodeselection/hybridestim/maxplungedepth maximal plunging depth, before new best node is forced to be selected (-1 for dynamic setting)
Range: {-1, ..., ∞}
-1
nodeselection/hybridestim/maxplungequot maximal quotient (estimate - lowerbound)/(cutoffbound - lowerbound) where plunging is performed
Range: [0, ∞]
0.25
nodeselection/hybridestim/memsavepriority priority of node selection rule <hybridestim> in memory saving mode
Range: {-536870912, ..., 536870911}
50
nodeselection/hybridestim/minplungedepth minimal plunging depth, before new best node may be selected (-1 for dynamic setting)
Range: {-1, ..., ∞}
-1

nodeselection/restartdfs

Option Description Default
nodeselection/restartdfs/countonlyleaves count only leaf nodes (otherwise all nodes)?
Range: boolean
1
nodeselection/restartdfs/selectbestfreq frequency for selecting the best node instead of the deepest one
Range: {0, ..., ∞}
100
nodeselection/restartdfs/stdpriority priority of node selection rule <restartdfs> in standard mode
Range: {-536870912, ..., 1073741823}
10000
Options for expert users
nodeselection/restartdfs/memsavepriority priority of node selection rule <restartdfs> in memory saving mode
Range: {-536870912, ..., 536870911}
50000

nodeselection/uct

Option Description Default
nodeselection/uct/stdpriority priority of node selection rule <uct> in standard mode
Range: {-536870912, ..., 1073741823}
10
Options for expert users
nodeselection/uct/memsavepriority priority of node selection rule <uct> in memory saving mode
Range: {-536870912, ..., 536870911}
0
nodeselection/uct/nodelimit maximum number of nodes before switching to default rule
Range: {0, ..., 1000000}
31
nodeselection/uct/useestimate should the estimate (TRUE) or lower bound of a node be used for UCT score?
Range: boolean
0
nodeselection/uct/weight weight for visit quotient of node selection rule
Range: [0, 1]
0.1

numerics

Option Description Default
numerics/checkfeastolfac feasibility tolerance factor; for checking the feasibility of the best solution
Range: [0, ∞]
1
numerics/dualfeastol feasibility tolerance for reduced costs in LP solution
Range: [1e-17, 0.001]
1e-07
numerics/epsilon absolute values smaller than this are considered zero
Range: [1e-20, 0.001]
1e-09
numerics/feastol feasibility tolerance for constraints
Range: [1e-17, 0.001]
1e-06
numerics/lpfeastolfactor factor w.r.t. primal feasibility tolerance that determines default (and maximal) primal feasibility tolerance of LP solver
Range: [1e-06, 1]
1
numerics/sumepsilon absolute values of sums smaller than this are considered zero
Range: [1e-17, 0.001]
1e-06
Options for expert users
numerics/barrierconvtol LP convergence tolerance used in barrier algorithm
Range: [1e-17, 0.001]
1e-10
numerics/boundstreps minimal relative improve for strengthening bounds
Range: [1e-17, ∞]
0.05
numerics/hugeval values larger than this are considered huge and should be handled separately (e.g., in activity computation)
Range: [0, ∞]
1e+15
numerics/pseudocostdelta minimal objective distance value to use for branching pseudo cost updates
Range: [0, ∞]
0.0001
numerics/pseudocosteps minimal variable distance value to use for branching pseudo cost updates
Range: [1e-17, 1]
0.1
numerics/recomputefac minimal decrease factor that causes the recomputation of a value (e.g., pseudo objective) instead of an update
Range: [0, ∞]
1e+07

presolving

Option Description Default
presolving/maxrestarts maximal number of restarts (-1: unlimited)
Range: {-1, ..., ∞}
-1
presolving/maxrounds maximal number of presolving rounds (-1: unlimited, 0: off)
Range: {-1, ..., ∞}
-1
Options for expert users
presolving/abortfac abort presolve, if at most this fraction of the problem was changed in last presolve round
Range: [0, 1]
0.0008
presolving/clqtablefac limit on number of entries in clique table relative to number of problem nonzeros
Range: [0, ∞]
2
presolving/donotaggr should aggregation of variables be forbidden?
Range: boolean
0
presolving/donotmultaggr should multi-aggregation of variables be forbidden?
Range: boolean
0
presolving/immrestartfac fraction of integer variables that were fixed in the root node triggering an immediate restart with preprocessing
Range: [0, 1]
0.1
presolving/restartfac fraction of integer variables that were fixed in the root node triggering a restart with preprocessing after root node evaluation
Range: [0, 1]
0.025
presolving/restartminred minimal fraction of integer variables removed after restart to allow for an additional restart
Range: [0, 1]
0.1
presolving/subrestartfac fraction of integer variables that were globally fixed during the solving process triggering a restart with preprocessing
Range: [0, 1]
1

presolving/boundshift

Option Description Default
presolving/boundshift/maxrounds maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞}
0
Options for expert users
presolving/boundshift/flipping is flipping allowed (multiplying with -1)?
Range: boolean
1
presolving/boundshift/integer shift only integer ranges?
Range: boolean
1
presolving/boundshift/maxshift absolute value of maximum shift
Range: {0, ..., ∞}
presolving/boundshift/priority priority of presolver <boundshift>
Range: {-536870912, ..., 536870911}
7900000
presolving/boundshift/timing timing mask of presolver <boundshift> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
4

presolving/convertinttobin

Option Description Default
presolving/convertinttobin/maxrounds maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞}
0
Options for expert users
presolving/convertinttobin/maxdomainsize absolute value of maximum domain size for converting an integer variable to binaries variables
Range: {0, ..., ∞}
presolving/convertinttobin/onlypoweroftwo should only integer variables with a domain size of 2^p - 1 be converted(, there we don't need an knapsack-constraint for restricting the sum of the binaries)
Range: boolean
0
presolving/convertinttobin/priority priority of presolver <convertinttobin>
Range: {-536870912, ..., 536870911}
6000000
presolving/convertinttobin/samelocksinbothdirections should only integer variables with uplocks equals downlocks be converted
Range: boolean
0
presolving/convertinttobin/timing timing mask of presolver <convertinttobin> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
4

presolving/domcol

Option Description Default
presolving/domcol/continuousred should reductions for continuous variables be performed?
Range: boolean
1
presolving/domcol/maxrounds maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
presolving/domcol/nummaxpairs maximal number of pair comparisons
Range: {1024, ..., 1000000000}
1048576
presolving/domcol/numminpairs minimal number of pair comparisons
Range: {100, ..., 1048576}
1024
presolving/domcol/predbndstr should predictive bound strengthening be applied?
Range: boolean
0
Options for expert users
presolving/domcol/priority priority of presolver <domcol>
Range: {-536870912, ..., 536870911}
-1000
presolving/domcol/timing timing mask of presolver <domcol> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
16

presolving/dualagg

Option Description Default
presolving/dualagg/maxrounds maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞}
0
Options for expert users
presolving/dualagg/priority priority of presolver <dualagg>
Range: {-536870912, ..., 536870911}
-12000
presolving/dualagg/timing timing mask of presolver <dualagg> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
16

presolving/dualcomp

Option Description Default
presolving/dualcomp/componlydisvars should only discrete variables be compensated?
Range: boolean
0
presolving/dualcomp/maxrounds maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
Options for expert users
presolving/dualcomp/priority priority of presolver <dualcomp>
Range: {-536870912, ..., 536870911}
-50
presolving/dualcomp/timing timing mask of presolver <dualcomp> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
16

presolving/dualinfer

Option Description Default
presolving/dualinfer/maxdualbndloops maximal number of dual bound strengthening loops
Range: {-1, ..., ∞}
12
presolving/dualinfer/maxrounds maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞}
0
presolving/dualinfer/maxrowsupport Maximum number of row's non-zeros for changing inequality to equality
Range: {2, ..., ∞}
3
presolving/dualinfer/twocolcombine use convex combination of columns for determining dual bounds
Range: boolean
1
Options for expert users
presolving/dualinfer/maxcombinefails maximal number of consecutive useless column combines
Range: {-1, ..., ∞}
1000
presolving/dualinfer/maxconsiderednonzeros maximal number of considered non-zeros within one column (-1: no limit)
Range: {-1, ..., ∞}
100
presolving/dualinfer/maxhashfac Maximum number of hashlist entries as multiple of number of columns in the problem (-1: no limit)
Range: {-1, ..., ∞}
10
presolving/dualinfer/maxpairfac Maximum number of processed column pairs as multiple of the number of columns in the problem (-1: no limit)
Range: {-1, ..., ∞}
1
presolving/dualinfer/maxretrievefails maximal number of consecutive useless hashtable retrieves
Range: {-1, ..., ∞}
1000
presolving/dualinfer/priority priority of presolver <dualinfer>
Range: {-536870912, ..., 536870911}
-3000
presolving/dualinfer/timing timing mask of presolver <dualinfer> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
16

presolving/dualsparsify

Option Description Default
presolving/dualsparsify/maxbinfillin maximal fillin for binary variables (-1: unlimited)
Range: {-1, ..., ∞}
1
presolving/dualsparsify/maxcontfillin maximal fillin for continuous variables (-1: unlimited)
Range: {-1, ..., ∞}
1
presolving/dualsparsify/maxintfillin maximal fillin for integer variables including binaries (-1: unlimited)
Range: {-1, ..., ∞}
1
presolving/dualsparsify/maxrounds maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
presolving/dualsparsify/mineliminatednonzeros minimal eliminated nonzeros within one column if we need to add a constraint to the problem
Range: {0, ..., ∞}
100
Options for expert users
presolving/dualsparsify/enablecopy should dualsparsify presolver be copied to sub-SCIPs?
Range: boolean
1
presolving/dualsparsify/maxconsiderednonzeros maximal number of considered nonzeros within one column (-1: no limit)
Range: {-1, ..., ∞}
70
presolving/dualsparsify/maxretrievefac limit on the number of useless vs. useful hashtable retrieves as a multiple of the number of constraints
Range: [0, ∞]
100
presolving/dualsparsify/preservegoodlocks should we preserve good locked properties of variables (at most one lock in one direction)?
Range: boolean
0
presolving/dualsparsify/preserveintcoefs should we forbid cancellations that destroy integer coefficients?
Range: boolean
0
presolving/dualsparsify/priority priority of presolver <dualsparsify>
Range: {-536870912, ..., 536870911}
-240000
presolving/dualsparsify/timing timing mask of presolver <dualsparsify> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
16
presolving/dualsparsify/waitingfac number of calls to wait until next execution as a multiple of the number of useless calls
Range: [0, ∞]
2

presolving/gateextraction

Option Description Default
presolving/gateextraction/maxrounds maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
Options for expert users
presolving/gateextraction/onlysetpart should we only try to extract set-partitioning constraints and no and-constraints
Range: boolean
0
presolving/gateextraction/priority priority of presolver <gateextraction>
Range: {-536870912, ..., 536870911}
1000000
presolving/gateextraction/searchequations should we try to extract set-partitioning constraint out of one logicor and one corresponding set-packing constraint
Range: boolean
1
presolving/gateextraction/sorting order logicor contraints to extract big-gates before smaller ones (-1), do not order them (0) or order them to extract smaller gates at first (1)
Range: {-1, ..., 1}
1
presolving/gateextraction/timing timing mask of presolver <gateextraction> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
16

presolving/implics

Option Description Default
presolving/implics/maxrounds maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
Options for expert users
presolving/implics/priority priority of presolver <implics>
Range: {-536870912, ..., 536870911}
-10000
presolving/implics/timing timing mask of presolver <implics> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
8

presolving/inttobinary

Option Description Default
presolving/inttobinary/maxrounds maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
Options for expert users
presolving/inttobinary/priority priority of presolver <inttobinary>
Range: {-536870912, ..., 536870911}
7000000
presolving/inttobinary/timing timing mask of presolver <inttobinary> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
4

presolving/milp

Option Description Default
presolving/milp/hugebound absolute bound value that is considered too huge for activitity based calculations
Range: [0, ∞]
1e+08
presolving/milp/markowitztolerance the markowitz tolerance used for substitutions
Range: [0, 1]
0.01
presolving/milp/maxfillinpersubstitution maximal possible fillin for substitutions to be considered
Range: {-2147483648, ..., ∞}
3
presolving/milp/maxrounds maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
presolving/milp/modifyconsfac modify SCIP constraints when the number of nonzeros or rows is at most this factor times the number of nonzeros or rows before presolving
Range: [0, 1]
0.8
presolving/milp/randomseed the random seed used for randomization of tie breaking
Range: {-2147483648, ..., ∞}
0
presolving/milp/threads maximum number of threads presolving may use (0: automatic)
Range: {0, ..., ∞}
GAMS threads
Options for expert users
presolving/milp/enabledomcol should the dominated column presolver be enabled within the presolve library?
Range: boolean
1
presolving/milp/enabledualinfer should the dualinfer presolver be enabled within the presolve library?
Range: boolean
1
presolving/milp/enablemultiaggr should the multi-aggregation presolver be enabled within the presolve library?
Range: boolean
1
presolving/milp/enableparallelrows should the parallel rows presolver be enabled within the presolve library?
Range: boolean
1
presolving/milp/enableprobing should the probing presolver be enabled within the presolve library?
Range: boolean
1
presolving/milp/enablesparsify should the sparsify presolver be enabled within the presolve library?
Range: boolean
0
presolving/milp/maxshiftperrow maximal amount of nonzeros allowed to be shifted to make space for substitutions
Range: {0, ..., ∞}
10
presolving/milp/priority priority of presolver <milp>
Range: {-536870912, ..., 536870911}
9999999
presolving/milp/timing timing mask of presolver <milp> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
8

presolving/qpkktref

Option Description Default
presolving/qpkktref/maxrounds maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
Options for expert users
presolving/qpkktref/addkktbinary if TRUE then allow binary variables for KKT update
Range: boolean
0
presolving/qpkktref/priority priority of presolver <qpkktref>
Range: {-536870912, ..., 536870911}
-1
presolving/qpkktref/timing timing mask of presolver <qpkktref> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
8
presolving/qpkktref/updatequadbounded if TRUE then only apply the update to QPs with bounded variables; if the variables are not bounded then a finite optimal solution might not exist and the KKT conditions would then be invalid
Range: boolean
1
presolving/qpkktref/updatequadindef if TRUE then apply quadratic constraint update even if the quadratic constraint matrix is known to be indefinite
Range: boolean
0

presolving/redvub

Option Description Default
presolving/redvub/maxrounds maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞}
0
Options for expert users
presolving/redvub/priority priority of presolver <redvub>
Range: {-536870912, ..., 536870911}
-9000000
presolving/redvub/timing timing mask of presolver <redvub> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
16

presolving/sparsify

Option Description Default
presolving/sparsify/maxbinfillin maximal fillin for binary variables (-1: unlimited)
Range: {-1, ..., ∞}
0
presolving/sparsify/maxcontfillin maximal fillin for continuous variables (-1: unlimited)
Range: {-1, ..., ∞}
0
presolving/sparsify/maxintfillin maximal fillin for integer variables including binaries (-1: unlimited)
Range: {-1, ..., ∞}
0
presolving/sparsify/maxrounds maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
Options for expert users
presolving/sparsify/cancellinear should we cancel nonzeros in constraints of the linear constraint handler?
Range: boolean
1
presolving/sparsify/enablecopy should sparsify presolver be copied to sub-SCIPs?
Range: boolean
1
presolving/sparsify/maxconsiderednonzeros maximal number of considered non-zeros within one row (-1: no limit)
Range: {-1, ..., ∞}
70
presolving/sparsify/maxnonzeros maximal support of one equality to be used for cancelling (-1: no limit)
Range: {-1, ..., ∞}
-1
presolving/sparsify/maxretrievefac limit on the number of useless vs. useful hashtable retrieves as a multiple of the number of constraints
Range: [0, ∞]
100
presolving/sparsify/preserveintcoefs should we forbid cancellations that destroy integer coefficients?
Range: boolean
1
presolving/sparsify/priority priority of presolver <sparsify>
Range: {-536870912, ..., 536870911}
-24000
presolving/sparsify/rowsort order in which to process inequalities ('n'o sorting, 'i'ncreasing nonzeros, 'd'ecreasing nonzeros)
Range: n, i, d
d
presolving/sparsify/timing timing mask of presolver <sparsify> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
16
presolving/sparsify/waitingfac number of calls to wait until next execution as a multiple of the number of useless calls
Range: [0, ∞]
2

presolving/stuffing

Option Description Default
presolving/stuffing/maxrounds maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞}
0
Options for expert users
presolving/stuffing/priority priority of presolver <stuffing>
Range: {-536870912, ..., 536870911}
-100
presolving/stuffing/timing timing mask of presolver <stuffing> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
16

presolving/trivial

Option Description Default
presolving/trivial/maxrounds maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
Options for expert users
presolving/trivial/priority priority of presolver <trivial>
Range: {-536870912, ..., 536870911}
9000000
presolving/trivial/timing timing mask of presolver <trivial> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
4

presolving/tworowbnd

Option Description Default
presolving/tworowbnd/maxcombinefails maximal number of consecutive useless row combines
Range: {-1, ..., ∞}
1000
presolving/tworowbnd/maxconsiderednonzeros maximal number of considered non-zeros within one row (-1: no limit)
Range: {-1, ..., ∞}
100
presolving/tworowbnd/maxhashfac Maximum number of hashlist entries as multiple of number of rows in the problem (-1: no limit)
Range: {-1, ..., ∞}
10
presolving/tworowbnd/maxpairfac Maximum number of processed row pairs as multiple of the number of rows in the problem (-1: no limit)
Range: {-1, ..., ∞}
1
presolving/tworowbnd/maxretrievefails maximal number of consecutive useless hashtable retrieves
Range: {-1, ..., ∞}
1000
presolving/tworowbnd/maxrounds maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞}
0
Options for expert users
presolving/tworowbnd/enablecopy should tworowbnd presolver be copied to sub-SCIPs?
Range: boolean
1
presolving/tworowbnd/priority priority of presolver <tworowbnd>
Range: {-536870912, ..., 536870911}
-2000
presolving/tworowbnd/timing timing mask of presolver <tworowbnd> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
16

propagating

Option Description Default
propagating/abortoncutoff should propagation be aborted immediately? setting this to FALSE could help conflict analysis to produce more conflict constraints
Range: boolean
1
propagating/maxrounds maximal number of propagation rounds per node (-1: unlimited)
Range: {-1, ..., ∞}
100
propagating/maxroundsroot maximal number of propagation rounds in the root node (-1: unlimited)
Range: {-1, ..., ∞}
1000

propagating/dualfix

Option Description Default
propagating/dualfix/freq frequency for calling propagator <dualfix> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
0
propagating/dualfix/maxprerounds maximal number of presolving rounds the propagator participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
Options for expert users
propagating/dualfix/delay should propagator be delayed, if other propagators found reductions?
Range: boolean
0
propagating/dualfix/presolpriority presolving priority of propagator <dualfix>
Range: {-536870912, ..., 536870911}
8000000
propagating/dualfix/presoltiming timing mask of the presolving method of propagator <dualfix> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {2, ..., 60}
4
propagating/dualfix/priority priority of propagator <dualfix>
Range: {-536870912, ..., 536870911}
8000000
propagating/dualfix/timingmask timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS))
Range: {1, ..., 15}
1

propagating/genvbounds

Option Description Default
propagating/genvbounds/freq frequency for calling propagator <genvbounds> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
propagating/genvbounds/maxprerounds maximal number of presolving rounds the propagator participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
Options for expert users
propagating/genvbounds/delay should propagator be delayed, if other propagators found reductions?
Range: boolean
0
propagating/genvbounds/global apply global propagation?
Range: boolean
1
propagating/genvbounds/presolpriority presolving priority of propagator <genvbounds>
Range: {-536870912, ..., 536870911}
-2000000
propagating/genvbounds/presoltiming timing mask of the presolving method of propagator <genvbounds> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {2, ..., 60}
4
propagating/genvbounds/priority priority of propagator <genvbounds>
Range: {-536870912, ..., 536870911}
3000000
propagating/genvbounds/propasconss should genvbounds be transformed to (linear) constraints?
Range: boolean
0
propagating/genvbounds/propinrootnode apply genvbounds in root node if no new incumbent was found?
Range: boolean
1
propagating/genvbounds/sort sort genvbounds and wait for bound change events?
Range: boolean
1
propagating/genvbounds/timingmask timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS))
Range: {1, ..., 15}
15

propagating/nlobbt

Option Description Default
propagating/nlobbt/addlprows should non-initial LP rows be used?
Range: boolean
1
propagating/nlobbt/freq frequency for calling propagator <nlobbt> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
-1
propagating/nlobbt/maxprerounds maximal number of presolving rounds the propagator participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
Options for expert users
propagating/nlobbt/delay should propagator be delayed, if other propagators found reductions?
Range: boolean
1
propagating/nlobbt/feastolfac factor for NLP feasibility tolerance
Range: [0, 1]
0.01
propagating/nlobbt/itlimitfactor LP iteration limit for nlobbt will be this factor times total LP iterations in root node
Range: [0, ∞]
2
propagating/nlobbt/minlinearfrac minimum (convex nlrows)/(linear nlrows) threshold to apply propagator
Range: [0, ∞]
0.02
propagating/nlobbt/minnonconvexfrac (convex nlrows)/(nonconvex nlrows) threshold to apply propagator
Range: [0, ∞]
0.2
propagating/nlobbt/nlpiterlimit iteration limit of NLP solver; 0 for no limit
Range: {0, ..., ∞}
500
propagating/nlobbt/nlptimelimit time limit of NLP solver; 0.0 for no limit
Range: [0, ∞]
0
propagating/nlobbt/nlpverblevel verbosity level of NLP solver
Range: {0, ..., 5}
0
propagating/nlobbt/presolpriority presolving priority of propagator <nlobbt>
Range: {-536870912, ..., 536870911}
0
propagating/nlobbt/presoltiming timing mask of the presolving method of propagator <nlobbt> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {2, ..., 60}
28
propagating/nlobbt/priority priority of propagator <nlobbt>
Range: {-536870912, ..., 536870911}
-1100000
propagating/nlobbt/relobjtolfac factor for NLP relative objective tolerance
Range: [0, 1]
0.01
propagating/nlobbt/timingmask timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS))
Range: {1, ..., 15}
4

propagating/obbt

Option Description Default
propagating/obbt/boundstreps minimal relative improve for strengthening bounds
Range: [0, 1]
0.001
propagating/obbt/conditionlimit maximum condition limit used in LP solver (-1.0: no limit)
Range: [-1, ∞]
-1
propagating/obbt/dualfeastol feasibility tolerance for reduced costs used in obbt; this value is used if SCIP's dual feastol is greater
Range: [0, ∞]
1e-09
propagating/obbt/freq frequency for calling propagator <obbt> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
0
propagating/obbt/itlimitfactor multiple of root node LP iterations used as total LP iteration limit for obbt (≤ 0: no limit )
Range: real
10
propagating/obbt/itlimitfactorbilin multiple of OBBT LP limit used as total LP iteration limit for solving bilinear inequality LPs (< 0 for no limit)
Range: real
3
propagating/obbt/maxprerounds maximal number of presolving rounds the propagator participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
propagating/obbt/minitlimit minimum LP iteration limit
Range: {0, ..., ∞}
5000
propagating/obbt/minnonconvexity minimum absolute value of nonconvex eigenvalues for a bilinear term
Range: [0, ∞]
0.1
Options for expert users
propagating/obbt/applyfilterrounds try to filter bounds in so-called filter rounds by solving auxiliary LPs?
Range: boolean
0
propagating/obbt/applytrivialfilter try to filter bounds with the LP solution after each solve?
Range: boolean
1
propagating/obbt/createbilinineqs solve auxiliary LPs in order to find valid inequalities for bilinear terms?
Range: boolean
1
propagating/obbt/creategenvbounds should obbt try to provide genvbounds if possible?
Range: boolean
1
propagating/obbt/delay should propagator be delayed, if other propagators found reductions?
Range: boolean
1
propagating/obbt/genvbdsduringfilter should we try to generate genvbounds during trivial and aggressive filtering?
Range: boolean
1
propagating/obbt/genvbdsduringsepa try to create genvbounds during separation process?
Range: boolean
1
propagating/obbt/minfilter minimal number of filtered bounds to apply another filter round
Range: {1, ..., ∞}
2
propagating/obbt/normalize should coefficients in filtering be normalized w.r.t. the domains sizes?
Range: boolean
1
propagating/obbt/onlynonconvexvars only apply obbt on non-convex variables
Range: boolean
0
propagating/obbt/orderingalgo select the type of ordering algorithm which should be used (0: no special ordering, 1: greedy, 2: greedy reverse)
Range: {0, ..., 2}
1
propagating/obbt/presolpriority presolving priority of propagator <obbt>
Range: {-536870912, ..., 536870911}
0
propagating/obbt/presoltiming timing mask of the presolving method of propagator <obbt> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {2, ..., 60}
28
propagating/obbt/priority priority of propagator <obbt>
Range: {-536870912, ..., 536870911}
-1000000
propagating/obbt/propagatefreq trigger a propagation round after that many bound tightenings (0: no propagation)
Range: {0, ..., ∞}
0
propagating/obbt/sepamaxiter maximum number of iteration spend to separate an obbt LP solution
Range: {0, ..., ∞}
10
propagating/obbt/sepaminiter minimum number of iteration spend to separate an obbt LP solution
Range: {0, ..., ∞}
0
propagating/obbt/separatesol should the obbt LP solution be separated?
Range: boolean
0
propagating/obbt/tightcontboundsprobing should continuous bounds be tightened during the probing mode?
Range: boolean
0
propagating/obbt/tightintboundsprobing should integral bounds be tightened during the probing mode?
Range: boolean
1
propagating/obbt/timingmask timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS))
Range: {1, ..., 15}
4

propagating/probing

Option Description Default
propagating/probing/freq frequency for calling propagator <probing> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
-1
propagating/probing/maxprerounds maximal number of presolving rounds the propagator participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
propagating/probing/maxruns maximal number of runs, probing participates in (-1: no limit)
Range: {-1, ..., ∞}
1
Options for expert users
propagating/probing/delay should propagator be delayed, if other propagators found reductions?
Range: boolean
1
propagating/probing/maxdepth maximal depth until propagation is executed(-1: no limit)
Range: {-1, ..., ∞}
-1
propagating/probing/maxfixings maximal number of fixings found, until probing is interrupted (0: don't iterrupt)
Range: {0, ..., ∞}
25
propagating/probing/maxsumuseless maximal number of probings without fixings, until probing is aborted (0: don't abort)
Range: {0, ..., ∞}
0
propagating/probing/maxtotaluseless maximal number of successive probings without fixings, bound changes, and implications, until probing is aborted (0: don't abort)
Range: {0, ..., ∞}
50
propagating/probing/maxuseless maximal number of successive probings without fixings, until probing is aborted (0: don't abort)
Range: {0, ..., ∞}
1000
propagating/probing/presolpriority presolving priority of propagator <probing>
Range: {-536870912, ..., 536870911}
-100000
propagating/probing/presoltiming timing mask of the presolving method of propagator <probing> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {2, ..., 60}
16
propagating/probing/priority priority of propagator <probing>
Range: {-536870912, ..., 536870911}
-100000
propagating/probing/proprounds maximal number of propagation rounds in probing subproblems (-1: no limit, 0: auto)
Range: {-1, ..., ∞}
-1
propagating/probing/timingmask timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS))
Range: {1, ..., 15}
4

propagating/pseudoobj

Option Description Default
propagating/pseudoobj/freq frequency for calling propagator <pseudoobj> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
propagating/pseudoobj/maxprerounds maximal number of presolving rounds the propagator participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
Options for expert users
propagating/pseudoobj/delay should propagator be delayed, if other propagators found reductions?
Range: boolean
0
propagating/pseudoobj/force should the propagator be forced even if active pricer are present?
Range: boolean
0
propagating/pseudoobj/maximplvars maximum number of binary variables the implications are used if turned on (-1: unlimited)?
Range: {-1, ..., ∞}
50000
propagating/pseudoobj/maxnewvars number of variables added after the propagator is reinitialized?
Range: {0, ..., ∞}
1000
propagating/pseudoobj/maxvarsfrac maximal fraction of non-binary variables with non-zero objective without a bound reduction before aborted
Range: [0, 1]
0.1
propagating/pseudoobj/minuseless minimal number of successive non-binary variable propagations without a bound reduction before aborted
Range: {0, ..., ∞}
100
propagating/pseudoobj/presolpriority presolving priority of propagator <pseudoobj>
Range: {-536870912, ..., 536870911}
6000000
propagating/pseudoobj/presoltiming timing mask of the presolving method of propagator <pseudoobj> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {2, ..., 60}
4
propagating/pseudoobj/priority priority of propagator <pseudoobj>
Range: {-536870912, ..., 536870911}
3000000
propagating/pseudoobj/propcutoffbound propagate new cutoff bound directly globally
Range: boolean
1
propagating/pseudoobj/propfullinroot whether to propagate all non-binary variables when we are propagating the root node
Range: boolean
1
propagating/pseudoobj/propuseimplics use implications to strengthen the propagation of binary variable (increasing the objective change)?
Range: boolean
1
propagating/pseudoobj/respropuseimplics use implications to strengthen the resolve propagation of binary variable (increasing the objective change)?
Range: boolean
1
propagating/pseudoobj/timingmask timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS))
Range: {1, ..., 15}
7

propagating/redcost

Option Description Default
propagating/redcost/continuous should reduced cost fixing be also applied to continuous variables?
Range: boolean
0
propagating/redcost/freq frequency for calling propagator <redcost> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
propagating/redcost/maxprerounds maximal number of presolving rounds the propagator participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
propagating/redcost/useimplics should implications be used to strength the reduced cost for binary variables?
Range: boolean
0
Options for expert users
propagating/redcost/delay should propagator be delayed, if other propagators found reductions?
Range: boolean
0
propagating/redcost/force should the propagator be forced even if active pricer are present?
Range: boolean
0
propagating/redcost/presolpriority presolving priority of propagator <redcost>
Range: {-536870912, ..., 536870911}
0
propagating/redcost/presoltiming timing mask of the presolving method of propagator <redcost> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {2, ..., 60}
28
propagating/redcost/priority priority of propagator <redcost>
Range: {-536870912, ..., 536870911}
1000000
propagating/redcost/timingmask timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS))
Range: {1, ..., 15}
6

propagating/rootredcost

Option Description Default
propagating/rootredcost/freq frequency for calling propagator <rootredcost> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
propagating/rootredcost/maxprerounds maximal number of presolving rounds the propagator participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
Options for expert users
propagating/rootredcost/delay should propagator be delayed, if other propagators found reductions?
Range: boolean
0
propagating/rootredcost/force should the propagator be forced even if active pricer are present?
Range: boolean
0
propagating/rootredcost/onlybinary should only binary variables be propagated?
Range: boolean
0
propagating/rootredcost/presolpriority presolving priority of propagator <rootredcost>
Range: {-536870912, ..., 536870911}
0
propagating/rootredcost/presoltiming timing mask of the presolving method of propagator <rootredcost> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {2, ..., 60}
28
propagating/rootredcost/priority priority of propagator <rootredcost>
Range: {-536870912, ..., 536870911}
10000000
propagating/rootredcost/timingmask timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS))
Range: {1, ..., 15}
5

propagating/symmetry

Option Description Default
propagating/symmetry/freq frequency for calling propagator <symmetry> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
propagating/symmetry/maxprerounds maximal number of presolving rounds the propagator participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
Options for expert users
propagating/symmetry/addconsstiming timing of adding constraints (0 = before presolving, 1 = during presolving, 2 = after presolving)
Range: {0, ..., 2}
2
propagating/symmetry/addsymresacks Add inequalities for symresacks for each generator?
Range: boolean
1
propagating/symmetry/checksymmetries Should all symmetries be checked after computation?
Range: boolean
0
propagating/symmetry/compresssymmetries Should non-affected variables be removed from permutation to save memory?
Range: boolean
1
propagating/symmetry/compressthreshold Compression is used if percentage of moved vars is at most the threshold.
Range: [0, 1]
0.5
propagating/symmetry/conssaddlp Should the symmetry breaking constraints be added to the LP?
Range: boolean
1
propagating/symmetry/delay should propagator be delayed, if other propagators found reductions?
Range: boolean
0
propagating/symmetry/detectorbitopes Should we check whether the components of the symmetry group can be handled by orbitopes?
Range: boolean
1
propagating/symmetry/disableofrestart Shall orbital fixing be disabled if orbital fixing has found a reduction and a restart occurs?
Range: boolean
0
propagating/symmetry/displaynorbitvars Should the number of variables affected by some symmetry be displayed?
Range: boolean
0
propagating/symmetry/doubleequations Double equations to positive/negative version?
Range: boolean
0
propagating/symmetry/maxgenerators limit on the number of generators that should be produced within symmetry detection (0 = no limit)
Range: {0, ..., ∞}
1500
propagating/symmetry/ofsymcomptiming timing of symmetry computation for orbital fixing (0 = before presolving, 1 = during presolving, 2 = at first call)
Range: {0, ..., 2}
2
propagating/symmetry/performpresolving run orbital fixing during presolving?
Range: boolean
0
propagating/symmetry/presolpriority presolving priority of propagator <symmetry>
Range: {-536870912, ..., 536870911}
-10000000
propagating/symmetry/presoltiming timing mask of the presolving method of propagator <symmetry> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {2, ..., 60}
16
propagating/symmetry/priority priority of propagator <symmetry>
Range: {-536870912, ..., 536870911}
-1000000
propagating/symmetry/recomputerestart recompute symmetries after a restart has occured?
Range: boolean
0
propagating/symmetry/symfixnonbinaryvars Whether all non-binary variables shall be not affected by symmetries if OF is active?
Range: boolean
0
propagating/symmetry/timingmask timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS))
Range: {1, ..., 15}
1
propagating/symmetry/usecolumnsparsity Should the number of conss a variable is contained in be exploited in symmetry detection?
Range: boolean
0

propagating/vbounds

Option Description Default
propagating/vbounds/detectcycles should cycles in the variable bound graph be identified?
Range: boolean
0
propagating/vbounds/dotoposort should the bounds be topologically sorted in advance?
Range: boolean
1
propagating/vbounds/freq frequency for calling propagator <vbounds> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
1
propagating/vbounds/maxcliquesexhaustive maximum number of cliques per variable to run clique table analysis in exhaustive presolving
Range: [0, ∞]
100
propagating/vbounds/maxcliquesmedium maximum number of cliques per variable to run clique table analysis in medium presolving
Range: [0, ∞]
50
propagating/vbounds/maxprerounds maximal number of presolving rounds the propagator participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
propagating/vbounds/minnewcliques minimum percentage of new cliques to trigger another clique table analysis
Range: [0, 1]
0.1
propagating/vbounds/usebdwidening should bound widening be used to initialize conflict analysis?
Range: boolean
1
Options for expert users
propagating/vbounds/delay should propagator be delayed, if other propagators found reductions?
Range: boolean
0
propagating/vbounds/presolpriority presolving priority of propagator <vbounds>
Range: {-536870912, ..., 536870911}
-90000
propagating/vbounds/presoltiming timing mask of the presolving method of propagator <vbounds> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {2, ..., 60}
24
propagating/vbounds/priority priority of propagator <vbounds>
Range: {-536870912, ..., 536870911}
3000000
propagating/vbounds/sortcliques should cliques be regarded for the topological sort?
Range: boolean
0
propagating/vbounds/timingmask timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS))
Range: {1, ..., 15}
5
propagating/vbounds/usecliques should cliques be propagated?
Range: boolean
0
propagating/vbounds/useimplics should implications be propagated?
Range: boolean
0
propagating/vbounds/usevbounds should vbounds be propagated?
Range: boolean
1

randomization

Option Description Default
randomization/lpseed random seed for LP solver, e.g. for perturbations in the simplex (0: LP default)
Range: {0, ..., ∞}
0
randomization/permutationseed seed value for permuting the problem after reading/transformation (0: no permutation)
Range: {0, ..., ∞}
0
randomization/randomseedshift global shift of all random seeds in the plugins and the LP random seed
Range: {0, ..., ∞}
0
Options for expert users
randomization/permuteconss should order of constraints be permuted (depends on permutationseed)?
Range: boolean
1
randomization/permutevars should order of variables be permuted (depends on permutationseed)?
Range: boolean
0

separating

Option Description Default
separating/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separation (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
1
separating/maxcoefratio maximal ratio between coefficients in strongcg, cmir, and flowcover cuts
Range: [1, ∞]
10000
separating/maxcuts maximal number of cuts separated per separation round (0: disable local separation)
Range: {0, ..., ∞}
100
separating/maxcutsroot maximal number of separated cuts at the root node (0: disable root node separation)
Range: {0, ..., ∞}
2000
separating/maxlocalbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying local separation (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
0
separating/maxrounds maximal number of separation rounds per node (-1: unlimited)
Range: {-1, ..., ∞}
-1
separating/maxroundsroot maximal number of separation rounds in the root node (-1: unlimited)
Range: {-1, ..., ∞}
-1
separating/maxstallrounds maximal number of consecutive separation rounds without objective or integrality improvement in local nodes (-1: no additional restriction)
Range: {-1, ..., ∞}
1
separating/maxstallroundsroot maximal number of consecutive separation rounds without objective or integrality improvement in the root node (-1: no additional restriction)
Range: {-1, ..., ∞}
10
separating/minactivityquot minimum cut activity quotient to convert cuts into constraints during a restart (0.0: all cuts are converted)
Range: [0, 1]
0.8
separating/minefficacy minimal efficacy for a cut to enter the LP
Range: [0, ∞]
0.0001
separating/minefficacyroot minimal efficacy for a cut to enter the LP in the root node
Range: [0, ∞]
0.0001
separating/minortho minimal orthogonality for a cut to enter the LP
Range: [0, 1]
0.9
separating/minorthoroot minimal orthogonality for a cut to enter the LP in the root node
Range: [0, 1]
0.9
separating/poolfreq separation frequency for the global cut pool (-1: disable global cut pool, 0: only separate pool at the root)
Range: {-1, ..., 65534}
10
Options for expert users
separating/cutagelimit maximum age a cut can reach before it is deleted from the global cut pool, or -1 to keep all cuts
Range: {-1, ..., ∞}
80
separating/cutselrestart cut selection during restart ('a'ge, activity 'q'uotient)
Range: a, q
a
separating/cutselsubscip cut selection for sub SCIPs ('a'ge, activity 'q'uotient)
Range: a, q
a
separating/dircutoffdistfac factor to scale directed cutoff distance of cut in score calculation
Range: [0, ∞]
0.5
separating/efficacyfac factor to scale efficacy of cut in score calculation
Range: [0, ∞]
0.6
separating/efficacynorm row norm to use for efficacy calculation ('e'uclidean, 'm'aximum, 's'um, 'd'iscrete)
Range: e, m, s, d
e
separating/intsupportfac factor to scale integral support of cut in separation score calculation
Range: [0, ∞]
0.1
separating/maxaddrounds maximal additional number of separation rounds in subsequent price-and-cut loops (-1: no additional restriction)
Range: {-1, ..., ∞}
1
separating/maxroundsrootsubrun maximal number of separation rounds in the root node of a subsequent run (-1: unlimited)
Range: {-1, ..., ∞}
-1
separating/maxruns maximal number of runs for which separation is enabled (-1: unlimited)
Range: {-1, ..., ∞}
-1
separating/objparalfac factor to scale objective parallelism of cut in separation score calculation
Range: [0, ∞]
0.1
separating/orthofunc function used for calc. scalar prod. in orthogonality test ('e'uclidean, 'd'iscrete)
Range: e, d
e

separating/aggregation

Option Description Default
separating/aggregation/dynamiccuts should generated cuts be removed from the LP if they are no longer tight?
Range: boolean
1
separating/aggregation/freq frequency for calling separator <aggregation> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
10
separating/aggregation/maxrounds maximal number of cmir separation rounds per node (-1: unlimited)
Range: {-1, ..., ∞}
-1
separating/aggregation/maxroundsroot maximal number of cmir separation rounds in the root node (-1: unlimited)
Range: {-1, ..., ∞}
-1
separating/aggregation/maxsepacuts maximal number of cmir cuts separated per separation round
Range: {0, ..., ∞}
100
separating/aggregation/maxsepacutsroot maximal number of cmir cuts separated per separation round in the root node
Range: {0, ..., ∞}
500
Options for expert users
separating/aggregation/aggrtol tolerance for bound distances used to select continuous variable in current aggregated constraint to be eliminated
Range: [0, ∞]
0.01
separating/aggregation/delay should separator be delayed, if other separators found cuts?
Range: boolean
0
separating/aggregation/densityoffset additional number of variables allowed in row on top of density
Range: {0, ..., ∞}
100
separating/aggregation/densityscore weight of row density in the aggregation scoring of the rows
Range: [0, ∞]
0.0001
separating/aggregation/expbackoff base for exponential increase of frequency at which separator <aggregation> is called (1: call at each multiple of frequency)
Range: {1, ..., 100}
4
separating/aggregation/fixintegralrhs should an additional variable be complemented if f0 = 0?
Range: boolean
1
separating/aggregation/maxaggdensity maximal density of aggregated row
Range: [0, 1]
0.2
separating/aggregation/maxaggrs maximal number of aggregations for each row per separation round
Range: {0, ..., ∞}
3
separating/aggregation/maxaggrsroot maximal number of aggregations for each row per separation round in the root node
Range: {0, ..., ∞}
6
separating/aggregation/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <aggregation> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
1
separating/aggregation/maxfails maximal number of consecutive unsuccessful aggregation tries (-1: unlimited)
Range: {-1, ..., ∞}
20
separating/aggregation/maxfailsroot maximal number of consecutive unsuccessful aggregation tries in the root node (-1: unlimited)
Range: {-1, ..., ∞}
100
separating/aggregation/maxrowdensity maximal density of row to be used in aggregation
Range: [0, 1]
0.05
separating/aggregation/maxrowfac maximal row aggregation factor
Range: [0, ∞]
10000
separating/aggregation/maxslack maximal slack of rows to be used in aggregation
Range: [0, ∞]
0
separating/aggregation/maxslackroot maximal slack of rows to be used in aggregation in the root node
Range: [0, ∞]
0.1
separating/aggregation/maxtestdelta maximal number of different deltas to try (-1: unlimited)
Range: {-1, ..., ∞}
-1
separating/aggregation/maxtries maximal number of rows to start aggregation with per separation round (-1: unlimited)
Range: {-1, ..., ∞}
200
separating/aggregation/maxtriesroot maximal number of rows to start aggregation with per separation round in the root node (-1: unlimited)
Range: {-1, ..., ∞}
-1
separating/aggregation/priority priority of separator <aggregation>
Range: {-536870912, ..., 536870911}
-3000
separating/aggregation/slackscore weight of slack in the aggregation scoring of the rows
Range: [0, ∞]
0.001
separating/aggregation/trynegscaling should negative values also be tested in scaling?
Range: boolean
1

separating/cgmip

Option Description Default
separating/cgmip/addviolationcons add constraint to subscip that only allows violated cuts (otherwise add obj. limit)?
Range: boolean
0
separating/cgmip/addviolconshdlr add constraint handler to filter out violated cuts?
Range: boolean
0
separating/cgmip/cmirownbounds tell CMIR-generator which bounds to used in rounding?
Range: boolean
0
separating/cgmip/conshdlrusenorm should the violation constraint handler use the norm of a cut to check for feasibility?
Range: boolean
1
separating/cgmip/contconvert Convert some integral variables to be continuous to reduce the size of the sub-MIP?
Range: boolean
0
separating/cgmip/contconvfrac fraction of integral variables converted to be continuous (if contconvert)
Range: [0, 1]
0.1
separating/cgmip/contconvmin minimum number of integral variables before some are converted to be continuous
Range: {-1, ..., ∞}
100
separating/cgmip/decisiontree Use decision tree to turn separation on/off?
Range: boolean
0
separating/cgmip/dynamiccuts should generated cuts be removed from the LP if they are no longer tight?
Range: boolean
1
separating/cgmip/earlyterm terminate separation if a violated (but possibly sub-optimal) cut has been found?
Range: boolean
1
separating/cgmip/freq frequency for calling separator <cgmip> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
-1
separating/cgmip/genprimalsols Try to generate primal solutions from Gomory cuts?
Range: boolean
0
separating/cgmip/intconvert Convert some integral variables attaining fractional values to have integral value?
Range: boolean
0
separating/cgmip/intconvfrac fraction of frac. integral variables converted to have integral value (if intconvert)
Range: [0, 1]
0.1
separating/cgmip/intconvmin minimum number of integral variables before some are converted to have integral value
Range: {-1, ..., ∞}
100
separating/cgmip/maxdepth maximal depth at which the separator is applied (-1: unlimited)
Range: {-1, ..., ∞}
-1
separating/cgmip/maxnodelimit maximum number of nodes considered for sub-MIP (-1: unlimited)
Range: {-1, ..., ∞}
5000
separating/cgmip/maxrounds maximal number of cgmip separation rounds per node (-1: unlimited)
Range: {-1, ..., ∞}
5
separating/cgmip/maxroundsroot maximal number of cgmip separation rounds in the root node (-1: unlimited)
Range: {-1, ..., ∞}
50
separating/cgmip/maxrowage maximal age of rows to consider if onlyactiverows is false
Range: {-1, ..., ∞}
-1
separating/cgmip/minnodelimit minimum number of nodes considered for sub-MIP (-1: unlimited)
Range: {-1, ..., ∞}
500
separating/cgmip/objlone Should the objective of the sub-MIP minimize the l1-norm of the multipliers?
Range: boolean
0
separating/cgmip/objweightsize Weight each row by its size?
Range: boolean
1
separating/cgmip/onlyactiverows Use only active rows to generate cuts?
Range: boolean
0
separating/cgmip/onlyintvars Generate cuts for problems with only integer variables?
Range: boolean
0
separating/cgmip/onlyrankone Separate only rank 1 inequalities w.r.t. CG-MIP separator?
Range: boolean
0
separating/cgmip/output Should information about the sub-MIP and cuts be displayed?
Range: boolean
0
separating/cgmip/primalseparation only separate cuts that are tight for the best feasible solution?
Range: boolean
1
separating/cgmip/skipmultbounds Skip the upper bounds on the multipliers in the sub-MIP?
Range: boolean
1
separating/cgmip/subscipfast Should the settings for the sub-MIP be optimized for speed?
Range: boolean
1
separating/cgmip/usecmir use CMIR-generator (otherwise add cut directly)?
Range: boolean
1
separating/cgmip/usecutpool use cutpool to store CG-cuts even if the are not efficient?
Range: boolean
1
separating/cgmip/useobjlb Use lower bound on objective function (via primal solution)?
Range: boolean
0
separating/cgmip/useobjub Use upper bound on objective function (via primal solution)?
Range: boolean
0
separating/cgmip/usestrongcg use strong CG-function to strengthen cut?
Range: boolean
0
Options for expert users
separating/cgmip/cutcoefbnd bounds on the values of the coefficients in the CG-cut
Range: [0, ∞]
1000
separating/cgmip/delay should separator be delayed, if other separators found cuts?
Range: boolean
0
separating/cgmip/expbackoff base for exponential increase of frequency at which separator <cgmip> is called (1: call at each multiple of frequency)
Range: {1, ..., 100}
4
separating/cgmip/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <cgmip> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
0
separating/cgmip/memorylimit memory limit for sub-MIP
Range: [0, ∞]
separating/cgmip/objweight weight used for the row combination coefficient in the sub-MIP objective
Range: [0, ∞]
0.001
separating/cgmip/priority priority of separator <cgmip>
Range: {-536870912, ..., 536870911}
-1000
separating/cgmip/timelimit time limit for sub-MIP
Range: [0, ∞]

separating/clique

Option Description Default
separating/clique/freq frequency for calling separator <clique> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
0
separating/clique/maxsepacuts maximal number of clique cuts separated per separation round (-1: no limit)
Range: {-1, ..., ∞}
10
Options for expert users
separating/clique/backtrackfreq frequency for premature backtracking up to tree level 1 (0: no backtracking)
Range: {0, ..., ∞}
1000
separating/clique/cliquedensity minimal density of cliques to use a dense clique table
Range: [0, 1]
0
separating/clique/cliquetablemem maximal memory size of dense clique table (in kb)
Range: [0, 2.09715e+06]
20000
separating/clique/delay should separator be delayed, if other separators found cuts?
Range: boolean
0
separating/clique/expbackoff base for exponential increase of frequency at which separator <clique> is called (1: call at each multiple of frequency)
Range: {1, ..., 100}
4
separating/clique/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <clique> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
0
separating/clique/maxtreenodes maximal number of nodes in branch and bound tree (-1: no limit)
Range: {-1, ..., ∞}
10000
separating/clique/maxzeroextensions maximal number of zero-valued variables extending the clique (-1: no limit)
Range: {-1, ..., ∞}
1000
separating/clique/priority priority of separator <clique>
Range: {-536870912, ..., 536870911}
-5000
separating/clique/scaleval factor for scaling weights
Range: [1, ∞]
1000

separating/closecuts

Option Description Default
separating/closecuts/freq frequency for calling separator <closecuts> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
-1
Options for expert users
separating/closecuts/closethres threshold on number of generated cuts below which the ordinary separation is started
Range: {-1, ..., ∞}
50
separating/closecuts/delay should separator be delayed, if other separators found cuts?
Range: boolean
0
separating/closecuts/expbackoff base for exponential increase of frequency at which separator <closecuts> is called (1: call at each multiple of frequency)
Range: {1, ..., 100}
4
separating/closecuts/inclobjcutoff include an objective cutoff when computing the relative interior?
Range: boolean
0
separating/closecuts/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <closecuts> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
1
separating/closecuts/maxlpiterfactor factor for maximal LP iterations in relative interior computation compared to node LP iterations (negative for no limit)
Range: [-1, ∞]
10
separating/closecuts/maxunsuccessful turn off separation in current node after unsuccessful calls (-1 never turn off)
Range: {-1, ..., ∞}
0
separating/closecuts/priority priority of separator <closecuts>
Range: {-536870912, ..., 536870911}
1000000
separating/closecuts/recomputerelint recompute relative interior point in each separation call?
Range: boolean
0
separating/closecuts/sepacombvalue convex combination value for close cuts
Range: [0, 1]
0.3
separating/closecuts/separelint generate close cuts w.r.t. relative interior point (best solution otherwise)?
Range: boolean
1

separating/cmir

Option Description Default
separating/cmir/freq frequency for calling separator <cmir> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
10
Options for expert users
separating/cmir/delay should separator be delayed, if other separators found cuts?
Range: boolean
0
separating/cmir/expbackoff base for exponential increase of frequency at which separator <cmir> is called (1: call at each multiple of frequency)
Range: {1, ..., 100}
4
separating/cmir/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <cmir> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
0
separating/cmir/priority priority of separator <cmir>
Range: {-536870912, ..., 536870911}
-100000

separating/convexproj

Option Description Default
separating/convexproj/freq frequency for calling separator <convexproj> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
-1
separating/convexproj/maxdepth maximal depth at which the separator is applied (-1: unlimited)
Range: {-1, ..., ∞}
-1
Options for expert users
separating/convexproj/delay should separator be delayed, if other separators found cuts?
Range: boolean
1
separating/convexproj/expbackoff base for exponential increase of frequency at which separator <convexproj> is called (1: call at each multiple of frequency)
Range: {1, ..., 100}
4
separating/convexproj/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <convexproj> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
1
separating/convexproj/nlpiterlimit iteration limit of NLP solver; 0 for no limit
Range: {0, ..., ∞}
250
separating/convexproj/nlptimelimit time limit of NLP solver; 0.0 for no limit
Range: [0, ∞]
0
separating/convexproj/priority priority of separator <convexproj>
Range: {-536870912, ..., 536870911}
0

separating/disjunctive

Option Description Default
separating/disjunctive/freq frequency for calling separator <disjunctive> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
0
separating/disjunctive/maxrank maximal rank of a disj. cut that could not be scaled to integral coefficients (-1: unlimited)
Range: {-1, ..., ∞}
20
separating/disjunctive/maxrankintegral maximal rank of a disj. cut that could be scaled to integral coefficients (-1: unlimited)
Range: {-1, ..., ∞}
-1
Options for expert users
separating/disjunctive/delay should separator be delayed, if other separators found cuts?
Range: boolean
1
separating/disjunctive/expbackoff base for exponential increase of frequency at which separator <disjunctive> is called (1: call at each multiple of frequency)
Range: {1, ..., 100}
4
separating/disjunctive/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <disjunctive> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
0
separating/disjunctive/maxconfsdelay delay separation if number of conflict graph edges is larger than predefined value (-1: no limit)
Range: {-1, ..., ∞}
100000
separating/disjunctive/maxdepth node depth of separating bipartite disjunctive cuts (-1: no limit)
Range: {-1, ..., ∞}
-1
separating/disjunctive/maxinvcuts maximal number of cuts investigated per iteration in a branching node
Range: {0, ..., ∞}
50
separating/disjunctive/maxinvcutsroot maximal number of cuts investigated per iteration in the root node
Range: {0, ..., ∞}
250
separating/disjunctive/maxrounds maximal number of separation rounds per iteration in a branching node (-1: no limit)
Range: {-1, ..., ∞}
25
separating/disjunctive/maxroundsroot maximal number of separation rounds in the root node (-1: no limit)
Range: {-1, ..., ∞}
100
separating/disjunctive/maxweightrange maximal valid range max(|weights|)/min(|weights|) of row weights
Range: [1, ∞]
1000
separating/disjunctive/priority priority of separator <disjunctive>
Range: {-536870912, ..., 536870911}
10
separating/disjunctive/strengthen strengthen cut if integer variables are present.
Range: boolean
1

separating/eccuts

Option Description Default
separating/eccuts/cutmaxrange maximal coef. range of a cut (max coef. divided by min coef.) in order to be added to LP relaxation
Range: [0, ∞]
1e+07
separating/eccuts/dynamiccuts should generated cuts be removed from the LP if they are no longer tight?
Range: boolean
1
separating/eccuts/freq frequency for calling separator <eccuts> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
-1
separating/eccuts/maxdepth maximal depth at which the separator is applied (-1: unlimited)
Range: {-1, ..., ∞}
-1
separating/eccuts/maxrounds maximal number of eccuts separation rounds per node (-1: unlimited)
Range: {-1, ..., ∞}
10
separating/eccuts/maxroundsroot maximal number of eccuts separation rounds in the root node (-1: unlimited)
Range: {-1, ..., ∞}
250
separating/eccuts/maxsepacuts maximal number of edge-concave cuts separated per separation round
Range: {0, ..., ∞}
10
separating/eccuts/maxsepacutsroot maximal number of edge-concave cuts separated per separation round in the root node
Range: {0, ..., ∞}
50
separating/eccuts/minviolation minimal violation of an edge-concave cut to be separated
Range: [0, 0.5]
0.3
Options for expert users
separating/eccuts/delay should separator be delayed, if other separators found cuts?
Range: boolean
0
separating/eccuts/expbackoff base for exponential increase of frequency at which separator <eccuts> is called (1: call at each multiple of frequency)
Range: {1, ..., 100}
4
separating/eccuts/maxaggrsize search for edge-concave aggregations of at most this size
Range: {3, ..., 5}
4
separating/eccuts/maxbilinterms maximum number of bilinear terms allowed to be in a quadratic constraint
Range: {0, ..., ∞}
500
separating/eccuts/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <eccuts> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
1
separating/eccuts/maxstallrounds maximum number of unsuccessful rounds in the edge-concave aggregation search
Range: {0, ..., ∞}
5
separating/eccuts/minaggrsize search for edge-concave aggregations of at least this size
Range: {3, ..., 5}
3
separating/eccuts/priority priority of separator <eccuts>
Range: {-536870912, ..., 536870911}
-13000

separating/flowcover

Option Description Default
separating/flowcover/freq frequency for calling separator <flowcover> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
10
Options for expert users
separating/flowcover/delay should separator be delayed, if other separators found cuts?
Range: boolean
0
separating/flowcover/expbackoff base for exponential increase of frequency at which separator <flowcover> is called (1: call at each multiple of frequency)
Range: {1, ..., 100}
4
separating/flowcover/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <flowcover> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
0
separating/flowcover/priority priority of separator <flowcover>
Range: {-536870912, ..., 536870911}
-100000

separating/gauge

Option Description Default
separating/gauge/freq frequency for calling separator <gauge> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
-1
Options for expert users
separating/gauge/delay should separator be delayed, if other separators found cuts?
Range: boolean
0
separating/gauge/expbackoff base for exponential increase of frequency at which separator <gauge> is called (1: call at each multiple of frequency)
Range: {1, ..., 100}
4
separating/gauge/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <gauge> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
1
separating/gauge/nlpiterlimit iteration limit of NLP solver; 0 for no limit
Range: {0, ..., ∞}
1000
separating/gauge/nlptimelimit time limit of NLP solver; 0.0 for no limit
Range: [0, ∞]
0
separating/gauge/priority priority of separator <gauge>
Range: {-536870912, ..., 536870911}
0

separating/gomory

Option Description Default
separating/gomory/away minimal integrality violation of a basis variable in order to try Gomory cut
Range: [0.0001, 0.5]
0.01
separating/gomory/dynamiccuts should generated cuts be removed from the LP if they are no longer tight?
Range: boolean
1
separating/gomory/freq frequency for calling separator <gomory> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
10
separating/gomory/maxrank maximal rank of a gomory cut that could not be scaled to integral coefficients (-1: unlimited)
Range: {-1, ..., ∞}
-1
separating/gomory/maxrankintegral maximal rank of a gomory cut that could be scaled to integral coefficients (-1: unlimited)
Range: {-1, ..., ∞}
-1
separating/gomory/maxrounds maximal number of gomory separation rounds per node (-1: unlimited)
Range: {-1, ..., ∞}
5
separating/gomory/maxroundsroot maximal number of gomory separation rounds in the root node (-1: unlimited)
Range: {-1, ..., ∞}
10
separating/gomory/maxsepacuts maximal number of gomory cuts separated per separation round
Range: {0, ..., ∞}
50
separating/gomory/maxsepacutsroot maximal number of gomory cuts separated per separation round in the root node
Range: {0, ..., ∞}
200
Options for expert users
separating/gomory/delay should separator be delayed, if other separators found cuts?
Range: boolean
0
separating/gomory/delayedcuts should cuts be added to the delayed cut pool?
Range: boolean
0
separating/gomory/expbackoff base for exponential increase of frequency at which separator <gomory> is called (1: call at each multiple of frequency)
Range: {1, ..., 100}
4
separating/gomory/forcecuts if conversion to integral coefficients failed still consider the cut
Range: boolean
1
separating/gomory/makeintegral try to scale cuts to integral coefficients
Range: boolean
0
separating/gomory/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <gomory> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
1
separating/gomory/priority priority of separator <gomory>
Range: {-536870912, ..., 536870911}
-1000
separating/gomory/separaterows separate rows with integral slack
Range: boolean
1
separating/gomory/sidetypebasis choose side types of row (lhs/rhs) based on basis information?
Range: boolean
1

separating/impliedbounds

Option Description Default
separating/impliedbounds/freq frequency for calling separator <impliedbounds> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
10
Options for expert users
separating/impliedbounds/delay should separator be delayed, if other separators found cuts?
Range: boolean
0
separating/impliedbounds/expbackoff base for exponential increase of frequency at which separator <impliedbounds> is called (1: call at each multiple of frequency)
Range: {1, ..., 100}
4
separating/impliedbounds/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <impliedbounds> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
1
separating/impliedbounds/priority priority of separator <impliedbounds>
Range: {-536870912, ..., 536870911}
-50
separating/impliedbounds/usetwosizecliques should violated inequalities for cliques with 2 variables be separated?
Range: boolean
1

separating/intobj

Option Description Default
separating/intobj/freq frequency for calling separator <intobj> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
-1
Options for expert users
separating/intobj/delay should separator be delayed, if other separators found cuts?
Range: boolean
0
separating/intobj/expbackoff base for exponential increase of frequency at which separator <intobj> is called (1: call at each multiple of frequency)
Range: {1, ..., 100}
4
separating/intobj/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <intobj> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
0
separating/intobj/priority priority of separator <intobj>
Range: {-536870912, ..., 536870911}
-100

separating/mcf

Option Description Default
separating/mcf/dynamiccuts should generated cuts be removed from the LP if they are no longer tight?
Range: boolean
1
separating/mcf/freq frequency for calling separator <mcf> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
0
separating/mcf/maxsepacuts maximal number of mcf cuts separated per separation round
Range: {-1, ..., ∞}
100
separating/mcf/maxsepacutsroot maximal number of mcf cuts separated per separation round in the root node – default separation
Range: {-1, ..., ∞}
200
Options for expert users
separating/mcf/checkcutshoreconnectivity should we separate only if the cuts shores are connected?
Range: boolean
1
separating/mcf/delay should separator be delayed, if other separators found cuts?
Range: boolean
0
separating/mcf/expbackoff base for exponential increase of frequency at which separator <mcf> is called (1: call at each multiple of frequency)
Range: {1, ..., 100}
4
separating/mcf/fixintegralrhs should an additional variable be complemented if f0 = 0?
Range: boolean
1
separating/mcf/maxarcinconsistencyratio maximum inconsistency ratio of arcs not to be deleted
Range: [0, ∞]
0.5
separating/mcf/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <mcf> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
0
separating/mcf/maxinconsistencyratio maximum inconsistency ratio for separation at all
Range: [0, ∞]
0.02
separating/mcf/maxtestdelta maximal number of different deltas to try (-1: unlimited) – default separation
Range: {-1, ..., ∞}
20
separating/mcf/maxweightrange maximal valid range max(|weights|)/min(|weights|) of row weights
Range: [1, ∞]
1e+06
separating/mcf/modeltype model type of network (0: auto, 1:directed, 2:undirected)
Range: {0, ..., 2}
0
separating/mcf/nclusters number of clusters to generate in the shrunken network – default separation
Range: {2, ..., 32}
5
separating/mcf/priority priority of separator <mcf>
Range: {-536870912, ..., 536870911}
-10000
separating/mcf/separateflowcutset should we separate flowcutset inequalities on the network cuts?
Range: boolean
1
separating/mcf/separateknapsack should we separate knapsack cover inequalities on the network cuts?
Range: boolean
1
separating/mcf/separatesinglenodecuts should we separate inequalities based on single-node cuts?
Range: boolean
1
separating/mcf/trynegscaling should negative values also be tested in scaling?
Range: boolean
0

separating/oddcycle

Option Description Default
separating/oddcycle/freq frequency for calling separator <oddcycle> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
-1
separating/oddcycle/liftoddcycles Should odd cycle cuts be lifted?
Range: boolean
0
separating/oddcycle/maxrounds maximal number of oddcycle separation rounds per node (-1: unlimited)
Range: {-1, ..., ∞}
10
separating/oddcycle/maxroundsroot maximal number of oddcycle separation rounds in the root node (-1: unlimited)
Range: {-1, ..., ∞}
10
separating/oddcycle/maxsepacuts maximal number of oddcycle cuts separated per separation round
Range: {0, ..., ∞}
5000
separating/oddcycle/maxsepacutsroot maximal number of oddcycle cuts separated per separation round in the root node
Range: {0, ..., ∞}
5000
separating/oddcycle/usegls Should the search method by Groetschel, Lovasz, Schrijver be used? Otherwise use levelgraph method by Hoffman, Padberg.
Range: boolean
1
Options for expert users
separating/oddcycle/addselfarcs add links between a variable and its negated
Range: boolean
1
separating/oddcycle/allowmultiplecuts Even if a variable is already covered by a cut, still allow another cut to cover it too?
Range: boolean
1
separating/oddcycle/cutthreshold maximal number of other cuts s.t. separation is applied (-1 for direct call)
Range: {-1, ..., ∞}
-1
separating/oddcycle/delay should separator be delayed, if other separators found cuts?
Range: boolean
0
separating/oddcycle/expbackoff base for exponential increase of frequency at which separator <oddcycle> is called (1: call at each multiple of frequency)
Range: {1, ..., 100}
4
separating/oddcycle/includetriangles separate triangles found as 3-cycles or repaired larger cycles
Range: boolean
1
separating/oddcycle/lpliftcoef Choose lifting candidate by coef*lpvalue or only by coef?
Range: boolean
0
separating/oddcycle/maxbounddist maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <oddcycle> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1]
1
separating/oddcycle/maxcutslevel maximal number of oddcycle cuts generated in every level of the level graph
Range: {0, ..., ∞}
50
separating/oddcycle/maxcutsroot maximal number of oddcycle cuts generated per chosen variable as root of the level graph
Range: {0, ..., ∞}
1
separating/oddcycle/maxnlevels maximal number of levels in level graph
Range: {0, ..., ∞}
20
separating/oddcycle/maxpernodeslevel percentage of nodes allowed in the same level of the level graph [0-100]
Range: {0, ..., 100}
100
separating/oddcycle/maxreference minimal weight on an edge (in level graph or bipartite graph)
Range: {0, ..., ∞}
0
separating/oddcycle/maxunsucessfull number of unsuccessful calls at current node
Range: {0, ..., ∞}
3
separating/oddcycle/multiplecuts Even if a variable is already covered by a cut, still try it as start node for a cycle search?
Range: boolean
0
separating/oddcycle/offsetnodeslevel offset of nodes allowed in the same level of the level graph (additional to the percentage of levelnodes)
Range: {0, ..., ∞}
10
separating/oddcycle/offsettestvars offset of variables to try the chosen method on (additional to the percentage of testvars)
Range: {0, ..., ∞}
100
separating/oddcycle/percenttestvars percentage of variables to try the chosen method on [0-100]
Range: {0, ..., 100}
0
separating/oddcycle/priority priority of separator <oddcycle>
Range: {-536870912, ..., 536870911}
-15000
separating/oddcycle/recalcliftcoef Calculate lifting coefficient of every candidate in every step (or only if its chosen)?
Range: boolean
1
separating/oddcycle/repaircycles try to repair violated cycles with double appearance of a variable
Range: boolean
1
separating/oddcycle/scalingfactor factor for scaling of the arc-weights
Range: {1, ..., ∞}
1000
separating/oddcycle/sortrootneighbors sort level of the root neighbors by fractionality (maxfrac)
Range: boolean
1
separating/oddcycle/sortswitch use sorted variable array (unsorted(0), maxlp(1), minlp(2), maxfrac(3), minfrac(4))
Range: {0, ..., 4}
3

separating/rapidlearning

Option Description Default
separating/rapidlearning/freq frequency for calling separator <rapidlearning> (-1: never, 0: only in root node)
Range: {-1, ..., 65534}
5
Options for expert users
separating/rapidlearning/applybdchgs should the found global bound deductions be applied in the original SCIP?
Range: boolean
1
separating/rapidlearning/applyconflicts should the found conflicts be applied in the original SCIP?
Range: boolean
1
separating/rapidlearning/applyinfervals should the inference values be used as initialization in the original SCIP?
Range: boolean
1
separating/rapidlearning/applyprimalsol should the incumbent solution be copied to the original SCIP?
Range: boolean
1
separating/rapidlearning/applysolved should a solved status be copied to the original SCIP?
Range: boolean
1
separating/rapidlearning/checkdegeneracy should local LP degeneracy be checked?
Range: boolean
1
separating/rapidlearning/checkdualbound should the progress on the dual bound be checked?
Range: boolean
0
separating/rapidlearning/checkexec check whether rapid learning should be executed
Range: boolean
1
separating/rapidlearning