SCIP (Solving Constraint Integer Programs) is developed at the Zuse Institute Berlin (ZIB) in cooperation with TU Darmstadt, RWTH Aachen, and University of Erlangen-Nürnberg, see the SCIP webpage for the current list of developers.
SCIP is a framework for Constraint Integer Programming oriented towards the needs of Mathematical Programming experts who want to have total control of the solution process and access detailed information down to the guts of the solver. SCIP can also be used as a pure MIP or MINLP solver or as a framework for branch-cut-and-price. Within GAMS, the MIP and MINLP solving facilities of SCIP are available.
For more detailed information, we refer to [3, 4, 5, 35, 36, 102, 168, 116, 117, 103, 247, 248, 262] and the SCIP web site.
GAMS/SCIP uses CPLEX, if licensed, and otherwise SOPLEX [264] as LP solver, the COIN-OR Interior Point Optimizer IPOPT [253] as nonlinear solver, and CppAD to compute derivatives of nonlinear functions.
SCIP supports continuous, binary, integer, semi-continuous, semi-integer variables, indicator constraints, special ordered sets, and branching priorities for discrete variables.
Usage
The following statement can be used inside your GAMS program to specify using SCIP
Option MIP = SCIP; { or QCP or NLP or MIQCP or MINLP or ... }
The above statement should appear before the Solve statement. If SCIP was specified as the default solver during GAMS installation, the above statement is not necessary.
GAMS/SCIP currently does not support the GAMS Branch-and-Cut-and-Heuristic (BCH) Facility. If you need to use GAMS/SCIP with BCH, please consider to use a GAMS system of version ≤ 23.3.
Specification of SCIP Options
GAMS/SCIP supports the GAMS parameters reslim, iterlim, nodlim, optca, optcr, and workspace. Further, the option threads can be used to control the number of threads used in the MILP presolver, the linear algebra routines of IPOPT, and for solving LPs if CPLEX' barrier solver is used.
Options can be specified by a SCIP options file. A SCIP options file consists of one option or comment per line. A pound sign (#) at the beginning of a line causes the entire line to be ignored. Otherwise, the line will be interpreted as an option name and value separated by an equal sign (=) and any amount of white space (blanks or tabs). Further, string values have to be enclosed in quotation marks.
A small example for a scip.opt file is:
propagating/probing/maxprerounds = 0
separating/maxrounds = 0
separating/maxroundsroot = 0
It causes GAMS/SCIP to disable probing during presolve and to turn off all cut generators.
Specification of Indicators
Indicators are a modeling tool to specify that certain equations in a model must only be satisfied if certain binary variables take a specified value. Indicators are not supported by the GAMS language, but can be passed to SCIP via a separate file, see Indicator Constraints for more details on its syntax. The name of that file is specified via the option gams/indicatorfile in a SCIP option file. Currently, indicators can only be used for linear equations.
Special Features
SCIP interactive shell
The interactive shell in SCIP is a powerful tool that allows the user to display various information (e.g., branching statistics, presolved model), load emphasis settings, interrupt a solve to change parameters or trigger a restart, write the model in various file formats, start SCIPs solution counter, and many more things.
When setting the option gams/interactive to a nonempty string, the GAMS/SCIP interface opens the interactive shell of SCIP after having load the GAMS problem and parameters and passes the value of the gams/interactive parameter to the SCIP interactive shell.
By default, SCIP behaves as if gams/interactive has been set to "optimize write gamssol quit", that is, SCIP is requested to solve the problem, then to pass the solution back to GAMS, and to quit.
An example use of the SCIP interactive shell feature via GAMS is to add the following line to your SCIP options file:
gams/interactive = "write prob orig.lp presolve write transprob presol.mps opt write gamssol quit"
This instructs SCIP to write the original problem to the file orig.lp in LP format, to presolve the instance, to write the presolved problem to the file presolved.mps in MPS format, to solve the instance, to write the solution out to GAMS, and to finish.
By omitting the quit command, SCIPs interactive shell remains open and awaits user input. The command help prints a list of available commands. Note, that on Windows, GAMS need to be called with the option interactivesolver enabled to allow user input for the solver process.
A tutorial on using the SCIP shell is available at https://www.scipopt.org/doc/html/SHELL.php.
Emphasis Settings
SCIP includes various emphasis settings, which are predefined values for a set of SCIP parameters. Such predefined settings are available for setting the effort that SCIP should spend for, e.g., presolving, separation, or heuristics.
The emphasis settings are not available as single parameters, but can be set via SCIPs interactive shell. E.g., writing set heuristics emphasis in the shell displays the available emphasis settings for heuristics (aggressive, fast, off) and expects the user to input which setting to use. Further, general emphasis settings are available in the set emphasis menu, some of them giving predefined settings similar to the CPLEX option mipemphasis.
Via the gams/interactive option, c.f. Section SCIP interactive shell, emphasis settings can be activated via a SCIP options file. For example, adding the option
gams/interactive = "set emphasis feasibility set loadgams optimize write gamssol quit"
instructs SCIP to load the emphasis setting feasibility prior to optimizing the model and passing the solution back to GAMS. Note, that setting one of the emphasis settings feasibility, hardlp, and optimality resets all previously set parameters to their default values, which includes the ones that are set by the GAMS/SCIP interface or which were loaded from a SCIP options file. Therefore, the command set loadgams has been used above to restore these parameter settings.
The following emphasis settings are available in SCIP:
| shell command | purpose |
set emphasis easycip | use for easy problems |
set emphasis feasibility | emphasize finding a feasible solution |
set emphasis hardlp | use for problems with a hard LP |
set emphasis optimality | emphasize proving optimality |
set emphasis numerics | increase numerical stability |
set heuristic emphasis aggressive | use primal heuristics aggressively |
set heuristic emphasis fast | use only fast primal heuristics |
set heuristic emphasis off | disable all primal heuristics |
set presolving emphasis aggressive | do aggressive presolving |
set presolving emphasis fast | use only fast presolving steps |
set presolving emphasis off | disable presolving |
set separating emphasis aggressive | use cutting plane separators aggressively |
set separating emphasis fast | use only fast cutting plane separators |
set separating emphasis off | disable all cutting plane separators |
Starting point
Using the completesol heuristic, SCIP can try to find a feasible solution based on values given by the user for all or some of the variables. The values need to be specified as variable levels in the GAMS model. The heuristic solves a copy of the problem where variables for which values have been provided are restricted to be close to that value. When an integral value is specified for a binary or integer variable, the variable is fixed to that value. See also Section 2.3.2 in [168] for a more detailed description of the heuristic.
For which variables the level values are passed from GAMS to SCIP is controlled by the parameter gams/mipstart. The parameter values have the following meaning:
- 0: do not pass any variable values to SCIP, the heuristic will not run
- 1: pass values for all binary and integer variables to SCIP and let SCIP try to find a feasible solution in its neighborhood by using the completesol heuristic
- 2 (default): pass values for all variables to SCIP and let SCIP check feasibility of the given solution, the heuristic will not run
- 3: pass values for all variables to SCIP and let SCIP try to find a feasible solution in the neighborhood by using the completesol heuristic
- 4: pass values for all binary and integer variables to SCIP which fractionality is at most the value of GAMS option tryint (thus, with default tryint=0, only for variables with integral values, the value is passed to SCIP) and let SCIP try to find a feasible solution in the neighborhood by using the completesol heuristic
Note, that the completesol heuristic will not run if there are too many variables with unknown values. This behavior can be adjusted by setting parameter heuristics/completesol/maxunknownrate.
Decomposition Information
SCIP potentially can make use of a user-provided problem decomposition, e.g., in primal heuristics PADM or GINS. Note, that SCIP's Benders Decomposition is not available with GAMS at the moment. A GAMS user can inform SCIP about such a decomposition by using the .stage variable suffix.
In an attempt to following the same convention on interpreting the .stage variable suffix as the GAMS/CPLEX link, variables which .stage suffix is set to an integral value greater than 0 are assigned to a block with this number. Variables which .stage suffix is set to a fractional value or a value smaller than 1 are assigned to no block.
Note, that the default value for the .stage suffix is 1. Therefore, GAMS/SCIP only passes decomposition information to SCIP if at least one variable has its .stage suffix set to a value different than 1. Moreover, in order to receive the .stage values, scaleOpt and priorOpt must be left at their default of 0.
Solution Pool
When SCIP solves a problem, it may find several solutions, whereof only the best one is available to the GAMS user via the variable level values in the GAMS model. If the option gams/dumpsolutions is specified, then all alternative solutions found by SCIP are written into GDX files and an index file with the name given by the this option is written. If the option gams/dumpsolutionsmerged is specified, then all alternative solutions found by SCIP are written into a single GDX file, which name is given by the this option.
The GAMS testlib model dumpsol shows an example use for this option via GUROBI. It can easily be adapted to be used with SCIP.
Solving process tracing
The option gams/solvetrace/file can be used to specify the name of a file where information about the progress of the branch-and-bound tree search in SCIP is stored. The file is created and updated during the solution process, so it may also be used to monitor the progress of SCIP while it still solves the model.
New entries are written periodically, depending on how many nodes have been processed or how much time has been elapsed since the last entry was written. Each entry contains information on the current primal and dual bound.
Notes on solving MINLPs with SCIP
SCIP includes capabilities to handle nonlinear functions that are specified via algebraic expressions. Therefore, neither external/extrinsic functions nor all GAMS operands (e.g., trigonometric ones) are supported yet.
Nonconvex MINLPs are solved via a spatial branch-and-bound algorithm using linear relaxations. The tightness of this relaxation depends heavily on the variable bounds, thus tight bounds for the nonlinear variables are crucial for SCIP.
Special options for convex MINLPs
Convex MINLPs are much easier to solve for SCIP, provided it recognizes the convexity of the model. So far, only a simple convexity check is implemented in SCIP, which may not give a conclusive answer in all cases. However, setting the option constraints/nonlinear/assumeconvex to TRUE can be used to tell SCIP that it should assume all nonlinear constraints to be of convex type. This may help to improve solving times for convex MINLPs considerably.
Another feature that can be especially useful for convex MINLPs is to enable the generation of cuts in the solution of the NLP relaxation in the root node and to consider using these cuts during the whole solution process. This is achieved by the parameters
constraints/quadratic/sepanlpmincont = 0
constraints/soc/sepanlpmincont = 0
constraints/nonlinear/sepanlpmincont = 0
constraints/abspower/sepanlpmincont = 0
separating/poolfreq = 1
However, it has been shown that these settings can also deteriorate performance.
Components
In the following, we list components that are available in SCIP together with some common properties. Some of these properties can be modified with corresponding parameters.
Branching Rules
| branching rule | priority | maxdepth | maxbounddist | description |
| relpscost | 10000 | -1 | 100 | reliability branching on pseudo cost values |
| pscost | 2000 | -1 | 100 | branching on pseudo cost values |
| inference | 1000 | -1 | 100 | inference history branching |
| mostinf | 100 | -1 | 100 | most infeasible branching |
| leastinf | 50 | -1 | 100 | least infeasible branching |
| distribution | 0 | -1 | 100 | branching rule based on variable influence on cumulative normal distribution of row activities |
| fullstrong | 0 | -1 | 100 | full strong branching |
| cloud | 0 | -1 | 100 | branching rule that considers several alternative LP optima |
| lookahead | 0 | -1 | 100 | full strong branching over multiple levels |
| multaggr | 0 | -1 | 100 | fullstrong branching on fractional and multi-aggregated variables |
| allfullstrong | -1000 | -1 | 100 | all variables full strong branching |
| vanillafullstrong | -2000 | -1 | 100 | vanilla full strong branching |
| random | -100000 | -1 | 100 | random variable branching |
| nodereopt | -9000000 | -1 | 100 | branching rule for node reoptimization |
See https://www.scipopt.org/doc/html/BRANCH.php for a detailed description of the branching rule properties.
Conflict Handler
| conflict handler | priority | description |
| logicor | 800000 | conflict handler creating logic or constraints |
| setppc | 700000 | conflict handler creating set covering constraints |
| indicatorconflict | 200000 | replace slack variables and generate logicor constraints |
| linear | -1000000 | conflict handler creating linear constraints |
| bounddisjunction | -3000000 | conflict handler creating bound disjunction constraints |
Constraint Handler
| constraint handler | checkprio | enfoprio | sepaprio | sepafreq | propfreq | eagerfreq | presolvetimings | description |
| integral | 0 | 0 | 0 | -1 | -1 | -1 | always | integrality constraint |
| soc | -10 | -40 | 10 | 1 | 1 | 100 | always | constraint handler for second order cone constraints |
| SOS1 | -10 | 100 | 1000 | 10 | 1 | 100 | medium | SOS1 constraint handler |
| SOS2 | -10 | 100 | 10 | 0 | 1 | 100 | fast | SOS2 constraint handler |
| varbound | -500000 | -500000 | 900000 | 0 | 1 | 100 | fast medium | variable bounds lhs <= x + c*y <= rhs, x non-binary, y non-continuous |
| knapsack | -600000 | -600000 | 600000 | 0 | 1 | 100 | always | knapsack constraint of the form a^T x <= b, x binary and a >= 0 |
| setppc | -700000 | -700000 | 700000 | 0 | 1 | 100 | always | set partitioning / packing / covering constraints |
| and | -850100 | -850100 | 850100 | 1 | 1 | 100 | fast exhaustive | constraint handler for AND-constraints: r = and(x1, ..., xn) |
| linear | -1000000 | -1000000 | 100000 | 0 | 1 | 100 | fast exhaustive | linear constraints of the form lhs <= a^T x <= rhs |
| orbisack | -1005200 | -1005200 | 40100 | 5 | 5 | -1 | exhaustive | symmetry breaking constraint handler for orbisacks |
| orbitope | -1005200 | -1005200 | 40100 | -1 | 1 | -1 | medium | symmetry breaking constraint handler relying on (partitioning/packing) orbitopes |
| symresack | -1005200 | -1005200 | 40100 | 5 | 5 | -1 | exhaustive | symmetry breaking constraint handler relying on symresacks |
| logicor | -2000000 | -2000000 | 10000 | 0 | 1 | 100 | always | logic or constraints |
| bounddisjunction | -3000000 | -3000000 | 0 | -1 | 1 | 100 | fast | bound disjunction constraints |
| abspower | -3500000 | -30 | 0 | 1 | 1 | 100 | fast medium | constraint handler for absolute power constraints lhs <= sign(x+offset)abs(x+offset)^n + c*z <= rhs |
| bivariate | -3600000 | -55 | 5 | 1 | 1 | 100 | fast | constraint handler for constraints of the form lhs <= f(x,y) + c*z <= rhs where f(x,y) is a bivariate function |
| quadratic | -4000000 | -50 | 10 | 1 | 1 | 100 | always | quadratic constraints of the form lhs <= b' x + x' A x <= rhs |
| nonlinear | -4000010 | -60 | 10 | 1 | 1 | 100 | always | constraint handler for nonlinear constraints |
| indicator | -6000000 | -100 | 10 | 10 | 1 | 100 | fast | indicator constraint handler |
| components | -9999999 | 0 | 0 | -1 | 1 | -1 | | independent components constraint handler |
See https://www.scipopt.org/doc/html/CONS.php for a detailed description of the constraint handler properties.
Display Columns
| display column | header | position | width | priority | status | description |
| solfound | | 0 | 1 | 80000 | auto | letter that indicates the heuristic which found the solution |
| time | time | 50 | 5 | 4000 | auto | total solution time |
| nnodes | node | 100 | 7 | 100000 | auto | number of processed nodes |
| nodesleft | left | 200 | 7 | 90000 | auto | number of unprocessed nodes |
| nrank1nodes | rank1 | 500 | 7 | 40000 | off | current number of rank1 nodes left |
| nnodesbelowinc | nbInc | 550 | 6 | 40000 | off | current number of nodes with an estimate better than the current incumbent |
| lpiterations | LP iter | 1000 | 7 | 30000 | auto | number of simplex iterations |
| lpavgiterations | LP it/n | 1400 | 7 | 25000 | auto | average number of LP iterations since the last output line |
| lpcond | LP cond | 1450 | 7 | 0 | auto | estimate on condition number of LP solution |
| memused | umem | 1500 | 5 | 0 | auto | total number of bytes used in block memory |
| memtotal | mem/heur | 1500 | 8 | 20000 | auto | total number of bytes in block memory or the creator name when a new incumbent solution was found |
| depth | depth | 2000 | 5 | 500 | auto | depth of current node |
| maxdepth | mdpt | 2100 | 5 | 5000 | auto | maximal depth of all processed nodes |
| plungedepth | pdpt | 2200 | 5 | 10 | auto | current plunging depth |
| nfrac | frac | 2500 | 5 | 700 | auto | number of fractional variables in the current solution |
| nexternbranchcands | extbr | 2600 | 5 | 650 | auto | number of extern branching variables in the current node |
| vars | vars | 3000 | 5 | 3000 | auto | number of variables in the problem |
| conss | cons | 3100 | 5 | 3100 | auto | number of globally valid constraints in the problem |
| curconss | ccons | 3200 | 5 | 600 | auto | number of enabled constraints in current node |
| curcols | cols | 3300 | 5 | 800 | auto | number of LP columns in current node |
| currows | rows | 3400 | 5 | 900 | auto | number of LP rows in current node |
| cuts | cuts | 3500 | 5 | 2100 | auto | total number of cuts applied to the LPs |
| separounds | sepa | 3600 | 4 | 100 | auto | number of separation rounds performed at the current node |
| poolsize | pool | 3700 | 5 | 50 | auto | number of LP rows in the cut pool |
| conflicts | confs | 4000 | 5 | 2000 | auto | total number of conflicts found in conflict analysis |
| strongbranchs | strbr | 5000 | 5 | 1000 | auto | total number of strong branching calls |
| pseudoobj | pseudoobj | 6000 | 14 | 300 | auto | current pseudo objective value |
| lpobj | lpobj | 6500 | 14 | 300 | auto | current LP objective value |
| curdualbound | curdualbound | 7000 | 14 | 400 | auto | dual bound of current node |
| estimate | estimate | 7500 | 14 | 200 | auto | estimated value of feasible solution in current node |
| avgdualbound | avgdualbound | 8000 | 14 | 40 | auto | average dual bound of all unprocessed nodes |
| dualbound | dualbound | 9000 | 14 | 70000 | auto | current global dual bound |
| primalbound | primalbound | 10000 | 14 | 80000 | auto | current primal bound |
| cutoffbound | cutoffbound | 10100 | 14 | 10 | auto | current cutoff bound |
| gap | gap | 20000 | 8 | 60000 | auto | current (relative) gap using |primal-dual|/MIN(|dual|,|primal|) |
| primalgap | primgap | 21000 | 8 | 20000 | off | current (relative) gap using |primal-dual|/|primal| |
| nsols | nsols | 30000 | 5 | 0 | auto | current number of solutions found |
| completed | compl. | 30100 | 8 | 110000 | auto | completion of search in percent (based on tree size estimation) |
| nobjleaves | objleav | 31000 | 7 | 0 | auto | current number of encountered objective limit leaves |
| ninfeasleaves | infleav | 32000 | 7 | 0 | auto | number of encountered infeasible leaves |
| sols | sols | 100000 | 7 | 110000 | off | number of detected feasible solutions |
| feasST | feasST | 110000 | 6 | 110000 | off | number of detected non trivial feasible subtrees |
See https://www.scipopt.org/doc/html/DISP.php for a detailed description of the display column properties.
Node Selectors
| node selector | standard priority | memsave priority | description |
| estimate | 200000 | 100 | best estimate search |
| bfs | 100000 | 0 | best first search |
| hybridestim | 50000 | 50 | hybrid best estimate / best bound search |
| restartdfs | 10000 | 50000 | depth first search with periodical selection of the best node |
| uct | 10 | 0 | node selector which balances exploration and exploitation |
| dfs | 0 | 100000 | depth first search |
| breadthfirst | -10000 | -1000000 | breadth first search |
See https://www.scipopt.org/doc/html/NODESEL.php for a detailed description of the node selector properties.
Presolvers
| presolver | priority | timing | maxrounds | description |
| milp | 9999999 | medium | -1 | MILP specific presolving methods |
| trivial | 9000000 | fast | -1 | round fractional bounds on integers, fix variables with equal bounds |
| boundshift | 7900000 | fast | 0 | converts variables with domain [a,b] to variables with domain [0,b-a] |
| inttobinary | 7000000 | fast | -1 | converts integer variables with domain [a,a+1] to binaries |
| convertinttobin | 6000000 | fast | 0 | converts integer variables to binaries |
| gateextraction | 1000000 | exhaustive | -1 | presolver extracting gate(and)-constraints |
| qpkktref | -1 | medium | -1 | adds KKT conditions to (mixed-binary) quadratic programs |
| dualcomp | -50 | exhaustive | -1 | compensate single up-/downlocks by singleton continuous variables |
| stuffing | -100 | exhaustive | 0 | fix redundant singleton continuous variables |
| domcol | -1000 | exhaustive | -1 | dominated column presolver |
| tworowbnd | -2000 | exhaustive | 0 | do bound tigthening by using two rows |
| dualinfer | -3000 | exhaustive | 0 | exploit dual information for fixings and side changes |
| implics | -10000 | medium | -1 | implication graph aggregator |
| dualagg | -12000 | exhaustive | 0 | aggregate variables by dual arguments |
| sparsify | -24000 | exhaustive | -1 | eliminate non-zero coefficients |
| dualsparsify | -240000 | exhaustive | -1 | eliminate non-zero coefficients |
| redvub | -9000000 | exhaustive | 0 | detect redundant variable bound constraints |
See https://www.scipopt.org/doc/html/PRESOL.php for a detailed description of the presolver properties.
Primal Heuristics
| primal heuristic | type | priority | freq | freqoffset | description |
| padm | L | 70000 | 0 | 0 | penalty alternating direction method primal heuristic |
| ofins | L | 60000 | 0 | 0 | primal heuristic for reoptimization, objective function induced neighborhood search |
| trivialnegation | p | 40000 | 0 | 0 | negate solution entries if an objective coefficient changes the sign, enters or leaves the objective. |
| reoptsols | p | 40000 | 0 | 0 | primal heuristic updating solutions found in a previous optimization round |
| trivial | t | 10000 | 0 | 0 | start heuristic which tries some trivial solutions |
| clique | p | 5000 | 0 | 0 | LNS heuristic using a clique partition to restrict the search neighborhood |
| locks | p | 3000 | 0 | 0 | heuristic that fixes variables based on their rounding locks |
| vbounds | p | 2500 | 0 | 0 | LNS heuristic uses the variable lower and upper bounds to determine the search neighborhood |
| shiftandpropagate | p | 1000 | 0 | 0 | Pre-root heuristic to expand an auxiliary branch-and-bound tree and apply propagation techniques |
| zeroobj | L | 100 | -1 | 0 | heuristic trying to solve the problem without objective |
| completesol | L | 0 | 0 | 0 | primal heuristic trying to complete given partial solutions |
| dualval | L | 0 | -1 | 0 | primal heuristic using dual values |
| simplerounding | r | 0 | 1 | 0 | simple and fast LP rounding heuristic |
| repair | L | 0 | -1 | 0 | tries to repair a primal infeasible solution |
| randrounding | r | -200 | 20 | 0 | fast LP rounding heuristic |
| zirounding | r | -500 | 1 | 0 | LP rounding heuristic as suggested by C. Wallace taking row slacks and bounds into account |
| rounding | r | -1000 | 1 | 0 | LP rounding heuristic with infeasibility recovering |
| shifting | r | -5000 | 10 | 0 | LP rounding heuristic with infeasibility recovering also using continuous variables |
| intshifting | r | -10000 | 10 | 0 | LP rounding heuristic with infeasibility recovering and final LP solving |
| oneopt | i | -20000 | 1 | 0 | 1-opt heuristic which tries to improve setting of single integer variables |
| twoopt | i | -20100 | -1 | 0 | primal heuristic to improve incumbent solution by flipping pairs of variables |
| indicator | L | -20200 | 1 | 0 | indicator heuristic to create feasible solutions from values for indicator variables |
| adaptivediving | d | -70000 | 5 | 3 | diving heuristic that selects adaptively between the existing, public divesets |
| fixandinfer | p | -500000 | -1 | 0 | iteratively fixes variables and propagates inferences |
| farkasdiving | d | -900000 | 10 | 0 | LP diving heuristic that tries to construct a Farkas-proof |
| feaspump | o | -1000000 | 20 | 0 | objective feasibility pump 2.0 |
| conflictdiving | d | -1000100 | 10 | 0 | LP diving heuristic that chooses fixings w.r.t. conflict locks |
| coefdiving | d | -1001000 | -1 | 1 | LP diving heuristic that chooses fixings w.r.t. the matrix coefficients |
| pscostdiving | d | -1002000 | 10 | 2 | LP diving heuristic that chooses fixings w.r.t. the pseudo cost values |
| fracdiving | d | -1003000 | 10 | 3 | LP diving heuristic that chooses fixings w.r.t. the fractionalities |
| nlpdiving | d | -1003000 | 10 | 3 | NLP diving heuristic that chooses fixings w.r.t. the fractionalities |
| veclendiving | d | -1003100 | 10 | 4 | LP diving heuristic that rounds variables with long column vectors |
| distributiondiving | d | -1003300 | 10 | 3 | Diving heuristic that chooses fixings w.r.t. changes in the solution density |
| intdiving | d | -1003500 | -1 | 9 | LP diving heuristic that fixes binary variables with large LP value to one |
| actconsdiving | d | -1003700 | -1 | 5 | LP diving heuristic that chooses fixings w.r.t. the active constraints |
| objpscostdiving | o | -1004000 | 20 | 4 | LP diving heuristic that changes variable's objective values instead of bounds, using pseudo costs as guide |
| rootsoldiving | o | -1005000 | 20 | 5 | LP diving heuristic that changes variable's objective values using root LP solution as guide |
| linesearchdiving | d | -1006000 | 10 | 6 | LP diving heuristic that chooses fixings following the line from root solution to current solution |
| guideddiving | d | -1007000 | 10 | 7 | LP diving heuristic that chooses fixings in direction of incumbent solutions |
| octane | r | -1008000 | -1 | 0 | octane primal heuristic for pure {0;1}-problems based on Balas et al. |
| rens | L | -1100000 | 0 | 0 | LNS exploring fractional neighborhood of relaxation's optimum |
| alns | L | -1100500 | 20 | 0 | Large neighborhood search heuristic that orchestrates the popular neighborhoods Local Branching, RINS, RENS, DINS etc. |
| rins | L | -1101000 | 25 | 0 | relaxation induced neighborhood search by Danna, Rothberg, and Le Pape |
| localbranching | L | -1102000 | -1 | 0 | local branching heuristic by Fischetti and Lodi |
| trustregion | L | -1102000 | -1 | 0 | LNS heuristic for Benders' decomposition based on trust region methods |
| gins | L | -1103000 | 20 | 8 | gins works on k-neighborhood in a variable-constraint graph |
| mutation | L | -1103000 | -1 | 8 | mutation heuristic randomly fixing variables |
| lpface | L | -1104000 | 15 | 0 | LNS heuristic that searches the optimal LP face inside a sub-MIP |
| crossover | L | -1104000 | 30 | 0 | LNS heuristic that fixes all variables that are identic in a couple of solutions |
| dins | L | -1105000 | -1 | 0 | distance induced neighborhood search by Ghosh |
| bound | p | -1107000 | -1 | 0 | heuristic which fixes all integer variables to a bound and solves the remaining LP |
| undercover | L | -1110000 | 0 | 0 | solves a sub-CIP determined by a set covering approach |
| proximity | L | -2000000 | -1 | 0 | heuristic trying to improve the incumbent by an auxiliary proximity objective function |
| subnlp | L | -2000000 | 1 | 0 | primal heuristic that performs a local search in an NLP after fixing integer variables and presolving |
| mpec | d | -2050000 | 50 | 0 | regularization heuristic for convex and nonconvex MINLPs |
| multistart | L | -2100000 | 0 | 0 | multistart heuristic for convex and nonconvex MINLPs |
| trysol | t | -3000000 | 1 | 0 | try solution heuristic |
See https://www.scipopt.org/doc/html/HEUR.php for a detailed description of the primal heuristic properties.
Propagators
| propagator | propprio | freq | presolveprio | presolvetiming | description |
| rootredcost | 10000000 | 1 | 0 | always | reduced cost strengthening using root node reduced costs and the cutoff bound |
| dualfix | 8000000 | 0 | 8000000 | fast | roundable variables dual fixing |
| genvbounds | 3000000 | 1 | -2000000 | fast | generalized variable bounds propagator |
| vbounds | 3000000 | 1 | -90000 | medium exhaustive | propagates variable upper and lower bounds |
| pseudoobj | 3000000 | 1 | 6000000 | fast | pseudo objective function propagator |
| redcost | 1000000 | 1 | 0 | always | reduced cost strengthening propagator |
| probing | -100000d | -1 | -100000 | exhaustive | probing propagator on binary variables |
| symmetry | -1000000 | 1 | -10000000 | exhaustive | propagator for handling symmetry |
| obbt | -1000000d | 0 | 0 | always | optimization-based bound tightening propagator |
| nlobbt | -1100000d | -1 | 0 | always | propagator template |
See https://www.scipopt.org/doc/html/PROP.php for a detailed description of the propagator properties.
Separators
| separator | priority | freq | bounddist | description |
| closecuts | 1000000 | -1 | 1 | closecuts meta separator |
| disjunctive | 10d | 0 | 0 | disjunctive cut separator |
| convexproj | 0d | -1 | 1 | separate at projection of point onto convex region |
| gauge | 0 | -1 | 1 | gauge separator |
| impliedbounds | -50 | 10 | 1 | implied bounds separator |
| intobj | -100 | -1 | 0 | integer objective value separator |
| cgmip | -1000 | -1 | 0 | Chvatal-Gomory cuts via MIPs separator |
| gomory | -1000 | 10 | 1 | Gomory MIR cuts separator |
| strongcg | -2000 | 10 | 1 | Strong CG cuts separator (Letchford and Lodi) |
| aggregation | -3000 | 10 | 1 | aggregation heuristic for complemented mixed integer rounding cuts and flowcover cuts |
| clique | -5000 | 0 | 0 | clique separator of stable set relaxation |
| zerohalf | -6000 | 10 | 1 | {0,1/2}-cuts separator |
| mcf | -10000 | 0 | 0 | multi-commodity-flow network cut separator |
| eccuts | -13000 | -1 | 1 | separator for edge-concave functions |
| oddcycle | -15000 | -1 | 1 | odd cycle separator |
| flowcover | -100000 | 10 | 0 | separator for flowcover cuts |
| cmir | -100000 | 10 | 0 | separator for cmir cuts |
| rapidlearning | -1200000 | 5 | 1 | rapid learning heuristic and separator |
See https://www.scipopt.org/doc/html/SEPA.php for a detailed description of the separator properties.
List of SCIP Options
SCIP supports a large set of options. In the following, we give a detailed list of all SCIP options.
gams
| Option | Description | Default |
| gams/dumpsolutions | name of solutions index gdx file for writing all alternate solutions
Range: string | |
| gams/dumpsolutionsmerged | name of gdx file for writing all alternate solutions into a single file
Range: string | |
| gams/indicatorfile | name of GAMS options file that contains definitions on indicators
Range: string | |
| gams/interactive | command to be issued to the SCIP shell instead of issuing a solve command
Range: string | |
| gams/mipstart | how to handle initial variable levels, see also section Starting point
Range: {0, ..., 4} | 2 |
| gams/resolvenlp | whether to resolve MINLP with fixed discrete variables if best solution violates some constraints
Range: boolean | 1 |
gams/solvetrace
| Option | Description | Default |
| gams/solvetrace/file | name of file where to write branch-and-bound trace information too
Range: string | |
| gams/solvetrace/nodefreq | frequency in number of nodes when to write branch-and-bound trace information, 0 to disable
Range: {0, ..., ∞} | 100 |
| gams/solvetrace/timefreq | frequency in seconds when to write branch-and-bound trace information, 0.0 to disable
Range: [0, ∞] | 5 |
branching
| Option | Description | Default |
| branching/checksol | should LP solutions during strong branching with propagation be checked for feasibility?
Range: boolean | 1 |
| 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/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/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 |
| 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/onlyactiverows | should only rows which are active at the current node be considered?
Range: boolean | 0 |
| branching/distribution/priority | priority of branching rule <distribution>
Range: {-536870912, ..., 536870911} | 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/forcestrongbranch | should strong branching be applied even if there is just a single candidate?
Range: boolean | 0 |
| 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/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/priority | priority of branching rule <fullstrong>
Range: {-536870912, ..., 536870911} | 0 |
| 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/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/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/reliablescore | weight in score calculations for conflict score
Range: [0, ∞] | 0.001 |
| branching/inference/useweightedsum | should a weighted sum of inference, conflict and cutoff weights be used?
Range: boolean | 1 |
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/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/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/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/priority | priority of branching rule <lookahead>
Range: {-536870912, ..., 536870911} | 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/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/priority | priority of branching rule <multaggr>
Range: {-536870912, ..., 536870911} | 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/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/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 |
| 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/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/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/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/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/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/priority | priority of branching rule <relpscost>
Range: {-536870912, ..., 536870911} | 10000 |
| 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/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 |
| 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/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/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 |
| 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/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/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 |
| 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/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/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/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/enable | should conflict analysis be enabled?
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/preferbinary | should binary conflicts be preferred?
Range: boolean | 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/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/scorefac | factor to decrease importance of variables' earlier conflict scores
Range: [1e-06, 1] | 0.98 |
| conflict/sepaaltproofs | apply cut generating functions to construct alternative proofs
Range: boolean | 0 |
| 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/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/uselocalrows | use local rows to construct infeasibility proofs
Range: boolean | 1 |
| 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 |
| 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 |
| conflict/bounddisjunction/priority | priority of conflict handler <bounddisjunction>
Range: {-2147483648, ..., ∞} | -3000000 |
conflict/graph
| Option | Description | Default |
| conflict/graph/depthscorefac | score factor for depth level in bound relaxation heuristic
Range: real | 1 |
conflict/indicatorconflict
| Option | Description | Default |
| conflict/indicatorconflict/priority | priority of conflict handler <indicatorconflict>
Range: {-2147483648, ..., ∞} | 200000 |
conflict/linear
| Option | Description | Default |
| conflict/linear/priority | priority of conflict handler <linear>
Range: {-2147483648, ..., ∞} | -1000000 |
conflict/logicor
| Option | Description | Default |
| conflict/logicor/priority | priority of conflict handler <logicor>
Range: {-2147483648, ..., ∞} | 800000 |
conflict/setppc
| Option | Description | Default |
| conflict/setppc/priority | priority of conflict handler <setppc>
Range: {-2147483648, ..., ∞} | 700000 |
constraints
| Option | Description | Default |
| 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/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/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/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/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 1 |
| constraints/SOS1/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
| constraints/SOS1/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 10 |
| 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/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/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 1 |
| constraints/SOS2/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
| constraints/SOS2/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 0 |
constraints/abspower
| Option | Description | Default |
| constraints/abspower/addvarboundcons | should variable bound constraints be added for derived variable bounds?
Range: boolean | 1 |
| constraints/abspower/branchminconverror | whether to compute branching point such that the convexification error is minimized (after branching on 0.0)
Range: boolean | 0 |
| constraints/abspower/cutmaxrange | maximal coef range of a cut (maximal coefficient divided by minimal coefficient) in order to be added to LP relaxation
Range: [0, ∞] | 1e+07 |
| constraints/abspower/delayprop | should propagation method be delayed, if other propagators found reductions?
Range: boolean | 0 |
| constraints/abspower/delaysepa | should separation method be delayed, if other separators found cuts?
Range: boolean | 0 |
| constraints/abspower/dualpresolve | should dual presolve be applied?
Range: boolean | 1 |
| constraints/abspower/eagerfreq | frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534} | 100 |
| constraints/abspower/enfocutsremovable | are cuts added during enforcement removable from the LP in the same node?
Range: boolean | 0 |
| constraints/abspower/linfeasshift | whether to try to make solutions in check function feasible by shifting the linear variable z
Range: boolean | 1 |
| constraints/abspower/maxprerounds | maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| constraints/abspower/preferzerobranch | how much to prefer branching on 0.0 when sign of variable is not fixed yet: 0 no preference, 1 prefer if LP solution will be cutoff in both child nodes, 2 prefer always, 3 ensure always
Range: {0, ..., 3} | 1 |
| constraints/abspower/presoltiming | timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 12 |
| constraints/abspower/projectrefpoint | whether to project the reference point when linearizing an absolute power constraint in a convex region
Range: boolean | 1 |
| constraints/abspower/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 1 |
| constraints/abspower/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 15 |
| constraints/abspower/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 1 |
| constraints/abspower/sepainboundsonly | whether to separate linearization cuts only in the variable bounds (does not affect enforcement)
Range: boolean | 0 |
| constraints/abspower/sepanlpmincont | minimal required fraction of continuous variables in problem to use solution of NLP relaxation in root for separation
Range: [0, 2] | 1 |
constraints/and
| Option | Description | Default |
| 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/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 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/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 1 |
| constraints/and/upgraderesultant | should all binary resultant variables be upgraded to implicit binary variables?
Range: boolean | 1 |
constraints/bivariate
| Option | Description | Default |
| constraints/bivariate/cutmaxrange | maximal coef range of a cut (maximal coefficient divided by minimal coefficient) in order to be added to LP relaxation
Range: [0, ∞] | 1e+07 |
| constraints/bivariate/delayprop | should propagation method be delayed, if other propagators found reductions?
Range: boolean | 0 |
| constraints/bivariate/delaysepa | should separation method be delayed, if other separators found cuts?
Range: boolean | 0 |
| constraints/bivariate/eagerfreq | frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534} | 100 |
| constraints/bivariate/enfocutsremovable | are cuts added during enforcement removable from the LP in the same node?
Range: boolean | 0 |
| constraints/bivariate/linfeasshift | whether to try to make solutions in check function feasible by shifting a linear variable (esp. useful if constraint was actually objective function)
Range: boolean | 1 |
| constraints/bivariate/maxprerounds | maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| constraints/bivariate/maxproprounds | limit on number of propagation rounds for a single constraint within one round of SCIP propagation
Range: {0, ..., ∞} | 1 |
| constraints/bivariate/ninitlprefpoints | number of reference points in each direction where to compute linear support for envelope in LP initialization
Range: {0, ..., ∞} | 3 |
| constraints/bivariate/presoltiming | timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 4 |
| constraints/bivariate/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 1 |
| constraints/bivariate/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
| constraints/bivariate/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 1 |
constraints/bounddisjunction
| Option | Description | Default |
| 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/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 1 |
| constraints/bounddisjunction/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
| constraints/bounddisjunction/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | -1 |
constraints/components
| Option | Description | Default |
| 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/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/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/nodelimit | maximum number of nodes to be solved in subproblems during presolving
Range: {-1, ..., ∞} | 10000 |
| 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/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 1 |
| constraints/components/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
| constraints/components/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | -1 |
constraints/indicator
| Option | Description | Default |
| 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/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/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/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 1 |
| 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/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 10 |
| 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/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/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | -1 |
| constraints/integral/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
| constraints/integral/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | -1 |
constraints/knapsack
| Option | Description | Default |
| 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/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/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/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 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/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 0 |
| 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/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/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/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/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 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/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 |
| 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/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/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 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/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 0 |
| 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 nonlinear functions in inequalities (≤) are convex (disables reformulation)
Range: boolean | 0 |
| constraints/nonlinear/cutmaxrange | maximal coef range of a cut (maximal coefficient divided by minimal coefficient) in order to be added to LP relaxation
Range: [0, ∞] | 1e+07 |
| constraints/nonlinear/delayprop | should propagation method be delayed, if other propagators found reductions?
Range: boolean | 0 |
| constraints/nonlinear/delaysepa | should separation method be delayed, if other separators found cuts?
Range: boolean | 0 |
| constraints/nonlinear/eagerfreq | frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534} | 100 |
| constraints/nonlinear/enfocutsremovable | are cuts added during enforcement removable from the LP in the same node?
Range: boolean | 0 |
| constraints/nonlinear/linfeasshift | whether to try to make solutions in check function feasible by shifting a linear variable (esp. useful if constraint was actually objective function)
Range: boolean | 1 |
| constraints/nonlinear/maxexpansionexponent | maximal exponent where still expanding non-monomial polynomials in expression simplification
Range: {1, ..., ∞} | 2 |
| constraints/nonlinear/maxprerounds | maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| constraints/nonlinear/maxproprounds | limit on number of propagation rounds for a single constraint within one round of SCIP propagation
Range: {0, ..., ∞} | 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/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 1 |
| constraints/nonlinear/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
| constraints/nonlinear/reformulate | whether to reformulate expression graph
Range: boolean | 1 |
| constraints/nonlinear/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 1 |
| constraints/nonlinear/sepanlpmincont | minimal required fraction of continuous variables in problem to use solution of NLP relaxation in root for separation
Range: [0, 2] | 1 |
constraints/nonlinear/upgrade
| Option | Description | Default |
| constraints/nonlinear/upgrade/abspower | enable nonlinear upgrading for constraint handler <abspower>
Range: boolean | 1 |
| constraints/nonlinear/upgrade/and | enable nonlinear upgrading for constraint handler <and>
Range: boolean | 1 |
| constraints/nonlinear/upgrade/bivariate | enable nonlinear upgrading for constraint handler <bivariate>
Range: boolean | 0 |
| constraints/nonlinear/upgrade/linear | enable nonlinear upgrading for constraint handler <linear>
Range: boolean | 1 |
| constraints/nonlinear/upgrade/quadratic | enable nonlinear upgrading for constraint handler <quadratic>
Range: boolean | 1 |
constraints/orbisack
| Option | Description | Default |
| constraints/orbisack/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/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 5 |
| constraints/orbisack/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
| constraints/orbisack/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 5 |
constraints/orbitope
| Option | Description | Default |
| 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/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 1 |
| constraints/orbitope/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
| constraints/orbitope/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | -1 |
| constraints/orbitope/sepafullorbitope | Whether we separate inequalities for full orbitopes?
Range: boolean | 0 |
| constraints/orbitope/usedynamicprop | Whether we use a dynamic version of the propagation routine.
Range: boolean | 1 |
constraints/quadratic
| Option | Description | Default |
| constraints/quadratic/bilinineqmaxseparounds | maximum number of separation rounds to use linear inequalities for the bilinear term relaxation in a local node
Range: {0, ..., ∞} | 3 |
| constraints/quadratic/binreformbinaryonly | whether to consider only binary variables when replacing products with binary variables
Range: boolean | 1 |
| constraints/quadratic/binreforminitial | whether to make non-varbound linear constraints added due to replacing products with binary variables initial
Range: boolean | 0 |
| constraints/quadratic/binreformmaxcoef | limit (as factor on 1/feastol) on coefficients and coef. range in linear constraints created when replacing products with binary variables
Range: [0, ∞] | 0.0001 |
| constraints/quadratic/branchscoring | which score to give branching candidates: convexification 'g'ap, constraint 'v'iolation, 'c'entrality of variable value in domain
Range: c, g, v | g |
| constraints/quadratic/checkcurvature | whether multivariate quadratic functions should be checked for convexity/concavity
Range: boolean | 1 |
| constraints/quadratic/checkfactorable | whether constraint functions should be checked to be factorable
Range: boolean | 1 |
| constraints/quadratic/checkquadvarlocks | whether quadratic variables contained in a single constraint should be forced to be at their lower or upper bounds ('d'isable, change 't'ype, add 'b'ound disjunction)
Range: b, d, t | t |
| constraints/quadratic/cutmaxrange | maximal coef range of a cut (maximal coefficient divided by minimal coefficient) in order to be added to LP relaxation
Range: [0, ∞] | 1e+07 |
| constraints/quadratic/delayprop | should propagation method be delayed, if other propagators found reductions?
Range: boolean | 0 |
| constraints/quadratic/delaysepa | should separation method be delayed, if other separators found cuts?
Range: boolean | 0 |
| constraints/quadratic/disaggrmergemethod | strategy how to merge independent blocks to reach maxdisaggrsize limit (keep 'b'iggest blocks and merge others; keep 's'mallest blocks and merge other; merge small blocks into bigger blocks to reach 'm'ean sizes)
Range: b, m, s | m |
| constraints/quadratic/eagerfreq | frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534} | 100 |
| constraints/quadratic/empathy4and | empathy level for using the AND constraint handler: 0 always avoid using AND; 1 use AND sometimes; 2 use AND as often as possible
Range: {0, ..., 2} | 2 |
| constraints/quadratic/enfocutsremovable | are cuts added during enforcement removable from the LP in the same node?
Range: boolean | 0 |
| constraints/quadratic/enfolplimit | maximum number of enforcement rounds before declaring the LP relaxation infeasible (-1: no limit); WARNING: changing this parameter might lead to incorrect results!
Range: {-1, ..., ∞} | -1 |
| constraints/quadratic/gaugecuts | should convex quadratics generated strong cuts via gauge function?
Range: boolean | 0 |
| constraints/quadratic/interiorcomputation | how the interior point for gauge cuts should be computed: 'a'ny point per constraint, 'm'ost interior per constraint
Range: a, m | a |
| constraints/quadratic/linearizeheursol | whether linearizations of convex quadratic constraints should be added to cutpool in a solution found by some heuristic
Range: boolean | 1 |
| constraints/quadratic/linfeasshift | whether to try to make solutions in check function feasible by shifting a linear variable (esp. useful if constraint was actually objective function)
Range: boolean | 1 |
| constraints/quadratic/maxdisaggrsize | maximum number of created constraints when disaggregating a quadratic constraint (≤ 1: off)
Range: {1, ..., ∞} | 1 |
| constraints/quadratic/maxprerounds | maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| constraints/quadratic/maxproprounds | limit on number of propagation rounds for a single constraint within one round of SCIP propagation during solve
Range: {0, ..., ∞} | 1 |
| constraints/quadratic/maxproproundspresolve | limit on number of propagation rounds for a single constraint within one round of SCIP presolve
Range: {0, ..., ∞} | 10 |
| constraints/quadratic/mincurvcollectbilinterms | minimal curvature of constraints to be considered when returning bilinear terms to other plugins
Range: real | 0.8 |
| constraints/quadratic/minscorebilinterms | minimal required score in order to use linear inequalities for tighter bilinear relaxations
Range: [0, 1] | 0.01 |
| constraints/quadratic/presoltiming | timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 28 |
| constraints/quadratic/projectedcuts | should convex quadratics generated strong cuts via projections?
Range: boolean | 0 |
| constraints/quadratic/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 1 |
| constraints/quadratic/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
| constraints/quadratic/replacebinaryprod | max. length of linear term which when multiplied with a binary variables is replaced by an auxiliary variable and a linear reformulation (0 to turn off)
Range: {0, ..., ∞} | ∞ |
| constraints/quadratic/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 1 |
| constraints/quadratic/sepanlpmincont | minimal required fraction of continuous variables in problem to use solution of NLP relaxation in root for separation
Range: [0, 2] | 1 |
| constraints/quadratic/usebilinineqbranch | should linear inequalities be consindered when computing the branching scores for bilinear terms?
Range: boolean | 0 |
constraints/quadratic/upgrade
| Option | Description | Default |
| constraints/quadratic/upgrade/abspower | enable quadratic upgrading for constraint handler <abspower>
Range: boolean | 1 |
| constraints/quadratic/upgrade/bivariate | enable quadratic upgrading for constraint handler <bivariate>
Range: boolean | 0 |
| constraints/quadratic/upgrade/bounddisjunction | enable quadratic upgrading for constraint handler <bounddisjunction>
Range: boolean | 1 |
| constraints/quadratic/upgrade/linear | enable quadratic upgrading for constraint handler <linear>
Range: boolean | 1 |
| constraints/quadratic/upgrade/setppc | enable quadratic upgrading for constraint handler <setppc>
Range: boolean | 1 |
| constraints/quadratic/upgrade/soc | enable quadratic upgrading for constraint handler <soc>
Range: boolean | 1 |
constraints/setppc
| Option | Description | Default |
| constraints/setppc/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/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 1 |
| constraints/setppc/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
| constraints/setppc/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 0 |
constraints/soc
| Option | Description | Default |
| constraints/soc/delayprop | should propagation method be delayed, if other propagators found reductions?
Range: boolean | 0 |
| constraints/soc/delaysepa | should separation method be delayed, if other separators found cuts?
Range: boolean | 0 |
| constraints/soc/disaggregate | try to completely disaggregate soc?
Range: boolean | 1 |
| constraints/soc/eagerfreq | frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 65534} | 100 |
| constraints/soc/enfocutsremovable | are cuts added during enforcement removable from the LP in the same node?
Range: boolean | 0 |
| constraints/soc/generalsocupgrade | try to upgrade more general quadratics to soc?
Range: boolean | 1 |
| constraints/soc/glineur | whether the Glineur Outer Approximation should be used instead of Ben-Tal Nemirovski
Range: boolean | 1 |
| constraints/soc/linfeasshift | whether to try to make solutions feasible in check by shifting the variable on the right hand side
Range: boolean | 1 |
| constraints/soc/maxprerounds | maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| constraints/soc/nauxvars | number of auxiliary variables to use when creating a linear outer approx. of a SOC3 constraint; 0 to turn off
Range: {0, ..., ∞} | 0 |
| constraints/soc/nlpform | which formulation to use when adding a SOC constraint to the NLP (a: automatic, q: nonconvex quadratic form, s: convex sqrt form, e: convex exponential-sqrt form, d: convex division form)
Range: a, q, s, e, d | a |
| constraints/soc/presoltiming | timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 28 |
| constraints/soc/projectpoint | whether the reference point of a cut should be projected onto the feasible set of the SOC constraint
Range: boolean | 0 |
| constraints/soc/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 1 |
| constraints/soc/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
| constraints/soc/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 1 |
| constraints/soc/sepanlpmincont | minimal required fraction of continuous variables in problem to use solution of NLP relaxation in root for separation
Range: [0, 2] | 1 |
| constraints/soc/sparsify | whether to sparsify cuts
Range: boolean | 0 |
| constraints/soc/sparsifymaxloss | maximal loss in cut efficacy by sparsification
Range: [0, 1] | 0.2 |
| constraints/soc/sparsifynzgrowth | growth rate of maximal allowed nonzeros in cuts in sparsification
Range: [1, ∞] | 1.3 |
constraints/symresack
| Option | Description | Default |
| constraints/symresack/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/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 5 |
| constraints/symresack/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
| constraints/symresack/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 5 |
constraints/varbound
| Option | Description | Default |
| 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/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 1 |
| constraints/varbound/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 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 |
decomposition
| Option | Description | Default |
| decomposition/maxgraphedge | maximum number of edges in block graph computation, or -1 for no limit
Range: {-1, ..., ∞} | 10000 |
display
| Option | Description | Default |
| display/allviols | display all violations for a given start solution / the best solution after the solving process?
Range: boolean | 0 |
| display/freq | frequency for displaying node information lines
Range: {-1, ..., ∞} | 100 |
| display/headerfreq | frequency for displaying header lines (every n'th node information line)
Range: {-1, ..., ∞} | 15 |
| display/lpinfo | should the LP solver display status messages?
Range: boolean | 0 |
| display/relevantstats | should the relevant statistics be displayed at the end of solving?
Range: boolean | 1 |
| display/statistics | whether to print statistics on a solve and a provided decomposition
Range: boolean | 0 |
| display/verblevel | verbosity level of output
Range: {0, ..., 5} | 4 |
| display/width | maximal number of characters in a node information line
Range: {0, ..., ∞} | 143 (80 for Windows without IDE) |
display/avgdualbound
| Option | Description | Default |
| display/avgdualbound/active | display activation status of display column <avgdualbound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/completed
| Option | Description | Default |
| display/completed/active | display activation status of display column <completed> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/concdualbound
| Option | Description | Default |
| display/concdualbound/active | display activation status of display column <concdualbound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/concgap
| Option | Description | Default |
| display/concgap/active | display activation status of display column <concgap> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/concmemused
| Option | Description | Default |
| display/concmemused/active | display activation status of display column <concmemused> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/concprimalbound
| Option | Description | Default |
| display/concprimalbound/active | display activation status of display column <concprimalbound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/concsolfound
| Option | Description | Default |
| display/concsolfound/active | display activation status of display column <concsolfound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/conflicts
| Option | Description | Default |
| display/conflicts/active | display activation status of display column <conflicts> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/conss
| Option | Description | Default |
| display/conss/active | display activation status of display column <conss> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/curcols
| Option | Description | Default |
| display/curcols/active | display activation status of display column <curcols> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/curconss
| Option | Description | Default |
| display/curconss/active | display activation status of display column <curconss> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/curdualbound
| Option | Description | Default |
| display/curdualbound/active | display activation status of display column <curdualbound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/currows
| Option | Description | Default |
| display/currows/active | display activation status of display column <currows> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/cutoffbound
| Option | Description | Default |
| display/cutoffbound/active | display activation status of display column <cutoffbound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/cuts
| Option | Description | Default |
| display/cuts/active | display activation status of display column <cuts> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/depth
| Option | Description | Default |
| display/depth/active | display activation status of display column <depth> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/dualbound
| Option | Description | Default |
| display/dualbound/active | display activation status of display column <dualbound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/estimate
| Option | Description | Default |
| display/estimate/active | display activation status of display column <estimate> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/feasST
| Option | Description | Default |
| display/feasST/active | display activation status of display column <feasST> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 0 |
display/gap
| Option | Description | Default |
| display/gap/active | display activation status of display column <gap> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/lpavgiterations
| Option | Description | Default |
| display/lpavgiterations/active | display activation status of display column <lpavgiterations> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 (0 for Windows without IDE) |
display/lpcond
| Option | Description | Default |
| display/lpcond/active | display activation status of display column <lpcond> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/lpiterations
| Option | Description | Default |
| display/lpiterations/active | display activation status of display column <lpiterations> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/lpobj
| Option | Description | Default |
| display/lpobj/active | display activation status of display column <lpobj> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/maxdepth
| Option | Description | Default |
| display/maxdepth/active | display activation status of display column <maxdepth> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 (0 for Windows without IDE) |
display/memtotal
| Option | Description | Default |
| display/memtotal/active | display activation status of display column <memtotal> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/memused
| Option | Description | Default |
| display/memused/active | display activation status of display column <memused> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/nexternbranchcands
| Option | Description | Default |
| display/nexternbranchcands/active | display activation status of display column <nexternbranchcands> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 (2 for nonlinear instances) |
display/nfrac
| Option | Description | Default |
| display/nfrac/active | display activation status of display column <nfrac> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 (2 if discrete variables) |
display/ninfeasleaves
| Option | Description | Default |
| display/ninfeasleaves/active | display activation status of display column <ninfeasleaves> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/nnodes
| Option | Description | Default |
| display/nnodes/active | display activation status of display column <nnodes> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/nnodesbelowinc
| Option | Description | Default |
| display/nnodesbelowinc/active | display activation status of display column <nnodesbelowinc> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 0 |
display/nobjleaves
| Option | Description | Default |
| display/nobjleaves/active | display activation status of display column <nobjleaves> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/nodesleft
| Option | Description | Default |
| display/nodesleft/active | display activation status of display column <nodesleft> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/nrank1nodes
| Option | Description | Default |
| display/nrank1nodes/active | display activation status of display column <nrank1nodes> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 0 |
display/nsols
| Option | Description | Default |
| display/nsols/active | display activation status of display column <nsols> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/plungedepth
| Option | Description | Default |
| display/plungedepth/active | display activation status of display column <plungedepth> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/poolsize
| Option | Description | Default |
| display/poolsize/active | display activation status of display column <poolsize> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/primalbound
| Option | Description | Default |
| display/primalbound/active | display activation status of display column <primalbound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/primalgap
| Option | Description | Default |
| display/primalgap/active | display activation status of display column <primalgap> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 0 |
display/pseudoobj
| Option | Description | Default |
| display/pseudoobj/active | display activation status of display column <pseudoobj> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/separounds
| Option | Description | Default |
| display/separounds/active | display activation status of display column <separounds> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/solfound
| Option | Description | Default |
| display/solfound/active | display activation status of display column <solfound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/sols
| Option | Description | Default |
| display/sols/active | display activation status of display column <sols> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 0 |
display/strongbranchs
| Option | Description | Default |
| display/strongbranchs/active | display activation status of display column <strongbranchs> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/time
| Option | Description | Default |
| display/time/active | display activation status of display column <time> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 (2 for Windows without IDE) |
display/vars
| Option | Description | Default |
| display/vars/active | display activation status of display column <vars> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
estimation
| Option | Description | Default |
| estimation/coefmonossg | coefficient of 1 - SSG in monotone approximation of search completion
Range: [0, 1] | 0.6333 |
| estimation/coefmonoweight | coefficient of tree weight in monotone approximation of search completion
Range: [0, 1] | 0.3667 |
| estimation/completiontype | approximation of search tree completion: (a)uto, (g)ap, tree (w)eight, (m)onotone regression, (r)egression forest, (s)sg
Range: a, g, m, r, s, w | a |
| estimation/method | tree size estimation method: (c)ompletion, (e)nsemble, time series forecasts on either (g)ap, (l)eaf frequency, (o)open nodes, tree (w)eight, (s)sg, or (t)ree profile or w(b)e
Range: b, c, e, g, l, o, s, t, w | w |
| estimation/regforestfilename | user regression forest in RFCSV format
Range: string | - |
| estimation/reportfreq | report frequency on estimation: -1: never, 0:always, k ≥ 1: k times evenly during search
Range: {-1, ..., 1073741823} | -1 |
| estimation/useleafts | use leaf nodes as basic observations for time series, or all nodes?
Range: boolean | 1 |
estimation/restarts
| Option | Description | Default |
| estimation/restarts/countonlyleaves | should only leaves count for the minnodes parameter?
Range: boolean | 0 |
| estimation/restarts/hitcounterlim | limit on the number of successive samples to really trigger a restart
Range: {1, ..., ∞} | 50 |
| estimation/restarts/minnodes | minimum number of nodes before restart
Range: {-1, ..., ∞} | 1000 |
| estimation/restarts/restartactpricers | whether to apply a restart when active pricers are used
Range: boolean | 0 |
| estimation/restarts/restartfactor | factor by which the estimated number of nodes should exceed the current number of nodes
Range: [1, ∞] | 50 |
| estimation/restarts/restartlimit | restart limit
Range: {-1, ..., ∞} | 1 |
| estimation/restarts/restartnonlinear | whether to apply a restart when nonlinear constraints are present
Range: boolean | 0 |
| estimation/restarts/restartpolicy | restart policy: (a)lways, (c)ompletion, (e)stimation, (n)ever
Range: a, c, e, n | e |
estimation/ssg
| Option | Description | Default |
| estimation/ssg/nmaxsubtrees | the maximum number of individual SSG subtrees; -1: no limit
Range: {-1, ..., 1073741823} | -1 |
| estimation/ssg/nminnodeslastsplit | minimum number of nodes to process between two consecutive SSG splits
Range: {0, ..., ∞} | 0 |
estimation/treeprofile
| Option | Description | Default |
| estimation/treeprofile/enabled | should the event handler collect data?
Range: boolean | 0 |
| estimation/treeprofile/minnodesperdepth | minimum average number of nodes at each depth before producing estimations
Range: [1, ∞] | 20 |
heuristics
| Option | Description | Default |
| 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/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/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/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/onlylpbranchcands | should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean | 1 |
| 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/maxdepth | maximal depth level to call primal heuristic <adaptivediving> (-1: no limit)
Range: {-1, ..., 65534} | -1 |
| 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/priority | priority of heuristic <adaptivediving>
Range: {-536870912, ..., 536870911} | -70000 |
| 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 |
| heuristics/adaptivediving/useadaptivecontext | should the heuristic use its own statistics, or shared statistics?
Range: boolean | 0 |
heuristics/alns
| Option | Description | Default |
| 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/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/gamma | weight between uniform (gamma ~ 1) and weight driven (gamma ~ 0) probability distribution for exp3
Range: [0, 1] | 0.0704146 |
| heuristics/alns/maxdepth | maximal depth level to call primal heuristic <alns> (-1: no limit)
Range: {-1, ..., 65534} | -1 |
| heuristics/alns/maxnodes | maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞} | 5000 |
| heuristics/alns/minimprovehigh | upper bound for the minimal improvement over the incumbent
Range: [0, 1] | 0.01 |
| heuristics/alns/minimprovelow | lower threshold for the minimal improvement over the incumbent
Range: [0, 1] | 0.01 |
| heuristics/alns/minnodes | minimum number of nodes required to start a sub-SCIP
Range: {0, ..., ∞} | 50 |
| heuristics/alns/nodesofs | offset added to the nodes budget
Range: {0, ..., ∞} | 500 |
| heuristics/alns/nodesquot | fraction of nodes compared to the main SCIP for budget computation
Range: [0, 1] | 0.1 |
| heuristics/alns/nsolslim | limit on the number of improving solutions in a sub-SCIP call
Range: {-1, ..., ∞} | 3 |
| heuristics/alns/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/seed | initial random seed for bandit algorithms and random decisions by neighborhoods
Range: {0, ..., ∞} | 113 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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/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/trustregion/violpenalty | the penalty for each change in the binary variables from the candidate solution
Range: [0, ∞] | 100 |
heuristics/alns/zeroobjective
| Option | Description | Default |
| 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 |
| 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/copycuts | should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean | 1 |
| 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/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/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/minnodes | minimum number of nodes required to start the subproblem
Range: {0, ..., ∞} | 500 |
| 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 |
| 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/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/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/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/onlylpbranchcands | should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean | 0 |
| heuristics/coefdiving/priority | priority of heuristic <coefdiving>
Range: {-536870912, ..., 536870911} | -1001000 |
heuristics/completesol
| Option | Description | Default |
| heuristics/completesol/addallsols | should all subproblem solutions be added to the original SCIP?
Range: boolean | 0 |
| heuristics/completesol/beforepresol | should the heuristic run before presolving?
Range: boolean | 1 |
| 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/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/lplimfac | factor by which the limit on the number of LP depends on the node limit
Range: [1, ∞] | 2 |
| heuristics/completesol/maxcontvars | maximal number of continuous variables after presolving
Range: {-1, ..., ∞} | -1 |
| heuristics/completesol/maxdepth | maximal depth level to call primal heuristic <completesol> (-1: no limit)
Range: {-1, ..., 65534} | 0 |
| heuristics/completesol/maxlpiter | maximal number of LP iterations (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| heuristics/completesol/maxnodes | maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞} | 5000 |
| 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/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/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/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/completesol/solutions | heuristic stops, if the given number of improving solutions were found (-1: no limit)
Range: {-1, ..., ∞} | 5 |
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/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/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/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/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/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/onlylpbranchcands | should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean | 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/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/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/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/minfixingrate | minimum percentage of integer variables that have to be fixed
Range: [0, 1] | 0.666 |
| 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/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 |
| 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/copycuts | if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean | 1 |
| 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/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/minfixingrate | minimum percentage of integer variables that have to be fixable
Range: [0, 1] | 0.3 |
| heuristics/dins/minimprove | factor by which dins should at least improve the incumbent
Range: [0, 1] | 0.01 |
| 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/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/solnum | number of pool-solutions to be checked for flag array update (for hard fixing of binary variables)
Range: {1, ..., ∞} | 5 |
| 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/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/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/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/onlylpbranchcands | should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean | 1 |
| heuristics/distributiondiving/priority | priority of heuristic <distributiondiving>
Range: {-536870912, ..., 536870911} | -1003300 |
| heuristics/distributiondiving/scoreparam | the score;largest 'd'ifference, 'l'owest cumulative probability,'h'ighest c.p., 'v'otes lowest c.p., votes highest c.p.('w'), 'r'evolving
Range: l, v, d, h, w, r | r |
heuristics/dualval
| Option | Description | Default |
| heuristics/dualval/dynamicdepth | says if and how the recursion depth is computed at runtime
Range: {0, ..., 1} | 0 |
| heuristics/dualval/forceimprovements | exit if objective doesn't improve
Range: boolean | 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/maxdepth | maximal depth level to call primal heuristic <dualval> (-1: no limit)
Range: {-1, ..., 65534} | -1 |
| 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/onlycheaper | add constraint to ensure that discrete vars are improving
Range: boolean | 1 |
| heuristics/dualval/onlyleaves | disable the heuristic if it was not called at a leaf of the B&B tree
Range: boolean | 0 |
| heuristics/dualval/priority | priority of heuristic <dualval>
Range: {-536870912, ..., 536870911} | 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 |
heuristics/farkasdiving
| Option | Description | Default |
| heuristics/farkasdiving/backtrack | use one level of backtracking if infeasibility is encountered?
Range: boolean | 1 |
| heuristics/farkasdiving/checkcands | should diving candidates be checked before running?
Range: boolean | 0 |
| 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/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/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/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/onlylpbranchcands | should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean | 0 |
| 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/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/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/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/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/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/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/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/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 |
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 |
| 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/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/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/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/onlylpbranchcands | should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean | 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/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/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/maxdepth | maximal depth level to call primal heuristic <gins> (-1: no limit)
Range: {-1, ..., 65534} | -1 |
| 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/maxnodes | maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞} | 5000 |
| heuristics/gins/minfixingrate | percentage of integer variables that have to be fixed
Range: [1e-06, 0.999999] | 0.66 |
| 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/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 |
| 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/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/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/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/onlylpbranchcands | should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean | 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 |
| 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/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/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 |
| 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 |
| 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/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/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/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/onlylpbranchcands | should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean | 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/copycuts | if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean | 1 |
| 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/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/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 |
| 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/copycuts | should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean | 1 |
| 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/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/minfixingrate | minimum percentage of integer variables that have to be fixable
Range: [0, 1] | 0.65 |
| 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/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/priority | priority of heuristic <locks>
Range: {-536870912, ..., 536870911} | 3000 |
| heuristics/locks/roundupprobability | probability for rounding a variable up in case of ties
Range: [0, 1] | 0.67 |
| 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/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/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/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/minfixingrate | required percentage of fixed integer variables in sub-MIP to run
Range: [0, 1] | 0.1 |
| 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/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 |
| heuristics/lpface/priority | priority of heuristic <lpface>
Range: {-536870912, ..., 536870911} | -1104000 |
| heuristics/lpface/subscipobjective | objective function in the sub-SCIP: (z)ero, (r)oot-LP-difference, (i)nference, LP (f)ractionality, (o)riginal
Range: f, o, r, z, i | z |
| heuristics/lpface/uselprows | should subproblem be created out of the rows in the LP rows?
Range: boolean | 1 |
heuristics/mpec
| Option | Description | Default |
| heuristics/mpec/freq | frequency for calling primal heuristic <mpec> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534} | 50 |
| heuristics/mpec/freqofs | frequency offset for calling primal heuristic <mpec>
Range: {0, ..., 65534} | 0 |
| heuristics/mpec/inittheta | initial regularization right-hand side value
Range: [0, 0.25] | 0.125 |
| heuristics/mpec/maxdepth | maximal depth level to call primal heuristic <mpec> (-1: no limit)
Range: {-1, ..., 65534} | -1 |
| 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/priority | priority of heuristic <mpec>
Range: {-536870912, ..., 536870911} | -2050000 |
| 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 |
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/maxdepth | maximal depth level to call primal heuristic <multistart> (-1: no limit)
Range: {-1, ..., 65534} | -1 |
| heuristics/multistart/maxiter | number of iterations to reduce the maximum violation of a point
Range: {0, ..., ∞} | 300 |
| heuristics/multistart/maxncluster | maximum number of considered clusters per heuristic call
Range: {0, ..., ∞} | 3 |
| heuristics/multistart/maxreldist | maximum distance between two points in the same cluster
Range: [0, ∞] | 0.15 |
| heuristics/multistart/minimprfac | minimum required improving factor to proceed in improvement of a single point
Range: real | 0.05 |
| heuristics/multistart/minimpriter | number of iteration when checking the minimum improvement
Range: {1, ..., ∞} | 10 |
| heuristics/multistart/nlpminimpr | factor by which heuristic should at least improve the incumbent
Range: [0, ∞] | 0 |
| heuristics/multistart/nrndpoints | number of random points generated per execution call
Range: {0, ..., ∞} | 100 |
| heuristics/multistart/onlynlps | should the heuristic run only on continuous problems?
Range: boolean | 1 |
| 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/copycuts | if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean | 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/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/minfixingrate | percentage of integer variables that have to be fixed
Range: [1e-06, 0.999999] | 0.8 |
| 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/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 |
| heuristics/mutation/nwaitingnodes | number of nodes without incumbent change that heuristic should wait
Range: {0, ..., ∞} | 200 |
| heuristics/mutation/priority | priority of heuristic <mutation>
Range: {-536870912, ..., 536870911} | -1103000 |
| heuristics/mutation/uselprows | should subproblem be created out of the rows in the LP rows?
Range: boolean | 0 |
| heuristics/mutation/useuct | should uct node selection be used at the beginning of the search?
Range: boolean | 0 |
heuristics/nlpdiving
| Option | Description | Default |
| heuristics/nlpdiving/backtrack | use one level of backtracking if infeasibility is encountered?
Range: boolean | 1 |
| heuristics/nlpdiving/fixquot | percentage of fractional variables that should be fixed before the next NLP solve
Range: [0, 1] | 0.2 |
| heuristics/nlpdiving/freq | frequency for calling primal heuristic <nlpdiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534} | 10 |
| heuristics/nlpdiving/freqofs | frequency offset for calling primal heuristic <nlpdiving>
Range: {0, ..., 65534} | 3 |
| heuristics/nlpdiving/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/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/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/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/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/prefercover | should variables in a minimal cover be preferred?
Range: boolean | 1 |
| heuristics/nlpdiving/preferlpfracs | prefer variables that are also fractional in LP solution?
Range: boolean | 0 |
| heuristics/nlpdiving/priority | priority of heuristic <nlpdiving>
Range: {-536870912, ..., 536870911} | -1003000 |
| heuristics/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 |
heuristics/objpscostdiving
| Option | Description | Default |
| 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/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/maxdepth | maximal depth level to call primal heuristic <objpscostdiving> (-1: no limit)
Range: {-1, ..., 65534} | -1 |
| 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 |
| 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/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/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 |
| 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/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/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/lplimfac | factor by which the limit on the number of LP depends on the node limit
Range: [1, ∞] | 2 |
| 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/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/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 |
| heuristics/ofins/priority | priority of heuristic <ofins>
Range: {-536870912, ..., 536870911} | 60000 |
heuristics/oneopt
| Option | Description | Default |
| 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/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 |
| 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/admiterations | maximal number of ADM iterations in each penalty loop
Range: {1, ..., 100} | 4 |
| 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/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?
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/padm/timing | should the heuristic run before or after the processing of the node? (0: before, 1: after, 2: both)
Range: {0, ..., 2} | 0 |
heuristics/proximity
| Option | Description | Default |
| heuristics/proximity/binvarquot | threshold for percentage of binary variables required to start
Range: [0, 1] | 0.1 |
| 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 |
| 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/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/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/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/onlylpbranchcands | should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean | 1 |
| 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 |
| 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/addallsols | should all subproblem solutions be added to the original SCIP?
Range: boolean | 0 |
| heuristics/rens/bestsollimit | limit on number of improving incumbent solutions in sub-CIP
Range: {-1, ..., ∞} | -1 |
| 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/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/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/minfixingrate | minimum percentage of integer variables that have to be fixable
Range: [0, 1] | 0.5 |
| 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/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/priority | priority of heuristic <rens>
Range: {-536870912, ..., 536870911} | -1100000 |
| heuristics/rens/startsol | solution that is used for fixing values ('l'p relaxation, 'n'lp relaxation)
Range: n, l | l |
| 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 |
| 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/alpha | factor for the potential of var fixings
Range: [0, 100] | 2 |
| 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/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/minfixingrate | minimum percentage of integer variables that have to be fixed
Range: [0, 1] | 0.3 |
| heuristics/repair/minnodes | minimum number of nodes required to start the subproblem
Range: {0, ..., ∞} | 50 |
| 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/priority | priority of heuristic <repair>
Range: {-536870912, ..., 536870911} | 0 |
| 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 |
heuristics/rins
| Option | Description | Default |
| heuristics/rins/copycuts | if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean | 1 |
| 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/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/minfixingrate | minimum percentage of integer variables that have to be fixed
Range: [0, 1] | 0.3 |
| 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/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 |
| 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/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/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/maxdepth | maximal depth level to call primal heuristic <rootsoldiving> (-1: no limit)
Range: {-1, ..., 65534} | -1 |
| 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 |
| 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 |
| 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/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/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 |
| 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 |
| 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 |
| heuristics/simplerounding/maxdepth | maximal depth level to call primal heuristic <simplerounding> (-1: no limit)
Range: {-1, ..., 65534} | -1 |
| heuristics/simplerounding/oncepernode | should the heuristic only be called once per node?
Range: boolean | 0 |
| heuristics/simplerounding/priority | priority of heuristic <simplerounding>
Range: {-536870912, ..., 536870911} | 0 |
heuristics/subnlp
| Option | Description | Default |
| heuristics/subnlp/forbidfixings | whether to add constraints that forbid specific fixings that turned out to be infeasible
Range: boolean | 1 |
| heuristics/subnlp/freq | frequency for calling primal heuristic <subnlp> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534} | 1 |
| heuristics/subnlp/freqofs | frequency offset for calling primal heuristic <subnlp>
Range: {0, ..., 65534} | 0 |
| heuristics/subnlp/itermin | contingent of NLP iterations in relation to the number of nodes in SCIP
Range: {0, ..., ∞} | 300 |
| heuristics/subnlp/iteroffset | number of iterations added to the contingent of the total number of iterations
Range: {0, ..., ∞} | 500 |
| heuristics/subnlp/iterquotient | contingent of NLP iterations in relation to the number of nodes in SCIP
Range: [0, ∞] | 0.1 |
| heuristics/subnlp/keepcopy | whether to keep SCIP copy or to create new copy each time heuristic is applied
Range: boolean | 1 |
| heuristics/subnlp/maxdepth | maximal depth level to call primal heuristic <subnlp> (-1: no limit)
Range: {-1, ..., 65534} | -1 |
| heuristics/subnlp/maxpresolverounds | limit on number of presolve rounds in sub-SCIP (-1 for unlimited, 0 for no presolve)
Range: {-1, ..., ∞} | -1 |
| heuristics/subnlp/minimprove | factor by which NLP heuristic should at least improve the incumbent
Range: [0, 1] | 0.01 |
| heuristics/subnlp/nlpiterlimit | iteration limit of NLP solver; 0 to use solver default
Range: {0, ..., ∞} | 0 |
| heuristics/subnlp/nlpoptfile | name of an NLP solver specific options file
Range: string | |
| heuristics/subnlp/nlptimelimit | time limit of NLP solver; 0 to use solver default
Range: [0, ∞] | 0 |
| heuristics/subnlp/nlpverblevel | verbosity level of NLP solver
Range: {0, ..., ∞} | 0 |
| heuristics/subnlp/priority | priority of heuristic <subnlp>
Range: {-536870912, ..., 536870911} | -2000000 |
| heuristics/subnlp/resolvefromscratch | should the NLP resolve be started from the original starting point or the infeasible solution?
Range: boolean | 1 |
| heuristics/subnlp/resolvetolfactor | if SCIP does not accept a NLP feasible solution, resolve NLP with feas. tolerance reduced by this factor (set to 1.0 to turn off resolve)
Range: [0, 1] | 0.001 |
| heuristics/subnlp/runalways | whether to run NLP heuristic always if starting point available (does not use iteroffset,iterquot,itermin)
Range: boolean | 0 |
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 |
| 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 |
| heuristics/trivialnegation/maxdepth | maximal depth level to call primal heuristic <trivialnegation> (-1: no limit)
Range: {-1, ..., 65534} | 0 |
| heuristics/trivialnegation/priority | priority of heuristic <trivialnegation>
Range: {-536870912, ..., 536870911} | 40000 |
heuristics/trustregion
| Option | Description | Default |
| heuristics/trustregion/bestsollimit | limit on number of improving incumbent solutions in sub-CIP
Range: {-1, ..., ∞} | 3 |
| heuristics/trustregion/copycuts | if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean | 1 |
| 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/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/minbinvars | the number of binary variables necessary to run the heuristic
Range: {1, ..., ∞} | 10 |
| heuristics/trustregion/minnodes | minimum number of nodes required to start the subproblem
Range: {0, ..., ∞} | 100 |
| 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/nwaitingnodes | number of nodes without incumbent change that heuristic should wait
Range: {0, ..., ∞} | 1 |
| heuristics/trustregion/objminimprove | the minimum absolute improvement in the objective function value
Range: [0, ∞] | 0.01 |
| heuristics/trustregion/priority | priority of heuristic <trustregion>
Range: {-536870912, ..., 536870911} | -1102000 |
| heuristics/trustregion/uselprows | should subproblem be created out of the rows in the LP rows?
Range: boolean | 0 |
| heuristics/trustregion/violpenalty | the penalty for each change in the binary variables from the candidate solution
Range: [0, ∞] | 100 |
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 |
| heuristics/trysol/maxdepth | maximal depth level to call primal heuristic <trysol> (-1: no limit)
Range: {-1, ..., 65534} | -1 |
| heuristics/trysol/priority | priority of heuristic <trysol>
Range: {-536870912, ..., 536870911} | -3000000 |
heuristics/twoopt
| Option | Description | Default |
| heuristics/twoopt/freq | frequency for calling primal heuristic <twoopt> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 65534} | -1 |
| heuristics/twoopt/freqofs | frequency offset for calling primal heuristic <twoopt>
Range: {0, ..., 65534} | 0 |
| 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/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/fixingalts | prioritized sequence of fixing values used ('l'p relaxation, 'n'lp relaxation, 'i'ncumbent solution)
Range: string | li |
| 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/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/inferenceweight | weight for inference score in fixing order
Range: real | 1 |
| heuristics/undercover/locksrounding | shall LP values for integer vars be rounded according to locks?
Range: boolean | 1 |
| heuristics/undercover/maxbacktracks | maximum number of backtracks in fix-and-propagate
Range: {0, ..., ∞} | 6 |
| heuristics/undercover/maxcoversizeconss | maximum coversize maximum coversize (as ratio to the percentage of non-affected constraints)
Range: [0, ∞] | ∞ |
| heuristics/undercover/maxcoversizevars | maximum coversize (as fraction of total number of variables)
Range: [0, 1] | 1 |
| heuristics/undercover/maxdepth | maximal depth level to call primal heuristic <undercover> (-1: no limit)
Range: {-1, ..., 65534} | -1 |
| heuristics/undercover/maxnodes | maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞} | 500 |
| heuristics/undercover/maxrecovers | maximum number of recoverings
Range: {0, ..., ∞} | 0 |
| heuristics/undercover/maxreorders | maximum number of reorderings of the fixing order
Range: {0, ..., ∞} | 1 |
| heuristics/undercover/mincoveredabs | minimum number of nonlinear constraints in the original problem
Range: {0, ..., ∞} | 5 |
| heuristics/undercover/mincoveredrel | minimum percentage of nonlinear constraints in the original problem
Range: [0, 1] | 0.15 |
| heuristics/undercover/minimprove | factor by which the heuristic should at least improve the incumbent
Range: [-1, 1] | 0 |
| heuristics/undercover/minnodes | minimum number of nodes required to start the subproblem
Range: {0, ..., ∞} | 500 |
| heuristics/undercover/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 |
| 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/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/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/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/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/minnodes | minimum number of nodes required to start the subproblem
Range: {0, ..., ∞} | 500 |
| 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 |
| 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/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/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/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/onlylpbranchcands | should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean | 0 |
| heuristics/veclendiving/priority | priority of heuristic <veclendiving>
Range: {-536870912, ..., 536870911} | -1003100 |
heuristics/zeroobj
| Option | Description | Default |
| heuristics/zeroobj/addallsols | should all subproblem solutions be added to the original SCIP?
Range: boolean | 0 |
| 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/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/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 |
| 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 |
| heuristics/zirounding/maxdepth | maximal depth level to call primal heuristic <zirounding> (-1: no limit)
Range: {-1, ..., 65534} | -1 |
| heuristics/zirounding/maxroundingloops | determines maximum number of rounding loops
Range: {-1, ..., ∞} | 2 |
| heuristics/zirounding/minstopncalls | determines the minimum number of calls before percentage-based deactivation of Zirounding is applied
Range: {1, ..., ∞} | 1000 |
| heuristics/zirounding/priority | priority of heuristic <zirounding>
Range: {-536870912, ..., 536870911} | -500 |
| heuristics/zirounding/stoppercentage | if percentage of found solutions falls below this parameter, Zirounding will be deactivated
Range: [0, 1] | 0.02 |
| heuristics/zirounding/stopziround | flag to determine if Zirounding is deactivated after a certain percentage of unsuccessful calls
Range: boolean | 1 |
history
| Option | Description | Default |
| history/allowmerge | should variable histories be merged from sub-SCIPs whenever possible?
Range: boolean | 0 |
| history/allowtransfer | should variable histories be transferred to initialize SCIP copies?
Range: boolean | 0 |
| history/valuebased | should statistics be collected for variable domain value pairs?
Range: boolean | 0 |
limits
| Option | Description | Default |
| limits/absgap | solving stops, if the absolute gap = |primalbound - dualbound| is below the given value
Range: [0, ∞] | GAMS optca |
| limits/autorestartnodes | if solve exceeds this number of nodes for the first time, an automatic restart is triggered (-1: no automatic restart)
Range: {-1, ..., ∞} | -1 |
| limits/bestsol | solving stops, if the given number of solution improvements were found (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| limits/gap | solving stops, if the relative gap = |primal - dual|/MIN(|dual|,|primal|) is below the given value, the gap is 'Infinity', if primal and dual bound have opposite signs
Range: [0, ∞] | GAMS optcr |
| limits/maxorigsol | maximal number of solutions candidates to store in the solution storage of the original problem
Range: {0, ..., ∞} | 10 |
| limits/maxsol | maximal number of solutions to store in the solution storage
Range: {1, ..., ∞} | 100 |
| limits/memory | maximal memory usage in MB; reported memory usage is lower than real memory usage!
Range: [0, 8.79609e+12] | GAMS workspace |
| limits/nodes | maximal number of nodes to process (-1: no limit)
Range: {-1, ..., ∞} | GAMS nodlim, if > 0, otherwise -1 |
| limits/restarts | solving stops, if the given number of restarts was triggered (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| limits/softtime | soft time limit which should be applied after first solution was found (-1.0: disabled)
Range: [-1, ∞] | -1 |
| limits/solutions | solving stops, if the given number of solutions were found (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| limits/stallnodes | solving stops, if the given number of nodes was processed since the last improvement of the primal solution value (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| limits/time | maximal time in seconds to run
Range: [0, ∞] | GAMS reslim |
| limits/totalnodes | maximal number of total nodes (incl. restarts) to process (-1: no limit)
Range: {-1, ..., ∞} | -1 |
lp
| Option | Description | Default |
| lp/alwaysgetduals | should the Farkas duals always be collected when an LP is found to be infeasible?
Range: boolean | 0 |
| lp/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/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/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/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/refactorinterval | LP refactorization interval (0: auto)
Range: {0, ..., ∞} | 0 |
| 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/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/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 |
| lp/threads | number of threads used for solving the LP (0: automatic)
Range: {0, ..., 64} | GAMS threads |
memory
| Option | Description | Default |
| 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/savefac | fraction of maximal memory usage resulting in switch to memory saving mode
Range: [0, 1] | 0.8 |
| memory/treegrowfac | memory growing factor for tree array
Range: [1, 10] | 2 |
| memory/treegrowinit | initial size of tree array
Range: {0, ..., ∞} | 65536 |
misc
| Option | Description | Default |
| misc/allowstrongdualreds | should strong dual reductions be allowed in propagation and presolving?
Range: boolean | 1 |
| misc/allowweakdualreds | should weak dual reductions be allowed in propagation and presolving?
Range: boolean | 1 |
| misc/calcintegral | should SCIP calculate the primal dual integral value?
Range: boolean | 1 |
| misc/catchctrlc | should the CTRL-C interrupt be caught by SCIP?
Range: boolean | 1 |
| misc/estimexternmem | should the usage of external memory be estimated?
Range: boolean | 1 |
| misc/finitesolutionstore | should SCIP try to remove infinite fixings from solutions copied to the solution store?
Range: boolean | 0 |
| misc/improvingsols | should only solutions be checked which improve the primal bound
Range: boolean | 0 |
| misc/outputorigsol | should the best solution be transformed to the orignal space and be output in command line run?
Range: boolean | 1 |
| misc/printreason | should the reason be printed if a given start solution is infeasible
Range: boolean | 0 |
| misc/referencevalue | objective value for reference purposes
Range: real | ∞ |
| misc/resetstat | should the statistics be reset if the transformed problem is freed (in case of a Benders' decomposition this parameter should be set to FALSE)
Range: boolean | 1 |
| misc/scaleobj | should the objective function be scaled so that it is always integer?
Range: boolean | 1 |
| misc/transorigsols | should SCIP try to transfer original solutions to the transformed space (after presolving)?
Range: boolean | 1 |
| misc/transsolsorig | should SCIP try to transfer transformed solutions to the original space (after solving)?
Range: boolean | 1 |
| misc/useconstable | should a hashtable be used to map from constraint names to constraints?
Range: boolean | 1 |
| misc/usesmalltables | should smaller hashtables be used? yields better performance for small problems with about 100 variables
Range: boolean | 0 |
| misc/usesymmetry | bitset describing used symmetry handling technique (0: off; 1: polyhedral (orbitopes and/or symresacks); 2: orbital fixing; 3: orbitopes and orbital fixing)
Range: {0, ..., 3} | 3 |
| misc/usevartable | should a hashtable be used to map from variable names to variables?
Range: boolean | 1 |
nodeselection
| Option | Description | Default |
| nodeselection/childsel | child selection rule ('d'own, 'u'p, 'p'seudo costs, 'i'nference, 'l'p value, 'r'oot LP value difference, 'h'ybrid inference/root LP value difference)
Range: d, u, p, i, l, r, h | h |
nodeselection/bfs
| Option | Description | Default |
| nodeselection/bfs/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/bfs/stdpriority | priority of node selection rule <bfs> in standard mode
Range: {-536870912, ..., 1073741823} | 100000 |
nodeselection/breadthfirst
| Option | Description | Default |
| nodeselection/breadthfirst/memsavepriority | priority of node selection rule <breadthfirst> in memory saving mode
Range: {-536870912, ..., 536870911} | -1000000 |
| nodeselection/breadthfirst/stdpriority | priority of node selection rule <breadthfirst> in standard mode
Range: {-536870912, ..., 1073741823} | -10000 |
nodeselection/dfs
| Option | Description | Default |
| nodeselection/dfs/memsavepriority | priority of node selection rule <dfs> in memory saving mode
Range: {-536870912, ..., 536870911} | 100000 |
| nodeselection/dfs/stdpriority | priority of node selection rule <dfs> in standard mode
Range: {-536870912, ..., 1073741823} | 0 |
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/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/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 |
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/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/hybridestim/stdpriority | priority of node selection rule <hybridestim> in standard mode
Range: {-536870912, ..., 1073741823} | 50000 |
nodeselection/restartdfs
| Option | Description | Default |
| nodeselection/restartdfs/countonlyleaves | count only leaf nodes (otherwise all nodes)?
Range: boolean | 1 |
| nodeselection/restartdfs/memsavepriority | priority of node selection rule <restartdfs> in memory saving mode
Range: {-536870912, ..., 536870911} | 50000 |
| 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 |
nodeselection/uct
| Option | Description | Default |
| 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/stdpriority | priority of node selection rule <uct> in standard mode
Range: {-536870912, ..., 1073741823} | 10 |
| 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/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/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/hugeval | values larger than this are considered huge and should be handled separately (e.g., in activity computation)
Range: [0, ∞] | 1e+15 |
| 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/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 |
| numerics/sumepsilon | absolute values of sums smaller than this are considered zero
Range: [1e-17, 0.001] | 1e-06 |
presolving
| Option | Description | Default |
| 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/maxrestarts | maximal number of restarts (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| presolving/maxrounds | maximal number of presolving rounds (-1: unlimited, 0: off)
Range: {-1, ..., ∞} | -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/flipping | is flipping allowed (multiplying with -1)?
Range: boolean | 1 |
| presolving/boundshift/integer | shift only integer ranges?
Range: boolean | 1 |
| presolving/boundshift/maxrounds | maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞} | 0 |
| 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/maxdomainsize | absolute value of maximum domain size for converting an integer variable to binaries variables
Range: {0, ..., ∞} | ∞ |
| presolving/convertinttobin/maxrounds | maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞} | 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 |
| 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 |
| 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 |
| 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/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/maxdualbndloops | maximal number of dual bound strengthening loops
Range: {-1, ..., ∞} | 12 |
| 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/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/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/dualinfer/twocolcombine | use convex combination of columns for determining dual bounds
Range: boolean | 1 |
presolving/dualsparsify
| Option | Description | Default |
| presolving/dualsparsify/enablecopy | should dualsparsify presolver be copied to sub-SCIPs?
Range: boolean | 1 |
| presolving/dualsparsify/maxbinfillin | maximal fillin for binary variables (-1: unlimited)
Range: {-1, ..., ∞} | 1 |
| presolving/dualsparsify/maxconsiderednonzeros | maximal number of considered nonzeros within one column (-1: no limit)
Range: {-1, ..., ∞} | 70 |
| 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/maxretrievefac | limit on the number of useless vs. useful hashtable retrieves as a multiple of the number of constraints
Range: [0, ∞] | 100 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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/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/hugebound | absolute bound value that is considered too huge for activitity based calculations
Range: [0, ∞] | 1e+08 |
| presolving/milp/markowitztolerance | the markowitz tolerance used for substitutions
Range: [0, 1] | 0.01 |
| presolving/milp/maxfillinpersubstitution | maximal possible fillin for substitutions to be considered
Range: {-2147483648, ..., ∞} | 3 |
| presolving/milp/maxrounds | maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| presolving/milp/maxshiftperrow | maximal amount of nonzeros allowed to be shifted to make space for substitutions
Range: {0, ..., ∞} | 10 |
| 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/priority | priority of presolver <milp>
Range: {-536870912, ..., 536870911} | 9999999 |
| presolving/milp/randomseed | the random seed used for randomization of tie breaking
Range: {-2147483648, ..., ∞} | 0 |
| presolving/milp/threads | maximum number of threads presolving may use (0: automatic)
Range: {0, ..., ∞} | GAMS threads |
| presolving/milp/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/addkktbinary | if TRUE then allow binary variables for KKT update
Range: boolean | 0 |
| presolving/qpkktref/maxrounds | maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| 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 |
| 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/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/maxbinfillin | maximal fillin for binary variables (-1: unlimited)
Range: {-1, ..., ∞} | 0 |
| presolving/sparsify/maxconsiderednonzeros | maximal number of considered non-zeros within one row (-1: no limit)
Range: {-1, ..., ∞} | 70 |
| 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/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/maxrounds | maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| 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 |
| 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 |
| 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/enablecopy | should tworowbnd presolver be copied to sub-SCIPs?
Range: boolean | 1 |
| 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 |
| 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/delay | should propagator be delayed, if other propagators found reductions?
Range: boolean | 0 |
| 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 |
| 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/delay | should propagator be delayed, if other propagators found reductions?
Range: boolean | 0 |
| propagating/genvbounds/freq | frequency for calling propagator <genvbounds> (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 1 |
| propagating/genvbounds/global | apply global propagation?
Range: boolean | 1 |
| propagating/genvbounds/maxprerounds | maximal number of presolving rounds the propagator participates in (-1: no limit)
Range: {-1, ..., ∞} | -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/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/freq | frequency for calling propagator <nlobbt> (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | -1 |
| propagating/nlobbt/itlimitfactor | LP iteration limit for nlobbt will be this factor times total LP iterations in root node
Range: [0, ∞] | 2 |
| propagating/nlobbt/maxprerounds | maximal number of presolving rounds the propagator participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| 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/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/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/createbilinineqs | solve auxiliary LPs in order to find valid inequalities for bilinear terms?
Range: boolean | 1 |
| propagating/obbt/creategenvbounds | should obbt try to provide genvbounds if possible?
Range: boolean | 1 |
| propagating/obbt/delay | should propagator be delayed, if other propagators found reductions?
Range: boolean | 1 |
| propagating/obbt/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/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/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/minfilter | minimal number of filtered bounds to apply another filter round
Range: {1, ..., ∞} | 2 |
| 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 |
| propagating/obbt/normalize | should coefficients in filtering be normalized w.r.t. the domains sizes?
Range: boolean | 1 |
| propagating/obbt/onlynonconvexvars | only apply obbt on non-convex variables
Range: boolean | 0 |
| propagating/obbt/orderingalgo | select the type of ordering algorithm which should be used (0: no special ordering, 1: greedy, 2: greedy reverse)
Range: {0, ..., 2} | 1 |
| propagating/obbt/presolpriority | presolving priority of propagator <obbt>
Range: {-536870912, ..., 536870911} | 0 |
| propagating/obbt/presoltiming | timing mask of the presolving method of propagator <obbt> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {2, ..., 60} | 28 |
| propagating/obbt/priority | priority of propagator <obbt>
Range: {-536870912, ..., 536870911} | -1000000 |
| propagating/obbt/propagatefreq | trigger a propagation round after that many bound tightenings (0: no propagation)
Range: {0, ..., ∞} | 0 |
| propagating/obbt/sepamaxiter | maximum number of iteration spend to separate an obbt LP solution
Range: {0, ..., ∞} | 10 |
| propagating/obbt/sepaminiter | minimum number of iteration spend to separate an obbt LP solution
Range: {0, ..., ∞} | 0 |
| propagating/obbt/separatesol | should the obbt LP solution be separated?
Range: boolean | 0 |
| propagating/obbt/tightcontboundsprobing | should continuous bounds be tightened during the probing mode?
Range: boolean | 0 |
| propagating/obbt/tightintboundsprobing | should integral bounds be tightened during the probing mode?
Range: boolean | 1 |
| propagating/obbt/timingmask | timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS))
Range: {1, ..., 15} | 4 |
propagating/probing
| Option | Description | Default |
| propagating/probing/delay | should propagator be delayed, if other propagators found reductions?
Range: boolean | 1 |
| propagating/probing/freq | frequency for calling propagator <probing> (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | -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/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 |
| 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/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/freq | frequency for calling propagator <pseudoobj> (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 1 |
| 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/maxprerounds | maximal number of presolving rounds the propagator participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| 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/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/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/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/redcost/useimplics | should implications be used to strength the reduced cost for binary variables?
Range: boolean | 0 |
propagating/rootredcost
| Option | Description | Default |
| 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/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 |
| 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/addconsstiming | timing of adding constraints (0 = before presolving, 1 = during presolving, 2 = after presolving)
Range: {0, ..., 2} | 2 |
| propagating/symmetry/addsymresacks | Add inequalities for symresacks for each generator?
Range: boolean | 1 |
| propagating/symmetry/checksymmetries | Should all symmetries be checked after computation?
Range: boolean | 0 |
| propagating/symmetry/compresssymmetries | Should non-affected variables be removed from permutation to save memory?
Range: boolean | 1 |
| propagating/symmetry/compressthreshold | Compression is used if percentage of moved vars is at most the threshold.
Range: [0, 1] | 0.5 |
| propagating/symmetry/conssaddlp | Should the symmetry breaking constraints be added to the LP?
Range: boolean | 1 |
| propagating/symmetry/delay | should propagator be delayed, if other propagators found reductions?
Range: boolean | 0 |
| propagating/symmetry/detectorbitopes | Should we check whether the components of the symmetry group can be handled by orbitopes?
Range: boolean | 1 |
| propagating/symmetry/disableofrestart | Shall orbital fixing be disabled if orbital fixing has found a reduction and a restart occurs?
Range: boolean | 0 |
| propagating/symmetry/displaynorbitvars | Should the number of variables affected by some symmetry be displayed?
Range: boolean | 0 |
| propagating/symmetry/doubleequations | Double equations to positive/negative version?
Range: boolean | 0 |
| propagating/symmetry/freq | frequency for calling propagator <symmetry> (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 1 |
| propagating/symmetry/maxgenerators | limit on the number of generators that should be produced within symmetry detection (0 = no limit)
Range: {0, ..., ∞} | 1500 |
| propagating/symmetry/maxprerounds | maximal number of presolving rounds the propagator participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| propagating/symmetry/ofsymcomptiming | timing of symmetry computation for orbital fixing (0 = before presolving, 1 = during presolving, 2 = at first call)
Range: {0, ..., 2} | 2 |
| propagating/symmetry/performpresolving | run orbital fixing during presolving?
Range: boolean | 0 |
| propagating/symmetry/presolpriority | presolving priority of propagator <symmetry>
Range: {-536870912, ..., 536870911} | -10000000 |
| propagating/symmetry/presoltiming | timing mask of the presolving method of propagator <symmetry> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {2, ..., 60} | 16 |
| propagating/symmetry/priority | priority of propagator <symmetry>
Range: {-536870912, ..., 536870911} | -1000000 |
| propagating/symmetry/recomputerestart | recompute symmetries after a restart has occured?
Range: boolean | 0 |
| propagating/symmetry/symfixnonbinaryvars | Whether all non-binary variables shall be not affected by symmetries if OF is active?
Range: boolean | 0 |
| propagating/symmetry/timingmask | timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS))
Range: {1, ..., 15} | 1 |
| propagating/symmetry/usecolumnsparsity | Should the number of conss a variable is contained in be exploited in symmetry detection?
Range: boolean | 0 |
propagating/vbounds
| Option | Description | Default |
| propagating/vbounds/delay | should propagator be delayed, if other propagators found reductions?
Range: boolean | 0 |
| 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/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/usebdwidening | should bound widening be used to initialize conflict analysis?
Range: boolean | 1 |
| 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/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 |
| randomization/randomseedshift | global shift of all random seeds in the plugins and the LP random seed
Range: {0, ..., ∞} | 0 |
separating
| Option | Description | Default |
| separating/cutagelimit | maximum age a cut can reach before it is deleted from the global cut pool, or -1 to keep all cuts
Range: {-1, ..., ∞} | 80 |
| separating/cutselrestart | cut selection during restart ('a'ge, activity 'q'uotient)
Range: a, q | a |
| separating/cutselsubscip | cut selection for sub SCIPs ('a'ge, activity 'q'uotient)
Range: a, q | a |
| separating/dircutoffdistfac | factor to scale directed cutoff distance of cut in score calculation
Range: [0, ∞] | 0.5 |
| separating/efficacyfac | factor to scale efficacy of cut in score calculation
Range: [0, ∞] | 0.6 |
| separating/efficacynorm | row norm to use for efficacy calculation ('e'uclidean, 'm'aximum, 's'um, 'd'iscrete)
Range: e, m, s, d | e |
| separating/intsupportfac | factor to scale integral support of cut in separation score calculation
Range: [0, ∞] | 0.1 |
| separating/maxaddrounds | maximal additional number of separation rounds in subsequent price-and-cut loops (-1: no additional restriction)
Range: {-1, ..., ∞} | 1 |
| separating/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separation (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| separating/maxcoefratio | maximal ratio between coefficients in strongcg, cmir, and flowcover cuts
Range: [1, ∞] | 10000 |
| separating/maxcuts | maximal number of cuts separated per separation round (0: disable local separation)
Range: {0, ..., ∞} | 100 |
| separating/maxcutsroot | maximal number of separated cuts at the root node (0: disable root node separation)
Range: {0, ..., ∞} | 2000 |
| separating/maxlocalbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying local separation (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 0 |
| separating/maxrounds | maximal number of separation rounds per node (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| separating/maxroundsroot | maximal number of separation rounds in the root node (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| separating/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/maxstallrounds | maximal number of consecutive separation rounds without objective or integrality improvement in local nodes (-1: no additional restriction)
Range: {-1, ..., ∞} | 1 |
| separating/maxstallroundsroot | maximal number of consecutive separation rounds without objective or integrality improvement in the root node (-1: no additional restriction)
Range: {-1, ..., ∞} | 10 |
| separating/minactivityquot | minimum cut activity quotient to convert cuts into constraints during a restart (0.0: all cuts are converted)
Range: [0, 1] | 0.8 |
| separating/minefficacy | minimal efficacy for a cut to enter the LP
Range: [0, ∞] | 0.0001 |
| separating/minefficacyroot | minimal efficacy for a cut to enter the LP in the root node
Range: [0, ∞] | 0.0001 |
| separating/minortho | minimal orthogonality for a cut to enter the LP
Range: [0, 1] | 0.9 |
| separating/minorthoroot | minimal orthogonality for a cut to enter the LP in the root node
Range: [0, 1] | 0.9 |
| separating/objparalfac | factor to scale objective parallelism of cut in separation score calculation
Range: [0, ∞] | 0.1 |
| separating/orthofunc | function used for calc. scalar prod. in orthogonality test ('e'uclidean, 'd'iscrete)
Range: e, d | e |
| separating/poolfreq | separation frequency for the global cut pool (-1: disable global cut pool, 0: only separate pool at the root)
Range: {-1, ..., 65534} | 10 |
separating/aggregation
| Option | Description | Default |
| 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/dynamiccuts | should generated cuts be removed from the LP if they are no longer tight?
Range: boolean | 1 |
| 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/freq | frequency for calling separator <aggregation> (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 10 |
| 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/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/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/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 |
| 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/cutcoefbnd | bounds on the values of the coefficients in the CG-cut
Range: [0, ∞] | 1000 |
| separating/cgmip/decisiontree | Use decision tree to turn separation on/off?
Range: boolean | 0 |
| separating/cgmip/delay | should separator be delayed, if other separators found cuts?
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/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/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/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/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/memorylimit | memory limit for sub-MIP
Range: [0, ∞] | ∞ |
| 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/objweight | weight used for the row combination coefficient in the sub-MIP objective
Range: [0, ∞] | 0.001 |
| 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/priority | priority of separator <cgmip>
Range: {-536870912, ..., 536870911} | -1000 |
| 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/timelimit | time limit for sub-MIP
Range: [0, ∞] | ∞ |
| 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 |
separating/clique
| Option | Description | Default |
| 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/freq | frequency for calling separator <clique> (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 0 |
| 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/maxsepacuts | maximal number of clique cuts separated per separation round (-1: no limit)
Range: {-1, ..., ∞} | 10 |
| 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/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/freq | frequency for calling separator <closecuts> (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | -1 |
| 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/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/freq | frequency for calling separator <cmir> (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 10 |
| 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/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/freq | frequency for calling separator <convexproj> (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | -1 |
| 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/maxdepth | maximal depth at which the separator is applied (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| separating/convexproj/nlpiterlimit | iteration limit of NLP solver; 0 for no limit
Range: {0, ..., ∞} | 250 |
| separating/convexproj/nlptimelimit | time limit of NLP solver; 0.0 for no limit
Range: [0, ∞] | 0 |
| separating/convexproj/priority | priority of separator <convexproj>
Range: {-536870912, ..., 536870911} | 0 |
separating/disjunctive
| Option | Description | Default |
| separating/disjunctive/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/freq | frequency for calling separator <disjunctive> (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 0 |
| 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/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 |
| 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/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/eccuts/dynamiccuts | should generated cuts be removed from the LP if they are no longer tight?
Range: boolean | 1 |
| 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/freq | frequency for calling separator <eccuts> (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | -1 |
| 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/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/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/minviolation | minimal violation of an edge-concave cut to be separated
Range: [0, 0.5] | 0.3 |
| separating/eccuts/priority | priority of separator <eccuts>
Range: {-536870912, ..., 536870911} | -13000 |
separating/flowcover
| Option | Description | Default |
| 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/freq | frequency for calling separator <flowcover> (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 10 |
| 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/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/freq | frequency for calling separator <gauge> (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | -1 |
| separating/gauge/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <gauge> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| separating/gauge/nlpiterlimit | iteration limit of NLP solver; 0 for no limit
Range: {0, ..., ∞} | 1000 |
| separating/gauge/nlptimelimit | time limit of NLP solver; 0.0 for no limit
Range: [0, ∞] | 0 |
| separating/gauge/priority | priority of separator <gauge>
Range: {-536870912, ..., 536870911} | 0 |
separating/gomory
| Option | Description | Default |
| separating/gomory/away | minimal integrality violation of a basis variable in order to try Gomory cut
Range: [0.0001, 0.5] | 0.01 |
| separating/gomory/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/dynamiccuts | should generated cuts be removed from the LP if they are no longer tight?
Range: boolean | 1 |
| 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/freq | frequency for calling separator <gomory> (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 10 |
| 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/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 |
| separating/gomory/priority | priority of separator <gomory>
Range: {-536870912, ..., 536870911} | -1000 |
| separating/gomory/separaterows | separate rows with integral slack
Range: boolean | 1 |
| separating/gomory/sidetypebasis | choose side types of row (lhs/rhs) based on basis information?
Range: boolean | 1 |
separating/impliedbounds
| Option | Description | Default |
| separating/impliedbounds/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/freq | frequency for calling separator <impliedbounds> (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 10 |
| separating/impliedbounds/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <impliedbounds> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| separating/impliedbounds/priority | priority of separator <impliedbounds>
Range: {-536870912, ..., 536870911} | -50 |
| separating/impliedbounds/usetwosizecliques | should violated inequalities for cliques with 2 variables be separated?
Range: boolean | 1 |
separating/intobj
| Option | Description | Default |
| separating/intobj/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/freq | frequency for calling separator <intobj> (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | -1 |
| separating/intobj/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <intobj> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 0 |
| separating/intobj/priority | priority of separator <intobj>
Range: {-536870912, ..., 536870911} | -100 |
separating/mcf
| Option | Description | Default |
| separating/mcf/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/dynamiccuts | should generated cuts be removed from the LP if they are no longer tight?
Range: boolean | 1 |
| 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/freq | frequency for calling separator <mcf> (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 0 |
| 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/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 |
| separating/mcf/maxtestdelta | maximal number of different deltas to try (-1: unlimited) – default separation
Range: {-1, ..., ∞} | 20 |
| separating/mcf/maxweightrange | maximal valid range max(|weights|)/min(|weights|) of row weights
Range: [1, ∞] | 1e+06 |
| separating/mcf/modeltype | model type of network (0: auto, 1:directed, 2:undirected)
Range: {0, ..., 2} | 0 |
| separating/mcf/nclusters | number of clusters to generate in the shrunken network – default separation
Range: {2, ..., 32} | 5 |
| separating/mcf/priority | priority of separator <mcf>
Range: {-536870912, ..., 536870911} | -10000 |
| separating/mcf/separateflowcutset | should we separate flowcutset inequalities on the network cuts?
Range: boolean | 1 |
| separating/mcf/separateknapsack | should we separate knapsack cover inequalities on the network cuts?
Range: boolean | 1 |
| separating/mcf/separatesinglenodecuts | should we separate inequalities based on single-node cuts?
Range: boolean | 1 |
| separating/mcf/trynegscaling | should negative values also be tested in scaling?
Range: boolean | 0 |
separating/oddcycle
| Option | Description | Default |
| separating/oddcycle/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/freq | frequency for calling separator <oddcycle> (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | -1 |
| separating/oddcycle/includetriangles | separate triangles found as 3-cycles or repaired larger cycles
Range: boolean | 1 |
| separating/oddcycle/liftoddcycles | Should odd cycle cuts be lifted?
Range: boolean | 0 |
| 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/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/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/oddcycle/usegls | Should the search method by Groetschel, Lovasz, Schrijver be used? Otherwise use levelgraph method by Hoffman, Padberg.
Range: boolean | 1 |
separating/rapidlearning
| Option | Description | Default |
| 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/freq | frequency for calling separator <rapidlearning> (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 5 |
| 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/strongcg
| Option | Description | Default |
| separating/strongcg/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/strongcg/dynamiccuts | should generated cuts be removed from the LP if they are no longer tight?
Range: boolean | 1 |
| 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/freq | frequency for calling separator <strongcg> (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 10 |
| 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] | 1 |
| separating/strongcg/maxrounds | maximal number of strong CG separation rounds per node (-1: unlimited)
Range: {-1, ..., ∞} | 5 |
| separating/strongcg/maxroundsroot | maximal number of strong CG separation rounds in the root node (-1: unlimited)
Range: {-1, ..., ∞} | 20 |
| separating/strongcg/maxsepacuts | maximal number of strong CG cuts separated per separation round
Range: {0, ..., ∞} | 20 |
| separating/strongcg/maxsepacutsroot | maximal number of strong CG cuts separated per separation round in the root node
Range: {0, ..., ∞} | 500 |
| separating/strongcg/priority | priority of separator <strongcg>
Range: {-536870912, ..., 536870911} | -2000 |
separating/zerohalf
| Option | Description | Default |
| 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/dynamiccuts | should generated cuts be removed from the LP if they are no longer tight?
Range: boolean | 1 |
| 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/freq | frequency for calling separator <zerohalf> (-1: never, 0: only in root node)
Range: {-1, ..., 65534} | 10 |
| 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/initseed | initial seed used for random tie-breaking in cut selection
Range: {0, ..., ∞} | 24301 |
| 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/maxcutcands | maximal number of zerohalf cuts considered per separation round
Range: {0, ..., ∞} | 2000 |
| separating/zerohalf/maxparall | maximum parallelism for non-good cuts
Range: [0, 1] | 0.1 |
| 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/maxrowdensity | maximal density of row to be used in aggregation
Range: [0, 1] | 0.05 |
| 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 |
| 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/fa |