SCIP (Solving Constraint Integer Programs) is a framework for Constraint Integer Programming oriented towards the needs of Mathematical Programming experts who want to have total control of the solution process and access detailed information down to the guts of the solver. SCIP can also be used as a pure MIP or MINLP solver or as a framework for branch-cut-and-price. Within GAMS, the MIP and MINLP solving facilities of SCIP are available.
For more detailed information, we refer to [2, 3, 73, 126, 87, 88, 74, 19, 25, 20] and the SCIP web site.
GAMS/SCIP uses CPLEX, if licensed, and otherwise SOPLEX [203] as LP solver, the COIN-OR Interior Point Optimizer IPOPT [194] as nonlinear solver, and CppAD to compute derivatives of nonlinear functions.
SCIP supports continuous, binary, integer, semi-continuous, semi-integer variables, indicator constraints, special ordered sets, and branching priorities for discrete variables.
Usage
The following statement can be used inside your GAMS program to specify using SCIP
Option MIP = SCIP; { or QCP or NLP or MIQCP or MINLP or ... }
The above statement should appear before the Solve statement. If SCIP was specified as the default solver during GAMS installation, the above statement is not necessary.
Specification of SCIP Options
GAMS/SCIP supports the GAMS parameters reslim, iterlim, nodlim, optca, optcr, and workspace. Further, the option threads can be used to control the number of threads used in the MILP presolver, the linear algebra routines (e.g., in IPOPT), and for solving LPs if CPLEX' barrier solver is used. Setting threads to 0 (the default) will enable the automatic choice of the number of threads in the MILP presolver and LP solver, but does not enable multithreading for linear algebra routines at the moment.
Options can be specified by a SCIP options file. A SCIP options file consists of one option or comment per line. A pound sign (#) at the beginning of a line causes the entire line to be ignored. Otherwise, the line will be interpreted as an option name and value separated by an equal sign (=) and any amount of white space (blanks or tabs). Further, string values have to be enclosed in quotation marks.
A small example for a scip.opt file is:
propagating/probing/maxprerounds = 0
separating/maxrounds = 0
separating/maxroundsroot = 0
It causes GAMS/SCIP to disable probing during presolve and to turn off all cut generators.
Specification of Indicators
Indicators are a modeling tool to specify that certain equations in a model must only be satisfied if certain binary variables take a specified value. Indicators are not supported by the GAMS language, but can be passed to SCIP via a separate file, see Indicator Constraints for more details on its syntax. The name of that file is specified via the option gams/indicatorfile in a SCIP option file. Currently, indicators can only be used for linear equations.
Special Features
SCIP interactive shell
The interactive shell in SCIP is a powerful tool that allows the user to display various information (e.g., branching statistics, presolved model), load emphasis settings, interrupt a solve to change parameters or trigger a restart, write the model in various file formats, start SCIPs solution counter, and many more things.
When setting the option gams/interactive to a nonempty string, the GAMS/SCIP interface opens the interactive shell of SCIP after having load the GAMS problem and parameters and passes the value of the gams/interactive parameter to the SCIP interactive shell.
By default, SCIP behaves as if gams/interactive has been set to "optimize write gamssol quit", that is, SCIP is requested to solve the problem, then to pass the solution back to GAMS, and to quit.
An example use of the SCIP interactive shell feature via GAMS is to add the following line to your SCIP options file:
gams/interactive = "write prob orig.lp presolve write transprob presol.mps opt write gamssol quit"
This instructs SCIP to write the original problem to the file orig.lp in LP format, to presolve the instance, to write the presolved problem to the file presolved.mps in MPS format, to solve the instance, to write the solution out to GAMS, and to finish.
By omitting the quit command, SCIPs interactive shell remains open and awaits user input. The command help prints a list of available commands. Note, that on Windows, GAMS need to be called with the option interactivesolver enabled to allow user input for the solver process.
A tutorial on using the SCIP shell is available at https://www.scipopt.org/doc/html/SHELL.php.
Emphasis Settings
SCIP includes various emphasis settings, which are predefined values for a set of SCIP parameters. Such predefined settings are available for setting the effort that SCIP should spend for, e.g., presolving, separation, or heuristics.
The emphasis settings are not available as single parameters, but can be set via SCIPs interactive shell. E.g., writing set heuristics emphasis in the shell displays the available emphasis settings for heuristics (aggressive, fast, off) and expects the user to input which setting to use. Further, general emphasis settings are available in the set emphasis menu, some of them giving predefined settings similar to the CPLEX option mipemphasis.
Via the gams/interactive option, c.f. Section SCIP interactive shell, emphasis settings can be activated via a SCIP options file. For example, adding the option
gams/interactive = "set emphasis feasibility set loadgams optimize write gamssol quit"
instructs SCIP to load the emphasis setting feasibility prior to optimizing the model and passing the solution back to GAMS. Note, that setting one of the emphasis settings feasibility, hardlp, and optimality resets all previously set parameters to their default values, which includes the ones that are set by the GAMS/SCIP interface or which were loaded from a SCIP options file. Therefore, the command set loadgams has been used above to restore these parameter settings.
The following emphasis settings are available in SCIP:
| shell command | purpose |
set emphasis easycip | use for easy problems |
set emphasis feasibility | emphasize finding a feasible solution |
set emphasis hardlp | use for problems with a hard LP |
set emphasis optimality | emphasize proving optimality |
set emphasis numerics | increase numerical stability |
set emphasis cpsolver | setup a constraint programming like search |
set heuristic emphasis aggressive | use primal heuristics aggressively |
set heuristic emphasis fast | use only fast primal heuristics |
set heuristic emphasis off | disable all primal heuristics |
set presolving emphasis aggressive | do aggressive presolving |
set presolving emphasis fast | use only fast presolving steps |
set presolving emphasis off | disable presolving |
set separating emphasis aggressive | use cutting plane separators aggressively |
set separating emphasis fast | use only fast cutting plane separators |
set separating emphasis off | disable all cutting plane separators |
Starting point
Using the completesol heuristic, SCIP can try to find a feasible solution based on values given by the user for all or some of the variables. The values need to be specified as variable levels in the GAMS model. The heuristic solves a copy of the problem where variables for which values have been provided are restricted to be close to that value. When an integral value is specified for a binary or integer variable, the variable is fixed to that value. See also Section 2.3.2 in [126] for a more detailed description of the heuristic.
For which variables the level values are passed from GAMS to SCIP is controlled by the parameter gams/mipstart. The parameter values have the following meaning:
- 0: do not pass any variable values to SCIP, the heuristic will not run
- 1: pass values for all binary and integer variables to SCIP and let SCIP try to find a feasible solution in its neighborhood by using the completesol heuristic
- 2 (default): pass values for all variables to SCIP and let SCIP check feasibility of the given solution, the heuristic will not run
- 3: pass values for all variables to SCIP and let SCIP try to find a feasible solution in the neighborhood by using the completesol heuristic
- 4: pass values for all binary and integer variables to SCIP which fractionality is at most the value of GAMS option tryint (thus, with default tryint=0, only for variables with integral values, the value is passed to SCIP) and let SCIP try to find a feasible solution in the neighborhood by using the completesol heuristic
Note, that the completesol heuristic will not run if there are too many variables with unknown values. This behavior can be adjusted by setting parameter heuristics/completesol/maxunknownrate.
Decomposition Information
SCIP potentially can make use of a user-provided problem decomposition, e.g., in primal heuristics PADM or GINS. Note, that SCIP's Benders Decomposition is not available with GAMS at the moment. A GAMS user can inform SCIP about such a decomposition by using the .stage variable suffix.
In an attempt to following the same convention on interpreting the .stage variable suffix as the GAMS/CPLEX link, variables which .stage suffix is set to an integral value greater than 0 are assigned to a block with this number. Variables which .stage suffix is set to a fractional value or a value smaller than 1 are assigned to no block.
Note, that the default value for the .stage suffix is 1. Therefore, GAMS/SCIP only passes decomposition information to SCIP if at least one variable has its .stage suffix set to a value different than 1. Moreover, in order to receive the .stage values, scaleOpt and priorOpt must be left at their default of 0.
Solution Pool
When SCIP solves a problem, it may find several solutions, whereof only the best one is available to the GAMS user via the variable level values in the GAMS model. If the option gams/dumpsolutions is specified, then all alternative solutions found by SCIP are written into GDX files and an index file with the name given by the this option is written. If the option gams/dumpsolutionsmerged is specified, then all alternative solutions found by SCIP are written into a single GDX file, which name is given by the this option.
The GAMS testlib model dumpsol shows an example use for this option.
Solving process tracing
The option gams/solvetrace/file can be used to specify the name of a file where information about the progress of the branch-and-bound tree search in SCIP is stored. The file is created and updated during the solution process, so it may also be used to monitor the progress of SCIP while it still solves the model.
New entries are written periodically, depending on how many nodes have been processed or how much time has been elapsed since the last entry was written. Each entry contains information on the current primal and dual bound.
Notes on solving MINLPs
SCIP includes capabilities to handle nonlinear functions that are specified via algebraic expressions. Therefore, neither external/extrinsic functions nor all GAMS mathematical functions are supported.
Nonconvex MINLPs are solved via a spatial branch-and-bound algorithm using linear relaxations. The tightness of this relaxation depends heavily on the variable bounds, thus tight bounds for the nonlinear variables are crucial for SCIP.
Convex MINLPs are much easier to solve for SCIP, provided it recognizes the convexity of the model. The convexity check implemented in SCIP may not give a conclusive answer in all cases. However, setting the option constraints/nonlinear/assumeconvex to TRUE can be used to tell SCIP that it should assume all nonlinear constraints to be of convex type. This may help to improve solving times for convex MINLPs considerably in some cases. However, it can also deteriorate performance as it prevents the use of certain extended formulations.
Another feature that can be especially useful for convex MINLPs is to enable the generation of cuts in feasible solutions, since these supporting hyperplanes can be strong. At the moment, this is only enabled for purely continuous nonlinear programs (QCPs and NLPs), but can be adjusted by parameter constraints/nonlinear/linearizeheursol. In this connection, it may also be beneficial to set separating/poolfreq to 1.
Components
In the following, we list components that are available in SCIP together with some common properties. Many of these properties can be modified with corresponding parameters.
Branching Rules
| branching rule | priority | maxdepth | maxbounddist | description |
| relpscost | 10000 | -1 | 100 | reliability branching on pseudo cost values |
| pscost | 2000 | -1 | 100 | branching on pseudo cost values |
| inference | 1000 | -1 | 100 | inference history branching |
| mostinf | 100 | -1 | 100 | most infeasible branching |
| leastinf | 50 | -1 | 100 | least infeasible branching |
| fullstrong | 0 | -1 | 100 | full strong branching |
| distribution | 0 | -1 | 100 | branching rule based on variable influence on cumulative normal distribution of row activities |
| lookahead | 0 | -1 | 100 | full strong branching over multiple levels |
| multaggr | 0 | -1 | 100 | fullstrong branching on fractional and multi-aggregated variables |
| cloud | 0 | -1 | 100 | branching rule that considers several alternative LP optima |
| allfullstrong | -1000 | -1 | 100 | all variables full strong branching |
| gomory | -1000 | -1 | 100 | Gomory cut score branching |
| vanillafullstrong | -2000 | -1 | 100 | vanilla full strong branching |
| random | -100000 | -1 | 100 | random variable branching |
| nodereopt | -9000000 | -1 | 100 | branching rule for node reoptimization |
See https://www.scipopt.org/doc/html/BRANCH.php for a detailed description of the branching rule properties.
Conflict Handler
| conflict handler | priority | description |
| logicor | 800000 | conflict handler creating logic or constraints |
| setppc | 700000 | conflict handler creating set covering constraints |
| indicatorconflict | 200000 | replace slack variables and generate logicor constraints |
| linear | -1000000 | conflict handler creating linear constraints |
| bounddisjunction | -3000000 | conflict handler creating bound disjunction constraints |
Constraint Handler
| constraint handler | checkprio | enfoprio | sepaprio | sepafreq | propfreq | eagerfreq | presolvetimings | description |
| integral | 0 | 0 | 0 | -1 | -1 | -1 | always | integrality constraint |
| SOS1 | -10 | 100 | 1000 | 10 | 1 | 100 | medium | SOS1 constraint handler |
| SOS2 | -10 | 100 | 10 | 0 | 1 | 100 | fast | SOS2 constraint handler |
| varbound | -500000 | -500000 | 900000 | 0 | 1 | 100 | fast medium | variable bounds lhs <= x + c*y <= rhs, x non-binary, y non-continuous |
| knapsack | -600000 | -600000 | 600000 | 0 | 1 | 100 | always | knapsack constraint of the form a^T x <= b, x binary and a >= 0 |
| setppc | -700000 | -700000 | 700000 | 0 | 1 | 100 | always | set partitioning / packing / covering constraints |
| or | -850000 | -850000 | 850000 | 0 | 1 | 100 | medium | constraint handler for or constraints: r = or(x1, ..., xn) |
| and | -850100 | -850100 | 850100 | 1 | 1 | 100 | fast exhaustive | constraint handler for AND-constraints: r = and(x1, ..., xn) |
| xor | -850200 | -850200 | 850200 | 0 | 1 | 100 | always | constraint handler for xor constraints: r = xor(x1, ..., xn) |
| linear | -1000000 | -1000000 | 100000 | 0 | 1 | 100 | fast exhaustive | linear constraints of the form lhs <= a^T x <= rhs |
| orbisack | -1005200 | -1005200 | 40100 | 5 | 5 | -1 | exhaustive | symmetry breaking constraint handler for orbisacks |
| orbitope | -1005200 | -1005200 | 40100 | -1 | 1 | -1 | medium | symmetry breaking constraint handler relying on (partitioning/packing) orbitopes |
| symresack | -1005200 | -1005200 | 40100 | 5 | 5 | -1 | exhaustive | symmetry breaking constraint handler relying on symresacks |
| logicor | -2000000 | -2000000 | 10000 | 0 | 1 | 100 | always | logic or constraints |
| bounddisjunction | -3000000 | -3000000 | 0 | -1 | 1 | 100 | fast | bound disjunction constraints |
| nonlinear | -4000010 | 50 | 10 | 1 | 1 | 100 | always | handler for nonlinear constraints specified by algebraic expressions |
| indicator | -6000000 | -100 | 10 | 10 | 1 | 100 | fast | indicator constraint handler |
| fixedvar | -7000000 | -7000000 | 0 | -1 | -1 | -1 | always | check bounds of original variables that are not active in transformed problem |
| components | -9999999 | 0 | 0 | -1 | 1 | -1 | | independent components constraint handler |
See https://www.scipopt.org/doc/html/CONS.php for a detailed description of the constraint handler properties.
Cut Selectors
| cut selector | priority | description |
| hybrid | 8000 | weighted sum of efficacy, dircutoffdist, objparal, and intsupport |
| ensemble | 7000 | weighted sum of many terms with optional filtering and penalties |
| dynamic | 7000 | dynamic orthogonality for hybrid cutsel |
Display Columns
| display column | header | position | width | priority | status | description |
| solfound | | 0 | 1 | 80000 | auto | letter that indicates the heuristic which found the solution |
| time | time | 50 | 5 | 4000 | auto | total solution time |
| nnodes | node | 100 | 7 | 100000 | auto | number of processed nodes |
| nodesleft | left | 200 | 7 | 90000 | auto | number of unprocessed nodes |
| nrank1nodes | rank1 | 500 | 7 | 40000 | off | current number of rank1 nodes left |
| nnodesbelowinc | nbInc | 550 | 6 | 40000 | off | current number of nodes with an estimate better than the current incumbent |
| lpiterations | LP iter | 1000 | 7 | 30000 | auto | number of simplex iterations |
| lpavgiterations | LP it/n | 1400 | 7 | 25000 | auto | average number of LP iterations since the last output line |
| lpcond | LP cond | 1450 | 7 | 0 | auto | estimate on condition number of LP solution |
| memused | umem | 1500 | 5 | 0 | auto | total number of bytes used in block memory |
| memtotal | mem/heur | 1500 | 8 | 20000 | auto | total number of bytes in block memory or the creator name when a new incumbent solution was found |
| depth | depth | 2000 | 5 | 500 | auto | depth of current node |
| maxdepth | mdpt | 2100 | 5 | 5000 | auto | maximal depth of all processed nodes |
| plungedepth | pdpt | 2200 | 5 | 10 | auto | current plunging depth |
| nfrac | frac | 2500 | 5 | 700 | auto | number of fractional variables in the current solution |
| nexternbranchcands | extbr | 2600 | 5 | 650 | auto | number of extern branching variables in the current node |
| vars | vars | 3000 | 5 | 3000 | auto | number of variables in the problem |
| conss | cons | 3100 | 5 | 3100 | auto | number of globally valid constraints in the problem |
| curconss | ccons | 3200 | 5 | 600 | auto | number of enabled constraints in current node |
| curcols | cols | 3300 | 5 | 800 | auto | number of LP columns in current node |
| currows | rows | 3400 | 5 | 900 | auto | number of LP rows in current node |
| cuts | cuts | 3500 | 5 | 2100 | auto | total number of cuts applied to the LPs |
| separounds | sepa | 3600 | 4 | 100 | auto | number of separation rounds performed at the current node |
| poolsize | pool | 3700 | 5 | 50 | auto | number of LP rows in the cut pool |
| conflicts | confs | 4000 | 5 | 2000 | auto | total number of conflicts found in conflict analysis |
| strongbranchs | strbr | 5000 | 5 | 1000 | auto | total number of strong branching calls |
| pseudoobj | pseudoobj | 6000 | 14 | 300 | auto | current pseudo objective value |
| lpobj | lpobj | 6500 | 14 | 300 | auto | current LP objective value |
| curdualbound | curdualbound | 7000 | 14 | 400 | auto | dual bound of current node |
| estimate | estimate | 7500 | 14 | 200 | auto | estimated value of feasible solution in current node |
| avgdualbound | avgdualbound | 8000 | 14 | 40 | auto | average dual bound of all unprocessed nodes |
| dualbound | dualbound | 9000 | 14 | 70000 | auto | current global dual bound |
| primalbound | primalbound | 10000 | 14 | 80000 | auto | current primal bound |
| cutoffbound | cutoffbound | 10100 | 14 | 10 | auto | current cutoff bound |
| gap | gap | 20000 | 8 | 60000 | auto | current (relative) gap using |primal-dual|/MIN(|dual|,|primal|) |
| primalgap | primgap | 21000 | 8 | 20000 | off | current (relative) gap using |primal-dual|/|primal| |
| nsols | nsols | 30000 | 5 | 0 | auto | current number of solutions found |
| completed | compl. | 30100 | 8 | 110000 | auto | completion of search in percent (based on tree size estimation) |
| nobjleaves | objleav | 31000 | 7 | 0 | auto | current number of encountered objective limit leaves |
| ninfeasleaves | infleav | 32000 | 7 | 0 | auto | number of encountered infeasible leaves |
| sols | sols | 100000 | 7 | 110000 | off | number of detected feasible solutions |
| feasST | feasST | 110000 | 6 | 110000 | off | number of detected non trivial feasible subtrees |
See https://www.scipopt.org/doc/html/DISP.php for a detailed description of the display column properties.
Nonlinear Handler
| nonlinear handler | enabled | detect priority | enforce priority | description |
| default | 1 | 0 | 0 | default handler for expressions |
| convex | 1 | 50 | 50 | handler that identifies and estimates convex expressions |
| concave | 1 | 40 | 40 | handler that identifies and estimates concave expressions |
| bilinear | 1 | -10 | -10 | bilinear handler for expressions |
| perspective | 1 | -20 | 125 | perspective handler for expressions |
| quadratic | 1 | 1 | 100 | handler for quadratic expressions |
| quotient | 1 | 20 | 20 | nonlinear handler for quotient expressions |
| signomial | 1 | 30 | 30 | handler for signomial expressions |
| soc | 1 | 100 | 100 | nonlinear handler for second-order cone structures |
Node Selectors
| node selector | standard priority | memsave priority | description |
| estimate | 200000 | 100 | best estimate search |
| bfs | 100000 | 0 | best first search |
| hybridestim | 50000 | 50 | hybrid best estimate / best bound search |
| restartdfs | 10000 | 50000 | depth first search with periodical selection of the best node |
| uct | 10 | 0 | node selector which balances exploration and exploitation |
| dfs | 0 | 100000 | depth first search |
| breadthfirst | -10000 | -1000000 | breadth first search |
See https://www.scipopt.org/doc/html/NODESEL.php for a detailed description of the node selector properties.
Presolvers
| presolver | priority | timing | maxrounds | description |
| milp | 9999999 | medium | -1 | MILP specific presolving methods |
| trivial | 9000000 | fast | -1 | round fractional bounds on integers, fix variables with equal bounds |
| boundshift | 7900000 | fast | 0 | converts variables with domain [a,b] to variables with domain [0,b-a] |
| inttobinary | 7000000 | fast | -1 | converts integer variables with domain [a,a+1] to binaries |
| convertinttobin | 6000000 | fast | 0 | converts integer variables to binaries |
| gateextraction | 1000000 | exhaustive | -1 | presolver extracting gate(and)-constraints |
| qpkktref | -1 | medium | 0 | adds KKT conditions to (mixed-binary) quadratic programs |
| dualcomp | -50 | exhaustive | -1 | compensate single up-/downlocks by singleton continuous variables |
| stuffing | -100 | exhaustive | 0 | fix redundant singleton continuous variables |
| domcol | -1000 | exhaustive | -1 | dominated column presolver |
| tworowbnd | -2000 | exhaustive | 0 | do bound tigthening by using two rows |
| dualinfer | -3000 | exhaustive | 0 | exploit dual information for fixings and side changes |
| implics | -10000 | medium | -1 | implication graph aggregator |
| dualagg | -12000 | exhaustive | 0 | aggregate variables by dual arguments |
| sparsify | -24000 | exhaustive | -1 | eliminate non-zero coefficients |
| dualsparsify | -240000 | exhaustive | -1 | eliminate non-zero coefficients |
| redvub | -9000000 | exhaustive | 0 | detect redundant variable bound constraints |
See https://www.scipopt.org/doc/html/PRESOL.php for a detailed description of the presolver properties.
Primal Heuristics
| primal heuristic | type | priority | freq | freqoffset | description |
| actconsdiving | d | -1003700 | -1 | 5 | LP diving heuristic that chooses fixings w.r.t. the active constraints |
| adaptivediving | d | -70000 | 5 | 3 | diving heuristic that selects adaptively between the existing, public divesets |
| bound | p | -1107000 | -1 | 0 | heuristic which fixes all integer variables to a bound and solves the remaining LP |
| clique | p | 5000 | 0 | 0 | LNS heuristic using a clique partition to restrict the search neighborhood |
| coefdiving | d | -1001000 | -1 | 1 | LP diving heuristic that chooses fixings w.r.t. the matrix coefficients |
| completesol | L | 0 | 0 | 0 | primal heuristic trying to complete given partial solutions |
| conflictdiving | d | -1000100 | 10 | 0 | LP diving heuristic that chooses fixings w.r.t. conflict locks |
| crossover | L | -1104000 | 30 | 0 | LNS heuristic that fixes all variables that are identic in a couple of solutions |
| dins | L | -1105000 | -1 | 0 | distance induced neighborhood search by Ghosh |
| distributiondiving | d | -1003300 | 10 | 3 | Diving heuristic that chooses fixings w.r.t. changes in the solution density |
| dps | L | 75000 | -1 | 0 | primal heuristic for decomposable MIPs |
| dualval | L | -10 | -1 | 0 | primal heuristic using dual values |
| farkasdiving | d | -900000 | 10 | 0 | LP diving heuristic that tries to construct a Farkas-proof |
| feaspump | o | -1000000 | 20 | 0 | objective feasibility pump 2.0 |
| fixandinfer | p | -500000 | -1 | 0 | iteratively fixes variables and propagates inferences |
| fracdiving | d | -1003000 | 10 | 3 | LP diving heuristic that chooses fixings w.r.t. the fractionalities |
| gins | L | -1103000 | 20 | 8 | gins works on k-neighborhood in a variable-constraint graph |
| guideddiving | d | -1007000 | 10 | 7 | LP diving heuristic that chooses fixings in direction of incumbent solutions |
| zeroobj | L | 100 | -1 | 0 | heuristic trying to solve the problem without objective |
| indicator | L | -20200 | 1 | 0 | indicator heuristic to create feasible solutions from values for indicator variables |
| indicatordiving | I | -150000 | 0 | 0 | LP diving heuristic that fixes indicator variables controlling semicontinuous variables |
| intdiving | d | -1003500 | -1 | 9 | LP diving heuristic that fixes binary variables with large LP value to one |
| intshifting | r | -10000 | 10 | 0 | LP rounding heuristic with infeasibility recovering and final LP solving |
| linesearchdiving | d | -1006000 | 10 | 6 | LP diving heuristic that chooses fixings following the line from root solution to current solution |
| localbranching | L | -1102000 | -1 | 0 | local branching heuristic by Fischetti and Lodi |
| locks | p | 3000 | 0 | 0 | heuristic that fixes variables based on their rounding locks |
| lpface | L | -1104010 | 15 | 0 | LNS heuristic that searches the optimal LP face inside a sub-MIP |
| alns | L | -1100500 | 20 | 0 | Large neighborhood search heuristic that orchestrates the popular neighborhoods Local Branching, RINS, RENS, DINS etc. |
| nlpdiving | d | -1003010 | 10 | 3 | NLP diving heuristic that chooses fixings w.r.t. the fractionalities |
| mutation | L | -1103010 | -1 | 8 | mutation heuristic randomly fixing variables |
| multistart | L | -2100000 | 0 | 0 | multistart heuristic for convex and nonconvex MINLPs |
| mpec | d | -2050000 | 50 | 0 | regularization heuristic for convex and nonconvex MINLPs |
| objpscostdiving | o | -1004000 | 20 | 4 | LP diving heuristic that changes variable's objective values instead of bounds, using pseudo costs as guide |
| octane | r | -1008000 | -1 | 0 | octane primal heuristic for pure {0;1}-problems based on Balas et al. |
| ofins | L | 60000 | 0 | 0 | primal heuristic for reoptimization, objective function induced neighborhood search |
| oneopt | i | -20000 | 1 | 0 | 1-opt heuristic which tries to improve setting of single integer variables |
| padm | L | 70000 | 0 | 0 | penalty alternating direction method primal heuristic |
| proximity | L | -2000000 | -1 | 0 | heuristic trying to improve the incumbent by an auxiliary proximity objective function |
| pscostdiving | d | -1002000 | 10 | 2 | LP diving heuristic that chooses fixings w.r.t. the pseudo cost values |
| randrounding | r | -200 | 20 | 0 | fast LP rounding heuristic |
| rens | L | -1100000 | 0 | 0 | LNS exploring fractional neighborhood of relaxation's optimum |
| reoptsols | p | 40000 | 0 | 0 | primal heuristic updating solutions found in a previous optimization round |
| repair | L | -20 | -1 | 0 | tries to repair a primal infeasible solution |
| rins | L | -1101000 | 25 | 0 | relaxation induced neighborhood search by Danna, Rothberg, and Le Pape |
| rootsoldiving | o | -1005000 | 20 | 5 | LP diving heuristic that changes variable's objective values using root LP solution as guide |
| rounding | r | -1000 | 1 | 0 | LP rounding heuristic with infeasibility recovering |
| scheduler | L | -30000 | -1 | 0 | Adaptive heuristic to schedule LNS and diving heuristics |
| shiftandpropagate | p | 1000 | 0 | 0 | Pre-root heuristic to expand an auxiliary branch-and-bound tree and apply propagation techniques |
| shifting | r | -5000 | 10 | 0 | LP rounding heuristic with infeasibility recovering also using continuous variables |
| simplerounding | r | -30 | 1 | 0 | simple and fast LP rounding heuristic |
| subnlp | L | -2000010 | 1 | 0 | primal heuristic that performs a local search in an NLP after fixing integer variables and presolving |
| trivial | t | 10000 | 0 | 0 | start heuristic which tries some trivial solutions |
| trivialnegation | p | 39990 | 0 | 0 | negate solution entries if an objective coefficient changes the sign, enters or leaves the objective. |
| trustregion | L | -1102010 | -1 | 0 | LNS heuristic for Benders' decomposition based on trust region methods |
| trysol | t | -3000010 | 1 | 0 | try solution heuristic |
| twoopt | i | -20100 | -1 | 0 | primal heuristic to improve incumbent solution by flipping pairs of variables |
| undercover | L | -1110000 | 0 | 0 | solves a sub-CIP determined by a set covering approach |
| vbounds | p | 2500 | 0 | 0 | LNS heuristic uses the variable lower and upper bounds to determine the search neighborhood |
| veclendiving | d | -1003100 | 10 | 4 | LP diving heuristic that rounds variables with long column vectors |
| zirounding | r | -500 | 1 | 0 | LP rounding heuristic as suggested by C. Wallace taking row slacks and bounds into account |
See https://www.scipopt.org/doc/html/HEUR.php for a detailed description of the primal heuristic properties.
Propagators
| propagator | propprio | freq | presolveprio | presolvetiming | description |
| rootredcost | 10000000 | 1 | 0 | always | reduced cost strengthening using root node reduced costs and the cutoff bound |
| dualfix | 8000000 | 0 | 8000000 | fast | roundable variables dual fixing |
| genvbounds | 3000000 | 1 | -2000000 | fast | generalized variable bounds propagator |
| vbounds | 3000000 | 1 | -90000 | medium exhaustive | propagates variable upper and lower bounds |
| pseudoobj | 3000000 | 1 | 6000000 | fast | pseudo objective function propagator |
| redcost | 1000000 | 1 | 0 | always | reduced cost strengthening propagator |
| probing | -100000d | -1 | -100000 | exhaustive | probing propagator on binary variables |
| symmetry | -1000000 | 1 | -10000000 | exhaustive | propagator for handling symmetry |
| obbt | -1000000d | 0 | 0 | always | optimization-based bound tightening propagator |
| nlobbt | -1100000d | -1 | 0 | always | propagator template |
See https://www.scipopt.org/doc/html/PROP.php for a detailed description of the propagator properties.
Separators
| separator | priority | freq | bounddist | description |
| closecuts | 1000000 | -1 | 1 | closecuts meta separator |
| disjunctive | 10d | 0 | 0 | disjunctive cut separator |
| rlt | 10 | 0 | 1 | reformulation-linearization-technique separator |
| minor | 0 | 10 | 1 | separator to ensure that 2x2 principal minors of X - xx' are positive semi-definite |
| gauge | 0 | -1 | 1 | gauge separator |
| convexproj | 0d | -1 | 1 | separate at projection of point onto convex region |
| interminor | 0 | -1 | 1 | intersection cuts separator to ensure that 2x2 minors of X (= xx') have determinant 0 |
| mixing | -50 | 10 | 1 | mixing inequality separator |
| impliedbounds | -50 | 10 | 1 | implied bounds separator |
| intobj | -100 | -1 | 0 | integer objective value separator |
| gomory | -1000 | 10 | 1 | separator for Gomory mixed-integer and strong CG cuts from LP tableau rows |
| cgmip | -1000 | -1 | 0 | Chvatal-Gomory cuts via MIPs separator |
| aggregation | -3000 | 10 | 1 | aggregation heuristic for complemented mixed integer rounding cuts and flowcover cuts |
| clique | -5000 | 0 | 0 | clique separator of stable set relaxation |
| zerohalf | -6000 | 10 | 1 | {0,1/2}-cuts separator |
| lagromory | -8000 | -1 | 1 | separator for Lagromory cuts for MIP relaxations |
| mcf | -10000 | 0 | 0 | multi-commodity-flow network cut separator |
| eccuts | -13000 | -1 | 1 | separator for edge-concave functions |
| oddcycle | -15000 | -1 | 1 | odd cycle separator |
| flowcover | -100000 | 10 | 0 | separator for flowcover cuts |
| strongcg | -100000 | 10 | 0 | separator for strong CG cuts |
| gomorymi | -100000 | 10 | 0 | separator for Gomory mixed-integer cuts |
| cmir | -100000 | 10 | 0 | separator for cmir cuts |
| knapsackcover | -100000 | 10 | 0 | separator for knapsack cover cuts |
| rapidlearning | -1200000 | 5 | 1 | rapid learning heuristic and separator |
See https://www.scipopt.org/doc/html/SEPA.php for a detailed description of the separator properties.
List of SCIP Options
SCIP supports a large set of options. In the following, we give a detailed list of all SCIP options.
gams
| Option | Description | Default |
| gams/dumpsolutions | name of solutions index gdx file for writing all alternate solutions
Range: string | |
| gams/dumpsolutionsmerged | name of gdx file for writing all alternate solutions into a single file
Range: string | |
| gams/indicatorfile | name of GAMS options file that contains definitions on indicators
Range: string | |
| gams/infbound | value to use for variable bounds that are missing or exceed numerics/infinity
Range: [0, ∞] | ∞ |
| gams/interactive | command to be issued to the SCIP shell instead of issuing a solve command
Range: string | |
| gams/mipstart | how to handle initial variable levels, see also section Starting point
Range: {0, ..., 4} | 2 |
gams/solvetrace
| Option | Description | Default |
| gams/solvetrace/file | name of file where to write branch-and-bound trace information too
Range: string | |
| gams/solvetrace/nodefreq | frequency in number of nodes when to write branch-and-bound trace information, 0 to disable
Range: {0, ..., ∞} | 100 |
| gams/solvetrace/timefreq | frequency in seconds when to write branch-and-bound trace information, 0.0 to disable
Range: [0, ∞] | 5 |
branching
| Option | Description | Default |
| branching/clamp | minimal relative distance of branching point to bounds when branching on a continuous variable
Range: [0, 0.5] | 0.2 |
| branching/delaypscostupdate | should updating pseudo costs for continuous variables be delayed to the time after separation?
Range: boolean | 1 |
| branching/divingpscost | should pseudo costs be updated also in diving and probing mode?
Range: boolean | 1 |
| branching/lpgainnormalize | strategy for normalization of LP gain when updating pseudocosts of continuous variables (divide by movement of 'l'p value, reduction in 'd'omain width, or reduction in domain width of 's'ibling)
Range: d, l, s | s |
| branching/midpull | fraction by which to move branching point of a continuous variable towards the middle of the domain; a value of 1.0 leads to branching always in the middle of the domain
Range: [0, 1] | 0.75 |
| branching/midpullreldomtrig | multiply midpull by relative domain width if the latter is below this value
Range: [0, 1] | 0.5 |
| branching/preferbinary | should branching on binary variables be preferred?
Range: boolean | 0 |
| Options for expert users |
| branching/checksol | should LP solutions during strong branching with propagation be checked for feasibility?
Range: boolean | 1 |
| branching/firstsbchild | child node to be regarded first during strong branching (only with propagation): 'u'p child, 'd'own child, 'h'istory-based, or 'a'utomatic
Range: a, d, u, h | a |
| branching/forceallchildren | should all strong branching children be regarded even if one is detected to be infeasible? (only with propagation)
Range: boolean | 0 |
| branching/roundsbsol | should LP solutions during strong branching with propagation be rounded? (only when checksbsol=TRUE)
Range: boolean | 1 |
| branching/scorefac | branching score factor to weigh downward and upward gain prediction in sum score function
Range: [0, 1] | 0.167 |
| branching/scorefunc | branching score function ('s'um, 'p'roduct, 'q'uotient)
Range: s, p, q | p |
| branching/sumadjustscore | score adjustment near zero by adding epsilon (TRUE) or using maximum (FALSE)
Range: boolean | 0 |
branching/allfullstrong
| Option | Description | Default |
| branching/allfullstrong/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| branching/allfullstrong/maxdepth | maximal depth level, up to which branching rule <allfullstrong> should be used (-1 for no limit)
Range: {-1, ..., 1073741822} | -1 |
| branching/allfullstrong/priority | priority of branching rule <allfullstrong>
Range: {-536870912, ..., 536870911} | -1000 |
branching/cloud
| Option | Description | Default |
| branching/cloud/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| branching/cloud/maxdepth | maximal depth level, up to which branching rule <cloud> should be used (-1 for no limit)
Range: {-1, ..., 1073741822} | -1 |
| branching/cloud/maxdepthunion | maximum depth for the union
Range: {0, ..., 65000} | 65000 |
| branching/cloud/maxpoints | maximum number of points for the cloud (-1 means no limit)
Range: {-1, ..., ∞} | -1 |
| branching/cloud/minsuccessrate | minimum success rate for the cloud
Range: [0, 1] | 0 |
| branching/cloud/minsuccessunion | minimum success rate for the union
Range: [0, 1] | 0 |
| branching/cloud/onlyF2 | should only F2 be used?
Range: boolean | 0 |
| branching/cloud/priority | priority of branching rule <cloud>
Range: {-536870912, ..., 536870911} | 0 |
| branching/cloud/usecloud | should a cloud of points be used?
Range: boolean | 1 |
| branching/cloud/useunion | should the union of candidates be used?
Range: boolean | 0 |
branching/distribution
| Option | Description | Default |
| branching/distribution/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| branching/distribution/maxdepth | maximal depth level, up to which branching rule <distribution> should be used (-1 for no limit)
Range: {-1, ..., 1073741822} | -1 |
| branching/distribution/priority | priority of branching rule <distribution>
Range: {-536870912, ..., 536870911} | 0 |
| Options for expert users |
| branching/distribution/onlyactiverows | should only rows which are active at the current node be considered?
Range: boolean | 0 |
| branching/distribution/scoreparam | the score;largest 'd'ifference, 'l'owest cumulative probability,'h'ighest c.p., 'v'otes lowest c.p., votes highest c.p.('w')
Range: d, h, l, v, w | v |
| branching/distribution/weightedscore | should the branching score weigh up- and down-scores of a variable
Range: boolean | 0 |
branching/fullstrong
| Option | Description | Default |
| branching/fullstrong/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| branching/fullstrong/maxdepth | maximal depth level, up to which branching rule <fullstrong> should be used (-1 for no limit)
Range: {-1, ..., 1073741822} | -1 |
| branching/fullstrong/priority | priority of branching rule <fullstrong>
Range: {-536870912, ..., 536870911} | 0 |
| Options for expert users |
| branching/fullstrong/forcestrongbranch | should strong branching be applied even if there is just a single candidate?
Range: boolean | 0 |
| branching/fullstrong/maxproprounds | maximum number of propagation rounds to be performed during strong branching before solving the LP (-1: no limit, -2: parameter settings)
Range: {-3, ..., ∞} | -2 |
| branching/fullstrong/probingbounds | should valid bounds be identified in a probing-like fashion during strong branching (only with propagation)?
Range: boolean | 1 |
| branching/fullstrong/reevalage | number of intermediate LPs solved to trigger reevaluation of strong branching value for a variable that was already evaluated at the current node
Range: {0, ..., ∞} | 10 |
branching/gomory
| Option | Description | Default |
| branching/gomory/efficacyweight | weight of efficacy in the weighted sum cut scoring rule
Range: [-1, 1] | 1 |
| branching/gomory/intsupportweight | weight of integer support in the weighted sum cut scoring rule
Range: [-1, 1] | 0 |
| branching/gomory/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| branching/gomory/maxdepth | maximal depth level, up to which branching rule <gomory> should be used (-1 for no limit)
Range: {-1, ..., 1073741822} | -1 |
| branching/gomory/maxncands | maximum amount of branching candidates to generate Gomory cuts for (-1: all candidates)
Range: {-1, ..., ∞} | -1 |
| branching/gomory/objparallelweight | weight of objective parallelism in the weighted sum cut scoring rule
Range: [-1, 1] | 0 |
| branching/gomory/performrelpscost | whether relpscost branching should be called without branching (used for bound inferences and conflicts)
Range: boolean | 0 |
| branching/gomory/priority | priority of branching rule <gomory>
Range: {-536870912, ..., 536870911} | -1000 |
| branching/gomory/useweakercuts | use weaker cuts that are exactly derived from the branching split disjunction
Range: boolean | 1 |
branching/inference
| Option | Description | Default |
| branching/inference/conflictprio | priority value for using conflict weights in lex. order
Range: {0, ..., ∞} | 1 |
| branching/inference/cutoffprio | priority value for using cutoff weights in lex. order
Range: {0, ..., ∞} | 1 |
| branching/inference/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| branching/inference/maxdepth | maximal depth level, up to which branching rule <inference> should be used (-1 for no limit)
Range: {-1, ..., 1073741822} | -1 |
| branching/inference/priority | priority of branching rule <inference>
Range: {-536870912, ..., 536870911} | 1000 |
| branching/inference/useweightedsum | should a weighted sum of inference, conflict and cutoff weights be used?
Range: boolean | 1 |
| Options for expert users |
| branching/inference/conflictweight | weight in score calculations for conflict score
Range: [0, ∞] | 1000 |
| branching/inference/cutoffweight | weight in score calculations for cutoff score
Range: [0, ∞] | 1 |
| branching/inference/fractionals | should branching on LP solution be restricted to the fractional variables?
Range: boolean | 1 |
| branching/inference/inferenceweight | weight in score calculations for inference score
Range: real | 1 |
| branching/inference/reliablescore | weight in score calculations for conflict score
Range: [0, ∞] | 0.001 |
branching/leastinf
| Option | Description | Default |
| branching/leastinf/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| branching/leastinf/maxdepth | maximal depth level, up to which branching rule <leastinf> should be used (-1 for no limit)
Range: {-1, ..., 1073741822} | -1 |
| branching/leastinf/priority | priority of branching rule <leastinf>
Range: {-536870912, ..., 536870911} | 50 |
branching/lookahead
| Option | Description | Default |
| branching/lookahead/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| branching/lookahead/maxdepth | maximal depth level, up to which branching rule <lookahead> should be used (-1 for no limit)
Range: {-1, ..., 1073741822} | -1 |
| branching/lookahead/priority | priority of branching rule <lookahead>
Range: {-536870912, ..., 536870911} | 0 |
| Options for expert users |
| branching/lookahead/abbreviated | toggles the abbreviated LAB.
Range: boolean | 1 |
| branching/lookahead/abbrevpseudo | if abbreviated: Use pseudo costs to estimate the score of a candidate.
Range: boolean | 0 |
| branching/lookahead/addbinconsrow | should binary constraints be added as rows to the base LP? (0: no, 1: separate, 2: as initial rows)
Range: {0, ..., 2} | 0 |
| branching/lookahead/addclique | add binary constraints with two variables found at the root node also as a clique
Range: boolean | 0 |
| branching/lookahead/addnonviocons | should binary constraints, that are not violated by the base LP, be collected and added?
Range: boolean | 0 |
| branching/lookahead/applychildbounds | should bounds known for child nodes be applied?
Range: boolean | 0 |
| branching/lookahead/deeperscoringfunction | scoring function to be used at deeper levels
Range: d, f, s, w, l, c, r, x | x |
| branching/lookahead/enforcemaxdomreds | should the maximum number of domain reductions maxnviolateddomreds be enforced?
Range: boolean | 0 |
| branching/lookahead/filterbymaxgain | should lookahead branching only be applied if the max gain in level 1 is not uniquely that of the best candidate?
Range: boolean | 0 |
| branching/lookahead/level2avgscore | should the average score be used for uninitialized scores in level 2?
Range: boolean | 0 |
| branching/lookahead/level2zeroscore | should uninitialized scores in level 2 be set to 0?
Range: boolean | 0 |
| branching/lookahead/maxncands | if abbreviated: The max number of candidates to consider at the node.
Range: {1, ..., ∞} | 4 |
| branching/lookahead/maxndeepercands | if abbreviated: The max number of candidates to consider per deeper node.
Range: {0, ..., ∞} | 2 |
| branching/lookahead/maxnviolatedbincons | how many binary constraints that are violated by the base lp solution should be gathered until the rule is stopped and they are added? [0 for unrestricted]
Range: {0, ..., ∞} | 0 |
| branching/lookahead/maxnviolatedcons | how many constraints that are violated by the base lp solution should be gathered until the rule is stopped and they are added? [0 for unrestricted]
Range: {0, ..., ∞} | 1 |
| branching/lookahead/maxnviolateddomreds | how many domain reductions that are violated by the base lp solution should be gathered until the rule is stopped and they are added? [0 for unrestricted]
Range: {0, ..., ∞} | 1 |
| branching/lookahead/maxproprounds | maximum number of propagation rounds to perform at each temporary node (-1: unlimited, 0: SCIP default)
Range: {-1, ..., ∞} | 0 |
| branching/lookahead/mergedomainreductions | should domain reductions of feasible siblings should be merged?
Range: boolean | 0 |
| branching/lookahead/minweight | if scoringfunction is 's', this value is used to weight the min of the gains of two child problems in the convex combination
Range: [0, ∞] | 0.8 |
| branching/lookahead/onlyvioldomreds | should only domain reductions that violate the LP solution be applied?
Range: boolean | 0 |
| branching/lookahead/prefersimplebounds | should domain reductions only be applied if there are simple bound changes?
Range: boolean | 0 |
| branching/lookahead/propagate | should domain propagation be executed before each temporary node is solved?
Range: boolean | 1 |
| branching/lookahead/recursiondepth | the max depth of LAB.
Range: {1, ..., ∞} | 2 |
| branching/lookahead/reevalage | max number of LPs solved after which a previous prob branching results are recalculated
Range: {0, ..., ∞} | 10 |
| branching/lookahead/reevalagefsb | max number of LPs solved after which a previous FSB scoring results are recalculated
Range: {0, ..., ∞} | 10 |
| branching/lookahead/reusebasis | if abbreviated: Should the information gathered to obtain the best candidates be reused?
Range: boolean | 1 |
| branching/lookahead/scoringfunction | scoring function to be used at the base level
Range: d, f, s, w, p, l, c, r, a | a |
| branching/lookahead/scoringscoringfunction | scoring function to be used during FSB scoring
Range: d, f, s, w, l, c, r | d |
| branching/lookahead/storeunviolatedsol | if only non violating constraints are added, should the branching decision be stored till the next call?
Range: boolean | 1 |
| branching/lookahead/updatebranchingresults | should branching results (and scores) be updated w.r.t. proven dual bounds?
Range: boolean | 0 |
| branching/lookahead/usedomainreduction | should domain reductions be collected and applied?
Range: boolean | 1 |
| branching/lookahead/useimpliedbincons | should binary constraints be collected and applied?
Range: boolean | 0 |
| branching/lookahead/uselevel2data | should branching data generated at depth level 2 be stored for re-using it?
Range: boolean | 1 |
| branching/lookahead/worsefactor | if the FSB score is of a candidate is worse than the best by this factor, skip this candidate (-1: disable)
Range: [-1, ∞] | -1 |
branching/mostinf
| Option | Description | Default |
| branching/mostinf/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| branching/mostinf/maxdepth | maximal depth level, up to which branching rule <mostinf> should be used (-1 for no limit)
Range: {-1, ..., 1073741822} | -1 |
| branching/mostinf/priority | priority of branching rule <mostinf>
Range: {-536870912, ..., 536870911} | 100 |
branching/multaggr
| Option | Description | Default |
| branching/multaggr/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| branching/multaggr/maxdepth | maximal depth level, up to which branching rule <multaggr> should be used (-1 for no limit)
Range: {-1, ..., 1073741822} | -1 |
| branching/multaggr/priority | priority of branching rule <multaggr>
Range: {-536870912, ..., 536870911} | 0 |
| Options for expert users |
| branching/multaggr/maxproprounds | maximum number of propagation rounds to be performed during multaggr branching before solving the LP (-1: no limit, -2: parameter settings)
Range: {-2, ..., ∞} | 0 |
| branching/multaggr/probingbounds | should valid bounds be identified in a probing-like fashion during multaggr branching (only with propagation)?
Range: boolean | 1 |
| branching/multaggr/reevalage | number of intermediate LPs solved to trigger reevaluation of strong branching value for a variable that was already evaluated at the current node
Range: {0, ..., ∞} | 0 |
branching/nodereopt
| Option | Description | Default |
| branching/nodereopt/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| branching/nodereopt/maxdepth | maximal depth level, up to which branching rule <nodereopt> should be used (-1 for no limit)
Range: {-1, ..., 1073741822} | -1 |
| branching/nodereopt/priority | priority of branching rule <nodereopt>
Range: {-536870912, ..., 536870911} | -9000000 |
branching/pscost
| Option | Description | Default |
| branching/pscost/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| branching/pscost/maxdepth | maximal depth level, up to which branching rule <pscost> should be used (-1 for no limit)
Range: {-1, ..., 1073741822} | -1 |
| branching/pscost/narymaxdepth | maximal depth where to do n-ary branching, -1 to turn off
Range: {-1, ..., ∞} | -1 |
| branching/pscost/naryminwidth | minimal domain width in children when doing n-ary branching, relative to global bounds
Range: [0, 1] | 0.001 |
| branching/pscost/narywidthfactor | factor of domain width in n-ary branching when creating nodes with increasing distance from branching value
Range: [1, ∞] | 2 |
| branching/pscost/nchildren | number of children to create in n-ary branching
Range: {2, ..., ∞} | 2 |
| branching/pscost/priority | priority of branching rule <pscost>
Range: {-536870912, ..., 536870911} | 2000 |
| branching/pscost/strategy | strategy for utilizing pseudo-costs of external branching candidates (multiply as in pseudo costs 'u'pdate rule, or by 'd'omain reduction, or by domain reduction of 's'ibling, or by 'v'ariable score)
Range: d, s, u, v | u |
| Options for expert users |
| branching/pscost/maxscoreweight | weight for maximum of scores of a branching candidate when building weighted sum of min/max/sum of scores
Range: real | 1.3 |
| branching/pscost/minscoreweight | weight for minimum of scores of a branching candidate when building weighted sum of min/max/sum of scores
Range: real | 0.8 |
| branching/pscost/sumscoreweight | weight for sum of scores of a branching candidate when building weighted sum of min/max/sum of scores
Range: real | 0.1 |
branching/random
| Option | Description | Default |
| branching/random/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| branching/random/maxdepth | maximal depth level, up to which branching rule <random> should be used (-1 for no limit)
Range: {-1, ..., 1073741822} | -1 |
| branching/random/priority | priority of branching rule <random>
Range: {-536870912, ..., 536870911} | -100000 |
| branching/random/seed | initial random seed value
Range: {0, ..., ∞} | 41 |
branching/relpscost
| Option | Description | Default |
| branching/relpscost/initcand | maximal number of candidates initialized with strong branching per node
Range: {0, ..., ∞} | 100 |
| branching/relpscost/inititer | iteration limit for strong branching initializations of pseudo cost entries (0: auto)
Range: {0, ..., ∞} | 0 |
| branching/relpscost/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| branching/relpscost/maxdepth | maximal depth level, up to which branching rule <relpscost> should be used (-1 for no limit)
Range: {-1, ..., 1073741822} | -1 |
| branching/relpscost/priority | priority of branching rule <relpscost>
Range: {-536870912, ..., 536870911} | 10000 |
| branching/relpscost/sbiterofs | additional number of allowed strong branching LP iterations
Range: {0, ..., ∞} | 100000 |
| branching/relpscost/sbiterquot | maximal fraction of strong branching LP iterations compared to node relaxation LP iterations
Range: [0, ∞] | 0.5 |
| Options for expert users |
| branching/relpscost/confidencelevel | the confidence level for statistical methods, between 0 (Min) and 4 (Max).
Range: {0, ..., 4} | 2 |
| branching/relpscost/conflictlengthweight | weight in score calculations for conflict length score
Range: real | 0 |
| branching/relpscost/conflictweight | weight in score calculations for conflict score
Range: real | 0.01 |
| branching/relpscost/cutoffweight | weight in score calculations for cutoff score
Range: real | 0.0001 |
| branching/relpscost/degeneracyaware | should degeneracy be taken into account to update weights and skip strong branching? (0: off, 1: after root, 2: always)
Range: {0, ..., 2} | 1 |
| branching/relpscost/dynamicweights | should the weights of the branching rule be adjusted dynamically during solving based on objective and infeasible leaf counters?
Range: boolean | 1 |
| branching/relpscost/filtercandssym | Use symmetry to filter branching candidates?
Range: boolean | 0 |
| branching/relpscost/gmiavgeffweight | weight in score calculations for average GMI cuts normalized efficacy
Range: real | 0 |
| branching/relpscost/gmilasteffweight | weight in score calculations for last GMI cuts normalized efficacy
Range: real | 1e-05 |
| branching/relpscost/higherrortol | high relative error tolerance for reliability
Range: [0, ∞] | 1 |
| branching/relpscost/inferenceweight | weight in score calculations for inference score
Range: real | 0.0001 |
| branching/relpscost/lowerrortol | low relative error tolerance for reliability
Range: [0, ∞] | 0.05 |
| branching/relpscost/maxbdchgs | maximal number of bound tightenings before the node is reevaluated (-1: unlimited)
Range: {-1, ..., ∞} | 5 |
| branching/relpscost/maxlookahead | maximal number of further variables evaluated without better score
Range: {1, ..., ∞} | 9 |
| branching/relpscost/maxproprounds | maximum number of propagation rounds to be performed during strong branching before solving the LP (-1: no limit, -2: parameter settings)
Range: {-2, ..., ∞} | -2 |
| branching/relpscost/maxreliable | maximal value for minimum pseudo cost size to regard pseudo cost value as reliable
Range: [0, ∞] | 5 |
| branching/relpscost/minreliable | minimal value for minimum pseudo cost size to regard pseudo cost value as reliable
Range: [0, ∞] | 1 |
| branching/relpscost/nlscoreweight | weight in score calculations for nlcount score
Range: real | 0.1 |
| branching/relpscost/probingbounds | should valid bounds be identified in a probing-like fashion during strong branching (only with propagation)?
Range: boolean | 1 |
| branching/relpscost/pscostweight | weight in score calculations for pseudo cost score
Range: real | 1 |
| branching/relpscost/randinitorder | should candidates be initialized in randomized order?
Range: boolean | 0 |
| branching/relpscost/skipbadinitcands | should branching rule skip candidates that have a low probability to be better than the best strong-branching or pseudo-candidate?
Range: boolean | 1 |
| branching/relpscost/startrandseed | start seed for random number generation
Range: {0, ..., ∞} | 5 |
| branching/relpscost/storesemiinitcosts | should strong branching result be considered for pseudo costs if the other direction was infeasible?
Range: boolean | 0 |
| branching/relpscost/transsympscost | Transfer pscost information to symmetric variables?
Range: boolean | 0 |
| branching/relpscost/usedynamicconfidence | should the confidence level be adjusted dynamically?
Range: boolean | 0 |
| branching/relpscost/usehyptestforreliability | should the strong branching decision be based on a hypothesis test?
Range: boolean | 0 |
| branching/relpscost/userelerrorreliability | should reliability be based on relative errors?
Range: boolean | 0 |
| branching/relpscost/usesblocalinfo | should the scoring function use only local cutoff and inference information obtained for strong branching candidates?
Range: boolean | 0 |
| branching/relpscost/usesmallweightsitlim | should smaller weights be used for pseudo cost updates after hitting the LP iteration limit?
Range: boolean | 0 |
branching/treemodel
| Option | Description | Default |
| branching/treemodel/enable | should candidate branching variables be scored using the Treemodel branching rules?
Range: boolean | 0 |
| branching/treemodel/height | estimated tree height at which we switch from using the low rule to the high rule
Range: {0, ..., ∞} | 10 |
| branching/treemodel/highrule | scoring function to use at nodes predicted to be high in the tree ('d'efault, 's'vts, 'r'atio, 't'ree sample)
Range: d, s, r, t | r |
| branching/treemodel/lowrule | scoring function to use at nodes predicted to be low in the tree ('d'efault, 's'vts, 'r'atio, 't'ree sample)
Range: d, s, r, t | r |
| Options for expert users |
| branching/treemodel/fallbackinf | which method should be used as a fallback if the tree size estimates are infinite? ('d'efault, 'r'atio)
Range: d, r | r |
| branching/treemodel/fallbacknoprim | which method should be used as a fallback if there is no primal bound available? ('d'efault, 'r'atio)
Range: d, r | r |
| branching/treemodel/filterhigh | should dominated candidates be filtered before using the high scoring function? ('a'uto, 't'rue, 'f'alse)
Range: a, t, f | a |
| branching/treemodel/filterlow | should dominated candidates be filtered before using the low scoring function? ('a'uto, 't'rue, 'f'alse)
Range: a, t, f | a |
| branching/treemodel/maxfpiter | maximum number of fixed-point iterations when computing the ratio
Range: {1, ..., ∞} | 24 |
| branching/treemodel/maxsvtsheight | maximum height to compute the SVTS score exactly before approximating
Range: {0, ..., ∞} | 100 |
| branching/treemodel/smallpscost | threshold at which pseudocosts are considered small, making hybrid scores more likely to be the deciding factor in branching
Range: [0, ∞] | 0.1 |
branching/vanillafullstrong
| Option | Description | Default |
| branching/vanillafullstrong/idempotent | should strong branching side-effects be prevented (e.g., domain changes, stat updates etc.)?
Range: boolean | 0 |
| branching/vanillafullstrong/integralcands | should integral variables in the current LP solution be considered as branching candidates?
Range: boolean | 0 |
| branching/vanillafullstrong/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| branching/vanillafullstrong/maxdepth | maximal depth level, up to which branching rule <vanillafullstrong> should be used (-1 for no limit)
Range: {-1, ..., 1073741822} | -1 |
| branching/vanillafullstrong/priority | priority of branching rule <vanillafullstrong>
Range: {-536870912, ..., 536870911} | -2000 |
| Options for expert users |
| branching/vanillafullstrong/collectscores | should strong branching scores be collected?
Range: boolean | 0 |
| branching/vanillafullstrong/donotbranch | should candidates only be scored, but no branching be performed?
Range: boolean | 0 |
| branching/vanillafullstrong/scoreall | should strong branching scores be computed for all candidates, or can we early stop when a variable has infinite score?
Range: boolean | 0 |
conflict
| Option | Description | Default |
| conflict/conflictgraphweight | the weight the VSIDS score is weight by updating the VSIDS for a variable if it is part of a conflict graph
Range: [0, 1] | 1 |
| conflict/conflictweight | the weight the VSIDS score is weight by updating the VSIDS for a variable if it is part of a conflict
Range: [0, 1] | 0 |
| conflict/enable | should conflict analysis be enabled?
Range: boolean | 1 |
| conflict/preferbinary | should binary conflicts be preferred?
Range: boolean | 0 |
| conflict/restartfac | factor to increase restartnum with after each restart
Range: [0, ∞] | 1.5 |
| conflict/restartnum | number of successful conflict analysis calls that trigger a restart (0: disable conflict restarts)
Range: {0, ..., ∞} | 0 |
| conflict/sepaaltproofs | apply cut generating functions to construct alternative proofs
Range: boolean | 0 |
| conflict/useboundlp | should bound exceeding LP conflict analysis be used? ('o'ff, 'c'onflict graph, 'd'ual ray, 'b'oth conflict graph and dual ray)
Range: o, c, d, b | b |
| conflict/useinflp | should infeasible LP conflict analysis be used? ('o'ff, 'c'onflict graph, 'd'ual ray, 'b'oth conflict graph and dual ray)
Range: o, c, d, b | b |
| conflict/useprop | should propagation conflict analysis be used?
Range: boolean | 1 |
| conflict/usepseudo | should pseudo solution conflict analysis be used?
Range: boolean | 1 |
| conflict/usesb | should infeasible/bound exceeding strong branching conflict analysis be used?
Range: boolean | 1 |
| Options for expert users |
| conflict/allowlocal | should conflict constraints be generated that are only valid locally?
Range: boolean | 1 |
| conflict/cleanboundexceedings | should conflicts based on an old cutoff bound be removed from the conflict pool after improving the primal bound?
Range: boolean | 1 |
| conflict/downlockscorefac | score factor for down locks in bound relaxation heuristic
Range: real | 0 |
| conflict/dynamic | should the conflict constraints be subject to aging?
Range: boolean | 1 |
| conflict/fuiplevels | number of depth levels up to which first UIP's are used in conflict analysis (-1: use All-FirstUIP rule)
Range: {-1, ..., ∞} | -1 |
| conflict/fullshortenconflict | try to shorten the whole conflict set or terminate early (depending on the 'maxvarsdetectimpliedbounds' parameter)
Range: boolean | 1 |
| conflict/ignorerelaxedbd | should relaxed bounds be ignored?
Range: boolean | 0 |
| conflict/interconss | maximal number of intermediate conflict constraints generated in conflict graph (-1: use every intermediate constraint)
Range: {-1, ..., ∞} | -1 |
| conflict/keepreprop | should constraints be kept for repropagation even if they are too long?
Range: boolean | 1 |
| conflict/lpiterations | maximal number of LP iterations in each LP resolving loop (-1: no limit)
Range: {-1, ..., ∞} | 10 |
| conflict/maxconss | maximal number of conflict constraints accepted at an infeasible node (-1: use all generated conflict constraints)
Range: {-1, ..., ∞} | 10 |
| conflict/maxlploops | maximal number of LP resolving loops during conflict analysis (-1: no limit)
Range: {-1, ..., ∞} | 2 |
| conflict/maxstoresize | maximal size of conflict store (-1: auto, 0: disable storage)
Range: {-1, ..., ∞} | 10000 |
| conflict/maxvarsdetectimpliedbounds | maximal number of variables to try to detect global bound implications and shorten the whole conflict set (0: disabled)
Range: {0, ..., ∞} | 250 |
| conflict/maxvarsfac | maximal fraction of variables involved in a conflict constraint
Range: [0, ∞] | 0.15 |
| conflict/minimprove | minimal improvement of primal bound to remove conflicts based on a previous incumbent
Range: [0, 1] | 0.05 |
| conflict/minmaxvars | minimal absolute maximum of variables involved in a conflict constraint
Range: {0, ..., ∞} | 0 |
| conflict/prefinfproof | prefer infeasibility proof to boundexceeding proof
Range: boolean | 1 |
| conflict/proofscorefac | score factor for impact on acticity in bound relaxation heuristic
Range: real | 1 |
| conflict/reconvlevels | number of depth levels up to which UIP reconvergence constraints are generated (-1: generate reconvergence constraints in all depth levels)
Range: {-1, ..., ∞} | -1 |
| conflict/removable | should the conflict's relaxations be subject to LP aging and cleanup?
Range: boolean | 1 |
| conflict/repropagate | should earlier nodes be repropagated in order to replace branching decisions by deductions?
Range: boolean | 1 |
| conflict/scorefac | factor to decrease importance of variables' earlier conflict scores
Range: [1e-06, 1] | 0.98 |
| conflict/separate | should the conflict constraints be separated?
Range: boolean | 1 |
| conflict/settlelocal | should conflict constraints be attached only to the local subtree where they can be useful?
Range: boolean | 0 |
| conflict/uplockscorefac | score factor for up locks in bound relaxation heuristic
Range: real | 0 |
| conflict/uselocalrows | use local rows to construct infeasibility proofs
Range: boolean | 1 |
| conflict/weightrepropdepth | weight of the repropagation depth of a conflict used in score calculation
Range: [0, 1] | 0.1 |
| conflict/weightsize | weight of the size of a conflict used in score calculation
Range: [0, 1] | 0.001 |
| conflict/weightvaliddepth | weight of the valid depth of a conflict used in score calculation
Range: [0, 1] | 1 |
conflict/bounddisjunction
| Option | Description | Default |
| conflict/bounddisjunction/continuousfrac | maximal percantage of continuous variables within a conflict
Range: [0, 1] | 0.4 |
| Options for expert users |
| conflict/bounddisjunction/priority | priority of conflict handler <bounddisjunction>
Range: {-2147483648, ..., ∞} | -3000000 |
conflict/graph
| Option | Description | Default |
| Options for expert users |
| conflict/graph/depthscorefac | score factor for depth level in bound relaxation heuristic
Range: real | 1 |
conflict/indicatorconflict
| Option | Description | Default |
| Options for expert users |
| conflict/indicatorconflict/priority | priority of conflict handler <indicatorconflict>
Range: {-2147483648, ..., ∞} | 200000 |
conflict/linear
| Option | Description | Default |
| Options for expert users |
| conflict/linear/priority | priority of conflict handler <linear>
Range: {-2147483648, ..., ∞} | -1000000 |
conflict/logicor
| Option | Description | Default |
| Options for expert users |
| conflict/logicor/priority | priority of conflict handler <logicor>
Range: {-2147483648, ..., ∞} | 800000 |
conflict/setppc
| Option | Description | Default |
| Options for expert users |
| conflict/setppc/priority | priority of conflict handler <setppc>
Range: {-2147483648, ..., ∞} | 700000 |
constraints
| Option | Description | Default |
| Options for expert users |
| constraints/agelimit | maximum age an unnecessary constraint can reach before it is deleted (0: dynamic, -1: keep all constraints)
Range: {-1, ..., ∞} | 0 |
| constraints/disableenfops | should enforcement of pseudo solution be disabled?
Range: boolean | 0 |
| constraints/obsoleteage | age of a constraint after which it is marked obsolete (0: dynamic, -1 do not mark constraints obsolete)
Range: {-1, ..., ∞} | -1 |
constraints/SOS1
| Option | Description | Default |
| constraints/SOS1/branchnonzeros | Branch on SOS constraint with most number of nonzeros?
Range: boolean | 0 |
| constraints/SOS1/branchsos | Use SOS1 branching in enforcing (otherwise leave decision to branching rules)? This value can only be set to false if all SOS1 variables are binary
Range: boolean | 1 |
| constraints/SOS1/branchweight | Branch on SOS cons. with highest nonzero-variable weight for branching (needs branchnonzeros = false)?
Range: boolean | 0 |
| constraints/SOS1/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 1 |
| constraints/SOS1/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 10 |
| Options for expert users |
| constraints/SOS1/addbdsfeas | minimal feasibility value for bound inequalities in order to be added to the branching node
Range: real | 1 |
| constraints/SOS1/addcomps | if TRUE then add complementarity constraints to the branching nodes (can be used in combination with neighborhood or bipartite branching)
Range: boolean | 0 |
| constraints/SOS1/addcompsdepth | only add complementarity constraints to branching nodes for predefined depth (-1: no limit)
Range: {-1, ..., ∞} | 30 |
| constraints/SOS1/addcompsfeas | minimal feasibility value for complementarity constraints in order to be added to the branching node
Range: real | -0.6 |
| constraints/SOS1/addextendedbds | should added complementarity constraints be extended to SOS1 constraints to get tighter bound inequalities
Range: boolean | 1 |
| constraints/SOS1/autocutsfromsos1 | if TRUE then automatically switch to separating initial SOS1 constraints if the SOS1 constraints do not overlap
Range: boolean | 1 |
| constraints/SOS1/autosos1branch | if TRUE then automatically switch to SOS1 branching if the SOS1 constraints do not overlap
Range: boolean | 1 |
| constraints/SOS1/boundcutsdepth | node depth of separating bound cuts (-1: no limit)
Range: {-1, ..., ∞} | 40 |
| constraints/SOS1/boundcutsfreq | frequency for separating bound cuts; zero means to separate only in the root node
Range: {-1, ..., 1073741822} | 10 |
| constraints/SOS1/boundcutsfromgraph | if TRUE separate bound inequalities from the conflict graph
Range: boolean | 1 |
| constraints/SOS1/boundcutsfromsos1 | if TRUE separate bound inequalities from initial SOS1 constraints
Range: boolean | 0 |
| constraints/SOS1/branchingrule | which branching rule should be applied ? ('n': neighborhood, 'b': bipartite, 's': SOS1/clique) (note: in some cases an automatic switching to SOS1 branching is possible)
Range: n, b, s | n |
| constraints/SOS1/conflictprop | whether to use conflict graph propagation
Range: boolean | 1 |
| constraints/SOS1/delayprop | should propagation method be delayed, if other propagators found reductions?
Range: boolean | 0 |
| constraints/SOS1/delaysepa | should separation method be delayed, if other separators found cuts?
Range: boolean | 0 |
| constraints/SOS1/depthimplanalysis | number of recursive calls of implication graph analysis (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| constraints/SOS1/eagerfreq | frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 1073741822} | 100 |
| constraints/SOS1/fixnonzero | if neighborhood branching is used, then fix the branching variable (if positive in sign) to the value of the feasibility tolerance
Range: boolean | 0 |
| constraints/SOS1/implcutsdepth | node depth of separating implied bound cuts (-1: no limit)
Range: {-1, ..., ∞} | 40 |
| constraints/SOS1/implcutsfreq | frequency for separating implied bound cuts; zero means to separate only in the root node
Range: {-1, ..., 1073741822} | 0 |
| constraints/SOS1/implprop | whether to use implication graph propagation
Range: boolean | 1 |
| constraints/SOS1/maxaddcomps | maximal number of complementarity constraints added per branching node (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| constraints/SOS1/maxboundcuts | maximal number of bound cuts separated per branching node
Range: {0, ..., ∞} | 50 |
| constraints/SOS1/maxboundcutsroot | maximal number of bound cuts separated per iteration in the root node
Range: {0, ..., ∞} | 150 |
| constraints/SOS1/maxextensions | maximal number of extensions that will be computed for each SOS1 constraint (-1: no limit)
Range: {-1, ..., ∞} | 1 |
| constraints/SOS1/maximplcuts | maximal number of implied bound cuts separated per branching node
Range: {0, ..., ∞} | 50 |
| constraints/SOS1/maximplcutsroot | maximal number of implied bound cuts separated per iteration in the root node
Range: {0, ..., ∞} | 150 |
| constraints/SOS1/maxprerounds | maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| constraints/SOS1/maxsosadjacency | do not create an adjacency matrix if number of SOS1 variables is larger than predefined value (-1: no limit)
Range: {-1, ..., ∞} | 10000 |
| constraints/SOS1/maxtightenbds | maximal number of bound tightening rounds per presolving round (-1: no limit)
Range: {-1, ..., ∞} | 5 |
| constraints/SOS1/nstrongiter | maximal number LP iterations to perform for each strong branching round (-2: auto, -1: no limit)
Range: {-2, ..., ∞} | 10000 |
| constraints/SOS1/nstrongrounds | maximal number of strong branching rounds to perform for each node (-1: auto); only available for neighborhood and bipartite branching
Range: {-1, ..., ∞} | 0 |
| constraints/SOS1/perfimplanalysis | if TRUE then perform implication graph analysis (might add additional SOS1 constraints)
Range: boolean | 0 |
| constraints/SOS1/presoltiming | timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 8 |
| constraints/SOS1/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
| constraints/SOS1/sosconsprop | whether to use SOS1 constraint propagation
Range: boolean | 0 |
| constraints/SOS1/strthenboundcuts | if TRUE then bound cuts are strengthened in case bound variables are available
Range: boolean | 1 |
constraints/SOS2
| Option | Description | Default |
| constraints/SOS2/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 1 |
| constraints/SOS2/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 0 |
| Options for expert users |
| constraints/SOS2/delayprop | should propagation method be delayed, if other propagators found reductions?
Range: boolean | 0 |
| constraints/SOS2/delaysepa | should separation method be delayed, if other separators found cuts?
Range: boolean | 0 |
| constraints/SOS2/eagerfreq | frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 1073741822} | 100 |
| constraints/SOS2/maxprerounds | maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| constraints/SOS2/presoltiming | timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 4 |
| constraints/SOS2/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
constraints/and
| Option | Description | Default |
| constraints/and/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 1 |
| constraints/and/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 1 |
| Options for expert users |
| constraints/and/aggrlinearization | should an aggregated linearization be used?
Range: boolean | 0 |
| constraints/and/delayprop | should propagation method be delayed, if other propagators found reductions?
Range: boolean | 0 |
| constraints/and/delaysepa | should separation method be delayed, if other separators found cuts?
Range: boolean | 0 |
| constraints/and/dualpresolving | should dual presolving be performed?
Range: boolean | 1 |
| constraints/and/eagerfreq | frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 1073741822} | 100 |
| constraints/and/enforcecuts | should cuts be separated during LP enforcing?
Range: boolean | 1 |
| constraints/and/linearize | should the AND-constraint get linearized and removed (in presolving)?
Range: boolean | 0 |
| constraints/and/maxprerounds | maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| constraints/and/presolpairwise | should pairwise constraint comparison be performed in presolving?
Range: boolean | 1 |
| constraints/and/presoltiming | timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 20 |
| constraints/and/presolusehashing | should hash table be used for detecting redundant constraints in advance
Range: boolean | 1 |
| constraints/and/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
| constraints/and/upgraderesultant | should all binary resultant variables be upgraded to implicit binary variables?
Range: boolean | 1 |
constraints/bounddisjunction
| Option | Description | Default |
| constraints/bounddisjunction/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 1 |
| constraints/bounddisjunction/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | -1 |
| Options for expert users |
| constraints/bounddisjunction/delayprop | should propagation method be delayed, if other propagators found reductions?
Range: boolean | 0 |
| constraints/bounddisjunction/delaysepa | should separation method be delayed, if other separators found cuts?
Range: boolean | 0 |
| constraints/bounddisjunction/eagerfreq | frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 1073741822} | 100 |
| constraints/bounddisjunction/maxprerounds | maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| constraints/bounddisjunction/presoltiming | timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 4 |
| constraints/bounddisjunction/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
constraints/components
| Option | Description | Default |
| constraints/components/intfactor | the weight of an integer variable compared to binary variables
Range: [0, ∞] | 1 |
| constraints/components/maxdepth | maximum depth of a node to run components detection (-1: disable component detection during solving)
Range: {-1, ..., ∞} | -1 |
| constraints/components/nodelimit | maximum number of nodes to be solved in subproblems during presolving
Range: {-1, ..., ∞} | 10000 |
| constraints/components/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 1 |
| constraints/components/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | -1 |
| Options for expert users |
| constraints/components/delayprop | should propagation method be delayed, if other propagators found reductions?
Range: boolean | 1 |
| constraints/components/delaysepa | should separation method be delayed, if other separators found cuts?
Range: boolean | 0 |
| constraints/components/eagerfreq | frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 1073741822} | -1 |
| constraints/components/feastolfactor | factor to increase the feasibility tolerance of the main SCIP in all sub-SCIPs, default value 1.0
Range: [0, 1e+06] | 1 |
| constraints/components/maxintvars | maximum number of integer (or binary) variables to solve a subproblem during presolving (-1: unlimited)
Range: {-1, ..., ∞} | 500 |
| constraints/components/maxprerounds | maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| constraints/components/minrelsize | minimum relative size (in terms of variables) to solve a component individually during branch-and-bound
Range: [0, 1] | 0.1 |
| constraints/components/minsize | minimum absolute size (in terms of variables) to solve a component individually during branch-and-bound
Range: {0, ..., ∞} | 50 |
| constraints/components/presoltiming | timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 32 |
| constraints/components/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
constraints/fixedvar
| Option | Description | Default |
| constraints/fixedvar/enabled | whether to check and enforce bounds on fixed variables
Range: boolean | 1 |
| constraints/fixedvar/prefercut | whether to prefer separation over tightening LP feastol in enforcement
Range: boolean | 1 |
| constraints/fixedvar/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | -1 |
| constraints/fixedvar/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | -1 |
| constraints/fixedvar/subscips | whether to act on subSCIPs
Range: boolean | 1 |
| Options for expert users |
| constraints/fixedvar/delayprop | should propagation method be delayed, if other propagators found reductions?
Range: boolean | 0 |
| constraints/fixedvar/delaysepa | should separation method be delayed, if other separators found cuts?
Range: boolean | 0 |
| constraints/fixedvar/eagerfreq | frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 1073741822} | -1 |
| constraints/fixedvar/maxprerounds | maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞} | 0 |
| constraints/fixedvar/presoltiming | timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 28 |
| constraints/fixedvar/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
constraints/indicator
| Option | Description | Default |
| constraints/indicator/maxsepacuts | maximal number of cuts separated per separation round
Range: {0, ..., ∞} | 100 |
| constraints/indicator/maxsepacutsroot | maximal number of cuts separated per separation round in the root node
Range: {0, ..., ∞} | 2000 |
| constraints/indicator/maxsepanonviolated | maximal number of separated non violated IISs, before separation is stopped
Range: {0, ..., ∞} | 3 |
| constraints/indicator/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 1 |
| constraints/indicator/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 10 |
| Options for expert users |
| constraints/indicator/addcoupling | Add coupling constraints or rows if big-M is small enough?
Range: boolean | 1 |
| constraints/indicator/addcouplingcons | Add initial variable upper bound constraints, if 'addcoupling' is true?
Range: boolean | 0 |
| constraints/indicator/addopposite | Add opposite inequality in nodes in which the binary variable has been fixed to 0?
Range: boolean | 0 |
| constraints/indicator/branchindicators | Branch on indicator constraints in enforcing?
Range: boolean | 0 |
| constraints/indicator/conflictsupgrade | Try to upgrade bounddisjunction conflicts by replacing slack variables?
Range: boolean | 0 |
| constraints/indicator/delayprop | should propagation method be delayed, if other propagators found reductions?
Range: boolean | 0 |
| constraints/indicator/delaysepa | should separation method be delayed, if other separators found cuts?
Range: boolean | 0 |
| constraints/indicator/dualreductions | Should dual reduction steps be performed?
Range: boolean | 1 |
| constraints/indicator/eagerfreq | frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 1073741822} | 100 |
| constraints/indicator/enforcecuts | In enforcing try to generate cuts (only if sepaalternativelp is true)?
Range: boolean | 0 |
| constraints/indicator/forcerestart | Force restart if absolute gap is 1 or enough binary variables have been fixed?
Range: boolean | 0 |
| constraints/indicator/generatebilinear | Do not generate indicator constraint, but a bilinear constraint instead?
Range: boolean | 0 |
| constraints/indicator/genlogicor | Generate logicor constraints instead of cuts?
Range: boolean | 0 |
| constraints/indicator/maxconditionaltlp | maximum estimated condition of the solution basis matrix of the alternative LP to be trustworthy (0.0 to disable check)
Range: [0, ∞] | 0 |
| constraints/indicator/maxcouplingvalue | maximum coefficient for binary variable in coupling constraint
Range: [0, 1e+09] | 10000 |
| constraints/indicator/maxprerounds | maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| constraints/indicator/nolinconscont | Decompose problem (do not generate linear constraint if all variables are continuous)?
Range: boolean | 0 |
| constraints/indicator/presoltiming | timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 4 |
| constraints/indicator/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
| constraints/indicator/removeindicators | Remove indicator constraint if corresponding variable bound constraint has been added?
Range: boolean | 0 |
| constraints/indicator/restartfrac | fraction of binary variables that need to be fixed before restart occurs (in forcerestart)
Range: [0, 1] | 0.9 |
| constraints/indicator/scaleslackvar | Scale slack variable coefficient at construction time?
Range: boolean | 0 |
| constraints/indicator/sepaalternativelp | Separate using the alternative LP?
Range: boolean | 0 |
| constraints/indicator/sepacouplingcuts | Should the coupling inequalities be separated dynamically?
Range: boolean | 1 |
| constraints/indicator/sepacouplinglocal | Allow to use local bounds in order to separate coupling inequalities?
Range: boolean | 0 |
| constraints/indicator/sepacouplingvalue | maximum coefficient for binary variable in separated coupling constraint
Range: [0, 1e+09] | 10000 |
| constraints/indicator/sepaperspective | Separate cuts based on perspective formulation?
Range: boolean | 0 |
| constraints/indicator/sepapersplocal | Allow to use local bounds in order to separate perspective cuts?
Range: boolean | 1 |
| constraints/indicator/trysolfromcover | Try to construct a feasible solution from a cover?
Range: boolean | 0 |
| constraints/indicator/trysolutions | Try to make solutions feasible by setting indicator variables?
Range: boolean | 1 |
| constraints/indicator/updatebounds | Update bounds of original variables for separation?
Range: boolean | 0 |
| constraints/indicator/upgradelinear | Try to upgrade linear constraints to indicator constraints?
Range: boolean | 0 |
| constraints/indicator/useobjectivecut | Use objective cut with current best solution to alternative LP?
Range: boolean | 0 |
| constraints/indicator/useotherconss | Collect other constraints to alternative LP?
Range: boolean | 0 |
constraints/integral
| Option | Description | Default |
| constraints/integral/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | -1 |
| constraints/integral/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | -1 |
| Options for expert users |
| constraints/integral/delayprop | should propagation method be delayed, if other propagators found reductions?
Range: boolean | 0 |
| constraints/integral/delaysepa | should separation method be delayed, if other separators found cuts?
Range: boolean | 0 |
| constraints/integral/eagerfreq | frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 1073741822} | -1 |
| constraints/integral/maxprerounds | maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞} | 0 |
| constraints/integral/presoltiming | timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 28 |
| constraints/integral/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
constraints/knapsack
| Option | Description | Default |
| constraints/knapsack/maxrounds | maximal number of separation rounds per node (-1: unlimited)
Range: {-1, ..., ∞} | 5 |
| constraints/knapsack/maxroundsroot | maximal number of separation rounds per node in the root node (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| constraints/knapsack/maxsepacuts | maximal number of cuts separated per separation round
Range: {0, ..., ∞} | 50 |
| constraints/knapsack/maxsepacutsroot | maximal number of cuts separated per separation round in the root node
Range: {0, ..., ∞} | 200 |
| constraints/knapsack/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 1 |
| constraints/knapsack/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 0 |
| Options for expert users |
| constraints/knapsack/cliqueextractfactor | lower clique size limit for greedy clique extraction algorithm (relative to largest clique)
Range: [0, 1] | 0.5 |
| constraints/knapsack/clqpartupdatefac | factor on the growth of global cliques to decide when to update a previous (negated) clique partition (used only if updatecliquepartitions is set to TRUE)
Range: [1, 10] | 1.5 |
| constraints/knapsack/delayprop | should propagation method be delayed, if other propagators found reductions?
Range: boolean | 0 |
| constraints/knapsack/delaysepa | should separation method be delayed, if other separators found cuts?
Range: boolean | 0 |
| constraints/knapsack/detectcutoffbound | should presolving try to detect constraints parallel to the objective function defining an upper bound and prevent these constraints from entering the LP?
Range: boolean | 1 |
| constraints/knapsack/detectlowerbound | should presolving try to detect constraints parallel to the objective function defining a lower bound and prevent these constraints from entering the LP?
Range: boolean | 1 |
| constraints/knapsack/disaggregation | should disaggregation of knapsack constraints be allowed in preprocessing?
Range: boolean | 1 |
| constraints/knapsack/dualpresolving | should dual presolving steps be performed?
Range: boolean | 1 |
| constraints/knapsack/eagerfreq | frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 1073741822} | 100 |
| constraints/knapsack/maxcardbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for separating knapsack cuts
Range: [0, 1] | 0 |
| constraints/knapsack/maxprerounds | maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| constraints/knapsack/negatedclique | should negated clique information be used in solving process
Range: boolean | 1 |
| constraints/knapsack/presolpairwise | should pairwise constraint comparison be performed in presolving?
Range: boolean | 1 |
| constraints/knapsack/presoltiming | timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 28 |
| constraints/knapsack/presolusehashing | should hash table be used for detecting redundant constraints in advance
Range: boolean | 1 |
| constraints/knapsack/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
| constraints/knapsack/sepacardfreq | multiplier on separation frequency, how often knapsack cuts are separated (-1: never, 0: only at root)
Range: {-1, ..., 1073741822} | 1 |
| constraints/knapsack/simplifyinequalities | should presolving try to simplify knapsacks
Range: boolean | 1 |
| constraints/knapsack/updatecliquepartitions | should clique partition information be updated when old partition seems outdated?
Range: boolean | 0 |
| constraints/knapsack/usegubs | should GUB information be used for separation?
Range: boolean | 0 |
constraints/linear
| Option | Description | Default |
| constraints/linear/maxrounds | maximal number of separation rounds per node (-1: unlimited)
Range: {-1, ..., ∞} | 5 |
| constraints/linear/maxroundsroot | maximal number of separation rounds per node in the root node (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| constraints/linear/maxsepacuts | maximal number of cuts separated per separation round
Range: {0, ..., ∞} | 50 |
| constraints/linear/maxsepacutsroot | maximal number of cuts separated per separation round in the root node
Range: {0, ..., ∞} | 200 |
| constraints/linear/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 1 |
| constraints/linear/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 0 |
| constraints/linear/separateall | should all constraints be subject to cardinality cut generation instead of only the ones with non-zero dual value?
Range: boolean | 0 |
| Options for expert users |
| constraints/linear/aggregatevariables | should presolving search for aggregations in equations
Range: boolean | 1 |
| constraints/linear/checkrelmaxabs | should the violation for a constraint with side 0.0 be checked relative to 1.0 (FALSE) or to the maximum absolute value in the activity (TRUE)?
Range: boolean | 0 |
| constraints/linear/delayprop | should propagation method be delayed, if other propagators found reductions?
Range: boolean | 0 |
| constraints/linear/delaysepa | should separation method be delayed, if other separators found cuts?
Range: boolean | 0 |
| constraints/linear/detectcutoffbound | should presolving try to detect constraints parallel to the objective function defining an upper bound and prevent these constraints from entering the LP?
Range: boolean | 1 |
| constraints/linear/detectlowerbound | should presolving try to detect constraints parallel to the objective function defining a lower bound and prevent these constraints from entering the LP?
Range: boolean | 1 |
| constraints/linear/detectpartialobjective | should presolving try to detect subsets of constraints parallel to the objective function?
Range: boolean | 1 |
| constraints/linear/dualpresolving | should dual presolving steps be performed?
Range: boolean | 1 |
| constraints/linear/eagerfreq | frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 1073741822} | 100 |
| constraints/linear/extractcliques | should Cliques be extracted?
Range: boolean | 1 |
| constraints/linear/maxaggrnormscale | maximal allowed relative gain in maximum norm for constraint aggregation (0.0: disable constraint aggregation)
Range: [0, ∞] | 0 |
| constraints/linear/maxcardbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for separating knapsack cardinality cuts
Range: [0, 1] | 0 |
| constraints/linear/maxdualmultaggrquot | maximum coefficient dynamism (ie. maxabsval / minabsval) for dual multiaggregation
Range: [1, ∞] | ∞ |
| constraints/linear/maxeasyactivitydelta | maximum activity delta to run easy propagation on linear constraint (faster, but numerically less stable)
Range: [0, ∞] | 1e+06 |
| constraints/linear/maxmultaggrquot | maximum coefficient dynamism (ie. maxabsval / minabsval) for primal multiaggregation
Range: [1, ∞] | 1000 |
| constraints/linear/maxprerounds | maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| constraints/linear/mingainpernmincomparisons | minimal gain per minimal pairwise presolve comparisons to repeat pairwise comparison round
Range: [0, 1] | 1e-06 |
| constraints/linear/multaggrremove | should multi-aggregations only be performed if the constraint can be removed afterwards?
Range: boolean | 0 |
| constraints/linear/nmincomparisons | number for minimal pairwise presolve comparisons
Range: {1, ..., ∞} | 200000 |
| constraints/linear/presolpairwise | should pairwise constraint comparison be performed in presolving?
Range: boolean | 1 |
| constraints/linear/presoltiming | timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 20 |
| constraints/linear/presolusehashing | should hash table be used for detecting redundant constraints in advance
Range: boolean | 1 |
| constraints/linear/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
| constraints/linear/rangedrowartcons | should presolving and propagation extract sub-constraints from ranged rows and equations?
Range: boolean | 1 |
| constraints/linear/rangedrowfreq | frequency for applying ranged row propagation
Range: {1, ..., 1073741822} | 1 |
| constraints/linear/rangedrowmaxdepth | maximum depth to apply ranged row propagation
Range: {0, ..., ∞} | ∞ |
| constraints/linear/rangedrowpropagation | should presolving and propagation try to improve bounds, detect infeasibility, and extract sub-constraints from ranged rows and equations?
Range: boolean | 1 |
| constraints/linear/simplifyinequalities | should presolving try to simplify inequalities
Range: boolean | 1 |
| constraints/linear/singletonstuffing | should stuffing of singleton continuous variables be performed?
Range: boolean | 1 |
| constraints/linear/singlevarstuffing | should single variable stuffing be performed, which tries to fulfill constraints using the cheapest variable?
Range: boolean | 0 |
| constraints/linear/sortvars | apply binaries sorting in decr. order of coeff abs value?
Range: boolean | 1 |
| constraints/linear/tightenboundsfreq | multiplier on propagation frequency, how often the bounds are tightened (-1: never, 0: only at root)
Range: {-1, ..., 1073741822} | 1 |
constraints/linear/upgrade
| Option | Description | Default |
| constraints/linear/upgrade/indicator | enable linear upgrading for constraint handler <indicator>
Range: boolean | 1 |
| constraints/linear/upgrade/knapsack | enable linear upgrading for constraint handler <knapsack>
Range: boolean | 1 |
| constraints/linear/upgrade/logicor | enable linear upgrading for constraint handler <logicor>
Range: boolean | 1 |
| constraints/linear/upgrade/setppc | enable linear upgrading for constraint handler <setppc>
Range: boolean | 1 |
| constraints/linear/upgrade/varbound | enable linear upgrading for constraint handler <varbound>
Range: boolean | 1 |
| constraints/linear/upgrade/xor | enable linear upgrading for constraint handler <xor>
Range: boolean | 1 |
constraints/logicor
| Option | Description | Default |
| constraints/logicor/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 1 |
| constraints/logicor/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 0 |
| Options for expert users |
| constraints/logicor/delayprop | should propagation method be delayed, if other propagators found reductions?
Range: boolean | 0 |
| constraints/logicor/delaysepa | should separation method be delayed, if other separators found cuts?
Range: boolean | 0 |
| constraints/logicor/dualpresolving | should dual presolving steps be performed?
Range: boolean | 1 |
| constraints/logicor/eagerfreq | frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 1073741822} | 100 |
| constraints/logicor/implications | should implications/cliques be used in presolving
Range: boolean | 1 |
| constraints/logicor/maxprerounds | maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| constraints/logicor/negatedclique | should negated clique information be used in presolving
Range: boolean | 1 |
| constraints/logicor/presolpairwise | should pairwise constraint comparison be performed in presolving?
Range: boolean | 1 |
| constraints/logicor/presoltiming | timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 28 |
| constraints/logicor/presolusehashing | should hash table be used for detecting redundant constraints in advance
Range: boolean | 1 |
| constraints/logicor/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
| constraints/logicor/strengthen | should pairwise constraint comparison try to strengthen constraints by removing superflous non-zeros?
Range: boolean | 1 |
constraints/nonlinear
| Option | Description | Default |
| constraints/nonlinear/assumeconvex | whether to assume that any constraint is convex
Range: boolean | 0 |
| constraints/nonlinear/bilinmaxnauxexprs | maximal number of auxiliary expressions per bilinear term
Range: {0, ..., ∞} | 10 |
| constraints/nonlinear/linearizeheursol | whether tight linearizations of nonlinear constraints should be added to cutpool when some heuristics finds a new solution ('o'ff, on new 'i'ncumbents, on 'e'very solution)
Range: o, i, e | i if QCP or NLP, o otherwise |
| constraints/nonlinear/maxproprounds | limit on number of propagation rounds for a set of constraints within one round of SCIP propagation
Range: {0, ..., ∞} | 10 |
| constraints/nonlinear/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 1 |
| constraints/nonlinear/reformbinprods | whether to reformulate products of binary variables during presolving
Range: boolean | 1 |
| constraints/nonlinear/reformbinprodsand | whether to use the AND constraint handler for reformulating binary products
Range: boolean | 1 |
| constraints/nonlinear/reformbinprodsfac | minimum number of terms to reformulate bilinear binary products by factorizing variables (≤ 1: disabled)
Range: {1, ..., ∞} | 50 |
| constraints/nonlinear/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 1 |
| Options for expert users |
| constraints/nonlinear/checkvarlocks | whether variables contained in a single constraint should be forced to be at their lower or upper bounds ('d'isable, change 't'ype, add 'b'ound disjunction)
Range: b, d, t | t |
| constraints/nonlinear/conssiderelaxamount | by how much to relax constraint sides during bound tightening
Range: [0, 1] | 1e-09 |
| constraints/nonlinear/delayprop | should propagation method be delayed, if other propagators found reductions?
Range: boolean | 0 |
| constraints/nonlinear/delaysepa | should separation method be delayed, if other separators found cuts?
Range: boolean | 0 |
| constraints/nonlinear/eagerfreq | frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 1073741822} | 100 |
| constraints/nonlinear/enfoauxviolfactor | an expression will be enforced if the "auxiliary" violation is at least this factor times the "original" violation
Range: [0, 1] | 0.01 |
| constraints/nonlinear/forbidmultaggrnlvar | whether to forbid multiaggregation of nonlinear variables
Range: boolean | 1 |
| constraints/nonlinear/forcestrongcut | whether to force "strong" cuts in enforcement
Range: boolean | 0 |
| constraints/nonlinear/maxprerounds | maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| constraints/nonlinear/presoltiming | timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 28 |
| constraints/nonlinear/propauxvars | whether to check bounds of all auxiliary variable to seed reverse propagation
Range: boolean | 1 |
| constraints/nonlinear/propinenforce | whether to (re)run propagation in enforcement
Range: boolean | 0 |
| constraints/nonlinear/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
| constraints/nonlinear/rownotremovable | whether to make rows to be non-removable in the node where they are added (can prevent some cycling): 'o'ff, in 'e'nforcement only, 'a'lways
Range: o, e, a | o |
| constraints/nonlinear/strongcutefficacy | consider efficacy requirement when deciding whether a cut is "strong"
Range: boolean | 0 |
| constraints/nonlinear/strongcutmaxcoef | "strong" cuts will be scaled to have their maximal coef in [1/strongcutmaxcoef,strongcutmaxcoef]
Range: [1, ∞] | 1000 |
| constraints/nonlinear/tightenlpfeastol | whether to tighten LP feasibility tolerance during enforcement, if it seems useful
Range: boolean | 1 |
| constraints/nonlinear/varboundrelax | strategy on how to relax variable bounds during bound tightening: relax (n)ot, relax by (a)bsolute value, relax always by a(b)solute value, relax by (r)relative value
Range: n, a, b, r | r |
| constraints/nonlinear/varboundrelaxamount | by how much to relax variable bounds during bound tightening if strategy 'a', 'b', or 'r'
Range: [0, 1] | 1e-09 |
| constraints/nonlinear/violscale | method how to scale violations to make them comparable (not used for feasibility check): (n)one, (a)ctivity and side, norm of (g)radient
Range: n, a, g | n |
| constraints/nonlinear/vpadjfacetthresh | adjust computed facet of envelope of vertex-polyhedral function up to a violation of this value times LP feasibility tolerance
Range: [0, ∞] | 10 |
| constraints/nonlinear/vpdualsimplex | whether to use dual simplex instead of primal simplex for LP that computes facet of vertex-polyhedral function
Range: boolean | 1 |
| constraints/nonlinear/vpmaxperturb | maximal relative perturbation of reference point when computing facet of envelope of vertex-polyhedral function (dim>2)
Range: [0, 1] | 0.001 |
| constraints/nonlinear/weakcutminviolfactor | retry enfo of constraint with weak cuts if violation is least this factor of maximal violated constraints
Range: [0, 2] | 0.5 |
| constraints/nonlinear/weakcutthreshold | threshold for when to regard a cut from an estimator as weak (lower values allow more weak cuts)
Range: [0, 1] | 0.2 |
constraints/nonlinear/branching
| Option | Description | Default |
| constraints/nonlinear/branching/aux | from which depth on in the tree to allow branching on auxiliary variables (variables added for extended formulation)
Range: {0, ..., ∞} | ∞ |
| constraints/nonlinear/branching/domainweight | weight by how much to consider the domain width in branching score
Range: [0, ∞] | 0 |
| constraints/nonlinear/branching/dualweight | weight by how much to consider the dual values of rows that contain a variable for its branching score
Range: [0, ∞] | 0 |
| constraints/nonlinear/branching/external | whether to use external branching candidates and branching rules for branching
Range: boolean | 0 |
| constraints/nonlinear/branching/fracweight | weight by how much to consider fractionality of integer variables in branching score for spatial branching
Range: [0, ∞] | 1 |
| constraints/nonlinear/branching/highscorefactor | consider a variable branching score high if its branching score ≥ this factor * maximal branching score among all variables
Range: [0, 1] | 0.9 |
| constraints/nonlinear/branching/highviolfactor | consider a constraint highly violated if its violation is ≥ this factor * maximal violation among all constraints
Range: [0, 1] | 0 |
| constraints/nonlinear/branching/mixfractional | minimal average pseudo cost count for discrete variables at which to start considering spatial branching before branching on fractional integer variables
Range: [0, ∞] | ∞ |
| constraints/nonlinear/branching/pscostreliable | minimum pseudo-cost update count required to consider pseudo-costs reliable
Range: [0, ∞] | 2 |
| constraints/nonlinear/branching/pscostweight | weight by how much to consider the pseudo cost of a variable for its branching score
Range: [0, ∞] | 1 |
| constraints/nonlinear/branching/scoreagg | how to aggregate several branching scores given for the same expression: 'a'verage, 'm'aximum, 's'um
Range: a, m, s | s |
| constraints/nonlinear/branching/vartypeweight | weight by how much to consider variable type (continuous: 0, binary: 1, integer: 0.1, impl-integer: 0.01) in branching score
Range: [0, ∞] | 0.5 |
| constraints/nonlinear/branching/violsplit | method used to split violation in expression onto variables: 'u'niform, 'm'idness of solution, 'd'omain width, 'l'ogarithmic domain width
Range: u, m, d, l | m |
| constraints/nonlinear/branching/violweight | weight by how much to consider the violation assigned to a variable for its branching score
Range: [0, ∞] | 1 |
constraints/nonlinear/upgrade
| Option | Description | Default |
| constraints/nonlinear/upgrade/linear | enable nonlinear upgrading for constraint handler <linear>
Range: boolean | 1 |
| constraints/nonlinear/upgrade/setppc | enable nonlinear upgrading for constraint handler <setppc>
Range: boolean | 1 |
constraints/or
| Option | Description | Default |
| constraints/or/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 1 |
| constraints/or/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 0 |
| Options for expert users |
| constraints/or/delayprop | should propagation method be delayed, if other propagators found reductions?
Range: boolean | 0 |
| constraints/or/delaysepa | should separation method be delayed, if other separators found cuts?
Range: boolean | 0 |
| constraints/or/eagerfreq | frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 1073741822} | 100 |
| constraints/or/maxprerounds | maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| constraints/or/presoltiming | timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 8 |
| constraints/or/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
constraints/orbisack
| Option | Description | Default |
| constraints/orbisack/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 5 |
| constraints/orbisack/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 5 |
| Options for expert users |
| constraints/orbisack/checkpporbisack | Upgrade orbisack constraints to packing/partioning orbisacks?
Range: boolean | 1 |
| constraints/orbisack/coeffbound | Maximum size of coefficients for orbisack inequalities
Range: [0, ∞] | 1e+06 |
| constraints/orbisack/coverseparation | Separate cover inequalities for orbisacks?
Range: boolean | 1 |
| constraints/orbisack/delayprop | should propagation method be delayed, if other propagators found reductions?
Range: boolean | 0 |
| constraints/orbisack/delaysepa | should separation method be delayed, if other separators found cuts?
Range: boolean | 0 |
| constraints/orbisack/eagerfreq | frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 1073741822} | -1 |
| constraints/orbisack/forceconscopy | Whether orbisack constraints should be forced to be copied to sub SCIPs.
Range: boolean | 0 |
| constraints/orbisack/maxprerounds | maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| constraints/orbisack/orbiSeparation | Separate orbisack inequalities?
Range: boolean | 0 |
| constraints/orbisack/presoltiming | timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 16 |
| constraints/orbisack/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
constraints/orbitope
| Option | Description | Default |
| constraints/orbitope/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 1 |
| constraints/orbitope/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | -1 |
| Options for expert users |
| constraints/orbitope/checkpporbitope | Strengthen orbitope constraints to packing/partioning orbitopes?
Range: boolean | 1 |
| constraints/orbitope/delayprop | should propagation method be delayed, if other propagators found reductions?
Range: boolean | 0 |
| constraints/orbitope/delaysepa | should separation method be delayed, if other separators found cuts?
Range: boolean | 0 |
| constraints/orbitope/eagerfreq | frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 1073741822} | -1 |
| constraints/orbitope/forceconscopy | Whether orbitope constraints should be forced to be copied to sub SCIPs.
Range: boolean | 0 |
| constraints/orbitope/maxprerounds | maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| constraints/orbitope/presoltiming | timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 8 |
| constraints/orbitope/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
| constraints/orbitope/sepafullorbitope | Whether we separate inequalities for full orbitopes?
Range: boolean | 0 |
constraints/setppc
| Option | Description | Default |
| constraints/setppc/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 1 |
| constraints/setppc/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 0 |
| Options for expert users |
| constraints/setppc/addvariablesascliques | should we try to generate extra cliques out of all binary variables to maybe fasten redundant constraint detection
Range: boolean | 0 |
| constraints/setppc/cliquelifting | should we try to lift variables into other clique constraints, fix variables, aggregate them, and also shrink the amount of variables in clique constraints
Range: boolean | 0 |
| constraints/setppc/cliqueshrinking | should we try to shrink the number of variables in a clique constraints, by replacing more than one variable by only one
Range: boolean | 1 |
| constraints/setppc/delayprop | should propagation method be delayed, if other propagators found reductions?
Range: boolean | 0 |
| constraints/setppc/delaysepa | should separation method be delayed, if other separators found cuts?
Range: boolean | 0 |
| constraints/setppc/dualpresolving | should dual presolving steps be performed?
Range: boolean | 1 |
| constraints/setppc/eagerfreq | frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 1073741822} | 100 |
| constraints/setppc/maxprerounds | maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| constraints/setppc/npseudobranches | number of children created in pseudo branching (0: disable pseudo branching)
Range: {0, ..., ∞} | 2 |
| constraints/setppc/presolpairwise | should pairwise constraint comparison be performed in presolving?
Range: boolean | 1 |
| constraints/setppc/presoltiming | timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 28 |
| constraints/setppc/presolusehashing | should hash table be used for detecting redundant constraints in advance
Range: boolean | 1 |
| constraints/setppc/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
constraints/symresack
| Option | Description | Default |
| constraints/symresack/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 5 |
| constraints/symresack/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 5 |
| Options for expert users |
| constraints/symresack/checkmonotonicity | Check whether permutation is monotone when upgrading to packing/partioning symresacks?
Range: boolean | 1 |
| constraints/symresack/delayprop | should propagation method be delayed, if other propagators found reductions?
Range: boolean | 0 |
| constraints/symresack/delaysepa | should separation method be delayed, if other separators found cuts?
Range: boolean | 0 |
| constraints/symresack/eagerfreq | frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 1073741822} | -1 |
| constraints/symresack/forceconscopy | Whether symresack constraints should be forced to be copied to sub SCIPs.
Range: boolean | 0 |
| constraints/symresack/maxprerounds | maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| constraints/symresack/ppsymresack | Upgrade symresack constraints to packing/partioning symresacks?
Range: boolean | 1 |
| constraints/symresack/presoltiming | timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 16 |
| constraints/symresack/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
constraints/varbound
| Option | Description | Default |
| constraints/varbound/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 1 |
| constraints/varbound/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 0 |
| constraints/varbound/usebdwidening | should bound widening be used in conflict analysis?
Range: boolean | 1 |
| Options for expert users |
| constraints/varbound/delayprop | should propagation method be delayed, if other propagators found reductions?
Range: boolean | 0 |
| constraints/varbound/delaysepa | should separation method be delayed, if other separators found cuts?
Range: boolean | 0 |
| constraints/varbound/eagerfreq | frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 1073741822} | 100 |
| constraints/varbound/maxlpcoef | maximum coefficient in varbound constraint to be added as a row into LP
Range: [0, ∞] | 1e+09 |
| constraints/varbound/maxprerounds | maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| constraints/varbound/presolpairwise | should pairwise constraint comparison be performed in presolving?
Range: boolean | 1 |
| constraints/varbound/presoltiming | timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 12 |
| constraints/varbound/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
constraints/xor
| Option | Description | Default |
| constraints/xor/propfreq | frequency for propagating domains (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 1 |
| constraints/xor/sepafreq | frequency for separating cuts (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 0 |
| Options for expert users |
| constraints/xor/addextendedform | should the extended formulation be added in presolving?
Range: boolean | 0 |
| constraints/xor/addflowextended | should the extended flow formulation be added (nonsymmetric formulation otherwise)?
Range: boolean | 0 |
| constraints/xor/delayprop | should propagation method be delayed, if other propagators found reductions?
Range: boolean | 0 |
| constraints/xor/delaysepa | should separation method be delayed, if other separators found cuts?
Range: boolean | 0 |
| constraints/xor/eagerfreq | frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation)
Range: {-1, ..., 1073741822} | 100 |
| constraints/xor/gausspropfreq | frequency for applying the Gauss propagator
Range: {-1, ..., 1073741822} | 5 |
| constraints/xor/maxprerounds | maximal number of presolving rounds the constraint handler participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| constraints/xor/presolpairwise | should pairwise constraint comparison be performed in presolving?
Range: boolean | 1 |
| constraints/xor/presoltiming | timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 28 |
| constraints/xor/presolusehashing | should hash table be used for detecting redundant constraints in advance?
Range: boolean | 1 |
| constraints/xor/proptiming | timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)
Range: {1, ..., 15} | 1 |
| constraints/xor/separateparity | should parity inequalities be separated?
Range: boolean | 0 |
cutselection/dynamic
| Option | Description | Default |
| cutselection/dynamic/dircutoffdistweight | weight of directed cutoff distance in cut score calculation
Range: [0, ∞] | 0 |
| cutselection/dynamic/efficacyweight | weight of efficacy in cut score calculation
Range: [0, ∞] | 1 |
| cutselection/dynamic/filtermode | filtering strategy during cut selection
Range: d, f | d |
| cutselection/dynamic/intsupportweight | weight of integral support in cut score calculation
Range: [0, ∞] | 0 |
| cutselection/dynamic/maxdepth | maximum depth at which this cutselector is employed
Range: {-1, ..., 1073741822} | -1 |
| cutselection/dynamic/mingain | minimal efficacy gain for a cut to enter the LP
Range: [0, 1] | 0.01 |
| cutselection/dynamic/minortho | minimal orthogonality for a cut to enter the LP
Range: [0, 1] | 0.9 |
| cutselection/dynamic/objparalweight | weight of objective parallelism in cut score calculation
Range: [0, ∞] | 0 |
| cutselection/dynamic/priority | priority of cut selection rule <dynamic>
Range: {-536870912, ..., 1073741823} | 7000 |
cutselection/ensemble
| Option | Description | Default |
| cutselection/ensemble/dircutoffdistweight | weight of normed-directed cutoff distance in cut score calculation
Range: [0, ∞] | 0 |
| cutselection/ensemble/efficacyweight | weight of normed-efficacy in cut score calculation
Range: [0, ∞] | 0.75 |
| cutselection/ensemble/endsparsitybonus | max sparsity value for which a bonus is applied in cut score calculation
Range: [0, ∞] | 0.2 |
| cutselection/ensemble/expimprovweight | weight of normed-expected obj improvement in cut score calculation
Range: [0, ∞] | 0.1 |
| cutselection/ensemble/filterparalcuts | should cuts be filtered so no two parallel cuts are added
Range: boolean | 0 |
| cutselection/ensemble/goodnumericsbonus | weight of good numerics bonus (ratio of coefficients) in cut score calculation
Range: [0, ∞] | 0 |
| cutselection/ensemble/intsupportweight | weight of integral support in cut score calculation
Range: [0, ∞] | 0.45 |
| cutselection/ensemble/locksweight | weight of normed-num-locks in cut score calculation
Range: [0, ∞] | 0.25 |
| cutselection/ensemble/maxnonzerorootround | max non-zeros per round applied cuts (root). multiple num LP cols.
Range: [0, ∞] | 4.5 |
| cutselection/ensemble/maxnonzerotreeround | max non-zeros per round applied cuts (tree). multiple num LP cols.
Range: [0, ∞] | 9.5 |
| cutselection/ensemble/maxparal | threshold for when two cuts are considered parallel to each other
Range: [0, 1] | 0.95 |
| cutselection/ensemble/maxsparsitybonus | weight of maximum sparsity reward in cut score calculation
Range: [0, ∞] | 0.5 |
| cutselection/ensemble/minscore | minimum score s.t. a cut can be added
Range: real | 0 |
| cutselection/ensemble/objparalweight | weight of objective parallelism in cut score calculation
Range: [0, ∞] | 0.25 |
| cutselection/ensemble/priority | priority of cut selection rule <ensemble>
Range: {-536870912, ..., 1073741823} | 7000 |
| cutselection/ensemble/pscostweight | weight of normed-pseudo-costs in cut score calculation
Range: [0, ∞] | 0.75 |
| Options for expert users |
| cutselection/ensemble/filterdensecuts | should cuts over a given density threshold be filtered
Range: boolean | 1 |
| cutselection/ensemble/maxcoefratiobonus | max coefficient ratio for which numeric bonus is applied.
Range: {1, ..., 1000000} | 10000 |
| cutselection/ensemble/maxcutdensity | max allowed cut density if filtering dense cuts
Range: [0, 1] | 0.425 |
| cutselection/ensemble/maxcuts | max number of cuts such that cut selector is applied.
Range: {1, ..., 1000000} | 200 |
| cutselection/ensemble/maxnumvars | max number of variables such that cut selector is applied.
Range: {1, ..., 1000000} | 50000 |
| cutselection/ensemble/paralpenalty | penalty for weaker of two parallel cuts if penalising parallel cuts
Range: [0, ∞] | 0.25 |
| cutselection/ensemble/penaliselocks | should the number of locks be penalised instead of rewarded
Range: boolean | 1 |
| cutselection/ensemble/penaliseobjparal | should objective parallelism be penalised instead of rewarded
Range: boolean | 1 |
| cutselection/ensemble/penaliseparalcuts | should two parallel cuts be penalised instead of outright filtered
Range: boolean | 1 |
cutselection/hybrid
| Option | Description | Default |
| cutselection/hybrid/dircutoffdistweight | weight of directed cutoff distance in cut score calculation
Range: [0, ∞] | 0 |
| cutselection/hybrid/efficacyweight | weight of efficacy in cut score calculation
Range: [0, ∞] | 1 |
| cutselection/hybrid/intsupportweight | weight of integral support in cut score calculation
Range: [0, ∞] | 0.1 |
| cutselection/hybrid/minortho | minimal orthogonality for a cut to enter the LP
Range: [0, 1] | 0.9 |
| cutselection/hybrid/minorthoroot | minimal orthogonality for a cut to enter the LP in the root node
Range: [0, 1] | 0.9 |
| cutselection/hybrid/objparalweight | weight of objective parallelism in cut score calculation
Range: [0, ∞] | 0.1 |
| cutselection/hybrid/priority | priority of cut selection rule <hybrid>
Range: {-536870912, ..., 1073741823} | 8000 |
decomposition
| Option | Description | Default |
| decomposition/disablemeasures | disable expensive measures
Range: boolean | 0 |
| decomposition/maxgraphedge | maximum number of edges in block graph computation (-1: no limit, 0: disable block graph computation)
Range: {-1, ..., ∞} | 10000 |
display
| Option | Description | Default |
| display/allviols | display all violations for a given start solution / the best solution after the solving process?
Range: boolean | 0 |
| display/freq | frequency for displaying node information lines
Range: {-1, ..., ∞} | 100 |
| display/headerfreq | frequency for displaying header lines (every n'th node information line)
Range: {-1, ..., ∞} | 15 |
| display/lpinfo | should the LP solver display status messages?
Range: boolean | 0 |
| display/relevantstats | should the relevant statistics be displayed at the end of solving?
Range: boolean | 1 |
| display/statistics | whether to print statistics on a solve and a provided decomposition
Range: boolean | 0 |
| display/verblevel | verbosity level of output
Range: {0, ..., 5} | 4 |
| display/width | maximal number of characters in a node information line
Range: {0, ..., ∞} | 143 (80 for Windows without IDE) |
display/avgdualbound
| Option | Description | Default |
| display/avgdualbound/active | display activation status of display column <avgdualbound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/completed
| Option | Description | Default |
| display/completed/active | display activation status of display column <completed> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/concdualbound
| Option | Description | Default |
| display/concdualbound/active | display activation status of display column <concdualbound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/concgap
| Option | Description | Default |
| display/concgap/active | display activation status of display column <concgap> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/concmemused
| Option | Description | Default |
| display/concmemused/active | display activation status of display column <concmemused> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/concprimalbound
| Option | Description | Default |
| display/concprimalbound/active | display activation status of display column <concprimalbound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/concsolfound
| Option | Description | Default |
| display/concsolfound/active | display activation status of display column <concsolfound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/conflicts
| Option | Description | Default |
| display/conflicts/active | display activation status of display column <conflicts> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/conss
| Option | Description | Default |
| display/conss/active | display activation status of display column <conss> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/curcols
| Option | Description | Default |
| display/curcols/active | display activation status of display column <curcols> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/curconss
| Option | Description | Default |
| display/curconss/active | display activation status of display column <curconss> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/curdualbound
| Option | Description | Default |
| display/curdualbound/active | display activation status of display column <curdualbound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/currows
| Option | Description | Default |
| display/currows/active | display activation status of display column <currows> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/cutoffbound
| Option | Description | Default |
| display/cutoffbound/active | display activation status of display column <cutoffbound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/cuts
| Option | Description | Default |
| display/cuts/active | display activation status of display column <cuts> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/depth
| Option | Description | Default |
| display/depth/active | display activation status of display column <depth> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/dualbound
| Option | Description | Default |
| display/dualbound/active | display activation status of display column <dualbound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/estimate
| Option | Description | Default |
| display/estimate/active | display activation status of display column <estimate> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/feasST
| Option | Description | Default |
| display/feasST/active | display activation status of display column <feasST> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 0 |
display/gap
| Option | Description | Default |
| display/gap/active | display activation status of display column <gap> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/lpavgiterations
| Option | Description | Default |
| display/lpavgiterations/active | display activation status of display column <lpavgiterations> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 (0 for Windows without IDE) |
display/lpcond
| Option | Description | Default |
| display/lpcond/active | display activation status of display column <lpcond> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/lpiterations
| Option | Description | Default |
| display/lpiterations/active | display activation status of display column <lpiterations> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/lpobj
| Option | Description | Default |
| display/lpobj/active | display activation status of display column <lpobj> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/maxdepth
| Option | Description | Default |
| display/maxdepth/active | display activation status of display column <maxdepth> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 (0 for Windows without IDE) |
display/memtotal
| Option | Description | Default |
| display/memtotal/active | display activation status of display column <memtotal> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/memused
| Option | Description | Default |
| display/memused/active | display activation status of display column <memused> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/nexternbranchcands
| Option | Description | Default |
| display/nexternbranchcands/active | display activation status of display column <nexternbranchcands> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/nfrac
| Option | Description | Default |
| display/nfrac/active | display activation status of display column <nfrac> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/ninfeasleaves
| Option | Description | Default |
| display/ninfeasleaves/active | display activation status of display column <ninfeasleaves> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/nnodes
| Option | Description | Default |
| display/nnodes/active | display activation status of display column <nnodes> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/nnodesbelowinc
| Option | Description | Default |
| display/nnodesbelowinc/active | display activation status of display column <nnodesbelowinc> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 0 |
display/nobjleaves
| Option | Description | Default |
| display/nobjleaves/active | display activation status of display column <nobjleaves> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/nodesleft
| Option | Description | Default |
| display/nodesleft/active | display activation status of display column <nodesleft> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/nrank1nodes
| Option | Description | Default |
| display/nrank1nodes/active | display activation status of display column <nrank1nodes> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 0 |
display/nsols
| Option | Description | Default |
| display/nsols/active | display activation status of display column <nsols> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/plungedepth
| Option | Description | Default |
| display/plungedepth/active | display activation status of display column <plungedepth> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/poolsize
| Option | Description | Default |
| display/poolsize/active | display activation status of display column <poolsize> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/primalbound
| Option | Description | Default |
| display/primalbound/active | display activation status of display column <primalbound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/primalgap
| Option | Description | Default |
| display/primalgap/active | display activation status of display column <primalgap> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 0 |
display/pseudoobj
| Option | Description | Default |
| display/pseudoobj/active | display activation status of display column <pseudoobj> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/separounds
| Option | Description | Default |
| display/separounds/active | display activation status of display column <separounds> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/solfound
| Option | Description | Default |
| display/solfound/active | display activation status of display column <solfound> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/sols
| Option | Description | Default |
| display/sols/active | display activation status of display column <sols> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 0 |
display/strongbranchs
| Option | Description | Default |
| display/strongbranchs/active | display activation status of display column <strongbranchs> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
display/time
| Option | Description | Default |
| display/time/active | display activation status of display column <time> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 (2 for Windows without IDE) |
display/vars
| Option | Description | Default |
| display/vars/active | display activation status of display column <vars> (0: off, 1: auto, 2:on)
Range: {0, ..., 2} | 1 |
estimation
| Option | Description | Default |
| estimation/coefmonossg | coefficient of 1 - SSG in monotone approximation of search completion
Range: [0, 1] | 0.6333 |
| estimation/coefmonoweight | coefficient of tree weight in monotone approximation of search completion
Range: [0, 1] | 0.3667 |
| estimation/completiontype | approximation of search tree completion: (a)uto, (g)ap, tree (w)eight, (m)onotone regression, (r)egression forest, (s)sg
Range: a, g, m, r, s, w | a |
| estimation/method | tree size estimation method: (c)ompletion, (e)nsemble, time series forecasts on either (g)ap, (l)eaf frequency, (o)open nodes, tree (w)eight, (s)sg, or (t)ree profile or w(b)e
Range: b, c, e, g, l, o, s, t, w | w |
| estimation/regforestfilename | user regression forest in RFCSV format
Range: string | - |
| Options for expert users |
| estimation/reportfreq | report frequency on estimation: -1: never, 0:always, k ≥ 1: k times evenly during search
Range: {-1, ..., 1073741823} | -1 |
| estimation/showstats | should statistics be shown at the end?
Range: boolean | 0 |
| estimation/useleafts | use leaf nodes as basic observations for time series, or all nodes?
Range: boolean | 1 |
estimation/restarts
| Option | Description | Default |
| estimation/restarts/countonlyleaves | should only leaves count for the minnodes parameter?
Range: boolean | 0 |
| estimation/restarts/hitcounterlim | limit on the number of successive samples to really trigger a restart
Range: {1, ..., ∞} | 50 |
| estimation/restarts/minnodes | minimum number of nodes before restart
Range: {-1, ..., ∞} | 1000 |
| estimation/restarts/restartactpricers | whether to apply a restart when active pricers are used
Range: boolean | 0 |
| estimation/restarts/restartfactor | factor by which the estimated number of nodes should exceed the current number of nodes
Range: [1, ∞] | 50 |
| estimation/restarts/restartlimit | restart limit
Range: {-1, ..., ∞} | 1 |
| estimation/restarts/restartnonlinear | whether to apply a restart when nonlinear constraints are present
Range: boolean | 0 |
| estimation/restarts/restartpolicy | restart policy: (a)lways, (c)ompletion, (e)stimation, (n)ever
Range: a, c, e, n | e |
estimation/ssg
| Option | Description | Default |
| estimation/ssg/nmaxsubtrees | the maximum number of individual SSG subtrees; -1: no limit
Range: {-1, ..., 1073741823} | -1 |
| estimation/ssg/nminnodeslastsplit | minimum number of nodes to process between two consecutive SSG splits
Range: {0, ..., ∞} | 0 |
estimation/treeprofile
| Option | Description | Default |
| estimation/treeprofile/enabled | should the event handler collect data?
Range: boolean | 0 |
| estimation/treeprofile/minnodesperdepth | minimum average number of nodes at each depth before producing estimations
Range: [1, ∞] | 20 |
expr/log
| Option | Description | Default |
| expr/log/minzerodistance | minimal distance from zero to enforce for child in bound tightening
Range: [0, 1] | 1e-09 |
expr/pow
| Option | Description | Default |
| expr/pow/distribfracexponent | whether a fractional exponent is distributed onto factors on power of product
Range: boolean | 0 |
| expr/pow/expandmaxexponent | maximal exponent when to expand power of sum in simplify
Range: {1, ..., ∞} | 2 |
| expr/pow/minzerodistance | minimal distance from zero to enforce for child in bound tightening
Range: [0, 1] | 1e-09 |
expr/prod
| Option | Description | Default |
| expr/prod/expandalways | whether to expand products of a sum and several factors in simplify
Range: boolean | 0 |
heuristics
| Option | Description | Default |
| Options for expert users |
| heuristics/useuctsubscip | should setting of common subscip parameters include the activation of the UCT node selector?
Range: boolean | 0 |
heuristics/actconsdiving
| Option | Description | Default |
| heuristics/actconsdiving/backtrack | use one level of backtracking if infeasibility is encountered?
Range: boolean | 1 |
| heuristics/actconsdiving/freq | frequency for calling primal heuristic <actconsdiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/actconsdiving/freqofs | frequency offset for calling primal heuristic <actconsdiving>
Range: {0, ..., 1073741822} | 5 |
| heuristics/actconsdiving/lpresolvedomchgquot | percentage of immediate domain changes during probing to trigger LP resolve
Range: [0, ∞] | 0.15 |
| heuristics/actconsdiving/lpsolvefreq | LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
Range: {0, ..., ∞} | 0 |
| heuristics/actconsdiving/maxlpiterofs | additional number of allowed LP iterations
Range: {0, ..., ∞} | 1000 |
| heuristics/actconsdiving/maxlpiterquot | maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞] | 0.05 |
| heuristics/actconsdiving/onlylpbranchcands | should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean | 1 |
| Options for expert users |
| heuristics/actconsdiving/maxdepth | maximal depth level to call primal heuristic <actconsdiving> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/actconsdiving/maxdiveavgquot | maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞] | 0 |
| heuristics/actconsdiving/maxdiveavgquotnosol | maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞] | 1 |
| heuristics/actconsdiving/maxdiveubquot | maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1] | 0.8 |
| heuristics/actconsdiving/maxdiveubquotnosol | maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1] | 1 |
| heuristics/actconsdiving/maxreldepth | maximal relative depth to start diving
Range: [0, 1] | 1 |
| heuristics/actconsdiving/minreldepth | minimal relative depth to start diving
Range: [0, 1] | 0 |
| heuristics/actconsdiving/priority | priority of heuristic <actconsdiving>
Range: {-536870912, ..., 536870911} | -1003700 |
heuristics/adaptivediving
| Option | Description | Default |
| heuristics/adaptivediving/bestsolweight | weight of incumbent solutions compared to other solutions in computation of LP iteration limit
Range: [0, ∞] | 10 |
| heuristics/adaptivediving/epsilon | parameter that increases probability of exploration among divesets (only active if seltype is 'e')
Range: [0, ∞] | 1 |
| heuristics/adaptivediving/freq | frequency for calling primal heuristic <adaptivediving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 5 |
| heuristics/adaptivediving/freqofs | frequency offset for calling primal heuristic <adaptivediving>
Range: {0, ..., 1073741822} | 3 |
| heuristics/adaptivediving/maxlpiterofs | additional number of allowed LP iterations
Range: {0, ..., ∞} | 1500 |
| heuristics/adaptivediving/maxlpiterquot | maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞] | 0.1 |
| heuristics/adaptivediving/scoretype | score parameter for selection: minimize either average 'n'odes, LP 'i'terations,backtrack/'c'onflict ratio, 'd'epth, 1 / 's'olutions, or 1 / solutions'u'ccess
Range: c, d, i, n, s, u | c |
| heuristics/adaptivediving/selconfidencecoeff | coefficient c to decrease initial confidence (calls + 1.0) / (calls + c) in scores
Range: [1, 2.14748e+09] | 10 |
| heuristics/adaptivediving/seltype | selection strategy: (e)psilon-greedy, (w)eighted distribution, (n)ext diving
Range: e, n, w | w |
| Options for expert users |
| heuristics/adaptivediving/maxdepth | maximal depth level to call primal heuristic <adaptivediving> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/adaptivediving/priority | priority of heuristic <adaptivediving>
Range: {-536870912, ..., 536870911} | -70000 |
| heuristics/adaptivediving/useadaptivecontext | should the heuristic use its own statistics, or shared statistics?
Range: boolean | 0 |
heuristics/alns
| Option | Description | Default |
| heuristics/alns/freq | frequency for calling primal heuristic <alns> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 20 |
| heuristics/alns/freqofs | frequency offset for calling primal heuristic <alns>
Range: {0, ..., 1073741822} | 0 |
| heuristics/alns/nodesofs | offset added to the nodes budget
Range: {0, ..., ∞} | 500 |
| heuristics/alns/nodesquot | fraction of nodes compared to the main SCIP for budget computation
Range: [0, 1] | 0.1 |
| heuristics/alns/nodesquotmin | lower bound fraction of nodes compared to the main SCIP for budget computation
Range: [0, 1] | 0 |
| heuristics/alns/nsolslim | limit on the number of improving solutions in a sub-SCIP call
Range: {-1, ..., ∞} | 3 |
| heuristics/alns/seed | initial random seed for bandit algorithms and random decisions by neighborhoods
Range: {0, ..., ∞} | 113 |
| Options for expert users |
| heuristics/alns/adjustfixingrate | should the heuristic adjust the target fixing rate based on the success?
Range: boolean | 1 |
| heuristics/alns/adjustminimprove | should the factor by which the minimum improvement is bound be dynamically updated?
Range: boolean | 0 |
| heuristics/alns/adjusttargetnodes | should the target nodes be dynamically adjusted?
Range: boolean | 1 |
| heuristics/alns/alpha | parameter to increase the confidence width in UCB
Range: [0, 100] | 0.0016 |
| heuristics/alns/banditalgo | the bandit algorithm: (u)pper confidence bounds, (e)xp.3, epsilon (g)reedy, exp.3-(i)x
Range: u, e, g, i | i |
| heuristics/alns/beta | reward offset between 0 and 1 at every observation for Exp.3
Range: [0, 1] | 0 |
| heuristics/alns/copycuts | should cutting planes be copied to the sub-SCIP?
Range: boolean | 0 |
| heuristics/alns/domorefixings | should the ALNS heuristic do more fixings by itself based on variable prioritization until the target fixing rate is reached?
Range: boolean | 1 |
| heuristics/alns/eps | increase exploration in epsilon-greedy bandit algorithm
Range: [0, 1] | 0.468584 |
| heuristics/alns/fixtol | tolerance by which the fixing rate may be missed without generic fixing
Range: [0, 1] | 0.1 |
| heuristics/alns/gamma | weight between uniform (gamma ~ 1) and weight driven (gamma ~ 0) probability distribution for exp3
Range: [0, 1] | 0.0704146 |
| heuristics/alns/initduringroot | should the heuristic be executed multiple times during the root node?
Range: boolean | 0 |
| heuristics/alns/maxcallssamesol | number of allowed executions of the heuristic on the same incumbent solution (-1: no limit, 0: number of active neighborhoods)
Range: {-1, ..., 100} | -1 |
| heuristics/alns/maxdepth | maximal depth level to call primal heuristic <alns> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/alns/maxnodes | maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞} | 5000 |
| heuristics/alns/minimprovehigh | upper bound for the minimal improvement over the incumbent
Range: [0, 1] | 0.01 |
| heuristics/alns/minimprovelow | lower threshold for the minimal improvement over the incumbent
Range: [0, 1] | 0.01 |
| heuristics/alns/minnodes | minimum number of nodes required to start a sub-SCIP
Range: {0, ..., ∞} | 50 |
| heuristics/alns/priority | priority of heuristic <alns>
Range: {-536870912, ..., 536870911} | -1100500 |
| heuristics/alns/resetweights | should the bandit algorithms be reset when a new problem is read?
Range: boolean | 1 |
| heuristics/alns/rewardbaseline | the reward baseline to separate successful and failed calls
Range: [0, 0.99] | 0.5 |
| heuristics/alns/rewardcontrol | reward control to increase the weight of the simple solution indicator and decrease the weight of the closed gap reward
Range: [0, 1] | 0.8 |
| heuristics/alns/rewardfilename | file name to store all rewards and the selection of the bandit
Range: string | - |
| heuristics/alns/scalebyeffort | should the reward be scaled by the effort?
Range: boolean | 1 |
| heuristics/alns/shownbstats | show statistics on neighborhoods?
Range: boolean | 0 |
| heuristics/alns/startminimprove | initial factor by which ALNS should at least improve the incumbent
Range: [0, 1] | 0.01 |
| heuristics/alns/subsciprandseeds | should random seeds of sub-SCIPs be altered to increase diversification?
Range: boolean | 0 |
| heuristics/alns/targetnodefactor | factor by which target node number is eventually increased
Range: [1, 100000] | 1.05 |
| heuristics/alns/unfixtol | tolerance by which the fixing rate may be exceeded without generic unfixing
Range: [0, 1] | 0.1 |
| heuristics/alns/usedistances | distances from fixed variables be used for variable prioritization
Range: boolean | 1 |
| heuristics/alns/uselocalredcost | should local reduced costs be used for generic (un)fixing?
Range: boolean | 0 |
| heuristics/alns/usepscost | should pseudo cost scores be used for variable priorization?
Range: boolean | 1 |
| heuristics/alns/useredcost | should reduced cost scores be used for variable prioritization?
Range: boolean | 1 |
| heuristics/alns/usesubscipheurs | should the heuristic activate other sub-SCIP heuristics during its search?
Range: boolean | 0 |
| heuristics/alns/waitingnodes | number of nodes since last incumbent solution that the heuristic should wait
Range: {0, ..., ∞} | 25 |
heuristics/alns/crossover
| Option | Description | Default |
| Options for expert users |
| heuristics/alns/crossover/active | is this neighborhood active?
Range: boolean | 1 |
| heuristics/alns/crossover/maxfixingrate | maximum fixing rate for this neighborhood
Range: [0, 1] | 0.9 |
| heuristics/alns/crossover/minfixingrate | minimum fixing rate for this neighborhood
Range: [0, 1] | 0.3 |
| heuristics/alns/crossover/nsols | the number of solutions that crossover should combine
Range: {2, ..., 10} | 2 |
| heuristics/alns/crossover/priority | positive call priority to initialize bandit algorithms
Range: [0.01, 1] | 1 |
heuristics/alns/dins
| Option | Description | Default |
| Options for expert users |
| heuristics/alns/dins/active | is this neighborhood active?
Range: boolean | 1 |
| heuristics/alns/dins/maxfixingrate | maximum fixing rate for this neighborhood
Range: [0, 1] | 0.9 |
| heuristics/alns/dins/minfixingrate | minimum fixing rate for this neighborhood
Range: [0, 1] | 0.3 |
| heuristics/alns/dins/npoolsols | number of pool solutions where binary solution values must agree
Range: {1, ..., 100} | 5 |
| heuristics/alns/dins/priority | positive call priority to initialize bandit algorithms
Range: [0.01, 1] | 1 |
heuristics/alns/localbranching
| Option | Description | Default |
| Options for expert users |
| heuristics/alns/localbranching/active | is this neighborhood active?
Range: boolean | 1 |
| heuristics/alns/localbranching/maxfixingrate | maximum fixing rate for this neighborhood
Range: [0, 1] | 0.9 |
| heuristics/alns/localbranching/minfixingrate | minimum fixing rate for this neighborhood
Range: [0, 1] | 0.3 |
| heuristics/alns/localbranching/priority | positive call priority to initialize bandit algorithms
Range: [0.01, 1] | 1 |
heuristics/alns/mutation
| Option | Description | Default |
| Options for expert users |
| heuristics/alns/mutation/active | is this neighborhood active?
Range: boolean | 1 |
| heuristics/alns/mutation/maxfixingrate | maximum fixing rate for this neighborhood
Range: [0, 1] | 0.9 |
| heuristics/alns/mutation/minfixingrate | minimum fixing rate for this neighborhood
Range: [0, 1] | 0.3 |
| heuristics/alns/mutation/priority | positive call priority to initialize bandit algorithms
Range: [0.01, 1] | 1 |
heuristics/alns/proximity
| Option | Description | Default |
| Options for expert users |
| heuristics/alns/proximity/active | is this neighborhood active?
Range: boolean | 1 |
| heuristics/alns/proximity/maxfixingrate | maximum fixing rate for this neighborhood
Range: [0, 1] | 0.9 |
| heuristics/alns/proximity/minfixingrate | minimum fixing rate for this neighborhood
Range: [0, 1] | 0.3 |
| heuristics/alns/proximity/priority | positive call priority to initialize bandit algorithms
Range: [0.01, 1] | 1 |
heuristics/alns/rens
| Option | Description | Default |
| Options for expert users |
| heuristics/alns/rens/active | is this neighborhood active?
Range: boolean | 1 |
| heuristics/alns/rens/maxfixingrate | maximum fixing rate for this neighborhood
Range: [0, 1] | 0.9 |
| heuristics/alns/rens/minfixingrate | minimum fixing rate for this neighborhood
Range: [0, 1] | 0.3 |
| heuristics/alns/rens/priority | positive call priority to initialize bandit algorithms
Range: [0.01, 1] | 1 |
heuristics/alns/rins
| Option | Description | Default |
| Options for expert users |
| heuristics/alns/rins/active | is this neighborhood active?
Range: boolean | 1 |
| heuristics/alns/rins/maxfixingrate | maximum fixing rate for this neighborhood
Range: [0, 1] | 0.9 |
| heuristics/alns/rins/minfixingrate | minimum fixing rate for this neighborhood
Range: [0, 1] | 0.3 |
| heuristics/alns/rins/priority | positive call priority to initialize bandit algorithms
Range: [0.01, 1] | 1 |
heuristics/alns/trustregion
| Option | Description | Default |
| heuristics/alns/trustregion/violpenalty | the penalty for each change in the binary variables from the candidate solution
Range: [0, ∞] | 100 |
| Options for expert users |
| heuristics/alns/trustregion/active | is this neighborhood active?
Range: boolean | 0 |
| heuristics/alns/trustregion/maxfixingrate | maximum fixing rate for this neighborhood
Range: [0, 1] | 0.9 |
| heuristics/alns/trustregion/minfixingrate | minimum fixing rate for this neighborhood
Range: [0, 1] | 0.3 |
| heuristics/alns/trustregion/priority | positive call priority to initialize bandit algorithms
Range: [0.01, 1] | 1 |
heuristics/alns/zeroobjective
| Option | Description | Default |
| Options for expert users |
| heuristics/alns/zeroobjective/active | is this neighborhood active?
Range: boolean | 1 |
| heuristics/alns/zeroobjective/maxfixingrate | maximum fixing rate for this neighborhood
Range: [0, 1] | 0.9 |
| heuristics/alns/zeroobjective/minfixingrate | minimum fixing rate for this neighborhood
Range: [0, 1] | 0.3 |
| heuristics/alns/zeroobjective/priority | positive call priority to initialize bandit algorithms
Range: [0.01, 1] | 1 |
heuristics/bound
| Option | Description | Default |
| heuristics/bound/bound | to which bound should integer variables be fixed? ('l'ower, 'u'pper, or 'b'oth)
Range: l, u, b | l |
| heuristics/bound/freq | frequency for calling primal heuristic <bound> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/bound/freqofs | frequency offset for calling primal heuristic <bound>
Range: {0, ..., 1073741822} | 0 |
| Options for expert users |
| heuristics/bound/maxdepth | maximal depth level to call primal heuristic <bound> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/bound/maxproprounds | maximum number of propagation rounds during probing (-1 infinity, -2 parameter settings)
Range: {-1, ..., 536870911} | 0 |
| heuristics/bound/onlywithoutsol | Should heuristic only be executed if no primal solution was found, yet?
Range: boolean | 1 |
| heuristics/bound/priority | priority of heuristic <bound>
Range: {-536870912, ..., 536870911} | -1107000 |
heuristics/clique
| Option | Description | Default |
| heuristics/clique/freq | frequency for calling primal heuristic <clique> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 0 |
| heuristics/clique/freqofs | frequency offset for calling primal heuristic <clique>
Range: {0, ..., 1073741822} | 0 |
| heuristics/clique/minintfixingrate | minimum percentage of integer variables that have to be fixable
Range: [0, 1] | 0.65 |
| heuristics/clique/minmipfixingrate | minimum percentage of fixed variables in the sub-MIP
Range: [0, 1] | 0.65 |
| heuristics/clique/nodesofs | number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞} | 500 |
| heuristics/clique/nodesquot | contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1] | 0.1 |
| Options for expert users |
| heuristics/clique/copycuts | should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean | 1 |
| heuristics/clique/maxbacktracks | maximum number of backtracks during the fixing process
Range: {-1, ..., 536870911} | 10 |
| heuristics/clique/maxdepth | maximal depth level to call primal heuristic <clique> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/clique/maxnodes | maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞} | 5000 |
| heuristics/clique/maxproprounds | maximum number of propagation rounds during probing (-1 infinity)
Range: {-1, ..., 536870911} | 2 |
| heuristics/clique/minimprove | factor by which clique heuristic should at least improve the incumbent
Range: [0, 1] | 0.01 |
| heuristics/clique/minnodes | minimum number of nodes required to start the subproblem
Range: {0, ..., ∞} | 500 |
| heuristics/clique/priority | priority of heuristic <clique>
Range: {-536870912, ..., 536870911} | 5000 |
| heuristics/clique/uselockfixings | should more variables be fixed based on variable locks if the fixing rate was not reached?
Range: boolean | 0 |
heuristics/coefdiving
| Option | Description | Default |
| heuristics/coefdiving/backtrack | use one level of backtracking if infeasibility is encountered?
Range: boolean | 1 |
| heuristics/coefdiving/freq | frequency for calling primal heuristic <coefdiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/coefdiving/freqofs | frequency offset for calling primal heuristic <coefdiving>
Range: {0, ..., 1073741822} | 1 |
| heuristics/coefdiving/lpresolvedomchgquot | percentage of immediate domain changes during probing to trigger LP resolve
Range: [0, ∞] | 0.15 |
| heuristics/coefdiving/lpsolvefreq | LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
Range: {0, ..., ∞} | 0 |
| heuristics/coefdiving/maxlpiterofs | additional number of allowed LP iterations
Range: {0, ..., ∞} | 1000 |
| heuristics/coefdiving/maxlpiterquot | maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞] | 0.05 |
| heuristics/coefdiving/onlylpbranchcands | should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean | 0 |
| Options for expert users |
| heuristics/coefdiving/maxdepth | maximal depth level to call primal heuristic <coefdiving> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/coefdiving/maxdiveavgquot | maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞] | 0 |
| heuristics/coefdiving/maxdiveavgquotnosol | maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞] | 0 |
| heuristics/coefdiving/maxdiveubquot | maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1] | 0.8 |
| heuristics/coefdiving/maxdiveubquotnosol | maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1] | 0.1 |
| heuristics/coefdiving/maxreldepth | maximal relative depth to start diving
Range: [0, 1] | 1 |
| heuristics/coefdiving/minreldepth | minimal relative depth to start diving
Range: [0, 1] | 0 |
| heuristics/coefdiving/priority | priority of heuristic <coefdiving>
Range: {-536870912, ..., 536870911} | -1001000 |
heuristics/completesol
| Option | Description | Default |
| heuristics/completesol/beforepresol | should the heuristic run before presolving?
Range: boolean | 1 |
| heuristics/completesol/freq | frequency for calling primal heuristic <completesol> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 0 |
| heuristics/completesol/freqofs | frequency offset for calling primal heuristic <completesol>
Range: {0, ..., 1073741822} | 0 |
| heuristics/completesol/ignorecont | should number of continuous variables be ignored?
Range: boolean | 0 |
| heuristics/completesol/maxcontvars | maximal number of continuous variables after presolving
Range: {-1, ..., ∞} | -1 |
| heuristics/completesol/maxlpiter | maximal number of LP iterations (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| heuristics/completesol/maxproprounds | maximal number of iterations in propagation (-1: no limit)
Range: {-1, ..., ∞} | 10 |
| heuristics/completesol/maxunknownrate | maximal rate of unknown solution values
Range: [0, 1] | 0.85 |
| heuristics/completesol/nodesofs | number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞} | 500 |
| heuristics/completesol/nodesquot | contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1] | 0.1 |
| heuristics/completesol/solutions | heuristic stops, if the given number of improving solutions were found (-1: no limit)
Range: {-1, ..., ∞} | 5 |
| Options for expert users |
| heuristics/completesol/addallsols | should all subproblem solutions be added to the original SCIP?
Range: boolean | 0 |
| heuristics/completesol/boundwidening | bound widening factor applied to continuous variables (0: fix variables to given solution values, 1: relax to global bounds)
Range: [0, 1] | 0.1 |
| heuristics/completesol/lplimfac | factor by which the limit on the number of LP depends on the node limit
Range: [1, ∞] | 2 |
| heuristics/completesol/maxdepth | maximal depth level to call primal heuristic <completesol> (-1: no limit)
Range: {-1, ..., 1073741822} | 0 |
| heuristics/completesol/maxnodes | maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞} | 5000 |
| heuristics/completesol/minimprove | factor by which the incumbent should be improved at least
Range: [0, 1] | 0.01 |
| heuristics/completesol/minnodes | minimum number of nodes required to start the subproblem
Range: {0, ..., ∞} | 50 |
| heuristics/completesol/objweight | weight of the original objective function (1: only original objective)
Range: [0.001, 1] | 1 |
| heuristics/completesol/priority | priority of heuristic <completesol>
Range: {-536870912, ..., 536870911} | 0 |
heuristics/conflictdiving
| Option | Description | Default |
| heuristics/conflictdiving/backtrack | use one level of backtracking if infeasibility is encountered?
Range: boolean | 1 |
| heuristics/conflictdiving/freq | frequency for calling primal heuristic <conflictdiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 10 |
| heuristics/conflictdiving/freqofs | frequency offset for calling primal heuristic <conflictdiving>
Range: {0, ..., 1073741822} | 0 |
| heuristics/conflictdiving/lpresolvedomchgquot | percentage of immediate domain changes during probing to trigger LP resolve
Range: [0, ∞] | 0.15 |
| heuristics/conflictdiving/lpsolvefreq | LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
Range: {0, ..., ∞} | 0 |
| heuristics/conflictdiving/maxlpiterofs | additional number of allowed LP iterations
Range: {0, ..., ∞} | 1000 |
| heuristics/conflictdiving/maxlpiterquot | maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞] | 0.15 |
| heuristics/conflictdiving/onlylpbranchcands | should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean | 0 |
| Options for expert users |
| heuristics/conflictdiving/likecoef | perform rounding like coefficient diving
Range: boolean | 0 |
| heuristics/conflictdiving/lockweight | weight used in a convex combination of conflict and variable locks
Range: [0, 1] | 0.75 |
| heuristics/conflictdiving/maxdepth | maximal depth level to call primal heuristic <conflictdiving> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/conflictdiving/maxdiveavgquot | maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞] | 0 |
| heuristics/conflictdiving/maxdiveavgquotnosol | maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞] | 0 |
| heuristics/conflictdiving/maxdiveubquot | maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1] | 0.8 |
| heuristics/conflictdiving/maxdiveubquotnosol | maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1] | 0.1 |
| heuristics/conflictdiving/maxreldepth | maximal relative depth to start diving
Range: [0, 1] | 1 |
| heuristics/conflictdiving/maxviol | try to maximize the violation
Range: boolean | 1 |
| heuristics/conflictdiving/minconflictlocks | minimal number of conflict locks per variable
Range: {0, ..., ∞} | 5 |
| heuristics/conflictdiving/minreldepth | minimal relative depth to start diving
Range: [0, 1] | 0 |
| heuristics/conflictdiving/priority | priority of heuristic <conflictdiving>
Range: {-536870912, ..., 536870911} | -1000100 |
heuristics/crossover
| Option | Description | Default |
| heuristics/crossover/bestsollimit | limit on number of improving incumbent solutions in sub-CIP
Range: {-1, ..., ∞} | -1 |
| heuristics/crossover/freq | frequency for calling primal heuristic <crossover> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 30 |
| heuristics/crossover/freqofs | frequency offset for calling primal heuristic <crossover>
Range: {0, ..., 1073741822} | 0 |
| heuristics/crossover/minfixingrate | minimum percentage of integer variables that have to be fixed
Range: [0, 1] | 0.666 |
| heuristics/crossover/nodesofs | number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞} | 500 |
| heuristics/crossover/nodesquot | contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1] | 0.1 |
| heuristics/crossover/nusedsols | number of solutions to be taken into account
Range: {2, ..., ∞} | 3 |
| Options for expert users |
| heuristics/crossover/copycuts | if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean | 1 |
| heuristics/crossover/dontwaitatroot | should the nwaitingnodes parameter be ignored at the root node?
Range: boolean | 0 |
| heuristics/crossover/lplimfac | factor by which the limit on the number of LP depends on the node limit
Range: [1, ∞] | 2 |
| heuristics/crossover/maxdepth | maximal depth level to call primal heuristic <crossover> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/crossover/maxnodes | maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞} | 5000 |
| heuristics/crossover/minimprove | factor by which Crossover should at least improve the incumbent
Range: [0, 1] | 0.01 |
| heuristics/crossover/minnodes | minimum number of nodes required to start the subproblem
Range: {0, ..., ∞} | 50 |
| heuristics/crossover/nwaitingnodes | number of nodes without incumbent change that heuristic should wait
Range: {0, ..., ∞} | 200 |
| heuristics/crossover/permute | should the subproblem be permuted to increase diversification?
Range: boolean | 0 |
| heuristics/crossover/priority | priority of heuristic <crossover>
Range: {-536870912, ..., 536870911} | -1104000 |
| heuristics/crossover/randomization | should the choice which sols to take be randomized?
Range: boolean | 1 |
| heuristics/crossover/uselprows | should subproblem be created out of the rows in the LP rows?
Range: boolean | 0 |
| heuristics/crossover/useuct | should uct node selection be used at the beginning of the search?
Range: boolean | 0 |
heuristics/dins
| Option | Description | Default |
| heuristics/dins/bestsollimit | limit on number of improving incumbent solutions in sub-CIP
Range: {-1, ..., ∞} | 3 |
| heuristics/dins/freq | frequency for calling primal heuristic <dins> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/dins/freqofs | frequency offset for calling primal heuristic <dins>
Range: {0, ..., 1073741822} | 0 |
| heuristics/dins/minfixingrate | minimum percentage of integer variables that have to be fixable
Range: [0, 1] | 0.3 |
| heuristics/dins/minnodes | minimum number of nodes required to start the subproblem
Range: {0, ..., ∞} | 50 |
| heuristics/dins/neighborhoodsize | radius (using Manhattan metric) of the incumbent's neighborhood to be searched
Range: {1, ..., ∞} | 18 |
| heuristics/dins/nodesofs | number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞} | 5000 |
| heuristics/dins/nodesquot | contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1] | 0.05 |
| heuristics/dins/solnum | number of pool-solutions to be checked for flag array update (for hard fixing of binary variables)
Range: {1, ..., ∞} | 5 |
| Options for expert users |
| heuristics/dins/copycuts | if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean | 1 |
| heuristics/dins/lplimfac | factor by which the limit on the number of LP depends on the node limit
Range: [1, ∞] | 1.5 |
| heuristics/dins/maxdepth | maximal depth level to call primal heuristic <dins> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/dins/maxnodes | maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞} | 5000 |
| heuristics/dins/minimprove | factor by which dins should at least improve the incumbent
Range: [0, 1] | 0.01 |
| heuristics/dins/nwaitingnodes | number of nodes without incumbent change that heuristic should wait
Range: {0, ..., ∞} | 200 |
| heuristics/dins/priority | priority of heuristic <dins>
Range: {-536870912, ..., 536870911} | -1105000 |
| heuristics/dins/uselprows | should subproblem be created out of the rows in the LP rows?
Range: boolean | 0 |
| heuristics/dins/useuct | should uct node selection be used at the beginning of the search?
Range: boolean | 0 |
heuristics/distributiondiving
| Option | Description | Default |
| heuristics/distributiondiving/backtrack | use one level of backtracking if infeasibility is encountered?
Range: boolean | 1 |
| heuristics/distributiondiving/freq | frequency for calling primal heuristic <distributiondiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 10 |
| heuristics/distributiondiving/freqofs | frequency offset for calling primal heuristic <distributiondiving>
Range: {0, ..., 1073741822} | 3 |
| heuristics/distributiondiving/lpresolvedomchgquot | percentage of immediate domain changes during probing to trigger LP resolve
Range: [0, ∞] | 0.15 |
| heuristics/distributiondiving/lpsolvefreq | LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
Range: {0, ..., ∞} | 0 |
| heuristics/distributiondiving/maxlpiterofs | additional number of allowed LP iterations
Range: {0, ..., ∞} | 1000 |
| heuristics/distributiondiving/maxlpiterquot | maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞] | 0.05 |
| heuristics/distributiondiving/onlylpbranchcands | should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean | 1 |
| Options for expert users |
| heuristics/distributiondiving/maxdepth | maximal depth level to call primal heuristic <distributiondiving> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/distributiondiving/maxdiveavgquot | maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞] | 0 |
| heuristics/distributiondiving/maxdiveavgquotnosol | maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞] | 0 |
| heuristics/distributiondiving/maxdiveubquot | maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1] | 0.8 |
| heuristics/distributiondiving/maxdiveubquotnosol | maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1] | 0.1 |
| heuristics/distributiondiving/maxreldepth | maximal relative depth to start diving
Range: [0, 1] | 1 |
| heuristics/distributiondiving/minreldepth | minimal relative depth to start diving
Range: [0, 1] | 0 |
| heuristics/distributiondiving/priority | priority of heuristic <distributiondiving>
Range: {-536870912, ..., 536870911} | -1003300 |
| heuristics/distributiondiving/scoreparam | the score;largest 'd'ifference, 'l'owest cumulative probability,'h'ighest c.p., 'v'otes lowest c.p., votes highest c.p.('w'), 'r'evolving
Range: l, v, d, h, w, r | r |
heuristics/dps
| Option | Description | Default |
| heuristics/dps/freq | frequency for calling primal heuristic <dps> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/dps/freqofs | frequency offset for calling primal heuristic <dps>
Range: {0, ..., 1073741822} | 0 |
| heuristics/dps/maxiterations | maximal number of iterations
Range: {1, ..., ∞} | 50 |
| heuristics/dps/maxlinkscore | maximal linking score of used decomposition (equivalent to percentage of linking constraints)
Range: [0, 1] | 1 |
| heuristics/dps/penalty | multiplier for absolute increase of penalty parameters (0: no increase)
Range: [0, ∞] | 100 |
| heuristics/dps/reoptimize | should the problem get reoptimized with the original objective function?
Range: boolean | 0 |
| heuristics/dps/reoptlimits | should strict limits for reoptimization be set?
Range: boolean | 1 |
| heuristics/dps/reuse | should solutions get reused in subproblems?
Range: boolean | 0 |
| heuristics/dps/timing | should the heuristic run before or after the processing of the node? (0: before, 1: after, 2: both)
Range: {0, ..., 2} | 0 |
| Options for expert users |
| heuristics/dps/maxdepth | maximal depth level to call primal heuristic <dps> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/dps/priority | priority of heuristic <dps>
Range: {-536870912, ..., 536870911} | 75000 |
heuristics/dualval
| Option | Description | Default |
| heuristics/dualval/dynamicdepth | says if and how the recursion depth is computed at runtime
Range: {0, ..., 1} | 0 |
| heuristics/dualval/freq | frequency for calling primal heuristic <dualval> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/dualval/freqofs | frequency offset for calling primal heuristic <dualval>
Range: {0, ..., 1073741822} | 0 |
| heuristics/dualval/heurverblevel | verblevel of the heuristic, default is 0 to display nothing
Range: {0, ..., 4} | 0 |
| heuristics/dualval/lambdaobj | scaling factor for the objective function
Range: [0, 1] | 0 |
| heuristics/dualval/lambdaslack | value added to objective of slack variables, must not be zero
Range: [0.1, ∞] | 1 |
| heuristics/dualval/maxcalls | maximal number of recursive calls of the heuristic (if dynamicdepth is off)
Range: {0, ..., ∞} | 25 |
| heuristics/dualval/maxequalranks | maximal number of variables that may have maximal rank, quit if there are more, turn off by setting -1
Range: {-1, ..., ∞} | 50 |
| heuristics/dualval/mingap | minimal gap for which we still run the heuristic, if gap is less we return without doing anything
Range: [0, 100] | 5 |
| heuristics/dualval/nlpverblevel | verblevel of the nlp solver, can be 0 or 1
Range: {0, ..., 1} | 0 |
| heuristics/dualval/onlyleaves | disable the heuristic if it was not called at a leaf of the B&B tree
Range: boolean | 0 |
| heuristics/dualval/rankvalue | number of ranks that should be displayed when the heuristic is called
Range: {0, ..., ∞} | 10 |
| heuristics/dualval/relaxcontvars | relax the continous variables
Range: boolean | 0 |
| heuristics/dualval/relaxindicators | relax the indicator variables by introducing continuous copies
Range: boolean | 0 |
| Options for expert users |
| heuristics/dualval/forceimprovements | exit if objective doesn't improve
Range: boolean | 0 |
| heuristics/dualval/maxdepth | maximal depth level to call primal heuristic <dualval> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/dualval/onlycheaper | add constraint to ensure that discrete vars are improving
Range: boolean | 1 |
| heuristics/dualval/priority | priority of heuristic <dualval>
Range: {-536870912, ..., 536870911} | -10 |
heuristics/farkasdiving
| Option | Description | Default |
| heuristics/farkasdiving/backtrack | use one level of backtracking if infeasibility is encountered?
Range: boolean | 1 |
| heuristics/farkasdiving/freq | frequency for calling primal heuristic <farkasdiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 10 |
| heuristics/farkasdiving/freqofs | frequency offset for calling primal heuristic <farkasdiving>
Range: {0, ..., 1073741822} | 0 |
| heuristics/farkasdiving/lpresolvedomchgquot | percentage of immediate domain changes during probing to trigger LP resolve
Range: [0, ∞] | 0.15 |
| heuristics/farkasdiving/lpsolvefreq | LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
Range: {0, ..., ∞} | 1 |
| heuristics/farkasdiving/maxlpiterofs | additional number of allowed LP iterations
Range: {0, ..., ∞} | 1000 |
| heuristics/farkasdiving/maxlpiterquot | maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞] | 0.05 |
| heuristics/farkasdiving/onlylpbranchcands | should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean | 0 |
| Options for expert users |
| heuristics/farkasdiving/checkcands | should diving candidates be checked before running?
Range: boolean | 0 |
| heuristics/farkasdiving/maxdepth | maximal depth level to call primal heuristic <farkasdiving> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/farkasdiving/maxdiveavgquot | maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞] | 0 |
| heuristics/farkasdiving/maxdiveavgquotnosol | maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞] | 0 |
| heuristics/farkasdiving/maxdiveubquot | maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1] | 0.8 |
| heuristics/farkasdiving/maxdiveubquotnosol | maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1] | 0.1 |
| heuristics/farkasdiving/maxobjocc | maximal occurance factor of an objective coefficient
Range: [0, 1] | 1 |
| heuristics/farkasdiving/maxreldepth | maximal relative depth to start diving
Range: [0, 1] | 1 |
| heuristics/farkasdiving/minreldepth | minimal relative depth to start diving
Range: [0, 1] | 0 |
| heuristics/farkasdiving/objdynamism | minimal objective dynamism (log) to run
Range: [0, ∞] | 0.0001 |
| heuristics/farkasdiving/priority | priority of heuristic <farkasdiving>
Range: {-536870912, ..., 536870911} | -900000 |
| heuristics/farkasdiving/rootsuccess | should the heuristic only run within the tree if at least one solution was found at the root node?
Range: boolean | 1 |
| heuristics/farkasdiving/scalescore | should the score be scaled?
Range: boolean | 1 |
| heuristics/farkasdiving/scaletype | scale score by [f]ractionality or [i]mpact on farkasproof
Range: f, i | i |
heuristics/feaspump
| Option | Description | Default |
| heuristics/feaspump/alpha | initial weight of the objective function in the convex combination
Range: [0, 1] | 1 |
| heuristics/feaspump/alphadiff | threshold difference for the convex parameter to perform perturbation
Range: [0, 1] | 1 |
| heuristics/feaspump/beforecuts | should the feasibility pump be called at root node before cut separation?
Range: boolean | 1 |
| heuristics/feaspump/freq | frequency for calling primal heuristic <feaspump> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 20 |
| heuristics/feaspump/freqofs | frequency offset for calling primal heuristic <feaspump>
Range: {0, ..., 1073741822} | 0 |
| heuristics/feaspump/maxlpiterofs | additional number of allowed LP iterations
Range: {0, ..., ∞} | 1000 |
| heuristics/feaspump/maxlpiterquot | maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞] | 0.01 |
| heuristics/feaspump/neighborhoodsize | radius (using Manhattan metric) of the neighborhood to be searched in stage 3
Range: {1, ..., ∞} | 18 |
| heuristics/feaspump/objfactor | factor by which the regard of the objective is decreased in each round, 1.0 for dynamic
Range: [0, 1] | 0.1 |
| heuristics/feaspump/pertsolfound | should a random perturbation be performed if a feasible solution was found?
Range: boolean | 1 |
| heuristics/feaspump/stage3 | should we solve a local branching sub-MIP if no solution could be found?
Range: boolean | 0 |
| heuristics/feaspump/usefp20 | should an iterative round-and-propagate scheme be used to find the integral points?
Range: boolean | 0 |
| Options for expert users |
| heuristics/feaspump/copycuts | should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean | 1 |
| heuristics/feaspump/cyclelength | maximum length of cycles to be checked explicitly in each round
Range: {1, ..., 100} | 3 |
| heuristics/feaspump/maxdepth | maximal depth level to call primal heuristic <feaspump> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/feaspump/maxloops | maximal number of pumping loops (-1: no limit)
Range: {-1, ..., ∞} | 10000 |
| heuristics/feaspump/maxsols | total number of feasible solutions found up to which heuristic is called (-1: no limit)
Range: {-1, ..., ∞} | 10 |
| heuristics/feaspump/maxstallloops | maximal number of pumping rounds without fractionality improvement (-1: no limit)
Range: {-1, ..., ∞} | 10 |
| heuristics/feaspump/minflips | minimum number of random variables to flip, if a 1-cycle is encountered
Range: {1, ..., ∞} | 10 |
| heuristics/feaspump/perturbfreq | number of iterations until a random perturbation is forced
Range: {1, ..., ∞} | 100 |
| heuristics/feaspump/priority | priority of heuristic <feaspump>
Range: {-536870912, ..., 536870911} | -1000000 |
heuristics/fixandinfer
| Option | Description | Default |
| heuristics/fixandinfer/freq | frequency for calling primal heuristic <fixandinfer> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/fixandinfer/freqofs | frequency offset for calling primal heuristic <fixandinfer>
Range: {0, ..., 1073741822} | 0 |
| Options for expert users |
| heuristics/fixandinfer/maxdepth | maximal depth level to call primal heuristic <fixandinfer> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/fixandinfer/minfixings | minimal number of fixings to apply before dive may be aborted
Range: {0, ..., ∞} | 100 |
| heuristics/fixandinfer/priority | priority of heuristic <fixandinfer>
Range: {-536870912, ..., 536870911} | -500000 |
| heuristics/fixandinfer/proprounds | maximal number of propagation rounds in probing subproblems (-1: no limit, 0: auto)
Range: {-1, ..., ∞} | 0 |
heuristics/fracdiving
| Option | Description | Default |
| heuristics/fracdiving/backtrack | use one level of backtracking if infeasibility is encountered?
Range: boolean | 1 |
| heuristics/fracdiving/freq | frequency for calling primal heuristic <fracdiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 10 |
| heuristics/fracdiving/freqofs | frequency offset for calling primal heuristic <fracdiving>
Range: {0, ..., 1073741822} | 3 |
| heuristics/fracdiving/lpresolvedomchgquot | percentage of immediate domain changes during probing to trigger LP resolve
Range: [0, ∞] | 0.15 |
| heuristics/fracdiving/lpsolvefreq | LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
Range: {0, ..., ∞} | 0 |
| heuristics/fracdiving/maxlpiterofs | additional number of allowed LP iterations
Range: {0, ..., ∞} | 1000 |
| heuristics/fracdiving/maxlpiterquot | maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞] | 0.05 |
| heuristics/fracdiving/onlylpbranchcands | should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean | 0 |
| Options for expert users |
| heuristics/fracdiving/maxdepth | maximal depth level to call primal heuristic <fracdiving> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/fracdiving/maxdiveavgquot | maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞] | 0 |
| heuristics/fracdiving/maxdiveavgquotnosol | maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞] | 0 |
| heuristics/fracdiving/maxdiveubquot | maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1] | 0.8 |
| heuristics/fracdiving/maxdiveubquotnosol | maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1] | 0.1 |
| heuristics/fracdiving/maxreldepth | maximal relative depth to start diving
Range: [0, 1] | 1 |
| heuristics/fracdiving/minreldepth | minimal relative depth to start diving
Range: [0, 1] | 0 |
| heuristics/fracdiving/priority | priority of heuristic <fracdiving>
Range: {-536870912, ..., 536870911} | -1003000 |
heuristics/gins
| Option | Description | Default |
| heuristics/gins/bestsollimit | limit on number of improving incumbent solutions in sub-CIP
Range: {-1, ..., ∞} | 3 |
| heuristics/gins/freq | frequency for calling primal heuristic <gins> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 20 |
| heuristics/gins/freqofs | frequency offset for calling primal heuristic <gins>
Range: {0, ..., 1073741822} | 8 |
| heuristics/gins/maxdistance | maximum distance to selected variable to enter the subproblem, or -1 to select the distance that best approximates the minimum fixing rate from below
Range: {-1, ..., ∞} | 3 |
| heuristics/gins/minfixingrate | percentage of integer variables that have to be fixed
Range: [1e-06, 0.999999] | 0.66 |
| heuristics/gins/nodesofs | number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞} | 500 |
| heuristics/gins/nodesquot | contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1] | 0.15 |
| Options for expert users |
| heuristics/gins/consecutiveblocks | should blocks be treated consecutively (sorted by ascending label?)
Range: boolean | 1 |
| heuristics/gins/copycuts | if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean | 1 |
| heuristics/gins/fixcontvars | should continuous variables outside the neighborhoods be fixed?
Range: boolean | 0 |
| heuristics/gins/maxdepth | maximal depth level to call primal heuristic <gins> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/gins/maxnodes | maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞} | 5000 |
| heuristics/gins/minimprove | factor by which gins should at least improve the incumbent
Range: [0, 1] | 0.01 |
| heuristics/gins/minnodes | minimum number of nodes required to start the subproblem
Range: {0, ..., ∞} | 50 |
| heuristics/gins/nwaitingnodes | number of nodes without incumbent change that heuristic should wait
Range: {0, ..., ∞} | 100 |
| heuristics/gins/overlap | overlap of blocks between runs - 0.0: no overlap, 1.0: shift by only 1 block
Range: [0, 1] | 0 |
| heuristics/gins/potential | the reference point to compute the neighborhood potential: (r)oot, (l)ocal lp, or (p)seudo solution
Range: l, p, r | r |
| heuristics/gins/priority | priority of heuristic <gins>
Range: {-536870912, ..., 536870911} | -1103000 |
| heuristics/gins/relaxdenseconss | should dense constraints (at least as dense as 1 - minfixingrate) be ignored by connectivity graph?
Range: boolean | 0 |
| heuristics/gins/rollhorizonlimfac | limiting percentage for variables already used in sub-SCIPs to terminate rolling horizon approach
Range: [0, 1] | 0.4 |
| heuristics/gins/usedecomp | should user decompositions be considered, if available?
Range: boolean | 1 |
| heuristics/gins/usedecomprollhorizon | should user decompositions be considered for initial selection in rolling horizon, if available?
Range: boolean | 0 |
| heuristics/gins/uselprows | should subproblem be created out of the rows in the LP rows?
Range: boolean | 0 |
| heuristics/gins/userollinghorizon | should the heuristic solve a sequence of sub-MIP's around the first selected variable
Range: boolean | 1 |
| heuristics/gins/useselfallback | should random initial variable selection be used if decomposition was not successful?
Range: boolean | 1 |
heuristics/guideddiving
| Option | Description | Default |
| heuristics/guideddiving/backtrack | use one level of backtracking if infeasibility is encountered?
Range: boolean | 1 |
| heuristics/guideddiving/freq | frequency for calling primal heuristic <guideddiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 10 |
| heuristics/guideddiving/freqofs | frequency offset for calling primal heuristic <guideddiving>
Range: {0, ..., 1073741822} | 7 |
| heuristics/guideddiving/lpresolvedomchgquot | percentage of immediate domain changes during probing to trigger LP resolve
Range: [0, ∞] | 0.15 |
| heuristics/guideddiving/lpsolvefreq | LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
Range: {0, ..., ∞} | 0 |
| heuristics/guideddiving/maxlpiterofs | additional number of allowed LP iterations
Range: {0, ..., ∞} | 1000 |
| heuristics/guideddiving/maxlpiterquot | maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞] | 0.05 |
| heuristics/guideddiving/onlylpbranchcands | should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean | 0 |
| Options for expert users |
| heuristics/guideddiving/maxdepth | maximal depth level to call primal heuristic <guideddiving> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/guideddiving/maxdiveavgquot | maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞] | 0 |
| heuristics/guideddiving/maxdiveavgquotnosol | maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞] | 1 |
| heuristics/guideddiving/maxdiveubquot | maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1] | 0.8 |
| heuristics/guideddiving/maxdiveubquotnosol | maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1] | 1 |
| heuristics/guideddiving/maxreldepth | maximal relative depth to start diving
Range: [0, 1] | 1 |
| heuristics/guideddiving/minreldepth | minimal relative depth to start diving
Range: [0, 1] | 0 |
| heuristics/guideddiving/priority | priority of heuristic <guideddiving>
Range: {-536870912, ..., 536870911} | -1007000 |
heuristics/indicator
| Option | Description | Default |
| heuristics/indicator/freq | frequency for calling primal heuristic <indicator> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 1 |
| heuristics/indicator/freqofs | frequency offset for calling primal heuristic <indicator>
Range: {0, ..., 1073741822} | 0 |
| Options for expert users |
| heuristics/indicator/improvesols | Try to improve other solutions by one-opt?
Range: boolean | 0 |
| heuristics/indicator/maxdepth | maximal depth level to call primal heuristic <indicator> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/indicator/oneopt | whether the one-opt heuristic should be started
Range: boolean | 0 |
| heuristics/indicator/priority | priority of heuristic <indicator>
Range: {-536870912, ..., 536870911} | -20200 |
heuristics/indicatordiving
| Option | Description | Default |
| heuristics/indicatordiving/backtrack | use one level of backtracking if infeasibility is encountered?
Range: boolean | 1 |
| heuristics/indicatordiving/freq | frequency for calling primal heuristic <indicatordiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 0 |
| heuristics/indicatordiving/freqofs | frequency offset for calling primal heuristic <indicatordiving>
Range: {0, ..., 1073741822} | 0 |
| heuristics/indicatordiving/lpresolvedomchgquot | percentage of immediate domain changes during probing to trigger LP resolve
Range: [0, ∞] | 0.15 |
| heuristics/indicatordiving/lpsolvefreq | LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
Range: {0, ..., ∞} | 30 |
| heuristics/indicatordiving/maxlpiterofs | additional number of allowed LP iterations
Range: {0, ..., ∞} | 1000 |
| heuristics/indicatordiving/maxlpiterquot | maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞] | 0.05 |
| heuristics/indicatordiving/onlylpbranchcands | should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean | 0 |
| heuristics/indicatordiving/roundingfrac | in violation case all fractional below this value are fixed to constant
Range: [0, 1] | 0.5 |
| heuristics/indicatordiving/roundingmode | decides which roundingmode is selected (0: conservative, 1: aggressive)
Range: {0, ..., 1} | 0 |
| heuristics/indicatordiving/runwithoutscinds | should heur run if there are no indicator constraints modeling semicont. vars?
Range: boolean | 0 |
| heuristics/indicatordiving/semicontscoremode | which values of semi-continuous variables should get a high score? (0: low, 1: middle, 2: high)
Range: {0, ..., 2} | 0 |
| heuristics/indicatordiving/usevarbounds | should varbound constraints be considered?
Range: boolean | 1 |
| Options for expert users |
| heuristics/indicatordiving/maxdepth | maximal depth level to call primal heuristic <indicatordiving> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/indicatordiving/maxdiveavgquot | maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞] | 0 |
| heuristics/indicatordiving/maxdiveavgquotnosol | maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞] | 0 |
| heuristics/indicatordiving/maxdiveubquot | maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1] | 0.8 |
| heuristics/indicatordiving/maxdiveubquotnosol | maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1] | 0.1 |
| heuristics/indicatordiving/maxreldepth | maximal relative depth to start diving
Range: [0, 1] | 1 |
| heuristics/indicatordiving/minreldepth | minimal relative depth to start diving
Range: [0, 1] | 0 |
| heuristics/indicatordiving/priority | priority of heuristic <indicatordiving>
Range: {-536870912, ..., 536870911} | -150000 |
heuristics/intdiving
| Option | Description | Default |
| heuristics/intdiving/backtrack | use one level of backtracking if infeasibility is encountered?
Range: boolean | 1 |
| heuristics/intdiving/freq | frequency for calling primal heuristic <intdiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/intdiving/freqofs | frequency offset for calling primal heuristic <intdiving>
Range: {0, ..., 1073741822} | 9 |
| heuristics/intdiving/maxlpiterofs | additional number of allowed LP iterations
Range: {0, ..., ∞} | 1000 |
| heuristics/intdiving/maxlpiterquot | maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞] | 0.05 |
| Options for expert users |
| heuristics/intdiving/maxdepth | maximal depth level to call primal heuristic <intdiving> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/intdiving/maxdiveavgquot | maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞] | 0 |
| heuristics/intdiving/maxdiveavgquotnosol | maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞] | 0 |
| heuristics/intdiving/maxdiveubquot | maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1] | 0.8 |
| heuristics/intdiving/maxdiveubquotnosol | maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1] | 0.1 |
| heuristics/intdiving/maxreldepth | maximal relative depth to start diving
Range: [0, 1] | 1 |
| heuristics/intdiving/minreldepth | minimal relative depth to start diving
Range: [0, 1] | 0 |
| heuristics/intdiving/priority | priority of heuristic <intdiving>
Range: {-536870912, ..., 536870911} | -1003500 |
heuristics/intshifting
| Option | Description | Default |
| heuristics/intshifting/freq | frequency for calling primal heuristic <intshifting> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 10 |
| heuristics/intshifting/freqofs | frequency offset for calling primal heuristic <intshifting>
Range: {0, ..., 1073741822} | 0 |
| Options for expert users |
| heuristics/intshifting/maxdepth | maximal depth level to call primal heuristic <intshifting> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/intshifting/priority | priority of heuristic <intshifting>
Range: {-536870912, ..., 536870911} | -10000 |
heuristics/linesearchdiving
| Option | Description | Default |
| heuristics/linesearchdiving/backtrack | use one level of backtracking if infeasibility is encountered?
Range: boolean | 1 |
| heuristics/linesearchdiving/freq | frequency for calling primal heuristic <linesearchdiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 10 |
| heuristics/linesearchdiving/freqofs | frequency offset for calling primal heuristic <linesearchdiving>
Range: {0, ..., 1073741822} | 6 |
| heuristics/linesearchdiving/lpresolvedomchgquot | percentage of immediate domain changes during probing to trigger LP resolve
Range: [0, ∞] | 0.15 |
| heuristics/linesearchdiving/lpsolvefreq | LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
Range: {0, ..., ∞} | 0 |
| heuristics/linesearchdiving/maxlpiterofs | additional number of allowed LP iterations
Range: {0, ..., ∞} | 1000 |
| heuristics/linesearchdiving/maxlpiterquot | maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞] | 0.05 |
| heuristics/linesearchdiving/onlylpbranchcands | should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean | 0 |
| Options for expert users |
| heuristics/linesearchdiving/maxdepth | maximal depth level to call primal heuristic <linesearchdiving> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/linesearchdiving/maxdiveavgquot | maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞] | 0 |
| heuristics/linesearchdiving/maxdiveavgquotnosol | maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞] | 0 |
| heuristics/linesearchdiving/maxdiveubquot | maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1] | 0.8 |
| heuristics/linesearchdiving/maxdiveubquotnosol | maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1] | 0.1 |
| heuristics/linesearchdiving/maxreldepth | maximal relative depth to start diving
Range: [0, 1] | 1 |
| heuristics/linesearchdiving/minreldepth | minimal relative depth to start diving
Range: [0, 1] | 0 |
| heuristics/linesearchdiving/priority | priority of heuristic <linesearchdiving>
Range: {-536870912, ..., 536870911} | -1006000 |
heuristics/localbranching
| Option | Description | Default |
| heuristics/localbranching/bestsollimit | limit on number of improving incumbent solutions in sub-CIP
Range: {-1, ..., ∞} | 3 |
| heuristics/localbranching/freq | frequency for calling primal heuristic <localbranching> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/localbranching/freqofs | frequency offset for calling primal heuristic <localbranching>
Range: {0, ..., 1073741822} | 0 |
| heuristics/localbranching/neighborhoodsize | radius (using Manhattan metric) of the incumbent's neighborhood to be searched
Range: {1, ..., ∞} | 18 |
| heuristics/localbranching/nodesofs | number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞} | 1000 |
| heuristics/localbranching/nodesquot | contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1] | 0.05 |
| Options for expert users |
| heuristics/localbranching/copycuts | if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean | 1 |
| heuristics/localbranching/lplimfac | factor by which the limit on the number of LP depends on the node limit
Range: [1, ∞] | 1.5 |
| heuristics/localbranching/maxdepth | maximal depth level to call primal heuristic <localbranching> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/localbranching/maxnodes | maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞} | 10000 |
| heuristics/localbranching/minimprove | factor by which localbranching should at least improve the incumbent
Range: [0, 1] | 0.01 |
| heuristics/localbranching/minnodes | minimum number of nodes required to start the subproblem
Range: {0, ..., ∞} | 1000 |
| heuristics/localbranching/nwaitingnodes | number of nodes without incumbent change that heuristic should wait
Range: {0, ..., ∞} | 200 |
| heuristics/localbranching/priority | priority of heuristic <localbranching>
Range: {-536870912, ..., 536870911} | -1102000 |
| heuristics/localbranching/uselprows | should subproblem be created out of the rows in the LP rows?
Range: boolean | 0 |
heuristics/locks
| Option | Description | Default |
| heuristics/locks/freq | frequency for calling primal heuristic <locks> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 0 |
| heuristics/locks/freqofs | frequency offset for calling primal heuristic <locks>
Range: {0, ..., 1073741822} | 0 |
| heuristics/locks/minfixingrate | minimum percentage of integer variables that have to be fixable
Range: [0, 1] | 0.65 |
| heuristics/locks/nodesofs | number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞} | 500 |
| heuristics/locks/nodesquot | contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1] | 0.1 |
| heuristics/locks/roundupprobability | probability for rounding a variable up in case of ties
Range: [0, 1] | 0.67 |
| Options for expert users |
| heuristics/locks/copycuts | should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean | 1 |
| heuristics/locks/maxdepth | maximal depth level to call primal heuristic <locks> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/locks/maxnodes | maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞} | 5000 |
| heuristics/locks/maxproprounds | maximum number of propagation rounds to be performed in each propagation call (-1: no limit, -2: parameter settings)
Range: {-2, ..., ∞} | 2 |
| heuristics/locks/minfixingratelp | minimum fixing rate over all variables (including continuous) to solve LP
Range: [0, 1] | 0 |
| heuristics/locks/minimprove | factor by which locks heuristic should at least improve the incumbent
Range: [0, 1] | 0.01 |
| heuristics/locks/minnodes | minimum number of nodes required to start the subproblem
Range: {0, ..., ∞} | 500 |
| heuristics/locks/priority | priority of heuristic <locks>
Range: {-536870912, ..., 536870911} | 3000 |
| heuristics/locks/updatelocks | should the locks be updated based on LP rows?
Range: boolean | 1 |
| heuristics/locks/usefinalsubmip | should a final sub-MIP be solved to costruct a feasible solution if the LP was not roundable?
Range: boolean | 1 |
heuristics/lpface
| Option | Description | Default |
| heuristics/lpface/freq | frequency for calling primal heuristic <lpface> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 15 |
| heuristics/lpface/freqofs | frequency offset for calling primal heuristic <lpface>
Range: {0, ..., 1073741822} | 0 |
| heuristics/lpface/minfixingrate | required percentage of fixed integer variables in sub-MIP to run
Range: [0, 1] | 0.1 |
| heuristics/lpface/nodesofs | number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞} | 200 |
| heuristics/lpface/nodesquot | contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1] | 0.1 |
| Options for expert users |
| heuristics/lpface/copycuts | if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean | 1 |
| heuristics/lpface/dualbasisequations | should dually nonbasic rows be turned into equations?
Range: boolean | 0 |
| heuristics/lpface/keepsubscip | should the heuristic continue solving the same sub-SCIP?
Range: boolean | 0 |
| heuristics/lpface/lplimfac | factor by which the limit on the number of LP depends on the node limit
Range: [1, ∞] | 2 |
| heuristics/lpface/maxdepth | maximal depth level to call primal heuristic <lpface> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/lpface/maxnodes | maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞} | 5000 |
| heuristics/lpface/minnodes | minimum number of nodes required to start the subproblem
Range: {0, ..., ∞} | 50 |
| heuristics/lpface/minpathlen | the minimum active search tree path length along which lower bound hasn't changed before heuristic becomes active
Range: {0, ..., 65531} | 5 |
| heuristics/lpface/priority | priority of heuristic <lpface>
Range: {-536870912, ..., 536870911} | -1104010 |
| heuristics/lpface/subscipobjective | objective function in the sub-SCIP: (z)ero, (r)oot-LP-difference, (i)nference, LP (f)ractionality, (o)riginal
Range: f, o, r, z, i | z |
| heuristics/lpface/uselprows | should subproblem be created out of the rows in the LP rows?
Range: boolean | 1 |
heuristics/mpec
| Option | Description | Default |
| heuristics/mpec/freq | frequency for calling primal heuristic <mpec> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 50 |
| heuristics/mpec/freqofs | frequency offset for calling primal heuristic <mpec>
Range: {0, ..., 1073741822} | 0 |
| heuristics/mpec/inittheta | initial regularization right-hand side value
Range: [0, 0.25] | 0.125 |
| heuristics/mpec/maxiter | maximum number of iterations of the MPEC loop
Range: {0, ..., ∞} | 100 |
| heuristics/mpec/maxnlpcost | maximum cost available for solving NLPs per call of the heuristic
Range: [0, ∞] | 1e+08 |
| heuristics/mpec/maxnlpiter | maximum number of NLP iterations per solve
Range: {0, ..., ∞} | 500 |
| heuristics/mpec/maxnunsucc | maximum number of consecutive calls for which the heuristic did not find an improving solution
Range: {0, ..., ∞} | 10 |
| heuristics/mpec/mingapleft | minimum amount of gap left in order to call the heuristic
Range: [0, ∞] | 0.05 |
| heuristics/mpec/minimprove | factor by which heuristic should at least improve the incumbent
Range: [0, 1] | 0.01 |
| heuristics/mpec/sigma | regularization update factor
Range: [0, 1] | 0.5 |
| heuristics/mpec/subnlptrigger | maximum number of NLP iterations per solve
Range: [0, 1] | 0.001 |
| Options for expert users |
| heuristics/mpec/maxdepth | maximal depth level to call primal heuristic <mpec> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/mpec/priority | priority of heuristic <mpec>
Range: {-536870912, ..., 536870911} | -2050000 |
heuristics/multistart
| Option | Description | Default |
| heuristics/multistart/freq | frequency for calling primal heuristic <multistart> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 0 |
| heuristics/multistart/freqofs | frequency offset for calling primal heuristic <multistart>
Range: {0, ..., 1073741822} | 0 |
| heuristics/multistart/gradlimit | limit for gradient computations for all improvePoint() calls (0 for no limit)
Range: [0, ∞] | 5e+06 |
| heuristics/multistart/maxboundsize | maximum variable domain size for unbounded variables
Range: [0, ∞] | 20000 |
| heuristics/multistart/maxiter | number of iterations to reduce the maximum violation of a point
Range: {0, ..., ∞} | 300 |
| heuristics/multistart/maxncluster | maximum number of considered clusters per heuristic call
Range: {0, ..., ∞} | 3 |
| heuristics/multistart/maxreldist | maximum distance between two points in the same cluster
Range: [0, ∞] | 0.15 |
| heuristics/multistart/minimprfac | minimum required improving factor to proceed in improvement of a single point
Range: real | 0.05 |
| heuristics/multistart/minimpriter | number of iteration when checking the minimum improvement
Range: {1, ..., ∞} | 10 |
| heuristics/multistart/nrndpoints | number of random points generated per execution call
Range: {0, ..., ∞} | 100 |
| heuristics/multistart/onlynlps | should the heuristic run only on continuous problems?
Range: boolean | 1 |
| Options for expert users |
| heuristics/multistart/maxdepth | maximal depth level to call primal heuristic <multistart> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/multistart/priority | priority of heuristic <multistart>
Range: {-536870912, ..., 536870911} | -2100000 |
heuristics/mutation
| Option | Description | Default |
| heuristics/mutation/bestsollimit | limit on number of improving incumbent solutions in sub-CIP
Range: {-1, ..., ∞} | -1 |
| heuristics/mutation/freq | frequency for calling primal heuristic <mutation> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/mutation/freqofs | frequency offset for calling primal heuristic <mutation>
Range: {0, ..., 1073741822} | 8 |
| heuristics/mutation/minfixingrate | percentage of integer variables that have to be fixed
Range: [1e-06, 0.999999] | 0.8 |
| heuristics/mutation/nodesofs | number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞} | 500 |
| heuristics/mutation/nodesquot | contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1] | 0.1 |
| Options for expert users |
| heuristics/mutation/copycuts | if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean | 1 |
| heuristics/mutation/maxdepth | maximal depth level to call primal heuristic <mutation> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/mutation/maxnodes | maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞} | 5000 |
| heuristics/mutation/minimprove | factor by which mutation should at least improve the incumbent
Range: [0, 1] | 0.01 |
| heuristics/mutation/minnodes | minimum number of nodes required to start the subproblem
Range: {0, ..., ∞} | 500 |
| heuristics/mutation/nwaitingnodes | number of nodes without incumbent change that heuristic should wait
Range: {0, ..., ∞} | 200 |
| heuristics/mutation/priority | priority of heuristic <mutation>
Range: {-536870912, ..., 536870911} | -1103010 |
| heuristics/mutation/uselprows | should subproblem be created out of the rows in the LP rows?
Range: boolean | 0 |
| heuristics/mutation/useuct | should uct node selection be used at the beginning of the search?
Range: boolean | 0 |
heuristics/nlpdiving
| Option | Description | Default |
| heuristics/nlpdiving/backtrack | use one level of backtracking if infeasibility is encountered?
Range: boolean | 1 |
| heuristics/nlpdiving/fixquot | percentage of fractional variables that should be fixed before the next NLP solve
Range: [0, 1] | 0.2 |
| heuristics/nlpdiving/freq | frequency for calling primal heuristic <nlpdiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 10 |
| heuristics/nlpdiving/freqofs | frequency offset for calling primal heuristic <nlpdiving>
Range: {0, ..., 1073741822} | 3 |
| heuristics/nlpdiving/maxfeasnlps | maximal number of NLPs with feasible solution to solve during one dive
Range: {1, ..., ∞} | 10 |
| heuristics/nlpdiving/maxnlpiterabs | minimial absolute number of allowed NLP iterations
Range: {0, ..., ∞} | 200 |
| heuristics/nlpdiving/maxnlpiterrel | additional allowed number of NLP iterations relative to successfully found solutions
Range: {0, ..., ∞} | 10 |
| heuristics/nlpdiving/minsuccquot | heuristic will not run if less then this percentage of calls succeeded (0.0: no limit)
Range: [0, 1] | 0.1 |
| heuristics/nlpdiving/nlpfastfail | should the NLP solver stop early if it converges slow?
Range: boolean | 1 |
| heuristics/nlpdiving/prefercover | should variables in a minimal cover be preferred?
Range: boolean | 1 |
| heuristics/nlpdiving/solvesubmip | should a sub-MIP be solved if all cover variables are fixed?
Range: boolean | 0 |
| heuristics/nlpdiving/varselrule | which variable selection should be used? ('f'ractionality, 'c'oefficient, 'p'seudocost, 'g'uided, 'd'ouble, 'v'eclen)
Range: f, c, p, g, d, v | d |
| Options for expert users |
| heuristics/nlpdiving/lp | should the LP relaxation be solved before the NLP relaxation?
Range: boolean | 0 |
| heuristics/nlpdiving/maxdepth | maximal depth level to call primal heuristic <nlpdiving> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/nlpdiving/maxdiveavgquot | maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞] | 0 |
| heuristics/nlpdiving/maxdiveavgquotnosol | maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞] | 0 |
| heuristics/nlpdiving/maxdiveubquot | maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1] | 0.8 |
| heuristics/nlpdiving/maxdiveubquotnosol | maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1] | 0.1 |
| heuristics/nlpdiving/maxreldepth | maximal relative depth to start diving
Range: [0, 1] | 1 |
| heuristics/nlpdiving/minreldepth | minimal relative depth to start diving
Range: [0, 1] | 0 |
| heuristics/nlpdiving/nlpstart | which point should be used as starting point for the NLP solver? ('n'one, last 'f'easible, from dive's'tart)
Range: f, n, s | s |
| heuristics/nlpdiving/preferlpfracs | prefer variables that are also fractional in LP solution?
Range: boolean | 0 |
| heuristics/nlpdiving/priority | priority of heuristic <nlpdiving>
Range: {-536870912, ..., 536870911} | -1003010 |
heuristics/objpscostdiving
| Option | Description | Default |
| heuristics/objpscostdiving/freq | frequency for calling primal heuristic <objpscostdiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 20 |
| heuristics/objpscostdiving/freqofs | frequency offset for calling primal heuristic <objpscostdiving>
Range: {0, ..., 1073741822} | 4 |
| heuristics/objpscostdiving/maxlpiterofs | additional number of allowed LP iterations
Range: {0, ..., ∞} | 1000 |
| heuristics/objpscostdiving/maxlpiterquot | maximal fraction of diving LP iterations compared to total iteration number
Range: [0, 1] | 0.01 |
| Options for expert users |
| heuristics/objpscostdiving/depthfac | maximal diving depth: number of binary/integer variables times depthfac
Range: [0, ∞] | 0.5 |
| heuristics/objpscostdiving/depthfacnosol | maximal diving depth factor if no feasible solution was found yet
Range: [0, ∞] | 2 |
| heuristics/objpscostdiving/maxdepth | maximal depth level to call primal heuristic <objpscostdiving> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/objpscostdiving/maxreldepth | maximal relative depth to start diving
Range: [0, 1] | 1 |
| heuristics/objpscostdiving/maxsols | total number of feasible solutions found up to which heuristic is called (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| heuristics/objpscostdiving/minreldepth | minimal relative depth to start diving
Range: [0, 1] | 0 |
| heuristics/objpscostdiving/priority | priority of heuristic <objpscostdiving>
Range: {-536870912, ..., 536870911} | -1004000 |
heuristics/octane
| Option | Description | Default |
| heuristics/octane/freq | frequency for calling primal heuristic <octane> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/octane/freqofs | frequency offset for calling primal heuristic <octane>
Range: {0, ..., 1073741822} | 0 |
| Options for expert users |
| heuristics/octane/ffirst | number of 0-1-points to be tested at first whether they violate a common row
Range: {1, ..., ∞} | 10 |
| heuristics/octane/fmax | number of 0-1-points to be tested as possible solutions by OCTANE
Range: {1, ..., ∞} | 100 |
| heuristics/octane/maxdepth | maximal depth level to call primal heuristic <octane> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/octane/priority | priority of heuristic <octane>
Range: {-536870912, ..., 536870911} | -1008000 |
| heuristics/octane/useavgnbray | should the weighted average of the nonbasic cone be used as one ray direction?
Range: boolean | 1 |
| heuristics/octane/useavgray | should the average of the basic cone be used as one ray direction?
Range: boolean | 1 |
| heuristics/octane/useavgwgtray | should the weighted average of the basic cone be used as one ray direction?
Range: boolean | 1 |
| heuristics/octane/usediffray | should the difference between the root solution and the current LP solution be used as one ray direction?
Range: boolean | 0 |
| heuristics/octane/usefracspace | execute OCTANE only in the space of fractional variables (TRUE) or in the full space?
Range: boolean | 1 |
| heuristics/octane/useobjray | should the inner normal of the objective be used as one ray direction?
Range: boolean | 1 |
heuristics/ofins
| Option | Description | Default |
| heuristics/ofins/freq | frequency for calling primal heuristic <ofins> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 0 |
| heuristics/ofins/freqofs | frequency offset for calling primal heuristic <ofins>
Range: {0, ..., 1073741822} | 0 |
| heuristics/ofins/maxchange | maximal rate of change per coefficient to get fixed
Range: [0, 1] | 0.04 |
| heuristics/ofins/maxchangerate | maximal rate of changed coefficients
Range: [0, 1] | 0.5 |
| heuristics/ofins/nodesofs | number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞} | 500 |
| heuristics/ofins/nodesquot | contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1] | 0.1 |
| Options for expert users |
| heuristics/ofins/addallsols | should all subproblem solutions be added to the original SCIP?
Range: boolean | 0 |
| heuristics/ofins/copycuts | should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean | 1 |
| heuristics/ofins/lplimfac | factor by which the limit on the number of LP depends on the node limit
Range: [1, ∞] | 2 |
| heuristics/ofins/maxdepth | maximal depth level to call primal heuristic <ofins> (-1: no limit)
Range: {-1, ..., 1073741822} | 0 |
| heuristics/ofins/maxnodes | maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞} | 5000 |
| heuristics/ofins/minimprove | factor by which RENS should at least improve the incumbent
Range: [0, 1] | 0.01 |
| heuristics/ofins/minnodes | minimum number of nodes required to start the subproblem
Range: {0, ..., ∞} | 50 |
| heuristics/ofins/priority | priority of heuristic <ofins>
Range: {-536870912, ..., 536870911} | 60000 |
heuristics/oneopt
| Option | Description | Default |
| heuristics/oneopt/freq | frequency for calling primal heuristic <oneopt> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 1 |
| heuristics/oneopt/freqofs | frequency offset for calling primal heuristic <oneopt>
Range: {0, ..., 1073741822} | 0 |
| Options for expert users |
| heuristics/oneopt/beforepresol | should the heuristic be called before presolving?
Range: boolean | 0 |
| heuristics/oneopt/duringroot | should the heuristic be called before and during the root node?
Range: boolean | 1 |
| heuristics/oneopt/forcelpconstruction | should the construction of the LP be forced even if LP solving is deactivated?
Range: boolean | 0 |
| heuristics/oneopt/maxdepth | maximal depth level to call primal heuristic <oneopt> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/oneopt/priority | priority of heuristic <oneopt>
Range: {-536870912, ..., 536870911} | -20000 |
| heuristics/oneopt/useloop | should the heuristic continue to run as long as improvements are found?
Range: boolean | 1 |
| heuristics/oneopt/weightedobj | should the objective be weighted with the potential shifting value when sorting the shifting candidates?
Range: boolean | 1 |
heuristics/padm
| Option | Description | Default |
| heuristics/padm/assignlinking | should linking constraints be assigned?
Range: boolean | 1 |
| heuristics/padm/freq | frequency for calling primal heuristic <padm> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 0 |
| heuristics/padm/freqofs | frequency offset for calling primal heuristic <padm>
Range: {0, ..., 1073741822} | 0 |
| heuristics/padm/reoptimize | should the problem get reoptimized with the original objective function?
Range: boolean | 1 |
| heuristics/padm/timing | should the heuristic run before or after the processing of the node? (0: before, 1: after, 2: both)
Range: {0, ..., 2} | 0 |
| Options for expert users |
| heuristics/padm/admiterations | maximal number of ADM iterations in each penalty loop
Range: {1, ..., 100} | 4 |
| heuristics/padm/gap | mipgap at start
Range: [0, 16] | 2 |
| heuristics/padm/maxdepth | maximal depth level to call primal heuristic <padm> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/padm/maxnodes | maximum number of nodes to regard in all subproblems
Range: {0, ..., ∞} | 5000 |
| heuristics/padm/minnodes | minimum number of nodes to regard in one subproblem
Range: {0, ..., ∞} | 50 |
| heuristics/padm/nodefac | factor to control nodelimits of subproblems
Range: [0, 0.99] | 0.8 |
| heuristics/padm/original | should the original problem be used? This is only for testing and not recommended!
Range: boolean | 0 |
| heuristics/padm/penaltyiterations | maximal number of penalty iterations
Range: {1, ..., 100000} | 100 |
| heuristics/padm/priority | priority of heuristic <padm>
Range: {-536870912, ..., 536870911} | 70000 |
| heuristics/padm/scaling | enable sigmoid rescaling of penalty parameters
Range: boolean | 1 |
heuristics/proximity
| Option | Description | Default |
| heuristics/proximity/freq | frequency for calling primal heuristic <proximity> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/proximity/freqofs | frequency offset for calling primal heuristic <proximity>
Range: {0, ..., 1073741822} | 0 |
| Options for expert users |
| heuristics/proximity/binvarquot | threshold for percentage of binary variables required to start
Range: [0, 1] | 0.1 |
| heuristics/proximity/lpitersquot | quotient of sub-MIP LP iterations with respect to LP iterations so far
Range: [0, 1] | 0.2 |
| heuristics/proximity/maxdepth | maximal depth level to call primal heuristic <proximity> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/proximity/maxlpiters | maximum number of LP iterations to be performed in the subproblem
Range: {-1, ..., ∞} | 100000 |
| heuristics/proximity/maxnodes | maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞} | 10000 |
| heuristics/proximity/mingap | minimum primal-dual gap for which the heuristic is executed
Range: [0, ∞] | 0.01 |
| heuristics/proximity/minimprove | factor by which proximity should at least improve the incumbent
Range: [0, 1] | 0.02 |
| heuristics/proximity/minlpiters | minimum number of LP iterations performed in subproblem
Range: {0, ..., ∞} | 200 |
| heuristics/proximity/minnodes | minimum number of nodes required to start the subproblem
Range: {0, ..., ∞} | 1 |
| heuristics/proximity/nodesofs | number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞} | 50 |
| heuristics/proximity/nodesquot | sub-MIP node limit w.r.t number of original nodes
Range: [0, ∞] | 0.1 |
| heuristics/proximity/priority | priority of heuristic <proximity>
Range: {-536870912, ..., 536870911} | -2000000 |
| heuristics/proximity/restart | should the heuristic immediately run again on its newly found solution?
Range: boolean | 1 |
| heuristics/proximity/usefinallp | should the heuristic solve a final LP in case of continuous objective variables?
Range: boolean | 0 |
| heuristics/proximity/uselprows | should subproblem be constructed based on LP row information?
Range: boolean | 0 |
| heuristics/proximity/useuct | should uct node selection be used at the beginning of the search?
Range: boolean | 0 |
| heuristics/proximity/waitingnodes | waiting nodes since last incumbent before heuristic is executed
Range: {0, ..., ∞} | 100 |
heuristics/pscostdiving
| Option | Description | Default |
| heuristics/pscostdiving/backtrack | use one level of backtracking if infeasibility is encountered?
Range: boolean | 1 |
| heuristics/pscostdiving/freq | frequency for calling primal heuristic <pscostdiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 10 |
| heuristics/pscostdiving/freqofs | frequency offset for calling primal heuristic <pscostdiving>
Range: {0, ..., 1073741822} | 2 |
| heuristics/pscostdiving/lpresolvedomchgquot | percentage of immediate domain changes during probing to trigger LP resolve
Range: [0, ∞] | 0.15 |
| heuristics/pscostdiving/lpsolvefreq | LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
Range: {0, ..., ∞} | 0 |
| heuristics/pscostdiving/maxlpiterofs | additional number of allowed LP iterations
Range: {0, ..., ∞} | 1000 |
| heuristics/pscostdiving/maxlpiterquot | maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞] | 0.05 |
| heuristics/pscostdiving/onlylpbranchcands | should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean | 1 |
| Options for expert users |
| heuristics/pscostdiving/maxdepth | maximal depth level to call primal heuristic <pscostdiving> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/pscostdiving/maxdiveavgquot | maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞] | 0 |
| heuristics/pscostdiving/maxdiveavgquotnosol | maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞] | 0 |
| heuristics/pscostdiving/maxdiveubquot | maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1] | 0.8 |
| heuristics/pscostdiving/maxdiveubquotnosol | maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1] | 0.1 |
| heuristics/pscostdiving/maxreldepth | maximal relative depth to start diving
Range: [0, 1] | 1 |
| heuristics/pscostdiving/minreldepth | minimal relative depth to start diving
Range: [0, 1] | 0 |
| heuristics/pscostdiving/priority | priority of heuristic <pscostdiving>
Range: {-536870912, ..., 536870911} | -1002000 |
heuristics/randrounding
| Option | Description | Default |
| heuristics/randrounding/freq | frequency for calling primal heuristic <randrounding> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 20 |
| heuristics/randrounding/freqofs | frequency offset for calling primal heuristic <randrounding>
Range: {0, ..., 1073741822} | 0 |
| Options for expert users |
| heuristics/randrounding/maxdepth | maximal depth level to call primal heuristic <randrounding> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/randrounding/maxproprounds | limit of rounds for each propagation call
Range: {-1, ..., ∞} | 1 |
| heuristics/randrounding/oncepernode | should the heuristic only be called once per node?
Range: boolean | 0 |
| heuristics/randrounding/priority | priority of heuristic <randrounding>
Range: {-536870912, ..., 536870911} | -200 |
| heuristics/randrounding/propagateonlyroot | should the probing part of the heuristic be applied exclusively at the root node?
Range: boolean | 1 |
| heuristics/randrounding/usesimplerounding | should the heuristic apply the variable lock strategy of simple rounding, if possible?
Range: boolean | 0 |
heuristics/rens
| Option | Description | Default |
| heuristics/rens/bestsollimit | limit on number of improving incumbent solutions in sub-CIP
Range: {-1, ..., ∞} | -1 |
| heuristics/rens/freq | frequency for calling primal heuristic <rens> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 0 |
| heuristics/rens/freqofs | frequency offset for calling primal heuristic <rens>
Range: {0, ..., 1073741822} | 0 |
| heuristics/rens/minfixingrate | minimum percentage of integer variables that have to be fixable
Range: [0, 1] | 0.5 |
| heuristics/rens/nodesofs | number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞} | 500 |
| heuristics/rens/nodesquot | contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1] | 0.1 |
| heuristics/rens/startsol | solution that is used for fixing values ('l'p relaxation, 'n'lp relaxation)
Range: n, l | l |
| Options for expert users |
| heuristics/rens/addallsols | should all subproblem solutions be added to the original SCIP?
Range: boolean | 0 |
| heuristics/rens/binarybounds | should general integers get binary bounds [floor(.),ceil(.)] ?
Range: boolean | 1 |
| heuristics/rens/copycuts | if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean | 1 |
| heuristics/rens/extratime | should the RENS sub-CIP get its own full time limit? This is only for testing and not recommended!
Range: boolean | 0 |
| heuristics/rens/fullscale | should the RENS sub-CIP be solved with cuts, conflicts, strong branching,... This is only for testing and not recommended!
Range: boolean | 0 |
| heuristics/rens/lplimfac | factor by which the limit on the number of LP depends on the node limit
Range: [1, ∞] | 2 |
| heuristics/rens/maxdepth | maximal depth level to call primal heuristic <rens> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/rens/maxnodes | maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞} | 5000 |
| heuristics/rens/minimprove | factor by which RENS should at least improve the incumbent
Range: [0, 1] | 0.01 |
| heuristics/rens/minnodes | minimum number of nodes required to start the subproblem
Range: {0, ..., ∞} | 50 |
| heuristics/rens/priority | priority of heuristic <rens>
Range: {-536870912, ..., 536870911} | -1100000 |
| heuristics/rens/uselprows | should subproblem be created out of the rows in the LP rows?
Range: boolean | 0 |
| heuristics/rens/useuct | should uct node selection be used at the beginning of the search?
Range: boolean | 0 |
heuristics/reoptsols
| Option | Description | Default |
| heuristics/reoptsols/freq | frequency for calling primal heuristic <reoptsols> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 0 |
| heuristics/reoptsols/freqofs | frequency offset for calling primal heuristic <reoptsols>
Range: {0, ..., 1073741822} | 0 |
| Options for expert users |
| heuristics/reoptsols/maxdepth | maximal depth level to call primal heuristic <reoptsols> (-1: no limit)
Range: {-1, ..., 1073741822} | 0 |
| heuristics/reoptsols/maxruns | check solutions of the last k runs. (-1: all)
Range: {-1, ..., ∞} | -1 |
| heuristics/reoptsols/maxsols | maximal number solutions which should be checked. (-1: all)
Range: {-1, ..., ∞} | 1000 |
| heuristics/reoptsols/priority | priority of heuristic <reoptsols>
Range: {-536870912, ..., 536870911} | 40000 |
heuristics/repair
| Option | Description | Default |
| heuristics/repair/filename | file name of a solution to be used as infeasible starting point, [-] if not available
Range: string | - |
| heuristics/repair/freq | frequency for calling primal heuristic <repair> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/repair/freqofs | frequency offset for calling primal heuristic <repair>
Range: {0, ..., 1073741822} | 0 |
| heuristics/repair/minfixingrate | minimum percentage of integer variables that have to be fixed
Range: [0, 1] | 0.3 |
| heuristics/repair/nodesofs | number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞} | 500 |
| heuristics/repair/nodesquot | contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1] | 0.1 |
| heuristics/repair/roundit | True : fractional variables which are not fractional in the given solution are rounded, FALSE : solving process of this heuristic is stopped.
Range: boolean | 1 |
| heuristics/repair/useobjfactor | should a scaled objective function for original variables be used in repair subproblem?
Range: boolean | 0 |
| heuristics/repair/useslackvars | should slack variables be used in repair subproblem?
Range: boolean | 0 |
| heuristics/repair/usevarfix | should variable fixings be used in repair subproblem?
Range: boolean | 1 |
| Options for expert users |
| heuristics/repair/alpha | factor for the potential of var fixings
Range: [0, 100] | 2 |
| heuristics/repair/maxdepth | maximal depth level to call primal heuristic <repair> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/repair/maxnodes | maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞} | 5000 |
| heuristics/repair/minnodes | minimum number of nodes required to start the subproblem
Range: {0, ..., ∞} | 50 |
| heuristics/repair/priority | priority of heuristic <repair>
Range: {-536870912, ..., 536870911} | -20 |
heuristics/rins
| Option | Description | Default |
| heuristics/rins/freq | frequency for calling primal heuristic <rins> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 25 |
| heuristics/rins/freqofs | frequency offset for calling primal heuristic <rins>
Range: {0, ..., 1073741822} | 0 |
| heuristics/rins/minfixingrate | minimum percentage of integer variables that have to be fixed
Range: [0, 1] | 0.3 |
| heuristics/rins/nodesofs | number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞} | 500 |
| heuristics/rins/nodesquot | contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1] | 0.3 |
| Options for expert users |
| heuristics/rins/copycuts | if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean | 1 |
| heuristics/rins/lplimfac | factor by which the limit on the number of LP depends on the node limit
Range: [1, ∞] | 2 |
| heuristics/rins/maxdepth | maximal depth level to call primal heuristic <rins> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/rins/maxnodes | maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞} | 5000 |
| heuristics/rins/minimprove | factor by which rins should at least improve the incumbent
Range: [0, 1] | 0.01 |
| heuristics/rins/minnodes | minimum number of nodes required to start the subproblem
Range: {0, ..., ∞} | 50 |
| heuristics/rins/nwaitingnodes | number of nodes without incumbent change that heuristic should wait
Range: {0, ..., ∞} | 200 |
| heuristics/rins/priority | priority of heuristic <rins>
Range: {-536870912, ..., 536870911} | -1101000 |
| heuristics/rins/uselprows | should subproblem be created out of the rows in the LP rows?
Range: boolean | 0 |
| heuristics/rins/useuct | should uct node selection be used at the beginning of the search?
Range: boolean | 0 |
heuristics/rootsoldiving
| Option | Description | Default |
| heuristics/rootsoldiving/freq | frequency for calling primal heuristic <rootsoldiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 20 |
| heuristics/rootsoldiving/freqofs | frequency offset for calling primal heuristic <rootsoldiving>
Range: {0, ..., 1073741822} | 5 |
| heuristics/rootsoldiving/maxlpiterofs | additional number of allowed LP iterations
Range: {0, ..., ∞} | 1000 |
| heuristics/rootsoldiving/maxlpiterquot | maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞] | 0.01 |
| Options for expert users |
| heuristics/rootsoldiving/alpha | soft rounding factor to fade out objective coefficients
Range: [0, 1] | 0.9 |
| heuristics/rootsoldiving/depthfac | maximal diving depth: number of binary/integer variables times depthfac
Range: [0, ∞] | 0.5 |
| heuristics/rootsoldiving/depthfacnosol | maximal diving depth factor if no feasible solution was found yet
Range: [0, ∞] | 2 |
| heuristics/rootsoldiving/maxdepth | maximal depth level to call primal heuristic <rootsoldiving> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/rootsoldiving/maxreldepth | maximal relative depth to start diving
Range: [0, 1] | 1 |
| heuristics/rootsoldiving/maxsols | total number of feasible solutions found up to which heuristic is called (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| heuristics/rootsoldiving/minreldepth | minimal relative depth to start diving
Range: [0, 1] | 0 |
| heuristics/rootsoldiving/priority | priority of heuristic <rootsoldiving>
Range: {-536870912, ..., 536870911} | -1005000 |
heuristics/rounding
| Option | Description | Default |
| heuristics/rounding/freq | frequency for calling primal heuristic <rounding> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 1 |
| heuristics/rounding/freqofs | frequency offset for calling primal heuristic <rounding>
Range: {0, ..., 1073741822} | 0 |
| Options for expert users |
| heuristics/rounding/maxdepth | maximal depth level to call primal heuristic <rounding> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/rounding/oncepernode | should the heuristic only be called once per node?
Range: boolean | 0 |
| heuristics/rounding/priority | priority of heuristic <rounding>
Range: {-536870912, ..., 536870911} | -1000 |
| heuristics/rounding/successfactor | number of calls per found solution that are considered as standard success, a higher factor causes the heuristic to be called more often
Range: {-1, ..., ∞} | 100 |
heuristics/scheduler
| Option | Description | Default |
| heuristics/scheduler/freq | frequency for calling primal heuristic <scheduler> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/scheduler/freqofs | frequency offset for calling primal heuristic <scheduler>
Range: {0, ..., 1073741822} | 0 |
| heuristics/scheduler/nodesofs | offset added to the nodes budget
Range: {0, ..., ∞} | 500 |
| heuristics/scheduler/nodesquot | fraction of nodes compared to the main SCIP for budget computation
Range: [0, 1] | 0.1 |
| heuristics/scheduler/nodesquotmin | lower bound fraction of nodes compared to the main SCIP for budget computation
Range: [0, 1] | 0 |
| heuristics/scheduler/nsolslim | limit on the number of improving solutions in a sub-SCIP call
Range: {-1, ..., ∞} | 3 |
| heuristics/scheduler/seed | initial random seed for bandit algorithms and random decisions by neighborhoods
Range: {0, ..., ∞} | 113 |
| Options for expert users |
| heuristics/scheduler/alpha | parameter to increase the confidence width in UCB
Range: [0, 100] | 0.0016 |
| heuristics/scheduler/banditalgo | the bandit algorithm: (u)pper confidence bounds, (e)xp.3, epsilon (g)reedy, exp.3-(i)x
Range: u, e, g, i | i |
| heuristics/scheduler/beta | reward offset between 0 and 1 at every observation for Exp.3
Range: [0, 1] | 0 |
| heuristics/scheduler/conflictrewardweight | weight by how much number of conflicts found by diving is rewarded in reward function
Range: [0, 1] | 0.2 |
| heuristics/scheduler/copycuts | should cutting planes be copied to the sub-SCIP?
Range: boolean | 0 |
| heuristics/scheduler/defaultroot | should the default priorities be used at the root node?
Range: boolean | 1 |
| heuristics/scheduler/effortrewardweight | weight by how much effort is rewarded in reward function
Range: [0, 1] | 0.2 |
| heuristics/scheduler/eps | increase exploration in epsilon-greedy bandit algorithm
Range: [0, 1] | 0.468584 |
| heuristics/scheduler/epsgreedy_usemod | TRUE if modified version of the epsilon-greedy bandit algorithm should be used
Range: boolean | 1 |
| heuristics/scheduler/fixtol | tolerance by which the fixing rate may be missed without generic fixing
Range: [0, 1] | 0.1 |
| heuristics/scheduler/gamma | weight between uniform (gamma ~ 1) and weight driven (gamma ~ 0) probability distribution for exp3
Range: [0, 1] | 0.0704146 |
| heuristics/scheduler/heurtimelimit | time limit for a single heuristic run
Range: [0, ∞] | 60 |
| heuristics/scheduler/initdivingnodelimit | initial node limit for diving heuristics
Range: {0, ..., ∞} | 500 |
| heuristics/scheduler/initduringroot | should the heuristic be executed multiple times during the root node?
Range: boolean | 0 |
| heuristics/scheduler/initlnsnodelimit | initial node limit for LNS heuristics
Range: {0, ..., ∞} | 50 |
| heuristics/scheduler/maxcallssamesol | number of allowed executions of the heuristic on the same incumbent solution (-1: no limit, 0: number of active neighborhoods)
Range: {-1, ..., 100} | -1 |
| heuristics/scheduler/maxdepth | maximal depth level to call primal heuristic <scheduler> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/scheduler/maxnodes | maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞} | 500 |
| heuristics/scheduler/minnodes | minimum number of nodes required to start a sub-SCIP
Range: {0, ..., ∞} | 50 |
| heuristics/scheduler/nselections | number of heuristics picked by the scheduler in one call (-1: number of controlled heuristics, 0: until new incumbent is found)
Range: {-1, ..., 100} | 5 |
| heuristics/scheduler/priority | priority of heuristic <scheduler>
Range: {-536870912, ..., 536870911} | -30000 |
| heuristics/scheduler/qualrewardweight | weight by how much quality of a new incumbent is rewarded in reward function
Range: [0, 1] | 0.3 |
| heuristics/scheduler/resetweights | should the bandit algorithms be reset when a new problem is read?
Range: boolean | 0 |
| heuristics/scheduler/solrewardweight | weight by how much finding a new incumbent is rewarded in reward function
Range: [0, 1] | 0.3 |
| heuristics/scheduler/subsciprandseeds | should random seeds of sub-SCIPs be altered to increase diversification?
Range: boolean | 0 |
| heuristics/scheduler/targetnodefactor | factor by which target node number is eventually increased
Range: [1, 100000] | 1.05 |
| heuristics/scheduler/unfixtol | tolerance by which the fixing rate may be exceeded without generic unfixing
Range: [0, 1] | 0.1 |
| heuristics/scheduler/usedistances | distances from fixed variables be used for variable prioritization
Range: boolean | 1 |
| heuristics/scheduler/uselocalredcost | should local reduced costs be used for generic (un)fixing?
Range: boolean | 0 |
| heuristics/scheduler/usepscost | should pseudo cost scores be used for variable priorization?
Range: boolean | 1 |
| heuristics/scheduler/useredcost | should reduced cost scores be used for variable prioritization?
Range: boolean | 1 |
| heuristics/scheduler/usesubscipheurs | should the heuristic activate other sub-SCIP heuristics during its search?
Range: boolean | 0 |
| heuristics/scheduler/waitingnodes | number of nodes since last incumbent solution that the heuristic should wait
Range: {0, ..., ∞} | 0 |
heuristics/scheduler/crossover
| Option | Description | Default |
| Options for expert users |
| heuristics/scheduler/crossover/active | is this neighborhood active?
Range: boolean | 1 |
| heuristics/scheduler/crossover/maxfixingrate | maximum fixing rate for this neighborhood
Range: [0, 1] | 0.9 |
| heuristics/scheduler/crossover/minfixingrate | minimum fixing rate for this neighborhood
Range: [0, 1] | 0.3 |
| heuristics/scheduler/crossover/nsols | the number of solutions that crossover should combine
Range: {2, ..., 10} | 2 |
| heuristics/scheduler/crossover/priority | positive call priority to initialize bandit algorithms
Range: [0.01, 1] | 1 |
heuristics/scheduler/dins
| Option | Description | Default |
| Options for expert users |
| heuristics/scheduler/dins/active | is this neighborhood active?
Range: boolean | 1 |
| heuristics/scheduler/dins/maxfixingrate | maximum fixing rate for this neighborhood
Range: [0, 1] | 0.9 |
| heuristics/scheduler/dins/minfixingrate | minimum fixing rate for this neighborhood
Range: [0, 1] | 0.3 |
| heuristics/scheduler/dins/npoolsols | number of pool solutions where binary solution values must agree
Range: {1, ..., 100} | 5 |
| heuristics/scheduler/dins/priority | positive call priority to initialize bandit algorithms
Range: [0.01, 1] | 1 |
heuristics/scheduler/localbranching
| Option | Description | Default |
| Options for expert users |
| heuristics/scheduler/localbranching/active | is this neighborhood active?
Range: boolean | 1 |
| heuristics/scheduler/localbranching/maxfixingrate | maximum fixing rate for this neighborhood
Range: [0, 1] | 0.9 |
| heuristics/scheduler/localbranching/minfixingrate | minimum fixing rate for this neighborhood
Range: [0, 1] | 0.3 |
| heuristics/scheduler/localbranching/priority | positive call priority to initialize bandit algorithms
Range: [0.01, 1] | 1 |
heuristics/scheduler/mutation
| Option | Description | Default |
| Options for expert users |
| heuristics/scheduler/mutation/active | is this neighborhood active?
Range: boolean | 1 |
| heuristics/scheduler/mutation/maxfixingrate | maximum fixing rate for this neighborhood
Range: [0, 1] | 0.9 |
| heuristics/scheduler/mutation/minfixingrate | minimum fixing rate for this neighborhood
Range: [0, 1] | 0.3 |
| heuristics/scheduler/mutation/priority | positive call priority to initialize bandit algorithms
Range: [0.01, 1] | 1 |
heuristics/scheduler/proximity
| Option | Description | Default |
| Options for expert users |
| heuristics/scheduler/proximity/active | is this neighborhood active?
Range: boolean | 1 |
| heuristics/scheduler/proximity/maxfixingrate | maximum fixing rate for this neighborhood
Range: [0, 1] | 0.9 |
| heuristics/scheduler/proximity/minfixingrate | minimum fixing rate for this neighborhood
Range: [0, 1] | 0.3 |
| heuristics/scheduler/proximity/priority | positive call priority to initialize bandit algorithms
Range: [0.01, 1] | 1 |
heuristics/scheduler/rens
| Option | Description | Default |
| Options for expert users |
| heuristics/scheduler/rens/active | is this neighborhood active?
Range: boolean | 1 |
| heuristics/scheduler/rens/maxfixingrate | maximum fixing rate for this neighborhood
Range: [0, 1] | 0.9 |
| heuristics/scheduler/rens/minfixingrate | minimum fixing rate for this neighborhood
Range: [0, 1] | 0.3 |
| heuristics/scheduler/rens/priority | positive call priority to initialize bandit algorithms
Range: [0.01, 1] | 1 |
heuristics/scheduler/rins
| Option | Description | Default |
| Options for expert users |
| heuristics/scheduler/rins/active | is this neighborhood active?
Range: boolean | 1 |
| heuristics/scheduler/rins/maxfixingrate | maximum fixing rate for this neighborhood
Range: [0, 1] | 0.9 |
| heuristics/scheduler/rins/minfixingrate | minimum fixing rate for this neighborhood
Range: [0, 1] | 0.3 |
| heuristics/scheduler/rins/priority | positive call priority to initialize bandit algorithms
Range: [0.01, 1] | 1 |
heuristics/scheduler/trustregion
| Option | Description | Default |
| heuristics/scheduler/trustregion/violpenalty | the penalty for each change in the binary variables from the candidate solution
Range: [0, ∞] | 100 |
| Options for expert users |
| heuristics/scheduler/trustregion/active | is this neighborhood active?
Range: boolean | 0 |
| heuristics/scheduler/trustregion/maxfixingrate | maximum fixing rate for this neighborhood
Range: [0, 1] | 0.9 |
| heuristics/scheduler/trustregion/minfixingrate | minimum fixing rate for this neighborhood
Range: [0, 1] | 0.3 |
| heuristics/scheduler/trustregion/priority | positive call priority to initialize bandit algorithms
Range: [0.01, 1] | 1 |
heuristics/scheduler/zeroobjective
| Option | Description | Default |
| Options for expert users |
| heuristics/scheduler/zeroobjective/active | is this neighborhood active?
Range: boolean | 1 |
| heuristics/scheduler/zeroobjective/maxfixingrate | maximum fixing rate for this neighborhood
Range: [0, 1] | 0.9 |
| heuristics/scheduler/zeroobjective/minfixingrate | minimum fixing rate for this neighborhood
Range: [0, 1] | 0.3 |
| heuristics/scheduler/zeroobjective/priority | positive call priority to initialize bandit algorithms
Range: [0.01, 1] | 1 |
heuristics/shiftandpropagate
| Option | Description | Default |
| heuristics/shiftandpropagate/freq | frequency for calling primal heuristic <shiftandpropagate> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 0 |
| heuristics/shiftandpropagate/freqofs | frequency offset for calling primal heuristic <shiftandpropagate>
Range: {0, ..., 1073741822} | 0 |
| Options for expert users |
| heuristics/shiftandpropagate/binlocksfirst | should binary variables with no locks be preferred in the ordering?
Range: boolean | 0 |
| heuristics/shiftandpropagate/collectstats | should variable statistics be collected during probing?
Range: boolean | 1 |
| heuristics/shiftandpropagate/cutoffbreaker | The number of cutoffs before heuristic stops
Range: {-1, ..., 1000000} | 15 |
| heuristics/shiftandpropagate/fixbinlocks | should binary variables with no locks in one direction be fixed to that direction?
Range: boolean | 1 |
| heuristics/shiftandpropagate/impliscontinuous | should implicit integer variables be treated as continuous variables?
Range: boolean | 1 |
| heuristics/shiftandpropagate/maxcutoffquot | maximum percentage of allowed cutoffs before stopping the heuristic
Range: [0, 2] | 0 |
| heuristics/shiftandpropagate/maxdepth | maximal depth level to call primal heuristic <shiftandpropagate> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/shiftandpropagate/minfixingratelp | minimum fixing rate over all variables (including continuous) to solve LP
Range: [0, 1] | 0 |
| heuristics/shiftandpropagate/normalize | should coefficients and left/right hand sides be normalized by max row coeff?
Range: boolean | 1 |
| heuristics/shiftandpropagate/nozerofixing | should variables with a zero shifting value be delayed instead of being fixed?
Range: boolean | 0 |
| heuristics/shiftandpropagate/nproprounds | The number of propagation rounds used for each propagation
Range: {-1, ..., 1000} | 10 |
| heuristics/shiftandpropagate/onlywithoutsol | Should heuristic only be executed if no primal solution was found, yet?
Range: boolean | 1 |
| heuristics/shiftandpropagate/preferbinaries | Should binary variables be shifted first?
Range: boolean | 1 |
| heuristics/shiftandpropagate/priority | priority of heuristic <shiftandpropagate>
Range: {-536870912, ..., 536870911} | 1000 |
| heuristics/shiftandpropagate/probing | Should domains be reduced by probing?
Range: boolean | 1 |
| heuristics/shiftandpropagate/relax | Should continuous variables be relaxed?
Range: boolean | 1 |
| heuristics/shiftandpropagate/selectbest | should the heuristic choose the best candidate in every round? (set to FALSE for static order)?
Range: boolean | 0 |
| heuristics/shiftandpropagate/sortkey | the key for variable sorting: (n)orms down, norms (u)p, (v)iolations down, viola(t)ions up, or (r)andom
Range: n, r, t, u, v | v |
| heuristics/shiftandpropagate/sortvars | Should variables be sorted for the heuristic?
Range: boolean | 1 |
| heuristics/shiftandpropagate/stopafterfeasible | Should the heuristic stop calculating optimal shift values when no more rows are violated?
Range: boolean | 1 |
| heuristics/shiftandpropagate/updateweights | should row weight be increased every time the row is violated?
Range: boolean | 0 |
heuristics/shifting
| Option | Description | Default |
| heuristics/shifting/freq | frequency for calling primal heuristic <shifting> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 10 |
| heuristics/shifting/freqofs | frequency offset for calling primal heuristic <shifting>
Range: {0, ..., 1073741822} | 0 |
| Options for expert users |
| heuristics/shifting/maxdepth | maximal depth level to call primal heuristic <shifting> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/shifting/priority | priority of heuristic <shifting>
Range: {-536870912, ..., 536870911} | -5000 |
heuristics/simplerounding
| Option | Description | Default |
| heuristics/simplerounding/freq | frequency for calling primal heuristic <simplerounding> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 1 |
| heuristics/simplerounding/freqofs | frequency offset for calling primal heuristic <simplerounding>
Range: {0, ..., 1073741822} | 0 |
| Options for expert users |
| heuristics/simplerounding/maxdepth | maximal depth level to call primal heuristic <simplerounding> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/simplerounding/oncepernode | should the heuristic only be called once per node?
Range: boolean | 0 |
| heuristics/simplerounding/priority | priority of heuristic <simplerounding>
Range: {-536870912, ..., 536870911} | -30 |
heuristics/subnlp
| Option | Description | Default |
| heuristics/subnlp/expectinfeas | percentage of NLP solves with infeasible status required to tell NLP solver to expect an infeasible NLP
Range: [0, 1] | 0 |
| heuristics/subnlp/feastolfactor | factor on SCIP feasibility tolerance for NLP solves if resolving when NLP solution not feasible in CIP
Range: [0, 1] | 0.1 |
| heuristics/subnlp/forbidfixings | whether to add constraints that forbid specific fixings that turned out to be infeasible
Range: boolean | 0 |
| heuristics/subnlp/freq | frequency for calling primal heuristic <subnlp> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 1 |
| heuristics/subnlp/freqofs | frequency offset for calling primal heuristic <subnlp>
Range: {0, ..., 1073741822} | 0 |
| heuristics/subnlp/iterinit | number of iterations used for initial NLP solves
Range: {0, ..., ∞} | 300 |
| heuristics/subnlp/itermin | minimal number of iterations for NLP solves
Range: {0, ..., ∞} | 20 |
| heuristics/subnlp/maxpresolverounds | limit on number of presolve rounds in sub-SCIP (-1 for unlimited, 0 for no presolve)
Range: {-1, ..., ∞} | -1 |
| heuristics/subnlp/ninitsolves | number of successful NLP solves until switching to iterlimit guess and using success rate
Range: {0, ..., ∞} | 2 |
| heuristics/subnlp/nlpverblevel | verbosity level of NLP solver
Range: {0, ..., 65535} | 0 |
| heuristics/subnlp/nodesfactor | factor on number of nodes in SCIP (plus nodesoffset) to compute itercontingent (higher value runs heuristics more frequently)
Range: [0, ∞] | 0.3 |
| heuristics/subnlp/nodesoffset | number of nodes added to the current number of nodes when computing itercontingent (higher value runs heuristic more often in early search)
Range: {0, ..., ∞} | 1600 |
| heuristics/subnlp/presolveemphasis | presolve emphasis in sub-SCIP (0: default, 1: aggressive, 2: fast, 3: off)
Range: {0, ..., 3} | 2 |
| heuristics/subnlp/setcutoff | whether to set cutoff in sub-SCIP to current primal bound
Range: boolean | 1 |
| heuristics/subnlp/successrateexp | exponent for power of success rate to be multiplied with itercontingent (lower value decreases impact of success rate)
Range: [0, ∞] | 1 |
| Options for expert users |
| heuristics/subnlp/keepcopy | whether to keep SCIP copy or to create new copy each time heuristic is applied
Range: boolean | 1 |
| heuristics/subnlp/maxdepth | maximal depth level to call primal heuristic <subnlp> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/subnlp/opttol | absolute optimality tolerance to use for NLP solves
Range: [0, 1] | 1e-07 |
| heuristics/subnlp/priority | priority of heuristic <subnlp>
Range: {-536870912, ..., 536870911} | -2000010 |
heuristics/trivial
| Option | Description | Default |
| heuristics/trivial/freq | frequency for calling primal heuristic <trivial> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 0 |
| heuristics/trivial/freqofs | frequency offset for calling primal heuristic <trivial>
Range: {0, ..., 1073741822} | 0 |
| Options for expert users |
| heuristics/trivial/maxdepth | maximal depth level to call primal heuristic <trivial> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/trivial/priority | priority of heuristic <trivial>
Range: {-536870912, ..., 536870911} | 10000 |
heuristics/trivialnegation
| Option | Description | Default |
| heuristics/trivialnegation/freq | frequency for calling primal heuristic <trivialnegation> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 0 |
| heuristics/trivialnegation/freqofs | frequency offset for calling primal heuristic <trivialnegation>
Range: {0, ..., 1073741822} | 0 |
| Options for expert users |
| heuristics/trivialnegation/maxdepth | maximal depth level to call primal heuristic <trivialnegation> (-1: no limit)
Range: {-1, ..., 1073741822} | 0 |
| heuristics/trivialnegation/priority | priority of heuristic <trivialnegation>
Range: {-536870912, ..., 536870911} | 39990 |
heuristics/trustregion
| Option | Description | Default |
| heuristics/trustregion/bestsollimit | limit on number of improving incumbent solutions in sub-CIP
Range: {-1, ..., ∞} | 3 |
| heuristics/trustregion/freq | frequency for calling primal heuristic <trustregion> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/trustregion/freqofs | frequency offset for calling primal heuristic <trustregion>
Range: {0, ..., 1073741822} | 0 |
| heuristics/trustregion/minbinvars | the number of binary variables necessary to run the heuristic
Range: {1, ..., ∞} | 10 |
| heuristics/trustregion/nodesofs | number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞} | 1000 |
| heuristics/trustregion/nodesquot | contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1] | 0.05 |
| heuristics/trustregion/objminimprove | the minimum absolute improvement in the objective function value
Range: [0, ∞] | 0.01 |
| heuristics/trustregion/violpenalty | the penalty for each change in the binary variables from the candidate solution
Range: [0, ∞] | 100 |
| Options for expert users |
| heuristics/trustregion/copycuts | if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean | 1 |
| heuristics/trustregion/lplimfac | factor by which the limit on the number of LP depends on the node limit
Range: [1, ∞] | 1.5 |
| heuristics/trustregion/maxdepth | maximal depth level to call primal heuristic <trustregion> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/trustregion/maxnodes | maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞} | 10000 |
| heuristics/trustregion/minnodes | minimum number of nodes required to start the subproblem
Range: {0, ..., ∞} | 100 |
| heuristics/trustregion/nwaitingnodes | number of nodes without incumbent change that heuristic should wait
Range: {0, ..., ∞} | 1 |
| heuristics/trustregion/priority | priority of heuristic <trustregion>
Range: {-536870912, ..., 536870911} | -1102010 |
| heuristics/trustregion/uselprows | should subproblem be created out of the rows in the LP rows?
Range: boolean | 0 |
heuristics/trysol
| Option | Description | Default |
| heuristics/trysol/freq | frequency for calling primal heuristic <trysol> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 1 |
| heuristics/trysol/freqofs | frequency offset for calling primal heuristic <trysol>
Range: {0, ..., 1073741822} | 0 |
| Options for expert users |
| heuristics/trysol/maxdepth | maximal depth level to call primal heuristic <trysol> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/trysol/priority | priority of heuristic <trysol>
Range: {-536870912, ..., 536870911} | -3000010 |
heuristics/twoopt
| Option | Description | Default |
| heuristics/twoopt/freq | frequency for calling primal heuristic <twoopt> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/twoopt/freqofs | frequency offset for calling primal heuristic <twoopt>
Range: {0, ..., 1073741822} | 0 |
| Options for expert users |
| heuristics/twoopt/intopt | Should Integer-2-Optimization be applied or not?
Range: boolean | 0 |
| heuristics/twoopt/matchingrate | parameter to determine the percentage of rows two variables have to share before they are considered equal
Range: [0, 1] | 0.5 |
| heuristics/twoopt/maxdepth | maximal depth level to call primal heuristic <twoopt> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/twoopt/maxnslaves | maximum number of slaves for one master variable
Range: {-1, ..., 1000000} | 199 |
| heuristics/twoopt/priority | priority of heuristic <twoopt>
Range: {-536870912, ..., 536870911} | -20100 |
| heuristics/twoopt/waitingnodes | user parameter to determine number of nodes to wait after last best solution before calling heuristic
Range: {0, ..., 10000} | 0 |
heuristics/undercover
| Option | Description | Default |
| heuristics/undercover/fixingalts | prioritized sequence of fixing values used ('l'p relaxation, 'n'lp relaxation, 'i'ncumbent solution)
Range: string | li |
| heuristics/undercover/freq | frequency for calling primal heuristic <undercover> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 0 |
| heuristics/undercover/freqofs | frequency offset for calling primal heuristic <undercover>
Range: {0, ..., 1073741822} | 0 |
| heuristics/undercover/nodesofs | number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞} | 500 |
| heuristics/undercover/nodesquot | contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1] | 0.1 |
| heuristics/undercover/onlyconvexify | should we only fix variables in order to obtain a convex problem?
Range: boolean | 0 |
| heuristics/undercover/postnlp | should the NLP heuristic be called to polish a feasible solution?
Range: boolean | 1 |
| Options for expert users |
| heuristics/undercover/beforecuts | should the heuristic be called at root node before cut separation?
Range: boolean | 1 |
| heuristics/undercover/conflictweight | weight for conflict score in fixing order
Range: real | 1000 |
| heuristics/undercover/copycuts | should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean | 1 |
| heuristics/undercover/coverand | should and constraints be covered (or just copied)?
Range: boolean | 1 |
| heuristics/undercover/coverbd | should bounddisjunction constraints be covered (or just copied)?
Range: boolean | 0 |
| heuristics/undercover/coverind | should indicator constraints be covered (or just copied)?
Range: boolean | 0 |
| heuristics/undercover/coveringobj | objective function of the covering problem (influenced nonlinear 'c'onstraints/'t'erms, 'd'omain size, 'l'ocks, 'm'in of up/down locks, 'u'nit penalties)
Range: c, d, l, m, t, u | u |
| heuristics/undercover/covernl | should nonlinear constraints be covered (or just copied)?
Range: boolean | 1 |
| heuristics/undercover/cutoffweight | weight for cutoff score in fixing order
Range: [0, ∞] | 1 |
| heuristics/undercover/fixingorder | order in which variables should be fixed (increasing 'C'onflict score, decreasing 'c'onflict score, increasing 'V'ariable index, decreasing 'v'ariable index
Range: C, c, V, v | v |
| heuristics/undercover/fixintfirst | should integer variables in the cover be fixed first?
Range: boolean | 0 |
| heuristics/undercover/inferenceweight | weight for inference score in fixing order
Range: real | 1 |
| heuristics/undercover/locksrounding | shall LP values for integer vars be rounded according to locks?
Range: boolean | 1 |
| heuristics/undercover/maxbacktracks | maximum number of backtracks in fix-and-propagate
Range: {0, ..., ∞} | 6 |
| heuristics/undercover/maxcoversizeconss | maximum coversize (as ratio to the percentage of non-affected constraints)
Range: [0, ∞] | ∞ |
| heuristics/undercover/maxcoversizevars | maximum coversize (as fraction of total number of variables)
Range: [0, 1] | 1 |
| heuristics/undercover/maxdepth | maximal depth level to call primal heuristic <undercover> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/undercover/maxnodes | maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞} | 500 |
| heuristics/undercover/maxrecovers | maximum number of recoverings
Range: {0, ..., ∞} | 0 |
| heuristics/undercover/maxreorders | maximum number of reorderings of the fixing order
Range: {0, ..., ∞} | 1 |
| heuristics/undercover/mincoveredabs | minimum number of nonlinear constraints in the original problem
Range: {0, ..., ∞} | 5 |
| heuristics/undercover/mincoveredrel | minimum percentage of nonlinear constraints in the original problem
Range: [0, 1] | 0.15 |
| heuristics/undercover/minimprove | factor by which the heuristic should at least improve the incumbent
Range: [-1, 1] | 0 |
| heuristics/undercover/minnodes | minimum number of nodes required to start the subproblem
Range: {0, ..., ∞} | 500 |
| heuristics/undercover/priority | priority of heuristic <undercover>
Range: {-536870912, ..., 536870911} | -1110000 |
| heuristics/undercover/recoverdiv | fraction of covering variables in the last cover which need to change their value when recovering
Range: [0, 1] | 0.9 |
| heuristics/undercover/reusecover | shall the cover be reused if a conflict was added after an infeasible subproblem?
Range: boolean | 0 |
heuristics/vbounds
| Option | Description | Default |
| heuristics/vbounds/freq | frequency for calling primal heuristic <vbounds> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 0 |
| heuristics/vbounds/freqofs | frequency offset for calling primal heuristic <vbounds>
Range: {0, ..., 1073741822} | 0 |
| heuristics/vbounds/minintfixingrate | minimum percentage of integer variables that have to be fixed
Range: [0, 1] | 0.65 |
| heuristics/vbounds/minmipfixingrate | minimum percentage of variables that have to be fixed within sub-SCIP (integer and continuous)
Range: [0, 1] | 0.65 |
| heuristics/vbounds/nodesofs | number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞} | 500 |
| heuristics/vbounds/nodesquot | contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1] | 0.1 |
| Options for expert users |
| heuristics/vbounds/copycuts | should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean | 1 |
| heuristics/vbounds/feasvariant | which variants of the vbounds heuristic that try to stay feasible should be called? (0: off, 1: w/o looking at obj, 2: only fix to best bound, 4: only fix to worst bound
Range: {0, ..., 7} | 6 |
| heuristics/vbounds/maxbacktracks | maximum number of backtracks during the fixing process
Range: {-1, ..., 536870911} | 10 |
| heuristics/vbounds/maxdepth | maximal depth level to call primal heuristic <vbounds> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/vbounds/maxnodes | maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞} | 5000 |
| heuristics/vbounds/maxproprounds | maximum number of propagation rounds during probing (-1 infinity)
Range: {-1, ..., 536870911} | 2 |
| heuristics/vbounds/minimprove | factor by which vbounds heuristic should at least improve the incumbent
Range: [0, 1] | 0.01 |
| heuristics/vbounds/minnodes | minimum number of nodes required to start the subproblem
Range: {0, ..., ∞} | 500 |
| heuristics/vbounds/priority | priority of heuristic <vbounds>
Range: {-536870912, ..., 536870911} | 2500 |
| heuristics/vbounds/tightenvariant | which tightening variants of the vbounds heuristic should be called? (0: off, 1: w/o looking at obj, 2: only fix to best bound, 4: only fix to worst bound
Range: {0, ..., 7} | 7 |
| heuristics/vbounds/uselockfixings | should more variables be fixed based on variable locks if the fixing rate was not reached?
Range: boolean | 0 |
heuristics/veclendiving
| Option | Description | Default |
| heuristics/veclendiving/backtrack | use one level of backtracking if infeasibility is encountered?
Range: boolean | 1 |
| heuristics/veclendiving/freq | frequency for calling primal heuristic <veclendiving> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 10 |
| heuristics/veclendiving/freqofs | frequency offset for calling primal heuristic <veclendiving>
Range: {0, ..., 1073741822} | 4 |
| heuristics/veclendiving/lpresolvedomchgquot | percentage of immediate domain changes during probing to trigger LP resolve
Range: [0, ∞] | 0.15 |
| heuristics/veclendiving/lpsolvefreq | LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
Range: {0, ..., ∞} | 0 |
| heuristics/veclendiving/maxlpiterofs | additional number of allowed LP iterations
Range: {0, ..., ∞} | 1000 |
| heuristics/veclendiving/maxlpiterquot | maximal fraction of diving LP iterations compared to node LP iterations
Range: [0, ∞] | 0.05 |
| heuristics/veclendiving/onlylpbranchcands | should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection?
Range: boolean | 0 |
| Options for expert users |
| heuristics/veclendiving/maxdepth | maximal depth level to call primal heuristic <veclendiving> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/veclendiving/maxdiveavgquot | maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, ∞] | 0 |
| heuristics/veclendiving/maxdiveavgquotnosol | maximal AVGQUOT when no solution was found yet (0.0: no limit)
Range: [0, ∞] | 0 |
| heuristics/veclendiving/maxdiveubquot | maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)
Range: [0, 1] | 0.8 |
| heuristics/veclendiving/maxdiveubquotnosol | maximal UBQUOT when no solution was found yet (0.0: no limit)
Range: [0, 1] | 0.1 |
| heuristics/veclendiving/maxreldepth | maximal relative depth to start diving
Range: [0, 1] | 1 |
| heuristics/veclendiving/minreldepth | minimal relative depth to start diving
Range: [0, 1] | 0 |
| heuristics/veclendiving/priority | priority of heuristic <veclendiving>
Range: {-536870912, ..., 536870911} | -1003100 |
heuristics/zeroobj
| Option | Description | Default |
| heuristics/zeroobj/freq | frequency for calling primal heuristic <zeroobj> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/zeroobj/freqofs | frequency offset for calling primal heuristic <zeroobj>
Range: {0, ..., 1073741822} | 0 |
| heuristics/zeroobj/nodesofs | number of nodes added to the contingent of the total nodes
Range: {0, ..., ∞} | 100 |
| heuristics/zeroobj/nodesquot | contingent of sub problem nodes in relation to the number of nodes of the original problem
Range: [0, 1] | 0.1 |
| Options for expert users |
| heuristics/zeroobj/addallsols | should all subproblem solutions be added to the original SCIP?
Range: boolean | 0 |
| heuristics/zeroobj/maxdepth | maximal depth level to call primal heuristic <zeroobj> (-1: no limit)
Range: {-1, ..., 1073741822} | 0 |
| heuristics/zeroobj/maxlpiters | maximum number of LP iterations to be performed in the subproblem
Range: {-1, ..., ∞} | 5000 |
| heuristics/zeroobj/maxnodes | maximum number of nodes to regard in the subproblem
Range: {0, ..., ∞} | 1000 |
| heuristics/zeroobj/minimprove | factor by which zeroobj should at least improve the incumbent
Range: [0, 1] | 0.01 |
| heuristics/zeroobj/minnodes | minimum number of nodes required to start the subproblem
Range: {0, ..., ∞} | 100 |
| heuristics/zeroobj/onlywithoutsol | should heuristic only be executed if no primal solution was found, yet?
Range: boolean | 1 |
| heuristics/zeroobj/priority | priority of heuristic <zeroobj>
Range: {-536870912, ..., 536870911} | 100 |
| heuristics/zeroobj/useuct | should uct node selection be used at the beginning of the search?
Range: boolean | 0 |
heuristics/zirounding
| Option | Description | Default |
| heuristics/zirounding/freq | frequency for calling primal heuristic <zirounding> (-1: never, 0: only at depth freqofs)
Range: {-1, ..., 1073741822} | 1 |
| heuristics/zirounding/freqofs | frequency offset for calling primal heuristic <zirounding>
Range: {0, ..., 1073741822} | 0 |
| Options for expert users |
| heuristics/zirounding/maxdepth | maximal depth level to call primal heuristic <zirounding> (-1: no limit)
Range: {-1, ..., 1073741822} | -1 |
| heuristics/zirounding/maxroundingloops | determines maximum number of rounding loops
Range: {-1, ..., ∞} | 2 |
| heuristics/zirounding/minstopncalls | determines the minimum number of calls before percentage-based deactivation of Zirounding is applied
Range: {1, ..., ∞} | 1000 |
| heuristics/zirounding/priority | priority of heuristic <zirounding>
Range: {-536870912, ..., 536870911} | -500 |
| heuristics/zirounding/stoppercentage | if percentage of found solutions falls below this parameter, Zirounding will be deactivated
Range: [0, 1] | 0.02 |
| heuristics/zirounding/stopziround | flag to determine if Zirounding is deactivated after a certain percentage of unsuccessful calls
Range: boolean | 1 |
history
| Option | Description | Default |
| history/allowmerge | should variable histories be merged from sub-SCIPs whenever possible?
Range: boolean | 0 |
| history/allowtransfer | should variable histories be transferred to initialize SCIP copies?
Range: boolean | 0 |
| history/valuebased | should statistics be collected for variable domain value pairs?
Range: boolean | 0 |
limits
| Option | Description | Default |
| limits/absgap | solving stops, if the absolute gap = |primalbound - dualbound| is below the given value
Range: [0, ∞] | GAMS optca |
| limits/autorestartnodes | if solve exceeds this number of nodes for the first time, an automatic restart is triggered (-1: no automatic restart)
Range: {-1, ..., ∞} | -1 |
| limits/bestsol | solving stops, if the given number of solution improvements were found (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| limits/dual | solving stops, if dual bound is at least as good as given value
Range: real | ∞ |
| limits/gap | solving stops, if the relative gap = |primal - dual|/MIN(|dual|,|primal|) is below the given value, the gap is 'Infinity', if primal and dual bound have opposite signs
Range: [0, ∞] | GAMS optcr |
| limits/maxorigsol | maximal number of solutions candidates to store in the solution storage of the original problem
Range: {0, ..., ∞} | 10 |
| limits/maxsol | maximal number of solutions to store in the solution storage
Range: {1, ..., ∞} | 100 |
| limits/memory | maximal memory usage in MB; reported memory usage is lower than real memory usage!
Range: [0, 8.79609e+12] | GAMS workspace |
| limits/nodes | maximal number of nodes to process (-1: no limit)
Range: {-1, ..., ∞} | GAMS nodlim, if > 0, otherwise -1 |
| limits/primal | solving stops, if primal bound is at least as good as given value (alias objectivestop)
Range: real | ∞ |
| limits/restarts | solving stops, if the given number of restarts was triggered (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| limits/softtime | soft time limit which should be applied after first solution was found (-1.0: disabled)
Range: [-1, ∞] | -1 |
| limits/solutions | solving stops, if the given number of solutions were found; this limit is first checked in presolving (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| limits/stallnodes | solving stops, if the given number of nodes was processed since the last improvement of the primal solution value (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| limits/time | maximal time in seconds to run
Range: [0, ∞] | GAMS reslim |
| limits/totalnodes | maximal number of total nodes (incl. restarts) to process (-1: no limit)
Range: {-1, ..., ∞} | -1 |
lp
| Option | Description | Default |
| lp/alwaysgetduals | should the Farkas duals always be collected when an LP is found to be infeasible?
Range: boolean | 0 |
| lp/initalgorithm | LP algorithm for solving initial LP relaxations (automatic 's'implex, 'p'rimal simplex, 'd'ual simplex, 'b'arrier, barrier with 'c'rossover)
Range: s, p, d, b, c | s |
| lp/pricing | LP pricing strategy ('l'pi default, 'a'uto, 'f'ull pricing, 'p'artial, 's'teepest edge pricing, 'q'uickstart steepest edge pricing, 'd'evex pricing)
Range: l, a, f, p, s, q, d | l |
| lp/resolvealgorithm | LP algorithm for resolving LP relaxations if a starting basis exists (automatic 's'implex, 'p'rimal simplex, 'd'ual simplex, 'b'arrier, barrier with 'c'rossover)
Range: s, p, d, b, c | s |
| lp/solvedepth | maximal depth for solving LP at the nodes (-1: no depth limit)
Range: {-1, ..., 1073741822} | -1 |
| lp/solvefreq | frequency for solving LP at the nodes (-1: never; 0: only root LP)
Range: {-1, ..., 1073741822} | 1 |
| lp/solver | LP solver to use (clp, cplex, highs, soplex)
Range: string | cplex, if licensed, otherwise soplex |
| Options for expert users |
| lp/checkdualfeas | should LP solutions be checked for dual feasibility, resolving LP when numerical troubles occur?
Range: boolean | 1 |
| lp/checkfarkas | should infeasibility proofs from the LP be checked?
Range: boolean | 1 |
| lp/checkprimfeas | should LP solutions be checked for primal feasibility, resolving LP when numerical troubles occur?
Range: boolean | 1 |
| lp/checkstability | should LP solver's return status be checked for stability?
Range: boolean | 1 |
| lp/cleanupcols | should new non-basic columns be removed after LP solving?
Range: boolean | 0 |
| lp/cleanupcolsroot | should new non-basic columns be removed after root LP solving?
Range: boolean | 0 |
| lp/cleanuprows | should new basic rows be removed after LP solving?
Range: boolean | 1 |
| lp/cleanuprowsroot | should new basic rows be removed after root LP solving?
Range: boolean | 1 |
| lp/clearinitialprobinglp | should lp state be cleared at the end of probing mode when lp was initially unsolved, e.g., when called right after presolving?
Range: boolean | 1 |
| lp/colagelimit | maximum age a dynamic column can reach before it is deleted from the LP (-1: don't delete columns due to aging)
Range: {-1, ..., ∞} | 10 |
| lp/conditionlimit | maximum condition number of LP basis counted as stable (-1.0: no limit)
Range: [-1, ∞] | -1 |
| lp/disablecutoff | disable the cutoff bound in the LP solver? (0: enabled, 1: disabled, 2: auto)
Range: {0, ..., 2} | 2 |
| lp/fastmip | which FASTMIP setting of LP solver should be used? 0: off, 1: low
Range: {0, ..., 1} | 1 |
| lp/freesolvalbuffers | should the buffers for storing LP solution values during diving be freed at end of diving?
Range: boolean | 0 |
| lp/iterlim | iteration limit for each single LP solve (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| lp/lexdualalgo | should the lexicographic dual algorithm be used?
Range: boolean | 0 |
| lp/lexdualbasic | choose fractional basic variables in lexicographic dual algorithm?
Range: boolean | 0 |
| lp/lexdualmaxrounds | maximum number of rounds in the lexicographic dual algorithm (-1: unbounded)
Range: {-1, ..., ∞} | 2 |
| lp/lexdualrootonly | should the lexicographic dual algorithm be applied only at the root node
Range: boolean | 1 |
| lp/lexdualstalling | turn on the lex dual algorithm only when stalling?
Range: boolean | 1 |
| lp/minmarkowitz | minimal Markowitz threshold to control sparsity/stability in LU factorization
Range: [0.0001, 0.9999] | 0.01 |
| lp/presolving | should presolving of LP solver be used?
Range: boolean | 1 |
| lp/refactorinterval | LP refactorization interval (0: auto)
Range: {0, ..., ∞} | 0 |
| lp/resolveiterfac | factor of average LP iterations that is used as LP iteration limit for LP resolve (-1: unlimited)
Range: [-1, ∞] | -1 |
| lp/resolveitermin | minimum number of iterations that are allowed for LP resolve
Range: {1, ..., ∞} | 1000 |
| lp/resolverestore | should the LP be resolved to restore the state at start of diving (if FALSE we buffer the solution values)?
Range: boolean | 0 |
| lp/rootiterlim | iteration limit for initial root LP solve (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| lp/rowagelimit | maximum age a dynamic row can reach before it is deleted from the LP (-1: don't delete rows due to aging)
Range: {-1, ..., ∞} | 10 |
| lp/rowrepswitch | simplex algorithm shall use row representation of the basis if number of rows divided by number of columns exceeds this value (-1.0 to disable row representation)
Range: [-1, ∞] | 1.2 |
| lp/scaling | LP scaling (0: none, 1: normal, 2: aggressive)
Range: {0, ..., 2} | 1 |
| lp/solutionpolishing | LP solution polishing method (0: disabled, 1: only root, 2: always, 3: auto)
Range: {0, ..., 3} | 3 |
| lp/threads | number of threads used for solving the LP (0: automatic)
Range: {0, ..., 64} | GAMS threads |
memory
| Option | Description | Default |
| memory/savefac | fraction of maximal memory usage resulting in switch to memory saving mode
Range: [0, 1] | 0.8 |
| Options for expert users |
| memory/arraygrowfac | memory growing factor for dynamically allocated arrays
Range: [1, 10] | 1.2 |
| memory/arraygrowinit | initial size of dynamically allocated arrays
Range: {0, ..., ∞} | 4 |
| memory/pathgrowfac | memory growing factor for path array
Range: [1, 10] | 2 |
| memory/pathgrowinit | initial size of path array
Range: {0, ..., ∞} | 256 |
| memory/treegrowfac | memory growing factor for tree array
Range: [1, 10] | 2 |
| memory/treegrowinit | initial size of tree array
Range: {0, ..., ∞} | 65536 |
misc
| Option | Description | Default |
| misc/allowstrongdualreds | should strong dual reductions be allowed in propagation and presolving?
Range: boolean | 1 |
| misc/allowweakdualreds | should weak dual reductions be allowed in propagation and presolving?
Range: boolean | 1 |
| misc/avoidmemout | try to avoid running into memory limit by restricting plugins like heuristics?
Range: boolean | 1 |
| misc/calcintegral | should SCIP calculate the primal dual integral value?
Range: boolean | 1 |
| misc/catchctrlc | should the CTRL-C interrupt be caught by SCIP?
Range: boolean | 1 |
| misc/estimexternmem | should the usage of external memory be estimated?
Range: boolean | 1 |
| misc/finitesolutionstore | should SCIP try to remove infinite fixings from solutions copied to the solution store?
Range: boolean | 0 |
| misc/improvingsols | should only solutions be checked which improve the primal bound
Range: boolean | 0 |
| misc/outputorigsol | should the best solution be transformed to the orignal space and be output in command line run?
Range: boolean | 1 |
| misc/printreason | should the reason be printed if a given start solution is infeasible
Range: boolean | 0 |
| misc/referencevalue | objective value for reference purposes
Range: real | ∞ |
| misc/resetstat | should the statistics be reset if the transformed problem is freed (in case of a Benders' decomposition this parameter should be set to FALSE)
Range: boolean | 1 |
| misc/scaleobj | should the objective function be scaled so that it is always integer?
Range: boolean | 1 |
| misc/showdivingstats | should detailed statistics for diving heuristics be shown?
Range: boolean | 0 |
| misc/transorigsols | should SCIP try to transfer original solutions to the transformed space (after presolving)?
Range: boolean | 1 |
| misc/transsolsorig | should SCIP try to transfer transformed solutions to the original space (after solving)?
Range: boolean | 1 |
| misc/useconstable | should a hashtable be used to map from constraint names to constraints?
Range: boolean | 1 |
| misc/usesmalltables | should smaller hashtables be used? yields better performance for small problems with about 100 variables
Range: boolean | 0 |
| misc/usesymmetry | bitset describing used symmetry handling technique: (0: off; 1: constraint-based (orbitopes and/or symresacks); 2: orbital fixing; 3: orbitopes and orbital fixing; 4: Schreier Sims cuts; 5: Schreier Sims cuts and orbitopes; 6: Schreier Sims cuts and orbital fixing; 7: Schreier Sims cuts, orbitopes, and orbital fixing)
Range: {0, ..., 7} | 7 |
| misc/usevartable | should a hashtable be used to map from variable names to variables?
Range: boolean | 1 |
nlhdlr/bilinear
| Option | Description | Default |
| nlhdlr/bilinear/enabled | should this nonlinear handler be used
Range: boolean | 1 |
| nlhdlr/bilinear/maxsepadepth | maximum depth to apply separation
Range: {0, ..., ∞} | ∞ |
| nlhdlr/bilinear/maxseparounds | maximum number of separation rounds in a local node
Range: {0, ..., ∞} | 1 |
| nlhdlr/bilinear/maxseparoundsroot | maximum number of separation rounds in the root node
Range: {0, ..., ∞} | 10 |
| nlhdlr/bilinear/useinteval | whether to use the interval evaluation callback of the nlhdlr
Range: boolean | 1 |
| nlhdlr/bilinear/usereverseprop | whether to use the reverse propagation callback of the nlhdlr
Range: boolean | 1 |
nlhdlr/concave
| Option | Description | Default |
| nlhdlr/concave/detectsum | whether to run convexity detection when the root of an expression is a sum
Range: boolean | 0 |
| nlhdlr/concave/enabled | should this nonlinear handler be used
Range: boolean | 1 |
| Options for expert users |
| nlhdlr/concave/cvxprodcomp | whether to use convexity check on product composition f(h)*h
Range: boolean | 1 |
| nlhdlr/concave/cvxquadratic | whether to use convexity check on quadratics
Range: boolean | 0 |
| nlhdlr/concave/cvxsignomial | whether to use convexity check on signomials
Range: boolean | 1 |
| nlhdlr/concave/handletrivial | whether to also handle trivial convex expressions
Range: boolean | 0 |
nlhdlr/convex
| Option | Description | Default |
| nlhdlr/convex/detectsum | whether to run convexity detection when the root of an expression is a non-quadratic sum
Range: boolean | 0 |
| nlhdlr/convex/enabled | should this nonlinear handler be used
Range: boolean | 1 |
| nlhdlr/convex/extendedform | whether to create extended formulations instead of looking for maximal convex expressions
Range: boolean | 1 |
| nlhdlr/convex/maxperturb | maximal relative perturbation of non-differentiable reference point
Range: [0, 1] | 0.01 |
| Options for expert users |
| nlhdlr/convex/cvxprodcomp | whether to use convexity check on product composition f(h)*h
Range: boolean | 1 |
| nlhdlr/convex/cvxquadratic | whether to use convexity check on quadratics
Range: boolean | 1 |
| nlhdlr/convex/cvxsignomial | whether to use convexity check on signomials
Range: boolean | 1 |
| nlhdlr/convex/handletrivial | whether to also handle trivial convex expressions
Range: boolean | 0 |
nlhdlr/default
| Option | Description | Default |
| nlhdlr/default/enabled | should this nonlinear handler be used
Range: boolean | 1 |
nlhdlr/perspective
| Option | Description | Default |
| nlhdlr/perspective/adjrefpoint | whether to adjust the reference point
Range: boolean | 1 |
| nlhdlr/perspective/convexonly | whether perspective cuts are added only for convex expressions
Range: boolean | 0 |
| nlhdlr/perspective/enabled | should this nonlinear handler be used
Range: boolean | 1 |
| nlhdlr/perspective/maxproprounds | maximal number of propagation rounds in probing
Range: {-1, ..., ∞} | 1 |
| nlhdlr/perspective/mindomreduction | minimal relative reduction in a variable's domain for applying probing
Range: [0, 1] | 0.1 |
| nlhdlr/perspective/minviolprobing | minimal violation w.r.t. auxiliary variables for applying probing
Range: [0, ∞] | 1e-05 |
| nlhdlr/perspective/probingfreq | probing frequency (-1 - no probing, 0 - root node only)
Range: {-1, ..., ∞} | 1 |
| nlhdlr/perspective/probingonlyinsepa | whether to do probing only in separation
Range: boolean | 1 |
| nlhdlr/perspective/tightenbounds | whether variable semicontinuity is used to tighten variable bounds
Range: boolean | 1 |
nlhdlr/quadratic
| Option | Description | Default |
| nlhdlr/quadratic/atwhichnodes | determines at which nodes cut is used (if it's -1, it's used only at the root node, if it's n ≥ 0, it's used at every multiple of n
Range: {-1, ..., ∞} | 1 |
| nlhdlr/quadratic/enabled | should this nonlinear handler be used
Range: boolean | 1 |
| nlhdlr/quadratic/ignorebadrayrestriction | should cut be generated even with bad numerics when restricting to ray?
Range: boolean | 1 |
| nlhdlr/quadratic/ignorenhighre | should cut be added even when range / efficacy is large?
Range: boolean | 1 |
| nlhdlr/quadratic/maxrank | maximal rank a slackvar can have
Range: {0, ..., ∞} | ∞ |
| nlhdlr/quadratic/mincutviolation | minimal cut violation the generated cuts must fulfill to be added to the LP
Range: [0, ∞] | 0.0001 |
| nlhdlr/quadratic/minviolation | minimal violation the constraint must fulfill such that a cut is generated
Range: [0, ∞] | 0.0001 |
| nlhdlr/quadratic/ncutslimit | limit for number of cuts generated consecutively
Range: {0, ..., ∞} | 2 |
| nlhdlr/quadratic/ncutslimitroot | limit for number of cuts generated at root node
Range: {0, ..., ∞} | 20 |
| nlhdlr/quadratic/nstrengthlimit | limit for number of rays we do the strengthening for
Range: {0, ..., ∞} | ∞ |
| nlhdlr/quadratic/sparsifycuts | should we try to sparisfy the intersection cut?
Range: boolean | 0 |
| nlhdlr/quadratic/trackmore | for monoidal strengthening, should we track more statistics (more expensive)?
Range: boolean | 0 |
| nlhdlr/quadratic/useboundsasrays | use bounds of variables in quadratic as rays for intersection cuts
Range: boolean | 0 |
| nlhdlr/quadratic/useintersectioncuts | whether to use intersection cuts for quadratic constraints to separate
Range: boolean | 0 |
| nlhdlr/quadratic/useminrep | whether the minimal representation of the S-free set should be used (instead of the gauge)
Range: boolean | 1 |
| nlhdlr/quadratic/usemonoidal | whether monoidal strengthening should be used
Range: boolean | 1 |
| nlhdlr/quadratic/usestrengthening | whether the strengthening should be used
Range: boolean | 0 |
nlhdlr/quotient
| Option | Description | Default |
| nlhdlr/quotient/enabled | should this nonlinear handler be used
Range: boolean | 1 |
nlhdlr/signomial
| Option | Description | Default |
| nlhdlr/signomial/enabled | should this nonlinear handler be used
Range: boolean | 1 |
| Options for expert users |
| nlhdlr/signomial/maxnundervars | maximum number of variables when underestimating a concave power function
Range: {2, ..., 14} | 14 |
| nlhdlr/signomial/mincutscale | minimum scale factor when scaling a cut
Range: [1e-06, 1e+06] | 1e-05 |
nlhdlr/soc
| Option | Description | Default |
| nlhdlr/soc/compeigenvalues | Should Eigenvalue computations be done to detect complex cases in quadratic constraints?
Range: boolean | 1 |
| nlhdlr/soc/enabled | should this nonlinear handler be used
Range: boolean | 1 |
| nlhdlr/soc/mincutefficacy | Minimum efficacy which a cut needs in order to be added.
Range: [0, ∞] | 1e-05 |
nlp
| Option | Description | Default |
| nlp/disable | should the NLP relaxation be always disabled (also for NLPs/MINLPs)?
Range: boolean | 0 |
nlpi/ipopt
| Option | Description | Default |
| nlpi/ipopt/hessian_approximation | Indicates what Hessian information is to be used. Valid values if not empty: exact limited-memory
Range: string | |
| nlpi/ipopt/hsllib | Name of library containing HSL routines for load at runtime
Range: string | |
| nlpi/ipopt/linear_solver | Linear solver used for step computations. Valid values if not empty: ma27 ma57 ma77 ma86 ma97 pardiso pardisomkl mumps custom
Range: string | ma27, if IpoptH licensed, mumps otherwise |
| nlpi/ipopt/linear_system_scaling | Method for scaling the linear system. Valid values if not empty: none mc19 slack-based
Range: string | mc19, if IpoptH licensed, empty otherwise |
| nlpi/ipopt/mu_strategy | Update strategy for barrier parameter. Valid values if not empty: monotone adaptive
Range: string | |
| nlpi/ipopt/nlp_scaling_method | Select the technique used for scaling the NLP. Valid values if not empty: none user-scaling gradient-based equilibration-based
Range: string | |
| nlpi/ipopt/optfile | name of Ipopt options file
Range: string | |
| nlpi/ipopt/pardisolib | Name of library containing Pardiso routines (from pardiso-project.org) for load at runtime
Range: string | |
| nlpi/ipopt/print_level | Output verbosity level. -1 to use NLPI or Ipopt default.
Range: {-1, ..., 12} | -1 |
| nlpi/ipopt/priority | priority of NLPI <ipopt>
Range: {-536870912, ..., 536870911} | 1000 |
| nlpi/ipopt/warm_start_push | amount (relative and absolute) by which starting point is moved away from bounds in warmstarts
Range: [0, 1] | 1e-09 |
nodeselection
| Option | Description | Default |
| nodeselection/childsel | child selection rule ('d'own, 'u'p, 'p'seudo costs, 'i'nference, 'l'p value, 'r'oot LP value difference, 'h'ybrid inference/root LP value difference)
Range: d, u, p, i, l, r, h | h |
nodeselection/bfs
| Option | Description | Default |
| nodeselection/bfs/stdpriority | priority of node selection rule <bfs> in standard mode
Range: {-536870912, ..., 1073741823} | 100000 |
| Options for expert users |
| nodeselection/bfs/maxplungedepth | maximal plunging depth, before new best node is forced to be selected (-1 for dynamic setting)
Range: {-1, ..., ∞} | -1 |
| nodeselection/bfs/maxplungequot | maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where plunging is performed
Range: [0, ∞] | 0.25 |
| nodeselection/bfs/memsavepriority | priority of node selection rule <bfs> in memory saving mode
Range: {-536870912, ..., 536870911} | 0 |
| nodeselection/bfs/minplungedepth | minimal plunging depth, before new best node may be selected (-1 for dynamic setting)
Range: {-1, ..., ∞} | -1 |
nodeselection/breadthfirst
| Option | Description | Default |
| nodeselection/breadthfirst/stdpriority | priority of node selection rule <breadthfirst> in standard mode
Range: {-536870912, ..., 1073741823} | -10000 |
| Options for expert users |
| nodeselection/breadthfirst/memsavepriority | priority of node selection rule <breadthfirst> in memory saving mode
Range: {-536870912, ..., 536870911} | -1000000 |
nodeselection/dfs
| Option | Description | Default |
| nodeselection/dfs/stdpriority | priority of node selection rule <dfs> in standard mode
Range: {-536870912, ..., 1073741823} | 0 |
| Options for expert users |
| nodeselection/dfs/memsavepriority | priority of node selection rule <dfs> in memory saving mode
Range: {-536870912, ..., 536870911} | 100000 |
nodeselection/estimate
| Option | Description | Default |
| nodeselection/estimate/bestnodefreq | frequency at which the best node instead of the best estimate is selected (0: never)
Range: {0, ..., ∞} | 10 |
| nodeselection/estimate/breadthfirstdepth | depth until breadth-first search is applied
Range: {-1, ..., ∞} | -1 |
| nodeselection/estimate/plungeoffset | number of nodes before doing plunging the first time
Range: {0, ..., ∞} | 0 |
| nodeselection/estimate/stdpriority | priority of node selection rule <estimate> in standard mode
Range: {-536870912, ..., 1073741823} | 200000 |
| Options for expert users |
| nodeselection/estimate/maxplungedepth | maximal plunging depth, before new best node is forced to be selected (-1 for dynamic setting)
Range: {-1, ..., ∞} | -1 |
| nodeselection/estimate/maxplungequot | maximal quotient (estimate - lowerbound)/(cutoffbound - lowerbound) where plunging is performed
Range: [0, ∞] | 0.25 |
| nodeselection/estimate/memsavepriority | priority of node selection rule <estimate> in memory saving mode
Range: {-536870912, ..., 536870911} | 100 |
| nodeselection/estimate/minplungedepth | minimal plunging depth, before new best node may be selected (-1 for dynamic setting)
Range: {-1, ..., ∞} | -1 |
nodeselection/hybridestim
| Option | Description | Default |
| nodeselection/hybridestim/bestnodefreq | frequency at which the best node instead of the hybrid best estimate / best bound is selected (0: never)
Range: {0, ..., ∞} | 1000 |
| nodeselection/hybridestim/stdpriority | priority of node selection rule <hybridestim> in standard mode
Range: {-536870912, ..., 1073741823} | 50000 |
| Options for expert users |
| nodeselection/hybridestim/estimweight | weight of estimate value in node selection score (0: pure best bound search, 1: pure best estimate search)
Range: [0, 1] | 0.1 |
| nodeselection/hybridestim/maxplungedepth | maximal plunging depth, before new best node is forced to be selected (-1 for dynamic setting)
Range: {-1, ..., ∞} | -1 |
| nodeselection/hybridestim/maxplungequot | maximal quotient (estimate - lowerbound)/(cutoffbound - lowerbound) where plunging is performed
Range: [0, ∞] | 0.25 |
| nodeselection/hybridestim/memsavepriority | priority of node selection rule <hybridestim> in memory saving mode
Range: {-536870912, ..., 536870911} | 50 |
| nodeselection/hybridestim/minplungedepth | minimal plunging depth, before new best node may be selected (-1 for dynamic setting)
Range: {-1, ..., ∞} | -1 |
nodeselection/restartdfs
| Option | Description | Default |
| nodeselection/restartdfs/countonlyleaves | count only leaf nodes (otherwise all nodes)?
Range: boolean | 1 |
| nodeselection/restartdfs/selectbestfreq | frequency for selecting the best node instead of the deepest one
Range: {0, ..., ∞} | 100 |
| nodeselection/restartdfs/stdpriority | priority of node selection rule <restartdfs> in standard mode
Range: {-536870912, ..., 1073741823} | 10000 |
| Options for expert users |
| nodeselection/restartdfs/memsavepriority | priority of node selection rule <restartdfs> in memory saving mode
Range: {-536870912, ..., 536870911} | 50000 |
nodeselection/uct
| Option | Description | Default |
| nodeselection/uct/stdpriority | priority of node selection rule <uct> in standard mode
Range: {-536870912, ..., 1073741823} | 10 |
| Options for expert users |
| nodeselection/uct/memsavepriority | priority of node selection rule <uct> in memory saving mode
Range: {-536870912, ..., 536870911} | 0 |
| nodeselection/uct/nodelimit | maximum number of nodes before switching to default rule
Range: {0, ..., 1000000} | 31 |
| nodeselection/uct/useestimate | should the estimate (TRUE) or lower bound of a node be used for UCT score?
Range: boolean | 0 |
| nodeselection/uct/weight | weight for visit quotient of node selection rule
Range: [0, 1] | 0.1 |
numerics
| Option | Description | Default |
| numerics/checkfeastolfac | feasibility tolerance factor; for checking the feasibility of the best solution
Range: [0, ∞] | 1 |
| numerics/dualfeastol | feasibility tolerance for reduced costs in LP solution
Range: [1e-17, 0.001] | 1e-07 |
| numerics/epsilon | absolute values smaller than this are considered zero
Range: [1e-20, 0.001] | 1e-09 |
| numerics/feastol | feasibility tolerance for constraints
Range: [1e-17, 0.001] | 1e-06 |
| numerics/lpfeastolfactor | factor w.r.t. primal feasibility tolerance that determines default (and maximal) primal feasibility tolerance of LP solver
Range: [1e-06, 1] | 1 |
| numerics/sumepsilon | absolute values of sums smaller than this are considered zero
Range: [1e-17, 0.001] | 1e-06 |
| Options for expert users |
| numerics/barrierconvtol | LP convergence tolerance used in barrier algorithm
Range: [1e-17, 0.001] | 1e-10 |
| numerics/boundstreps | minimal relative improve for strengthening bounds
Range: [1e-17, ∞] | 0.05 |
| numerics/hugeval | values larger than this are considered huge and should be handled separately (e.g., in activity computation)
Range: [0, ∞] | 1e+15 |
| numerics/pseudocostdelta | minimal objective distance value to use for branching pseudo cost updates
Range: [0, ∞] | 0.0001 |
| numerics/pseudocosteps | minimal variable distance value to use for branching pseudo cost updates
Range: [1e-17, 1] | 0.1 |
| numerics/recomputefac | minimal decrease factor that causes the recomputation of a value (e.g., pseudo objective) instead of an update
Range: [0, ∞] | 1e+07 |
presolving
| Option | Description | Default |
| presolving/maxrestarts | maximal number of restarts (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| presolving/maxrounds | maximal number of presolving rounds (-1: unlimited, 0: off)
Range: {-1, ..., ∞} | -1 |
| Options for expert users |
| presolving/abortfac | abort presolve, if at most this fraction of the problem was changed in last presolve round
Range: [0, 1] | 0.0008 |
| presolving/clqtablefac | limit on number of entries in clique table relative to number of problem nonzeros
Range: [0, ∞] | 2 |
| presolving/donotaggr | should aggregation of variables be forbidden?
Range: boolean | 0 |
| presolving/donotmultaggr | should multi-aggregation of variables be forbidden?
Range: boolean | 0 |
| presolving/immrestartfac | fraction of integer variables that were fixed in the root node triggering an immediate restart with preprocessing
Range: [0, 1] | 0.1 |
| presolving/restartfac | fraction of integer variables that were fixed in the root node triggering a restart with preprocessing after root node evaluation
Range: [0, 1] | 0.025 |
| presolving/restartminred | minimal fraction of integer variables removed after restart to allow for an additional restart
Range: [0, 1] | 0.1 |
| presolving/subrestartfac | fraction of integer variables that were globally fixed during the solving process triggering a restart with preprocessing
Range: [0, 1] | 1 |
presolving/boundshift
| Option | Description | Default |
| presolving/boundshift/maxrounds | maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞} | 0 |
| Options for expert users |
| presolving/boundshift/flipping | is flipping allowed (multiplying with -1)?
Range: boolean | 1 |
| presolving/boundshift/integer | shift only integer ranges?
Range: boolean | 1 |
| presolving/boundshift/maxshift | absolute value of maximum shift
Range: {0, ..., ∞} | ∞ |
| presolving/boundshift/priority | priority of presolver <boundshift>
Range: {-536870912, ..., 536870911} | 7900000 |
| presolving/boundshift/timing | timing mask of presolver <boundshift> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 4 |
presolving/convertinttobin
| Option | Description | Default |
| presolving/convertinttobin/maxrounds | maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞} | 0 |
| Options for expert users |
| presolving/convertinttobin/maxdomainsize | absolute value of maximum domain size for converting an integer variable to binaries variables
Range: {0, ..., ∞} | ∞ |
| presolving/convertinttobin/onlypoweroftwo | should only integer variables with a domain size of 2^p - 1 be converted(, there we don't need an knapsack-constraint for restricting the sum of the binaries)
Range: boolean | 0 |
| presolving/convertinttobin/priority | priority of presolver <convertinttobin>
Range: {-536870912, ..., 536870911} | 6000000 |
| presolving/convertinttobin/samelocksinbothdirections | should only integer variables with uplocks equals downlocks be converted
Range: boolean | 0 |
| presolving/convertinttobin/timing | timing mask of presolver <convertinttobin> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 4 |
presolving/domcol
| Option | Description | Default |
| presolving/domcol/continuousred | should reductions for continuous variables be performed?
Range: boolean | 1 |
| presolving/domcol/maxrounds | maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| presolving/domcol/nummaxpairs | maximal number of pair comparisons
Range: {1024, ..., 1000000000} | 1048576 |
| presolving/domcol/numminpairs | minimal number of pair comparisons
Range: {100, ..., 1048576} | 1024 |
| presolving/domcol/predbndstr | should predictive bound strengthening be applied?
Range: boolean | 0 |
| Options for expert users |
| presolving/domcol/priority | priority of presolver <domcol>
Range: {-536870912, ..., 536870911} | -1000 |
| presolving/domcol/timing | timing mask of presolver <domcol> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 16 |
presolving/dualagg
| Option | Description | Default |
| presolving/dualagg/maxrounds | maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞} | 0 |
| Options for expert users |
| presolving/dualagg/priority | priority of presolver <dualagg>
Range: {-536870912, ..., 536870911} | -12000 |
| presolving/dualagg/timing | timing mask of presolver <dualagg> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 16 |
presolving/dualcomp
| Option | Description | Default |
| presolving/dualcomp/componlydisvars | should only discrete variables be compensated?
Range: boolean | 0 |
| presolving/dualcomp/maxrounds | maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| Options for expert users |
| presolving/dualcomp/priority | priority of presolver <dualcomp>
Range: {-536870912, ..., 536870911} | -50 |
| presolving/dualcomp/timing | timing mask of presolver <dualcomp> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 16 |
presolving/dualinfer
| Option | Description | Default |
| presolving/dualinfer/maxdualbndloops | maximal number of dual bound strengthening loops
Range: {-1, ..., ∞} | 12 |
| presolving/dualinfer/maxrounds | maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞} | 0 |
| presolving/dualinfer/maxrowsupport | Maximum number of row's non-zeros for changing inequality to equality
Range: {2, ..., ∞} | 3 |
| presolving/dualinfer/twocolcombine | use convex combination of columns for determining dual bounds
Range: boolean | 1 |
| Options for expert users |
| presolving/dualinfer/maxcombinefails | maximal number of consecutive useless column combines
Range: {-1, ..., ∞} | 1000 |
| presolving/dualinfer/maxconsiderednonzeros | maximal number of considered non-zeros within one column (-1: no limit)
Range: {-1, ..., ∞} | 100 |
| presolving/dualinfer/maxhashfac | Maximum number of hashlist entries as multiple of number of columns in the problem (-1: no limit)
Range: {-1, ..., ∞} | 10 |
| presolving/dualinfer/maxpairfac | Maximum number of processed column pairs as multiple of the number of columns in the problem (-1: no limit)
Range: {-1, ..., ∞} | 1 |
| presolving/dualinfer/maxretrievefails | maximal number of consecutive useless hashtable retrieves
Range: {-1, ..., ∞} | 1000 |
| presolving/dualinfer/priority | priority of presolver <dualinfer>
Range: {-536870912, ..., 536870911} | -3000 |
| presolving/dualinfer/timing | timing mask of presolver <dualinfer> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 16 |
presolving/dualsparsify
| Option | Description | Default |
| presolving/dualsparsify/maxbinfillin | maximal fillin for binary variables (-1: unlimited)
Range: {-1, ..., ∞} | 1 |
| presolving/dualsparsify/maxcontfillin | maximal fillin for continuous variables (-1: unlimited)
Range: {-1, ..., ∞} | 1 |
| presolving/dualsparsify/maxintfillin | maximal fillin for integer variables including binaries (-1: unlimited)
Range: {-1, ..., ∞} | 1 |
| presolving/dualsparsify/maxrounds | maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| presolving/dualsparsify/mineliminatednonzeros | minimal eliminated nonzeros within one column if we need to add a constraint to the problem
Range: {0, ..., ∞} | 100 |
| Options for expert users |
| presolving/dualsparsify/enablecopy | should dualsparsify presolver be copied to sub-SCIPs?
Range: boolean | 1 |
| presolving/dualsparsify/maxconsiderednonzeros | maximal number of considered nonzeros within one column (-1: no limit)
Range: {-1, ..., ∞} | 70 |
| presolving/dualsparsify/maxretrievefac | limit on the number of useless vs. useful hashtable retrieves as a multiple of the number of constraints
Range: [0, ∞] | 100 |
| presolving/dualsparsify/preservegoodlocks | should we preserve good locked properties of variables (at most one lock in one direction)?
Range: boolean | 0 |
| presolving/dualsparsify/preserveintcoefs | should we forbid cancellations that destroy integer coefficients?
Range: boolean | 0 |
| presolving/dualsparsify/priority | priority of presolver <dualsparsify>
Range: {-536870912, ..., 536870911} | -240000 |
| presolving/dualsparsify/timing | timing mask of presolver <dualsparsify> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 16 |
| presolving/dualsparsify/waitingfac | number of calls to wait until next execution as a multiple of the number of useless calls
Range: [0, ∞] | 2 |
presolving/gateextraction
| Option | Description | Default |
| presolving/gateextraction/maxrounds | maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| Options for expert users |
| presolving/gateextraction/onlysetpart | should we only try to extract set-partitioning constraints and no and-constraints
Range: boolean | 0 |
| presolving/gateextraction/priority | priority of presolver <gateextraction>
Range: {-536870912, ..., 536870911} | 1000000 |
| presolving/gateextraction/searchequations | should we try to extract set-partitioning constraint out of one logicor and one corresponding set-packing constraint
Range: boolean | 1 |
| presolving/gateextraction/sorting | order logicor contraints to extract big-gates before smaller ones (-1), do not order them (0) or order them to extract smaller gates at first (1)
Range: {-1, ..., 1} | 1 |
| presolving/gateextraction/timing | timing mask of presolver <gateextraction> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 16 |
presolving/implics
| Option | Description | Default |
| presolving/implics/maxrounds | maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| Options for expert users |
| presolving/implics/priority | priority of presolver <implics>
Range: {-536870912, ..., 536870911} | -10000 |
| presolving/implics/timing | timing mask of presolver <implics> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 8 |
presolving/inttobinary
| Option | Description | Default |
| presolving/inttobinary/maxrounds | maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| Options for expert users |
| presolving/inttobinary/priority | priority of presolver <inttobinary>
Range: {-536870912, ..., 536870911} | 7000000 |
| presolving/inttobinary/timing | timing mask of presolver <inttobinary> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 4 |
presolving/milp
| Option | Description | Default |
| presolving/milp/hugebound | absolute bound value that is considered too huge for activitity based calculations
Range: [0, ∞] | 1e+08 |
| presolving/milp/markowitztolerance | the markowitz tolerance used for substitutions
Range: [0, 1] | 0.01 |
| presolving/milp/maxbadgesizepar | maximal badge size in Probing in PaPILO if PaPILO is executed in parallel mode
Range: {-1, ..., ∞} | -1 |
| presolving/milp/maxbadgesizeseq | maximal badge size in Probing in PaPILO if PaPILO is executed in sequential mode
Range: {-1, ..., ∞} | 15000 |
| presolving/milp/maxfillinpersubstitution | maximal possible fillin for substitutions to be considered
Range: {-2147483648, ..., ∞} | 3 |
| presolving/milp/maxrounds | maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| presolving/milp/modifyconsfac | modify SCIP constraints when the number of nonzeros or rows is at most this factor times the number of nonzeros or rows before presolving
Range: [0, 1] | 0.8 |
| presolving/milp/randomseed | the random seed used for randomization of tie breaking
Range: {-2147483648, ..., ∞} | 0 |
| presolving/milp/threads | maximum number of threads presolving may use (0: automatic)
Range: {0, ..., ∞} | GAMS threads |
| presolving/milp/verbosity | verbosity level of PaPILO (0: quiet, 1: errors, 2: warnings, 3: normal, 4: detailed)
Range: {0, ..., 4} | 0 |
| Options for expert users |
| presolving/milp/enabledomcol | should the dominated column presolver be enabled within the presolve library?
Range: boolean | 1 |
| presolving/milp/enabledualinfer | should the dualinfer presolver be enabled within the presolve library?
Range: boolean | 1 |
| presolving/milp/enablemultiaggr | should the multi-aggregation presolver be enabled within the presolve library?
Range: boolean | 1 |
| presolving/milp/enableparallelrows | should the parallel rows presolver be enabled within the presolve library?
Range: boolean | 1 |
| presolving/milp/enableprobing | should the probing presolver be enabled within the presolve library?
Range: boolean | 1 |
| presolving/milp/enablesparsify | should the sparsify presolver be enabled within the presolve library?
Range: boolean | 0 |
| presolving/milp/internalmaxrounds | internal maxrounds for each milp presolving (-1: no limit, 0: model cleanup)
Range: {-1, ..., ∞} | -1 |
| presolving/milp/maxshiftperrow | maximal amount of nonzeros allowed to be shifted to make space for substitutions
Range: {0, ..., ∞} | 10 |
| presolving/milp/priority | priority of presolver <milp>
Range: {-536870912, ..., 536870911} | 9999999 |
| presolving/milp/probfilename | filename to store the problem before MILP presolving starts (only enforced constraints)
Range: string | - |
| presolving/milp/timing | timing mask of presolver <milp> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 8 |
presolving/qpkktref
| Option | Description | Default |
| presolving/qpkktref/maxrounds | maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞} | 0 |
| Options for expert users |
| presolving/qpkktref/addkktbinary | if TRUE then allow binary variables for KKT update
Range: boolean | 0 |
| presolving/qpkktref/priority | priority of presolver <qpkktref>
Range: {-536870912, ..., 536870911} | -1 |
| presolving/qpkktref/timing | timing mask of presolver <qpkktref> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 8 |
| presolving/qpkktref/updatequadbounded | if TRUE then only apply the update to QPs with bounded variables; if the variables are not bounded then a finite optimal solution might not exist and the KKT conditions would then be invalid
Range: boolean | 1 |
| presolving/qpkktref/updatequadindef | if TRUE then apply quadratic constraint update even if the quadratic constraint matrix is known to be indefinite
Range: boolean | 0 |
presolving/redvub
| Option | Description | Default |
| presolving/redvub/maxrounds | maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞} | 0 |
| Options for expert users |
| presolving/redvub/priority | priority of presolver <redvub>
Range: {-536870912, ..., 536870911} | -9000000 |
| presolving/redvub/timing | timing mask of presolver <redvub> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 16 |
presolving/sparsify
| Option | Description | Default |
| presolving/sparsify/maxbinfillin | maximal fillin for binary variables (-1: unlimited)
Range: {-1, ..., ∞} | 0 |
| presolving/sparsify/maxcontfillin | maximal fillin for continuous variables (-1: unlimited)
Range: {-1, ..., ∞} | 0 |
| presolving/sparsify/maxintfillin | maximal fillin for integer variables including binaries (-1: unlimited)
Range: {-1, ..., ∞} | 0 |
| presolving/sparsify/maxrounds | maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| Options for expert users |
| presolving/sparsify/cancellinear | should we cancel nonzeros in constraints of the linear constraint handler?
Range: boolean | 1 |
| presolving/sparsify/enablecopy | should sparsify presolver be copied to sub-SCIPs?
Range: boolean | 1 |
| presolving/sparsify/maxconsiderednonzeros | maximal number of considered non-zeros within one row (-1: no limit)
Range: {-1, ..., ∞} | 70 |
| presolving/sparsify/maxnonzeros | maximal support of one equality to be used for cancelling (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| presolving/sparsify/maxretrievefac | limit on the number of useless vs. useful hashtable retrieves as a multiple of the number of constraints
Range: [0, ∞] | 100 |
| presolving/sparsify/preserveintcoefs | should we forbid cancellations that destroy integer coefficients?
Range: boolean | 1 |
| presolving/sparsify/priority | priority of presolver <sparsify>
Range: {-536870912, ..., 536870911} | -24000 |
| presolving/sparsify/rowsort | order in which to process inequalities ('n'o sorting, 'i'ncreasing nonzeros, 'd'ecreasing nonzeros)
Range: n, i, d | d |
| presolving/sparsify/timing | timing mask of presolver <sparsify> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 16 |
| presolving/sparsify/waitingfac | number of calls to wait until next execution as a multiple of the number of useless calls
Range: [0, ∞] | 2 |
presolving/stuffing
| Option | Description | Default |
| presolving/stuffing/maxrounds | maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞} | 0 |
| Options for expert users |
| presolving/stuffing/priority | priority of presolver <stuffing>
Range: {-536870912, ..., 536870911} | -100 |
| presolving/stuffing/timing | timing mask of presolver <stuffing> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 16 |
presolving/trivial
| Option | Description | Default |
| presolving/trivial/maxrounds | maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| Options for expert users |
| presolving/trivial/priority | priority of presolver <trivial>
Range: {-536870912, ..., 536870911} | 9000000 |
| presolving/trivial/timing | timing mask of presolver <trivial> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 4 |
presolving/tworowbnd
| Option | Description | Default |
| presolving/tworowbnd/maxcombinefails | maximal number of consecutive useless row combines
Range: {-1, ..., ∞} | 1000 |
| presolving/tworowbnd/maxconsiderednonzeros | maximal number of considered non-zeros within one row (-1: no limit)
Range: {-1, ..., ∞} | 100 |
| presolving/tworowbnd/maxhashfac | Maximum number of hashlist entries as multiple of number of rows in the problem (-1: no limit)
Range: {-1, ..., ∞} | 10 |
| presolving/tworowbnd/maxpairfac | Maximum number of processed row pairs as multiple of the number of rows in the problem (-1: no limit)
Range: {-1, ..., ∞} | 1 |
| presolving/tworowbnd/maxretrievefails | maximal number of consecutive useless hashtable retrieves
Range: {-1, ..., ∞} | 1000 |
| presolving/tworowbnd/maxrounds | maximal number of presolving rounds the presolver participates in (-1: no limit)
Range: {-1, ..., ∞} | 0 |
| Options for expert users |
| presolving/tworowbnd/enablecopy | should tworowbnd presolver be copied to sub-SCIPs?
Range: boolean | 1 |
| presolving/tworowbnd/priority | priority of presolver <tworowbnd>
Range: {-536870912, ..., 536870911} | -2000 |
| presolving/tworowbnd/timing | timing mask of presolver <tworowbnd> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {4, ..., 60} | 16 |
propagating
| Option | Description | Default |
| propagating/abortoncutoff | should propagation be aborted immediately? setting this to FALSE could help conflict analysis to produce more conflict constraints
Range: boolean | 1 |
| propagating/maxrounds | maximal number of propagation rounds per node (-1: unlimited)
Range: {-1, ..., ∞} | 100 |
| propagating/maxroundsroot | maximal number of propagation rounds in the root node (-1: unlimited)
Range: {-1, ..., ∞} | 1000 |
propagating/dualfix
| Option | Description | Default |
| propagating/dualfix/freq | frequency for calling propagator <dualfix> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 0 |
| propagating/dualfix/maxprerounds | maximal number of presolving rounds the propagator participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| Options for expert users |
| propagating/dualfix/delay | should propagator be delayed, if other propagators found reductions?
Range: boolean | 0 |
| propagating/dualfix/presolpriority | presolving priority of propagator <dualfix>
Range: {-536870912, ..., 536870911} | 8000000 |
| propagating/dualfix/presoltiming | timing mask of the presolving method of propagator <dualfix> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {2, ..., 60} | 4 |
| propagating/dualfix/priority | priority of propagator <dualfix>
Range: {-536870912, ..., 536870911} | 8000000 |
| propagating/dualfix/timingmask | timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS))
Range: {1, ..., 15} | 1 |
propagating/genvbounds
| Option | Description | Default |
| propagating/genvbounds/freq | frequency for calling propagator <genvbounds> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 1 |
| propagating/genvbounds/maxprerounds | maximal number of presolving rounds the propagator participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| Options for expert users |
| propagating/genvbounds/delay | should propagator be delayed, if other propagators found reductions?
Range: boolean | 0 |
| propagating/genvbounds/global | apply global propagation?
Range: boolean | 1 |
| propagating/genvbounds/presolpriority | presolving priority of propagator <genvbounds>
Range: {-536870912, ..., 536870911} | -2000000 |
| propagating/genvbounds/presoltiming | timing mask of the presolving method of propagator <genvbounds> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {2, ..., 60} | 4 |
| propagating/genvbounds/priority | priority of propagator <genvbounds>
Range: {-536870912, ..., 536870911} | 3000000 |
| propagating/genvbounds/propasconss | should genvbounds be transformed to (linear) constraints?
Range: boolean | 0 |
| propagating/genvbounds/propinrootnode | apply genvbounds in root node if no new incumbent was found?
Range: boolean | 1 |
| propagating/genvbounds/sort | sort genvbounds and wait for bound change events?
Range: boolean | 1 |
| propagating/genvbounds/timingmask | timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS))
Range: {1, ..., 15} | 15 |
propagating/nlobbt
| Option | Description | Default |
| propagating/nlobbt/addlprows | should non-initial LP rows be used?
Range: boolean | 1 |
| propagating/nlobbt/freq | frequency for calling propagator <nlobbt> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | -1 |
| propagating/nlobbt/maxprerounds | maximal number of presolving rounds the propagator participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| Options for expert users |
| propagating/nlobbt/delay | should propagator be delayed, if other propagators found reductions?
Range: boolean | 1 |
| propagating/nlobbt/feastolfac | factor for NLP feasibility tolerance
Range: [0, 1] | 0.01 |
| propagating/nlobbt/itlimitfactor | LP iteration limit for nlobbt will be this factor times total LP iterations in root node
Range: [0, ∞] | 2 |
| propagating/nlobbt/minlinearfrac | minimum (convex nlrows)/(linear nlrows) threshold to apply propagator
Range: [0, ∞] | 0.02 |
| propagating/nlobbt/minnonconvexfrac | (convex nlrows)/(nonconvex nlrows) threshold to apply propagator
Range: [0, ∞] | 0.2 |
| propagating/nlobbt/nlpiterlimit | iteration limit of NLP solver; 0 for no limit
Range: {0, ..., ∞} | 500 |
| propagating/nlobbt/nlptimelimit | time limit of NLP solver; 0.0 for no limit
Range: [0, ∞] | 0 |
| propagating/nlobbt/nlpverblevel | verbosity level of NLP solver
Range: {0, ..., 5} | 0 |
| propagating/nlobbt/presolpriority | presolving priority of propagator <nlobbt>
Range: {-536870912, ..., 536870911} | 0 |
| propagating/nlobbt/presoltiming | timing mask of the presolving method of propagator <nlobbt> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {2, ..., 60} | 28 |
| propagating/nlobbt/priority | priority of propagator <nlobbt>
Range: {-536870912, ..., 536870911} | -1100000 |
| propagating/nlobbt/relobjtolfac | factor for NLP relative objective tolerance
Range: [0, 1] | 0.01 |
| propagating/nlobbt/timingmask | timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS))
Range: {1, ..., 15} | 4 |
propagating/obbt
| Option | Description | Default |
| propagating/obbt/boundstreps | minimal relative improve for strengthening bounds
Range: [0, 1] | 0.001 |
| propagating/obbt/conditionlimit | maximum condition limit used in LP solver (-1.0: no limit)
Range: [-1, ∞] | -1 |
| propagating/obbt/dualfeastol | feasibility tolerance for reduced costs used in obbt; this value is used if SCIP's dual feastol is greater
Range: [0, ∞] | 1e-09 |
| propagating/obbt/freq | frequency for calling propagator <obbt> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 0 |
| propagating/obbt/itlimitfactor | multiple of root node LP iterations used as total LP iteration limit for obbt (≤ 0: no limit )
Range: real | 10 |
| propagating/obbt/itlimitfactorbilin | multiple of OBBT LP limit used as total LP iteration limit for solving bilinear inequality LPs (< 0 for no limit)
Range: real | 3 |
| propagating/obbt/maxprerounds | maximal number of presolving rounds the propagator participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| propagating/obbt/minitlimit | minimum LP iteration limit
Range: {0, ..., ∞} | 5000 |
| propagating/obbt/minnonconvexity | minimum absolute value of nonconvex eigenvalues for a bilinear term
Range: [0, ∞] | 0.1 |
| Options for expert users |
| propagating/obbt/applyfilterrounds | try to filter bounds in so-called filter rounds by solving auxiliary LPs?
Range: boolean | 0 |
| propagating/obbt/applytrivialfilter | try to filter bounds with the LP solution after each solve?
Range: boolean | 1 |
| propagating/obbt/createbilinineqs | solve auxiliary LPs in order to find valid inequalities for bilinear terms?
Range: boolean | 1 |
| propagating/obbt/creategenvbounds | should obbt try to provide genvbounds if possible?
Range: boolean | 1 |
| propagating/obbt/createlincons | create linear constraints from inequalities for bilinear terms?
Range: boolean | 0 |
| propagating/obbt/delay | should propagator be delayed, if other propagators found reductions?
Range: boolean | 1 |
| propagating/obbt/genvbdsduringfilter | should we try to generate genvbounds during trivial and aggressive filtering?
Range: boolean | 1 |
| propagating/obbt/genvbdsduringsepa | try to create genvbounds during separation process?
Range: boolean | 1 |
| propagating/obbt/indicators | apply obbt on variables of indicator constraints? (independent of convexity)
Range: boolean | 0 |
| propagating/obbt/indicatorthreshold | threshold whether upper bounds of vars of indicator conss are considered or tightened
Range: [0, ∞] | 1e+06 |
| propagating/obbt/minfilter | minimal number of filtered bounds to apply another filter round
Range: {1, ..., ∞} | 2 |
| propagating/obbt/normalize | should coefficients in filtering be normalized w.r.t. the domains sizes?
Range: boolean | 1 |
| propagating/obbt/onlynonconvexvars | only apply obbt on non-convex variables
Range: boolean | 1 |
| propagating/obbt/orderingalgo | select the type of ordering algorithm which should be used (0: no special ordering, 1: greedy, 2: greedy reverse)
Range: {0, ..., 2} | 1 |
| propagating/obbt/presolpriority | presolving priority of propagator <obbt>
Range: {-536870912, ..., 536870911} | 0 |
| propagating/obbt/presoltiming | timing mask of the presolving method of propagator <obbt> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {2, ..., 60} | 28 |
| propagating/obbt/priority | priority of propagator <obbt>
Range: {-536870912, ..., 536870911} | -1000000 |
| propagating/obbt/propagatefreq | trigger a propagation round after that many bound tightenings (0: no propagation)
Range: {0, ..., ∞} | 0 |
| propagating/obbt/sepamaxiter | maximum number of iteration spend to separate an obbt LP solution
Range: {0, ..., ∞} | 10 |
| propagating/obbt/sepaminiter | minimum number of iteration spend to separate an obbt LP solution
Range: {0, ..., ∞} | 0 |
| propagating/obbt/separatesol | should the obbt LP solution be separated?
Range: boolean | 0 |
| propagating/obbt/tightcontboundsprobing | should continuous bounds be tightened during the probing mode?
Range: boolean | 0 |
| propagating/obbt/tightintboundsprobing | should integral bounds be tightened during the probing mode?
Range: boolean | 1 |
| propagating/obbt/timingmask | timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS))
Range: {1, ..., 15} | 4 |
propagating/probing
| Option | Description | Default |
| propagating/probing/freq | frequency for calling propagator <probing> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | -1 |
| propagating/probing/maxprerounds | maximal number of presolving rounds the propagator participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| propagating/probing/maxruns | maximal number of runs, probing participates in (-1: no limit)
Range: {-1, ..., ∞} | 1 |
| Options for expert users |
| propagating/probing/delay | should propagator be delayed, if other propagators found reductions?
Range: boolean | 1 |
| propagating/probing/maxdepth | maximal depth until propagation is executed(-1: no limit)
Range: {-1, ..., ∞} | -1 |
| propagating/probing/maxfixings | maximal number of fixings found, until probing is interrupted (0: don't iterrupt)
Range: {0, ..., ∞} | 25 |
| propagating/probing/maxsumuseless | maximal number of probings without fixings, until probing is aborted (0: don't abort)
Range: {0, ..., ∞} | 0 |
| propagating/probing/maxtotaluseless | maximal number of successive probings without fixings, bound changes, and implications, until probing is aborted (0: don't abort)
Range: {0, ..., ∞} | 50 |
| propagating/probing/maxuseless | maximal number of successive probings without fixings, until probing is aborted (0: don't abort)
Range: {0, ..., ∞} | 1000 |
| propagating/probing/presolpriority | presolving priority of propagator <probing>
Range: {-536870912, ..., 536870911} | -100000 |
| propagating/probing/presoltiming | timing mask of the presolving method of propagator <probing> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {2, ..., 60} | 16 |
| propagating/probing/priority | priority of propagator <probing>
Range: {-536870912, ..., 536870911} | -100000 |
| propagating/probing/proprounds | maximal number of propagation rounds in probing subproblems (-1: no limit, 0: auto)
Range: {-1, ..., ∞} | -1 |
| propagating/probing/timingmask | timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS))
Range: {1, ..., 15} | 4 |
propagating/pseudoobj
| Option | Description | Default |
| propagating/pseudoobj/freq | frequency for calling propagator <pseudoobj> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 1 |
| propagating/pseudoobj/maxprerounds | maximal number of presolving rounds the propagator participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| Options for expert users |
| propagating/pseudoobj/delay | should propagator be delayed, if other propagators found reductions?
Range: boolean | 0 |
| propagating/pseudoobj/force | should the propagator be forced even if active pricer are present?
Range: boolean | 0 |
| propagating/pseudoobj/maximplvars | maximum number of binary variables the implications are used if turned on (-1: unlimited)?
Range: {-1, ..., ∞} | 50000 |
| propagating/pseudoobj/maxnewvars | number of variables added after the propagator is reinitialized?
Range: {0, ..., ∞} | 1000 |
| propagating/pseudoobj/maxvarsfrac | maximal fraction of non-binary variables with non-zero objective without a bound reduction before aborted
Range: [0, 1] | 0.1 |
| propagating/pseudoobj/minuseless | minimal number of successive non-binary variable propagations without a bound reduction before aborted
Range: {0, ..., ∞} | 100 |
| propagating/pseudoobj/presolpriority | presolving priority of propagator <pseudoobj>
Range: {-536870912, ..., 536870911} | 6000000 |
| propagating/pseudoobj/presoltiming | timing mask of the presolving method of propagator <pseudoobj> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {2, ..., 60} | 4 |
| propagating/pseudoobj/priority | priority of propagator <pseudoobj>
Range: {-536870912, ..., 536870911} | 3000000 |
| propagating/pseudoobj/propcutoffbound | propagate new cutoff bound directly globally
Range: boolean | 1 |
| propagating/pseudoobj/propfullinroot | whether to propagate all non-binary variables when we are propagating the root node
Range: boolean | 1 |
| propagating/pseudoobj/propuseimplics | use implications to strengthen the propagation of binary variable (increasing the objective change)?
Range: boolean | 1 |
| propagating/pseudoobj/respropuseimplics | use implications to strengthen the resolve propagation of binary variable (increasing the objective change)?
Range: boolean | 1 |
| propagating/pseudoobj/timingmask | timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS))
Range: {1, ..., 15} | 7 |
propagating/redcost
| Option | Description | Default |
| propagating/redcost/continuous | should reduced cost fixing be also applied to continuous variables?
Range: boolean | 0 |
| propagating/redcost/freq | frequency for calling propagator <redcost> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 1 |
| propagating/redcost/maxprerounds | maximal number of presolving rounds the propagator participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| propagating/redcost/useimplics | should implications be used to strength the reduced cost for binary variables?
Range: boolean | 0 |
| Options for expert users |
| propagating/redcost/delay | should propagator be delayed, if other propagators found reductions?
Range: boolean | 0 |
| propagating/redcost/force | should the propagator be forced even if active pricer are present?
Range: boolean | 0 |
| propagating/redcost/presolpriority | presolving priority of propagator <redcost>
Range: {-536870912, ..., 536870911} | 0 |
| propagating/redcost/presoltiming | timing mask of the presolving method of propagator <redcost> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {2, ..., 60} | 28 |
| propagating/redcost/priority | priority of propagator <redcost>
Range: {-536870912, ..., 536870911} | 1000000 |
| propagating/redcost/timingmask | timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS))
Range: {1, ..., 15} | 6 |
propagating/rootredcost
| Option | Description | Default |
| propagating/rootredcost/freq | frequency for calling propagator <rootredcost> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 1 |
| propagating/rootredcost/maxprerounds | maximal number of presolving rounds the propagator participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| Options for expert users |
| propagating/rootredcost/delay | should propagator be delayed, if other propagators found reductions?
Range: boolean | 0 |
| propagating/rootredcost/force | should the propagator be forced even if active pricer are present?
Range: boolean | 0 |
| propagating/rootredcost/onlybinary | should only binary variables be propagated?
Range: boolean | 0 |
| propagating/rootredcost/presolpriority | presolving priority of propagator <rootredcost>
Range: {-536870912, ..., 536870911} | 0 |
| propagating/rootredcost/presoltiming | timing mask of the presolving method of propagator <rootredcost> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {2, ..., 60} | 28 |
| propagating/rootredcost/priority | priority of propagator <rootredcost>
Range: {-536870912, ..., 536870911} | 10000000 |
| propagating/rootredcost/timingmask | timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS))
Range: {1, ..., 15} | 5 |
propagating/symmetry
| Option | Description | Default |
| propagating/symmetry/freq | frequency for calling propagator <symmetry> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 1 |
| propagating/symmetry/maxprerounds | maximal number of presolving rounds the propagator participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| Options for expert users |
| propagating/symmetry/addconflictcuts | Should Schreier Sims constraints be added if we use a conflict based rule?
Range: boolean | 1 |
| propagating/symmetry/addstrongsbcs | Should strong SBCs for enclosing orbit of symmetric subgroups be added if orbitopes are not used?
Range: boolean | 0 |
| propagating/symmetry/addsymresacks | Add inequalities for symresacks for each generator?
Range: boolean | 1 |
| propagating/symmetry/addweaksbcs | Should we add weak SBCs for enclosing orbit of symmetric subgroups?
Range: boolean | 1 |
| propagating/symmetry/checksymmetries | Should all symmetries be checked after computation?
Range: boolean | 0 |
| propagating/symmetry/compresssymmetries | Should non-affected variables be removed from permutation to save memory?
Range: boolean | 1 |
| propagating/symmetry/compressthreshold | Compression is used if percentage of moved vars is at most the threshold.
Range: [0, 1] | 0.5 |
| propagating/symmetry/conssaddlp | Should the symmetry breaking constraints be added to the LP?
Range: boolean | 1 |
| propagating/symmetry/delay | should propagator be delayed, if other propagators found reductions?
Range: boolean | 0 |
| propagating/symmetry/detectdoublelex | Should we check whether the components of the symmetry group can be handled by double lex matrices?
Range: boolean | 1 |
| propagating/symmetry/detectorbitopes | Should we check whether the components of the symmetry group can be handled by orbitopes?
Range: boolean | 1 |
| propagating/symmetry/detectsubgroups | Should we try to detect symmetric subgroups of the symmetry group on binary variables?
Range: boolean | 1 |
| propagating/symmetry/displaynorbitvars | Should the number of variables affected by some symmetry be displayed?
Range: boolean | 0 |
| propagating/symmetry/doubleequations | Double equations to positive/negative version?
Range: boolean | 0 |
| propagating/symmetry/enforcecomputesymmetry | Is only symmetry on binary variables used?
Range: boolean | 0 |
| propagating/symmetry/maxgenerators | limit on the number of generators that should be produced within symmetry detection (0 = no limit)
Range: {0, ..., ∞} | 1500 |
| propagating/symmetry/maxnconsssubgroup | maximum number of constraints up to which subgroup structures are detected
Range: {0, ..., ∞} | 500000 |
| propagating/symmetry/performpresolving | run orbital fixing during presolving? (disabled)
Range: boolean | 0 |
| propagating/symmetry/preferlessrows | Shall orbitopes with less rows be preferred in detection?
Range: boolean | 1 |
| propagating/symmetry/presolpriority | presolving priority of propagator <symmetry>
Range: {-536870912, ..., 536870911} | -10000000 |
| propagating/symmetry/presoltiming | timing mask of the presolving method of propagator <symmetry> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {2, ..., 60} | 16 |
| propagating/symmetry/priority | priority of propagator <symmetry>
Range: {-536870912, ..., 536870911} | -1000000 |
| propagating/symmetry/recomputerestart | recompute symmetries after a restart has occurred? (0 = never)
Range: {0, ..., 0} | 0 |
| propagating/symmetry/sstaddcuts | Should Schreier Sims constraints be added?
Range: boolean | 1 |
| propagating/symmetry/sstleaderrule | rule to select the leader in an orbit (0: first var; 1: last var; 2: var having most conflicting vars in orbit)
Range: {0, ..., 2} | 0 |
| propagating/symmetry/sstleadervartype | bitset encoding which variable types can be leaders (1: binary; 2: integer; 4: impl. int; 8: continuous);if multiple types are allowed, take the one with most affected vars
Range: {1, ..., 15} | 14 |
| propagating/symmetry/sstmixedcomponents | Should Schreier Sims constraints be added if a symmetry component contains variables of different types?
Range: boolean | 1 |
| propagating/symmetry/ssttiebreakrule | rule to select the orbit in Schreier Sims inequalities (variable in 0: minimum size orbit; 1: maximum size orbit; 2: orbit with most variables in conflict with leader)
Range: {0, ..., 2} | 1 |
| propagating/symmetry/symtiming | timing of symmetry computation and handling (0 = before presolving, 1 = during presolving, 2 = after presolving)
Range: {0, ..., 2} | 2 |
| propagating/symmetry/symtype | Type of symmetries that shall be computed?
Range: {0, ..., 1} | 0 |
| propagating/symmetry/timingmask | timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS))
Range: {1, ..., 15} | 1 |
| propagating/symmetry/usecolumnsparsity | Should the number of conss a variable is contained in be exploited in symmetry detection?
Range: boolean | 0 |
| propagating/symmetry/usedynamicprop | whether dynamified symmetry handling constraint methods should be used
Range: boolean | 1 |
propagating/symmetry/orbitopalreduction
| Option | Description | Default |
| Options for expert users |
| propagating/symmetry/orbitopalreduction/columnordering | The column ordering variant, respects enum SCIP_ColumnOrdering.
Range: {0, ..., 4} | 4 |
propagating/vbounds
| Option | Description | Default |
| propagating/vbounds/detectcycles | should cycles in the variable bound graph be identified?
Range: boolean | 0 |
| propagating/vbounds/dotoposort | should the bounds be topologically sorted in advance?
Range: boolean | 1 |
| propagating/vbounds/freq | frequency for calling propagator <vbounds> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 1 |
| propagating/vbounds/maxcliquesexhaustive | maximum number of cliques per variable to run clique table analysis in exhaustive presolving
Range: [0, ∞] | 100 |
| propagating/vbounds/maxcliquesmedium | maximum number of cliques per variable to run clique table analysis in medium presolving
Range: [0, ∞] | 50 |
| propagating/vbounds/maxprerounds | maximal number of presolving rounds the propagator participates in (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| propagating/vbounds/minnewcliques | minimum percentage of new cliques to trigger another clique table analysis
Range: [0, 1] | 0.1 |
| propagating/vbounds/usebdwidening | should bound widening be used to initialize conflict analysis?
Range: boolean | 1 |
| Options for expert users |
| propagating/vbounds/delay | should propagator be delayed, if other propagators found reductions?
Range: boolean | 0 |
| propagating/vbounds/presolpriority | presolving priority of propagator <vbounds>
Range: {-536870912, ..., 536870911} | -90000 |
| propagating/vbounds/presoltiming | timing mask of the presolving method of propagator <vbounds> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
Range: {2, ..., 60} | 24 |
| propagating/vbounds/priority | priority of propagator <vbounds>
Range: {-536870912, ..., 536870911} | 3000000 |
| propagating/vbounds/sortcliques | should cliques be regarded for the topological sort?
Range: boolean | 0 |
| propagating/vbounds/timingmask | timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS))
Range: {1, ..., 15} | 5 |
| propagating/vbounds/usecliques | should cliques be propagated?
Range: boolean | 0 |
| propagating/vbounds/useimplics | should implications be propagated?
Range: boolean | 0 |
| propagating/vbounds/usevbounds | should vbounds be propagated?
Range: boolean | 1 |
randomization
| Option | Description | Default |
| randomization/lpseed | random seed for LP solver, e.g. for perturbations in the simplex (0: LP default)
Range: {0, ..., ∞} | 0 |
| randomization/permutationseed | seed value for permuting the problem after reading/transformation (0: no permutation)
Range: {0, ..., ∞} | 0 |
| randomization/randomseedshift | global shift of all random seeds in the plugins and the LP random seed
Range: {0, ..., ∞} | 0 |
| Options for expert users |
| randomization/permuteconss | should order of constraints be permuted (depends on permutationseed)?
Range: boolean | 1 |
| randomization/permutevars | should order of variables be permuted (depends on permutationseed)?
Range: boolean | 0 |
separating
| Option | Description | Default |
| separating/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separation (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| separating/maxcoefratio | maximal ratio between coefficients in strongcg, cmir, and flowcover cuts
Range: [1, ∞] | 10000 |
| separating/maxcoefratiofacrowprep | maximal ratio between coefficients (as factor of 1/feastol) to ensure in rowprep cleanup
Range: [0, ∞] | 10 |
| separating/maxcuts | maximal number of cuts separated per separation round (0: disable local separation)
Range: {0, ..., ∞} | 100 |
| separating/maxcutsgenfactor | factor w.r.t. maxcuts for maximal number of cuts generated per separation round (-1.0: no limit, ≥ 0.0: valid finite limit)
Range: [-1, ∞] | 2 |
| separating/maxcutsroot | maximal number of separated cuts per separation round at the root node (0: disable root node separation)
Range: {0, ..., ∞} | 2000 |
| separating/maxcutsrootgenfactor | factor w.r.t. maxcutsroot for maximal number of generated cuts per separation round at the root node (-1.0: no limit, ≥ 0.0: valid finite limit)
Range: [-1, ∞] | 2 |
| separating/maxlocalbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying local separation (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 0 |
| separating/maxrounds | maximal number of separation rounds per node (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| separating/maxroundsroot | maximal number of separation rounds in the root node (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| separating/maxstallrounds | maximal number of consecutive separation rounds without objective or integrality improvement in local nodes (-1: no additional restriction)
Range: {-1, ..., ∞} | 1 |
| separating/maxstallroundsroot | maximal number of consecutive separation rounds without objective or integrality improvement in the root node (-1: no additional restriction)
Range: {-1, ..., ∞} | 10 |
| separating/minactivityquot | minimum cut activity quotient to convert cuts into constraints during a restart (0.0: all cuts are converted)
Range: [0, 1] | 0.8 |
| separating/minefficacy | minimal efficacy for a cut to enter the LP
Range: [0, ∞] | 0.0001 |
| separating/minefficacyroot | minimal efficacy for a cut to enter the LP in the root node
Range: [0, ∞] | 0.0001 |
| separating/poolfreq | separation frequency for the global cut pool (-1: disable global cut pool, 0: only separate pool at the root)
Range: {-1, ..., 1073741822} | 10 |
| Options for expert users |
| separating/cutagelimit | maximum age a cut can reach before it is deleted from the global cut pool, or -1 to keep all cuts
Range: {-1, ..., ∞} | 80 |
| separating/cutselrestart | cut selection during restart ('a'ge, activity 'q'uotient)
Range: a, q | a |
| separating/cutselsubscip | cut selection for sub SCIPs ('a'ge, activity 'q'uotient)
Range: a, q | a |
| separating/efficacynorm | row norm to use for efficacy calculation ('e'uclidean, 'm'aximum, 's'um, 'd'iscrete)
Range: e, m, s, d | e |
| separating/filtercutpoolrel | should cutpool separate only cuts with high relative efficacy?
Range: boolean | 0 |
| separating/maxaddrounds | maximal additional number of separation rounds in subsequent price-and-cut loops (-1: no additional restriction)
Range: {-1, ..., ∞} | 1 |
| separating/maxroundsrootsubrun | maximal number of separation rounds in the root node of a subsequent run (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| separating/maxruns | maximal number of runs for which separation is enabled (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| separating/orthofunc | function used for calc. scalar prod. in orthogonality test ('e'uclidean, 'd'iscrete)
Range: e, d | e |
separating/aggregation
| Option | Description | Default |
| separating/aggregation/dynamiccuts | should generated cuts be removed from the LP if they are no longer tight?
Range: boolean | 1 |
| separating/aggregation/freq | frequency for calling separator <aggregation> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 10 |
| separating/aggregation/maxrounds | maximal number of cmir separation rounds per node (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| separating/aggregation/maxroundsroot | maximal number of cmir separation rounds in the root node (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| separating/aggregation/maxsepacuts | maximal number of cmir cuts separated per separation round
Range: {0, ..., ∞} | 100 |
| separating/aggregation/maxsepacutsroot | maximal number of cmir cuts separated per separation round in the root node
Range: {0, ..., ∞} | 500 |
| Options for expert users |
| separating/aggregation/aggrtol | tolerance for bound distances used to select continuous variable in current aggregated constraint to be eliminated
Range: [0, ∞] | 0.01 |
| separating/aggregation/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/aggregation/densityoffset | additional number of variables allowed in row on top of density
Range: {0, ..., ∞} | 100 |
| separating/aggregation/densityscore | weight of row density in the aggregation scoring of the rows
Range: [0, ∞] | 0.0001 |
| separating/aggregation/expbackoff | base for exponential increase of frequency at which separator <aggregation> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/aggregation/fixintegralrhs | should an additional variable be complemented if f0 = 0?
Range: boolean | 1 |
| separating/aggregation/maxaggdensity | maximal density of aggregated row
Range: [0, 1] | 0.2 |
| separating/aggregation/maxaggrs | maximal number of aggregations for each row per separation round
Range: {0, ..., ∞} | 3 |
| separating/aggregation/maxaggrsroot | maximal number of aggregations for each row per separation round in the root node
Range: {0, ..., ∞} | 6 |
| separating/aggregation/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <aggregation> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| separating/aggregation/maxfails | maximal number of consecutive unsuccessful aggregation tries (-1: unlimited)
Range: {-1, ..., ∞} | 20 |
| separating/aggregation/maxfailsroot | maximal number of consecutive unsuccessful aggregation tries in the root node (-1: unlimited)
Range: {-1, ..., ∞} | 100 |
| separating/aggregation/maxrowdensity | maximal density of row to be used in aggregation
Range: [0, 1] | 0.05 |
| separating/aggregation/maxrowfac | maximal row aggregation factor
Range: [0, ∞] | 10000 |
| separating/aggregation/maxslack | maximal slack of rows to be used in aggregation
Range: [0, ∞] | 0 |
| separating/aggregation/maxslackroot | maximal slack of rows to be used in aggregation in the root node
Range: [0, ∞] | 0.1 |
| separating/aggregation/maxtestdelta | maximal number of different deltas to try (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| separating/aggregation/maxtries | maximal number of rows to start aggregation with per separation round (-1: unlimited)
Range: {-1, ..., ∞} | 200 |
| separating/aggregation/maxtriesroot | maximal number of rows to start aggregation with per separation round in the root node (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| separating/aggregation/priority | priority of separator <aggregation>
Range: {-536870912, ..., 536870911} | -3000 |
| separating/aggregation/slackscore | weight of slack in the aggregation scoring of the rows
Range: [0, ∞] | 0.001 |
| separating/aggregation/trynegscaling | should negative values also be tested in scaling?
Range: boolean | 1 |
separating/cgmip
| Option | Description | Default |
| separating/cgmip/addviolationcons | add constraint to subscip that only allows violated cuts (otherwise add obj. limit)?
Range: boolean | 0 |
| separating/cgmip/addviolconshdlr | add constraint handler to filter out violated cuts?
Range: boolean | 0 |
| separating/cgmip/cmirownbounds | tell CMIR-generator which bounds to used in rounding?
Range: boolean | 0 |
| separating/cgmip/conshdlrusenorm | should the violation constraint handler use the norm of a cut to check for feasibility?
Range: boolean | 1 |
| separating/cgmip/contconvert | Convert some integral variables to be continuous to reduce the size of the sub-MIP?
Range: boolean | 0 |
| separating/cgmip/contconvfrac | fraction of integral variables converted to be continuous (if contconvert)
Range: [0, 1] | 0.1 |
| separating/cgmip/contconvmin | minimum number of integral variables before some are converted to be continuous
Range: {-1, ..., ∞} | 100 |
| separating/cgmip/decisiontree | Use decision tree to turn separation on/off?
Range: boolean | 0 |
| separating/cgmip/dynamiccuts | should generated cuts be removed from the LP if they are no longer tight?
Range: boolean | 1 |
| separating/cgmip/earlyterm | terminate separation if a violated (but possibly sub-optimal) cut has been found?
Range: boolean | 1 |
| separating/cgmip/freq | frequency for calling separator <cgmip> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | -1 |
| separating/cgmip/genprimalsols | Try to generate primal solutions from Gomory cuts?
Range: boolean | 0 |
| separating/cgmip/intconvert | Convert some integral variables attaining fractional values to have integral value?
Range: boolean | 0 |
| separating/cgmip/intconvfrac | fraction of frac. integral variables converted to have integral value (if intconvert)
Range: [0, 1] | 0.1 |
| separating/cgmip/intconvmin | minimum number of integral variables before some are converted to have integral value
Range: {-1, ..., ∞} | 100 |
| separating/cgmip/maxdepth | maximal depth at which the separator is applied (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| separating/cgmip/maxnodelimit | maximum number of nodes considered for sub-MIP (-1: unlimited)
Range: {-1, ..., ∞} | 5000 |
| separating/cgmip/maxrounds | maximal number of cgmip separation rounds per node (-1: unlimited)
Range: {-1, ..., ∞} | 5 |
| separating/cgmip/maxroundsroot | maximal number of cgmip separation rounds in the root node (-1: unlimited)
Range: {-1, ..., ∞} | 50 |
| separating/cgmip/maxrowage | maximal age of rows to consider if onlyactiverows is false
Range: {-1, ..., ∞} | -1 |
| separating/cgmip/minnodelimit | minimum number of nodes considered for sub-MIP (-1: unlimited)
Range: {-1, ..., ∞} | 500 |
| separating/cgmip/objlone | Should the objective of the sub-MIP minimize the l1-norm of the multipliers?
Range: boolean | 0 |
| separating/cgmip/objweightsize | Weight each row by its size?
Range: boolean | 1 |
| separating/cgmip/onlyactiverows | Use only active rows to generate cuts?
Range: boolean | 0 |
| separating/cgmip/onlyintvars | Generate cuts for problems with only integer variables?
Range: boolean | 0 |
| separating/cgmip/onlyrankone | Separate only rank 1 inequalities w.r.t. CG-MIP separator?
Range: boolean | 0 |
| separating/cgmip/output | Should information about the sub-MIP and cuts be displayed?
Range: boolean | 0 |
| separating/cgmip/primalseparation | only separate cuts that are tight for the best feasible solution?
Range: boolean | 1 |
| separating/cgmip/skipmultbounds | Skip the upper bounds on the multipliers in the sub-MIP?
Range: boolean | 1 |
| separating/cgmip/subscipfast | Should the settings for the sub-MIP be optimized for speed?
Range: boolean | 1 |
| separating/cgmip/usecmir | use CMIR-generator (otherwise add cut directly)?
Range: boolean | 1 |
| separating/cgmip/usecutpool | use cutpool to store CG-cuts even if the are not efficient?
Range: boolean | 1 |
| separating/cgmip/useobjlb | Use lower bound on objective function (via primal solution)?
Range: boolean | 0 |
| separating/cgmip/useobjub | Use upper bound on objective function (via primal solution)?
Range: boolean | 0 |
| separating/cgmip/usestrongcg | use strong CG-function to strengthen cut?
Range: boolean | 0 |
| Options for expert users |
| separating/cgmip/cutcoefbnd | bounds on the values of the coefficients in the CG-cut
Range: [0, ∞] | 1000 |
| separating/cgmip/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/cgmip/expbackoff | base for exponential increase of frequency at which separator <cgmip> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/cgmip/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <cgmip> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 0 |
| separating/cgmip/memorylimit | memory limit for sub-MIP
Range: [0, ∞] | ∞ |
| separating/cgmip/objweight | weight used for the row combination coefficient in the sub-MIP objective
Range: [0, ∞] | 0.001 |
| separating/cgmip/priority | priority of separator <cgmip>
Range: {-536870912, ..., 536870911} | -1000 |
| separating/cgmip/timelimit | time limit for sub-MIP
Range: [0, ∞] | ∞ |
separating/clique
| Option | Description | Default |
| separating/clique/freq | frequency for calling separator <clique> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 0 |
| separating/clique/maxsepacuts | maximal number of clique cuts separated per separation round (-1: no limit)
Range: {-1, ..., ∞} | 10 |
| Options for expert users |
| separating/clique/backtrackfreq | frequency for premature backtracking up to tree level 1 (0: no backtracking)
Range: {0, ..., ∞} | 1000 |
| separating/clique/cliquedensity | minimal density of cliques to use a dense clique table
Range: [0, 1] | 0 |
| separating/clique/cliquetablemem | maximal memory size of dense clique table (in kb)
Range: [0, 2.09715e+06] | 20000 |
| separating/clique/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/clique/expbackoff | base for exponential increase of frequency at which separator <clique> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/clique/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <clique> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 0 |
| separating/clique/maxtreenodes | maximal number of nodes in branch and bound tree (-1: no limit)
Range: {-1, ..., ∞} | 10000 |
| separating/clique/maxzeroextensions | maximal number of zero-valued variables extending the clique (-1: no limit)
Range: {-1, ..., ∞} | 1000 |
| separating/clique/priority | priority of separator <clique>
Range: {-536870912, ..., 536870911} | -5000 |
| separating/clique/scaleval | factor for scaling weights
Range: [1, ∞] | 1000 |
separating/closecuts
| Option | Description | Default |
| separating/closecuts/freq | frequency for calling separator <closecuts> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | -1 |
| Options for expert users |
| separating/closecuts/closethres | threshold on number of generated cuts below which the ordinary separation is started
Range: {-1, ..., ∞} | 50 |
| separating/closecuts/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/closecuts/expbackoff | base for exponential increase of frequency at which separator <closecuts> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/closecuts/inclobjcutoff | include an objective cutoff when computing the relative interior?
Range: boolean | 0 |
| separating/closecuts/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <closecuts> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| separating/closecuts/maxlpiterfactor | factor for maximal LP iterations in relative interior computation compared to node LP iterations (negative for no limit)
Range: [-1, ∞] | 10 |
| separating/closecuts/maxunsuccessful | turn off separation in current node after unsuccessful calls (-1 never turn off)
Range: {-1, ..., ∞} | 0 |
| separating/closecuts/priority | priority of separator <closecuts>
Range: {-536870912, ..., 536870911} | 1000000 |
| separating/closecuts/recomputerelint | recompute relative interior point in each separation call?
Range: boolean | 0 |
| separating/closecuts/sepacombvalue | convex combination value for close cuts
Range: [0, 1] | 0.3 |
| separating/closecuts/separelint | generate close cuts w.r.t. relative interior point (best solution otherwise)?
Range: boolean | 1 |
separating/cmir
| Option | Description | Default |
| separating/cmir/freq | frequency for calling separator <cmir> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 10 |
| Options for expert users |
| separating/cmir/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/cmir/expbackoff | base for exponential increase of frequency at which separator <cmir> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/cmir/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <cmir> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 0 |
| separating/cmir/priority | priority of separator <cmir>
Range: {-536870912, ..., 536870911} | -100000 |
separating/convexproj
| Option | Description | Default |
| separating/convexproj/freq | frequency for calling separator <convexproj> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | -1 |
| separating/convexproj/maxdepth | maximal depth at which the separator is applied (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| Options for expert users |
| separating/convexproj/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 1 |
| separating/convexproj/expbackoff | base for exponential increase of frequency at which separator <convexproj> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/convexproj/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <convexproj> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| separating/convexproj/nlpiterlimit | iteration limit of NLP solver; 0 for no limit
Range: {0, ..., ∞} | 250 |
| separating/convexproj/priority | priority of separator <convexproj>
Range: {-536870912, ..., 536870911} | 0 |
separating/disjunctive
| Option | Description | Default |
| separating/disjunctive/freq | frequency for calling separator <disjunctive> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 0 |
| separating/disjunctive/maxrank | maximal rank of a disj. cut that could not be scaled to integral coefficients (-1: unlimited)
Range: {-1, ..., ∞} | 20 |
| separating/disjunctive/maxrankintegral | maximal rank of a disj. cut that could be scaled to integral coefficients (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| Options for expert users |
| separating/disjunctive/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 1 |
| separating/disjunctive/expbackoff | base for exponential increase of frequency at which separator <disjunctive> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/disjunctive/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <disjunctive> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 0 |
| separating/disjunctive/maxconfsdelay | delay separation if number of conflict graph edges is larger than predefined value (-1: no limit)
Range: {-1, ..., ∞} | 100000 |
| separating/disjunctive/maxdepth | node depth of separating bipartite disjunctive cuts (-1: no limit)
Range: {-1, ..., ∞} | -1 |
| separating/disjunctive/maxinvcuts | maximal number of cuts investigated per iteration in a branching node
Range: {0, ..., ∞} | 50 |
| separating/disjunctive/maxinvcutsroot | maximal number of cuts investigated per iteration in the root node
Range: {0, ..., ∞} | 250 |
| separating/disjunctive/maxrounds | maximal number of separation rounds per iteration in a branching node (-1: no limit)
Range: {-1, ..., ∞} | 25 |
| separating/disjunctive/maxroundsroot | maximal number of separation rounds in the root node (-1: no limit)
Range: {-1, ..., ∞} | 100 |
| separating/disjunctive/maxweightrange | maximal valid range max(|weights|)/min(|weights|) of row weights
Range: [1, ∞] | 1000 |
| separating/disjunctive/priority | priority of separator <disjunctive>
Range: {-536870912, ..., 536870911} | 10 |
| separating/disjunctive/strengthen | strengthen cut if integer variables are present.
Range: boolean | 1 |
separating/eccuts
| Option | Description | Default |
| separating/eccuts/cutmaxrange | maximal coef. range of a cut (max coef. divided by min coef.) in order to be added to LP relaxation
Range: [0, ∞] | 1e+07 |
| separating/eccuts/dynamiccuts | should generated cuts be removed from the LP if they are no longer tight?
Range: boolean | 1 |
| separating/eccuts/freq | frequency for calling separator <eccuts> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | -1 |
| separating/eccuts/maxdepth | maximal depth at which the separator is applied (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| separating/eccuts/maxrounds | maximal number of eccuts separation rounds per node (-1: unlimited)
Range: {-1, ..., ∞} | 10 |
| separating/eccuts/maxroundsroot | maximal number of eccuts separation rounds in the root node (-1: unlimited)
Range: {-1, ..., ∞} | 250 |
| separating/eccuts/maxsepacuts | maximal number of edge-concave cuts separated per separation round
Range: {0, ..., ∞} | 10 |
| separating/eccuts/maxsepacutsroot | maximal number of edge-concave cuts separated per separation round in the root node
Range: {0, ..., ∞} | 50 |
| separating/eccuts/minviolation | minimal violation of an edge-concave cut to be separated
Range: [0, 0.5] | 0.3 |
| Options for expert users |
| separating/eccuts/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/eccuts/expbackoff | base for exponential increase of frequency at which separator <eccuts> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/eccuts/maxaggrsize | search for edge-concave aggregations of at most this size
Range: {3, ..., 5} | 4 |
| separating/eccuts/maxbilinterms | maximum number of bilinear terms allowed to be in a quadratic constraint
Range: {0, ..., ∞} | 500 |
| separating/eccuts/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <eccuts> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| separating/eccuts/maxstallrounds | maximum number of unsuccessful rounds in the edge-concave aggregation search
Range: {0, ..., ∞} | 5 |
| separating/eccuts/minaggrsize | search for edge-concave aggregations of at least this size
Range: {3, ..., 5} | 3 |
| separating/eccuts/priority | priority of separator <eccuts>
Range: {-536870912, ..., 536870911} | -13000 |
separating/flowcover
| Option | Description | Default |
| separating/flowcover/freq | frequency for calling separator <flowcover> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 10 |
| Options for expert users |
| separating/flowcover/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/flowcover/expbackoff | base for exponential increase of frequency at which separator <flowcover> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/flowcover/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <flowcover> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 0 |
| separating/flowcover/priority | priority of separator <flowcover>
Range: {-536870912, ..., 536870911} | -100000 |
separating/gauge
| Option | Description | Default |
| separating/gauge/freq | frequency for calling separator <gauge> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | -1 |
| Options for expert users |
| separating/gauge/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/gauge/expbackoff | base for exponential increase of frequency at which separator <gauge> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/gauge/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <gauge> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| separating/gauge/nlpiterlimit | iteration limit of NLP solver; 0 for no limit
Range: {0, ..., ∞} | 1000 |
| separating/gauge/priority | priority of separator <gauge>
Range: {-536870912, ..., 536870911} | 0 |
separating/gomory
| Option | Description | Default |
| separating/gomory/away | minimal integrality violation of a basis variable in order to try Gomory cut
Range: [0.0001, 0.5] | 0.01 |
| separating/gomory/dynamiccuts | should generated cuts be removed from the LP if they are no longer tight?
Range: boolean | 1 |
| separating/gomory/freq | frequency for calling separator <gomory> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 10 |
| separating/gomory/maxrank | maximal rank of a gomory cut that could not be scaled to integral coefficients (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| separating/gomory/maxrankintegral | maximal rank of a gomory cut that could be scaled to integral coefficients (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| separating/gomory/maxrounds | maximal number of gomory separation rounds per node (-1: unlimited)
Range: {-1, ..., ∞} | 5 |
| separating/gomory/maxroundsroot | maximal number of gomory separation rounds in the root node (-1: unlimited)
Range: {-1, ..., ∞} | 10 |
| separating/gomory/maxsepacuts | maximal number of gomory cuts separated per separation round
Range: {0, ..., ∞} | 50 |
| separating/gomory/maxsepacutsroot | maximal number of gomory cuts separated per separation round in the root node
Range: {0, ..., ∞} | 200 |
| Options for expert users |
| separating/gomory/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/gomory/delayedcuts | should cuts be added to the delayed cut pool?
Range: boolean | 0 |
| separating/gomory/expbackoff | base for exponential increase of frequency at which separator <gomory> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/gomory/forcecuts | if conversion to integral coefficients failed still consider the cut
Range: boolean | 1 |
| separating/gomory/genbothgomscg | Should both Gomory and strong CG cuts be generated (otherwise take best)?
Range: boolean | 1 |
| separating/gomory/makeintegral | try to scale cuts to integral coefficients
Range: boolean | 0 |
| separating/gomory/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <gomory> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| separating/gomory/priority | priority of separator <gomory>
Range: {-536870912, ..., 536870911} | -1000 |
| separating/gomory/separaterows | separate rows with integral slack
Range: boolean | 1 |
| separating/gomory/sidetypebasis | choose side types of row (lhs/rhs) based on basis information?
Range: boolean | 1 |
| separating/gomory/trystrongcg | try to generate strengthened Chvatal-Gomory cuts?
Range: boolean | 1 |
separating/gomorymi
| Option | Description | Default |
| separating/gomorymi/freq | frequency for calling separator <gomorymi> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 10 |
| Options for expert users |
| separating/gomorymi/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/gomorymi/expbackoff | base for exponential increase of frequency at which separator <gomorymi> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/gomorymi/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <gomorymi> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 0 |
| separating/gomorymi/priority | priority of separator <gomorymi>
Range: {-536870912, ..., 536870911} | -100000 |
separating/impliedbounds
| Option | Description | Default |
| separating/impliedbounds/freq | frequency for calling separator <impliedbounds> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 10 |
| Options for expert users |
| separating/impliedbounds/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/impliedbounds/expbackoff | base for exponential increase of frequency at which separator <impliedbounds> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/impliedbounds/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <impliedbounds> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| separating/impliedbounds/priority | priority of separator <impliedbounds>
Range: {-536870912, ..., 536870911} | -50 |
| separating/impliedbounds/usetwosizecliques | should violated inequalities for cliques with 2 variables be separated?
Range: boolean | 1 |
separating/interminor
| Option | Description | Default |
| separating/interminor/freq | frequency for calling separator <interminor> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | -1 |
| separating/interminor/maxrounds | maximal number of separation rounds per node (-1: unlimited)
Range: {-1, ..., ∞} | 10 |
| separating/interminor/maxroundsroot | maximal number of separation rounds in the root node (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| separating/interminor/mincutviol | minimum required violation of a cut
Range: [0, ∞] | 0.0001 |
| separating/interminor/usebounds | whether to also enforce nonegativity bounds of principle minors
Range: boolean | 0 |
| separating/interminor/usestrengthening | whether to use strengthened intersection cuts to separate minors
Range: boolean | 0 |
| Options for expert users |
| separating/interminor/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/interminor/expbackoff | base for exponential increase of frequency at which separator <interminor> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/interminor/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <interminor> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| separating/interminor/priority | priority of separator <interminor>
Range: {-536870912, ..., 536870911} | 0 |
separating/intobj
| Option | Description | Default |
| separating/intobj/freq | frequency for calling separator <intobj> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | -1 |
| Options for expert users |
| separating/intobj/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/intobj/expbackoff | base for exponential increase of frequency at which separator <intobj> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/intobj/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <intobj> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 0 |
| separating/intobj/priority | priority of separator <intobj>
Range: {-536870912, ..., 536870911} | -100 |
separating/knapsackcover
| Option | Description | Default |
| separating/knapsackcover/freq | frequency for calling separator <knapsackcover> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 10 |
| Options for expert users |
| separating/knapsackcover/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/knapsackcover/expbackoff | base for exponential increase of frequency at which separator <knapsackcover> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/knapsackcover/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <knapsackcover> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 0 |
| separating/knapsackcover/priority | priority of separator <knapsackcover>
Range: {-536870912, ..., 536870911} | -100000 |
separating/lagromory
| Option | Description | Default |
| separating/lagromory/away | minimal integrality violation of a basis variable to try separation
Range: [0, 1] | 0.01 |
| separating/lagromory/dualdegeneracyratethreshold | minimum dual degeneracy rate for separator execution
Range: [0, 1] | 0.5 |
| separating/lagromory/dynamiccuts | should generated cuts be removed from LP if they are no longer tight?
Range: boolean | 1 |
| separating/lagromory/freq | frequency for calling separator <lagromory> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | -1 |
| separating/lagromory/maxrounds | maximal number of separation rounds per node (-1: unlimited)
Range: {-1, ..., ∞} | 1 |
| separating/lagromory/maxroundsroot | maximal number of separation rounds in the root node (-1: unlimited)
Range: {-1, ..., ∞} | 1 |
| separating/lagromory/nmaxcutsperlp | maximal number of cuts separated per Lagromory LP in the non-root node
Range: {0, ..., ∞} | 10 |
| separating/lagromory/nmaxcutsperlproot | maximal number of cuts separated per Lagromory LP in the root node
Range: {0, ..., ∞} | 50 |
| separating/lagromory/perroundnmaxlpiters | maximal number of separating LP iterations per separation round (-1: unlimited)
Range: {-1, ..., ∞} | 50000 |
| separating/lagromory/varconsratiothreshold | minimum variable-constraint ratio on optimal face for separator execution
Range: [1, ∞] | 1 |
| Options for expert users |
| separating/lagromory/aggregatecuts | aggregate all generated cuts using the Lagrangian multipliers?
Range: boolean | 1 |
| separating/lagromory/allowlocal | should locally valid cuts be generated?
Range: boolean | 0 |
| separating/lagromory/constant | a constant for stablity center based stabilization of Lagrangian multipliers
Range: [2, ∞] | 2 |
| separating/lagromory/cutaddfreq | frequency of subgradient iterations for adding cuts to objective function
Range: {0, ..., ∞} | 1 |
| separating/lagromory/cutgenfreq | frequency of subgradient iterations for generating cuts
Range: {0, ..., ∞} | 1 |
| separating/lagromory/cutsfilterfactor | fraction of generated cuts per explored basis to accept from separator
Range: [0, 1] | 1 |
| separating/lagromory/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/lagromory/delayedcuts | should cuts be added to the delayed cut pool
Range: boolean | 0 |
| separating/lagromory/deltaslab1ub | factor of delta deciding larger increment of mu parameter (factor for step length)
Range: [0, 1] | 0.001 |
| separating/lagromory/deltaslab2ub | factor of delta deciding smaller increment of mu parameter (factor for step length)
Range: [0, 1] | 0.01 |
| separating/lagromory/expbackoff | base for exponential increase of frequency at which separator <lagromory> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/lagromory/forcecuts | force cuts to be added to the LP?
Range: boolean | 0 |
| separating/lagromory/makeintegral | try to scale all cuts to integral coefficients?
Range: boolean | 0 |
| separating/lagromory/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <lagromory> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| separating/lagromory/minrestart | minimum restart round for separator execution (0: from beginning of the instance solving, ≥ n with n ≥ 1: from restart round n)
Range: {0, ..., ∞} | 1 |
| separating/lagromory/mubacktrackfactor | factor of mu while backtracking the mu parameter (factor for step length)
Range: [0, 1] | 0.5 |
| separating/lagromory/muparamconst | is the mu parameter (factor for step length) constant?
Range: boolean | 1 |
| separating/lagromory/muparaminit | initial value of the mu parameter (factor for step length)
Range: [0, 100] | 0.01 |
| separating/lagromory/muparamlb | lower bound of the mu parameter (factor for step length)
Range: [0, 1] | 0 |
| separating/lagromory/muparamub | upper bound of the mu parameter (factor for step length)
Range: [1, 10] | 2 |
| separating/lagromory/muslab1factor | factor of mu parameter (factor for step length) for larger increment
Range: [0, ∞] | 10 |
| separating/lagromory/muslab2factor | factor of mu parameter (factor for step length) for smaller increment
Range: [0, ∞] | 2 |
| separating/lagromory/muslab3factor | factor of mu parameter (factor for step length) for reduction
Range: [0, ∞] | 0.5 |
| separating/lagromory/nmaxconsecitersformuupdate | consecutive number of iterations used to determine if mu needs to be backtracked
Range: {0, ..., ∞} | 10 |
| separating/lagromory/nmaxlagrangianvalsforavg | maximal number of iterations for rolling average of Lagrangian value
Range: {0, ..., ∞} | 2 |
| separating/lagromory/nmaxmainiters | maximal number of main loop iterations of the relax-and-cut algorithm
Range: {0, ..., ∞} | 4 |
| separating/lagromory/nmaxsubgradientiters | maximal number of subgradient loop iterations of the relax-and-cut algorithm
Range: {0, ..., ∞} | 6 |
| separating/lagromory/optimalfacepriority | priority of the optimal face for separator execution (0: low priority, 1: medium priority, 2: high priority)
Range: {0, ..., 2} | 2 |
| separating/lagromory/perlpiterfactor | factor w.r.t. non-root node LP iterations for iteration limit of each separating LP (negative for no limit)
Range: [-1, ∞] | 0.1 |
| separating/lagromory/perrootlpiterfactor | factor w.r.t. root node LP iterations for iteration limit of each separating LP (negative for no limit)
Range: [-1, ∞] | 0.2 |
| separating/lagromory/perroundcutsfactor | factor w.r.t. number of integer columns for number of cuts separated per separation round at a non-root node
Range: [0, ∞] | 0.5 |
| separating/lagromory/perroundcutsfactorroot | factor w.r.t. number of integer columns for number of cuts separated per separation round in root node
Range: [0, ∞] | 1 |
| separating/lagromory/perroundlpiterlimitfactor | factor w.r.t. root node LP iterations for maximal separating LP iterations per separation round (negative for no limit)
Range: [-1, ∞] | -1 |
| separating/lagromory/priority | priority of separator <lagromory>
Range: {-536870912, ..., 536870911} | -8000 |
| separating/lagromory/projectiontype | the ball into which the Lagrangian multipliers are projected for stabilization (0: no projection, 1: L1-norm ball projection, 2: L2-norm ball projection, 3: L_inf-norm ball projection)
Range: {0, ..., 3} | 2 |
| separating/lagromory/radiusinit | initial radius of the ball used in stabilization of Lagrangian multipliers
Range: [0, 1] | 0.5 |
| separating/lagromory/radiusmax | maximum radius of the ball used in stabilization of Lagrangian multipliers
Range: [0, ∞] | 20 |
| separating/lagromory/radiusmin | minimum radius of the ball used in stabilization of Lagrangian multipliers
Range: [0, ∞] | 1e-06 |
| separating/lagromory/radiusupdateweight | multiplier to evaluate cut violation score used for updating ball radius
Range: [0, 1] | 0.98 |
| separating/lagromory/rootlpiterlimitfactor | factor w.r.t. root node LP iterations for maximal separating LP iterations in the root node (negative for no limit)
Range: [-1, ∞] | -1 |
| separating/lagromory/separaterows | separate rows with integral slack?
Range: boolean | 1 |
| separating/lagromory/sidetypebasis | choose side types of row (lhs/rhs) based on basis information?
Range: boolean | 1 |
| separating/lagromory/sortcutoffsol | sort fractional integer columnsbased on fractionality?
Range: boolean | 1 |
| separating/lagromory/stabilitycentertype | type of stability center for taking weighted average of Lagrangian multipliers for stabilization (0: no weighted stabilization, 1: best Lagrangian multipliers)
Range: {0, ..., 1} | 1 |
| separating/lagromory/totalcutsfactor | factor w.r.t. number of integer columns for total number of cuts separated
Range: [0, ∞] | 50 |
| separating/lagromory/totallpiterlimitfactor | factor w.r.t. root node LP iterations for maximal separating LP iterations in the tree (negative for no limit)
Range: [-1, ∞] | -1 |
| separating/lagromory/ubparamnegfactor | factor for negative upper bound used as an estimate for the optimal Lagrangian dual value
Range: [0, 1] | 0.5 |
| separating/lagromory/ubparamposfactor | factor for positive upper bound used as an estimate for the optimal Lagrangian dual value
Range: [1, 100] | 2 |
separating/mcf
| Option | Description | Default |
| separating/mcf/dynamiccuts | should generated cuts be removed from the LP if they are no longer tight?
Range: boolean | 1 |
| separating/mcf/freq | frequency for calling separator <mcf> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 0 |
| separating/mcf/maxsepacuts | maximal number of mcf cuts separated per separation round
Range: {-1, ..., ∞} | 100 |
| separating/mcf/maxsepacutsroot | maximal number of mcf cuts separated per separation round in the root node – default separation
Range: {-1, ..., ∞} | 200 |
| Options for expert users |
| separating/mcf/checkcutshoreconnectivity | should we separate only if the cuts shores are connected?
Range: boolean | 1 |
| separating/mcf/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/mcf/expbackoff | base for exponential increase of frequency at which separator <mcf> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/mcf/fixintegralrhs | should an additional variable be complemented if f0 = 0?
Range: boolean | 1 |
| separating/mcf/maxarcinconsistencyratio | maximum inconsistency ratio of arcs not to be deleted
Range: [0, ∞] | 0.5 |
| separating/mcf/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <mcf> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 0 |
| separating/mcf/maxinconsistencyratio | maximum inconsistency ratio for separation at all
Range: [0, ∞] | 0.02 |
| separating/mcf/maxtestdelta | maximal number of different deltas to try (-1: unlimited) – default separation
Range: {-1, ..., ∞} | 20 |
| separating/mcf/maxweightrange | maximal valid range max(|weights|)/min(|weights|) of row weights
Range: [1, ∞] | 1e+06 |
| separating/mcf/modeltype | model type of network (0: auto, 1:directed, 2:undirected)
Range: {0, ..., 2} | 0 |
| separating/mcf/nclusters | number of clusters to generate in the shrunken network – default separation
Range: {2, ..., 32} | 5 |
| separating/mcf/priority | priority of separator <mcf>
Range: {-536870912, ..., 536870911} | -10000 |
| separating/mcf/separateflowcutset | should we separate flowcutset inequalities on the network cuts?
Range: boolean | 1 |
| separating/mcf/separateknapsack | should we separate knapsack cover inequalities on the network cuts?
Range: boolean | 1 |
| separating/mcf/separatesinglenodecuts | should we separate inequalities based on single-node cuts?
Range: boolean | 1 |
| separating/mcf/trynegscaling | should negative values also be tested in scaling?
Range: boolean | 0 |
separating/minor
| Option | Description | Default |
| separating/minor/freq | frequency for calling separator <minor> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 10 |
| separating/minor/ignorepackingconss | whether to ignore circle packing constraints during minor detection
Range: boolean | 1 |
| separating/minor/maxminorsconst | constant for the maximum number of minors, i.e., max(const, fac * # quadratic terms)
Range: {0, ..., ∞} | 3000 |
| separating/minor/maxminorsfac | factor for the maximum number of minors, i.e., max(const, fac * # quadratic terms)
Range: [0, ∞] | 10 |
| separating/minor/maxrounds | maximal number of separation rounds per node (-1: unlimited)
Range: {-1, ..., ∞} | 10 |
| separating/minor/maxroundsroot | maximal number of separation rounds in the root node (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| separating/minor/mincutviol | minimum required violation of a cut
Range: [0, ∞] | 0.0001 |
| Options for expert users |
| separating/minor/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/minor/expbackoff | base for exponential increase of frequency at which separator <minor> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/minor/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <minor> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| separating/minor/priority | priority of separator <minor>
Range: {-536870912, ..., 536870911} | 0 |
separating/mixing
| Option | Description | Default |
| separating/mixing/freq | frequency for calling separator <mixing> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 10 |
| separating/mixing/maxnunsuccessful | maximal number of consecutive unsuccessful iterations
Range: {-1, ..., ∞} | 10 |
| separating/mixing/maxrounds | maximal number of mixing separation rounds per node (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| separating/mixing/maxroundsroot | maximal number of mixing separation rounds in the root node (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| Options for expert users |
| separating/mixing/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/mixing/expbackoff | base for exponential increase of frequency at which separator <mixing> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/mixing/iscutsonints | Should general integer variables be used to generate cuts?
Range: boolean | 0 |
| separating/mixing/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <mixing> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| separating/mixing/priority | priority of separator <mixing>
Range: {-536870912, ..., 536870911} | -50 |
| separating/mixing/uselocalbounds | Should local bounds be used?
Range: boolean | 0 |
separating/oddcycle
| Option | Description | Default |
| separating/oddcycle/freq | frequency for calling separator <oddcycle> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | -1 |
| separating/oddcycle/liftoddcycles | Should odd cycle cuts be lifted?
Range: boolean | 0 |
| separating/oddcycle/maxrounds | maximal number of oddcycle separation rounds per node (-1: unlimited)
Range: {-1, ..., ∞} | 10 |
| separating/oddcycle/maxroundsroot | maximal number of oddcycle separation rounds in the root node (-1: unlimited)
Range: {-1, ..., ∞} | 10 |
| separating/oddcycle/maxsepacuts | maximal number of oddcycle cuts separated per separation round
Range: {0, ..., ∞} | 5000 |
| separating/oddcycle/maxsepacutsroot | maximal number of oddcycle cuts separated per separation round in the root node
Range: {0, ..., ∞} | 5000 |
| separating/oddcycle/usegls | Should the search method by Groetschel, Lovasz, Schrijver be used? Otherwise use levelgraph method by Hoffman, Padberg.
Range: boolean | 1 |
| Options for expert users |
| separating/oddcycle/addselfarcs | add links between a variable and its negated
Range: boolean | 1 |
| separating/oddcycle/allowmultiplecuts | Even if a variable is already covered by a cut, still allow another cut to cover it too?
Range: boolean | 1 |
| separating/oddcycle/cutthreshold | maximal number of other cuts s.t. separation is applied (-1 for direct call)
Range: {-1, ..., ∞} | -1 |
| separating/oddcycle/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/oddcycle/expbackoff | base for exponential increase of frequency at which separator <oddcycle> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/oddcycle/includetriangles | separate triangles found as 3-cycles or repaired larger cycles
Range: boolean | 1 |
| separating/oddcycle/lpliftcoef | Choose lifting candidate by coef*lpvalue or only by coef?
Range: boolean | 0 |
| separating/oddcycle/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <oddcycle> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| separating/oddcycle/maxcutslevel | maximal number of oddcycle cuts generated in every level of the level graph
Range: {0, ..., ∞} | 50 |
| separating/oddcycle/maxcutsroot | maximal number of oddcycle cuts generated per chosen variable as root of the level graph
Range: {0, ..., ∞} | 1 |
| separating/oddcycle/maxnlevels | maximal number of levels in level graph
Range: {0, ..., ∞} | 20 |
| separating/oddcycle/maxpernodeslevel | percentage of nodes allowed in the same level of the level graph [0-100]
Range: {0, ..., 100} | 100 |
| separating/oddcycle/maxreference | minimal weight on an edge (in level graph or bipartite graph)
Range: {0, ..., ∞} | 0 |
| separating/oddcycle/maxunsucessfull | number of unsuccessful calls at current node
Range: {0, ..., ∞} | 3 |
| separating/oddcycle/multiplecuts | Even if a variable is already covered by a cut, still try it as start node for a cycle search?
Range: boolean | 0 |
| separating/oddcycle/offsetnodeslevel | offset of nodes allowed in the same level of the level graph (additional to the percentage of levelnodes)
Range: {0, ..., ∞} | 10 |
| separating/oddcycle/offsettestvars | offset of variables to try the chosen method on (additional to the percentage of testvars)
Range: {0, ..., ∞} | 100 |
| separating/oddcycle/percenttestvars | percentage of variables to try the chosen method on [0-100]
Range: {0, ..., 100} | 0 |
| separating/oddcycle/priority | priority of separator <oddcycle>
Range: {-536870912, ..., 536870911} | -15000 |
| separating/oddcycle/recalcliftcoef | Calculate lifting coefficient of every candidate in every step (or only if its chosen)?
Range: boolean | 1 |
| separating/oddcycle/repaircycles | try to repair violated cycles with double appearance of a variable
Range: boolean | 1 |
| separating/oddcycle/scalingfactor | factor for scaling of the arc-weights
Range: {1, ..., ∞} | 1000 |
| separating/oddcycle/sortrootneighbors | sort level of the root neighbors by fractionality (maxfrac)
Range: boolean | 1 |
| separating/oddcycle/sortswitch | use sorted variable array (unsorted(0), maxlp(1), minlp(2), maxfrac(3), minfrac(4))
Range: {0, ..., 4} | 3 |
separating/rapidlearning
| Option | Description | Default |
| separating/rapidlearning/freq | frequency for calling separator <rapidlearning> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 5 |
| Options for expert users |
| separating/rapidlearning/applybdchgs | should the found global bound deductions be applied in the original SCIP?
Range: boolean | 1 |
| separating/rapidlearning/applyconflicts | should the found conflicts be applied in the original SCIP?
Range: boolean | 1 |
| separating/rapidlearning/applyinfervals | should the inference values be used as initialization in the original SCIP?
Range: boolean | 1 |
| separating/rapidlearning/applyprimalsol | should the incumbent solution be copied to the original SCIP?
Range: boolean | 1 |
| separating/rapidlearning/applysolved | should a solved status be copied to the original SCIP?
Range: boolean | 1 |
| separating/rapidlearning/checkdegeneracy | should local LP degeneracy be checked?
Range: boolean | 1 |
| separating/rapidlearning/checkdualbound | should the progress on the dual bound be checked?
Range: boolean | 0 |
| separating/rapidlearning/checkexec | check whether rapid learning should be executed
Range: boolean | 1 |
| separating/rapidlearning/checkleaves | should the ratio of leaves proven to be infeasible and exceeding the cutoff bound be checked?
Range: boolean | 0 |
| separating/rapidlearning/checknsols | should the number of solutions found so far be checked?
Range: boolean | 1 |
| separating/rapidlearning/checkobj | should the (local) objective function be checked?
Range: boolean | 0 |
| separating/rapidlearning/contvars | should rapid learning be applied when there are continuous variables?
Range: boolean | 0 |
| separating/rapidlearning/contvarsquot | maximal portion of continuous variables to apply rapid learning
Range: [0, 1] | 0.3 |
| separating/rapidlearning/copycuts | should all active cuts from cutpool be copied to constraints in subproblem?
Range: boolean | 1 |
| separating/rapidlearning/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/rapidlearning/expbackoff | base for exponential increase of frequency at which separator <rapidlearning> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/rapidlearning/lpiterquot | maximal fraction of LP iterations compared to node LP iterations
Range: [0, ∞] | 0.2 |
| separating/rapidlearning/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <rapidlearning> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| separating/rapidlearning/maxcalls | maximum number of overall calls
Range: {0, ..., ∞} | 100 |
| separating/rapidlearning/maxnconss | maximum problem size (constraints) for which rapid learning will be called
Range: {0, ..., ∞} | 10000 |
| separating/rapidlearning/maxnodes | maximum number of nodes considered in rapid learning run
Range: {0, ..., ∞} | 5000 |
| separating/rapidlearning/maxnvars | maximum problem size (variables) for which rapid learning will be called
Range: {0, ..., ∞} | 10000 |
| separating/rapidlearning/mindegeneracy | minimal degeneracy threshold to allow local rapid learning
Range: [0, 1] | 0.7 |
| separating/rapidlearning/mininflpratio | minimal threshold of inf/obj leaves to allow local rapid learning
Range: [0, ∞] | 10 |
| separating/rapidlearning/minnodes | minimum number of nodes considered in rapid learning run
Range: {0, ..., ∞} | 500 |
| separating/rapidlearning/minvarconsratio | minimal ratio of unfixed variables in relation to basis size to allow local rapid learning
Range: [1, ∞] | 2 |
| separating/rapidlearning/nwaitingnodes | number of nodes that should be processed before rapid learning is executed locally based on the progress of the dualbound
Range: {0, ..., ∞} | 100 |
| separating/rapidlearning/priority | priority of separator <rapidlearning>
Range: {-536870912, ..., 536870911} | -1200000 |
| separating/rapidlearning/reducedinfer | should the inference values only be used when rapidlearning found other reductions?
Range: boolean | 0 |
separating/rlt
| Option | Description | Default |
| separating/rlt/addtopool | if set to true, globally valid RLT cuts are added to the global cut pool
Range: boolean | 1 |
| separating/rlt/detecthidden | if set to true, hidden products are detected and separated by McCormick cuts
Range: boolean | 0 |
| separating/rlt/freq | frequency for calling separator <rlt> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 0 |
| separating/rlt/hiddenrlt | whether RLT cuts (TRUE) or only McCormick inequalities (FALSE) should be added for hidden products
Range: boolean | 0 |
| separating/rlt/maxncuts | maximal number of rlt-cuts that are added per round (-1: unlimited)
Range: {-1, ..., ∞} | -1 |
| separating/rlt/maxrounds | maximal number of separation rounds per node (-1: unlimited)
Range: {-1, ..., ∞} | 1 |
| separating/rlt/maxroundsroot | maximal number of separation rounds in the root node (-1: unlimited)
Range: {-1, ..., ∞} | 10 |
| separating/rlt/maxunknownterms | maximal number of unknown bilinear terms a row is still used with (-1: unlimited)
Range: {-1, ..., ∞} | 0 |
| separating/rlt/maxusedvars | maximal number of variables used to compute rlt cuts (-1: unlimited)
Range: {-1, ..., ∞} | 100 |
| separating/rlt/onlycontrows | if set to true, only continuous rows are used for rlt cuts
Range: boolean | 0 |
| separating/rlt/onlyeqrows | if set to true, only equality rows are used for rlt cuts
Range: boolean | 0 |
| separating/rlt/onlyoriginal | if set to true, only original rows and variables are used
Range: boolean | 1 |
| separating/rlt/useinsubscip | if set to true, rlt is also used in sub-scips
Range: boolean | 0 |
| separating/rlt/useprojection | if set to true, projected rows are checked first
Range: boolean | 0 |
| Options for expert users |
| separating/rlt/badscore | threshold for score of cut relative to best score to be discarded
Range: [0, 1] | 0.5 |
| separating/rlt/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/rlt/dircutoffdistweight | weight of directed cutoff distance in cut score calculation
Range: [0, 1] | 0 |
| separating/rlt/efficacyweight | weight of efficacy in cut score calculation
Range: [0, 1] | 1 |
| separating/rlt/expbackoff | base for exponential increase of frequency at which separator <rlt> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/rlt/goodmaxparall | maximum parallelism for good cuts
Range: [0, 1] | 0.1 |
| separating/rlt/goodscore | threshold for score of cut relative to best score to be considered good, so that less strict filtering is applied
Range: [0, 1] | 1 |
| separating/rlt/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <rlt> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| separating/rlt/maxparall | maximum parallelism for non-good cuts
Range: [0, 1] | 0.1 |
| separating/rlt/objparalweight | weight of objective parallelism in cut score calculation
Range: [0, 1] | 0 |
| separating/rlt/priority | priority of separator <rlt>
Range: {-536870912, ..., 536870911} | 10 |
separating/strongcg
| Option | Description | Default |
| separating/strongcg/freq | frequency for calling separator <strongcg> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 10 |
| Options for expert users |
| separating/strongcg/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/strongcg/expbackoff | base for exponential increase of frequency at which separator <strongcg> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/strongcg/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <strongcg> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 0 |
| separating/strongcg/priority | priority of separator <strongcg>
Range: {-536870912, ..., 536870911} | -100000 |
separating/zerohalf
| Option | Description | Default |
| separating/zerohalf/dynamiccuts | should generated cuts be removed from the LP if they are no longer tight?
Range: boolean | 1 |
| separating/zerohalf/freq | frequency for calling separator <zerohalf> (-1: never, 0: only in root node)
Range: {-1, ..., 1073741822} | 10 |
| separating/zerohalf/initseed | initial seed used for random tie-breaking in cut selection
Range: {0, ..., ∞} | 24301 |
| separating/zerohalf/maxcutcands | maximal number of zerohalf cuts considered per separation round
Range: {0, ..., ∞} | 2000 |
| separating/zerohalf/maxrounds | maximal number of zerohalf separation rounds per node (-1: unlimited)
Range: {-1, ..., ∞} | 5 |
| separating/zerohalf/maxroundsroot | maximal number of zerohalf separation rounds in the root node (-1: unlimited)
Range: {-1, ..., ∞} | 20 |
| separating/zerohalf/maxsepacuts | maximal number of zerohalf cuts separated per separation round
Range: {0, ..., ∞} | 20 |
| separating/zerohalf/maxsepacutsroot | maximal number of zerohalf cuts separated per separation round in the root node
Range: {0, ..., ∞} | 100 |
| Options for expert users |
| separating/zerohalf/badscore | threshold for score of cut relative to best score to be discarded
Range: [0, 1] | 0.5 |
| separating/zerohalf/delay | should separator be delayed, if other separators found cuts?
Range: boolean | 0 |
| separating/zerohalf/densityoffset | additional number of variables allowed in row on top of density
Range: {0, ..., ∞} | 100 |
| separating/zerohalf/dircutoffdistweight | weight of directed cutoff distance in cut score calculation
Range: [0, 1] | 0 |
| separating/zerohalf/efficacyweight | weight of efficacy in cut score calculation
Range: [0, 1] | 1 |
| separating/zerohalf/expbackoff | base for exponential increase of frequency at which separator <zerohalf> is called (1: call at each multiple of frequency)
Range: {1, ..., 100} | 4 |
| separating/zerohalf/goodmaxparall | maximum parallelism for good cuts
Range: [0, 1] | 0.1 |
| separating/zerohalf/goodscore | threshold for score of cut relative to best score to be considered good, so that less strict filtering is applied
Range: [0, 1] | 1 |
| separating/zerohalf/maxbounddist | maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <zerohalf> (0.0: only on current best node, 1.0: on all nodes)
Range: [0, 1] | 1 |
| separating/zerohalf/maxparall | maximum parallelism for non-good cuts
Range: [0, 1] | 0.1 |
| separating/zerohalf/maxrowdensity | maximal density of row to be used in aggregation
Range: [0, 1] | 0.05 |
| separating/zerohalf/maxslack | maximal slack of rows to be used in aggregation
Range: [0, ∞] | 0 |
| separating/zerohalf/maxslackroot | maximal slack of rows to be used in aggregation in the root node
Range: [0, ∞] | 0 |
| separating/zerohalf/minviol | minimal violation to generate zerohalfcut for
Range: [0, ∞] | 0.1 |
| separating/zerohalf/objparalweight | weight of objective parallelism in cut score calculation
Range: [0, 1] | 0 |
| separating/zerohalf/priority | priority of separator <zerohalf>
Range: {-536870912, ..., 536870911} | -6000 |
solvingphases
| Option | Description | Default |
| solvingphases/enabled | should the event handler adapt the solver behavior?
Range: boolean | 0 |
| solvingphases/fallback | should the event handler fall back from optimal phase?
Range: boolean | 0 |
| solvingphases/feassetname | settings file for feasibility phase – precedence over emphasis settings
Range: string | - |
| solvingphases/improvesetname | settings file for improvement phase – precedence over emphasis settings
Range: string | - |
| solvingphases/interruptoptimal | should the event handler interrupt the solving process after optimal solution was found?
Range: boolean | 0 |
| solvingphases/nodeoffset | node offset for rank-1 and estimate transitions
Range: {1, ..., ∞} | 50 |
| solvingphases/optimalvalue | optimal solution value for problem
Range: real | ∞ |
| solvingphases/proofsetname | settings file for proof phase – precedence over emphasis settings
Range: string | - |
| solvingphases/testmode | should the event handler test all phase transitions?
Range: boolean | 0 |
| solvingphases/transitionmethod | transition method: Possible options are 'e'stimate,'l'ogarithmic regression,'o'ptimal-value based,'r'ank-1
Range: e, l, o, r | r |
| solvingphases/useemphsettings | should emphasis settings for the solving phases be used, or settings files?
Range: boolean | 1 |
| solvingphases/userestart1to2 | should a restart be applied between the feasibility and improvement phase?
Range: boolean | 0 |
| solvingphases/userestart2to3 | should a restart be applied between the improvement and the proof phase?
Range: boolean | 0 |
| solvingphases/xtype | x-type for logarithmic regression - (t)ime, (n)odes, (l)p iterations
Range: l, n, t | n |
table/branchrules
| Option | Description | Default |
| table/branchrules/active | is statistics table <branchrules> active
Range: boolean | 1 |
table/compression
| Option | Description | Default |
| table/compression/active | is statistics table <compression> active
Range: boolean | 1 |
table/concurrentsolver
| Option | Description | Default |
| table/concurrentsolver/active | is statistics table <concurrentsolver> active
Range: boolean | 1 |
table/conflict
| Option | Description | Default |
| table/conflict/active | is statistics table <conflict> active
Range: boolean | 1 |
table/cons_nonlinear
| Option | Description | Default |
| table/cons_nonlinear/active | is statistics table <cons_nonlinear> active
Range: boolean | 0 |
table/constiming
| Option | Description | Default |
| table/constiming/active | is statistics table <constiming> active
Range: boolean | 1 |
table/constraint
| Option | Description | Default |
| table/constraint/active | is statistics table <constraint> active
Range: boolean | 1 |
table/cutsel
| Option | Description | Default |
| table/cutsel/active | is statistics table <cutsel> active
Range: boolean | 1 |
table/estim
| Option | Description | Default |
| table/estim/active | is statistics table <estim> active
Range: boolean | 1 |
table/exprhdlr
| Option | Description | Default |
| table/exprhdlr/active | is statistics table <exprhdlr> active
Range: boolean | 1 |
table/heuristics
| Option | Description | Default |
| table/heuristics/active | is statistics table <heuristics> active
Range: boolean | 1 |
table/lp
| Option | Description | Default |
| table/lp/active | is statistics table <lp> active
Range: boolean | 1 |
table/neighborhood
| Option | Description | Default |
| table/neighborhood/active | is statistics table <neighborhood> active
Range: boolean | 1 |
table/nlhdlr
| Option | Description | Default |
| table/nlhdlr/active | is statistics table <nlhdlr> active
Range: boolean | 1 |
table/nlhdlr_bilinear
| Option | Description | Default |
| table/nlhdlr_bilinear/active | is statistics table <nlhdlr_bilinear> active
Range: boolean | 0 |
table/nlhdlr_quadratic
| Option | Description | Default |
| table/nlhdlr_quadratic/active | is statistics table <nlhdlr_quadratic> active
Range: boolean | 0 |
table/nlp
| Option | Description | Default |
| table/nlp/active | is statistics table <nlp> active
Range: boolean | 1 |
table/nlpi
| Option | Description | Default |
| table/nlpi/active | is statistics table <nlpi> active
Range: boolean | 1 |
table/origprob
| Option | Description | Default |
| table/origprob/active | is statistics table <origprob> active
Range: boolean | 1 |
table/presolvedprob
| Option | Description | Default |
| table/presolvedprob/active | is statistics table <presolvedprob> active
Range: boolean | 1 |
table/presolver
| Option | Description | Default |
| table/presolver/active | is statistics table <presolver> active
Range: boolean | 1 |
table/pricer
| Option | Description | Default |
| table/pricer/active | is statistics table <pricer> active
Range: boolean | 1 |
table/propagator
| Option | Description | Default |
| table/propagator/active | is statistics table <propagator> active
Range: boolean | 1 |
table/relaxator
| Option | Description | Default |
| table/relaxator/active | is statistics table <relaxator> active
Range: boolean | 1 |
table/root
| Option | Description | Default |
| table/root/active | is statistics table <root> active
Range: boolean | 1 |
table/scheduler
| Option | Description | Default |
| table/scheduler/active | is statistics table <scheduler> active
Range: boolean | 1 |
table/separator
| Option | Description | Default |
| table/separator/active | is statistics table <separator> active
Range: boolean | 1 |
table/solution
| Option | Description | Default |
| table/solution/active | is statistics table <solution> active
Range: boolean | 1 |
table/status
| Option | Description | Default |
| table/status/active | is statistics table <status> active
Range: boolean | 1 |
table/symmetry
| Option | Description | Default |
| table/symmetry/active | is statistics table <symmetry> active
Range: boolean | 1 |
table/timing
| Option | Description | Default |
| table/timing/active | is statistics table <timing> active
Range: boolean | 1 |
table/tree
| Option | Description | Default |
| table/tree/active | is statistics table <tree> active
Range: boolean | 1 |
timing
| Option | Description | Default |
| timing/clocktype | default clock type (1: CPU user seconds, 2: wall clock time)
Range: {1, ..., 2} | 2 |
| timing/enabled | is timing enabled?
Range: boolean | 1 |
| timing/nlpieval | should time for evaluation in NLP solves be measured?
Range: boolean | 0 |
| timing/rareclockcheck | should clock checks of solving time be performed less frequently (note: time limit could be exceeded slightly)
Range: boolean | 0 |
| timing/reading | belongs reading time to solving time?
Range: boolean | 0 |
| timing/statistictiming | should timing for statistic output be performed?
Range: boolean | 1 |