SCIP

Table of Contents

SCIP (Solving Constraint Integer Programs) 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 [2, 3, 73, 126, 87, 88, 74, 19, 25, 20] and the SCIP web site.

GAMS/SCIP uses CPLEX, if licensed, and otherwise SOPLEX [203] as LP solver, the COIN-OR Interior Point Optimizer IPOPT [194] 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.

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 (e.g., in IPOPT), and for solving LPs if CPLEX' barrier solver is used. Setting threads to 0 (the default) will enable the automatic choice of the number of threads in the MILP presolver and LP solver, but does not enable multithreading for linear algebra routines at the moment.

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 emphasis cpsolver setup a constraint programming like search
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 [126] 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.

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

SCIP includes capabilities to handle nonlinear functions that are specified via algebraic expressions. Therefore, neither external/extrinsic functions nor all GAMS mathematical functions are supported.

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.

Convex MINLPs are much easier to solve for SCIP, provided it recognizes the convexity of the model. The convexity check implemented in SCIP 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 in some cases. However, it can also deteriorate performance as it prevents the use of certain extended formulations.

Another feature that can be especially useful for convex MINLPs is to enable the generation of cuts in feasible solutions, since these supporting hyperplanes can be strong. At the moment, this is only enabled for purely continuous nonlinear programs (QCPs and NLPs), but can be adjusted by parameter constraints/nonlinear/linearizeheursol. In this connection, it may also be beneficial to set separating/poolfreq to 1.

Components

In the following, we list components that are available in SCIP together with some common properties. Many 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
fullstrong 0 -1 100 full strong branching
distribution 0 -1 100 branching rule based on variable influence on cumulative normal distribution of row activities
lookahead 0 -1 100 full strong branching over multiple levels
multaggr 0 -1 100 fullstrong branching on fractional and multi-aggregated variables
cloud 0 -1 100 branching rule that considers several alternative LP optima
allfullstrong -1000 -1 100 all variables full strong branching
gomory -1000 -1 100 Gomory cut score 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
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
or -850000 -850000 850000 0 1 100 medium constraint handler for or constraints: r = or(x1, ..., xn)
and -850100 -850100 850100 1 1 100 fast exhaustive constraint handler for AND-constraints: r = and(x1, ..., xn)
xor -850200 -850200 850200 0 1 100 always constraint handler for xor constraints: r = xor(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
nonlinear -4000010 50 10 1 1 100 always handler for nonlinear constraints specified by algebraic expressions
indicator -6000000 -100 10 10 1 100 fast indicator constraint handler
fixedvar -7000000 -7000000 0 -1 -1 -1 always check bounds of original variables that are not active in transformed problem
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.

Cut Selectors

cut selector priority description
hybrid 8000 weighted sum of efficacy, dircutoffdist, objparal, and intsupport
ensemble 7000 weighted sum of many terms with optional filtering and penalties
dynamic 7000 dynamic orthogonality for hybrid cutsel

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.

Nonlinear Handler

nonlinear handler enabled detect priority enforce priority description
default 1 0 0 default handler for expressions
convex 1 50 50 handler that identifies and estimates convex expressions
concave 1 40 40 handler that identifies and estimates concave expressions
bilinear 1 -10 -10 bilinear handler for expressions
perspective 1 -20 125 perspective handler for expressions
quadratic 1 1 100 handler for quadratic expressions
quotient 1 20 20 nonlinear handler for quotient expressions
signomial 1 30 30 handler for signomial expressions
soc 1 100 100 nonlinear handler for second-order cone structures

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

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
rlt 10 0 1 reformulation-linearization-technique separator
minor 0 10 1 separator to ensure that 2x2 principal minors of X - xx' are positive semi-definite
gauge 0 -1 1 gauge separator
convexproj 0d -1 1 separate at projection of point onto convex region
interminor 0 -1 1 intersection cuts separator to ensure that 2x2 minors of X (= xx') have determinant 0
mixing -50 10 1 mixing inequality separator
impliedbounds -50 10 1 implied bounds separator
intobj -100 -1 0 integer objective value separator
gomory -1000 10 1 separator for Gomory mixed-integer and strong CG cuts from LP tableau rows
cgmip -1000 -1 0 Chvatal-Gomory cuts via MIPs separator
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
lagromory -8000 -1 1 separator for Lagromory cuts for MIP relaxations
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
strongcg -100000 10 0 separator for strong CG cuts
gomorymi -100000 10 0 separator for Gomory mixed-integer cuts
cmir -100000 10 0 separator for cmir cuts
knapsackcover -100000 10 0 separator for knapsack cover 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/infbound value to use for variable bounds that are missing or exceed numerics/infinity
Range: [0, ∞]
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/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, ..., 1073741822}
-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, ..., 1073741822}
-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, ..., 1073741822}
-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, ..., 1073741822}
-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/gomory

Option Description Default
branching/gomory/efficacyweight weight of efficacy in the weighted sum cut scoring rule
Range: [-1, 1]
1
branching/gomory/intsupportweight weight of integer support in the weighted sum cut scoring rule
Range: [-1, 1]
0
branching/gomory/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/gomory/maxdepth maximal depth level, up to which branching rule <gomory> should be used (-1 for no limit)
Range: {-1, ..., 1073741822}
-1
branching/gomory/maxncands maximum amount of branching candidates to generate Gomory cuts for (-1: all candidates)
Range: {-1, ..., ∞}
-1
branching/gomory/objparallelweight weight of objective parallelism in the weighted sum cut scoring rule
Range: [-1, 1]
0
branching/gomory/performrelpscost whether relpscost branching should be called without branching (used for bound inferences and conflicts)
Range: boolean
0
branching/gomory/priority priority of branching rule <gomory>
Range: {-536870912, ..., 536870911}
-1000
branching/gomory/useweakercuts use weaker cuts that are exactly derived from the branching split disjunction
Range: boolean
1

branching/inference

Option Description Default
branching/inference/conflictprio priority value for using conflict weights in lex. order
Range: {0, ..., ∞}
1
branching/inference/cutoffprio priority value for using cutoff weights in lex. order
Range: {0, ..., ∞}
1
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, ..., 1073741822}
-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, ..., 1073741822}
-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, ..., 1073741822}
-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, ..., 1073741822}
-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, ..., 1073741822}
-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, ..., 1073741822}
-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, ..., 1073741822}
-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, ..., 1073741822}
-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, ..., 1073741822}
-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/gmiavgeffweight weight in score calculations for average GMI cuts normalized efficacy
Range: real
0
branching/relpscost/gmilasteffweight weight in score calculations for last GMI cuts normalized efficacy
Range: real
1e-05
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, ..., 1073741822}
-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, ..., 1073741822}
1
constraints/SOS1/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
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, ..., 1073741822}
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, ..., 1073741822}
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, ..., 1073741822}
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, ..., 1073741822}
1
constraints/SOS2/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
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, ..., 1073741822}
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/and

Option Description Default
constraints/and/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
1
constraints/and/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
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, ..., 1073741822}
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/bounddisjunction

Option Description Default
constraints/bounddisjunction/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
1
constraints/bounddisjunction/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
-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, ..., 1073741822}
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, ..., 1073741822}
1
constraints/components/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
-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, ..., 1073741822}
-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/fixedvar

Option Description Default
constraints/fixedvar/enabled whether to check and enforce bounds on fixed variables
Range: boolean
1
constraints/fixedvar/prefercut whether to prefer separation over tightening LP feastol in enforcement
Range: boolean
1
constraints/fixedvar/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
-1
constraints/fixedvar/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
-1
constraints/fixedvar/subscips whether to act on subSCIPs
Range: boolean
1
Options for expert users
constraints/fixedvar/delayprop should propagation method be delayed, if other propagators found reductions?
Range: boolean
0
constraints/fixedvar/delaysepa should separation method be delayed, if other separators found cuts?
Range: boolean
0
constraints/fixedvar/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, ..., 1073741822}
-1
constraints/fixedvar/maxprerounds maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞}
0
constraints/fixedvar/presoltiming timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
28
constraints/fixedvar/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, ..., 1073741822}
1
constraints/indicator/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
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, ..., 1073741822}
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, ..., 1073741822}
-1
constraints/integral/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
-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, ..., 1073741822}
-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, ..., 1073741822}
1
constraints/knapsack/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
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, ..., 1073741822}
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, ..., 1073741822}
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, ..., 1073741822}
1
constraints/linear/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
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, ..., 1073741822}
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, ..., 1073741822}
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, ..., 1073741822}
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, ..., 1073741822}
1
constraints/logicor/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
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, ..., 1073741822}
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/assumeconvex whether to assume that any constraint is convex
Range: boolean
0
constraints/nonlinear/bilinmaxnauxexprs maximal number of auxiliary expressions per bilinear term
Range: {0, ..., ∞}
10
constraints/nonlinear/linearizeheursol whether tight linearizations of nonlinear constraints should be added to cutpool when some heuristics finds a new solution ('o'ff, on new 'i'ncumbents, on 'e'very solution)
Range: o, i, e
i if QCP or NLP, o otherwise
constraints/nonlinear/maxproprounds limit on number of propagation rounds for a set of constraints within one round of SCIP propagation
Range: {0, ..., ∞}
10
constraints/nonlinear/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
1
constraints/nonlinear/reformbinprods whether to reformulate products of binary variables during presolving
Range: boolean
1
constraints/nonlinear/reformbinprodsand whether to use the AND constraint handler for reformulating binary products
Range: boolean
1
constraints/nonlinear/reformbinprodsfac minimum number of terms to reformulate bilinear binary products by factorizing variables (≤ 1: disabled)
Range: {1, ..., ∞}
50
constraints/nonlinear/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
1
Options for expert users
constraints/nonlinear/checkvarlocks whether 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/nonlinear/conssiderelaxamount by how much to relax constraint sides during bound tightening
Range: [0, 1]
1e-09
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, ..., 1073741822}
100
constraints/nonlinear/enfoauxviolfactor an expression will be enforced if the "auxiliary" violation is at least this factor times the "original" violation
Range: [0, 1]
0.01
constraints/nonlinear/forbidmultaggrnlvar whether to forbid multiaggregation of nonlinear variables
Range: boolean
1
constraints/nonlinear/forcestrongcut whether to force "strong" cuts in enforcement
Range: boolean
0
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/propauxvars whether to check bounds of all auxiliary variable to seed reverse propagation
Range: boolean
1
constraints/nonlinear/propinenforce whether to (re)run propagation in enforcement
Range: boolean
0
constraints/nonlinear/proptiming timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15}
1
constraints/nonlinear/rownotremovable whether to make rows to be non-removable in the node where they are added (can prevent some cycling): 'o'ff, in 'e'nforcement only, 'a'lways
Range: o, e, a
o
constraints/nonlinear/strongcutefficacy consider efficacy requirement when deciding whether a cut is "strong"
Range: boolean
0
constraints/nonlinear/strongcutmaxcoef "strong" cuts will be scaled to have their maximal coef in [1/strongcutmaxcoef,strongcutmaxcoef]
Range: [1, ∞]
1000
constraints/nonlinear/tightenlpfeastol whether to tighten LP feasibility tolerance during enforcement, if it seems useful
Range: boolean
1
constraints/nonlinear/varboundrelax strategy on how to relax variable bounds during bound tightening: relax (n)ot, relax by (a)bsolute value, relax always by a(b)solute value, relax by (r)relative value
Range: n, a, b, r
r
constraints/nonlinear/varboundrelaxamount by how much to relax variable bounds during bound tightening if strategy 'a', 'b', or 'r'
Range: [0, 1]
1e-09
constraints/nonlinear/violscale method how to scale violations to make them comparable (not used for feasibility check): (n)one, (a)ctivity and side, norm of (g)radient
Range: n, a, g
n
constraints/nonlinear/vpadjfacetthresh adjust computed facet of envelope of vertex-polyhedral function up to a violation of this value times LP feasibility tolerance
Range: [0, ∞]
10
constraints/nonlinear/vpdualsimplex whether to use dual simplex instead of primal simplex for LP that computes facet of vertex-polyhedral function
Range: boolean
1
constraints/nonlinear/vpmaxperturb maximal relative perturbation of reference point when computing facet of envelope of vertex-polyhedral function (dim>2)
Range: [0, 1]
0.001
constraints/nonlinear/weakcutminviolfactor retry enfo of constraint with weak cuts if violation is least this factor of maximal violated constraints
Range: [0, 2]
0.5
constraints/nonlinear/weakcutthreshold threshold for when to regard a cut from an estimator as weak (lower values allow more weak cuts)
Range: [0, 1]
0.2

constraints/nonlinear/branching

Option Description Default
constraints/nonlinear/branching/aux from which depth on in the tree to allow branching on auxiliary variables (variables added for extended formulation)
Range: {0, ..., ∞}
constraints/nonlinear/branching/domainweight weight by how much to consider the domain width in branching score
Range: [0, ∞]
0
constraints/nonlinear/branching/dualweight weight by how much to consider the dual values of rows that contain a variable for its branching score
Range: [0, ∞]
0
constraints/nonlinear/branching/external whether to use external branching candidates and branching rules for branching
Range: boolean
0
constraints/nonlinear/branching/fracweight weight by how much to consider fractionality of integer variables in branching score for spatial branching
Range: [0, ∞]
1
constraints/nonlinear/branching/highscorefactor consider a variable branching score high if its branching score ≥ this factor * maximal branching score among all variables
Range: [0, 1]
0.9
constraints/nonlinear/branching/highviolfactor consider a constraint highly violated if its violation is ≥ this factor * maximal violation among all constraints
Range: [0, 1]
0
constraints/nonlinear/branching/mixfractional minimal average pseudo cost count for discrete variables at which to start considering spatial branching before branching on fractional integer variables
Range: [0, ∞]
constraints/nonlinear/branching/pscostreliable minimum pseudo-cost update count required to consider pseudo-costs reliable
Range: [0, ∞]
2
constraints/nonlinear/branching/pscostweight weight by how much to consider the pseudo cost of a variable for its branching score
Range: [0, ∞]
1
constraints/nonlinear/branching/scoreagg how to aggregate several branching scores given for the same expression: 'a'verage, 'm'aximum, 's'um
Range: a, m, s
s
constraints/nonlinear/branching/vartypeweight weight by how much to consider variable type (continuous: 0, binary: 1, integer: 0.1, impl-integer: 0.01) in branching score
Range: [0, ∞]
0.5
constraints/nonlinear/branching/violsplit method used to split violation in expression onto variables: 'u'niform, 'm'idness of solution, 'd'omain width, 'l'ogarithmic domain width
Range: u, m, d, l
m
constraints/nonlinear/branching/violweight weight by how much to consider the violation assigned to a variable for its branching score
Range: [0, ∞]
1

constraints/nonlinear/upgrade

Option Description Default
constraints/nonlinear/upgrade/linear enable nonlinear upgrading for constraint handler <linear>
Range: boolean
1
constraints/nonlinear/upgrade/setppc enable nonlinear upgrading for constraint handler <setppc>
Range: boolean
1

constraints/or

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

constraints/orbisack

Option Description Default
constraints/orbisack/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
5
constraints/orbisack/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
1
constraints/orbitope/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
-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, ..., 1073741822}
-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/setppc

Option Description Default
constraints/setppc/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
1
constraints/setppc/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
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, ..., 1073741822}
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/symresack

Option Description Default
constraints/symresack/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
5
constraints/symresack/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
1
constraints/varbound/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
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, ..., 1073741822}
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

constraints/xor

Option Description Default
constraints/xor/propfreq frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
1
constraints/xor/sepafreq frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822}
0
Options for expert users
constraints/xor/addextendedform should the extended formulation be added in presolving?
Range: boolean
0
constraints/xor/addflowextended should the extended flow formulation be added (nonsymmetric formulation otherwise)?
Range: boolean
0
constraints/xor/delayprop should propagation method be delayed, if other propagators found reductions?
Range: boolean
0
constraints/xor/delaysepa should separation method be delayed, if other separators found cuts?
Range: boolean
0
constraints/xor/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, ..., 1073741822}
100
constraints/xor/gausspropfreq frequency for applying the Gauss propagator
Range: {-1, ..., 1073741822}
5
constraints/xor/maxprerounds maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞}
-1
constraints/xor/presolpairwise should pairwise constraint comparison be performed in presolving?
Range: boolean
1
constraints/xor/presoltiming timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60}
28
constraints/xor/presolusehashing should hash table be used for detecting redundant constraints in advance?
Range: boolean
1
constraints/xor/proptiming timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15}
1
constraints/xor/separateparity should parity inequalities be separated?
Range: boolean
0

cutselection/dynamic

Option Description Default
cutselection/dynamic/dircutoffdistweight weight of directed cutoff distance in cut score calculation
Range: [0, ∞]
0
cutselection/dynamic/efficacyweight weight of efficacy in cut score calculation
Range: [0, ∞]
1
cutselection/dynamic/filtermode filtering strategy during cut selection
Range: d, f
d
cutselection/dynamic/intsupportweight weight of integral support in cut score calculation
Range: [0, ∞]
0
cutselection/dynamic/maxdepth maximum depth at which this cutselector is employed
Range: {-1, ..., 1073741822}
-1
cutselection/dynamic/mingain minimal efficacy gain for a cut to enter the LP
Range: [0, 1]
0.01
cutselection/dynamic/minortho minimal orthogonality for a cut to enter the LP
Range: [0, 1]
0.9
cutselection/dynamic/objparalweight weight of objective parallelism in cut score calculation
Range: [0, ∞]
0
cutselection/dynamic/priority priority of cut selection rule <dynamic>
Range: {-536870912, ..., 1073741823}
7000

cutselection/ensemble

Option Description Default
cutselection/ensemble/dircutoffdistweight weight of normed-directed cutoff distance in cut score calculation
Range: [0, ∞]
0
cutselection/ensemble/efficacyweight weight of normed-efficacy in cut score calculation
Range: [0, ∞]
0.75
cutselection/ensemble/endsparsitybonus max sparsity value for which a bonus is applied in cut score calculation
Range: [0, ∞]
0.2
cutselection/ensemble/expimprovweight weight of normed-expected obj improvement in cut score calculation
Range: [0, ∞]
0.1
cutselection/ensemble/filterparalcuts should cuts be filtered so no two parallel cuts are added
Range: boolean
0
cutselection/ensemble/goodnumericsbonus weight of good numerics bonus (ratio of coefficients) in cut score calculation
Range: [0, ∞]
0
cutselection/ensemble/intsupportweight weight of integral support in cut score calculation
Range: [0, ∞]
0.45
cutselection/ensemble/locksweight weight of normed-num-locks in cut score calculation
Range: [0, ∞]
0.25
cutselection/ensemble/maxnonzerorootround max non-zeros per round applied cuts (root). multiple num LP cols.
Range: [0, ∞]
4.5
cutselection/ensemble/maxnonzerotreeround max non-zeros per round applied cuts (tree). multiple num LP cols.
Range: [0, ∞]
9.5
cutselection/ensemble/maxparal threshold for when two cuts are considered parallel to each other
Range: [0, 1]
0.95
cutselection/ensemble/maxsparsitybonus weight of maximum sparsity reward in cut score calculation
Range: [0, ∞]
0.5
cutselection/ensemble/minscore minimum score s.t. a cut can be added
Range: real
0
cutselection/ensemble/objparalweight weight of objective parallelism in cut score calculation
Range: [0, ∞]
0.25
cutselection/ensemble/priority priority of cut selection rule <ensemble>
Range: {-536870912, ..., 1073741823}
7000
cutselection/ensemble/pscostweight weight of normed-pseudo-costs in cut score calculation
Range: [0, ∞]
0.75
Options for expert users
cutselection/ensemble/filterdensecuts should cuts over a given density threshold be filtered
Range: boolean
1
cutselection/ensemble/maxcoefratiobonus max coefficient ratio for which numeric bonus is applied.
Range: {1, ..., 1000000}
10000
cutselection/ensemble/maxcutdensity max allowed cut density if filtering dense cuts
Range: [0, 1]
0.425
cutselection/ensemble/maxcuts max number of cuts such that cut selector is applied.
Range: {1, ..., 1000000}
200
cutselection/ensemble/maxnumvars max number of variables such that cut selector is applied.
Range: {1, ..., 1000000}
50000
cutselection/ensemble/paralpenalty penalty for weaker of two parallel cuts if penalising parallel cuts
Range: [0, ∞]
0.25
cutselection/ensemble/penaliselocks should the number of locks be penalised instead of rewarded
Range: boolean
1
cutselection/ensemble/penaliseobjparal should objective parallelism be penalised instead of rewarded
Range: boolean
1
cutselection/ensemble/penaliseparalcuts should two parallel cuts be penalised instead of outright filtered
Range: boolean
1

cutselection/hybrid

Option Description Default
cutselection/hybrid/dircutoffdistweight weight of directed cutoff distance in cut score calculation
Range: [0, ∞]
0
cutselection/hybrid/efficacyweight weight of efficacy in cut score calculation
Range: [0, ∞]
1
cutselection/hybrid/intsupportweight weight of integral support in cut score calculation
Range: [0, ∞]
0.1
cutselection/hybrid/minortho minimal orthogonality for a cut to enter the LP
Range: [0, 1]
0.9
cutselection/hybrid/minorthoroot minimal orthogonality for a cut to enter the LP in the root node
Range: [0, 1]
0.9
cutselection/hybrid/objparalweight weight of objective parallelism in cut score calculation
Range: [0, ∞]
0.1
cutselection/hybrid/priority priority of cut selection rule <hybrid>
Range: {-536870912, ..., 1073741823}
8000

decomposition

Option Description Default
decomposition/disablemeasures disable expensive measures
Range: boolean
0
decomposition/maxgraphedge maximum number of edges in block graph computation (-1: no limit, 0: disable block graph computation)
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

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

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/showstats should statistics be shown at the end?
Range: boolean
0
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

expr/log

Option Description Default
expr/log/minzerodistance minimal distance from zero to enforce for child in bound tightening
Range: [0, 1]
1e-09

expr/pow

Option Description Default
expr/pow/distribfracexponent whether a fractional exponent is distributed onto factors on power of product
Range: boolean
0
expr/pow/expandmaxexponent maximal exponent when to expand power of sum in simplify
Range: {1, ..., ∞}
2
expr/pow/minzerodistance minimal distance from zero to enforce for child in bound tightening
Range: [0, 1]
1e-09

expr/prod

Option Description Default
expr/prod/expandalways whether to expand products of a sum and several factors in simplify
Range: boolean
0

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, ..., 1073741822}
-1
heuristics/actconsdiving/freqofs frequency offset for calling primal heuristic <actconsdiving>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
5
heuristics/adaptivediving/freqofs frequency offset for calling primal heuristic <adaptivediving>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
20
heuristics/alns/freqofs frequency offset for calling primal heuristic <alns>
Range: {0, ..., 1073741822}
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/nodesquotmin lower bound fraction of nodes compared to the main SCIP for budget computation
Range: [0, 1]
0
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, exp.3-(i)x
Range: u, e, g, i
i
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/initduringroot should the heuristic be executed multiple times during the root node?
Range: boolean
0
heuristics/alns/maxcallssamesol number of allowed executions of the heuristic on the same incumbent solution (-1: no limit, 0: number of active neighborhoods)
Range: {-1, ..., 100}
-1
heuristics/alns/maxdepth maximal depth level to call primal heuristic <alns> (-1: no limit)
Range: {-1, ..., 1073741822}
-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/shownbstats show statistics on neighborhoods?
Range: boolean
0
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, ..., 1073741822}
-1
heuristics/bound/freqofs frequency offset for calling primal heuristic <bound>
Range: {0, ..., 1073741822}
0
Options for expert users
heuristics/bound/maxdepth maximal depth level to call primal heuristic <bound> (-1: no limit)
Range: {-1, ..., 1073741822}
-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, ..., 1073741822}
0
heuristics/clique/freqofs frequency offset for calling primal heuristic <clique>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
-1
heuristics/coefdiving/freqofs frequency offset for calling primal heuristic <coefdiving>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
0
heuristics/completesol/freqofs frequency offset for calling primal heuristic <completesol>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
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, ..., 1073741822}
10
heuristics/conflictdiving/freqofs frequency offset for calling primal heuristic <conflictdiving>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
30
heuristics/crossover/freqofs frequency offset for calling primal heuristic <crossover>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
-1
heuristics/dins/freqofs frequency offset for calling primal heuristic <dins>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
10
heuristics/distributiondiving/freqofs frequency offset for calling primal heuristic <distributiondiving>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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/dps

Option Description Default
heuristics/dps/freq frequency for calling primal heuristic <dps> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822}
-1
heuristics/dps/freqofs frequency offset for calling primal heuristic <dps>
Range: {0, ..., 1073741822}
0
heuristics/dps/maxiterations maximal number of iterations
Range: {1, ..., ∞}
50
heuristics/dps/maxlinkscore maximal linking score of used decomposition (equivalent to percentage of linking constraints)
Range: [0, 1]
1
heuristics/dps/penalty multiplier for absolute increase of penalty parameters (0: no increase)
Range: [0, ∞]
100
heuristics/dps/reoptimize should the problem get reoptimized with the original objective function?
Range: boolean
0
heuristics/dps/reoptlimits should strict limits for reoptimization be set?
Range: boolean
1
heuristics/dps/reuse should solutions get reused in subproblems?
Range: boolean
0
heuristics/dps/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/dps/maxdepth maximal depth level to call primal heuristic <dps> (-1: no limit)
Range: {-1, ..., 1073741822}
-1
heuristics/dps/priority priority of heuristic <dps>
Range: {-536870912, ..., 536870911}
75000

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, ..., 1073741822}
-1
heuristics/dualval/freqofs frequency offset for calling primal heuristic <dualval>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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}
-10

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, ..., 1073741822}
10
heuristics/farkasdiving/freqofs frequency offset for calling primal heuristic <farkasdiving>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
20
heuristics/feaspump/freqofs frequency offset for calling primal heuristic <feaspump>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
-1
heuristics/fixandinfer/freqofs frequency offset for calling primal heuristic <fixandinfer>
Range: {0, ..., 1073741822}
0
Options for expert users
heuristics/fixandinfer/maxdepth maximal depth level to call primal heuristic <fixandinfer> (-1: no limit)
Range: {-1, ..., 1073741822}
-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, ..., 1073741822}
10
heuristics/fracdiving/freqofs frequency offset for calling primal heuristic <fracdiving>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
20
heuristics/gins/freqofs frequency offset for calling primal heuristic <gins>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
10
heuristics/guideddiving/freqofs frequency offset for calling primal heuristic <guideddiving>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
1
heuristics/indicator/freqofs frequency offset for calling primal heuristic <indicator>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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/indicatordiving

Option Description Default
heuristics/indicatordiving/backtrack use one level of backtracking if infeasibility is encountered?
Range: boolean
1
heuristics/indicatordiving/freq frequency for calling primal heuristic <indicatordiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822}
0
heuristics/indicatordiving/freqofs frequency offset for calling primal heuristic <indicatordiving>
Range: {0, ..., 1073741822}
0
heuristics/indicatordiving/lpresolvedomchgquot percentage of immediate domain changes during probing to trigger LP resolve
Range: [0, ∞]
0.15
heuristics/indicatordiving/lpsolvefreq LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
Range: {0, ..., ∞}
30
heuristics/indicatordiving/maxlpiterofs additional number of allowed LP iterations
Range: {0, ..., ∞}
1000
heuristics/indicatordiving/maxlpiterquot maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞]
0.05
heuristics/indicatordiving/onlylpbranchcands should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean
0
heuristics/indicatordiving/roundingfrac in violation case all fractional below this value are fixed to constant
Range: [0, 1]
0.5
heuristics/indicatordiving/roundingmode decides which roundingmode is selected (0: conservative, 1: aggressive)
Range: {0, ..., 1}
0
heuristics/indicatordiving/runwithoutscinds should heur run if there are no indicator constraints modeling semicont. vars?
Range: boolean
0
heuristics/indicatordiving/semicontscoremode which values of semi-continuous variables should get a high score? (0: low, 1: middle, 2: high)
Range: {0, ..., 2}
0
heuristics/indicatordiving/usevarbounds should varbound constraints be considered?
Range: boolean
1
Options for expert users
heuristics/indicatordiving/maxdepth maximal depth level to call primal heuristic <indicatordiving> (-1: no limit)
Range: {-1, ..., 1073741822}
-1
heuristics/indicatordiving/maxdiveavgquot maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞]
0
heuristics/indicatordiving/maxdiveavgquotnosol maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞]
0
heuristics/indicatordiving/maxdiveubquot maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1]
0.8
heuristics/indicatordiving/maxdiveubquotnosol maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1]
0.1
heuristics/indicatordiving/maxreldepth maximal relative depth to start diving
Range: [0, 1]
1
heuristics/indicatordiving/minreldepth minimal relative depth to start diving
Range: [0, 1]
0
heuristics/indicatordiving/priority priority of heuristic <indicatordiving>
Range: {-536870912, ..., 536870911}
-150000

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, ..., 1073741822}
-1
heuristics/intdiving/freqofs frequency offset for calling primal heuristic <intdiving>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
10
heuristics/intshifting/freqofs frequency offset for calling primal heuristic <intshifting>
Range: {0, ..., 1073741822}
0
Options for expert users
heuristics/intshifting/maxdepth maximal depth level to call primal heuristic <intshifting> (-1: no limit)
Range: {-1, ..., 1073741822}
-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, ..., 1073741822}
10
heuristics/linesearchdiving/freqofs frequency offset for calling primal heuristic <linesearchdiving>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
-1
heuristics/localbranching/freqofs frequency offset for calling primal heuristic <localbranching>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
0
heuristics/locks/freqofs frequency offset for calling primal heuristic <locks>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
15
heuristics/lpface/freqofs frequency offset for calling primal heuristic <lpface>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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}
-1104010
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, ..., 1073741822}
50
heuristics/mpec/freqofs frequency offset for calling primal heuristic <mpec>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
0
heuristics/multistart/freqofs frequency offset for calling primal heuristic <multistart>
Range: {0, ..., 1073741822}
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/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, ..., 1073741822}
-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, ..., 1073741822}
-1
heuristics/mutation/freqofs frequency offset for calling primal heuristic <mutation>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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}
-1103010
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, ..., 1073741822}
10
heuristics/nlpdiving/freqofs frequency offset for calling primal heuristic <nlpdiving>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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}
-1003010

heuristics/objpscostdiving

Option Description Default
heuristics/objpscostdiving/freq frequency for calling primal heuristic <objpscostdiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822}
20
heuristics/objpscostdiving/freqofs frequency offset for calling primal heuristic <objpscostdiving>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
-1
heuristics/octane/freqofs frequency offset for calling primal heuristic <octane>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
0
heuristics/ofins/freqofs frequency offset for calling primal heuristic <ofins>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
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, ..., 1073741822}
1
heuristics/oneopt/freqofs frequency offset for calling primal heuristic <oneopt>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
0
heuristics/padm/freqofs frequency offset for calling primal heuristic <padm>
Range: {0, ..., 1073741822}
0
heuristics/padm/reoptimize should the problem get reoptimized with the original objective function?
Range: boolean
1
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, ..., 1073741822}
-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/original should the original problem be used? This is only for testing and not recommended!
Range: boolean
0
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, ..., 1073741822}
-1
heuristics/proximity/freqofs frequency offset for calling primal heuristic <proximity>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
10
heuristics/pscostdiving/freqofs frequency offset for calling primal heuristic <pscostdiving>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
20
heuristics/randrounding/freqofs frequency offset for calling primal heuristic <randrounding>
Range: {0, ..., 1073741822}
0
Options for expert users
heuristics/randrounding/maxdepth maximal depth level to call primal heuristic <randrounding> (-1: no limit)
Range: {-1, ..., 1073741822}
-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, ..., 1073741822}
0
heuristics/rens/freqofs frequency offset for calling primal heuristic <rens>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
0
heuristics/reoptsols/freqofs frequency offset for calling primal heuristic <reoptsols>
Range: {0, ..., 1073741822}
0
Options for expert users
heuristics/reoptsols/maxdepth maximal depth level to call primal heuristic <reoptsols> (-1: no limit)
Range: {-1, ..., 1073741822}
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, ..., 1073741822}
-1
heuristics/repair/freqofs frequency offset for calling primal heuristic <repair>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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}
-20

heuristics/rins

Option Description Default
heuristics/rins/freq frequency for calling primal heuristic <rins> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822}
25
heuristics/rins/freqofs frequency offset for calling primal heuristic <rins>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
20
heuristics/rootsoldiving/freqofs frequency offset for calling primal heuristic <rootsoldiving>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
1
heuristics/rounding/freqofs frequency offset for calling primal heuristic <rounding>
Range: {0, ..., 1073741822}
0
Options for expert users
heuristics/rounding/maxdepth maximal depth level to call primal heuristic <rounding> (-1: no limit)
Range: {-1, ..., 1073741822}
-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/scheduler

Option Description Default
heuristics/scheduler/freq frequency for calling primal heuristic <scheduler> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822}
-1
heuristics/scheduler/freqofs frequency offset for calling primal heuristic <scheduler>
Range: {0, ..., 1073741822}
0
heuristics/scheduler/nodesofs offset added to the nodes budget
Range: {0, ..., ∞}
500
heuristics/scheduler/nodesquot fraction of nodes compared to the main SCIP for budget computation
Range: [0, 1]
0.1
heuristics/scheduler/nodesquotmin lower bound fraction of nodes compared to the main SCIP for budget computation
Range: [0, 1]
0
heuristics/scheduler/nsolslim limit on the number of improving solutions in a sub-SCIP call
Range: {-1, ..., ∞}
3
heuristics/scheduler/seed initial random seed for bandit algorithms and random decisions by neighborhoods
Range: {0, ..., ∞}
113
Options for expert users
heuristics/scheduler/alpha parameter to increase the confidence width in UCB
Range: [0, 100]
0.0016
heuristics/scheduler/banditalgo the bandit algorithm: (u)pper confidence bounds, (e)xp.3, epsilon (g)reedy, exp.3-(i)x
Range: u, e, g, i
i
heuristics/scheduler/beta reward offset between 0 and 1 at every observation for Exp.3
Range: [0, 1]
0
heuristics/scheduler/conflictrewardweight weight by how much number of conflicts found by diving is rewarded in reward function
Range: [0, 1]
0.2
heuristics/scheduler/copycuts should cutting planes be copied to the sub-SCIP?
Range: boolean
0
heuristics/scheduler/defaultroot should the default priorities be used at the root node?
Range: boolean
1
heuristics/scheduler/effortrewardweight weight by how much effort is rewarded in reward function
Range: [0, 1]
0.2
heuristics/scheduler/eps increase exploration in epsilon-greedy bandit algorithm
Range: [0, 1]
0.468584
heuristics/scheduler/epsgreedy_usemod TRUE if modified version of the epsilon-greedy bandit algorithm should be used
Range: boolean
1
heuristics/scheduler/fixtol tolerance by which the fixing rate may be missed without generic fixing
Range: [0, 1]
0.1
heuristics/scheduler/gamma weight between uniform (gamma ~ 1) and weight driven (gamma ~ 0) probability distribution for exp3
Range: [0, 1]
0.0704146
heuristics/scheduler/heurtimelimit time limit for a single heuristic run
Range: [0, ∞]
60
heuristics/scheduler/initdivingnodelimit initial node limit for diving heuristics
Range: {0, ..., ∞}
500
heuristics/scheduler/initduringroot should the heuristic be executed multiple times during the root node?
Range: boolean
0
heuristics/scheduler/initlnsnodelimit initial node limit for LNS heuristics
Range: {0, ..., ∞}
50
heuristics/scheduler/maxcallssamesol number of allowed executions of the heuristic on the same incumbent solution (-1: no limit, 0: number of active neighborhoods)
Range: {-1, ..., 100}
-1
heuristics/scheduler/maxdepth maximal depth level to call primal heuristic <scheduler> (-1: no limit)
Range: {-1, ..., 1073741822}
-1
heuristics/scheduler/maxnodes maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞}
500
heuristics/scheduler/minnodes minimum number of nodes required to start a sub-SCIP
Range: {0, ..., ∞}
50
heuristics/scheduler/nselections number of heuristics picked by the scheduler in one call (-1: number of controlled heuristics, 0: until new incumbent is found)
Range: {-1, ..., 100}
5
heuristics/scheduler/priority priority of heuristic <scheduler>
Range: {-536870912, ..., 536870911}
-30000
heuristics/scheduler/qualrewardweight weight by how much quality of a new incumbent is rewarded in reward function
Range: [0, 1]
0.3
heuristics/scheduler/resetweights should the bandit algorithms be reset when a new problem is read?
Range: boolean
0
heuristics/scheduler/solrewardweight weight by how much finding a new incumbent is rewarded in reward function
Range: [0, 1]
0.3
heuristics/scheduler/subsciprandseeds should random seeds of sub-SCIPs be altered to increase diversification?
Range: boolean
0
heuristics/scheduler/targetnodefactor factor by which target node number is eventually increased
Range: [1, 100000]
1.05
heuristics/scheduler/unfixtol tolerance by which the fixing rate may be exceeded without generic unfixing
Range: [0, 1]
0.1
heuristics/scheduler/usedistances distances from fixed variables be used for variable prioritization
Range: boolean
1
heuristics/scheduler/uselocalredcost should local reduced costs be used for generic (un)fixing?
Range: boolean
0
heuristics/scheduler/usepscost should pseudo cost scores be used for variable priorization?
Range: boolean
1
heuristics/scheduler/useredcost should reduced cost scores be used for variable prioritization?
Range: boolean
1
heuristics/scheduler/usesubscipheurs should the heuristic activate other sub-SCIP heuristics during its search?
Range: boolean
0
heuristics/scheduler/waitingnodes number of nodes since last incumbent solution that the heuristic should wait
Range: {0, ..., ∞}
0

heuristics/scheduler/crossover

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

heuristics/scheduler/dins

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

heuristics/scheduler/localbranching

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

heuristics/scheduler/mutation

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

heuristics/scheduler/proximity

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

heuristics/scheduler/rens

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

heuristics/scheduler/rins

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

heuristics/scheduler/trustregion

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

heuristics/scheduler/zeroobjective

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

heuristics/shiftandpropagate

Option Description Default
heuristics/shiftandpropagate/freq frequency for calling primal heuristic <shiftandpropagate> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822}
0
heuristics/shiftandpropagate/freqofs frequency offset for calling primal heuristic <shiftandpropagate>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
10
heuristics/shifting/freqofs frequency offset for calling primal heuristic <shifting>
Range: {0, ..., 1073741822}
0
Options for expert users
heuristics/shifting/maxdepth maximal depth level to call primal heuristic <shifting> (-1: no limit)
Range: {-1, ..., 1073741822}
-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, ..., 1073741822}
1
heuristics/simplerounding/freqofs frequency offset for calling primal heuristic <simplerounding>
Range: {0, ..., 1073741822}
0
Options for expert users
heuristics/simplerounding/maxdepth maximal depth level to call primal heuristic <simplerounding> (-1: no limit)
Range: {-1, ..., 1073741822}
-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}
-30

heuristics/subnlp

Option Description Default
heuristics/subnlp/expectinfeas percentage of NLP solves with infeasible status required to tell NLP solver to expect an infeasible NLP
Range: [0, 1]
0
heuristics/subnlp/feastolfactor factor on SCIP feasibility tolerance for NLP solves if resolving when NLP solution not feasible in CIP
Range: [0, 1]
0.1
heuristics/subnlp/forbidfixings whether to add constraints that forbid specific fixings that turned out to be infeasible
Range: boolean
0
heuristics/subnlp/freq frequency for calling primal heuristic <subnlp> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822}
1
heuristics/subnlp/freqofs frequency offset for calling primal heuristic <subnlp>
Range: {0, ..., 1073741822}
0
heuristics/subnlp/iterinit number of iterations used for initial NLP solves
Range: {0, ..., ∞}
300
heuristics/subnlp/itermin minimal number of iterations for NLP solves
Range: {0, ..., ∞}
20
heuristics/subnlp/maxpresolverounds limit on number of presolve rounds in sub-SCIP (-1 for unlimited, 0 for no presolve)
Range: {-1, ..., ∞}
-1
heuristics/subnlp/ninitsolves number of successful NLP solves until switching to iterlimit guess and using success rate
Range: {0, ..., ∞}
2
heuristics/subnlp/nlpverblevel verbosity level of NLP solver
Range: {0, ..., 65535}
0
heuristics/subnlp/nodesfactor factor on number of nodes in SCIP (plus nodesoffset) to compute itercontingent (higher value runs heuristics more frequently)
Range: [0, ∞]
0.3
heuristics/subnlp/nodesoffset number of nodes added to the current number of nodes when computing itercontingent (higher value runs heuristic more often in early search)
Range: {0, ..., ∞}
1600
heuristics/subnlp/presolveemphasis presolve emphasis in sub-SCIP (0: default, 1: aggressive, 2: fast, 3: off)
Range: {0, ..., 3}
2
heuristics/subnlp/setcutoff whether to set cutoff in sub-SCIP to current primal bound
Range: boolean
1
heuristics/subnlp/successrateexp exponent for power of success rate to be multiplied with itercontingent (lower value decreases impact of success rate)
Range: [0, ∞]
1
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, ..., 1073741822}
-1
heuristics/subnlp/opttol absolute optimality tolerance to use for NLP solves
Range: [0, 1]
1e-07
heuristics/subnlp/priority priority of heuristic <subnlp>
Range: {-536870912, ..., 536870911}
-2000010

heuristics/trivial

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

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, ..., 1073741822}
-1
heuristics/trustregion/freqofs frequency offset for calling primal heuristic <trustregion>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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}
-1102010
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, ..., 1073741822}
1
heuristics/trysol/freqofs frequency offset for calling primal heuristic <trysol>
Range: {0, ..., 1073741822}
0
Options for expert users
heuristics/trysol/maxdepth maximal depth level to call primal heuristic <trysol> (-1: no limit)
Range: {-1, ..., 1073741822}
-1
heuristics/trysol/priority priority of heuristic <trysol>
Range: {-536870912, ..., 536870911}
-3000010

heuristics/twoopt

Option Description Default
heuristics/twoopt/freq frequency for calling primal heuristic <twoopt> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822}
-1
heuristics/twoopt/freqofs frequency offset for calling primal heuristic <twoopt>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
0
heuristics/undercover/freqofs frequency offset for calling primal heuristic <undercover>
Range: {0, ..., 1073741822}
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/coverand should and constraints be covered (or just copied)?
Range: boolean
1
heuristics/undercover/coverbd should bounddisjunction constraints be covered (or just copied)?
Range: boolean
0
heuristics/undercover/coverind should indicator 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/covernl should nonlinear constraints be covered (or just copied)?
Range: boolean
1
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 (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, ..., 1073741822}
-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, ..., 1073741822}
0
heuristics/vbounds/freqofs frequency offset for calling primal heuristic <vbounds>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
10
heuristics/veclendiving/freqofs frequency offset for calling primal heuristic <veclendiving>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
-1
heuristics/zeroobj/freqofs frequency offset for calling primal heuristic <zeroobj>
Range: {0, ..., 1073741822}
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, ..., 1073741822}
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, ..., 1073741822}
1
heuristics/zirounding/freqofs frequency offset for calling primal heuristic <zirounding>
Range: {0, ..., 1073741822}
0
Options for expert users
heuristics/zirounding/maxdepth maximal depth level to call primal heuristic <zirounding> (-1: no limit)
Range: {-1, ..., 1073741822}
-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/dual solving stops, if dual bound is at least as good as given value
Range: real
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/primal solving stops, if primal bound is at least as good as given value (alias objectivestop)
Range: real
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; this limit is first checked in presolving (-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, ..., 1073741822}
-1
lp/solvefreq frequency for solving LP at the nodes (-1: never; 0: only root LP)
Range: {-1, ..., 1073741822}
1
lp/solver LP solver to use (clp, cplex, highs, 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/avoidmemout try to avoid running into memory limit by restricting plugins like heuristics?
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/showdivingstats should detailed statistics for diving heuristics be shown?
Range: boolean
0
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: constraint-based (orbitopes and/or symresacks); 2: orbital fixing; 3: orbitopes and orbital fixing; 4: Schreier Sims cuts; 5: Schreier Sims cuts and orbitopes; 6: Schreier Sims cuts and orbital fixing; 7: Schreier Sims cuts, orbitopes, and orbital fixing)
Range: {0, ..., 7}
7
misc/usevartable should a hashtable be used to map from variable names to variables?
Range: boolean
1

nlhdlr/bilinear

Option Description Default
nlhdlr/bilinear/enabled should this nonlinear handler be used
Range: boolean
1
nlhdlr/bilinear/maxsepadepth maximum depth to apply separation
Range: {0, ..., ∞}
nlhdlr/bilinear/maxseparounds maximum number of separation rounds in a local node
Range: {0, ..., ∞}
1
nlhdlr/bilinear/maxseparoundsroot maximum number of separation rounds in the root node
Range: {0, ..., ∞}
10
nlhdlr/bilinear/useinteval whether to use the interval evaluation callback of the nlhdlr
Range: boolean
1
nlhdlr/bilinear/usereverseprop whether to use the reverse propagation callback of the nlhdlr
Range: boolean
1

nlhdlr/concave

Option Description Default
nlhdlr/concave/detectsum whether to run convexity detection when the root of an expression is a sum
Range: boolean
0
nlhdlr/concave/enabled should this nonlinear handler be used
Range: boolean
1
Options for expert users
nlhdlr/concave/cvxprodcomp whether to use convexity check on product composition f(h)*h
Range: boolean
1
nlhdlr/concave/cvxquadratic whether to use convexity check on quadratics
Range: boolean
0
nlhdlr/concave/cvxsignomial whether to use convexity check on signomials
Range: boolean
1
nlhdlr/concave/handletrivial whether to also handle trivial convex expressions
Range: boolean
0

nlhdlr/convex

Option Description Default
nlhdlr/convex/detectsum whether to run convexity detection when the root of an expression is a non-quadratic sum
Range: boolean
0
nlhdlr/convex/enabled should this nonlinear handler be used
Range: boolean
1
nlhdlr/convex/extendedform whether to create extended formulations instead of looking for maximal convex expressions
Range: boolean
1
nlhdlr/convex/maxperturb maximal relative perturbation of non-differentiable reference point
Range: [0, 1]
0.01
Options for expert users
nlhdlr/convex/cvxprodcomp whether to use convexity check on product composition f(h)*h
Range: boolean
1
nlhdlr/convex/cvxquadratic whether to use convexity check on quadratics
Range: boolean
1
nlhdlr/convex/cvxsignomial whether to use convexity check on signomials
Range: boolean
1
nlhdlr/convex/handletrivial whether to also handle trivial convex expressions
Range: boolean
0

nlhdlr/default

Option Description Default
nlhdlr/default/enabled should this nonlinear handler be used
Range: boolean
1

nlhdlr/perspective

Option Description Default
nlhdlr/perspective/adjrefpoint whether to adjust the reference point
Range: boolean
1
nlhdlr/perspective/convexonly whether perspective cuts are added only for convex expressions
Range: boolean
0
nlhdlr/perspective/enabled should this nonlinear handler be used
Range: boolean
1
nlhdlr/perspective/maxproprounds maximal number of propagation rounds in probing
Range: {-1, ..., ∞}
1
nlhdlr/perspective/mindomreduction minimal relative reduction in a variable's domain for applying probing
Range: [0, 1]
0.1
nlhdlr/perspective/minviolprobing minimal violation w.r.t. auxiliary variables for applying probing
Range: [0, ∞]
1e-05
nlhdlr/perspective/probingfreq probing frequency (-1 - no probing, 0 - root node only)
Range: {-1, ..., ∞}
1
nlhdlr/perspective/probingonlyinsepa whether to do probing only in separation
Range: boolean
1
nlhdlr/perspective/tightenbounds whether variable semicontinuity is used to tighten variable bounds
Range: boolean
1

nlhdlr/quadratic

Option Description Default
nlhdlr/quadratic/atwhichnodes determines at which nodes cut is used (if it's -1, it's used only at the root node, if it's n ≥ 0, it's used at every multiple of n
Range: {-1, ..., ∞}
1
nlhdlr/quadratic/enabled should this nonlinear handler be used
Range: boolean
1
nlhdlr/quadratic/ignorebadrayrestriction should cut be generated even with bad numerics when restricting to ray?
Range: boolean
1
nlhdlr/quadratic/ignorenhighre should cut be added even when range / efficacy is large?
Range: boolean
1
nlhdlr/quadratic/maxrank maximal rank a slackvar can have
Range: {0, ..., ∞}
nlhdlr/quadratic/mincutviolation minimal cut violation the generated cuts must fulfill to be added to the LP
Range: [0, ∞]
0.0001
nlhdlr/quadratic/minviolation minimal violation the constraint must fulfill such that a cut is generated
Range: [0, ∞]
0.0001
nlhdlr/quadratic/ncutslimit limit for number of cuts generated consecutively
Range: {0, ..., ∞}
2
nlhdlr/quadratic/ncutslimitroot limit for number of cuts generated at root node
Range: {0, ..., ∞}
20
nlhdlr/quadratic/nstrengthlimit limit for number of rays we do the strengthening for
Range: {0, ..., ∞}
nlhdlr/quadratic/sparsifycuts should we try to sparisfy the intersection cut?
Range: boolean
0
nlhdlr/quadratic/trackmore for monoidal strengthening, should we track more statistics (more expensive)?
Range: boolean
0
nlhdlr/quadratic/useboundsasrays use bounds of variables in quadratic as rays for intersection cuts
Range: boolean
0
nlhdlr/quadratic/useintersectioncuts whether to use intersection cuts for quadratic constraints to separate
Range: boolean
0
nlhdlr/quadratic/useminrep whether the minimal representation of the S-free set should be used (instead of the gauge)
Range: boolean
1
nlhdlr/quadratic/usemonoidal whether monoidal strengthening should be used
Range: boolean
1
nlhdlr/quadratic/usestrengthening whether the strengthening should be used
Range: boolean
0

nlhdlr/quotient

Option Description Default
nlhdlr/quotient/enabled should this nonlinear handler be used
Range: boolean
1

nlhdlr/signomial

Option Description Default
nlhdlr/signomial/enabled should this nonlinear handler be used
Range: boolean
1
Options for expert users
nlhdlr/signomial/maxnundervars maximum number of variables when underestimating a concave power function
Range: {2, ..., 14}
14
nlhdlr/signomial/mincutscale minimum scale factor when scaling a cut
Range: [1e-06, 1e+06]
1e-05

nlhdlr/soc

Option Description Default
nlhdlr/soc/compeigenvalues Should Eigenvalue computations be done to detect complex cases in quadratic constraints?
Range: boolean
1
nlhdlr/soc/enabled should this nonlinear handler be used
Range: boolean
1
nlhdlr/soc/mincutefficacy Minimum efficacy which a cut needs in order to be added.
Range: [0, ∞]
1e-05

nlp

Option Description Default
nlp/disable should the NLP relaxation be always disabled (also for NLPs/MINLPs)?
Range: boolean
0

nlpi/ipopt

Option Description Default
nlpi/ipopt/hessian_approximation Indicates what Hessian information is to be used. Valid values if not empty: exact limited-memory
Range: string
nlpi/ipopt/hsllib Name of library containing HSL routines for load at runtime
Range: string
nlpi/ipopt/linear_solver Linear solver used for step computations. Valid values if not empty: ma27 ma57 ma77 ma86 ma97 pardiso pardisomkl mumps custom
Range: string
ma27, if IpoptH licensed, mumps otherwise
nlpi/ipopt/linear_system_scaling Method for scaling the linear system. Valid values if not empty: none mc19 slack-based
Range: string
mc19, if IpoptH licensed, empty otherwise
nlpi/ipopt/mu_strategy Update strategy for barrier parameter. Valid values if not empty: monotone adaptive
Range: string
nlpi/ipopt/nlp_scaling_method Select the technique used for scaling the NLP. Valid values if not empty: none user-scaling gradient-based equilibration-based
Range: string
nlpi/ipopt/optfile name of Ipopt options file
Range: string
nlpi/ipopt/pardisolib Name of library containing Pardiso routines (from pardiso-project.org) for load at runtime
Range: string
nlpi/ipopt/print_level Output verbosity level. -1 to use NLPI or Ipopt default.
Range: {-1, ..., 12}
-1
nlpi/ipopt/priority priority of NLPI <ipopt>
Range: {-536870912, ..., 536870911}
1000
nlpi/ipopt/warm_start_push amount (relative and absolute) by which starting point is moved away from bounds in warmstarts
Range: [0, 1]
1e-09

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/maxbadgesizepar maximal badge size in Probing in PaPILO if PaPILO is executed in parallel mode
Range: {-1, ..., ∞}
-1
presolving/milp/maxbadgesizeseq maximal badge size in Probing in PaPILO if PaPILO is executed in sequential mode
Range: {-1, ..., ∞}
15000
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
presolving/milp/verbosity verbosity level of PaPILO (0: quiet, 1: errors, 2: warnings, 3: normal, 4: detailed)
Range: {0, ..., 4}
0
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/internalmaxrounds internal maxrounds for each milp presolving (-1: no limit, 0: model cleanup)
Range: {-1, ..., ∞}
-1
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/probfilename filename to store the problem before MILP presolving starts (only enforced constraints)
Range: string
-
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, ..., ∞}
0
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, ..., 1073741822}
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, ..., 1073741822}
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, ..., 1073741822}
-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, ..., 1073741822}
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/createlincons create linear constraints from inequalities for bilinear terms?
Range: boolean
0
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/indicators apply obbt on variables of indicator constraints? (independent of convexity)
Range: boolean
0
propagating/obbt/indicatorthreshold threshold whether upper bounds of vars of indicator conss are considered or tightened
Range: [0, ∞]
1e+06
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
1
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, ..., 1073741822}
-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, ..., 1073741822}
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, ..., 1073741822}
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: {