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, 4, 20, 21, 74, 128, 88, 89, 75, 22, 192, 193, 205] and the SCIP web site.

GAMS/SCIP uses CPLEX, if licensed, and otherwise SOPLEX [207] as LP solver, the COIN-OR Interior Point Optimizer IPOPT [197] 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 [128] 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
distribution	0	-1	100	branching rule based on variable influence on cumulative normal distribution of row activities
fullstrong	0	-1	100	full strong branching
cloud	0	-1	100	branching rule that considers several alternative LP optima
lookahead	0	-1	100	full strong branching over multiple levels
multaggr	0	-1	100	fullstrong branching on fractional and multi-aggregated variables
allfullstrong	-1000	-1	100	all variables full strong branching
vanillafullstrong	-2000	-1	100	vanilla full strong branching
random	-100000	-1	100	random variable branching
nodereopt	-9000000	-1	100	branching rule for node reoptimization

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

Conflict Handler

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

Constraint Handler

constraint handler	checkprio	enfoprio	sepaprio	sepafreq	propfreq	eagerfreq	presolvetimings	description
integral	0	0	0	-1	-1	-1	always	integrality constraint
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	-60	10	1	1	100	always	handler for nonlinear constraints specified by algebraic expressions
indicator	-6000000	-100	10	10	1	100	fast	indicator constraint handler
components	-9999999	0	0	-1	1	-1		independent components constraint handler

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

Display Columns

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

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

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
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
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
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
rlt	10	0	1	reformulation-linearization-technique separator
disjunctive	10d	0	0	disjunctive cut separator
gauge	0	-1	1	gauge separator
interminor	0	-1	1	intersection cuts separator to ensure that 2x2 minors of X (= xx') have determinant 0
convexproj	0d	-1	1	separate at projection of point onto convex region
minor	0	10	1	separator to ensure that 2x2 principal minors of X - xx' are positive semi-definite
impliedbounds	-50	10	1	implied bounds separator
mixing	-50	10	1	mixing inequality 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
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
strongcg	-100000	10	0	separator for strong CG cuts
gomorymi	-100000	10	0	separator for Gomory mixed-integer cuts
knapsackcover	-100000	10	0	separator for knapsack cover cuts
flowcover	-100000	10	0	separator for flowcover cuts
cmir	-100000	10	0	separator for cmir cuts
rapidlearning	-1200000	5	1	rapid learning heuristic and separator

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

List of SCIP Options

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

gams

Option	Description	Default
gams/dumpsolutions	name of solutions index gdx file for writing all alternate solutions Range: string
gams/dumpsolutionsmerged	name of gdx file for writing all alternate solutions into a single file Range: string
gams/indicatorfile	name of GAMS options file that contains definitions on indicators Range: string
gams/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, ..., 65534}	-1
branching/allfullstrong/priority	priority of branching rule <allfullstrong> Range: {-536870912, ..., 536870911}	-1000

branching/cloud

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

branching/distribution

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

branching/fullstrong

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

branching/inference

Option	Description	Default
branching/inference/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, ..., 65534}	-1
branching/inference/priority	priority of branching rule <inference> Range: {-536870912, ..., 536870911}	1000
branching/inference/useweightedsum	should a weighted sum of inference, conflict and cutoff weights be used? Range: boolean	1
Options for expert users
branching/inference/conflictweight	weight in score calculations for conflict score Range: [0, ∞]	1000
branching/inference/cutoffweight	weight in score calculations for cutoff score Range: [0, ∞]	1
branching/inference/fractionals	should branching on LP solution be restricted to the fractional variables? Range: boolean	1
branching/inference/inferenceweight	weight in score calculations for inference score Range: real	1
branching/inference/reliablescore	weight in score calculations for conflict score Range: [0, ∞]	0.001

branching/leastinf

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

branching/lookahead

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

branching/mostinf

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

branching/multaggr

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

branching/nodereopt

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

branching/pscost

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

branching/random

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

branching/relpscost

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

branching/treemodel

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

branching/vanillafullstrong

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

conflict

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

conflict/bounddisjunction

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

conflict/graph

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

conflict/indicatorconflict

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

conflict/linear

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

conflict/logicor

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

conflict/setppc

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

constraints

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

constraints/SOS1

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

constraints/SOS2

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

constraints/and

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

constraints/bounddisjunction

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

constraints/components

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

constraints/indicator

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

constraints/integral

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

constraints/knapsack

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

constraints/linear

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

constraints/linear/upgrade

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

constraints/logicor

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

constraints/nonlinear

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

constraints/orbitope

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

constraints/setppc

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

constraints/symresack

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

constraints/varbound

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

constraints/xor

Option	Description	Default
constraints/xor/propfreq	frequency for propagating domains (-1: never, 0: only in root node) Range: {-1, ..., 65534}	1
constraints/xor/sepafreq	frequency for separating cuts (-1: never, 0: only in root node) Range: {-1, ..., 65534}	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, ..., 65534}	100
constraints/xor/gausspropfreq	frequency for applying the Gauss propagator Range: {-1, ..., 65534}	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/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/minzerodistance	minimal distance from zero to enforce for child in bound tightening Range: [0, 1]	1e-09

heuristics

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

heuristics/actconsdiving

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

heuristics/adaptivediving

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

heuristics/alns

Option	Description	Default
heuristics/alns/freq	frequency for calling primal heuristic <alns> (-1: never, 0: only at depth freqofs) Range: {-1, ..., 65534}	20
heuristics/alns/freqofs	frequency offset for calling primal heuristic <alns> Range: {0, ..., 65534}	0
heuristics/alns/nodesofs	offset added to the nodes budget Range: {0, ..., ∞}	500
heuristics/alns/nodesquot	fraction of nodes compared to the main SCIP for budget computation Range: [0, 1]	0.1
heuristics/alns/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 Range: u, e, g	u
heuristics/alns/beta	reward offset between 0 and 1 at every observation for Exp.3 Range: [0, 1]	0
heuristics/alns/copycuts	should cutting planes be copied to the sub-SCIP? Range: boolean	0
heuristics/alns/domorefixings	should the ALNS heuristic do more fixings by itself based on variable prioritization until the target fixing rate is reached? Range: boolean	1
heuristics/alns/eps	increase exploration in epsilon-greedy bandit algorithm Range: [0, 1]	0.468584
heuristics/alns/fixtol	tolerance by which the fixing rate may be missed without generic fixing Range: [0, 1]	0.1
heuristics/alns/gamma	weight between uniform (gamma ~ 1) and weight driven (gamma ~ 0) probability distribution for exp3 Range: [0, 1]	0.0704146
heuristics/alns/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, ..., 65534}	-1
heuristics/alns/maxnodes	maximum number of nodes to regard in the subproblem Range: {0, ..., ∞}	5000
heuristics/alns/minimprovehigh	upper bound for the minimal improvement over the incumbent Range: [0, 1]	0.01
heuristics/alns/minimprovelow	lower threshold for the minimal improvement over the incumbent Range: [0, 1]	0.01
heuristics/alns/minnodes	minimum number of nodes required to start a sub-SCIP Range: {0, ..., ∞}	50
heuristics/alns/priority	priority of heuristic <alns> Range: {-536870912, ..., 536870911}	-1100500
heuristics/alns/resetweights	should the bandit algorithms be reset when a new problem is read? Range: boolean	1
heuristics/alns/rewardbaseline	the reward baseline to separate successful and failed calls Range: [0, 0.99]	0.5
heuristics/alns/rewardcontrol	reward control to increase the weight of the simple solution indicator and decrease the weight of the closed gap reward Range: [0, 1]	0.8
heuristics/alns/rewardfilename	file name to store all rewards and the selection of the bandit Range: string	-
heuristics/alns/scalebyeffort	should the reward be scaled by the effort? Range: boolean	1
heuristics/alns/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, ..., 65534}	-1
heuristics/bound/freqofs	frequency offset for calling primal heuristic <bound> Range: {0, ..., 65534}	0
Options for expert users
heuristics/bound/maxdepth	maximal depth level to call primal heuristic <bound> (-1: no limit) Range: {-1, ..., 65534}	-1
heuristics/bound/maxproprounds	maximum number of propagation rounds during probing (-1 infinity, -2 parameter settings) Range: {-1, ..., 536870911}	0
heuristics/bound/onlywithoutsol	Should heuristic only be executed if no primal solution was found, yet? Range: boolean	1
heuristics/bound/priority	priority of heuristic <bound> Range: {-536870912, ..., 536870911}	-1107000

heuristics/clique

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

heuristics/coefdiving

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

heuristics/completesol

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

heuristics/conflictdiving

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

heuristics/crossover

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

heuristics/dins

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

heuristics/distributiondiving

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

heuristics/dps

Option	Description	Default
heuristics/dps/freq	frequency for calling primal heuristic <dps> (-1: never, 0: only at depth freqofs) Range: {-1, ..., 65534}	-1
heuristics/dps/freqofs	frequency offset for calling primal heuristic <dps> Range: {0, ..., 65534}	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/reuse	should solutions get reused in subproblems? Range: boolean	0
Options for expert users
heuristics/dps/maxdepth	maximal depth level to call primal heuristic <dps> (-1: no limit) Range: {-1, ..., 65534}	-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, ..., 65534}	-1
heuristics/dualval/freqofs	frequency offset for calling primal heuristic <dualval> Range: {0, ..., 65534}	0
heuristics/dualval/heurverblevel	verblevel of the heuristic, default is 0 to display nothing Range: {0, ..., 4}	0
heuristics/dualval/lambdaobj	scaling factor for the objective function Range: [0, 1]	0
heuristics/dualval/lambdaslack	value added to objective of slack variables, must not be zero Range: [0.1, ∞]	1
heuristics/dualval/maxcalls	maximal number of recursive calls of the heuristic (if dynamicdepth is off) Range: {0, ..., ∞}	25
heuristics/dualval/maxequalranks	maximal number of variables that may have maximal rank, quit if there are more, turn off by setting -1 Range: {-1, ..., ∞}	50
heuristics/dualval/mingap	minimal gap for which we still run the heuristic, if gap is less we return without doing anything Range: [0, 100]	5
heuristics/dualval/nlpverblevel	verblevel of the nlp solver, can be 0 or 1 Range: {0, ..., 1}	0
heuristics/dualval/onlyleaves	disable the heuristic if it was not called at a leaf of the B&B tree Range: boolean	0
heuristics/dualval/rankvalue	number of ranks that should be displayed when the heuristic is called Range: {0, ..., ∞}	10
heuristics/dualval/relaxcontvars	relax the continous variables Range: boolean	0
heuristics/dualval/relaxindicators	relax the indicator variables by introducing continuous copies Range: boolean	0
Options for expert users
heuristics/dualval/forceimprovements	exit if objective doesn't improve Range: boolean	0
heuristics/dualval/maxdepth	maximal depth level to call primal heuristic <dualval> (-1: no limit) Range: {-1, ..., 65534}	-1
heuristics/dualval/onlycheaper	add constraint to ensure that discrete vars are improving Range: boolean	1
heuristics/dualval/priority	priority of heuristic <dualval> Range: {-536870912, ..., 536870911}	-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, ..., 65534}	10
heuristics/farkasdiving/freqofs	frequency offset for calling primal heuristic <farkasdiving> Range: {0, ..., 65534}	0
heuristics/farkasdiving/lpresolvedomchgquot	percentage of immediate domain changes during probing to trigger LP resolve Range: [0, ∞]	0.15
heuristics/farkasdiving/lpsolvefreq	LP solve frequency for diving heuristics (0: only after enough domain changes have been found) Range: {0, ..., ∞}	1
heuristics/farkasdiving/maxlpiterofs	additional number of allowed LP iterations Range: {0, ..., ∞}	1000
heuristics/farkasdiving/maxlpiterquot	maximal fraction of diving LP iterations compared to node LP iterations Range: [0, ∞]	0.05
heuristics/farkasdiving/onlylpbranchcands	should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection? Range: boolean	0
Options for expert users
heuristics/farkasdiving/checkcands	should diving candidates be checked before running? Range: boolean	0
heuristics/farkasdiving/maxdepth	maximal depth level to call primal heuristic <farkasdiving> (-1: no limit) Range: {-1, ..., 65534}	-1
heuristics/farkasdiving/maxdiveavgquot	maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit) Range: [0, ∞]	0
heuristics/farkasdiving/maxdiveavgquotnosol	maximal AVGQUOT when no solution was found yet (0.0: no limit) Range: [0, ∞]	0
heuristics/farkasdiving/maxdiveubquot	maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit) Range: [0, 1]	0.8
heuristics/farkasdiving/maxdiveubquotnosol	maximal UBQUOT when no solution was found yet (0.0: no limit) Range: [0, 1]	0.1
heuristics/farkasdiving/maxobjocc	maximal occurance factor of an objective coefficient Range: [0, 1]	1
heuristics/farkasdiving/maxreldepth	maximal relative depth to start diving Range: [0, 1]	1
heuristics/farkasdiving/minreldepth	minimal relative depth to start diving Range: [0, 1]	0
heuristics/farkasdiving/objdynamism	minimal objective dynamism (log) to run Range: [0, ∞]	0.0001
heuristics/farkasdiving/priority	priority of heuristic <farkasdiving> Range: {-536870912, ..., 536870911}	-900000
heuristics/farkasdiving/rootsuccess	should the heuristic only run within the tree if at least one solution was found at the root node? Range: boolean	1
heuristics/farkasdiving/scalescore	should the score be scaled? Range: boolean	1
heuristics/farkasdiving/scaletype	scale score by [f]ractionality or [i]mpact on farkasproof Range: f, i	i

heuristics/feaspump

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

heuristics/fixandinfer

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

heuristics/fracdiving

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

heuristics/gins

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

heuristics/guideddiving

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

heuristics/indicator

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

heuristics/intdiving

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

heuristics/intshifting

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

heuristics/linesearchdiving

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

heuristics/localbranching

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

heuristics/locks

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

heuristics/lpface

Option	Description	Default
heuristics/lpface/freq	frequency for calling primal heuristic <lpface> (-1: never, 0: only at depth freqofs) Range: {-1, ..., 65534}	15
heuristics/lpface/freqofs	frequency offset for calling primal heuristic <lpface> Range: {0, ..., 65534}	0
heuristics/lpface/minfixingrate	required percentage of fixed integer variables in sub-MIP to run Range: [0, 1]	0.1
heuristics/lpface/nodesofs	number of nodes added to the contingent of the total nodes Range: {0, ..., ∞}	200
heuristics/lpface/nodesquot	contingent of sub problem nodes in relation to the number of nodes of the original problem Range: [0, 1]	0.1
Options for expert users
heuristics/lpface/copycuts	if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem? Range: boolean	1
heuristics/lpface/dualbasisequations	should dually nonbasic rows be turned into equations? Range: boolean	0
heuristics/lpface/keepsubscip	should the heuristic continue solving the same sub-SCIP? Range: boolean	0
heuristics/lpface/lplimfac	factor by which the limit on the number of LP depends on the node limit Range: [1, ∞]	2
heuristics/lpface/maxdepth	maximal depth level to call primal heuristic <lpface> (-1: no limit) Range: {-1, ..., 65534}	-1
heuristics/lpface/maxnodes	maximum number of nodes to regard in the subproblem Range: {0, ..., ∞}	5000
heuristics/lpface/minnodes	minimum number of nodes required to start the subproblem Range: {0, ..., ∞}	50
heuristics/lpface/minpathlen	the minimum active search tree path length along which lower bound hasn't changed before heuristic becomes active Range: {0, ..., 65531}	5
heuristics/lpface/priority	priority of heuristic <lpface> Range: {-536870912, ..., 536870911}	-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, ..., 65534}	50
heuristics/mpec/freqofs	frequency offset for calling primal heuristic <mpec> Range: {0, ..., 65534}	0
heuristics/mpec/inittheta	initial regularization right-hand side value Range: [0, 0.25]	0.125
heuristics/mpec/maxiter	maximum number of iterations of the MPEC loop Range: {0, ..., ∞}	100
heuristics/mpec/maxnlpcost	maximum cost available for solving NLPs per call of the heuristic Range: [0, ∞]	1e+08
heuristics/mpec/maxnlpiter	maximum number of NLP iterations per solve Range: {0, ..., ∞}	500
heuristics/mpec/maxnunsucc	maximum number of consecutive calls for which the heuristic did not find an improving solution Range: {0, ..., ∞}	10
heuristics/mpec/mingapleft	minimum amount of gap left in order to call the heuristic Range: [0, ∞]	0.05
heuristics/mpec/minimprove	factor by which heuristic should at least improve the incumbent Range: [0, 1]	0.01
heuristics/mpec/sigma	regularization update factor Range: [0, 1]	0.5
heuristics/mpec/subnlptrigger	maximum number of NLP iterations per solve Range: [0, 1]	0.001
Options for expert users
heuristics/mpec/maxdepth	maximal depth level to call primal heuristic <mpec> (-1: no limit) Range: {-1, ..., 65534}	-1
heuristics/mpec/priority	priority of heuristic <mpec> Range: {-536870912, ..., 536870911}	-2050000

heuristics/multistart

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

heuristics/mutation

Option	Description	Default
heuristics/mutation/bestsollimit	limit on number of improving incumbent solutions in sub-CIP Range: {-1, ..., ∞}	-1
heuristics/mutation/freq	frequency for calling primal heuristic <mutation> (-1: never, 0: only at depth freqofs) Range: {-1, ..., 65534}	-1
heuristics/mutation/freqofs	frequency offset for calling primal heuristic <mutation> Range: {0, ..., 65534}	8
heuristics/mutation/minfixingrate	percentage of integer variables that have to be fixed Range: [1e-06, 0.999999]	0.8
heuristics/mutation/nodesofs	number of nodes added to the contingent of the total nodes Range: {0, ..., ∞}	500
heuristics/mutation/nodesquot	contingent of sub problem nodes in relation to the number of nodes of the original problem Range: [0, 1]	0.1
Options for expert users
heuristics/mutation/copycuts	if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem? Range: boolean	1
heuristics/mutation/maxdepth	maximal depth level to call primal heuristic <mutation> (-1: no limit) Range: {-1, ..., 65534}	-1
heuristics/mutation/maxnodes	maximum number of nodes to regard in the subproblem Range: {0, ..., ∞}	5000
heuristics/mutation/minimprove	factor by which mutation should at least improve the incumbent Range: [0, 1]	0.01
heuristics/mutation/minnodes	minimum number of nodes required to start the subproblem Range: {0, ..., ∞}	500
heuristics/mutation/nwaitingnodes	number of nodes without incumbent change that heuristic should wait Range: {0, ..., ∞}	200
heuristics/mutation/priority	priority of heuristic <mutation> Range: {-536870912, ..., 536870911}	-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, ..., 65534}	10
heuristics/nlpdiving/freqofs	frequency offset for calling primal heuristic <nlpdiving> Range: {0, ..., 65534}	3
heuristics/nlpdiving/maxfeasnlps	maximal number of NLPs with feasible solution to solve during one dive Range: {1, ..., ∞}	10
heuristics/nlpdiving/maxnlpiterabs	minimial absolute number of allowed NLP iterations Range: {0, ..., ∞}	200
heuristics/nlpdiving/maxnlpiterrel	additional allowed number of NLP iterations relative to successfully found solutions Range: {0, ..., ∞}	10
heuristics/nlpdiving/minsuccquot	heuristic will not run if less then this percentage of calls succeeded (0.0: no limit) Range: [0, 1]	0.1
heuristics/nlpdiving/nlpfastfail	should the NLP solver stop early if it converges slow? Range: boolean	1
heuristics/nlpdiving/prefercover	should variables in a minimal cover be preferred? Range: boolean	1
heuristics/nlpdiving/solvesubmip	should a sub-MIP be solved if all cover variables are fixed? Range: boolean	0
heuristics/nlpdiving/varselrule	which variable selection should be used? ('f'ractionality, 'c'oefficient, 'p'seudocost, 'g'uided, 'd'ouble, 'v'eclen) Range: f, c, p, g, d, v	d
Options for expert users
heuristics/nlpdiving/lp	should the LP relaxation be solved before the NLP relaxation? Range: boolean	0
heuristics/nlpdiving/maxdepth	maximal depth level to call primal heuristic <nlpdiving> (-1: no limit) Range: {-1, ..., 65534}	-1
heuristics/nlpdiving/maxdiveavgquot	maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit) Range: [0, ∞]	0
heuristics/nlpdiving/maxdiveavgquotnosol	maximal AVGQUOT when no solution was found yet (0.0: no limit) Range: [0, ∞]	0
heuristics/nlpdiving/maxdiveubquot	maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit) Range: [0, 1]	0.8
heuristics/nlpdiving/maxdiveubquotnosol	maximal UBQUOT when no solution was found yet (0.0: no limit) Range: [0, 1]	0.1
heuristics/nlpdiving/maxreldepth	maximal relative depth to start diving Range: [0, 1]	1
heuristics/nlpdiving/minreldepth	minimal relative depth to start diving Range: [0, 1]	0
heuristics/nlpdiving/nlpstart	which point should be used as starting point for the NLP solver? ('n'one, last 'f'easible, from dive's'tart) Range: f, n, s	s
heuristics/nlpdiving/preferlpfracs	prefer variables that are also fractional in LP solution? Range: boolean	0
heuristics/nlpdiving/priority	priority of heuristic <nlpdiving> Range: {-536870912, ..., 536870911}	-1003010

heuristics/objpscostdiving

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

heuristics/octane

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

heuristics/ofins

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

heuristics/oneopt

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

heuristics/padm

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

heuristics/pscostdiving

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

heuristics/randrounding

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

heuristics/rens

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

heuristics/reoptsols

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

heuristics/repair

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

heuristics/rins

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

heuristics/rootsoldiving

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

heuristics/rounding

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

heuristics/shiftandpropagate

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

heuristics/shifting

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

heuristics/simplerounding

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

heuristics/trivialnegation

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

heuristics/twoopt

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

heuristics/undercover

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

heuristics/vbounds

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

heuristics/veclendiving

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

heuristics/zeroobj

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

heuristics/zirounding

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

history

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

limits

Option	Description	Default
limits/absgap	solving stops, if the absolute gap = |primalbound - dualbound| is below the given value Range: [0, ∞]	GAMS optca
limits/autorestartnodes	if solve exceeds this number of nodes for the first time, an automatic restart is triggered (-1: no automatic restart) Range: {-1, ..., ∞}	-1
limits/bestsol	solving stops, if the given number of solution improvements were found (-1: no limit) Range: {-1, ..., ∞}	-1
limits/gap	solving stops, if the relative gap = |primal - dual|/MIN(|dual|,|primal|) is below the given value, the gap is 'Infinity', if primal and dual bound have opposite signs Range: [0, ∞]	GAMS optcr
limits/maxorigsol	maximal number of solutions candidates to store in the solution storage of the original problem Range: {0, ..., ∞}	10
limits/maxsol	maximal number of solutions to store in the solution storage Range: {1, ..., ∞}	100
limits/memory	maximal memory usage in MB; reported memory usage is lower than real memory usage! Range: [0, 8.79609e+12]	GAMS workspace
limits/nodes	maximal number of nodes to process (-1: no limit) Range: {-1, ..., ∞}	GAMS nodlim, if > 0, otherwise -1
limits/restarts	solving stops, if the given number of restarts was triggered (-1: no limit) Range: {-1, ..., ∞}	-1
limits/softtime	soft time limit which should be applied after first solution was found (-1.0: disabled) Range: [-1, ∞]	-1
limits/solutions	solving stops, if the given number of solutions were found; 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, ..., 65534}	-1
lp/solvefreq	frequency for solving LP at the nodes (-1: never; 0: only root LP) Range: {-1, ..., 65534}	1
lp/solver	LP solver to use (clp, cplex, soplex) Range: string	cplex, if licensed, otherwise soplex
Options for expert users
lp/checkdualfeas	should LP solutions be checked for dual feasibility, resolving LP when numerical troubles occur? Range: boolean	1
lp/checkfarkas	should infeasibility proofs from the LP be checked? Range: boolean	1
lp/checkprimfeas	should LP solutions be checked for primal feasibility, resolving LP when numerical troubles occur? Range: boolean	1
lp/checkstability	should LP solver's return status be checked for stability? Range: boolean	1
lp/cleanupcols	should new non-basic columns be removed after LP solving? Range: boolean	0
lp/cleanupcolsroot	should new non-basic columns be removed after root LP solving? Range: boolean	0
lp/cleanuprows	should new basic rows be removed after LP solving? Range: boolean	1
lp/cleanuprowsroot	should new basic rows be removed after root LP solving? Range: boolean	1
lp/clearinitialprobinglp	should lp state be cleared at the end of probing mode when lp was initially unsolved, e.g., when called right after presolving? Range: boolean	1
lp/colagelimit	maximum age a dynamic column can reach before it is deleted from the LP (-1: don't delete columns due to aging) Range: {-1, ..., ∞}	10
lp/conditionlimit	maximum condition number of LP basis counted as stable (-1.0: no limit) Range: [-1, ∞]	-1
lp/disablecutoff	disable the cutoff bound in the LP solver? (0: enabled, 1: disabled, 2: auto) Range: {0, ..., 2}	2
lp/fastmip	which FASTMIP setting of LP solver should be used? 0: off, 1: low Range: {0, ..., 1}	1
lp/freesolvalbuffers	should the buffers for storing LP solution values during diving be freed at end of diving? Range: boolean	0
lp/iterlim	iteration limit for each single LP solve (-1: no limit) Range: {-1, ..., ∞}	-1
lp/lexdualalgo	should the lexicographic dual algorithm be used? Range: boolean	0
lp/lexdualbasic	choose fractional basic variables in lexicographic dual algorithm? Range: boolean	0
lp/lexdualmaxrounds	maximum number of rounds in the lexicographic dual algorithm (-1: unbounded) Range: {-1, ..., ∞}	2
lp/lexdualrootonly	should the lexicographic dual algorithm be applied only at the root node Range: boolean	1
lp/lexdualstalling	turn on the lex dual algorithm only when stalling? Range: boolean	1
lp/minmarkowitz	minimal Markowitz threshold to control sparsity/stability in LU factorization Range: [0.0001, 0.9999]	0.01
lp/presolving	should presolving of LP solver be used? Range: boolean	1
lp/refactorinterval	LP refactorization interval (0: auto) Range: {0, ..., ∞}	0
lp/resolveiterfac	factor of average LP iterations that is used as LP iteration limit for LP resolve (-1: unlimited) Range: [-1, ∞]	-1
lp/resolveitermin	minimum number of iterations that are allowed for LP resolve Range: {1, ..., ∞}	1000
lp/resolverestore	should the LP be resolved to restore the state at start of diving (if FALSE we buffer the solution values)? Range: boolean	0
lp/rootiterlim	iteration limit for initial root LP solve (-1: no limit) Range: {-1, ..., ∞}	-1
lp/rowagelimit	maximum age a dynamic row can reach before it is deleted from the LP (-1: don't delete rows due to aging) Range: {-1, ..., ∞}	10
lp/rowrepswitch	simplex algorithm shall use row representation of the basis if number of rows divided by number of columns exceeds this value (-1.0 to disable row representation) Range: [-1, ∞]	1.2
lp/scaling	LP scaling (0: none, 1: normal, 2: aggressive) Range: {0, ..., 2}	1
lp/solutionpolishing	LP solution polishing method (0: disabled, 1: only root, 2: always, 3: auto) Range: {0, ..., 3}	3
lp/threads	number of threads used for solving the LP (0: automatic) Range: {0, ..., 64}	GAMS threads

memory

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

misc

Option	Description	Default
misc/allowstrongdualreds	should strong dual reductions be allowed in propagation and presolving? Range: boolean	1
misc/allowweakdualreds	should weak dual reductions be allowed in propagation and presolving? Range: boolean	1
misc/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: polyhedral (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
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/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/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/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
Options for expert users
presolving/milp/enabledomcol	should the dominated column presolver be enabled within the presolve library? Range: boolean	1
presolving/milp/enabledualinfer	should the dualinfer presolver be enabled within the presolve library? Range: boolean	1
presolving/milp/enablemultiaggr	should the multi-aggregation presolver be enabled within the presolve library? Range: boolean	1
presolving/milp/enableparallelrows	should the parallel rows presolver be enabled within the presolve library? Range: boolean	1
presolving/milp/enableprobing	should the probing presolver be enabled within the presolve library? Range: boolean	1
presolving/milp/enablesparsify	should the sparsify presolver be enabled within the presolve library? Range: boolean	0
presolving/milp/maxshiftperrow	maximal amount of nonzeros allowed to be shifted to make space for substitutions Range: {0, ..., ∞}	10
presolving/milp/priority	priority of presolver <milp> Range: {-536870912, ..., 536870911}	9999999
presolving/milp/probfilename	filename to store the problem before MILP presolving starts 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, ..., 65534}	0
propagating/dualfix/maxprerounds	maximal number of presolving rounds the propagator participates in (-1: no limit) Range: {-1, ..., ∞}	-1
Options for expert users
propagating/dualfix/delay	should propagator be delayed, if other propagators found reductions? Range: boolean	0
propagating/dualfix/presolpriority	presolving priority of propagator <dualfix> Range: {-536870912, ..., 536870911}	8000000
propagating/dualfix/presoltiming	timing mask of the presolving method of propagator <dualfix> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) Range: {2, ..., 60}	4
propagating/dualfix/priority	priority of propagator <dualfix> Range: {-536870912, ..., 536870911}	8000000
propagating/dualfix/timingmask	timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)) Range: {1, ..., 15}	1

propagating/genvbounds

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

propagating/nlobbt

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

propagating/obbt

Option	Description	Default
propagating/obbt/boundstreps	minimal relative improve for strengthening bounds Range: [0, 1]	0.001
propagating/obbt/conditionlimit	maximum condition limit used in LP solver (-1.0: no limit) Range: [-1, ∞]	-1
propagating/obbt/dualfeastol	feasibility tolerance for reduced costs used in obbt; this value is used if SCIP's dual feastol is greater Range: [0, ∞]	1e-09
propagating/obbt/freq	frequency for calling propagator <obbt> (-1: never, 0: only in root node) Range: {-1, ..., 65534}	0
propagating/obbt/itlimitfactor	multiple of root node LP iterations used as total LP iteration limit for obbt (≤ 0: no limit ) Range: real	10
propagating/obbt/itlimitfactorbilin	multiple of OBBT LP limit used as total LP iteration limit for solving bilinear inequality LPs (< 0 for no limit) Range: real	3
propagating/obbt/maxprerounds	maximal number of presolving rounds the propagator participates in (-1: no limit) Range: {-1, ..., ∞}	-1
propagating/obbt/minitlimit	minimum LP iteration limit Range: {0, ..., ∞}	5000
propagating/obbt/minnonconvexity	minimum absolute value of nonconvex eigenvalues for a bilinear term Range: [0, ∞]	0.1
Options for expert users
propagating/obbt/applyfilterrounds	try to filter bounds in so-called filter rounds by solving auxiliary LPs? Range: boolean	0
propagating/obbt/applytrivialfilter	try to filter bounds with the LP solution after each solve? Range: boolean	1
propagating/obbt/createbilinineqs	solve auxiliary LPs in order to find valid inequalities for bilinear terms? Range: boolean	1
propagating/obbt/creategenvbounds	should obbt try to provide genvbounds if possible? Range: boolean	1
propagating/obbt/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/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, ..., 65534}	-1
propagating/probing/maxprerounds	maximal number of presolving rounds the propagator participates in (-1: no limit) Range: {-1, ..., ∞}	-1
propagating/probing/maxruns	maximal number of runs, probing participates in (-1: no limit) Range: {-1, ..., ∞}	1
Options for expert users
propagating/probing/delay	should propagator be delayed, if other propagators found reductions? Range: boolean	1
propagating/probing/maxdepth	maximal depth until propagation is executed(-1: no limit) Range: {-1, ..., ∞}	-1
propagating/probing/maxfixings	maximal number of fixings found, until probing is interrupted (0: don't iterrupt) Range: {0, ..., ∞}	25
propagating/probing/maxsumuseless	maximal number of probings without fixings, until probing is aborted (0: don't abort) Range: {0, ..., ∞}	0
propagating/probing/maxtotaluseless	maximal number of successive probings without fixings, bound changes, and implications, until probing is aborted (0: don't abort) Range: {0, ..., ∞}	50
propagating/probing/maxuseless	maximal number of successive probings without fixings, until probing is aborted (0: don't abort) Range: {0, ..., ∞}	1000
propagating/probing/presolpriority	presolving priority of propagator <probing> Range: {-536870912, ..., 536870911}	-100000
propagating/probing/presoltiming	timing mask of the presolving method of propagator <probing> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) Range: {2, ..., 60}	16
propagating/probing/priority	priority of propagator <probing> Range: {-536870912, ..., 536870911}	-100000
propagating/probing/proprounds	maximal number of propagation rounds in probing subproblems (-1: no limit, 0: auto) Range: {-1, ..., ∞}	-1
propagating/probing/timingmask	timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)) Range: {1, ..., 15}	4

propagating/pseudoobj

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

propagating/redcost

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

propagating/rootredcost

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

propagating/symmetry

Option	Description	Default
propagating/symmetry/freq	frequency for calling propagator <symmetry> (-1: never, 0: only in root node) Range: {-1, ..., 65534}	1
propagating/symmetry/maxprerounds	maximal number of presolving rounds the propagator participates in (-1: no limit) Range: {-1, ..., ∞}	-1
Options for expert users
propagating/symmetry/addconflictcuts	Should Schreier Sims constraints be added if we use a conflict based rule? Range: boolean	1
propagating/symmetry/addconsstiming	timing of adding constraints (0 = before presolving, 1 = during presolving, 2 = after presolving) Range: {0, ..., 2}	2
propagating/symmetry/addstrongsbcs	Should strong SBCs for enclosing orbit of symmetric subgroups be added if orbitopes are not used? Range: boolean	0
propagating/symmetry/addsymresacks	Add inequalities for symresacks for each generator? Range: boolean	0
propagating/symmetry/addweaksbcs	Should we add weak SBCs for enclosing orbit of symmetric subgroups? Range: boolean	1
propagating/symmetry/checksymmetries	Should all symmetries be checked after computation? Range: boolean	0
propagating/symmetry/compresssymmetries	Should non-affected variables be removed from permutation to save memory? Range: boolean	1
propagating/symmetry/compressthreshold	Compression is used if percentage of moved vars is at most the threshold. Range: [0, 1]	0.5
propagating/symmetry/conssaddlp	Should the symmetry breaking constraints be added to the LP? Range: boolean	1
propagating/symmetry/delay	should propagator be delayed, if other propagators found reductions? Range: boolean	0
propagating/symmetry/detectorbitopes	Should we check whether the components of the symmetry group can be handled by orbitopes? Range: boolean	1
propagating/symmetry/detectsubgroups	Should we try to detect symmetric subgroups of the symmetry group on binary variables? Range: boolean	1
propagating/symmetry/displaynorbitvars	Should the number of variables affected by some symmetry be displayed? Range: boolean	0
propagating/symmetry/doubleequations	Double equations to positive/negative version? Range: boolean	0
propagating/symmetry/maxgenerators	limit on the number of generators that should be produced within symmetry detection (0 = no limit) Range: {0, ..., ∞}	1500
propagating/symmetry/maxnconsssubgroup	maximum number of constraints up to which subgroup structures are detected Range: {0, ..., ∞}	500000
propagating/symmetry/ofsymcomptiming	timing of symmetry computation for orbital fixing (0 = before presolving, 1 = during presolving, 2 = at first call) Range: {0, ..., 2}	2
propagating/symmetry/onlybinarysymmetry	Is only symmetry on binary variables used? Range: boolean	1
propagating/symmetry/performpresolving	run orbital fixing during presolving? Range: boolean	0
propagating/symmetry/preferlessrows	Shall orbitopes with less rows be preferred in detection? Range: boolean	1
propagating/symmetry/presolpriority	presolving priority of propagator <symmetry> Range: {-536870912, ..., 536870911}	-10000000
propagating/symmetry/presoltiming	timing mask of the presolving method of propagator <symmetry> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) Range: {2, ..., 60}	16
propagating/symmetry/priority	priority of propagator <symmetry> Range: {-536870912, ..., 536870911}	-1000000
propagating/symmetry/recomputerestart	recompute symmetries after a restart has occured? (0 = never) Range: {0, ..., 0}	0
propagating/symmetry/sstaddcuts	Should Schreier Sims constraints be added? Range: boolean	1
propagating/symmetry/sstleaderrule	rule to select the leader in an orbit (0: first var; 1: last var; 2: var having most conflicting vars in orbit; 3: var having most conflicting vars in problem) Range: {0, ..., 3}	0
propagating/symmetry/sstleadervartype	bitset encoding which variable types can be leaders (1: binary; 2: integer; 4: impl. int; 8: continuous);if multiple types are allowed, take the one with most affected vars Range: {1, ..., 15}	14
propagating/symmetry/sstmixedcomponents	Should Schreier Sims constraints be added if a symmetry component contains variables of different types? Range: boolean	1
propagating/symmetry/ssttiebreakrule	rule to select the orbit in Schreier Sims inequalities (variable in 0: minimum size orbit; 1: maximum size orbit; 2: orbit with most variables in conflict with leader) Range: {0, ..., 2}	1
propagating/symmetry/symfixnonbinaryvars	Whether all non-binary variables shall be not affected by symmetries if OF is active? Range: boolean	0
propagating/symmetry/timingmask	timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)) Range: {1, ..., 15}	1
propagating/symmetry/usecolumnsparsity	Should the number of conss a variable is contained in be exploited in symmetry detection? Range: boolean	0
propagating/symmetry/usedynamicprop	whether dynamic propagation should be used for full orbitopes Range: boolean	1

propagating/vbounds

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

randomization

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

separating

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

separating/aggregation

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

separating/cgmip

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

separating/clique

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

separating/closecuts

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

separating/cmir

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

separating/convexproj

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

separating/disjunctive

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

separating/eccuts

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

separating/flowcover

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

separating/gauge

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

separating/gomory

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

separating/gomorymi

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

separating/impliedbounds

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

separating/interminor

Option	Description	Default
separating/interminor/freq	frequency for calling separator <interminor> (-1: never, 0: only in root node) Range: {-1, ..., 65534}	-1
separating/interminor/maxrounds	maximal number of separation rounds per node (-1: unlimited) Range: {-1, ..., ∞}	10
separating/interminor/maxroundsroot	maximal number of separation rounds in the root node (-1: unlimited) Range: {-1, ..., ∞}	-1
separating/interminor/mincutviol	minimum required violation of a cut Range: [0, ∞]	0.0001
separating/interminor/usebounds	whether to also enforce nonegativity bounds of principle minors Range: boolean	0
separating/interminor/usestrengthening	whether to use strengthened intersection cuts to separate minors Range: boolean	0
Options for expert users
separating/interminor/delay	should separator be delayed, if other separators found cuts? Range: boolean	0
separating/interminor/expbackoff	base for exponential increase of frequency at which separator <interminor> is called (1: call at each multiple of frequency) Range: {1, ..., 100}	4
separating/interminor/maxbounddist	maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <interminor> (0.0: only on current best node, 1.0: on all nodes) Range: [0, 1]	1
separating/interminor/priority	priority of separator <interminor> Range: {-536870912, ..., 536870911}	0

separating/intobj

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

separating/knapsackcover

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

separating/mcf

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

separating/minor

Option	Description	Default
separating/minor/freq	frequency for calling separator <minor> (-1: never, 0: only in root node) Range: {-1, ..., 65534}	10
separating/minor/ignorepackingconss	whether to ignore circle packing constraints during minor detection Range: boolean	1
separating/minor/maxminorsconst	constant for the maximum number of minors, i.e., max(const, fac * # quadratic terms) Range: {0, ..., ∞}	3000
separating/minor/maxminorsfac	factor for the maximum number of minors, i.e., max(const, fac * # quadratic terms) Range: [0, ∞]	10
separating/minor/maxrounds	maximal number of separation rounds per node (-1: unlimited) Range: {-1, ..., ∞}	10
separating/minor/maxroundsroot	maximal number of separation rounds in the root node (-1: unlimited) Range: {-1, ..., ∞}	-1
separating/minor/mincutviol	minimum required violation of a cut Range: [0, ∞]	0.0001
Options for expert users
separating/minor/delay	should separator be delayed, if other separators found cuts? Range: boolean	0
separating/minor/expbackoff	base for exponential increase of frequency at which separator <minor> is called (1: call at each multiple of frequency) Range: {1, ..., 100}	4
separating/minor/maxbounddist	maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <minor> (0.0: only on current best node, 1.0: on all nodes) Range: [0, 1]	1
separating/minor/priority	priority of separator <minor> Range: {-536870912, ..., 536870911}	0

separating/mixing

Option	Description	Default
separating/mixing/freq	frequency for calling separator <mixing> (-1: never, 0: only in root node) Range: {-1, ..., 65534}	10
separating/mixing/maxnunsuccessful	maximal number of consecutive unsuccessful iterations Range: {-1, ..., ∞}	10
separating/mixing/maxrounds	maximal number of mixing separation rounds per node (-1: unlimited) Range: {-1, ..., ∞}	-1
separating/mixing/maxroundsroot	maximal number of mixing separation rounds in the root node (-1: unlimited) Range: {-1, ..., ∞}	-1
Options for expert users
separating/mixing/delay	should separator be delayed, if other separators found cuts? Range: boolean	0
separating/mixing/expbackoff	base for exponential increase of frequency at which separator <mixing> is called (1: call at each multiple of frequency) Range: {1, ..., 100}	4
separating/mixing/iscutsonints	Should general integer variables be used to generate cuts? Range: boolean	0
separating/mixing/maxbounddist	maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <mixing> (0.0: only on current best node, 1.0: on all nodes) Range: [0, 1]	1
separating/mixing/priority	priority of separator <mixing> Range: {-536870912, ..., 536870911}	-50
separating/mixing/uselocalbounds	Should local bounds be used? Range: boolean	0

separating/oddcycle

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

separating/rapidlearning

Option	Description	Default
separating/rapidlearning/freq	frequency for calling separator <rapidlearning> (-1: never, 0: only in root node) Range: {-1, ..., 65534}	5
Options for expert users
separating/rapidlearning/applybdchgs	should the found global bound deductions be applied in the original SCIP? Range: boolean	1
separating/rapidlearning/applyconflicts	should the found conflicts be applied in the original SCIP? Range: boolean	1
separating/rapidlearning/applyinfervals	should the inference values be used as initialization in the original SCIP? Range: boolean	1
separating/rapidlearning/applyprimalsol	should the incumbent solution be copied to the original SCIP? Range: boolean	1
separating/rapidlearning/applysolved	should a solved status be copied to the original SCIP? Range: boolean	1
separating/rapidlearning/checkdegeneracy	should local LP degeneracy be checked? Range: boolean	1
separating/rapidlearning/checkdualbound	should the progress on the dual bound be checked? Range: boolean	0
separating/rapidlearning/checkexec	check whether rapid learning should be executed Range: boolean	1
separating/rapidlearning/checkleaves	should the ratio of leaves proven to be infeasible and exceeding the cutoff bound be checked? Range: boolean	0
separating/rapidlearning/checknsols	should the number of solutions found so far be checked? Range: boolean	1
separating/rapidlearning/checkobj	should the (local) objective function be checked? Range: boolean	0
separating/rapidlearning/contvars	should rapid learning be applied when there are continuous variables? Range: boolean	0
separating/rapidlearning/contvarsquot	maximal portion of continuous variables to apply rapid learning Range: [0, 1]	0.3
separating/rapidlearning/copycuts	should all active cuts from cutpool be copied to constraints in subproblem? Range: boolean	1
separating/rapidlearning/delay	should separator be delayed, if other separators found cuts? Range: boolean	0
separating/rapidlearning/expbackoff	base for exponential increase of frequency at which separator <rapidlearning> is called (1: call at each multiple of frequency) Range: {1, ..., 100}	4
separating/rapidlearning/lpiterquot	maximal fraction of LP iterations compared to node LP iterations Range: [0, ∞]	0.2
separating/rapidlearning/maxbounddist	maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <rapidlearning> (0.0: only on current best node, 1.0: on all nodes) Range: [0, 1]	1
separating/rapidlearning/maxcalls	maximum number of overall calls Range: {0, ..., ∞}	100
separating/rapidlearning/maxnconss	maximum problem size (constraints) for which rapid learning will be called Range: {0, ..., ∞}	10000
separating/rapidlearning/maxnodes	maximum number of nodes considered in rapid learning run Range: {0, ..., ∞}	5000
separating/rapidlearning/maxnvars	maximum problem size (variables) for which rapid learning will be called Range: {0, ..., ∞}	10000
separating/rapidlearning/mindegeneracy	minimal degeneracy threshold to allow local rapid learning Range: [0, 1]	0.7
separating/rapidlearning/mininflpratio	minimal threshold of inf/obj leaves to allow local rapid learning Range: [0, ∞]	10
separating/rapidlearning/minnodes	minimum number of nodes considered in rapid learning run Range: {0, ..., ∞}	500
separating/rapidlearning/minvarconsratio	minimal ratio of unfixed variables in relation to basis size to allow local rapid learning Range: [1, ∞]	2
separating/rapidlearning/nwaitingnodes	number of nodes that should be processed before rapid learning is executed locally based on the progress of the dualbound Range: {0, ..., ∞}	100
separating/rapidlearning/priority	priority of separator <rapidlearning> Range: {-536870912, ..., 536870911}	-1200000
separating/rapidlearning/reducedinfer	should the inference values only be used when rapidlearning found other reductions? Range: boolean	0

separating/rlt

Option	Description	Default
separating/rlt/addtopool	if set to true, globally valid RLT cuts are added to the global cut pool Range: boolean	1
separating/rlt/detecthidden	if set to true, hidden products are detected and separated by McCormick cuts Range: boolean	0
separating/rlt/freq	frequency for calling separator <rlt> (-1: never, 0: only in root node) Range: {-1, ..., 65534}	0
separating/rlt/hiddenrlt	whether RLT cuts (TRUE) or only McCormick inequalities (FALSE) should be added for hidden products Range: boolean	0
separating/rlt/maxncuts	maximal number of rlt-cuts that are added per round (-1: unlimited) Range: {-1, ..., ∞}	-1
separating/rlt/maxrounds	maximal number of separation rounds per node (-1: unlimited) Range: {-1, ..., ∞}	1
separating/rlt/maxroundsroot	maximal number of separation rounds in the root node (-1: unlimited) Range: {-1, ..., ∞}	10
separating/rlt/maxunknownterms	maximal number of unknown bilinear terms a row is still used with (-1: unlimited) Range: {-1, ..., ∞}	0
separating/rlt/maxusedvars	maximal number of variables used to compute rlt cuts (-1: unlimited) Range: {-1, ..., ∞}	100
separating/rlt/onlycontrows	if set to true, only continuous rows are used for rlt cuts Range: boolean	0
separating/rlt/onlyeqrows	if set to true, only equality rows are used for rlt cuts Range: boolean	0
separating/rlt/onlyoriginal	if set to true, only original rows and variables are used Range: boolean	1
separating/rlt/useinsubscip	if set to true, rlt is also used in sub-scips Range: boolean	0
separating/rlt/useprojection	if set to true, projected rows are checked first Range: boolean	0
Options for expert users
separating/rlt/badscore	threshold for score of cut relative to best score to be discarded Range: [0, 1]	0.5
separating/rlt/delay	should separator be delayed, if other separators found cuts? Range: boolean	0
separating/rlt/dircutoffdistweight	weight of directed cutoff distance in cut score calculation Range: [0, 1]	0
separating/rlt/efficacyweight	weight of efficacy in cut score calculation Range: [0, 1]	1
separating/rlt/expbackoff	base for exponential increase of frequency at which separator <rlt> is called (1: call at each multiple of frequency) Range: {1, ..., 100}	4
separating/rlt/goodmaxparall	maximum parallelism for good cuts Range: [0, 1]	0.1
separating/rlt/goodscore	threshold for score of cut relative to best score to be considered good, so that less strict filtering is applied Range: [0, 1]	1
separating/rlt/maxbounddist	maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <rlt> (0.0: only on current best node, 1.0: on all nodes) Range: [0, 1]	1
separating/rlt/maxparall	maximum parallelism for non-good cuts Range: [0, 1]	0.1
separating/rlt/objparalweight	weight of objective parallelism in cut score calculation Range: [0, 1]	0
separating/rlt/priority	priority of separator <rlt> Range: {-536870912, ..., 536870911}	10

separating/strongcg

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

separating/zerohalf

Option	Description	Default
separating/zerohalf/dynamiccuts	should generated cuts be removed from the LP if they are no longer tight? Range: boolean	1
separating/zerohalf/freq	frequency for calling separator <zerohalf> (-1: never, 0: only in root node) Range: {-1, ..., 65534}	10
separating/zerohalf/initseed	initial seed used for random tie-breaking in cut selection Range: {0, ..., ∞}	24301
separating/zerohalf/maxcutcands	maximal number of zerohalf cuts considered per separation round Range: {0, ..., ∞}	2000
separating/zerohalf/maxrounds	maximal number of zerohalf separation rounds per node (-1: unlimited) Range: {-1, ..., ∞}	5
separating/zerohalf/maxroundsroot	maximal number of zerohalf separation rounds in the root node (-1: unlimited) Range: {-1, ..., ∞}	20
separating/zerohalf/maxsepacuts	maximal number of zerohalf cuts separated per separation round Range: {0, ..., ∞}	20
separating/zerohalf/maxsepacutsroot	maximal number of zerohalf cuts separated per separation round in the root node Range: {0, ..., ∞}	100
Options for expert users
separating/zerohalf/badscore	threshold for score of cut relative to best score to be discarded Range: [0, 1]	0.5
separating/zerohalf/delay	should separator be delayed, if other separators found cuts? Range: boolean	0
separating/zerohalf/densityoffset	additional number of variables allowed in row on top of density Range: {0, ..., ∞}	100
separating/zerohalf/dircutoffdistweight	weight of directed cutoff distance in cut score calculation Range: [0, 1]	0
separating/zerohalf/efficacyweight	weight of efficacy in cut score calculation Range: [0, 1]	1
separating/zerohalf/expbackoff	base for exponential increase of frequency at which separator <zerohalf> is called (1: call at each multiple of frequency) Range: {1, ..., 100}	4
separating/zerohalf/goodmaxparall	maximum parallelism for good cuts Range: [0, 1]	0.1
separating/zerohalf/goodscore	threshold for score of cut relative to best score to be considered good, so that less strict filtering is applied Range: [0, 1]	1
separating/zerohalf/maxbounddist	maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <zerohalf> (0.0: only on current best node, 1.0: on all nodes) Range: [0, 1]	1
separating/zerohalf/maxparall	maximum parallelism for non-good cuts Range: [0, 1]	0.1
separating/zerohalf/maxrowdensity	maximal density of row to be used in aggregation Range: [0, 1]	0.05
separating/zerohalf/maxslack	maximal slack of rows to be used in aggregation Range: [0, ∞]	0
separating/zerohalf/maxslackroot	maximal slack of rows to be used in aggregation in the root node Range: [0, ∞]	0
separating/zerohalf/minviol	minimal violation to generate zerohalfcut for Range: [0, ∞]	0.1
separating/zerohalf/objparalweight	weight of objective parallelism in cut score calculation Range: [0, 1]	0
separating/zerohalf/priority	priority of separator <zerohalf> Range: {-536870912, ..., 536870911}	-6000

solvingphases

Option	Description	Default
solvingphases/enabled	should the event handler adapt the solver behavior? Range: boolean	0
solvingphases/fallback	should the event handler fall back from optimal phase? Range: boolean	0
solvingphases/feassetname	settings file for feasibility phase – precedence over emphasis settings Range: string	-
solvingphases/improvesetname	settings file for improvement phase – precedence over emphasis settings Range: string	-
solvingphases/interruptoptimal	should the event handler interrupt the solving process after optimal solution was found? Range: boolean	0
solvingphases/nodeoffset	node offset for rank-1 and estimate transitions Range: {1, ..., ∞}	50
solvingphases/optimalvalue	optimal solution value for problem Range: real	∞
solvingphases/proofsetname	settings file for proof phase – precedence over emphasis settings Range: string	-
solvingphases/testmode	should the event handler test all phase transitions? Range: boolean	0
solvingphases/transitionmethod	transition method: Possible options are 'e'stimate,'l'ogarithmic regression,'o'ptimal-value based,'r'ank-1 Range: e, l, o, r	r
solvingphases/useemphsettings	should emphasis settings for the solving phases be used, or settings files? Range: boolean	1
solvingphases/userestart1to2	should a restart be applied between the feasibility and improvement phase? Range: boolean	0
solvingphases/userestart2to3	should a restart be applied between the improvement and the proof phase? Range: boolean	0
solvingphases/xtype	x-type for logarithmic regression - (t)ime, (n)odes, (l)p iterations Range: l, n, t	n

table/branchrules

Option	Description	Default
table/branchrules/active	is statistics table <branchrules> active Range: boolean	1

table/compression

Option	Description	Default
table/compression/active	is statistics table <compression> active Range: boolean	1

table/concurrentsolver

Option	Description	Default
table/concurrentsolver/active	is statistics table <concurrentsolver> active Range: boolean	1

table/conflict

Option	Description	Default
table/conflict/active	is statistics table <conflict> active Range: boolean	1

table/cons_nonlinear

Option	Description	Default
table/cons_nonlinear/active	is statistics table <cons_nonlinear> active Range: boolean	0

table/constiming

Option	Description	Default
table/constiming/active	is statistics table <constiming> active Range: boolean	1

table/constraint

Option	Description	Default
table/constraint/active	is statistics table <constraint> active Range: boolean	1

table/cutsel

Option	Description	Default
table/cutsel/active	is statistics table <cutsel> active Range: boolean	1

table/estim

Option	Description	Default
table/estim/active	is statistics table <estim> active Range: boolean	1

table/exprhdlr

Option	Description	Default
table/exprhdlr/active	is statistics table <exprhdlr> active Range: boolean	1

table/heuristics

Option	Description	Default
table/heuristics/active	is statistics table <heuristics> active Range: boolean	1

table/lp

Option	Description	Default
table/lp/active	is statistics table <lp> active Range: boolean	1

table/neighborhood

Option	Description	Default
table/neighborhood/active	is statistics table <neighborhood> active Range: boolean	1

table/nlhdlr

Option	Description	Default
table/nlhdlr/active	is statistics table <nlhdlr> active Range: boolean	1

table/nlhdlr_bilinear

Option	Description	Default
table/nlhdlr_bilinear/active	is statistics table <nlhdlr_bilinear> active Range: boolean	0

table/nlhdlr_quadratic

Option	Description	Default
table/nlhdlr_quadratic/active	is statistics table <nlhdlr_quadratic> active Range: boolean	0

table/nlp

Option	Description	Default
table/nlp/active	is statistics table <nlp> active Range: boolean	1

table/nlpi

Option	Description	Default
table/nlpi/active	is statistics table <nlpi> active Range: boolean	1

table/orbitalfixing

Option	Description	Default
table/orbitalfixing/active	is statistics table <orbitalfixing> active Range: boolean	1

table/origprob

Option	Description	Default
table/origprob/active	is statistics table <origprob> active Range: boolean	1

table/presolvedprob

Option	Description	Default
table/presolvedprob/active	is statistics table <presolvedprob> active Range: boolean	1

table/presolver

Option	Description	Default
table/presolver/active	is statistics table <presolver> active Range: boolean	1

table/pricer

Option	Description	Default
table/pricer/active	is statistics table <pricer> active Range: boolean	1

table/propagator

Option	Description	Default
table/propagator/active	is statistics table <propagator> active Range: boolean	1

table/relaxator

Option	Description	Default
table/relaxator/active	is statistics table <relaxator> active Range: boolean	1

table/root

Option	Description	Default
table/root/active	is statistics table <root> active Range: boolean	1

table/separator

Option	Description	Default
table/separator/active	is statistics table <separator> active Range: boolean	1

table/solution

Option	Description	Default
table/solution/active	is statistics table <solution> active Range: boolean	1

table/status

Option	Description	Default
table/status/active	is statistics table <status> active Range: boolean	1

table/timing

Option	Description	Default
table/timing/active	is statistics table <timing> active Range: boolean	1

table/tree

Option	Description	Default
table/tree/active	is statistics table <tree> active Range: boolean	1

timing

Option	Description	Default
timing/clocktype	default clock type (1: CPU user seconds, 2: wall clock time) Range: {1, ..., 2}	2
timing/enabled	is timing enabled? Range: boolean	1
timing/nlpieval	should time for evaluation in NLP solves be measured? Range: boolean	0
timing/rareclockcheck	should clock checks of solving time be performed less frequently (note: time limit could be exceeded slightly) Range: boolean	0
timing/reading	belongs reading time to solving time? Range: boolean	0
timing/statistictiming	should timing for statistic output be performed? Range: boolean	1