# branching score function ('s'um, 'p'roduct) # [type: char, range: {sp}, default: p] branching/scorefunc = p # branching score factor to weigh downward and upward gain prediction in sum score function # [type: real, range: [0,1], default: 0.167] branching/scorefac = 0.167 # should branching on binary variables be preferred? # [type: bool, range: {TRUE,FALSE}, default: FALSE] branching/preferbinary = FALSE # should conflict analysis be enabled? # [type: bool, range: {TRUE,FALSE}, default: TRUE] conflict/enable = TRUE # should propagation conflict analysis be used? # [type: bool, range: {TRUE,FALSE}, default: TRUE] conflict/useprop = TRUE # should infeasible LP conflict analysis be used? # [type: bool, range: {TRUE,FALSE}, default: TRUE] conflict/useinflp = TRUE # should bound exceeding LP conflict analysis be used? # [type: bool, range: {TRUE,FALSE}, default: FALSE] conflict/useboundlp = FALSE # should infeasible/bound exceeding strong branching conflict analysis be used? # [type: bool, range: {TRUE,FALSE}, default: FALSE] conflict/usesb = FALSE # should pseudo solution conflict analysis be used? # [type: bool, range: {TRUE,FALSE}, default: TRUE] conflict/usepseudo = TRUE # maximal fraction of variables involved in a conflict constraint # [type: real, range: [0,1.79769313486232e+308], default: 0.1] conflict/maxvarsfac = 0.1 # minimal absolute maximum of variables involved in a conflict constraint # [type: int, range: [0,2147483647], default: 30] conflict/minmaxvars = 30 # maximal number of LP resolving loops during conflict analysis (-1: no limit) # [type: int, range: [-1,2147483647], default: 2] conflict/maxlploops = 2 # maximal number of LP iterations in each LP resolving loop (-1: no limit) # [type: int, range: [-1,2147483647], default: 10] conflict/lpiterations = 10 # number of depth levels up to which first UIP's are used in conflict analysis (-1: use All-FirstUIP rule) # [type: int, range: [-1,2147483647], default: -1] conflict/fuiplevels = -1 # maximal number of intermediate conflict constraints generated in conflict graph (-1: use every intermediate constraint) # [type: int, range: [-1,2147483647], default: -1] conflict/interconss = -1 # number of depth levels up to which UIP reconvergence constraints are generated (-1: generate reconvergence constraints in all depth levels) # [type: int, range: [-1,2147483647], default: -1] conflict/reconvlevels = -1 # maximal number of conflict constraints accepted at an infeasible node (-1: use all generated conflict constraints) # [type: int, range: [-1,2147483647], default: 10] conflict/maxconss = 10 # should binary conflicts be preferred? # [type: bool, range: {TRUE,FALSE}, default: FALSE] conflict/preferbinary = FALSE # should conflict constraints be generated that are only valid locally? # [type: bool, range: {TRUE,FALSE}, default: TRUE] conflict/allowlocal = TRUE # should conflict constraints be attached only to the local subtree where they can be useful? # [type: bool, range: {TRUE,FALSE}, default: FALSE] conflict/settlelocal = FALSE # should earlier nodes be repropagated in order to replace branching decisions by deductions? # [type: bool, range: {TRUE,FALSE}, default: TRUE] conflict/repropagate = TRUE # should constraints be kept for repropagation even if they are too long? # [type: bool, range: {TRUE,FALSE}, default: TRUE] conflict/keepreprop = TRUE # should the conflict constraints be subject to aging? # [type: bool, range: {TRUE,FALSE}, default: TRUE] conflict/dynamic = TRUE # should the conflict's relaxations be subject to LP aging and cleanup? # [type: bool, range: {TRUE,FALSE}, default: TRUE] conflict/removable = TRUE # score factor for depth level in bound relaxation heuristic of LP analysis # [type: real, range: [-1.79769313486232e+308,1.79769313486232e+308], default: 1] conflict/depthscorefac = 1 # factor to decrease importance of variables' earlier conflict scores # [type: real, range: [1e-06,1], default: 0.98] conflict/scorefac = 0.98 # number of successful conflict analysis calls that trigger a restart (0: disable conflict restarts) # [type: int, range: [0,2147483647], default: 0] conflict/restartnum = 0 # factor to increase restartnum with after each restart # [type: real, range: [0,1.79769313486232e+308], default: 1.5] conflict/restartfac = 1.5 # maximum age an unnecessary constraint can reach before it is deleted (0: dynamic, -1: keep all constraints) # [type: int, range: [-1,2147483647], default: 0] constraints/agelimit = 0 # age of a constraint after which it is marked obsolete (0: dynamic, -1 do not mark constraints obsolete) # [type: int, range: [-1,2147483647], default: -1] constraints/obsoleteage = -1 # should enforcement of pseudo solution be disabled? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/disableenfops = FALSE # verbosity level of output # [type: int, range: [0,5], default: 4] display/verblevel = 4 # maximal number of characters in a node information line # [type: int, range: [0,2147483647], default: 139] display/width = 139 # frequency for displaying node information lines # [type: int, range: [-1,2147483647], default: 100] display/freq = 100 # frequency for displaying header lines (every n'th node information line) # [type: int, range: [-1,2147483647], default: 15] display/headerfreq = 15 # should the LP solver display status messages? # [type: bool, range: {TRUE,FALSE}, default: FALSE] display/lpinfo = FALSE # maximal time in seconds to run # [type: real, range: [0,1.79769313486232e+308], default: 1e+20] limits/time = 1e+20 # maximal number of nodes to process (-1: no limit) # [type: longint, range: [-1,9223372036854775807], default: -1] limits/nodes = -1 # solving stops, if the given number of nodes was processed since the last improvement of the primal solution value (-1: no limit) # [type: longint, range: [-1,9223372036854775807], default: -1] limits/stallnodes = -1 # maximal memory usage in MB; reported memory usage is lower than real memory usage! # [type: real, range: [0,1.79769313486232e+308], default: 1e+20] limits/memory = 1e+20 # solving stops, if the relative gap = |(primalbound - dualbound)/dualbound| is below the given value # [type: real, range: [0,1.79769313486232e+308], default: 0] limits/gap = 0 # solving stops, if the absolute gap = |primalbound - dualbound| is below the given value # [type: real, range: [0,1.79769313486232e+308], default: 0] limits/absgap = 0 # solving stops, if the given number of solutions were found (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] limits/solutions = -1 # solving stops, if the given number of solution improvements were found (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] limits/bestsol = -1 # maximal number of solutions to store in the solution storage # [type: int, range: [1,2147483647], default: 100] limits/maxsol = 100 # frequency for solving LP at the nodes (-1: never; 0: only root LP) # [type: int, range: [-1,2147483647], default: 1] lp/solvefreq = 1 # maximal depth for solving LP at the nodes (-1: no depth limit) # [type: int, range: [-1,2147483647], default: -1] lp/solvedepth = -1 # LP algorithm for solving initial LP relaxations (automatic 's'implex, 'p'rimal simplex, 'd'ual simplex, 'b'arrier, barrier with 'c'rossover) # [type: char, range: {spdbc}, default: s] lp/initalgorithm = s # 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) # [type: char, range: {spdbc}, default: s] lp/resolvealgorithm = s # 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) # [type: char, range: {lafpsqd}, default: l] lp/pricing = l # maximum age a dynamic column can reach before it is deleted from the LP (-1: don't delete columns due to aging) # [type: int, range: [-1,2147483647], default: 10] lp/colagelimit = 10 # maximum age a dynamic row can reach before it is deleted from the LP (-1: don't delete rows due to aging) # [type: int, range: [-1,2147483647], default: 10] lp/rowagelimit = 10 # should new non-basic columns be removed after LP solving? # [type: bool, range: {TRUE,FALSE}, default: FALSE] lp/cleanupcols = FALSE # should new non-basic columns be removed after root LP solving? # [type: bool, range: {TRUE,FALSE}, default: FALSE] lp/cleanupcolsroot = FALSE # should new basic rows be removed after LP solving? # [type: bool, range: {TRUE,FALSE}, default: TRUE] lp/cleanuprows = TRUE # should new basic rows be removed after root LP solving? # [type: bool, range: {TRUE,FALSE}, default: TRUE] lp/cleanuprowsroot = TRUE # should LP solver's return status be checked for stability? # [type: bool, range: {TRUE,FALSE}, default: TRUE] lp/checkstability = TRUE # should LP solutions be checked, resolving LP when numerical troubles occur? # [type: bool, range: {TRUE,FALSE}, default: TRUE] lp/checkfeas = TRUE # should FASTMIP setting of LP solver be used? # [type: bool, range: {TRUE,FALSE}, default: TRUE] lp/fastmip = TRUE # should scaling of LP solver be used? # [type: bool, range: {TRUE,FALSE}, default: TRUE] lp/scaling = TRUE # should presolving of LP solver be used? # [type: bool, range: {TRUE,FALSE}, default: TRUE] lp/presolving = TRUE # should the lexicographic dual alogrithm be used? # [type: bool, range: {TRUE,FALSE}, default: FALSE] lp/lexdualalgo = FALSE # should the lexicographic dual algorithm be applied only at the root node # [type: bool, range: {TRUE,FALSE}, default: TRUE] lp/lexdualrootonly = TRUE # maximum number of rounds in the lexicographic dual algorithm (-1: unbounded) # [type: int, range: [-1,2147483647], default: 2] lp/lexdualmaxrounds = 2 # choose fractional basic variables in lexicographic dual algorithm? # [type: bool, range: {TRUE,FALSE}, default: FALSE] lp/lexdualbasic = FALSE # fraction of maximal memory usage resulting in switch to memory saving mode # [type: real, range: [0,1], default: 0.8] memory/savefac = 0.8 # memory growing factor for dynamically allocated arrays # [type: real, range: [1,10], default: 1.2] memory/arraygrowfac = 1.2 # initial size of dynamically allocated arrays # [type: int, range: [0,2147483647], default: 4] memory/arraygrowinit = 4 # memory growing factor for tree array # [type: real, range: [1,10], default: 2] memory/treegrowfac = 2 # initial size of tree array # [type: int, range: [0,2147483647], default: 65536] memory/treegrowinit = 65536 # memory growing factor for path array # [type: real, range: [1,10], default: 2] memory/pathgrowfac = 2 # initial size of path array # [type: int, range: [0,2147483647], default: 256] memory/pathgrowinit = 256 # should the CTRL-C interrupt be caught by SCIP? # [type: bool, range: {TRUE,FALSE}, default: TRUE] misc/catchctrlc = TRUE # child selection rule ('d'own, 'u'p, 'p'seudo costs, 'i'nference, 'l'p value, 'r'oot LP value difference, 'h'brid inference/root LP value difference) # [type: char, range: {dupilrh}, default: h] nodeselection/childsel = h # values larger than this are considered infinity # [type: real, range: [10000000000,1e+98], default: 1e+20] numerics/infinity = 1e+20 # absolute values smaller than this are considered zero # [type: real, range: [1e-20,0.001], default: 1e-09] numerics/epsilon = 1e-09 # absolute values of sums smaller than this are considered zero # [type: real, range: [1e-17,0.001], default: 1e-06] numerics/sumepsilon = 1e-06 # LP feasibility tolerance for constraints # [type: real, range: [1e-17,0.001], default: 1e-06] numerics/feastol = 1e-06 # LP feasibility tolerance for reduced costs # [type: real, range: [1e-17,0.001], default: 1e-09] numerics/dualfeastol = 1e-09 # LP convergence tolerance used in barrier algorithm # [type: real, range: [1e-17,0.001], default: 1e-10] numerics/barrierconvtol = 1e-10 # minimal relative improve for strengthening bounds # [type: real, range: [1e-17,1e+98], default: 0.05] numerics/boundstreps = 0.05 # minimal variable distance value to use for branching pseudo cost updates # [type: real, range: [1e-17,1], default: 0.1] numerics/pseudocosteps = 0.1 # minimal objective distance value to use for branching pseudo cost updates # [type: real, range: [0,1.79769313486232e+308], default: 0.0001] numerics/pseudocostdelta = 0.0001 # maximal number of presolving rounds (-1: unlimited) # [type: int, range: [-1,2147483647], default: -1] presolving/maxrounds = -1 # abort presolve, if at most this fraction of the problem was changed in last presolve round # [type: real, range: [0,1], default: 0.0001] presolving/abortfac = 0.0001 # maximal number of restarts (-1: unlimited) # [type: int, range: [-1,2147483647], default: -1] presolving/maxrestarts = -1 # fraction of integer variables that were fixed in the root node triggering a restart with preprocessing after root node evaluation # [type: real, range: [0,1], default: 0.05] presolving/restartfac = 0.05 # fraction of integer variables that were fixed in the root node triggering an immediate restart with preprocessing # [type: real, range: [0,1], default: 0.2] presolving/immrestartfac = 0.2 # fraction of integer variables that were globally fixed during the solving process triggering a restart with preprocessing # [type: real, range: [0,1], default: 1] presolving/subrestartfac = 1 # minimal fraction of integer variables removed after restart to allow for an additional restart # [type: real, range: [0,1], default: 0.1] presolving/restartminred = 0.1 # maximal number of variables priced in per pricing round # [type: int, range: [1,2147483647], default: 100] pricing/maxvars = 100 # maximal number of priced variables at the root node # [type: int, range: [1,2147483647], default: 2000] pricing/maxvarsroot = 2000 # pricing is aborted, if fac * pricing/maxvars pricing candidates were found # [type: real, range: [1,1.79769313486232e+308], default: 2] pricing/abortfac = 2 # maximal number of propagation rounds per node (-1: unlimited) # [type: int, range: [-1,2147483647], default: 100] propagating/maxrounds = 100 # maximal number of propagation rounds in the root node (-1: unlimited) # [type: int, range: [-1,2147483647], default: 1000] propagating/maxroundsroot = 1000 # should propagation be aborted immediately? setting this to FALSE could help conflict analysis to produce more conflict constraints # [type: bool, range: {TRUE,FALSE}, default: TRUE] propagating/abortoncutoff = TRUE # 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) # [type: real, range: [0,1], default: 1] separating/maxbounddist = 1 # minimal efficacy for a cut to enter the LP # [type: real, range: [0,1e+98], default: 0.05] separating/minefficacy = 0.05 # minimal efficacy for a cut to enter the LP in the root node # [type: real, range: [0,1e+98], default: 0.01] separating/minefficacyroot = 0.01 # minimal orthogonality for a cut to enter the LP # [type: real, range: [0,1], default: 0.5] separating/minortho = 0.5 # minimal orthogonality for a cut to enter the LP in the root node # [type: real, range: [0,1], default: 0.5] separating/minorthoroot = 0.5 # factor to scale objective parallelism of cut in separation score calculation # [type: real, range: [0,1e+98], default: 0.0001] separating/objparalfac = 0.0001 # factor to scale orthogonality of cut in separation score calculation (0.0 to disable orthogonality calculation) # [type: real, range: [0,1e+98], default: 1] separating/orthofac = 1 # function used for calc. scalar prod. in orthogonality test ('e'uclidean, 'd'iscrete) # [type: char, range: {ed}, default: e] separating/orthofunc = e # row norm to use for efficacy calculation ('e'uclidean, 'm'aximum, 's'um, 'd'iscrete) # [type: char, range: {emsd}, default: e] separating/efficacynorm = e # maximal number of runs for which separation is enabled (-1: unlimited) # [type: int, range: [-1,2147483647], default: -1] separating/maxruns = -1 # maximal number of separation rounds per node (-1: unlimited) # [type: int, range: [-1,2147483647], default: 5] separating/maxrounds = 1 # maximal number of separation rounds in the root node (-1: unlimited) # [type: int, range: [-1,2147483647], default: -1] separating/maxroundsroot = 5 # maximal number of separation rounds in the root node of a subsequent run (-1: unlimited) # [type: int, range: [-1,2147483647], default: 1] separating/maxroundsrootsubrun = 1 # maximal additional number of separation rounds in subsequent price-and-cut loops (-1: no additional restriction) # [type: int, range: [-1,2147483647], default: 1] separating/maxaddrounds = 1 # maximal number of consecutive separation rounds without objective or integrality improvement (-1: no additional restriction) # [type: int, range: [-1,2147483647], default: 5] separating/maxstallrounds = 5 # maximal number of cuts separated per separation round (0: disable local separation) # [type: int, range: [0,2147483647], default: 100] separating/maxcuts = 100 # maximal number of separated cuts at the root node (0: disable root node separation) # [type: int, range: [0,2147483647], default: 2000] separating/maxcutsroot = 2000 # maximum age a cut can reach before it is deleted from the global cut pool, or -1 to keep all cuts # [type: int, range: [-1,2147483647], default: 100] separating/cutagelimit = 100 # separation frequency for the global cut pool (-1: disable global cut pool, 0: only separate pool at the root) # [type: int, range: [-1,2147483647], default: 0] separating/poolfreq = 0 # default clock type (1: CPU user seconds, 2: wall clock time) # [type: int, range: [1,2], default: 1] timing/clocktype = 1 # is timing enabled? # [type: bool, range: {TRUE,FALSE}, default: TRUE] timing/enabled = TRUE # name of the VBC Tool output file, or - if no VBC Tool output should be created # [type: string, default: "-"] vbc/filename = "-" # should the real solving time be used instead of a time step counter in VBC output? # [type: bool, range: {TRUE,FALSE}, default: TRUE] vbc/realtime = TRUE # priority of conflict handler # [type: int, range: [-2147483648,2147483647], default: -1000000] conflict/linear/priority = -1000000 # frequency for separating cuts (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 0] constraints/linear/sepafreq = 0 # frequency for propagating domains (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 1] constraints/linear/propfreq = 1 # frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation) # [type: int, range: [-1,2147483647], default: 100] constraints/linear/eagerfreq = 100 # maximal number of presolving rounds the constraint handler participates in (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] constraints/linear/maxprerounds = -1 # should separation method be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/linear/delaysepa = FALSE # should propagation method be delayed, if other propagators found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/linear/delayprop = FALSE # should presolving method be delayed, if other presolvers found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/linear/delaypresol = FALSE # multiplier on propagation frequency, how often the bounds are tightened (-1: never, 0: only at root) # [type: int, range: [-1,2147483647], default: 1] constraints/linear/tightenboundsfreq = 1 # maximal number of separation rounds per node (-1: unlimited) # [type: int, range: [-1,2147483647], default: 5] constraints/linear/maxrounds = 5 # maximal number of separation rounds per node in the root node (-1: unlimited) # [type: int, range: [-1,2147483647], default: -1] constraints/linear/maxroundsroot = -1 # maximal number of cuts separated per separation round # [type: int, range: [0,2147483647], default: 50] constraints/linear/maxsepacuts = 50 # maximal number of cuts separated per separation round in the root node # [type: int, range: [0,2147483647], default: 200] constraints/linear/maxsepacutsroot = 200 # should pairwise constraint comparison be performed in presolving? # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/linear/presolpairwise = FALSE # should hash table be used for detecting redundant constraints in advance # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/linear/presolusehashing = TRUE # maximal allowed relative gain in maximum norm for constraint aggregation (0.0: disable constraint aggregation) # [type: real, range: [0,1.79769313486232e+308], default: 0] constraints/linear/maxaggrnormscale = 0 # maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for separating knapsack cardinality cuts # [type: real, range: [0,1], default: 0] constraints/linear/maxcardbounddist = 0 # should all constraints be subject to cardinality cut generation instead of only the ones with non-zero dual value? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/linear/separateall = FALSE # should presolving search for aggregations in equations # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/linear/aggregatevariables = TRUE # should presolving try to simplify inequalities # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/linear/simplifyinequalities = FALSE # should dual presolving steps be preformed? # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/linear/dualpresolving = TRUE # frequency for separating cuts (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 1] constraints/and/sepafreq = 1 # frequency for propagating domains (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 1] constraints/and/propfreq = 1 # frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation) # [type: int, range: [-1,2147483647], default: 100] constraints/and/eagerfreq = 100 # maximal number of presolving rounds the constraint handler participates in (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] constraints/and/maxprerounds = -1 # should separation method be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/and/delaysepa = FALSE # should propagation method be delayed, if other propagators found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/and/delayprop = FALSE # should presolving method be delayed, if other presolvers found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/and/delaypresol = FALSE # should pairwise constraint comparison be performed in presolving? # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/and/presolpairwise = FALSE # should hash table be used for detecting redundant constraints in advance # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/and/presolusehashing = TRUE # should the "and" constraint get linearized and removed (in presolving)? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/and/linearize = FALSE # should cuts be separated during LP enforcing? # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/and/enforcecuts = TRUE # should an aggregated linearization be used? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/and/aggrlinearization = FALSE # priority of conflict handler # [type: int, range: [-2147483648,2147483647], default: -3000000] conflict/bounddisjunction/priority = -3000000 # frequency for separating cuts (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: -1] constraints/bounddisjunction/sepafreq = -1 # frequency for propagating domains (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 1] constraints/bounddisjunction/propfreq = 1 # frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation) # [type: int, range: [-1,2147483647], default: 100] constraints/bounddisjunction/eagerfreq = 100 # maximal number of presolving rounds the constraint handler participates in (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] constraints/bounddisjunction/maxprerounds = -1 # should separation method be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/bounddisjunction/delaysepa = FALSE # should propagation method be delayed, if other propagators found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/bounddisjunction/delayprop = FALSE # should presolving method be delayed, if other presolvers found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/bounddisjunction/delaypresol = FALSE # frequency for separating cuts (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: -1] constraints/conjunction/sepafreq = -1 # frequency for propagating domains (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: -1] constraints/conjunction/propfreq = -1 # frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation) # [type: int, range: [-1,2147483647], default: 100] constraints/conjunction/eagerfreq = 100 # maximal number of presolving rounds the constraint handler participates in (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] constraints/conjunction/maxprerounds = -1 # should separation method be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/conjunction/delaysepa = FALSE # should propagation method be delayed, if other propagators found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/conjunction/delayprop = FALSE # should presolving method be delayed, if other presolvers found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/conjunction/delaypresol = FALSE # frequency for separating cuts (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: -1] constraints/countsols/sepafreq = -1 # frequency for propagating domains (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: -1] constraints/countsols/propfreq = -1 # frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation) # [type: int, range: [-1,2147483647], default: 100] constraints/countsols/eagerfreq = 100 # maximal number of presolving rounds the constraint handler participates in (-1: no limit) # [type: int, range: [-1,2147483647], default: 0] constraints/countsols/maxprerounds = 0 # should separation method be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/countsols/delaysepa = FALSE # should propagation method be delayed, if other propagators found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/countsols/delayprop = FALSE # should presolving method be delayed, if other presolvers found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/countsols/delaypresol = FALSE # should the sparse solution test be turned on? # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/countsols/sparsetest = TRUE # is it allowed to discard solutions? # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/countsols/discardsols = TRUE # is the constraint handler active? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/countsols/active = FALSE # should the solutions be collected? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/countsols/collect = FALSE # counting stops, if the given number of solutions were found (-1: no limit) # [type: longint, range: [-1,9223372036854775807], default: -1] constraints/countsols/sollimit = -1 # display activation status of display column (0: off, 1: auto, 2:on) # [type: int, range: [0,2], default: 0] display/sols/active = 0 # display activation status of display column (0: off, 1: auto, 2:on) # [type: int, range: [0,2], default: 0] display/feasST/active = 0 # frequency for separating cuts (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 10] constraints/indicator/sepafreq = 10 # frequency for propagating domains (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 1] constraints/indicator/propfreq = 1 # frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation) # [type: int, range: [-1,2147483647], default: 100] constraints/indicator/eagerfreq = 100 # maximal number of presolving rounds the constraint handler participates in (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] constraints/indicator/maxprerounds = -1 # should separation method be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/indicator/delaysepa = FALSE # should propagation method be delayed, if other propagators found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/indicator/delayprop = FALSE # should presolving method be delayed, if other presolvers found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/indicator/delaypresol = FALSE # Branch on indicator constraints in enforcing? # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/indicator/branchIndicators = TRUE # Generate logicor constraints instead of cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/indicator/genLogicor = FALSE # Separate using the alternative LP? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/indicator/sepaAlternativeLP = FALSE # add initial coupling inequalities # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/indicator/addCoupling = FALSE # Update bounds of original variables for separation? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/indicator/updateBounds = FALSE # Try to make solutions feasible by setting indicator variables? # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/indicator/trySolutions = TRUE # frequency for separating cuts (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: -1] constraints/integral/sepafreq = -1 # frequency for propagating domains (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: -1] constraints/integral/propfreq = -1 # frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation) # [type: int, range: [-1,2147483647], default: -1] constraints/integral/eagerfreq = -1 # maximal number of presolving rounds the constraint handler participates in (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] constraints/integral/maxprerounds = -1 # should separation method be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/integral/delaysepa = FALSE # should propagation method be delayed, if other propagators found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/integral/delayprop = FALSE # should presolving method be delayed, if other presolvers found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/integral/delaypresol = FALSE # frequency for separating cuts (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 0] constraints/knapsack/sepafreq = 0 # frequency for propagating domains (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 1] constraints/knapsack/propfreq = 1 # frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation) # [type: int, range: [-1,2147483647], default: 100] constraints/knapsack/eagerfreq = 100 # maximal number of presolving rounds the constraint handler participates in (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] constraints/knapsack/maxprerounds = -1 # should separation method be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/knapsack/delaysepa = FALSE # should propagation method be delayed, if other propagators found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/knapsack/delayprop = FALSE # should presolving method be delayed, if other presolvers found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/knapsack/delaypresol = FALSE # enable linear upgrading for constraint handler # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/linear/upgrade/knapsack = TRUE # multiplier on separation frequency, how often cardinality cuts are separated (-1: never, 0: only at root) # [type: int, range: [-1,2147483647], default: 1] constraints/knapsack/sepacardfreq = 1 # maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for separating knapsack cardinality cuts # [type: real, range: [0,1], default: 0] constraints/knapsack/maxcardbounddist = 0 # maximal number of separation rounds per node (-1: unlimited) # [type: int, range: [-1,2147483647], default: 5] constraints/knapsack/maxrounds = 5 # maximal number of separation rounds per node in the root node (-1: unlimited) # [type: int, range: [-1,2147483647], default: -1] constraints/knapsack/maxroundsroot = -1 # maximal number of cuts separated per separation round # [type: int, range: [0,2147483647], default: 50] constraints/knapsack/maxsepacuts = 50 # maximal number of cuts separated per separation round in the root node # [type: int, range: [0,2147483647], default: 200] constraints/knapsack/maxsepacutsroot = 200 # maximal number of cardinality inequalities lifted per separation round (-1: unlimited) # [type: int, range: [-1,2147483647], default: -1] constraints/knapsack/maxnumcardlift = -1 # should disaggregation of knapsack constraints be allowed in preprocessing? # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/knapsack/disaggregation = TRUE # should presolving try to simplify knapsacks # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/knapsack/simplifyinequalities = FALSE # priority of conflict handler # [type: int, range: [-2147483648,2147483647], default: 800000] conflict/logicor/priority = 800000 # frequency for separating cuts (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 0] constraints/logicor/sepafreq = 0 # frequency for propagating domains (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 1] constraints/logicor/propfreq = 1 # frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation) # [type: int, range: [-1,2147483647], default: 100] constraints/logicor/eagerfreq = 100 # maximal number of presolving rounds the constraint handler participates in (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] constraints/logicor/maxprerounds = -1 # should separation method be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/logicor/delaysepa = FALSE # should propagation method be delayed, if other propagators found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/logicor/delayprop = FALSE # should presolving method be delayed, if other presolvers found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/logicor/delaypresol = FALSE # enable linear upgrading for constraint handler # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/linear/upgrade/logicor = TRUE # should pairwise constraint comparison be performed in presolving? # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/logicor/presolpairwise = FALSE # should hash table be used for detecting redundant constraints in advance # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/logicor/presolusehashing = TRUE # frequency for separating cuts (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 0] constraints/or/sepafreq = 0 # frequency for propagating domains (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 1] constraints/or/propfreq = 1 # frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation) # [type: int, range: [-1,2147483647], default: 100] constraints/or/eagerfreq = 100 # maximal number of presolving rounds the constraint handler participates in (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] constraints/or/maxprerounds = -1 # should separation method be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/or/delaysepa = FALSE # should propagation method be delayed, if other propagators found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/or/delayprop = FALSE # should presolving method be delayed, if other presolvers found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/or/delaypresol = FALSE # frequency for separating cuts (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 2] constraints/quadratic/sepafreq = 2 # frequency for propagating domains (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 10] constraints/quadratic/propfreq = 10 # frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation) # [type: int, range: [-1,2147483647], default: 100] constraints/quadratic/eagerfreq = 100 # maximal number of presolving rounds the constraint handler participates in (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] constraints/quadratic/maxprerounds = -1 # should separation method be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/quadratic/delaysepa = FALSE # should propagation method be delayed, if other propagators found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/quadratic/delayprop = FALSE # should presolving method be delayed, if other presolvers found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/quadratic/delaypresol = FALSE # whether a square of a binary variables should be replaced by the binary variable # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/quadratic/replacesqrbinary = TRUE # max. length of linear term which when multiplied with a binary variables is replaced by an auxiliary variable and a linear reformulation (0 to turn off) # [type: int, range: [0,2147483647], default: 2147483647] constraints/quadratic/replacebinaryprod = 2147483647 # whether quadratic constraints consisting of several quadratic blocks should be disaggregated in several constraints # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/quadratic/disaggregate = TRUE # minimal efficacy for a cut to be added to the LP; overwrites separating/efficacy # [type: real, range: [0,1e+20], default: 0.0001] constraints/quadratic/minefficacy = 0.0001 # whether a quadratic constraint should be scaled w.r.t. the current gradient norm when checking for feasibility # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/quadratic/scaling = TRUE # whether a propagation should be used that is faster in case of bilinear term, but also less efficient # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/quadratic/fastpropagate = TRUE # a default bound to impose on unbounded variables in quadratic terms (-defaultbound is used for missing lower bounds) # [type: real, range: [0,1e+20], default: 1e+20] constraints/quadratic/defaultbound = 1e+20 # maximal range of a cut (maximal coefficient divided by minimal coefficient) in order to be added to LP relaxation # [type: real, range: [0,1e+20], default: 10000000000] constraints/quadratic/cutmaxrange = 10000000000 # strategy to use for selecting branching variable: b: rb-int-br, r: rb-int-br-rev, i: rb-inf # [type: char, range: {bri}, default: r] constraints/quadratic/strategy = r # minimal fractional distance of branching point to variable bounds; a value of 0.5 leads to branching always in the middle of a bounded domain # [type: real, range: [0.0001,0.5], default: 0.2] constraints/quadratic/mindistbrpointtobound = 0.2 # priority of conflict handler # [type: int, range: [-2147483648,2147483647], default: 700000] conflict/setppc/priority = 700000 # frequency for separating cuts (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 0] constraints/setppc/sepafreq = 0 # frequency for propagating domains (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 1] constraints/setppc/propfreq = 1 # frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation) # [type: int, range: [-1,2147483647], default: 100] constraints/setppc/eagerfreq = 100 # maximal number of presolving rounds the constraint handler participates in (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] constraints/setppc/maxprerounds = -1 # should separation method be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/setppc/delaysepa = FALSE # should propagation method be delayed, if other propagators found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/setppc/delayprop = FALSE # should presolving method be delayed, if other presolvers found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/setppc/delaypresol = FALSE # enable linear upgrading for constraint handler # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/linear/upgrade/setppc = TRUE # number of children created in pseudo branching (0: disable pseudo branching) # [type: int, range: [0,2147483647], default: 2] constraints/setppc/npseudobranches = 2 # should pairwise constraint comparison be performed in presolving? # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/setppc/presolpairwise = FALSE # should hash table be used for detecting redundant constraints in advance # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/setppc/presolusehashing = TRUE # frequency for separating cuts (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 0] constraints/SOS1/sepafreq = 0 # frequency for propagating domains (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 1] constraints/SOS1/propfreq = 1 # frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation) # [type: int, range: [-1,2147483647], default: 100] constraints/SOS1/eagerfreq = 100 # maximal number of presolving rounds the constraint handler participates in (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] constraints/SOS1/maxprerounds = -1 # should separation method be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/SOS1/delaysepa = FALSE # should propagation method be delayed, if other propagators found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/SOS1/delayprop = FALSE # should presolving method be delayed, if other presolvers found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/SOS1/delaypresol = FALSE # Use SOS1 branching in enforcing (otherwise leave decision to branching rules)? # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/SOS1/branchSOS = TRUE # Branch on SOS constraint with most number of nonzeros? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/SOS1/branchNonzeros = FALSE # Branch on SOS cons. with highest nonzero-variable weight for branching (needs branchNonzeros = false)? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/SOS1/branchWeight = FALSE # frequency for separating cuts (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 0] constraints/SOS2/sepafreq = 0 # frequency for propagating domains (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 1] constraints/SOS2/propfreq = 1 # frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation) # [type: int, range: [-1,2147483647], default: 100] constraints/SOS2/eagerfreq = 100 # maximal number of presolving rounds the constraint handler participates in (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] constraints/SOS2/maxprerounds = -1 # should separation method be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/SOS2/delaysepa = FALSE # should propagation method be delayed, if other propagators found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/SOS2/delayprop = FALSE # should presolving method be delayed, if other presolvers found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/SOS2/delaypresol = FALSE # frequency for separating cuts (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 0] constraints/varbound/sepafreq = 0 # frequency for propagating domains (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 1] constraints/varbound/propfreq = 1 # frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation) # [type: int, range: [-1,2147483647], default: 100] constraints/varbound/eagerfreq = 100 # maximal number of presolving rounds the constraint handler participates in (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] constraints/varbound/maxprerounds = -1 # should separation method be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/varbound/delaysepa = FALSE # should propagation method be delayed, if other propagators found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/varbound/delayprop = FALSE # should presolving method be delayed, if other presolvers found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/varbound/delaypresol = FALSE # enable linear upgrading for constraint handler # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/linear/upgrade/varbound = TRUE # frequency for separating cuts (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 0] constraints/xor/sepafreq = 0 # frequency for propagating domains (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 1] constraints/xor/propfreq = 1 # frequency for using all instead of only the useful constraints in separation, propagation and enforcement (-1: never, 0: only in first evaluation) # [type: int, range: [-1,2147483647], default: 100] constraints/xor/eagerfreq = 100 # maximal number of presolving rounds the constraint handler participates in (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] constraints/xor/maxprerounds = -1 # should separation method be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/xor/delaysepa = FALSE # should propagation method be delayed, if other propagators found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/xor/delayprop = FALSE # should presolving method be delayed, if other presolvers found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] constraints/xor/delaypresol = FALSE # should pairwise constraint comparison be performed in presolving? # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/xor/presolpairwise = FALSE # should hash table be used for detecting redundant constraints in advance # [type: bool, range: {TRUE,FALSE}, default: TRUE] constraints/xor/presolusehashing = TRUE # should model constraints be subject to aging? # [type: bool, range: {TRUE,FALSE}, default: TRUE] reading/cipreader/dynamicconss = TRUE # should columns be added and removed dynamically to the LP? # [type: bool, range: {TRUE,FALSE}, default: FALSE] reading/cipreader/dynamiccols = FALSE # should rows be added and removed dynamically to the LP? # [type: bool, range: {TRUE,FALSE}, default: FALSE] reading/cipreader/dynamicrows = FALSE # should model constraints be subject to aging? # [type: bool, range: {TRUE,FALSE}, default: TRUE] reading/cnfreader/dynamicconss = TRUE # should columns be added and removed dynamically to the LP? # [type: bool, range: {TRUE,FALSE}, default: FALSE] reading/cnfreader/dynamiccols = FALSE # should rows be added and removed dynamically to the LP? # [type: bool, range: {TRUE,FALSE}, default: FALSE] reading/cnfreader/dynamicrows = FALSE # are integer variables free by default (depending on GAMS version)? # [type: bool, range: {TRUE,FALSE}, default: FALSE] reading/gmsreader/freeints = FALSE # shall characters '#', '*', '+', '/', and '-' in variable and constraint names be replaced by '_'? # [type: bool, range: {TRUE,FALSE}, default: FALSE] reading/gmsreader/replaceforbiddenchars = FALSE # should model constraints be subject to aging? # [type: bool, range: {TRUE,FALSE}, default: TRUE] reading/lpreader/dynamicconss = TRUE # should columns be added and removed dynamically to the LP? # [type: bool, range: {TRUE,FALSE}, default: FALSE] reading/lpreader/dynamiccols = FALSE # should rows be added and removed dynamically to the LP? # [type: bool, range: {TRUE,FALSE}, default: FALSE] reading/lpreader/dynamicrows = FALSE # should model constraints be subject to aging? # [type: bool, range: {TRUE,FALSE}, default: TRUE] reading/mpsreader/dynamicconss = TRUE # should columns be added and removed dynamically to the LP? # [type: bool, range: {TRUE,FALSE}, default: FALSE] reading/mpsreader/dynamiccols = FALSE # should rows be added and removed dynamically to the LP? # [type: bool, range: {TRUE,FALSE}, default: FALSE] reading/mpsreader/dynamicrows = FALSE # should model constraints be subject to aging? # [type: bool, range: {TRUE,FALSE}, default: TRUE] reading/opbreader/dynamicconss = TRUE # should columns be added and removed dynamically to the LP? # [type: bool, range: {TRUE,FALSE}, default: FALSE] reading/opbreader/dynamiccols = FALSE # should rows be added and removed dynamically to the LP? # [type: bool, range: {TRUE,FALSE}, default: FALSE] reading/opbreader/dynamicrows = FALSE # should the nonlinear constraint be separated during LP processing? # [type: bool, range: {TRUE,FALSE}, default: TRUE] reading/opbreader/nlcseparate = TRUE # should the nonlinear constraint be propagated during node processing? # [type: bool, range: {TRUE,FALSE}, default: TRUE] reading/opbreader/nlcpropagate = TRUE # should the nonlinear constraints be removable? # [type: bool, range: {TRUE,FALSE}, default: TRUE] reading/opbreader/nlcremovable = TRUE # use '*' between coefficients and variables by writing to problem? # [type: bool, range: {TRUE,FALSE}, default: FALSE] reading/opbreader/multisymbol = FALSE # should the coloring values be relativ or absolute # [type: bool, range: {TRUE,FALSE}, default: TRUE] reading/ppmreader/rgbrelativ = TRUE # should the output format be binary(P6) (otherwise plain(P3) format) # [type: bool, range: {TRUE,FALSE}, default: TRUE] reading/ppmreader/rgbascii = TRUE # splitting coefficients in this number of intervals # [type: int, range: [3,16], default: 3] reading/ppmreader/coefficientlimit = 3 # maximal color value # [type: int, range: [0,255], default: 160] reading/ppmreader/rgblimit = 160 # should columns be added and removed dynamically to the LP? # [type: bool, range: {TRUE,FALSE}, default: FALSE] reading/zplreader/dynamiccols = FALSE # should the current directory be changed to that of the ZIMPL file before parsing? # [type: bool, range: {TRUE,FALSE}, default: TRUE] reading/zplreader/changedir = TRUE # additional parameter string passed to the ZIMPL parser (or - for no additional parameters) # [type: string, default: "-"] reading/zplreader/parameters = "-" # priority of presolver # [type: int, range: [-536870912,536870911], default: 7900000] presolving/boundshift/priority = 7900000 # maximal number of presolving rounds the presolver participates in (-1: no limit) # [type: int, range: [-1,2147483647], default: 0] presolving/boundshift/maxrounds = 0 # should presolver be delayed, if other presolvers found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] presolving/boundshift/delay = FALSE # absolute value of maximum shift # [type: longint, range: [0,9223372036854775807], default: 9223372036854775807] presolving/boundshift/maxshift = 9223372036854775807 # is flipping allowed (multiplying with -1)? # [type: bool, range: {TRUE,FALSE}, default: TRUE] presolving/boundshift/flipping = TRUE # shift only integer ranges? # [type: bool, range: {TRUE,FALSE}, default: TRUE] presolving/boundshift/integer = TRUE # priority of presolver # [type: int, range: [-536870912,536870911], default: 8000000] presolving/dualfix/priority = 8000000 # maximal number of presolving rounds the presolver participates in (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] presolving/dualfix/maxrounds = -1 # should presolver be delayed, if other presolvers found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] presolving/dualfix/delay = FALSE # priority of presolver # [type: int, range: [-536870912,536870911], default: -10000] presolving/implics/priority = -10000 # maximal number of presolving rounds the presolver participates in (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] presolving/implics/maxrounds = -1 # should presolver be delayed, if other presolvers found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] presolving/implics/delay = FALSE # priority of presolver # [type: int, range: [-536870912,536870911], default: 7000000] presolving/inttobinary/priority = 7000000 # maximal number of presolving rounds the presolver participates in (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] presolving/inttobinary/maxrounds = -1 # should presolver be delayed, if other presolvers found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] presolving/inttobinary/delay = FALSE # priority of presolver # [type: int, range: [-536870912,536870911], default: -100000] presolving/probing/priority = -100000 # maximal number of presolving rounds the presolver participates in (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] presolving/probing/maxrounds = -1 # should presolver be delayed, if other presolvers found reductions? # [type: bool, range: {TRUE,FALSE}, default: TRUE] presolving/probing/delay = TRUE # maximal number of runs, probing participates in (-1: no limit) # [type: int, range: [-1,2147483647], default: 1] presolving/probing/maxruns = 1 # maximal number of propagation rounds in probing subproblems (-1: no limit, 0: auto) # [type: int, range: [-1,2147483647], default: -1] presolving/probing/proprounds = -1 # maximal number of fixings found, until probing is interrupted (0: don't iterrupt) # [type: int, range: [0,2147483647], default: 50] presolving/probing/maxfixings = 50 # maximal number of successive probings without fixings, until probing is aborted (0: don't abort) # [type: int, range: [0,2147483647], default: 2000] presolving/probing/maxuseless = 2000 # maximal number of successive probings without fixings, bound changes, and implications, until probing is aborted (0: don't abort) # [type: int, range: [0,2147483647], default: 100] presolving/probing/maxtotaluseless = 100 # maximal number of probings without fixings, until probing is aborted (0: don't abort) # [type: int, range: [0,2147483647], default: 0] presolving/probing/maxsumuseless = 0 # priority of presolver # [type: int, range: [-536870912,536870911], default: 9000000] presolving/trivial/priority = 9000000 # maximal number of presolving rounds the presolver participates in (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] presolving/trivial/maxrounds = -1 # should presolver be delayed, if other presolvers found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] presolving/trivial/delay = FALSE # priority of node selection rule in standard mode # [type: int, range: [-536870912,536870911], default: 100000] nodeselection/bfs/stdpriority = 100000 # priority of node selection rule in memory saving mode # [type: int, range: [-536870912,536870911], default: 0] nodeselection/bfs/memsavepriority = 0 # minimal plunging depth, before new best node may be selected (-1 for dynamic setting) # [type: int, range: [-1,2147483647], default: -1] nodeselection/bfs/minplungedepth = -1 # maximal plunging depth, before new best node is forced to be selected (-1 for dynamic setting) # [type: int, range: [-1,2147483647], default: -1] nodeselection/bfs/maxplungedepth = -1 # maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where plunging is performed # [type: real, range: [0,1.79769313486232e+308], default: 0.25] nodeselection/bfs/maxplungequot = 0.25 # priority of node selection rule in standard mode # [type: int, range: [-536870912,536870911], default: 0] nodeselection/dfs/stdpriority = 0 # priority of node selection rule in memory saving mode # [type: int, range: [-536870912,536870911], default: 100000] nodeselection/dfs/memsavepriority = 100000 # priority of node selection rule in standard mode # [type: int, range: [-536870912,536870911], default: 200000] nodeselection/estimate/stdpriority = 200000 # priority of node selection rule in memory saving mode # [type: int, range: [-536870912,536870911], default: 100] nodeselection/estimate/memsavepriority = 100 # minimal plunging depth, before new best node may be selected (-1 for dynamic setting) # [type: int, range: [-1,2147483647], default: -1] nodeselection/estimate/minplungedepth = -1 # maximal plunging depth, before new best node is forced to be selected (-1 for dynamic setting) # [type: int, range: [-1,2147483647], default: -1] nodeselection/estimate/maxplungedepth = -1 # maximal quotient (estimate - lowerbound)/(cutoffbound - lowerbound) where plunging is performed # [type: real, range: [0,1.79769313486232e+308], default: 0.25] nodeselection/estimate/maxplungequot = 0.25 # frequency at which the best node instead of the best estimate is selected (0: never) # [type: int, range: [0,2147483647], default: 10] nodeselection/estimate/bestnodefreq = 10 # priority of node selection rule in standard mode # [type: int, range: [-536870912,536870911], default: 50000] nodeselection/hybridestim/stdpriority = 50000 # priority of node selection rule in memory saving mode # [type: int, range: [-536870912,536870911], default: 50] nodeselection/hybridestim/memsavepriority = 50 # minimal plunging depth, before new best node may be selected (-1 for dynamic setting) # [type: int, range: [-1,2147483647], default: -1] nodeselection/hybridestim/minplungedepth = -1 # maximal plunging depth, before new best node is forced to be selected (-1 for dynamic setting) # [type: int, range: [-1,2147483647], default: -1] nodeselection/hybridestim/maxplungedepth = -1 # maximal quotient (estimate - lowerbound)/(cutoffbound - lowerbound) where plunging is performed # [type: real, range: [0,1.79769313486232e+308], default: 0.25] nodeselection/hybridestim/maxplungequot = 0.25 # frequency at which the best node instead of the hybrid best estimate / best bound is selected (0: never) # [type: int, range: [0,2147483647], default: 1000] nodeselection/hybridestim/bestnodefreq = 1000 # weight of estimate value in node selection score (0: pure best bound search, 1: pure best estimate search) # [type: real, range: [0,1], default: 0.1] nodeselection/hybridestim/estimweight = 0.1 # priority of node selection rule in standard mode # [type: int, range: [-536870912,536870911], default: 10000] nodeselection/restartdfs/stdpriority = 10000 # priority of node selection rule in memory saving mode # [type: int, range: [-536870912,536870911], default: 50000] nodeselection/restartdfs/memsavepriority = 50000 # frequency for selecting the best node instead of the deepest one (0: never) # [type: int, range: [0,2147483647], default: 1000] nodeselection/restartdfs/selectbestfreq = 1000 # priority of branching rule # [type: int, range: [-536870912,536870911], default: -1000] branching/allfullstrong/priority = -1000 # maximal depth level, up to which branching rule should be used (-1 for no limit) # [type: int, range: [-1,2147483647], default: -1] branching/allfullstrong/maxdepth = -1 # 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) # [type: real, range: [0,1], default: 1] branching/allfullstrong/maxbounddist = 1 # priority of branching rule # [type: int, range: [-536870912,536870911], default: 0] branching/fullstrong/priority = 0 # maximal depth level, up to which branching rule should be used (-1 for no limit) # [type: int, range: [-1,2147483647], default: -1] branching/fullstrong/maxdepth = -1 # 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) # [type: real, range: [0,1], default: 1] branching/fullstrong/maxbounddist = 1 # number of intermediate LPs solved to trigger reevaluation of strong branching value for a variable that was already evaluated at the current node # [type: int, range: [0,2147483647], default: 10] branching/fullstrong/reevalage = 10 # priority of branching rule # [type: int, range: [-536870912,536870911], default: 1000] branching/inference/priority = 1000 # maximal depth level, up to which branching rule should be used (-1 for no limit) # [type: int, range: [-1,2147483647], default: -1] branching/inference/maxdepth = -1 # 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) # [type: real, range: [0,1], default: 1] branching/inference/maxbounddist = 1 # factor to weigh conflict score against inference score # [type: real, range: [0,1.79769313486232e+308], default: 1000] branching/inference/conflictweight = 1000 # factor to weigh average number of cutoffs in branching score # [type: real, range: [0,1.79769313486232e+308], default: 1] branching/inference/cutoffweight = 1 # should branching on LP solution be restricted to the fractional variables? # [type: bool, range: {TRUE,FALSE}, default: TRUE] branching/inference/fractionals = TRUE # priority of branching rule # [type: int, range: [-536870912,536870911], default: 100] branching/mostinf/priority = 100 # maximal depth level, up to which branching rule should be used (-1 for no limit) # [type: int, range: [-1,2147483647], default: -1] branching/mostinf/maxdepth = -1 # 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) # [type: real, range: [0,1], default: 1] branching/mostinf/maxbounddist = 1 # priority of branching rule # [type: int, range: [-536870912,536870911], default: 50] branching/leastinf/priority = 50 # maximal depth level, up to which branching rule should be used (-1 for no limit) # [type: int, range: [-1,2147483647], default: -1] branching/leastinf/maxdepth = -1 # 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) # [type: real, range: [0,1], default: 1] branching/leastinf/maxbounddist = 1 # priority of branching rule # [type: int, range: [-536870912,536870911], default: 2000] branching/pscost/priority = 2000 # maximal depth level, up to which branching rule should be used (-1 for no limit) # [type: int, range: [-1,2147483647], default: -1] branching/pscost/maxdepth = -1 # 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) # [type: real, range: [0,1], default: 1] branching/pscost/maxbounddist = 1 # priority of branching rule # [type: int, range: [-536870912,536870911], default: -100000] branching/random/priority = -100000 # maximal depth level, up to which branching rule should be used (-1 for no limit) # [type: int, range: [-1,2147483647], default: -1] branching/random/maxdepth = -1 # 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) # [type: real, range: [0,1], default: 1] branching/random/maxbounddist = 1 # priority of branching rule # [type: int, range: [-536870912,536870911], default: 10000] branching/relpscost/priority = 10000 # maximal depth level, up to which branching rule should be used (-1 for no limit) # [type: int, range: [-1,2147483647], default: -1] branching/relpscost/maxdepth = -1 # 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) # [type: real, range: [0,1], default: 1] branching/relpscost/maxbounddist = 1 # weight in score calculations for conflict score # [type: real, range: [-1.79769313486232e+308,1.79769313486232e+308], default: 0.01] branching/relpscost/conflictweight = 0.01 # weight in score calculations for conflict length score # [type: real, range: [-1.79769313486232e+308,1.79769313486232e+308], default: 0] branching/relpscost/conflictlengthweight = 0 # weight in score calculations for inference score # [type: real, range: [-1.79769313486232e+308,1.79769313486232e+308], default: 0.0001] branching/relpscost/inferenceweight = 0.0001 # weight in score calculations for cutoff score # [type: real, range: [-1.79769313486232e+308,1.79769313486232e+308], default: 0.0001] branching/relpscost/cutoffweight = 0.0001 # weight in score calculations for pseudo cost score # [type: real, range: [-1.79769313486232e+308,1.79769313486232e+308], default: 1] branching/relpscost/pscostweight = 1 # minimal value for minimum pseudo cost size to regard pseudo cost value as reliable # [type: real, range: [0,1.79769313486232e+308], default: 1] branching/relpscost/minreliable = 1 # maximal value for minimum pseudo cost size to regard pseudo cost value as reliable # [type: real, range: [0,1.79769313486232e+308], default: 8] branching/relpscost/maxreliable = 1 # maximal fraction of strong branching LP iterations compared to node relaxation LP iterations # [type: real, range: [0,1.79769313486232e+308], default: 0.5] branching/relpscost/sbiterquot = 0.5 # additional number of allowed strong branching LP iterations # [type: int, range: [0,2147483647], default: 100000] branching/relpscost/sbiterofs = 100000 # maximal number of further variables evaluated without better score # [type: int, range: [1,2147483647], default: 8] branching/relpscost/maxlookahead = 8 # maximal number of candidates initialized with strong branching per node # [type: int, range: [0,2147483647], default: 100] branching/relpscost/initcand = 100 # iteration limit for strong branching initializations of pseudo cost entries (0: auto) # [type: int, range: [0,2147483647], default: 0] branching/relpscost/inititer = 10 # maximal number of bound tightenings before the node is reevaluated (-1: unlimited) # [type: int, range: [-1,2147483647], default: 5] branching/relpscost/maxbdchgs = 5 # priority of heuristic # [type: int, range: [-536870912,536870911], default: -1003700] heuristics/actconsdiving/priority = -1003700 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: -1] heuristics/actconsdiving/freq = -1 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 5] heuristics/actconsdiving/freqofs = 5 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/actconsdiving/maxdepth = -1 # minimal relative depth to start diving # [type: real, range: [0,1], default: 0] heuristics/actconsdiving/minreldepth = 0 # maximal relative depth to start diving # [type: real, range: [0,1], default: 1] heuristics/actconsdiving/maxreldepth = 1 # maximal fraction of diving LP iterations compared to node LP iterations # [type: real, range: [0,1.79769313486232e+308], default: 0.05] heuristics/actconsdiving/maxlpiterquot = 0.05 # additional number of allowed LP iterations # [type: int, range: [0,2147483647], default: 1000] heuristics/actconsdiving/maxlpiterofs = 1000 # maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit) # [type: real, range: [0,1], default: 0.8] heuristics/actconsdiving/maxdiveubquot = 0.8 # maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit) # [type: real, range: [0,1.79769313486232e+308], default: 0] heuristics/actconsdiving/maxdiveavgquot = 0 # maximal UBQUOT when no solution was found yet (0.0: no limit) # [type: real, range: [0,1], default: 0.1] heuristics/actconsdiving/maxdiveubquotnosol = 0.1 # maximal AVGQUOT when no solution was found yet (0.0: no limit) # [type: real, range: [0,1.79769313486232e+308], default: 0] heuristics/actconsdiving/maxdiveavgquotnosol = 0 # use one level of backtracking if infeasibility is encountered? # [type: bool, range: {TRUE,FALSE}, default: TRUE] heuristics/actconsdiving/backtrack = TRUE # priority of heuristic # [type: int, range: [-536870912,536870911], default: -1001000] heuristics/coefdiving/priority = -1001000 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: 10] heuristics/coefdiving/freq = -1 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 1] heuristics/coefdiving/freqofs = 1 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/coefdiving/maxdepth = -1 # minimal relative depth to start diving # [type: real, range: [0,1], default: 0] heuristics/coefdiving/minreldepth = 0 # maximal relative depth to start diving # [type: real, range: [0,1], default: 1] heuristics/coefdiving/maxreldepth = 1 # maximal fraction of diving LP iterations compared to node LP iterations # [type: real, range: [0,1.79769313486232e+308], default: 0.05] heuristics/coefdiving/maxlpiterquot = 0.05 # additional number of allowed LP iterations # [type: int, range: [0,2147483647], default: 1000] heuristics/coefdiving/maxlpiterofs = 1000 # maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit) # [type: real, range: [0,1], default: 0.8] heuristics/coefdiving/maxdiveubquot = 0.8 # maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit) # [type: real, range: [0,1.79769313486232e+308], default: 0] heuristics/coefdiving/maxdiveavgquot = 0 # maximal UBQUOT when no solution was found yet (0.0: no limit) # [type: real, range: [0,1], default: 0.1] heuristics/coefdiving/maxdiveubquotnosol = 0.1 # maximal AVGQUOT when no solution was found yet (0.0: no limit) # [type: real, range: [0,1.79769313486232e+308], default: 0] heuristics/coefdiving/maxdiveavgquotnosol = 0 # use one level of backtracking if infeasibility is encountered? # [type: bool, range: {TRUE,FALSE}, default: TRUE] heuristics/coefdiving/backtrack = TRUE # priority of heuristic # [type: int, range: [-536870912,536870911], default: -1104000] heuristics/crossover/priority = -1104000 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: 30] heuristics/crossover/freq = -1 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 10] heuristics/crossover/freqofs = 10 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/crossover/maxdepth = -1 # number of nodes added to the contingent of the total nodes # [type: longint, range: [0,9223372036854775807], default: 500] heuristics/crossover/nodesofs = 500 # maximum number of nodes to regard in the subproblem # [type: longint, range: [0,9223372036854775807], default: 5000] heuristics/crossover/maxnodes = 5000 # minimum number of nodes required to start the subproblem # [type: longint, range: [0,9223372036854775807], default: 500] heuristics/crossover/minnodes = 500 # number of solutions to be taken into account # [type: int, range: [2,2147483647], default: 3] heuristics/crossover/nusedsols = 3 # number of nodes without incumbent change that heuristic should wait # [type: longint, range: [0,9223372036854775807], default: 200] heuristics/crossover/nwaitingnodes = 200 # contingent of sub problem nodes in relation to the number of nodes of the original problem # [type: real, range: [0,1], default: 0.1] heuristics/crossover/nodesquot = 0.1 # minimum percentage of integer variables that have to be fixed # [type: real, range: [0,1], default: 0.666] heuristics/crossover/minfixingrate = 0.666 # factor by which Crossover should at least improve the incumbent # [type: real, range: [0,1], default: 0.01] heuristics/crossover/minimprove = 0.01 # should the choice which sols to take be randomized? # [type: bool, range: {TRUE,FALSE}, default: TRUE] heuristics/crossover/randomization = TRUE # priority of heuristic # [type: int, range: [-536870912,536870911], default: -1105000] heuristics/dins/priority = -1105000 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: -1] heuristics/dins/freq = -1 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 0] heuristics/dins/freqofs = 0 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/dins/maxdepth = -1 # number of nodes added to the contingent of the total nodes # [type: longint, range: [0,9223372036854775807], default: 5000] heuristics/dins/nodesofs = 5000 # contingent of sub problem nodes in relation to the number of nodes of the original problem # [type: real, range: [0,1], default: 0.05] heuristics/dins/nodesquot = 0.05 # minimum number of nodes required to start the subproblem # [type: longint, range: [0,9223372036854775807], default: 500] heuristics/dins/minnodes = 500 # number of pool-solutions to be checked for flag array update (for hard fixing of binary variables) # [type: int, range: [1,2147483647], default: 5] heuristics/dins/solnum = 5 # radius (using Manhattan metric) of the incumbent's neighborhood to be searched # [type: int, range: [1,2147483647], default: 18] heuristics/dins/neighborhoodsize = 18 # maximum number of nodes to regard in the subproblem # [type: longint, range: [0,9223372036854775807], default: 5000] heuristics/dins/maxnodes = 5000 # factor by which DINS should at least improve the incumbent # [type: real, range: [0,1], default: 0.01] heuristics/dins/minimprove = 0.01 # number of nodes without incumbent change that heuristic should wait # [type: longint, range: [0,9223372036854775807], default: 0] heuristics/dins/nwaitingnodes = 0 # priority of heuristic # [type: int, range: [-536870912,536870911], default: -1000000] heuristics/feaspump/priority = -1000000 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: 20] heuristics/feaspump/freq = -1 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 0] heuristics/feaspump/freqofs = 0 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/feaspump/maxdepth = -1 # maximal fraction of diving LP iterations compared to node LP iterations # [type: real, range: [0,1.79769313486232e+308], default: 0.01] heuristics/feaspump/maxlpiterquot = 0.01 # additional number of allowed LP iterations # [type: int, range: [0,2147483647], default: 1000] heuristics/feaspump/maxlpiterofs = 1000 # total number of feasible solutions found up to which heuristic is called (-1: no limit) # [type: int, range: [-1,2147483647], default: 2] heuristics/feaspump/maxsols = 2 # factor by which the regard of the objective is decreased in each round, 1.0 for dynamic # [type: real, range: [0,1], default: 1] heuristics/feaspump/objfactor = 1 # maximal number of pumping loops (-1: no limit) # [type: int, range: [-1,2147483647], default: 10000] heuristics/feaspump/maxloops = 10000 # maximal number of pumping rounds without fractionality improvement (-1: no limit) # [type: int, range: [-1,2147483647], default: 10] heuristics/feaspump/maxstallloops = 10 # minimum number of random variables to flip, if a 1-cycle is encountered # [type: int, range: [1,2147483647], default: 10] heuristics/feaspump/minflips = 10 # maximum length of cycles to be checked explicitly in each round # [type: int, range: [1,100], default: 3] heuristics/feaspump/cyclelength = 3 # number of iterations until a random perturbation is forced # [type: int, range: [1,2147483647], default: 100] heuristics/feaspump/perturbfreq = 100 # should the feasibility pump be called at root node before cut separation? # [type: bool, range: {TRUE,FALSE}, default: TRUE] heuristics/feaspump/beforecuts = TRUE # priority of heuristic # [type: int, range: [-536870912,536870911], default: -500000] heuristics/fixandinfer/priority = -500000 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: -1] heuristics/fixandinfer/freq = -1 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 0] heuristics/fixandinfer/freqofs = 0 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/fixandinfer/maxdepth = -1 # maximal number of propagation rounds in probing subproblems (-1: no limit, 0: auto) # [type: int, range: [-1,2147483647], default: 0] heuristics/fixandinfer/proprounds = 0 # minimal number of fixings to apply before dive may be aborted # [type: int, range: [0,2147483647], default: 100] heuristics/fixandinfer/minfixings = 100 # priority of heuristic # [type: int, range: [-536870912,536870911], default: -1003000] heuristics/fracdiving/priority = -1003000 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: 10] heuristics/fracdiving/freq = -1 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 3] heuristics/fracdiving/freqofs = 3 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/fracdiving/maxdepth = -1 # minimal relative depth to start diving # [type: real, range: [0,1], default: 0] heuristics/fracdiving/minreldepth = 0 # maximal relative depth to start diving # [type: real, range: [0,1], default: 1] heuristics/fracdiving/maxreldepth = 1 # maximal fraction of diving LP iterations compared to node LP iterations # [type: real, range: [0,1.79769313486232e+308], default: 0.05] heuristics/fracdiving/maxlpiterquot = 0.05 # additional number of allowed LP iterations # [type: int, range: [0,2147483647], default: 1000] heuristics/fracdiving/maxlpiterofs = 1000 # maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit) # [type: real, range: [0,1], default: 0.8] heuristics/fracdiving/maxdiveubquot = 0.8 # maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit) # [type: real, range: [0,1.79769313486232e+308], default: 0] heuristics/fracdiving/maxdiveavgquot = 0 # maximal UBQUOT when no solution was found yet (0.0: no limit) # [type: real, range: [0,1], default: 0.1] heuristics/fracdiving/maxdiveubquotnosol = 0.1 # maximal AVGQUOT when no solution was found yet (0.0: no limit) # [type: real, range: [0,1.79769313486232e+308], default: 0] heuristics/fracdiving/maxdiveavgquotnosol = 0 # use one level of backtracking if infeasibility is encountered? # [type: bool, range: {TRUE,FALSE}, default: TRUE] heuristics/fracdiving/backtrack = TRUE # priority of heuristic # [type: int, range: [-536870912,536870911], default: -1007000] heuristics/guideddiving/priority = -1007000 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: 10] heuristics/guideddiving/freq = -1 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 7] heuristics/guideddiving/freqofs = 7 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/guideddiving/maxdepth = -1 # minimal relative depth to start diving # [type: real, range: [0,1], default: 0] heuristics/guideddiving/minreldepth = 0 # maximal relative depth to start diving # [type: real, range: [0,1], default: 1] heuristics/guideddiving/maxreldepth = 1 # maximal fraction of diving LP iterations compared to node LP iterations # [type: real, range: [0,1.79769313486232e+308], default: 0.05] heuristics/guideddiving/maxlpiterquot = 0.05 # additional number of allowed LP iterations # [type: int, range: [0,2147483647], default: 1000] heuristics/guideddiving/maxlpiterofs = 1000 # maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit) # [type: real, range: [0,1], default: 0.8] heuristics/guideddiving/maxdiveubquot = 0.8 # maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit) # [type: real, range: [0,1.79769313486232e+308], default: 0] heuristics/guideddiving/maxdiveavgquot = 0 # use one level of backtracking if infeasibility is encountered? # [type: bool, range: {TRUE,FALSE}, default: TRUE] heuristics/guideddiving/backtrack = TRUE # priority of heuristic # [type: int, range: [-536870912,536870911], default: -1003500] heuristics/intdiving/priority = -1003500 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: -1] heuristics/intdiving/freq = -1 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 9] heuristics/intdiving/freqofs = 9 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/intdiving/maxdepth = -1 # minimal relative depth to start diving # [type: real, range: [0,1], default: 0] heuristics/intdiving/minreldepth = 0 # maximal relative depth to start diving # [type: real, range: [0,1], default: 1] heuristics/intdiving/maxreldepth = 1 # maximal fraction of diving LP iterations compared to node LP iterations # [type: real, range: [0,1.79769313486232e+308], default: 0.05] heuristics/intdiving/maxlpiterquot = 0.05 # additional number of allowed LP iterations # [type: int, range: [0,2147483647], default: 1000] heuristics/intdiving/maxlpiterofs = 1000 # maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit) # [type: real, range: [0,1], default: 0.8] heuristics/intdiving/maxdiveubquot = 0.8 # maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit) # [type: real, range: [0,1.79769313486232e+308], default: 0] heuristics/intdiving/maxdiveavgquot = 0 # maximal UBQUOT when no solution was found yet (0.0: no limit) # [type: real, range: [0,1], default: 0.1] heuristics/intdiving/maxdiveubquotnosol = 0.1 # maximal AVGQUOT when no solution was found yet (0.0: no limit) # [type: real, range: [0,1.79769313486232e+308], default: 0] heuristics/intdiving/maxdiveavgquotnosol = 0 # use one level of backtracking if infeasibility is encountered? # [type: bool, range: {TRUE,FALSE}, default: TRUE] heuristics/intdiving/backtrack = TRUE # priority of heuristic # [type: int, range: [-536870912,536870911], default: -10000] heuristics/intshifting/priority = -10000 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: 10] heuristics/intshifting/freq = 10 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 0] heuristics/intshifting/freqofs = 0 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/intshifting/maxdepth = -1 # priority of heuristic # [type: int, range: [-536870912,536870911], default: -1006000] heuristics/linesearchdiving/priority = -1006000 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: 10] heuristics/linesearchdiving/freq = -1 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 6] heuristics/linesearchdiving/freqofs = 6 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/linesearchdiving/maxdepth = -1 # minimal relative depth to start diving # [type: real, range: [0,1], default: 0] heuristics/linesearchdiving/minreldepth = 0 # maximal relative depth to start diving # [type: real, range: [0,1], default: 1] heuristics/linesearchdiving/maxreldepth = 1 # maximal fraction of diving LP iterations compared to node LP iterations # [type: real, range: [0,1.79769313486232e+308], default: 0.05] heuristics/linesearchdiving/maxlpiterquot = 0.05 # additional number of allowed LP iterations # [type: int, range: [0,2147483647], default: 1000] heuristics/linesearchdiving/maxlpiterofs = 1000 # maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit) # [type: real, range: [0,1], default: 0.8] heuristics/linesearchdiving/maxdiveubquot = 0.8 # maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit) # [type: real, range: [0,1.79769313486232e+308], default: 0] heuristics/linesearchdiving/maxdiveavgquot = 0 # maximal UBQUOT when no solution was found yet (0.0: no limit) # [type: real, range: [0,1], default: 0.1] heuristics/linesearchdiving/maxdiveubquotnosol = 0.1 # maximal AVGQUOT when no solution was found yet (0.0: no limit) # [type: real, range: [0,1.79769313486232e+308], default: 0] heuristics/linesearchdiving/maxdiveavgquotnosol = 0 # use one level of backtracking if infeasibility is encountered? # [type: bool, range: {TRUE,FALSE}, default: TRUE] heuristics/linesearchdiving/backtrack = TRUE # priority of heuristic # [type: int, range: [-536870912,536870911], default: -1102000] heuristics/localbranching/priority = -1102000 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: -1] heuristics/localbranching/freq = -1 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 0] heuristics/localbranching/freqofs = 0 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/localbranching/maxdepth = -1 # number of nodes added to the contingent of the total nodes # [type: int, range: [0,2147483647], default: 1000] heuristics/localbranching/nodesofs = 1000 # radius (using Manhattan metric) of the incumbent's neighborhood to be searched # [type: int, range: [1,2147483647], default: 18] heuristics/localbranching/neighborhoodsize = 18 # contingent of sub problem nodes in relation to the number of nodes of the original problem # [type: real, range: [0,1], default: 0.05] heuristics/localbranching/nodesquot = 0.05 # minimum number of nodes required to start the subproblem # [type: int, range: [0,2147483647], default: 1000] heuristics/localbranching/minnodes = 1000 # maximum number of nodes to regard in the subproblem # [type: int, range: [0,2147483647], default: 10000] heuristics/localbranching/maxnodes = 10000 # number of nodes without incumbent change that heuristic should wait # [type: int, range: [0,2147483647], default: 200] heuristics/localbranching/nwaitingnodes = 200 # factor by which localbranching should at least improve the incumbent # [type: real, range: [0,1], default: 0.01] heuristics/localbranching/minimprove = 0.01 # priority of heuristic # [type: int, range: [-536870912,536870911], default: -1103000] heuristics/mutation/priority = -1103000 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: -1] heuristics/mutation/freq = -1 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 8] heuristics/mutation/freqofs = 8 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/mutation/maxdepth = -1 # number of nodes added to the contingent of the total nodes # [type: int, range: [0,2147483647], default: 500] heuristics/mutation/nodesofs = 500 # maximum number of nodes to regard in the subproblem # [type: int, range: [0,2147483647], default: 5000] heuristics/mutation/maxnodes = 5000 # minimum number of nodes required to start the subproblem # [type: int, range: [0,2147483647], default: 500] heuristics/mutation/minnodes = 500 # number of nodes without incumbent change that heuristic should wait # [type: int, range: [0,2147483647], default: 200] heuristics/mutation/nwaitingnodes = 200 # contingent of sub problem nodes in relation to the number of nodes of the original problem # [type: real, range: [0,1], default: 0.1] heuristics/mutation/nodesquot = 0.1 # percentage of integer variables that have to be fixed # [type: real, range: [1e-06,0.999999], default: 0.8] heuristics/mutation/minfixingrate = 0.8 # factor by which Mutation should at least improve the incumbent # [type: real, range: [0,1], default: 0.01] heuristics/mutation/minimprove = 0.01 # priority of heuristic # [type: int, range: [-536870912,536870911], default: -2000000] heuristics/nlp/priority = -2000000 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: 10] heuristics/nlp/freq = 10 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 0] heuristics/nlp/freqofs = 0 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/nlp/maxdepth = -1 # verbosity level of NLP solver # [type: int, range: [0,2], default: 0] heuristics/nlp/nlpverblevel = 0 # iteration limit of NLP solver; 0 to use solver default # [type: int, range: [0,2147483647], default: 0] heuristics/nlp/nlpiterlimit = 0 # time limit of NLP solver; 0 to use solver default # [type: real, range: [0,1e+20], default: 0] heuristics/nlp/nlptimelimit = 0 # if SCIP does not accept a solution which the NLP solver thinks is feasible, the feasibility tolerance is reduced by this factor and the NLP resolved (set to 1. to turn off resolve # [type: real, range: [0,1], default: 0.01] heuristics/nlp/resolvetolfactor = 0.01 # whether a resolve of an NLP due to disagreement of feasibility should be from the original starting point or the infeasible solution # [type: bool, range: {TRUE,FALSE}, default: TRUE] heuristics/nlp/resolvefromscratch = TRUE # number of iterations added to the contingent of the total number of iterations # [type: int, range: [0,2147483647], default: 500] heuristics/nlp/iteroffset = 500 # contingent of NLP iterations in relation to the number of nodes in SCIP # [type: real, range: [0,1e+20], default: 0.1] heuristics/nlp/iterquotient = 0.1 # contingent of NLP iterations in relation to the number of nodes in SCIP # [type: int, range: [0,2147483647], default: 300] heuristics/nlp/itermin = 300 # whether variable bound constraints should be handled explicitly before solving NLP instead of adding them to the NLP # [type: bool, range: {TRUE,FALSE}, default: TRUE] heuristics/nlp/varboundexplicit = TRUE # priority of heuristic # [type: int, range: [-536870912,536870911], default: -1004000] heuristics/objpscostdiving/priority = -1004000 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: 20] heuristics/objpscostdiving/freq = -1 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 4] heuristics/objpscostdiving/freqofs = 4 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/objpscostdiving/maxdepth = -1 # minimal relative depth to start diving # [type: real, range: [0,1], default: 0] heuristics/objpscostdiving/minreldepth = 0 # maximal relative depth to start diving # [type: real, range: [0,1], default: 1] heuristics/objpscostdiving/maxreldepth = 1 # maximal fraction of diving LP iterations compared to total iteration number # [type: real, range: [0,1], default: 0.01] heuristics/objpscostdiving/maxlpiterquot = 0.01 # additional number of allowed LP iterations # [type: int, range: [0,2147483647], default: 1000] heuristics/objpscostdiving/maxlpiterofs = 1000 # total number of feasible solutions found up to which heuristic is called (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/objpscostdiving/maxsols = -1 # maximal diving depth: number of binary/integer variables times depthfac # [type: real, range: [0,1.79769313486232e+308], default: 0.5] heuristics/objpscostdiving/depthfac = 0.5 # maximal diving depth factor if no feasible solution was found yet # [type: real, range: [0,1.79769313486232e+308], default: 2] heuristics/objpscostdiving/depthfacnosol = 2 # priority of heuristic # [type: int, range: [-536870912,536870911], default: -1008000] heuristics/octane/priority = -1008000 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: -1] heuristics/octane/freq = -1 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 0] heuristics/octane/freqofs = 0 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/octane/maxdepth = -1 # number of 0-1-points to be tested as possible solutions by OCTANE # [type: int, range: [1,2147483647], default: 100] heuristics/octane/fmax = 100 # number of 0-1-points to be tested at first whether they violate a common row # [type: int, range: [1,2147483647], default: 10] heuristics/octane/ffirst = 10 # execute OCTANE only in the space of fractional variables (TRUE) or in the full space? # [type: bool, range: {TRUE,FALSE}, default: TRUE] heuristics/octane/usefracspace = TRUE # should the inner normal of the objective be used as one ray direction? # [type: bool, range: {TRUE,FALSE}, default: TRUE] heuristics/octane/useobjray = TRUE # should the average of the basic cone be used as one ray direction? # [type: bool, range: {TRUE,FALSE}, default: TRUE] heuristics/octane/useavgray = TRUE # should the difference between the root solution and the current LP solution be used as one ray direction? # [type: bool, range: {TRUE,FALSE}, default: FALSE] heuristics/octane/usediffray = FALSE # should the weighted average of the basic cone be used as one ray direction? # [type: bool, range: {TRUE,FALSE}, default: TRUE] heuristics/octane/useavgwgtray = TRUE # should the weighted average of the nonbasic cone be used as one ray direction? # [type: bool, range: {TRUE,FALSE}, default: TRUE] heuristics/octane/useavgnbray = TRUE # priority of heuristic # [type: int, range: [-536870912,536870911], default: -20000] heuristics/oneopt/priority = -20000 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: 1] heuristics/oneopt/freq = 1 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 0] heuristics/oneopt/freqofs = 0 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/oneopt/maxdepth = -1 # should the objective be weighted with the potential shifting value when sorting the shifting candidates? # [type: bool, range: {TRUE,FALSE}, default: TRUE] heuristics/oneopt/weightedobj = TRUE # should the heuristic be called before and during the root node? # [type: bool, range: {TRUE,FALSE}, default: TRUE] heuristics/oneopt/duringroot = FALSE # priority of heuristic # [type: int, range: [-536870912,536870911], default: -1002000] heuristics/pscostdiving/priority = -1002000 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: 10] heuristics/pscostdiving/freq = -1 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 2] heuristics/pscostdiving/freqofs = 2 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/pscostdiving/maxdepth = -1 # minimal relative depth to start diving # [type: real, range: [0,1], default: 0] heuristics/pscostdiving/minreldepth = 0 # maximal relative depth to start diving # [type: real, range: [0,1], default: 1] heuristics/pscostdiving/maxreldepth = 1 # maximal fraction of diving LP iterations compared to node LP iterations # [type: real, range: [0,1.79769313486232e+308], default: 0.05] heuristics/pscostdiving/maxlpiterquot = 0.05 # additional number of allowed LP iterations # [type: int, range: [0,2147483647], default: 1000] heuristics/pscostdiving/maxlpiterofs = 1000 # maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit) # [type: real, range: [0,1], default: 0.8] heuristics/pscostdiving/maxdiveubquot = 0.8 # maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit) # [type: real, range: [0,1.79769313486232e+308], default: 0] heuristics/pscostdiving/maxdiveavgquot = 0 # maximal UBQUOT when no solution was found yet (0.0: no limit) # [type: real, range: [0,1], default: 0.1] heuristics/pscostdiving/maxdiveubquotnosol = 0.1 # maximal AVGQUOT when no solution was found yet (0.0: no limit) # [type: real, range: [0,1.79769313486232e+308], default: 0] heuristics/pscostdiving/maxdiveavgquotnosol = 0 # use one level of backtracking if infeasibility is encountered? # [type: bool, range: {TRUE,FALSE}, default: TRUE] heuristics/pscostdiving/backtrack = TRUE # priority of heuristic # [type: int, range: [-536870912,536870911], default: -1100000] heuristics/rens/priority = -1100000 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: 0] heuristics/rens/freq = -1 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 0] heuristics/rens/freqofs = 0 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/rens/maxdepth = -1 # minimum percentage of integer variables that have to be fixable # [type: real, range: [0,1], default: 0.5] heuristics/rens/minfixingrate = 0.5 # maximum number of nodes to regard in the subproblem # [type: longint, range: [0,9223372036854775807], default: 5000] heuristics/rens/maxnodes = 5000 # should general integers get binary bounds [floor(.),ceil(.)] ? # [type: bool, range: {TRUE,FALSE}, default: TRUE] heuristics/rens/binarybounds = TRUE # number of nodes added to the contingent of the total nodes # [type: longint, range: [0,9223372036854775807], default: 500] heuristics/rens/nodesofs = 500 # minimum number of nodes required to start the subproblem # [type: longint, range: [0,9223372036854775807], default: 500] heuristics/rens/minnodes = 500 # contingent of sub problem nodes in relation to the number of nodes of the original problem # [type: real, range: [0,1], default: 0.1] heuristics/rens/nodesquot = 0.1 # factor by which RENS should at least improve the incumbent # [type: real, range: [0,1], default: 0.01] heuristics/rens/minimprove = 0.01 # priority of heuristic # [type: int, range: [-536870912,536870911], default: -1101000] heuristics/rins/priority = -1101000 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: -1] heuristics/rins/freq = -1 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 5] heuristics/rins/freqofs = 5 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/rins/maxdepth = -1 # number of nodes added to the contingent of the total nodes # [type: int, range: [0,2147483647], default: 500] heuristics/rins/nodesofs = 500 # maximum number of nodes to regard in the subproblem # [type: int, range: [0,2147483647], default: 5000] heuristics/rins/maxnodes = 5000 # minimum number of nodes required to start the subproblem # [type: int, range: [0,2147483647], default: 500] heuristics/rins/minnodes = 500 # contingent of sub problem nodes in relation to the number of nodes of the original problem # [type: real, range: [0,1], default: 0.1] heuristics/rins/nodesquot = 0.1 # number of nodes without incumbent change that heuristic should wait # [type: int, range: [0,2147483647], default: 200] heuristics/rins/nwaitingnodes = 200 # factor by which RINS should at least improve the incumbent # [type: real, range: [0,1], default: 0.01] heuristics/rins/minimprove = 0.01 # minimum percentage of integer variables that have to be fixed # [type: real, range: [0,1], default: 0] heuristics/rins/minfixingrate = 0 # priority of heuristic # [type: int, range: [-536870912,536870911], default: -1005000] heuristics/rootsoldiving/priority = -1005000 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: 20] heuristics/rootsoldiving/freq = -1 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 5] heuristics/rootsoldiving/freqofs = 5 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/rootsoldiving/maxdepth = -1 # minimal relative depth to start diving # [type: real, range: [0,1], default: 0] heuristics/rootsoldiving/minreldepth = 0 # maximal relative depth to start diving # [type: real, range: [0,1], default: 1] heuristics/rootsoldiving/maxreldepth = 1 # maximal fraction of diving LP iterations compared to node LP iterations # [type: real, range: [0,1.79769313486232e+308], default: 0.01] heuristics/rootsoldiving/maxlpiterquot = 0.01 # additional number of allowed LP iterations # [type: int, range: [0,2147483647], default: 1000] heuristics/rootsoldiving/maxlpiterofs = 1000 # total number of feasible solutions found up to which heuristic is called (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/rootsoldiving/maxsols = -1 # maximal diving depth: number of binary/integer variables times depthfac # [type: real, range: [0,1.79769313486232e+308], default: 0.5] heuristics/rootsoldiving/depthfac = 0.5 # maximal diving depth factor if no feasible solution was found yet # [type: real, range: [0,1.79769313486232e+308], default: 2] heuristics/rootsoldiving/depthfacnosol = 2 # priority of heuristic # [type: int, range: [-536870912,536870911], default: -1000] heuristics/rounding/priority = -1000 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: 1] heuristics/rounding/freq = 1 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 0] heuristics/rounding/freqofs = 0 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/rounding/maxdepth = -1 # priority of heuristic # [type: int, range: [-536870912,536870911], default: -5000] heuristics/shifting/priority = -5000 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: 10] heuristics/shifting/freq = 10 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 0] heuristics/shifting/freqofs = 0 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/shifting/maxdepth = -1 # priority of heuristic # [type: int, range: [-536870912,536870911], default: 0] heuristics/simplerounding/priority = 0 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: 1] heuristics/simplerounding/freq = 1 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 0] heuristics/simplerounding/freqofs = 0 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/simplerounding/maxdepth = -1 # priority of heuristic # [type: int, range: [-536870912,536870911], default: 1000] heuristics/trivial/priority = 1000 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: 0] heuristics/trivial/freq = 0 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 0] heuristics/trivial/freqofs = 0 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/trivial/maxdepth = -1 # priority of heuristic # [type: int, range: [-536870912,536870911], default: -3000000] heuristics/trysol/priority = -3000000 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: 1] heuristics/trysol/freq = 1 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 0] heuristics/trysol/freqofs = 0 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/trysol/maxdepth = -1 # priority of heuristic # [type: int, range: [-536870912,536870911], default: -1003100] heuristics/veclendiving/priority = -1003100 # frequency for calling primal heuristic (-1: never, 0: only at depth freqofs) # [type: int, range: [-1,2147483647], default: 10] heuristics/veclendiving/freq = -1 # frequency offset for calling primal heuristic # [type: int, range: [0,2147483647], default: 4] heuristics/veclendiving/freqofs = 4 # maximal depth level to call primal heuristic (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] heuristics/veclendiving/maxdepth = -1 # minimal relative depth to start diving # [type: real, range: [0,1], default: 0] heuristics/veclendiving/minreldepth = 0 # maximal relative depth to start diving # [type: real, range: [0,1], default: 1] heuristics/veclendiving/maxreldepth = 1 # maximal fraction of diving LP iterations compared to node LP iterations # [type: real, range: [0,1.79769313486232e+308], default: 0.05] heuristics/veclendiving/maxlpiterquot = 0.05 # additional number of allowed LP iterations # [type: int, range: [0,2147483647], default: 1000] heuristics/veclendiving/maxlpiterofs = 1000 # maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit) # [type: real, range: [0,1], default: 0.8] heuristics/veclendiving/maxdiveubquot = 0.8 # maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit) # [type: real, range: [0,1.79769313486232e+308], default: 0] heuristics/veclendiving/maxdiveavgquot = 0 # maximal UBQUOT when no solution was found yet (0.0: no limit) # [type: real, range: [0,1], default: 0.1] heuristics/veclendiving/maxdiveubquotnosol = 0.1 # maximal AVGQUOT when no solution was found yet (0.0: no limit) # [type: real, range: [0,1.79769313486232e+308], default: 0] heuristics/veclendiving/maxdiveavgquotnosol = 0 # use one level of backtracking if infeasibility is encountered? # [type: bool, range: {TRUE,FALSE}, default: TRUE] heuristics/veclendiving/backtrack = TRUE # priority of propagator # [type: int, range: [-536870912,536870911], default: 0] propagating/pseudoobj/priority = 0 # frequency for calling propagator (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 1] propagating/pseudoobj/freq = 1 # should propagator be delayed, if other propagators found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] propagating/pseudoobj/delay = FALSE # maximal number of variables to look at in a single propagation round (-1: process all variables) # [type: int, range: [-1,2147483647], default: 100] propagating/pseudoobj/maxcands = 100 # priority of propagator # [type: int, range: [-536870912,536870911], default: 1000000] propagating/rootredcost/priority = 1000000 # frequency for calling propagator (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 1] propagating/rootredcost/freq = 1 # should propagator be delayed, if other propagators found reductions? # [type: bool, range: {TRUE,FALSE}, default: FALSE] propagating/rootredcost/delay = FALSE # priority of separator # [type: int, range: [-536870912,536870911], default: -5000] separating/clique/priority = -5000 # frequency for calling separator (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 0] separating/clique/freq = 0 # maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator (0.0: only on current best node, 1.0: on all nodes) # [type: real, range: [0,1], default: 0] separating/clique/maxbounddist = 0 # should separator be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] separating/clique/delay = FALSE # factor for scaling weights # [type: real, range: [1,1.79769313486232e+308], default: 1000] separating/clique/scaleval = 1000 # maximal number of nodes in branch and bound tree (-1: no limit) # [type: int, range: [-1,2147483647], default: -1] separating/clique/maxtreenodes = -1 # frequency for premature backtracking up to tree level 1 (0: no backtracking) # [type: int, range: [0,2147483647], default: 10000] separating/clique/backtrackfreq = 10000 # maximal number of clique cuts separated per separation round (-1: no limit) # [type: int, range: [-1,2147483647], default: 10] separating/clique/maxsepacuts = 10 # maximal number of zero-valued variables extending the clique (-1: no limit) # [type: int, range: [-1,2147483647], default: 1000] separating/clique/maxzeroextensions = 1000 # maximal memory size of dense clique table (in kb) # [type: real, range: [0,2097151.99902344], default: 20000] separating/clique/cliquetablemem = 20000 # minimal density of cliques to use a dense clique table # [type: real, range: [0,1], default: 0.05] separating/clique/cliquedensity = 0.05 # priority of separator # [type: int, range: [-536870912,536870911], default: -3000] separating/cmir/priority = -3000 # frequency for calling separator (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 0] separating/cmir/freq = 0 # maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator (0.0: only on current best node, 1.0: on all nodes) # [type: real, range: [0,1], default: 0] separating/cmir/maxbounddist = 0 # should separator be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] separating/cmir/delay = FALSE # maximal number of cmir separation rounds per node (-1: unlimited) # [type: int, range: [-1,2147483647], default: 3] separating/cmir/maxrounds = 3 # maximal number of cmir separation rounds in the root node (-1: unlimited) # [type: int, range: [-1,2147483647], default: 10] separating/cmir/maxroundsroot = 10 # maximal number of rows to start aggregation with per separation round (-1: unlimited) # [type: int, range: [-1,2147483647], default: 100] separating/cmir/maxtries = 100 # maximal number of rows to start aggregation with per separation round in the root node (-1: unlimited) # [type: int, range: [-1,2147483647], default: -1] separating/cmir/maxtriesroot = -1 # maximal number of consecutive unsuccesful aggregation tries (-1: unlimited) # [type: int, range: [-1,2147483647], default: 20] separating/cmir/maxfails = 20 # maximal number of consecutive unsuccesful aggregation tries in the root node (-1: unlimited) # [type: int, range: [-1,2147483647], default: 100] separating/cmir/maxfailsroot = 100 # maximal number of aggregations for each row per separation round # [type: int, range: [0,2147483647], default: 3] separating/cmir/maxaggrs = 3 # maximal number of aggregations for each row per separation round in the root node # [type: int, range: [0,2147483647], default: 6] separating/cmir/maxaggrsroot = 6 # maximal number of cmir cuts separated per separation round # [type: int, range: [0,2147483647], default: 100] separating/cmir/maxsepacuts = 100 # maximal number of cmir cuts separated per separation round in the root node # [type: int, range: [0,2147483647], default: 500] separating/cmir/maxsepacutsroot = 500 # maximal slack of rows to be used in aggregation # [type: real, range: [0,1.79769313486232e+308], default: 0] separating/cmir/maxslack = 0 # maximal slack of rows to be used in aggregation in the root node # [type: real, range: [0,1.79769313486232e+308], default: 0.1] separating/cmir/maxslackroot = 0.1 # weight of row density in the aggregation scoring of the rows # [type: real, range: [0,1.79769313486232e+308], default: 0.0001] separating/cmir/densityscore = 0.0001 # weight of slack in the aggregation scoring of the rows # [type: real, range: [0,1.79769313486232e+308], default: 0.001] separating/cmir/slackscore = 0.001 # maximal density of aggregated row # [type: real, range: [0,1], default: 0.2] separating/cmir/maxaggdensity = 0.2 # maximal density of row to be used in aggregation # [type: real, range: [0,1], default: 0.05] separating/cmir/maxrowdensity = 0.05 # additional number of variables allowed in row on top of density # [type: int, range: [0,2147483647], default: 100] separating/cmir/densityoffset = 100 # maximal row aggregation factor # [type: real, range: [0,1.79769313486232e+308], default: 10000] separating/cmir/maxrowfac = 10000 # maximal number of different deltas to try (-1: unlimited) # [type: int, range: [-1,2147483647], default: -1] separating/cmir/maxtestdelta = -1 # maximal number of active continuous variables in aggregated row # [type: int, range: [0,2147483647], default: 10] separating/cmir/maxconts = 10 # maximal number of active continuous variables in aggregated row in the root node # [type: int, range: [0,2147483647], default: 10] separating/cmir/maxcontsroot = 10 # tolerance for bounddistances used to select continuous variable in current aggregated constraint to be eliminated # [type: real, range: [0,1.79769313486232e+308], default: 0.1] separating/cmir/aggrtol = 0.1 # should negative values also be tested in scaling? # [type: bool, range: {TRUE,FALSE}, default: TRUE] separating/cmir/trynegscaling = TRUE # should an additional variable be complemented if f0 = 0? # [type: bool, range: {TRUE,FALSE}, default: TRUE] separating/cmir/fixintegralrhs = TRUE # should generated cuts be removed from the LP if they are no longer tight? # [type: bool, range: {TRUE,FALSE}, default: TRUE] separating/cmir/dynamiccuts = TRUE # priority of separator # [type: int, range: [-536870912,536870911], default: -4000] separating/flowcover/priority = -4000 # frequency for calling separator (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 0] separating/flowcover/freq = 0 # maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator (0.0: only on current best node, 1.0: on all nodes) # [type: real, range: [0,1], default: 0] separating/flowcover/maxbounddist = 0 # should separator be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] separating/flowcover/delay = FALSE # maximal number of separation rounds per node (-1: unlimited) # [type: int, range: [-1,2147483647], default: 5] separating/flowcover/maxrounds = 5 # maximal number of separation rounds in the root node (-1: unlimited) # [type: int, range: [-1,2147483647], default: 10] separating/flowcover/maxroundsroot = 10 # maximal number of rows to separate flow cover cuts for per separation round (-1: unlimited) # [type: int, range: [-1,2147483647], default: 100] separating/flowcover/maxtries = 100 # maximal number of rows to separate flow cover cuts for per separation round in the root (-1: unlimited) # [type: int, range: [-1,2147483647], default: -1] separating/flowcover/maxtriesroot = -1 # maximal number of consecutive fails to generate a cut per separation round (-1: unlimited) # [type: int, range: [-1,2147483647], default: 50] separating/flowcover/maxfails = 50 # maximal number of consecutive fails to generate a cut per separation round in the root (-1: unlimited) # [type: int, range: [-1,2147483647], default: 100] separating/flowcover/maxfailsroot = 100 # maximal number of flow cover cuts separated per separation round # [type: int, range: [0,2147483647], default: 100] separating/flowcover/maxsepacuts = 100 # maximal number of flow cover cuts separated per separation round in the root # [type: int, range: [0,2147483647], default: 200] separating/flowcover/maxsepacutsroot = 200 # maximal slack of rows to separate flow cover cuts for # [type: real, range: [0,1.79769313486232e+308], default: 1.79769313486232e+308] separating/flowcover/maxslack = 1.79769313486232e+308 # maximal slack of rows to separate flow cover cuts for in the root # [type: real, range: [0,1.79769313486232e+308], default: 1.79769313486232e+308] separating/flowcover/maxslackroot = 1.79769313486232e+308 # weight of slack in the scoring of the rows # [type: real, range: [0,1.79769313486232e+308], default: 0.001] separating/flowcover/slackscore = 0.001 # maximal density of row to separate flow cover cuts for # [type: real, range: [0,1], default: 1] separating/flowcover/maxrowdensity = 1 # should generated cuts be removed from the LP if they are no longer tight? # [type: bool, range: {TRUE,FALSE}, default: TRUE] separating/flowcover/dynamiccuts = TRUE # should flow cover cuts be separated for 0-1 single node flow set with reversed arcs in addition? # [type: bool, range: {TRUE,FALSE}, default: TRUE] separating/flowcover/multbyminusone = TRUE # cut generation heuristic: maximal number of different deltas to try # [type: int, range: [0,2147483647], default: 10] separating/flowcover/maxtestdelta = 10 # priority of separator # [type: int, range: [-536870912,536870911], default: -1000] separating/gomory/priority = -1000 # frequency for calling separator (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 0] separating/gomory/freq = 0 # maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator (0.0: only on current best node, 1.0: on all nodes) # [type: real, range: [0,1], default: 0] separating/gomory/maxbounddist = 0 # should separator be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] separating/gomory/delay = FALSE # maximal number of gomory separation rounds per node (-1: unlimited) # [type: int, range: [-1,2147483647], default: 5] separating/gomory/maxrounds = 5 # maximal number of gomory separation rounds in the root node (-1: unlimited) # [type: int, range: [-1,2147483647], default: -1] separating/gomory/maxroundsroot = -1 # maximal number of gomory cuts separated per separation round # [type: int, range: [0,2147483647], default: 50] separating/gomory/maxsepacuts = 50 # maximal number of gomory cuts separated per separation round in the root node # [type: int, range: [0,2147483647], default: 500] separating/gomory/maxsepacutsroot = 500 # maximal valid range max(|weights|)/min(|weights|) of row weights # [type: real, range: [1,1.79769313486232e+308], default: 10000] separating/gomory/maxweightrange = 10000 # should generated cuts be removed from the LP if they are no longer tight? # [type: bool, range: {TRUE,FALSE}, default: TRUE] separating/gomory/dynamiccuts = TRUE # priority of separator # [type: int, range: [-536870912,536870911], default: -50] separating/impliedbounds/priority = -50 # frequency for calling separator (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 0] separating/impliedbounds/freq = 0 # maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator (0.0: only on current best node, 1.0: on all nodes) # [type: real, range: [0,1], default: 0] separating/impliedbounds/maxbounddist = 0 # should separator be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] separating/impliedbounds/delay = FALSE # priority of separator # [type: int, range: [-536870912,536870911], default: -100] separating/intobj/priority = -100 # frequency for calling separator (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: -1] separating/intobj/freq = -1 # maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator (0.0: only on current best node, 1.0: on all nodes) # [type: real, range: [0,1], default: 0] separating/intobj/maxbounddist = 0 # should separator be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] separating/intobj/delay = FALSE # priority of separator # [type: int, range: [-536870912,536870911], default: -10000] separating/mcf/priority = -10000 # frequency for calling separator (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 0] separating/mcf/freq = 0 # maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator (0.0: only on current best node, 1.0: on all nodes) # [type: real, range: [0,1], default: 0] separating/mcf/maxbounddist = 0 # should separator be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] separating/mcf/delay = FALSE # number of clusters to generate in the shrunken network -- default separation # [type: int, range: [2,32], default: 5] separating/mcf/nclusters = 5 # maximal valid range max(|weights|)/min(|weights|) of row weights # [type: real, range: [1,1.79769313486232e+308], default: 1000000] separating/mcf/maxweightrange = 1000000 # maximal number of different deltas to try (-1: unlimited) -- default separation # [type: int, range: [-1,2147483647], default: 20] separating/mcf/maxtestdelta = 20 # should negative values also be tested in scaling? # [type: bool, range: {TRUE,FALSE}, default: FALSE] separating/mcf/trynegscaling = FALSE # should an additional variable be complemented if f0 = 0? # [type: bool, range: {TRUE,FALSE}, default: TRUE] separating/mcf/fixintegralrhs = TRUE # should generated cuts be removed from the LP if they are no longer tight? # [type: bool, range: {TRUE,FALSE}, default: TRUE] separating/mcf/dynamiccuts = TRUE # model type of network (0: auto, 1:directed, 2:undirected) # [type: int, range: [0,2], default: 0] separating/mcf/modeltype = 0 # maximal number of mcf cuts separated per separation round # [type: int, range: [-1,2147483647], default: 100] separating/mcf/maxsepacuts = 100 # maximal number of mcf cuts separated per separation round in the root node -- default separation # [type: int, range: [-1,2147483647], default: 200] separating/mcf/maxsepacutsroot = 200 # maximum inconsistency ratio for separation at all # [type: real, range: [0,1.79769313486232e+308], default: 0.02] separating/mcf/maxinconsistencyratio = 0.02 # maximum inconsistency ratio of arcs not to be deleted # [type: real, range: [0,1.79769313486232e+308], default: 0.5] separating/mcf/maxarcinconsistencyratio = 0.5 # should we separate only if the cuts shores are connected? # [type: bool, range: {TRUE,FALSE}, default: TRUE] separating/mcf/checkcutshoreconnectivity = TRUE # should we separate inequalities based on single-node cuts? # [type: bool, range: {TRUE,FALSE}, default: TRUE] separating/mcf/separatesinglenodecuts = TRUE # should we separate flowcutset inequalities on the network cuts? # [type: bool, range: {TRUE,FALSE}, default: TRUE] separating/mcf/separateflowcutset = TRUE # should we separate knapsack cover inequalities on the network cuts? # [type: bool, range: {TRUE,FALSE}, default: TRUE] separating/mcf/separateknapsack = TRUE # priority of separator # [type: int, range: [-536870912,536870911], default: 10000000] separating/redcost/priority = 10000000 # frequency for calling separator (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 1] separating/redcost/freq = 1 # maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator (0.0: only on current best node, 1.0: on all nodes) # [type: real, range: [0,1], default: 1] separating/redcost/maxbounddist = 1 # should separator be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] separating/redcost/delay = FALSE # should reduced cost fixing be also applied to continuous variables? # [type: bool, range: {TRUE,FALSE}, default: FALSE] separating/redcost/continuous = FALSE # priority of separator # [type: int, range: [-536870912,536870911], default: -2000] separating/strongcg/priority = -2000 # frequency for calling separator (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: 0] separating/strongcg/freq = 0 # maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator (0.0: only on current best node, 1.0: on all nodes) # [type: real, range: [0,1], default: 0] separating/strongcg/maxbounddist = 0 # should separator be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] separating/strongcg/delay = FALSE # maximal number of strong CG separation rounds per node (-1: unlimited) # [type: int, range: [-1,2147483647], default: 5] separating/strongcg/maxrounds = 5 # maximal number of strong CG separation rounds in the root node (-1: unlimited) # [type: int, range: [-1,2147483647], default: 20] separating/strongcg/maxroundsroot = 20 # maximal number of strong CG cuts separated per separation round # [type: int, range: [0,2147483647], default: 50] separating/strongcg/maxsepacuts = 50 # maximal number of strong CG cuts separated per separation round in the root node # [type: int, range: [0,2147483647], default: 500] separating/strongcg/maxsepacutsroot = 500 # maximal valid range max(|weights|)/min(|weights|) of row weights # [type: real, range: [1,1.79769313486232e+308], default: 10000] separating/strongcg/maxweightrange = 10000 # should generated cuts be removed from the LP if they are no longer tight? # [type: bool, range: {TRUE,FALSE}, default: TRUE] separating/strongcg/dynamiccuts = TRUE # priority of separator # [type: int, range: [-536870912,536870911], default: -6000] separating/zerohalf/priority = -6000 # frequency for calling separator (-1: never, 0: only in root node) # [type: int, range: [-1,2147483647], default: -1] separating/zerohalf/freq = -1 # maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator (0.0: only on current best node, 1.0: on all nodes) # [type: real, range: [0,1], default: 0] separating/zerohalf/maxbounddist = 0 # should separator be delayed, if other separators found cuts? # [type: bool, range: {TRUE,FALSE}, default: FALSE] separating/zerohalf/delay = FALSE # maximal number of zerohalf separation rounds per node (-1: unlimited) # [type: int, range: [-1,2147483647], default: 5] separating/zerohalf/maxrounds = 5 # maximal number of zerohalf separation rounds in the root node (-1: unlimited) # [type: int, range: [-1,2147483647], default: 10] separating/zerohalf/maxroundsroot = 10 # maximal number of {0,1/2}-cuts separated per separation round # [type: int, range: [0,2147483647], default: 50] separating/zerohalf/maxsepacuts = 50 # maximal number of {0,1/2}-cuts separated per separation round in the root node # [type: int, range: [0,2147483647], default: 500] separating/zerohalf/maxsepacutsroot = 500 # should generated cuts be removed from the LP if they are no longer tight? # [type: bool, range: {TRUE,FALSE}, default: TRUE] separating/zerohalf/dynamiccuts = TRUE # maximal number of {0,1/2}-cuts determined per separation round # (this includes separated but inefficacious cuts) # [type: int, range: [0,2147483647], default: 100] separating/zerohalf/maxcutsfound = 100 # maximal number of {0,1/2}-cuts determined per separation round in the root node # (this includes separated but inefficacious cuts) # [type: int, range: [0,2147483647], default: 1000] separating/zerohalf/maxcutsfoundroot = 1000 # separating cuts only if depth <= maxdepth (-1: unlimited) # [type: int, range: [-1,2147483647], default: -1] separating/zerohalf/maxdepth = -1 # maximal number of calls (-1: unlimited) # [type: longint, range: [-1,9223372036854775807], default: -1] separating/zerohalf/maxncalls = -1 # should continuous variables be relaxed by adding variable bounds? # [type: bool, range: {TRUE,FALSE}, default: FALSE] separating/zerohalf/relaxcontvars = FALSE # should rows be scaled to make fractional coefficients integer? # [type: bool, range: {TRUE,FALSE}, default: FALSE] separating/zerohalf/scalefraccoeffs = FALSE # should zerohalf cuts found in previous callbacks ignored? # [type: bool, range: {TRUE,FALSE}, default: FALSE] separating/zerohalf/ignoreprevzhcuts = FALSE # should only original LP rows be considered (i.e. ignore previously added LP rows)? # [type: bool, range: {TRUE,FALSE}, default: FALSE] separating/zerohalf/onlyorigrows = FALSE # should zerohalf cuts be filtered using a cutpool? # [type: bool, range: {TRUE,FALSE}, default: TRUE] separating/zerohalf/usezhcutpool = TRUE # should problem be decomposed into subproblems (if possible) before applying preprocessing? # [type: bool, range: {TRUE,FALSE}, default: FALSE] separating/zerohalf/preprocessing/decomposeproblem = FALSE # value of delta parameter used in preprocessing method 'd' # [type: real, range: [0,1], default: 0.5] separating/zerohalf/preprocessing/delta = 0.5 # preprocessing methods and ordering: # 'd' columns with small LP solution, # 'G' modified Gaussian elimination, # 'i' identical columns, # 'I' identical rows, # 'L' large slack rows, # 'M' large slack rows (minslack), # 's' column singletons, # 'X' add trivial zerohalf cuts, # 'z' zero columns, # 'Z' zero rows, # 'C' fast {'z','s'}, # 'R' fast {'Z','L','I'} # # '-' no preprocessing # # [type: string, default: "CXRGXIM"] separating/zerohalf/preprocessing/ppmethods = "CXRGXIM" # should the cuts be forced to enter the LP? # [type: bool, range: {TRUE,FALSE}, default: FALSE] separating/zerohalf/separating/forcecutstolp = FALSE # should the cuts be forced to enter SCIP's sepastore? # [type: bool, range: {TRUE,FALSE}, default: FALSE] separating/zerohalf/separating/forcecutstosepastore = FALSE # minimal violation of a {0,1/2}-cut to be separated # [type: real, range: [0.001,0.5], default: 0.3] separating/zerohalf/separating/minviolation = 0.3 # separating methods and ordering: # '!' stop further processing if a cut was found, # '2' exact polynomial time algorithm (only if matrix has max 2 odd entries per row), # 'e' enumeration heuristics (k=1: try all preprocessed rows), # 'E' enumeration heuristics (k=2: try all combinations of up to two preprocessed rows), # 'g' Extended Gaussian elimination heuristics, # 's' auxiliary IP heuristics (i.e. number of solved nodes is limited) # 'S' auxiliary IP exact (i.e. unlimited number of nodes) # # '-' no processing # # [type: string, default: "2g"] separating/zerohalf/separating/sepamethods = "2g" # optional settings file of the auxiliary IP (-: none) # [type: string, default: "-"] separating/zerohalf/separating/auxip/settingsfile = "-" # limits/solutions setting of the auxiliary IP # [type: int, range: [-1,2147483647], default: -1] separating/zerohalf/separating/auxip/sollimit = -1 # penalty factor used with objective function 'p' of auxiliary IP # [type: real, range: [0,1], default: 0.001] separating/zerohalf/separating/auxip/penaltyfactor = 0.001 # should all (proper) solutions of the auxiliary IP be used to generate cuts instead of using only the best? # [type: bool, range: {TRUE,FALSE}, default: TRUE] separating/zerohalf/separating/auxip/useallsols = TRUE # auxiliary IP objective: # 'v' maximize cut violation, # 'u' minimize number of aggregated rows in cut, # 'w' minimize number of aggregated rows in cut # weighted by the number of rows in the aggregation, # 'p' maximize cut violation and penalize a high number # of aggregated rows in the cut weighted by the number # of rows in the aggregation and the penalty factor p # # [type: char, range: {uvwp}, default: v] separating/zerohalf/separating/auxip/objective = v # display activation status of display column (0: off, 1: auto, 2:on) # [type: int, range: [0,2], default: 1] display/solfound/active = 1 # display activation status of display column