SCIP++ refs/heads/main
 
Loading...
Searching...
No Matches
parameters.hpp
1#pragma once
2
3// This file is automatically generated using gen_constexpr_parameters from the utils
4// updated for SCIP 9.2.0
5
6#include "scippp/param.hpp"
7#undef INFINITY
8
10namespace scippp::params {
11
12// NOLINTBEGIN(readability-identifier-naming)
13
15namespace BENDERS {
18 constexpr Param<double> SOLUTIONTOL { "benders/solutiontol" };
20 constexpr Param<bool> CUTLPSOL { "benders/cutlpsol" };
22 constexpr Param<bool> COPYBENDERS { "benders/copybenders" };
23}
25namespace BENDERS::DEFAULT {
27 constexpr Param<int> PRIORITY { "benders/default/priority" };
29 constexpr Param<bool> CUTLP { "benders/default/cutlp" };
31 constexpr Param<bool> CUTPSEUDO { "benders/default/cutpseudo" };
33 constexpr Param<bool> CUTRELAX { "benders/default/cutrelax" };
35 constexpr Param<bool> TRANSFERCUTS { "benders/default/transfercuts" };
37 constexpr Param<bool> LNSCHECK { "benders/default/lnscheck" };
39 constexpr Param<int> LNSMAXDEPTH { "benders/default/lnsmaxdepth" };
41 constexpr Param<int> LNSMAXCALLS { "benders/default/lnsmaxcalls" };
43 constexpr Param<int> LNSMAXCALLSROOT { "benders/default/lnsmaxcallsroot" };
45 constexpr Param<bool> CUTSASCONSS { "benders/default/cutsasconss" };
47 constexpr Param<double> SUBPROBFRAC { "benders/default/subprobfrac" };
49 constexpr Param<bool> UPDATEAUXVARBOUND { "benders/default/updateauxvarbound" };
51 constexpr Param<bool> AUXVARSIMPLINT { "benders/default/auxvarsimplint" };
53 constexpr Param<bool> CUTCHECK { "benders/default/cutcheck" };
55 constexpr Param<double> CUTSTRENGTHENMULT { "benders/default/cutstrengthenmult" };
57 constexpr Param<int> NOIMPROVELIMIT { "benders/default/noimprovelimit" };
59 constexpr Param<double> COREPOINTPERTURB { "benders/default/corepointperturb" };
62 constexpr Param<bool> CUTSTRENGTHENENABLED { "benders/default/cutstrengthenenabled" };
65 constexpr Param<char> CUTSTRENGTHENINTPOINT { "benders/default/cutstrengthenintpoint" };
67 constexpr Param<int> NUMTHREADS { "benders/default/numthreads" };
70 constexpr Param<bool> EXECFEASPHASE { "benders/default/execfeasphase" };
72 constexpr Param<double> SLACKVARCOEF { "benders/default/slackvarcoef" };
74 constexpr Param<double> MAXSLACKVARCOEF { "benders/default/maxslackvarcoef" };
76 constexpr Param<bool> CHECKCONSCONVEXITY { "benders/default/checkconsconvexity" };
78 constexpr Param<int> NLPITERLIMIT { "benders/default/nlpiterlimit" };
79}
81namespace BENDERS::DEFAULT::BENDERSCUT::FEAS {
83 constexpr Param<int> PRIORITY { "benders/default/benderscut/feas/priority" };
85 constexpr Param<bool> ENABLED { "benders/default/benderscut/feas/enabled" };
86}
88namespace BENDERS::DEFAULT::BENDERSCUT::FEASALT {
90 constexpr Param<int> PRIORITY { "benders/default/benderscut/feasalt/priority" };
92 constexpr Param<bool> ENABLED { "benders/default/benderscut/feasalt/enabled" };
93}
95namespace BENDERS::DEFAULT::BENDERSCUT::INTEGER {
97 constexpr Param<int> PRIORITY { "benders/default/benderscut/integer/priority" };
99 constexpr Param<bool> ENABLED { "benders/default/benderscut/integer/enabled" };
101 constexpr Param<double> CUTSCONSTANT { "benders/default/benderscut/integer/cutsconstant" };
103 constexpr Param<bool> ADDCUTS { "benders/default/benderscut/integer/addcuts" };
104}
106namespace BENDERS::DEFAULT::BENDERSCUT::NOGOOD {
108 constexpr Param<int> PRIORITY { "benders/default/benderscut/nogood/priority" };
110 constexpr Param<bool> ENABLED { "benders/default/benderscut/nogood/enabled" };
112 constexpr Param<bool> ADDCUTS { "benders/default/benderscut/nogood/addcuts" };
113}
115namespace BENDERS::DEFAULT::BENDERSCUT::OPTIMALITY {
117 constexpr Param<int> PRIORITY { "benders/default/benderscut/optimality/priority" };
119 constexpr Param<bool> ENABLED { "benders/default/benderscut/optimality/enabled" };
121 constexpr Param<bool> ADDCUTS { "benders/default/benderscut/optimality/addcuts" };
123 constexpr Param<bool> MIR { "benders/default/benderscut/optimality/mir" };
124}
126namespace BRANCHING {
128 constexpr Param<char> SCOREFUNC { "branching/scorefunc" };
130 constexpr Param<double> SCOREFAC { "branching/scorefac" };
132 constexpr Param<bool> PREFERBINARY { "branching/preferbinary" };
134 constexpr Param<double> CLAMP { "branching/clamp" };
137 constexpr Param<double> MIDPULL { "branching/midpull" };
139 constexpr Param<double> MIDPULLRELDOMTRIG { "branching/midpullreldomtrig" };
142 constexpr Param<char> LPGAINNORMALIZE { "branching/lpgainnormalize" };
144 constexpr Param<bool> DELAYPSCOSTUPDATE { "branching/delaypscostupdate" };
146 constexpr Param<bool> DIVINGPSCOST { "branching/divingpscost" };
149 constexpr Param<bool> FORCEALLCHILDREN { "branching/forceallchildren" };
152 constexpr Param<char> FIRSTSBCHILD { "branching/firstsbchild" };
154 constexpr Param<bool> CHECKSOL { "branching/checksol" };
156 constexpr Param<bool> ROUNDSBSOL { "branching/roundsbsol" };
158 constexpr Param<bool> SUMADJUSTSCORE { "branching/sumadjustscore" };
159}
161namespace BRANCHING::ALLFULLSTRONG {
163 constexpr Param<int> PRIORITY { "branching/allfullstrong/priority" };
165 constexpr Param<int> MAXDEPTH { "branching/allfullstrong/maxdepth" };
168 constexpr Param<double> MAXBOUNDDIST { "branching/allfullstrong/maxbounddist" };
169}
171namespace BRANCHING::CLOUD {
173 constexpr Param<int> PRIORITY { "branching/cloud/priority" };
175 constexpr Param<int> MAXDEPTH { "branching/cloud/maxdepth" };
178 constexpr Param<double> MAXBOUNDDIST { "branching/cloud/maxbounddist" };
180 constexpr Param<bool> USECLOUD { "branching/cloud/usecloud" };
182 constexpr Param<bool> ONLYF2 { "branching/cloud/onlyF2" };
184 constexpr Param<bool> USEUNION { "branching/cloud/useunion" };
186 constexpr Param<int> MAXPOINTS { "branching/cloud/maxpoints" };
188 constexpr Param<double> MINSUCCESSRATE { "branching/cloud/minsuccessrate" };
190 constexpr Param<double> MINSUCCESSUNION { "branching/cloud/minsuccessunion" };
192 constexpr Param<int> MAXDEPTHUNION { "branching/cloud/maxdepthunion" };
193}
195namespace BRANCHING::DISTRIBUTION {
197 constexpr Param<int> PRIORITY { "branching/distribution/priority" };
199 constexpr Param<int> MAXDEPTH { "branching/distribution/maxdepth" };
202 constexpr Param<double> MAXBOUNDDIST { "branching/distribution/maxbounddist" };
205 constexpr Param<char> SCOREPARAM { "branching/distribution/scoreparam" };
207 constexpr Param<bool> ONLYACTIVEROWS { "branching/distribution/onlyactiverows" };
209 constexpr Param<bool> WEIGHTEDSCORE { "branching/distribution/weightedscore" };
210}
212namespace BRANCHING::FULLSTRONG {
214 constexpr Param<int> PRIORITY { "branching/fullstrong/priority" };
216 constexpr Param<int> MAXDEPTH { "branching/fullstrong/maxdepth" };
219 constexpr Param<double> MAXBOUNDDIST { "branching/fullstrong/maxbounddist" };
222 constexpr Param<long long> REEVALAGE { "branching/fullstrong/reevalage" };
225 constexpr Param<int> MAXPROPROUNDS { "branching/fullstrong/maxproprounds" };
227 constexpr Param<bool> PROBINGBOUNDS { "branching/fullstrong/probingbounds" };
229 constexpr Param<bool> FORCESTRONGBRANCH { "branching/fullstrong/forcestrongbranch" };
230}
232namespace BRANCHING::GOMORY {
234 constexpr Param<int> PRIORITY { "branching/gomory/priority" };
236 constexpr Param<int> MAXDEPTH { "branching/gomory/maxdepth" };
239 constexpr Param<double> MAXBOUNDDIST { "branching/gomory/maxbounddist" };
241 constexpr Param<int> MAXNCANDS { "branching/gomory/maxncands" };
243 constexpr Param<double> EFFICACYWEIGHT { "branching/gomory/efficacyweight" };
245 constexpr Param<double> OBJPARALLELWEIGHT { "branching/gomory/objparallelweight" };
247 constexpr Param<double> INTSUPPORTWEIGHT { "branching/gomory/intsupportweight" };
249 constexpr Param<bool> PERFORMRELPSCOST { "branching/gomory/performrelpscost" };
251 constexpr Param<bool> USEWEAKERCUTS { "branching/gomory/useweakercuts" };
252}
254namespace BRANCHING::INFERENCE {
256 constexpr Param<int> PRIORITY { "branching/inference/priority" };
258 constexpr Param<int> MAXDEPTH { "branching/inference/maxdepth" };
261 constexpr Param<double> MAXBOUNDDIST { "branching/inference/maxbounddist" };
263 constexpr Param<double> CONFLICTWEIGHT { "branching/inference/conflictweight" };
265 constexpr Param<double> INFERENCEWEIGHT { "branching/inference/inferenceweight" };
267 constexpr Param<double> CUTOFFWEIGHT { "branching/inference/cutoffweight" };
269 constexpr Param<bool> FRACTIONALS { "branching/inference/fractionals" };
271 constexpr Param<bool> USEWEIGHTEDSUM { "branching/inference/useweightedsum" };
273 constexpr Param<double> RELIABLESCORE { "branching/inference/reliablescore" };
275 constexpr Param<int> CONFLICTPRIO { "branching/inference/conflictprio" };
277 constexpr Param<int> CUTOFFPRIO { "branching/inference/cutoffprio" };
278}
280namespace BRANCHING::LEASTINF {
282 constexpr Param<int> PRIORITY { "branching/leastinf/priority" };
284 constexpr Param<int> MAXDEPTH { "branching/leastinf/maxdepth" };
287 constexpr Param<double> MAXBOUNDDIST { "branching/leastinf/maxbounddist" };
288}
290namespace BRANCHING::LOOKAHEAD {
292 constexpr Param<int> PRIORITY { "branching/lookahead/priority" };
294 constexpr Param<int> MAXDEPTH { "branching/lookahead/maxdepth" };
297 constexpr Param<double> MAXBOUNDDIST { "branching/lookahead/maxbounddist" };
299 constexpr Param<bool> USEIMPLIEDBINCONS { "branching/lookahead/useimpliedbincons" };
301 constexpr Param<int> ADDBINCONSROW { "branching/lookahead/addbinconsrow" };
304 constexpr Param<int> MAXNVIOLATEDCONS { "branching/lookahead/maxnviolatedcons" };
307 constexpr Param<int> MAXNVIOLATEDBINCONS { "branching/lookahead/maxnviolatedbincons" };
310 constexpr Param<int> MAXNVIOLATEDDOMREDS { "branching/lookahead/maxnviolateddomreds" };
312 constexpr Param<long long> REEVALAGE { "branching/lookahead/reevalage" };
314 constexpr Param<long long> REEVALAGEFSB { "branching/lookahead/reevalagefsb" };
316 constexpr Param<int> RECURSIONDEPTH { "branching/lookahead/recursiondepth" };
318 constexpr Param<bool> USEDOMAINREDUCTION { "branching/lookahead/usedomainreduction" };
320 constexpr Param<bool> MERGEDOMAINREDUCTIONS { "branching/lookahead/mergedomainreductions" };
322 constexpr Param<bool> PREFERSIMPLEBOUNDS { "branching/lookahead/prefersimplebounds" };
324 constexpr Param<bool> ONLYVIOLDOMREDS { "branching/lookahead/onlyvioldomreds" };
326 constexpr Param<bool> ADDNONVIOCONS { "branching/lookahead/addnonviocons" };
328 constexpr Param<bool> ABBREVIATED { "branching/lookahead/abbreviated" };
330 constexpr Param<int> MAXNCANDS { "branching/lookahead/maxncands" };
332 constexpr Param<int> MAXNDEEPERCANDS { "branching/lookahead/maxndeepercands" };
334 constexpr Param<bool> REUSEBASIS { "branching/lookahead/reusebasis" };
336 constexpr Param<bool> STOREUNVIOLATEDSOL { "branching/lookahead/storeunviolatedsol" };
338 constexpr Param<bool> ABBREVPSEUDO { "branching/lookahead/abbrevpseudo" };
340 constexpr Param<bool> LEVEL2AVGSCORE { "branching/lookahead/level2avgscore" };
342 constexpr Param<bool> LEVEL2ZEROSCORE { "branching/lookahead/level2zeroscore" };
344 constexpr Param<bool> ADDCLIQUE { "branching/lookahead/addclique" };
346 constexpr Param<bool> PROPAGATE { "branching/lookahead/propagate" };
348 constexpr Param<bool> USELEVEL2DATA { "branching/lookahead/uselevel2data" };
350 constexpr Param<bool> APPLYCHILDBOUNDS { "branching/lookahead/applychildbounds" };
352 constexpr Param<bool> ENFORCEMAXDOMREDS { "branching/lookahead/enforcemaxdomreds" };
354 constexpr Param<bool> UPDATEBRANCHINGRESULTS { "branching/lookahead/updatebranchingresults" };
356 constexpr Param<int> MAXPROPROUNDS { "branching/lookahead/maxproprounds" };
358 constexpr Param<char> SCORINGFUNCTION { "branching/lookahead/scoringfunction" };
360 constexpr Param<char> DEEPERSCORINGFUNCTION { "branching/lookahead/deeperscoringfunction" };
362 constexpr Param<char> SCORINGSCORINGFUNCTION { "branching/lookahead/scoringscoringfunction" };
365 constexpr Param<double> MINWEIGHT { "branching/lookahead/minweight" };
367 constexpr Param<double> WORSEFACTOR { "branching/lookahead/worsefactor" };
370 constexpr Param<bool> FILTERBYMAXGAIN { "branching/lookahead/filterbymaxgain" };
371}
373namespace BRANCHING::MOSTINF {
375 constexpr Param<int> PRIORITY { "branching/mostinf/priority" };
377 constexpr Param<int> MAXDEPTH { "branching/mostinf/maxdepth" };
380 constexpr Param<double> MAXBOUNDDIST { "branching/mostinf/maxbounddist" };
381}
383namespace BRANCHING::MULTAGGR {
385 constexpr Param<int> PRIORITY { "branching/multaggr/priority" };
387 constexpr Param<int> MAXDEPTH { "branching/multaggr/maxdepth" };
390 constexpr Param<double> MAXBOUNDDIST { "branching/multaggr/maxbounddist" };
393 constexpr Param<long long> REEVALAGE { "branching/multaggr/reevalage" };
396 constexpr Param<int> MAXPROPROUNDS { "branching/multaggr/maxproprounds" };
398 constexpr Param<bool> PROBINGBOUNDS { "branching/multaggr/probingbounds" };
399}
401namespace BRANCHING::NODEREOPT {
403 constexpr Param<int> PRIORITY { "branching/nodereopt/priority" };
405 constexpr Param<int> MAXDEPTH { "branching/nodereopt/maxdepth" };
408 constexpr Param<double> MAXBOUNDDIST { "branching/nodereopt/maxbounddist" };
409}
411namespace BRANCHING::PSCOST {
413 constexpr Param<int> PRIORITY { "branching/pscost/priority" };
415 constexpr Param<int> MAXDEPTH { "branching/pscost/maxdepth" };
418 constexpr Param<double> MAXBOUNDDIST { "branching/pscost/maxbounddist" };
421 constexpr Param<char> STRATEGY { "branching/pscost/strategy" };
423 constexpr Param<double> MINSCOREWEIGHT { "branching/pscost/minscoreweight" };
425 constexpr Param<double> MAXSCOREWEIGHT { "branching/pscost/maxscoreweight" };
427 constexpr Param<double> SUMSCOREWEIGHT { "branching/pscost/sumscoreweight" };
429 constexpr Param<int> NCHILDREN { "branching/pscost/nchildren" };
431 constexpr Param<int> NARYMAXDEPTH { "branching/pscost/narymaxdepth" };
433 constexpr Param<double> NARYMINWIDTH { "branching/pscost/naryminwidth" };
435 constexpr Param<double> NARYWIDTHFACTOR { "branching/pscost/narywidthfactor" };
436}
438namespace BRANCHING::RANDOM {
440 constexpr Param<int> PRIORITY { "branching/random/priority" };
442 constexpr Param<int> MAXDEPTH { "branching/random/maxdepth" };
445 constexpr Param<double> MAXBOUNDDIST { "branching/random/maxbounddist" };
447 constexpr Param<int> SEED { "branching/random/seed" };
448}
450namespace BRANCHING::RELPSCOST {
452 constexpr Param<int> PRIORITY { "branching/relpscost/priority" };
454 constexpr Param<int> MAXDEPTH { "branching/relpscost/maxdepth" };
457 constexpr Param<double> MAXBOUNDDIST { "branching/relpscost/maxbounddist" };
459 constexpr Param<double> CONFLICTWEIGHT { "branching/relpscost/conflictweight" };
461 constexpr Param<double> CONFLICTLENGTHWEIGHT { "branching/relpscost/conflictlengthweight" };
463 constexpr Param<double> INFERENCEWEIGHT { "branching/relpscost/inferenceweight" };
465 constexpr Param<double> CUTOFFWEIGHT { "branching/relpscost/cutoffweight" };
467 constexpr Param<double> GMIAVGEFFWEIGHT { "branching/relpscost/gmiavgeffweight" };
469 constexpr Param<double> GMILASTEFFWEIGHT { "branching/relpscost/gmilasteffweight" };
471 constexpr Param<double> PSCOSTWEIGHT { "branching/relpscost/pscostweight" };
473 constexpr Param<double> NLSCOREWEIGHT { "branching/relpscost/nlscoreweight" };
475 constexpr Param<double> MINRELIABLE { "branching/relpscost/minreliable" };
477 constexpr Param<double> MAXRELIABLE { "branching/relpscost/maxreliable" };
479 constexpr Param<double> SBITERQUOT { "branching/relpscost/sbiterquot" };
481 constexpr Param<int> SBITEROFS { "branching/relpscost/sbiterofs" };
483 constexpr Param<int> MAXLOOKAHEAD { "branching/relpscost/maxlookahead" };
485 constexpr Param<int> INITCAND { "branching/relpscost/initcand" };
487 constexpr Param<int> INITITER { "branching/relpscost/inititer" };
489 constexpr Param<int> MAXBDCHGS { "branching/relpscost/maxbdchgs" };
492 constexpr Param<int> MAXPROPROUNDS { "branching/relpscost/maxproprounds" };
494 constexpr Param<bool> PROBINGBOUNDS { "branching/relpscost/probingbounds" };
496 constexpr Param<bool> USERELERRORRELIABILITY { "branching/relpscost/userelerrorreliability" };
498 constexpr Param<double> LOWERRORTOL { "branching/relpscost/lowerrortol" };
500 constexpr Param<double> HIGHERRORTOL { "branching/relpscost/higherrortol" };
502 constexpr Param<bool> STORESEMIINITCOSTS { "branching/relpscost/storesemiinitcosts" };
505 constexpr Param<bool> USESBLOCALINFO { "branching/relpscost/usesblocalinfo" };
507 constexpr Param<bool> USEHYPTESTFORRELIABILITY { "branching/relpscost/usehyptestforreliability" };
509 constexpr Param<bool> USEDYNAMICCONFIDENCE { "branching/relpscost/usedynamicconfidence" };
512 constexpr Param<bool> SKIPBADINITCANDS { "branching/relpscost/skipbadinitcands" };
514 constexpr Param<int> CONFIDENCELEVEL { "branching/relpscost/confidencelevel" };
516 constexpr Param<bool> RANDINITORDER { "branching/relpscost/randinitorder" };
518 constexpr Param<bool> USESMALLWEIGHTSITLIM { "branching/relpscost/usesmallweightsitlim" };
521 constexpr Param<bool> DYNAMICWEIGHTS { "branching/relpscost/dynamicweights" };
524 constexpr Param<int> DEGENERACYAWARE { "branching/relpscost/degeneracyaware" };
526 constexpr Param<int> STARTRANDSEED { "branching/relpscost/startrandseed" };
528 constexpr Param<bool> FILTERCANDSSYM { "branching/relpscost/filtercandssym" };
530 constexpr Param<bool> TRANSSYMPSCOST { "branching/relpscost/transsympscost" };
531}
533namespace BRANCHING::TREEMODEL {
535 constexpr Param<bool> ENABLE { "branching/treemodel/enable" };
537 constexpr Param<char> HIGHRULE { "branching/treemodel/highrule" };
539 constexpr Param<char> LOWRULE { "branching/treemodel/lowrule" };
541 constexpr Param<int> HEIGHT { "branching/treemodel/height" };
543 constexpr Param<char> FILTERHIGH { "branching/treemodel/filterhigh" };
545 constexpr Param<char> FILTERLOW { "branching/treemodel/filterlow" };
547 constexpr Param<int> MAXFPITER { "branching/treemodel/maxfpiter" };
549 constexpr Param<int> MAXSVTSHEIGHT { "branching/treemodel/maxsvtsheight" };
551 constexpr Param<char> FALLBACKINF { "branching/treemodel/fallbackinf" };
553 constexpr Param<char> FALLBACKNOPRIM { "branching/treemodel/fallbacknoprim" };
556 constexpr Param<double> SMALLPSCOST { "branching/treemodel/smallpscost" };
557}
559namespace BRANCHING::VANILLAFULLSTRONG {
561 constexpr Param<int> PRIORITY { "branching/vanillafullstrong/priority" };
563 constexpr Param<int> MAXDEPTH { "branching/vanillafullstrong/maxdepth" };
566 constexpr Param<double> MAXBOUNDDIST { "branching/vanillafullstrong/maxbounddist" };
568 constexpr Param<bool> INTEGRALCANDS { "branching/vanillafullstrong/integralcands" };
570 constexpr Param<bool> IDEMPOTENT { "branching/vanillafullstrong/idempotent" };
573 constexpr Param<bool> SCOREALL { "branching/vanillafullstrong/scoreall" };
575 constexpr Param<bool> COLLECTSCORES { "branching/vanillafullstrong/collectscores" };
577 constexpr Param<bool> DONOTBRANCH { "branching/vanillafullstrong/donotbranch" };
578}
580namespace COMPRESSION {
582 constexpr Param<bool> ENABLE { "compression/enable" };
583}
585namespace COMPRESSION::LARGESTREPR {
587 constexpr Param<int> PRIORITY { "compression/largestrepr/priority" };
589 constexpr Param<int> MINNLEAVES { "compression/largestrepr/minnleaves" };
591 constexpr Param<int> ITERATIONS { "compression/largestrepr/iterations" };
593 constexpr Param<int> MINCOMMONVARS { "compression/largestrepr/mincommonvars" };
594}
596namespace COMPRESSION::WEAKCOMPR {
598 constexpr Param<int> PRIORITY { "compression/weakcompr/priority" };
600 constexpr Param<int> MINNLEAVES { "compression/weakcompr/minnleaves" };
602 constexpr Param<bool> CONVERTCONSS { "compression/weakcompr/convertconss" };
603}
605namespace CONCURRENT {
607 constexpr Param<bool> CHANGESEEDS { "concurrent/changeseeds" };
609 constexpr Param<bool> CHANGECHILDSEL { "concurrent/changechildsel" };
611 constexpr Param<bool> COMMVARBNDS { "concurrent/commvarbnds" };
613 constexpr Param<bool> PRESOLVEBEFORE { "concurrent/presolvebefore" };
615 constexpr Param<int> INITSEED { "concurrent/initseed" };
617 constexpr Param<std::string> PARAMSETPREFIX { "concurrent/paramsetprefix" };
618}
620namespace CONCURRENT::SCIP {
622 constexpr Param<double> PREFPRIO { "concurrent/scip/prefprio" };
623}
625namespace CONCURRENT::SCIP_COUNTER {
627 constexpr Param<double> PREFPRIO { "concurrent/scip-counter/prefprio" };
628}
630namespace CONCURRENT::SCIP_CPSOLVER {
632 constexpr Param<double> PREFPRIO { "concurrent/scip-cpsolver/prefprio" };
633}
635namespace CONCURRENT::SCIP_DEFAULT {
637 constexpr Param<double> PREFPRIO { "concurrent/scip-default/prefprio" };
638}
640namespace CONCURRENT::SCIP_EASYCIP {
642 constexpr Param<double> PREFPRIO { "concurrent/scip-easycip/prefprio" };
643}
645namespace CONCURRENT::SCIP_FEAS {
647 constexpr Param<double> PREFPRIO { "concurrent/scip-feas/prefprio" };
648}
650namespace CONCURRENT::SCIP_HARDLP {
652 constexpr Param<double> PREFPRIO { "concurrent/scip-hardlp/prefprio" };
653}
655namespace CONCURRENT::SCIP_OPTI {
657 constexpr Param<double> PREFPRIO { "concurrent/scip-opti/prefprio" };
658}
660namespace CONCURRENT::SYNC {
662 constexpr Param<double> FREQINIT { "concurrent/sync/freqinit" };
664 constexpr Param<double> FREQMAX { "concurrent/sync/freqmax" };
666 constexpr Param<double> FREQFACTOR { "concurrent/sync/freqfactor" };
669 constexpr Param<double> TARGETPROGRESS { "concurrent/sync/targetprogress" };
671 constexpr Param<int> MAXNSOLS { "concurrent/sync/maxnsols" };
673 constexpr Param<int> MAXNSYNCDELAY { "concurrent/sync/maxnsyncdelay" };
675 constexpr Param<double> MINSYNCDELAY { "concurrent/sync/minsyncdelay" };
677 constexpr Param<int> NBESTSOLS { "concurrent/sync/nbestsols" };
678}
680namespace CONFLICT {
682 constexpr Param<bool> ENABLE { "conflict/enable" };
685 constexpr Param<bool> CLEANBOUNDEXCEEDINGS { "conflict/cleanboundexceedings" };
687 constexpr Param<bool> USELOCALROWS { "conflict/uselocalrows" };
689 constexpr Param<bool> USEPROP { "conflict/useprop" };
692 constexpr Param<char> USEINFLP { "conflict/useinflp" };
695 constexpr Param<char> USEBOUNDLP { "conflict/useboundlp" };
697 constexpr Param<bool> USESB { "conflict/usesb" };
699 constexpr Param<bool> USEPSEUDO { "conflict/usepseudo" };
701 constexpr Param<double> MAXVARSFAC { "conflict/maxvarsfac" };
703 constexpr Param<int> MINMAXVARS { "conflict/minmaxvars" };
705 constexpr Param<int> MAXLPLOOPS { "conflict/maxlploops" };
707 constexpr Param<int> LPITERATIONS { "conflict/lpiterations" };
709 constexpr Param<int> FUIPLEVELS { "conflict/fuiplevels" };
712 constexpr Param<int> INTERCONSS { "conflict/interconss" };
715 constexpr Param<int> RECONVLEVELS { "conflict/reconvlevels" };
718 constexpr Param<int> MAXCONSS { "conflict/maxconss" };
720 constexpr Param<int> MAXSTORESIZE { "conflict/maxstoresize" };
722 constexpr Param<bool> PREFERBINARY { "conflict/preferbinary" };
724 constexpr Param<bool> PREFINFPROOF { "conflict/prefinfproof" };
726 constexpr Param<bool> ALLOWLOCAL { "conflict/allowlocal" };
728 constexpr Param<bool> SETTLELOCAL { "conflict/settlelocal" };
730 constexpr Param<bool> REPROPAGATE { "conflict/repropagate" };
732 constexpr Param<bool> KEEPREPROP { "conflict/keepreprop" };
734 constexpr Param<bool> SEPARATE { "conflict/separate" };
736 constexpr Param<bool> DYNAMIC { "conflict/dynamic" };
738 constexpr Param<bool> REMOVABLE { "conflict/removable" };
740 constexpr Param<double> PROOFSCOREFAC { "conflict/proofscorefac" };
742 constexpr Param<double> UPLOCKSCOREFAC { "conflict/uplockscorefac" };
744 constexpr Param<double> DOWNLOCKSCOREFAC { "conflict/downlockscorefac" };
746 constexpr Param<double> SCOREFAC { "conflict/scorefac" };
748 constexpr Param<int> RESTARTNUM { "conflict/restartnum" };
750 constexpr Param<double> RESTARTFAC { "conflict/restartfac" };
752 constexpr Param<bool> IGNORERELAXEDBD { "conflict/ignorerelaxedbd" };
755 constexpr Param<int> MAXVARSDETECTIMPLIEDBOUNDS { "conflict/maxvarsdetectimpliedbounds" };
758 constexpr Param<bool> FULLSHORTENCONFLICT { "conflict/fullshortenconflict" };
760 constexpr Param<double> CONFLICTWEIGHT { "conflict/conflictweight" };
762 constexpr Param<double> CONFLICTGRAPHWEIGHT { "conflict/conflictgraphweight" };
764 constexpr Param<double> MINIMPROVE { "conflict/minimprove" };
766 constexpr Param<double> WEIGHTSIZE { "conflict/weightsize" };
768 constexpr Param<double> WEIGHTREPROPDEPTH { "conflict/weightrepropdepth" };
770 constexpr Param<double> WEIGHTVALIDDEPTH { "conflict/weightvaliddepth" };
772 constexpr Param<bool> SEPAALTPROOFS { "conflict/sepaaltproofs" };
773}
775namespace CONFLICT::BOUNDDISJUNCTION {
777 constexpr Param<double> CONTINUOUSFRAC { "conflict/bounddisjunction/continuousfrac" };
779 constexpr Param<int> PRIORITY { "conflict/bounddisjunction/priority" };
780}
782namespace CONFLICT::GRAPH {
784 constexpr Param<double> DEPTHSCOREFAC { "conflict/graph/depthscorefac" };
785}
787namespace CONFLICT::INDICATORCONFLICT {
789 constexpr Param<int> PRIORITY { "conflict/indicatorconflict/priority" };
790}
792namespace CONFLICT::LINEAR {
794 constexpr Param<int> PRIORITY { "conflict/linear/priority" };
795}
797namespace CONFLICT::LOGICOR {
799 constexpr Param<int> PRIORITY { "conflict/logicor/priority" };
800}
802namespace CONFLICT::SETPPC {
804 constexpr Param<int> PRIORITY { "conflict/setppc/priority" };
805}
807namespace CONSTRAINTS {
809 constexpr Param<int> AGELIMIT { "constraints/agelimit" };
811 constexpr Param<int> OBSOLETEAGE { "constraints/obsoleteage" };
813 constexpr Param<bool> DISABLEENFOPS { "constraints/disableenfops" };
814}
816namespace CONSTRAINTS::AND {
818 constexpr Param<int> SEPAFREQ { "constraints/and/sepafreq" };
820 constexpr Param<int> PROPFREQ { "constraints/and/propfreq" };
822 constexpr Param<int> PROPTIMING { "constraints/and/proptiming" };
825 constexpr Param<int> EAGERFREQ { "constraints/and/eagerfreq" };
827 constexpr Param<int> MAXPREROUNDS { "constraints/and/maxprerounds" };
829 constexpr Param<bool> DELAYSEPA { "constraints/and/delaysepa" };
831 constexpr Param<bool> DELAYPROP { "constraints/and/delayprop" };
833 constexpr Param<int> PRESOLTIMING { "constraints/and/presoltiming" };
835 constexpr Param<bool> PRESOLPAIRWISE { "constraints/and/presolpairwise" };
837 constexpr Param<bool> PRESOLUSEHASHING { "constraints/and/presolusehashing" };
839 constexpr Param<bool> LINEARIZE { "constraints/and/linearize" };
841 constexpr Param<bool> ENFORCECUTS { "constraints/and/enforcecuts" };
843 constexpr Param<bool> AGGRLINEARIZATION { "constraints/and/aggrlinearization" };
845 constexpr Param<bool> UPGRADERESULTANT { "constraints/and/upgraderesultant" };
847 constexpr Param<bool> DUALPRESOLVING { "constraints/and/dualpresolving" };
848}
850namespace CONSTRAINTS::BENDERS {
852 constexpr Param<int> SEPAFREQ { "constraints/benders/sepafreq" };
854 constexpr Param<int> PROPFREQ { "constraints/benders/propfreq" };
856 constexpr Param<int> PROPTIMING { "constraints/benders/proptiming" };
859 constexpr Param<int> EAGERFREQ { "constraints/benders/eagerfreq" };
861 constexpr Param<int> MAXPREROUNDS { "constraints/benders/maxprerounds" };
863 constexpr Param<bool> DELAYSEPA { "constraints/benders/delaysepa" };
865 constexpr Param<bool> DELAYPROP { "constraints/benders/delayprop" };
867 constexpr Param<int> PRESOLTIMING { "constraints/benders/presoltiming" };
869 constexpr Param<bool> ACTIVE { "constraints/benders/active" };
870}
872namespace CONSTRAINTS::BENDERSLP {
874 constexpr Param<int> SEPAFREQ { "constraints/benderslp/sepafreq" };
876 constexpr Param<int> PROPFREQ { "constraints/benderslp/propfreq" };
878 constexpr Param<int> PROPTIMING { "constraints/benderslp/proptiming" };
881 constexpr Param<int> EAGERFREQ { "constraints/benderslp/eagerfreq" };
883 constexpr Param<int> MAXPREROUNDS { "constraints/benderslp/maxprerounds" };
885 constexpr Param<bool> DELAYSEPA { "constraints/benderslp/delaysepa" };
887 constexpr Param<bool> DELAYPROP { "constraints/benderslp/delayprop" };
889 constexpr Param<int> PRESOLTIMING { "constraints/benderslp/presoltiming" };
891 constexpr Param<int> MAXDEPTH { "constraints/benderslp/maxdepth" };
893 constexpr Param<int> DEPTHFREQ { "constraints/benderslp/depthfreq" };
896 constexpr Param<int> STALLLIMIT { "constraints/benderslp/stalllimit" };
899 constexpr Param<int> ITERLIMIT { "constraints/benderslp/iterlimit" };
901 constexpr Param<bool> ACTIVE { "constraints/benderslp/active" };
902}
904namespace CONSTRAINTS::BOUNDDISJUNCTION {
906 constexpr Param<int> SEPAFREQ { "constraints/bounddisjunction/sepafreq" };
908 constexpr Param<int> PROPFREQ { "constraints/bounddisjunction/propfreq" };
910 constexpr Param<int> PROPTIMING { "constraints/bounddisjunction/proptiming" };
913 constexpr Param<int> EAGERFREQ { "constraints/bounddisjunction/eagerfreq" };
915 constexpr Param<int> MAXPREROUNDS { "constraints/bounddisjunction/maxprerounds" };
917 constexpr Param<bool> DELAYSEPA { "constraints/bounddisjunction/delaysepa" };
919 constexpr Param<bool> DELAYPROP { "constraints/bounddisjunction/delayprop" };
921 constexpr Param<int> PRESOLTIMING { "constraints/bounddisjunction/presoltiming" };
922}
924namespace CONSTRAINTS::CARDINALITY {
926 constexpr Param<int> SEPAFREQ { "constraints/cardinality/sepafreq" };
928 constexpr Param<int> PROPFREQ { "constraints/cardinality/propfreq" };
930 constexpr Param<int> PROPTIMING { "constraints/cardinality/proptiming" };
933 constexpr Param<int> EAGERFREQ { "constraints/cardinality/eagerfreq" };
935 constexpr Param<int> MAXPREROUNDS { "constraints/cardinality/maxprerounds" };
937 constexpr Param<bool> DELAYSEPA { "constraints/cardinality/delaysepa" };
939 constexpr Param<bool> DELAYPROP { "constraints/cardinality/delayprop" };
941 constexpr Param<int> PRESOLTIMING { "constraints/cardinality/presoltiming" };
943 constexpr Param<bool> BRANCHBALANCED { "constraints/cardinality/branchbalanced" };
945 constexpr Param<int> BALANCEDDEPTH { "constraints/cardinality/balanceddepth" };
948 constexpr Param<double> BALANCEDCUTOFF { "constraints/cardinality/balancedcutoff" };
949}
951namespace CONSTRAINTS::COMPONENTS {
953 constexpr Param<int> SEPAFREQ { "constraints/components/sepafreq" };
955 constexpr Param<int> PROPFREQ { "constraints/components/propfreq" };
957 constexpr Param<int> PROPTIMING { "constraints/components/proptiming" };
960 constexpr Param<int> EAGERFREQ { "constraints/components/eagerfreq" };
962 constexpr Param<int> MAXPREROUNDS { "constraints/components/maxprerounds" };
964 constexpr Param<bool> DELAYSEPA { "constraints/components/delaysepa" };
966 constexpr Param<bool> DELAYPROP { "constraints/components/delayprop" };
968 constexpr Param<int> PRESOLTIMING { "constraints/components/presoltiming" };
970 constexpr Param<int> MAXDEPTH { "constraints/components/maxdepth" };
972 constexpr Param<int> MAXINTVARS { "constraints/components/maxintvars" };
974 constexpr Param<int> MINSIZE { "constraints/components/minsize" };
976 constexpr Param<double> MINRELSIZE { "constraints/components/minrelsize" };
978 constexpr Param<long long> NODELIMIT { "constraints/components/nodelimit" };
980 constexpr Param<double> MAXCOMPWEIGHT { "constraints/components/maxcompweight" };
982 constexpr Param<double> INTFACTOR { "constraints/components/intfactor" };
984 constexpr Param<double> CONTFACTOR { "constraints/components/contfactor" };
986 constexpr Param<double> FEASTOLFACTOR { "constraints/components/feastolfactor" };
987}
989namespace CONSTRAINTS::CONJUNCTION {
991 constexpr Param<int> SEPAFREQ { "constraints/conjunction/sepafreq" };
993 constexpr Param<int> PROPFREQ { "constraints/conjunction/propfreq" };
995 constexpr Param<int> PROPTIMING { "constraints/conjunction/proptiming" };
998 constexpr Param<int> EAGERFREQ { "constraints/conjunction/eagerfreq" };
1000 constexpr Param<int> MAXPREROUNDS { "constraints/conjunction/maxprerounds" };
1002 constexpr Param<bool> DELAYSEPA { "constraints/conjunction/delaysepa" };
1004 constexpr Param<bool> DELAYPROP { "constraints/conjunction/delayprop" };
1006 constexpr Param<int> PRESOLTIMING { "constraints/conjunction/presoltiming" };
1007}
1009namespace CONSTRAINTS::COUNTSOLS {
1011 constexpr Param<int> SEPAFREQ { "constraints/countsols/sepafreq" };
1013 constexpr Param<int> PROPFREQ { "constraints/countsols/propfreq" };
1015 constexpr Param<int> PROPTIMING { "constraints/countsols/proptiming" };
1018 constexpr Param<int> EAGERFREQ { "constraints/countsols/eagerfreq" };
1020 constexpr Param<int> MAXPREROUNDS { "constraints/countsols/maxprerounds" };
1022 constexpr Param<bool> DELAYSEPA { "constraints/countsols/delaysepa" };
1024 constexpr Param<bool> DELAYPROP { "constraints/countsols/delayprop" };
1026 constexpr Param<int> PRESOLTIMING { "constraints/countsols/presoltiming" };
1028 constexpr Param<bool> ACTIVE { "constraints/countsols/active" };
1030 constexpr Param<bool> SPARSETEST { "constraints/countsols/sparsetest" };
1032 constexpr Param<bool> DISCARDSOLS { "constraints/countsols/discardsols" };
1034 constexpr Param<bool> COLLECT { "constraints/countsols/collect" };
1036 constexpr Param<long long> SOLLIMIT { "constraints/countsols/sollimit" };
1037}
1039namespace CONSTRAINTS::CUMULATIVE {
1041 constexpr Param<int> SEPAFREQ { "constraints/cumulative/sepafreq" };
1043 constexpr Param<int> PROPFREQ { "constraints/cumulative/propfreq" };
1045 constexpr Param<int> PROPTIMING { "constraints/cumulative/proptiming" };
1048 constexpr Param<int> EAGERFREQ { "constraints/cumulative/eagerfreq" };
1050 constexpr Param<int> MAXPREROUNDS { "constraints/cumulative/maxprerounds" };
1052 constexpr Param<bool> DELAYSEPA { "constraints/cumulative/delaysepa" };
1054 constexpr Param<bool> DELAYPROP { "constraints/cumulative/delayprop" };
1056 constexpr Param<int> PRESOLTIMING { "constraints/cumulative/presoltiming" };
1058 constexpr Param<bool> TTINFER { "constraints/cumulative/ttinfer" };
1060 constexpr Param<bool> EFCHECK { "constraints/cumulative/efcheck" };
1062 constexpr Param<bool> EFINFER { "constraints/cumulative/efinfer" };
1064 constexpr Param<bool> USEADJUSTEDJOBS { "constraints/cumulative/useadjustedjobs" };
1066 constexpr Param<bool> TTEFCHECK { "constraints/cumulative/ttefcheck" };
1068 constexpr Param<bool> TTEFINFER { "constraints/cumulative/ttefinfer" };
1070 constexpr Param<bool> USEBINVARS { "constraints/cumulative/usebinvars" };
1072 constexpr Param<bool> LOCALCUTS { "constraints/cumulative/localcuts" };
1074 constexpr Param<bool> USECOVERCUTS { "constraints/cumulative/usecovercuts" };
1076 constexpr Param<bool> CUTSASCONSS { "constraints/cumulative/cutsasconss" };
1078 constexpr Param<bool> SEPAOLD { "constraints/cumulative/sepaold" };
1080 constexpr Param<bool> FILLBRANCHCANDS { "constraints/cumulative/fillbranchcands" };
1082 constexpr Param<bool> DUALPRESOLVE { "constraints/cumulative/dualpresolve" };
1084 constexpr Param<bool> COEFTIGHTENING { "constraints/cumulative/coeftightening" };
1086 constexpr Param<bool> NORMALIZE { "constraints/cumulative/normalize" };
1088 constexpr Param<bool> PRESOLPAIRWISE { "constraints/cumulative/presolpairwise" };
1090 constexpr Param<bool> DISJUNCTIVE { "constraints/cumulative/disjunctive" };
1092 constexpr Param<long long> MAXNODES { "constraints/cumulative/maxnodes" };
1094 constexpr Param<bool> DETECTDISJUNCTIVE { "constraints/cumulative/detectdisjunctive" };
1096 constexpr Param<bool> DETECTVARBOUNDS { "constraints/cumulative/detectvarbounds" };
1098 constexpr Param<bool> USEBDWIDENING { "constraints/cumulative/usebdwidening" };
1099}
1101namespace CONSTRAINTS::DISJUNCTION {
1103 constexpr Param<int> SEPAFREQ { "constraints/disjunction/sepafreq" };
1105 constexpr Param<int> PROPFREQ { "constraints/disjunction/propfreq" };
1107 constexpr Param<int> PROPTIMING { "constraints/disjunction/proptiming" };
1110 constexpr Param<int> EAGERFREQ { "constraints/disjunction/eagerfreq" };
1112 constexpr Param<int> MAXPREROUNDS { "constraints/disjunction/maxprerounds" };
1114 constexpr Param<bool> DELAYSEPA { "constraints/disjunction/delaysepa" };
1116 constexpr Param<bool> DELAYPROP { "constraints/disjunction/delayprop" };
1118 constexpr Param<int> PRESOLTIMING { "constraints/disjunction/presoltiming" };
1120 constexpr Param<bool> ALWAYSBRANCH { "constraints/disjunction/alwaysbranch" };
1121}
1123namespace CONSTRAINTS::FIXEDVAR {
1125 constexpr Param<int> SEPAFREQ { "constraints/fixedvar/sepafreq" };
1127 constexpr Param<int> PROPFREQ { "constraints/fixedvar/propfreq" };
1129 constexpr Param<int> PROPTIMING { "constraints/fixedvar/proptiming" };
1132 constexpr Param<int> EAGERFREQ { "constraints/fixedvar/eagerfreq" };
1134 constexpr Param<int> MAXPREROUNDS { "constraints/fixedvar/maxprerounds" };
1136 constexpr Param<bool> DELAYSEPA { "constraints/fixedvar/delaysepa" };
1138 constexpr Param<bool> DELAYPROP { "constraints/fixedvar/delayprop" };
1140 constexpr Param<int> PRESOLTIMING { "constraints/fixedvar/presoltiming" };
1142 constexpr Param<bool> ENABLED { "constraints/fixedvar/enabled" };
1144 constexpr Param<bool> SUBSCIPS { "constraints/fixedvar/subscips" };
1146 constexpr Param<bool> PREFERCUT { "constraints/fixedvar/prefercut" };
1147}
1149namespace CONSTRAINTS::INDICATOR {
1151 constexpr Param<int> SEPAFREQ { "constraints/indicator/sepafreq" };
1153 constexpr Param<int> PROPFREQ { "constraints/indicator/propfreq" };
1155 constexpr Param<int> PROPTIMING { "constraints/indicator/proptiming" };
1158 constexpr Param<int> EAGERFREQ { "constraints/indicator/eagerfreq" };
1160 constexpr Param<int> MAXPREROUNDS { "constraints/indicator/maxprerounds" };
1162 constexpr Param<bool> DELAYSEPA { "constraints/indicator/delaysepa" };
1164 constexpr Param<bool> DELAYPROP { "constraints/indicator/delayprop" };
1166 constexpr Param<int> PRESOLTIMING { "constraints/indicator/presoltiming" };
1168 constexpr Param<bool> BRANCHINDICATORS { "constraints/indicator/branchindicators" };
1170 constexpr Param<bool> GENLOGICOR { "constraints/indicator/genlogicor" };
1172 constexpr Param<bool> ADDCOUPLING { "constraints/indicator/addcoupling" };
1174 constexpr Param<double> MAXCOUPLINGVALUE { "constraints/indicator/maxcouplingvalue" };
1176 constexpr Param<bool> ADDCOUPLINGCONS { "constraints/indicator/addcouplingcons" };
1178 constexpr Param<bool> SEPACOUPLINGCUTS { "constraints/indicator/sepacouplingcuts" };
1180 constexpr Param<bool> SEPACOUPLINGLOCAL { "constraints/indicator/sepacouplinglocal" };
1182 constexpr Param<double> SEPACOUPLINGVALUE { "constraints/indicator/sepacouplingvalue" };
1184 constexpr Param<bool> SEPAPERSPECTIVE { "constraints/indicator/sepaperspective" };
1186 constexpr Param<bool> SEPAPERSPLOCAL { "constraints/indicator/sepapersplocal" };
1188 constexpr Param<int> MAXSEPANONVIOLATED { "constraints/indicator/maxsepanonviolated" };
1190 constexpr Param<bool> UPDATEBOUNDS { "constraints/indicator/updatebounds" };
1193 constexpr Param<double> MAXCONDITIONALTLP { "constraints/indicator/maxconditionaltlp" };
1195 constexpr Param<int> MAXSEPACUTS { "constraints/indicator/maxsepacuts" };
1197 constexpr Param<int> MAXSEPACUTSROOT { "constraints/indicator/maxsepacutsroot" };
1199 constexpr Param<bool> REMOVEINDICATORS { "constraints/indicator/removeindicators" };
1201 constexpr Param<bool> GENERATEBILINEAR { "constraints/indicator/generatebilinear" };
1203 constexpr Param<bool> SCALESLACKVAR { "constraints/indicator/scaleslackvar" };
1205 constexpr Param<bool> TRYSOLUTIONS { "constraints/indicator/trysolutions" };
1207 constexpr Param<bool> ENFORCECUTS { "constraints/indicator/enforcecuts" };
1209 constexpr Param<bool> DUALREDUCTIONS { "constraints/indicator/dualreductions" };
1211 constexpr Param<bool> ADDOPPOSITE { "constraints/indicator/addopposite" };
1213 constexpr Param<bool> CONFLICTSUPGRADE { "constraints/indicator/conflictsupgrade" };
1215 constexpr Param<double> RESTARTFRAC { "constraints/indicator/restartfrac" };
1217 constexpr Param<bool> USEOTHERCONSS { "constraints/indicator/useotherconss" };
1219 constexpr Param<bool> USEOBJECTIVECUT { "constraints/indicator/useobjectivecut" };
1221 constexpr Param<bool> TRYSOLFROMCOVER { "constraints/indicator/trysolfromcover" };
1223 constexpr Param<bool> UPGRADELINEAR { "constraints/indicator/upgradelinear" };
1225 constexpr Param<bool> USESAMESLACKVAR { "constraints/indicator/usesameslackvar" };
1227 constexpr Param<bool> SEPAALTERNATIVELP { "constraints/indicator/sepaalternativelp" };
1229 constexpr Param<bool> FORCERESTART { "constraints/indicator/forcerestart" };
1231 constexpr Param<bool> NOLINCONSCONT { "constraints/indicator/nolinconscont" };
1232}
1234namespace CONSTRAINTS::INTEGRAL {
1236 constexpr Param<int> SEPAFREQ { "constraints/integral/sepafreq" };
1238 constexpr Param<int> PROPFREQ { "constraints/integral/propfreq" };
1240 constexpr Param<int> PROPTIMING { "constraints/integral/proptiming" };
1243 constexpr Param<int> EAGERFREQ { "constraints/integral/eagerfreq" };
1245 constexpr Param<int> MAXPREROUNDS { "constraints/integral/maxprerounds" };
1247 constexpr Param<bool> DELAYSEPA { "constraints/integral/delaysepa" };
1249 constexpr Param<bool> DELAYPROP { "constraints/integral/delayprop" };
1251 constexpr Param<int> PRESOLTIMING { "constraints/integral/presoltiming" };
1252}
1254namespace CONSTRAINTS::KNAPSACK {
1256 constexpr Param<int> SEPAFREQ { "constraints/knapsack/sepafreq" };
1258 constexpr Param<int> PROPFREQ { "constraints/knapsack/propfreq" };
1260 constexpr Param<int> PROPTIMING { "constraints/knapsack/proptiming" };
1263 constexpr Param<int> EAGERFREQ { "constraints/knapsack/eagerfreq" };
1265 constexpr Param<int> MAXPREROUNDS { "constraints/knapsack/maxprerounds" };
1267 constexpr Param<bool> DELAYSEPA { "constraints/knapsack/delaysepa" };
1269 constexpr Param<bool> DELAYPROP { "constraints/knapsack/delayprop" };
1271 constexpr Param<int> PRESOLTIMING { "constraints/knapsack/presoltiming" };
1273 constexpr Param<int> SEPACARDFREQ { "constraints/knapsack/sepacardfreq" };
1276 constexpr Param<double> MAXCARDBOUNDDIST { "constraints/knapsack/maxcardbounddist" };
1278 constexpr Param<double> CLIQUEEXTRACTFACTOR { "constraints/knapsack/cliqueextractfactor" };
1280 constexpr Param<int> MAXROUNDS { "constraints/knapsack/maxrounds" };
1282 constexpr Param<int> MAXROUNDSROOT { "constraints/knapsack/maxroundsroot" };
1284 constexpr Param<int> MAXSEPACUTS { "constraints/knapsack/maxsepacuts" };
1286 constexpr Param<int> MAXSEPACUTSROOT { "constraints/knapsack/maxsepacutsroot" };
1288 constexpr Param<bool> DISAGGREGATION { "constraints/knapsack/disaggregation" };
1290 constexpr Param<bool> SIMPLIFYINEQUALITIES { "constraints/knapsack/simplifyinequalities" };
1292 constexpr Param<bool> NEGATEDCLIQUE { "constraints/knapsack/negatedclique" };
1294 constexpr Param<bool> PRESOLPAIRWISE { "constraints/knapsack/presolpairwise" };
1296 constexpr Param<bool> PRESOLUSEHASHING { "constraints/knapsack/presolusehashing" };
1298 constexpr Param<bool> DUALPRESOLVING { "constraints/knapsack/dualpresolving" };
1300 constexpr Param<bool> USEGUBS { "constraints/knapsack/usegubs" };
1303 constexpr Param<bool> DETECTCUTOFFBOUND { "constraints/knapsack/detectcutoffbound" };
1306 constexpr Param<bool> DETECTLOWERBOUND { "constraints/knapsack/detectlowerbound" };
1308 constexpr Param<bool> UPDATECLIQUEPARTITIONS { "constraints/knapsack/updatecliquepartitions" };
1311 constexpr Param<double> CLQPARTUPDATEFAC { "constraints/knapsack/clqpartupdatefac" };
1312}
1314namespace CONSTRAINTS::LINEAR {
1316 constexpr Param<int> SEPAFREQ { "constraints/linear/sepafreq" };
1318 constexpr Param<int> PROPFREQ { "constraints/linear/propfreq" };
1320 constexpr Param<int> PROPTIMING { "constraints/linear/proptiming" };
1323 constexpr Param<int> EAGERFREQ { "constraints/linear/eagerfreq" };
1325 constexpr Param<int> MAXPREROUNDS { "constraints/linear/maxprerounds" };
1327 constexpr Param<bool> DELAYSEPA { "constraints/linear/delaysepa" };
1329 constexpr Param<bool> DELAYPROP { "constraints/linear/delayprop" };
1331 constexpr Param<int> PRESOLTIMING { "constraints/linear/presoltiming" };
1333 constexpr Param<int> TIGHTENBOUNDSFREQ { "constraints/linear/tightenboundsfreq" };
1335 constexpr Param<int> MAXROUNDS { "constraints/linear/maxrounds" };
1337 constexpr Param<int> MAXROUNDSROOT { "constraints/linear/maxroundsroot" };
1339 constexpr Param<int> MAXSEPACUTS { "constraints/linear/maxsepacuts" };
1341 constexpr Param<int> MAXSEPACUTSROOT { "constraints/linear/maxsepacutsroot" };
1343 constexpr Param<bool> PRESOLPAIRWISE { "constraints/linear/presolpairwise" };
1345 constexpr Param<bool> PRESOLUSEHASHING { "constraints/linear/presolusehashing" };
1347 constexpr Param<int> NMINCOMPARISONS { "constraints/linear/nmincomparisons" };
1349 constexpr Param<double> MINGAINPERNMINCOMPARISONS { "constraints/linear/mingainpernmincomparisons" };
1351 constexpr Param<double> MAXAGGRNORMSCALE { "constraints/linear/maxaggrnormscale" };
1353 constexpr Param<double> MAXEASYACTIVITYDELTA { "constraints/linear/maxeasyactivitydelta" };
1356 constexpr Param<double> MAXCARDBOUNDDIST { "constraints/linear/maxcardbounddist" };
1359 constexpr Param<bool> SEPARATEALL { "constraints/linear/separateall" };
1361 constexpr Param<bool> AGGREGATEVARIABLES { "constraints/linear/aggregatevariables" };
1363 constexpr Param<bool> SIMPLIFYINEQUALITIES { "constraints/linear/simplifyinequalities" };
1365 constexpr Param<bool> DUALPRESOLVING { "constraints/linear/dualpresolving" };
1367 constexpr Param<bool> SINGLETONSTUFFING { "constraints/linear/singletonstuffing" };
1369 constexpr Param<bool> SINGLEVARSTUFFING { "constraints/linear/singlevarstuffing" };
1371 constexpr Param<bool> SORTVARS { "constraints/linear/sortvars" };
1374 constexpr Param<bool> CHECKRELMAXABS { "constraints/linear/checkrelmaxabs" };
1377 constexpr Param<bool> DETECTCUTOFFBOUND { "constraints/linear/detectcutoffbound" };
1380 constexpr Param<bool> DETECTLOWERBOUND { "constraints/linear/detectlowerbound" };
1382 constexpr Param<bool> DETECTPARTIALOBJECTIVE { "constraints/linear/detectpartialobjective" };
1385 constexpr Param<bool> RANGEDROWPROPAGATION { "constraints/linear/rangedrowpropagation" };
1387 constexpr Param<bool> RANGEDROWARTCONS { "constraints/linear/rangedrowartcons" };
1389 constexpr Param<int> RANGEDROWMAXDEPTH { "constraints/linear/rangedrowmaxdepth" };
1391 constexpr Param<int> RANGEDROWFREQ { "constraints/linear/rangedrowfreq" };
1393 constexpr Param<bool> MULTAGGRREMOVE { "constraints/linear/multaggrremove" };
1395 constexpr Param<double> MAXMULTAGGRQUOT { "constraints/linear/maxmultaggrquot" };
1397 constexpr Param<double> MAXDUALMULTAGGRQUOT { "constraints/linear/maxdualmultaggrquot" };
1399 constexpr Param<bool> EXTRACTCLIQUES { "constraints/linear/extractcliques" };
1400}
1402namespace CONSTRAINTS::LINEAR::UPGRADE {
1404 constexpr Param<bool> INDICATOR { "constraints/linear/upgrade/indicator" };
1406 constexpr Param<bool> KNAPSACK { "constraints/linear/upgrade/knapsack" };
1408 constexpr Param<bool> LOGICOR { "constraints/linear/upgrade/logicor" };
1410 constexpr Param<bool> SETPPC { "constraints/linear/upgrade/setppc" };
1412 constexpr Param<bool> VARBOUND { "constraints/linear/upgrade/varbound" };
1414 constexpr Param<bool> XOR { "constraints/linear/upgrade/xor" };
1415}
1417namespace CONSTRAINTS::LINKING {
1419 constexpr Param<int> SEPAFREQ { "constraints/linking/sepafreq" };
1421 constexpr Param<int> PROPFREQ { "constraints/linking/propfreq" };
1423 constexpr Param<int> PROPTIMING { "constraints/linking/proptiming" };
1426 constexpr Param<int> EAGERFREQ { "constraints/linking/eagerfreq" };
1428 constexpr Param<int> MAXPREROUNDS { "constraints/linking/maxprerounds" };
1430 constexpr Param<bool> DELAYSEPA { "constraints/linking/delaysepa" };
1432 constexpr Param<bool> DELAYPROP { "constraints/linking/delayprop" };
1434 constexpr Param<int> PRESOLTIMING { "constraints/linking/presoltiming" };
1436 constexpr Param<bool> LINEARIZE { "constraints/linking/linearize" };
1437}
1439namespace CONSTRAINTS::LOGICOR {
1441 constexpr Param<int> SEPAFREQ { "constraints/logicor/sepafreq" };
1443 constexpr Param<int> PROPFREQ { "constraints/logicor/propfreq" };
1445 constexpr Param<int> PROPTIMING { "constraints/logicor/proptiming" };
1448 constexpr Param<int> EAGERFREQ { "constraints/logicor/eagerfreq" };
1450 constexpr Param<int> MAXPREROUNDS { "constraints/logicor/maxprerounds" };
1452 constexpr Param<bool> DELAYSEPA { "constraints/logicor/delaysepa" };
1454 constexpr Param<bool> DELAYPROP { "constraints/logicor/delayprop" };
1456 constexpr Param<int> PRESOLTIMING { "constraints/logicor/presoltiming" };
1458 constexpr Param<bool> PRESOLPAIRWISE { "constraints/logicor/presolpairwise" };
1460 constexpr Param<bool> PRESOLUSEHASHING { "constraints/logicor/presolusehashing" };
1462 constexpr Param<bool> DUALPRESOLVING { "constraints/logicor/dualpresolving" };
1464 constexpr Param<bool> NEGATEDCLIQUE { "constraints/logicor/negatedclique" };
1466 constexpr Param<bool> IMPLICATIONS { "constraints/logicor/implications" };
1468 constexpr Param<bool> STRENGTHEN { "constraints/logicor/strengthen" };
1469}
1471namespace CONSTRAINTS::NONLINEAR {
1473 constexpr Param<int> SEPAFREQ { "constraints/nonlinear/sepafreq" };
1475 constexpr Param<int> PROPFREQ { "constraints/nonlinear/propfreq" };
1477 constexpr Param<int> PROPTIMING { "constraints/nonlinear/proptiming" };
1480 constexpr Param<int> EAGERFREQ { "constraints/nonlinear/eagerfreq" };
1482 constexpr Param<int> MAXPREROUNDS { "constraints/nonlinear/maxprerounds" };
1484 constexpr Param<bool> DELAYSEPA { "constraints/nonlinear/delaysepa" };
1486 constexpr Param<bool> DELAYPROP { "constraints/nonlinear/delayprop" };
1488 constexpr Param<int> PRESOLTIMING { "constraints/nonlinear/presoltiming" };
1490 constexpr Param<int> MAXPROPROUNDS { "constraints/nonlinear/maxproprounds" };
1492 constexpr Param<bool> PROPAUXVARS { "constraints/nonlinear/propauxvars" };
1495 constexpr Param<char> VARBOUNDRELAX { "constraints/nonlinear/varboundrelax" };
1497 constexpr Param<double> VARBOUNDRELAXAMOUNT { "constraints/nonlinear/varboundrelaxamount" };
1499 constexpr Param<double> CONSSIDERELAXAMOUNT { "constraints/nonlinear/conssiderelaxamount" };
1502 constexpr Param<double> VPMAXPERTURB { "constraints/nonlinear/vpmaxperturb" };
1505 constexpr Param<double> VPADJFACETTHRESH { "constraints/nonlinear/vpadjfacetthresh" };
1507 constexpr Param<bool> VPDUALSIMPLEX { "constraints/nonlinear/vpdualsimplex" };
1509 constexpr Param<int> BILINMAXNAUXEXPRS { "constraints/nonlinear/bilinmaxnauxexprs" };
1511 constexpr Param<bool> REFORMBINPRODS { "constraints/nonlinear/reformbinprods" };
1513 constexpr Param<bool> REFORMBINPRODSAND { "constraints/nonlinear/reformbinprodsand" };
1515 constexpr Param<int> REFORMBINPRODSFAC { "constraints/nonlinear/reformbinprodsfac" };
1517 constexpr Param<bool> FORBIDMULTAGGRNLVAR { "constraints/nonlinear/forbidmultaggrnlvar" };
1519 constexpr Param<bool> TIGHTENLPFEASTOL { "constraints/nonlinear/tightenlpfeastol" };
1521 constexpr Param<bool> PROPINENFORCE { "constraints/nonlinear/propinenforce" };
1523 constexpr Param<double> WEAKCUTTHRESHOLD { "constraints/nonlinear/weakcutthreshold" };
1525 constexpr Param<double> STRONGCUTMAXCOEF { "constraints/nonlinear/strongcutmaxcoef" };
1527 constexpr Param<bool> STRONGCUTEFFICACY { "constraints/nonlinear/strongcutefficacy" };
1529 constexpr Param<bool> FORCESTRONGCUT { "constraints/nonlinear/forcestrongcut" };
1532 constexpr Param<double> ENFOAUXVIOLFACTOR { "constraints/nonlinear/enfoauxviolfactor" };
1534 constexpr Param<double> WEAKCUTMINVIOLFACTOR { "constraints/nonlinear/weakcutminviolfactor" };
1537 constexpr Param<char> ROWNOTREMOVABLE { "constraints/nonlinear/rownotremovable" };
1540 constexpr Param<char> VIOLSCALE { "constraints/nonlinear/violscale" };
1543 constexpr Param<char> CHECKVARLOCKS { "constraints/nonlinear/checkvarlocks" };
1546 constexpr Param<char> LINEARIZEHEURSOL { "constraints/nonlinear/linearizeheursol" };
1548 constexpr Param<bool> ASSUMECONVEX { "constraints/nonlinear/assumeconvex" };
1549}
1551namespace CONSTRAINTS::NONLINEAR::BRANCHING {
1554 constexpr Param<int> AUX { "constraints/nonlinear/branching/aux" };
1556 constexpr Param<bool> EXTERNAL { "constraints/nonlinear/branching/external" };
1559 constexpr Param<double> HIGHVIOLFACTOR { "constraints/nonlinear/branching/highviolfactor" };
1562 constexpr Param<double> HIGHSCOREFACTOR { "constraints/nonlinear/branching/highscorefactor" };
1564 constexpr Param<double> VIOLWEIGHT { "constraints/nonlinear/branching/violweight" };
1566 constexpr Param<double> FRACWEIGHT { "constraints/nonlinear/branching/fracweight" };
1568 constexpr Param<double> DUALWEIGHT { "constraints/nonlinear/branching/dualweight" };
1570 constexpr Param<double> PSCOSTWEIGHT { "constraints/nonlinear/branching/pscostweight" };
1572 constexpr Param<double> DOMAINWEIGHT { "constraints/nonlinear/branching/domainweight" };
1575 constexpr Param<double> VARTYPEWEIGHT { "constraints/nonlinear/branching/vartypeweight" };
1577 constexpr Param<char> SCOREAGG { "constraints/nonlinear/branching/scoreagg" };
1580 constexpr Param<char> VIOLSPLIT { "constraints/nonlinear/branching/violsplit" };
1582 constexpr Param<double> PSCOSTRELIABLE { "constraints/nonlinear/branching/pscostreliable" };
1585 constexpr Param<double> MIXFRACTIONAL { "constraints/nonlinear/branching/mixfractional" };
1586}
1588namespace CONSTRAINTS::NONLINEAR::UPGRADE {
1590 constexpr Param<bool> LINEAR { "constraints/nonlinear/upgrade/linear" };
1592 constexpr Param<bool> SETPPC { "constraints/nonlinear/upgrade/setppc" };
1593}
1595namespace CONSTRAINTS::OR {
1597 constexpr Param<int> SEPAFREQ { "constraints/or/sepafreq" };
1599 constexpr Param<int> PROPFREQ { "constraints/or/propfreq" };
1601 constexpr Param<int> PROPTIMING { "constraints/or/proptiming" };
1604 constexpr Param<int> EAGERFREQ { "constraints/or/eagerfreq" };
1606 constexpr Param<int> MAXPREROUNDS { "constraints/or/maxprerounds" };
1608 constexpr Param<bool> DELAYSEPA { "constraints/or/delaysepa" };
1610 constexpr Param<bool> DELAYPROP { "constraints/or/delayprop" };
1612 constexpr Param<int> PRESOLTIMING { "constraints/or/presoltiming" };
1613}
1615namespace CONSTRAINTS::ORBISACK {
1617 constexpr Param<int> SEPAFREQ { "constraints/orbisack/sepafreq" };
1619 constexpr Param<int> PROPFREQ { "constraints/orbisack/propfreq" };
1621 constexpr Param<int> PROPTIMING { "constraints/orbisack/proptiming" };
1624 constexpr Param<int> EAGERFREQ { "constraints/orbisack/eagerfreq" };
1626 constexpr Param<int> MAXPREROUNDS { "constraints/orbisack/maxprerounds" };
1628 constexpr Param<bool> DELAYSEPA { "constraints/orbisack/delaysepa" };
1630 constexpr Param<bool> DELAYPROP { "constraints/orbisack/delayprop" };
1632 constexpr Param<int> PRESOLTIMING { "constraints/orbisack/presoltiming" };
1634 constexpr Param<bool> COVERSEPARATION { "constraints/orbisack/coverseparation" };
1636 constexpr Param<bool> ORBISEPARATION { "constraints/orbisack/orbiSeparation" };
1638 constexpr Param<double> COEFFBOUND { "constraints/orbisack/coeffbound" };
1640 constexpr Param<bool> CHECKPPORBISACK { "constraints/orbisack/checkpporbisack" };
1642 constexpr Param<bool> FORCECONSCOPY { "constraints/orbisack/forceconscopy" };
1643}
1645namespace CONSTRAINTS::ORBITOPE {
1647 constexpr Param<int> SEPAFREQ { "constraints/orbitope/sepafreq" };
1649 constexpr Param<int> PROPFREQ { "constraints/orbitope/propfreq" };
1651 constexpr Param<int> PROPTIMING { "constraints/orbitope/proptiming" };
1654 constexpr Param<int> EAGERFREQ { "constraints/orbitope/eagerfreq" };
1656 constexpr Param<int> MAXPREROUNDS { "constraints/orbitope/maxprerounds" };
1658 constexpr Param<bool> DELAYSEPA { "constraints/orbitope/delaysepa" };
1660 constexpr Param<bool> DELAYPROP { "constraints/orbitope/delayprop" };
1662 constexpr Param<int> PRESOLTIMING { "constraints/orbitope/presoltiming" };
1664 constexpr Param<bool> CHECKPPORBITOPE { "constraints/orbitope/checkpporbitope" };
1666 constexpr Param<bool> SEPAFULLORBITOPE { "constraints/orbitope/sepafullorbitope" };
1668 constexpr Param<bool> FORCECONSCOPY { "constraints/orbitope/forceconscopy" };
1669}
1671namespace CONSTRAINTS::PSEUDOBOOLEAN {
1673 constexpr Param<int> SEPAFREQ { "constraints/pseudoboolean/sepafreq" };
1675 constexpr Param<int> PROPFREQ { "constraints/pseudoboolean/propfreq" };
1677 constexpr Param<int> PROPTIMING { "constraints/pseudoboolean/proptiming" };
1680 constexpr Param<int> EAGERFREQ { "constraints/pseudoboolean/eagerfreq" };
1682 constexpr Param<int> MAXPREROUNDS { "constraints/pseudoboolean/maxprerounds" };
1684 constexpr Param<bool> DELAYSEPA { "constraints/pseudoboolean/delaysepa" };
1686 constexpr Param<bool> DELAYPROP { "constraints/pseudoboolean/delayprop" };
1688 constexpr Param<int> PRESOLTIMING { "constraints/pseudoboolean/presoltiming" };
1690 constexpr Param<bool> DECOMPOSENORMAL { "constraints/pseudoboolean/decomposenormal" };
1692 constexpr Param<bool> DECOMPOSEINDICATOR { "constraints/pseudoboolean/decomposeindicator" };
1694 constexpr Param<bool> NLCSEPARATE { "constraints/pseudoboolean/nlcseparate" };
1696 constexpr Param<bool> NLCPROPAGATE { "constraints/pseudoboolean/nlcpropagate" };
1698 constexpr Param<bool> NLCREMOVABLE { "constraints/pseudoboolean/nlcremovable" };
1699}
1701namespace CONSTRAINTS::SETPPC {
1703 constexpr Param<int> SEPAFREQ { "constraints/setppc/sepafreq" };
1705 constexpr Param<int> PROPFREQ { "constraints/setppc/propfreq" };
1707 constexpr Param<int> PROPTIMING { "constraints/setppc/proptiming" };
1710 constexpr Param<int> EAGERFREQ { "constraints/setppc/eagerfreq" };
1712 constexpr Param<int> MAXPREROUNDS { "constraints/setppc/maxprerounds" };
1714 constexpr Param<bool> DELAYSEPA { "constraints/setppc/delaysepa" };
1716 constexpr Param<bool> DELAYPROP { "constraints/setppc/delayprop" };
1718 constexpr Param<int> PRESOLTIMING { "constraints/setppc/presoltiming" };
1720 constexpr Param<int> NPSEUDOBRANCHES { "constraints/setppc/npseudobranches" };
1722 constexpr Param<bool> PRESOLPAIRWISE { "constraints/setppc/presolpairwise" };
1724 constexpr Param<bool> PRESOLUSEHASHING { "constraints/setppc/presolusehashing" };
1726 constexpr Param<bool> DUALPRESOLVING { "constraints/setppc/dualpresolving" };
1729 constexpr Param<bool> CLIQUELIFTING { "constraints/setppc/cliquelifting" };
1732 constexpr Param<bool> ADDVARIABLESASCLIQUES { "constraints/setppc/addvariablesascliques" };
1735 constexpr Param<bool> CLIQUESHRINKING { "constraints/setppc/cliqueshrinking" };
1736}
1738namespace CONSTRAINTS::SOS1 {
1740 constexpr Param<int> SEPAFREQ { "constraints/SOS1/sepafreq" };
1742 constexpr Param<int> PROPFREQ { "constraints/SOS1/propfreq" };
1744 constexpr Param<int> PROPTIMING { "constraints/SOS1/proptiming" };
1747 constexpr Param<int> EAGERFREQ { "constraints/SOS1/eagerfreq" };
1749 constexpr Param<int> MAXPREROUNDS { "constraints/SOS1/maxprerounds" };
1751 constexpr Param<bool> DELAYSEPA { "constraints/SOS1/delaysepa" };
1753 constexpr Param<bool> DELAYPROP { "constraints/SOS1/delayprop" };
1755 constexpr Param<int> PRESOLTIMING { "constraints/SOS1/presoltiming" };
1757 constexpr Param<int> MAXSOSADJACENCY { "constraints/SOS1/maxsosadjacency" };
1759 constexpr Param<int> MAXEXTENSIONS { "constraints/SOS1/maxextensions" };
1761 constexpr Param<int> MAXTIGHTENBDS { "constraints/SOS1/maxtightenbds" };
1763 constexpr Param<bool> PERFIMPLANALYSIS { "constraints/SOS1/perfimplanalysis" };
1765 constexpr Param<int> DEPTHIMPLANALYSIS { "constraints/SOS1/depthimplanalysis" };
1767 constexpr Param<bool> CONFLICTPROP { "constraints/SOS1/conflictprop" };
1769 constexpr Param<bool> IMPLPROP { "constraints/SOS1/implprop" };
1771 constexpr Param<bool> SOSCONSPROP { "constraints/SOS1/sosconsprop" };
1774 constexpr Param<char> BRANCHINGRULE { "constraints/SOS1/branchingrule" };
1776 constexpr Param<bool> AUTOSOS1BRANCH { "constraints/SOS1/autosos1branch" };
1779 constexpr Param<bool> FIXNONZERO { "constraints/SOS1/fixnonzero" };
1782 constexpr Param<bool> ADDCOMPS { "constraints/SOS1/addcomps" };
1784 constexpr Param<int> MAXADDCOMPS { "constraints/SOS1/maxaddcomps" };
1786 constexpr Param<double> ADDCOMPSFEAS { "constraints/SOS1/addcompsfeas" };
1788 constexpr Param<double> ADDBDSFEAS { "constraints/SOS1/addbdsfeas" };
1790 constexpr Param<bool> ADDEXTENDEDBDS { "constraints/SOS1/addextendedbds" };
1793 constexpr Param<bool> BRANCHSOS { "constraints/SOS1/branchsos" };
1795 constexpr Param<bool> BRANCHNONZEROS { "constraints/SOS1/branchnonzeros" };
1797 constexpr Param<bool> BRANCHWEIGHT { "constraints/SOS1/branchweight" };
1799 constexpr Param<int> ADDCOMPSDEPTH { "constraints/SOS1/addcompsdepth" };
1802 constexpr Param<int> NSTRONGROUNDS { "constraints/SOS1/nstrongrounds" };
1804 constexpr Param<int> NSTRONGITER { "constraints/SOS1/nstrongiter" };
1806 constexpr Param<bool> BOUNDCUTSFROMSOS1 { "constraints/SOS1/boundcutsfromsos1" };
1808 constexpr Param<bool> BOUNDCUTSFROMGRAPH { "constraints/SOS1/boundcutsfromgraph" };
1810 constexpr Param<bool> AUTOCUTSFROMSOS1 { "constraints/SOS1/autocutsfromsos1" };
1812 constexpr Param<int> BOUNDCUTSFREQ { "constraints/SOS1/boundcutsfreq" };
1814 constexpr Param<int> BOUNDCUTSDEPTH { "constraints/SOS1/boundcutsdepth" };
1816 constexpr Param<int> MAXBOUNDCUTS { "constraints/SOS1/maxboundcuts" };
1818 constexpr Param<int> MAXBOUNDCUTSROOT { "constraints/SOS1/maxboundcutsroot" };
1820 constexpr Param<bool> STRTHENBOUNDCUTS { "constraints/SOS1/strthenboundcuts" };
1822 constexpr Param<int> IMPLCUTSFREQ { "constraints/SOS1/implcutsfreq" };
1824 constexpr Param<int> IMPLCUTSDEPTH { "constraints/SOS1/implcutsdepth" };
1826 constexpr Param<int> MAXIMPLCUTS { "constraints/SOS1/maximplcuts" };
1828 constexpr Param<int> MAXIMPLCUTSROOT { "constraints/SOS1/maximplcutsroot" };
1829}
1831namespace CONSTRAINTS::SOS2 {
1833 constexpr Param<int> SEPAFREQ { "constraints/SOS2/sepafreq" };
1835 constexpr Param<int> PROPFREQ { "constraints/SOS2/propfreq" };
1837 constexpr Param<int> PROPTIMING { "constraints/SOS2/proptiming" };
1840 constexpr Param<int> EAGERFREQ { "constraints/SOS2/eagerfreq" };
1842 constexpr Param<int> MAXPREROUNDS { "constraints/SOS2/maxprerounds" };
1844 constexpr Param<bool> DELAYSEPA { "constraints/SOS2/delaysepa" };
1846 constexpr Param<bool> DELAYPROP { "constraints/SOS2/delayprop" };
1848 constexpr Param<int> PRESOLTIMING { "constraints/SOS2/presoltiming" };
1849}
1851namespace CONSTRAINTS::SUPERINDICATOR {
1853 constexpr Param<int> SEPAFREQ { "constraints/superindicator/sepafreq" };
1855 constexpr Param<int> PROPFREQ { "constraints/superindicator/propfreq" };
1857 constexpr Param<int> PROPTIMING { "constraints/superindicator/proptiming" };
1860 constexpr Param<int> EAGERFREQ { "constraints/superindicator/eagerfreq" };
1862 constexpr Param<int> MAXPREROUNDS { "constraints/superindicator/maxprerounds" };
1864 constexpr Param<bool> DELAYSEPA { "constraints/superindicator/delaysepa" };
1866 constexpr Param<bool> DELAYPROP { "constraints/superindicator/delayprop" };
1868 constexpr Param<int> PRESOLTIMING { "constraints/superindicator/presoltiming" };
1870 constexpr Param<bool> CHECKSLACKTYPE { "constraints/superindicator/checkslacktype" };
1873 constexpr Param<double> MAXUPGDCOEFLINEAR { "constraints/superindicator/maxupgdcoeflinear" };
1875 constexpr Param<int> UPGDPRIOINDICATOR { "constraints/superindicator/upgdprioindicator" };
1877 constexpr Param<int> UPGDPRIOLINEAR { "constraints/superindicator/upgdpriolinear" };
1878}
1880namespace CONSTRAINTS::SYMRESACK {
1882 constexpr Param<int> SEPAFREQ { "constraints/symresack/sepafreq" };
1884 constexpr Param<int> PROPFREQ { "constraints/symresack/propfreq" };
1886 constexpr Param<int> PROPTIMING { "constraints/symresack/proptiming" };
1889 constexpr Param<int> EAGERFREQ { "constraints/symresack/eagerfreq" };
1891 constexpr Param<int> MAXPREROUNDS { "constraints/symresack/maxprerounds" };
1893 constexpr Param<bool> DELAYSEPA { "constraints/symresack/delaysepa" };
1895 constexpr Param<bool> DELAYPROP { "constraints/symresack/delayprop" };
1897 constexpr Param<int> PRESOLTIMING { "constraints/symresack/presoltiming" };
1899 constexpr Param<bool> PPSYMRESACK { "constraints/symresack/ppsymresack" };
1901 constexpr Param<bool> CHECKMONOTONICITY { "constraints/symresack/checkmonotonicity" };
1903 constexpr Param<bool> FORCECONSCOPY { "constraints/symresack/forceconscopy" };
1904}
1906namespace CONSTRAINTS::VARBOUND {
1908 constexpr Param<int> SEPAFREQ { "constraints/varbound/sepafreq" };
1910 constexpr Param<int> PROPFREQ { "constraints/varbound/propfreq" };
1912 constexpr Param<int> PROPTIMING { "constraints/varbound/proptiming" };
1915 constexpr Param<int> EAGERFREQ { "constraints/varbound/eagerfreq" };
1917 constexpr Param<int> MAXPREROUNDS { "constraints/varbound/maxprerounds" };
1919 constexpr Param<bool> DELAYSEPA { "constraints/varbound/delaysepa" };
1921 constexpr Param<bool> DELAYPROP { "constraints/varbound/delayprop" };
1923 constexpr Param<int> PRESOLTIMING { "constraints/varbound/presoltiming" };
1925 constexpr Param<bool> PRESOLPAIRWISE { "constraints/varbound/presolpairwise" };
1927 constexpr Param<double> MAXLPCOEF { "constraints/varbound/maxlpcoef" };
1929 constexpr Param<bool> USEBDWIDENING { "constraints/varbound/usebdwidening" };
1930}
1932namespace CONSTRAINTS::XOR {
1934 constexpr Param<int> SEPAFREQ { "constraints/xor/sepafreq" };
1936 constexpr Param<int> PROPFREQ { "constraints/xor/propfreq" };
1938 constexpr Param<int> PROPTIMING { "constraints/xor/proptiming" };
1941 constexpr Param<int> EAGERFREQ { "constraints/xor/eagerfreq" };
1943 constexpr Param<int> MAXPREROUNDS { "constraints/xor/maxprerounds" };
1945 constexpr Param<bool> DELAYSEPA { "constraints/xor/delaysepa" };
1947 constexpr Param<bool> DELAYPROP { "constraints/xor/delayprop" };
1949 constexpr Param<int> PRESOLTIMING { "constraints/xor/presoltiming" };
1951 constexpr Param<bool> PRESOLPAIRWISE { "constraints/xor/presolpairwise" };
1953 constexpr Param<bool> PRESOLUSEHASHING { "constraints/xor/presolusehashing" };
1955 constexpr Param<bool> ADDEXTENDEDFORM { "constraints/xor/addextendedform" };
1957 constexpr Param<bool> ADDFLOWEXTENDED { "constraints/xor/addflowextended" };
1959 constexpr Param<bool> SEPARATEPARITY { "constraints/xor/separateparity" };
1961 constexpr Param<int> GAUSSPROPFREQ { "constraints/xor/gausspropfreq" };
1962}
1964namespace CUTSELECTION::DYNAMIC {
1966 constexpr Param<int> PRIORITY { "cutselection/dynamic/priority" };
1968 constexpr Param<double> EFFICACYWEIGHT { "cutselection/dynamic/efficacyweight" };
1970 constexpr Param<double> DIRCUTOFFDISTWEIGHT { "cutselection/dynamic/dircutoffdistweight" };
1972 constexpr Param<double> OBJPARALWEIGHT { "cutselection/dynamic/objparalweight" };
1974 constexpr Param<double> INTSUPPORTWEIGHT { "cutselection/dynamic/intsupportweight" };
1976 constexpr Param<double> MINGAIN { "cutselection/dynamic/mingain" };
1978 constexpr Param<char> FILTERMODE { "cutselection/dynamic/filtermode" };
1980 constexpr Param<double> MINORTHO { "cutselection/dynamic/minortho" };
1982 constexpr Param<int> MAXDEPTH { "cutselection/dynamic/maxdepth" };
1983}
1985namespace CUTSELECTION::ENSEMBLE {
1987 constexpr Param<int> PRIORITY { "cutselection/ensemble/priority" };
1989 constexpr Param<double> EFFICACYWEIGHT { "cutselection/ensemble/efficacyweight" };
1991 constexpr Param<double> DIRCUTOFFDISTWEIGHT { "cutselection/ensemble/dircutoffdistweight" };
1993 constexpr Param<double> OBJPARALWEIGHT { "cutselection/ensemble/objparalweight" };
1995 constexpr Param<double> INTSUPPORTWEIGHT { "cutselection/ensemble/intsupportweight" };
1997 constexpr Param<double> EXPIMPROVWEIGHT { "cutselection/ensemble/expimprovweight" };
1999 constexpr Param<double> MINSCORE { "cutselection/ensemble/minscore" };
2001 constexpr Param<double> PSCOSTWEIGHT { "cutselection/ensemble/pscostweight" };
2003 constexpr Param<double> LOCKSWEIGHT { "cutselection/ensemble/locksweight" };
2005 constexpr Param<double> MAXSPARSITYBONUS { "cutselection/ensemble/maxsparsitybonus" };
2007 constexpr Param<double> GOODNUMERICSBONUS { "cutselection/ensemble/goodnumericsbonus" };
2009 constexpr Param<double> ENDSPARSITYBONUS { "cutselection/ensemble/endsparsitybonus" };
2011 constexpr Param<double> MAXPARAL { "cutselection/ensemble/maxparal" };
2013 constexpr Param<double> PARALPENALTY { "cutselection/ensemble/paralpenalty" };
2015 constexpr Param<double> MAXCUTDENSITY { "cutselection/ensemble/maxcutdensity" };
2017 constexpr Param<double> MAXNONZEROROOTROUND { "cutselection/ensemble/maxnonzerorootround" };
2019 constexpr Param<double> MAXNONZEROTREEROUND { "cutselection/ensemble/maxnonzerotreeround" };
2021 constexpr Param<bool> FILTERPARALCUTS { "cutselection/ensemble/filterparalcuts" };
2023 constexpr Param<bool> PENALISEPARALCUTS { "cutselection/ensemble/penaliseparalcuts" };
2025 constexpr Param<bool> FILTERDENSECUTS { "cutselection/ensemble/filterdensecuts" };
2027 constexpr Param<bool> PENALISELOCKS { "cutselection/ensemble/penaliselocks" };
2029 constexpr Param<bool> PENALISEOBJPARAL { "cutselection/ensemble/penaliseobjparal" };
2031 constexpr Param<int> MAXCOEFRATIOBONUS { "cutselection/ensemble/maxcoefratiobonus" };
2033 constexpr Param<int> MAXCUTS { "cutselection/ensemble/maxcuts" };
2035 constexpr Param<int> MAXNUMVARS { "cutselection/ensemble/maxnumvars" };
2036}
2038namespace CUTSELECTION::HYBRID {
2040 constexpr Param<int> PRIORITY { "cutselection/hybrid/priority" };
2042 constexpr Param<double> EFFICACYWEIGHT { "cutselection/hybrid/efficacyweight" };
2044 constexpr Param<double> DIRCUTOFFDISTWEIGHT { "cutselection/hybrid/dircutoffdistweight" };
2046 constexpr Param<double> OBJPARALWEIGHT { "cutselection/hybrid/objparalweight" };
2048 constexpr Param<double> INTSUPPORTWEIGHT { "cutselection/hybrid/intsupportweight" };
2050 constexpr Param<double> MINORTHO { "cutselection/hybrid/minortho" };
2052 constexpr Param<double> MINORTHOROOT { "cutselection/hybrid/minorthoroot" };
2053}
2055namespace DECOMPOSITION {
2057 constexpr Param<bool> BENDERSLABELS { "decomposition/benderslabels" };
2059 constexpr Param<bool> APPLYBENDERS { "decomposition/applybenders" };
2061 constexpr Param<int> MAXGRAPHEDGE { "decomposition/maxgraphedge" };
2063 constexpr Param<bool> DISABLEMEASURES { "decomposition/disablemeasures" };
2064}
2066namespace DISPLAY {
2068 constexpr Param<int> VERBLEVEL { "display/verblevel" };
2070 constexpr Param<int> WIDTH { "display/width" };
2072 constexpr Param<int> FREQ { "display/freq" };
2074 constexpr Param<int> HEADERFREQ { "display/headerfreq" };
2076 constexpr Param<bool> LPINFO { "display/lpinfo" };
2078 constexpr Param<bool> ALLVIOLS { "display/allviols" };
2080 constexpr Param<bool> RELEVANTSTATS { "display/relevantstats" };
2081}
2083namespace DISPLAY::AVGDUALBOUND {
2085 constexpr Param<int> ACTIVE { "display/avgdualbound/active" };
2086}
2088namespace DISPLAY::COMPLETED {
2090 constexpr Param<int> ACTIVE { "display/completed/active" };
2091}
2093namespace DISPLAY::CONCDUALBOUND {
2095 constexpr Param<int> ACTIVE { "display/concdualbound/active" };
2096}
2098namespace DISPLAY::CONCGAP {
2100 constexpr Param<int> ACTIVE { "display/concgap/active" };
2101}
2103namespace DISPLAY::CONCMEMUSED {
2105 constexpr Param<int> ACTIVE { "display/concmemused/active" };
2106}
2108namespace DISPLAY::CONCPRIMALBOUND {
2110 constexpr Param<int> ACTIVE { "display/concprimalbound/active" };
2111}
2113namespace DISPLAY::CONCSOLFOUND {
2115 constexpr Param<int> ACTIVE { "display/concsolfound/active" };
2116}
2118namespace DISPLAY::CONFLICTS {
2120 constexpr Param<int> ACTIVE { "display/conflicts/active" };
2121}
2123namespace DISPLAY::CONSS {
2125 constexpr Param<int> ACTIVE { "display/conss/active" };
2126}
2128namespace DISPLAY::CURCOLS {
2130 constexpr Param<int> ACTIVE { "display/curcols/active" };
2131}
2133namespace DISPLAY::CURCONSS {
2135 constexpr Param<int> ACTIVE { "display/curconss/active" };
2136}
2138namespace DISPLAY::CURDUALBOUND {
2140 constexpr Param<int> ACTIVE { "display/curdualbound/active" };
2141}
2143namespace DISPLAY::CURROWS {
2145 constexpr Param<int> ACTIVE { "display/currows/active" };
2146}
2148namespace DISPLAY::CUTOFFBOUND {
2150 constexpr Param<int> ACTIVE { "display/cutoffbound/active" };
2151}
2153namespace DISPLAY::CUTS {
2155 constexpr Param<int> ACTIVE { "display/cuts/active" };
2156}
2158namespace DISPLAY::DEPTH {
2160 constexpr Param<int> ACTIVE { "display/depth/active" };
2161}
2163namespace DISPLAY::DUALBOUND {
2165 constexpr Param<int> ACTIVE { "display/dualbound/active" };
2166}
2168namespace DISPLAY::ESTIMATE {
2170 constexpr Param<int> ACTIVE { "display/estimate/active" };
2171}
2173namespace DISPLAY::FEASST {
2175 constexpr Param<int> ACTIVE { "display/feasST/active" };
2176}
2178namespace DISPLAY::GAP {
2180 constexpr Param<int> ACTIVE { "display/gap/active" };
2181}
2183namespace DISPLAY::LPAVGITERATIONS {
2185 constexpr Param<int> ACTIVE { "display/lpavgiterations/active" };
2186}
2188namespace DISPLAY::LPCOND {
2190 constexpr Param<int> ACTIVE { "display/lpcond/active" };
2191}
2193namespace DISPLAY::LPITERATIONS {
2195 constexpr Param<int> ACTIVE { "display/lpiterations/active" };
2196}
2198namespace DISPLAY::LPOBJ {
2200 constexpr Param<int> ACTIVE { "display/lpobj/active" };
2201}
2203namespace DISPLAY::MAXDEPTH {
2205 constexpr Param<int> ACTIVE { "display/maxdepth/active" };
2206}
2208namespace DISPLAY::MEMTOTAL {
2210 constexpr Param<int> ACTIVE { "display/memtotal/active" };
2211}
2213namespace DISPLAY::MEMUSED {
2215 constexpr Param<int> ACTIVE { "display/memused/active" };
2216}
2218namespace DISPLAY::NEXTERNBRANCHCANDS {
2220 constexpr Param<int> ACTIVE { "display/nexternbranchcands/active" };
2221}
2223namespace DISPLAY::NFRAC {
2225 constexpr Param<int> ACTIVE { "display/nfrac/active" };
2226}
2228namespace DISPLAY::NINFEASLEAVES {
2230 constexpr Param<int> ACTIVE { "display/ninfeasleaves/active" };
2231}
2233namespace DISPLAY::NNODES {
2235 constexpr Param<int> ACTIVE { "display/nnodes/active" };
2236}
2238namespace DISPLAY::NNODESBELOWINC {
2240 constexpr Param<int> ACTIVE { "display/nnodesbelowinc/active" };
2241}
2243namespace DISPLAY::NOBJLEAVES {
2245 constexpr Param<int> ACTIVE { "display/nobjleaves/active" };
2246}
2248namespace DISPLAY::NODESLEFT {
2250 constexpr Param<int> ACTIVE { "display/nodesleft/active" };
2251}
2253namespace DISPLAY::NRANK1NODES {
2255 constexpr Param<int> ACTIVE { "display/nrank1nodes/active" };
2256}
2258namespace DISPLAY::NSOLS {
2260 constexpr Param<int> ACTIVE { "display/nsols/active" };
2261}
2263namespace DISPLAY::PLUNGEDEPTH {
2265 constexpr Param<int> ACTIVE { "display/plungedepth/active" };
2266}
2268namespace DISPLAY::POOLSIZE {
2270 constexpr Param<int> ACTIVE { "display/poolsize/active" };
2271}
2273namespace DISPLAY::PRIMALBOUND {
2275 constexpr Param<int> ACTIVE { "display/primalbound/active" };
2276}
2278namespace DISPLAY::PRIMALGAP {
2280 constexpr Param<int> ACTIVE { "display/primalgap/active" };
2281}
2283namespace DISPLAY::PSEUDOOBJ {
2285 constexpr Param<int> ACTIVE { "display/pseudoobj/active" };
2286}
2288namespace DISPLAY::SEPAROUNDS {
2290 constexpr Param<int> ACTIVE { "display/separounds/active" };
2291}
2293namespace DISPLAY::SOLFOUND {
2295 constexpr Param<int> ACTIVE { "display/solfound/active" };
2296}
2298namespace DISPLAY::SOLS {
2300 constexpr Param<int> ACTIVE { "display/sols/active" };
2301}
2303namespace DISPLAY::STRONGBRANCHS {
2305 constexpr Param<int> ACTIVE { "display/strongbranchs/active" };
2306}
2308namespace DISPLAY::TIME {
2310 constexpr Param<int> ACTIVE { "display/time/active" };
2311}
2313namespace DISPLAY::VARS {
2315 constexpr Param<int> ACTIVE { "display/vars/active" };
2316}
2318namespace ESTIMATION {
2321 constexpr Param<char> METHOD { "estimation/method" };
2323 constexpr Param<double> COEFMONOWEIGHT { "estimation/coefmonoweight" };
2325 constexpr Param<double> COEFMONOSSG { "estimation/coefmonossg" };
2327 constexpr Param<int> REPORTFREQ { "estimation/reportfreq" };
2329 constexpr Param<std::string> REGFORESTFILENAME { "estimation/regforestfilename" };
2332 constexpr Param<char> COMPLETIONTYPE { "estimation/completiontype" };
2334 constexpr Param<bool> USELEAFTS { "estimation/useleafts" };
2336 constexpr Param<bool> SHOWSTATS { "estimation/showstats" };
2337}
2339namespace ESTIMATION::RESTARTS {
2341 constexpr Param<char> RESTARTPOLICY { "estimation/restarts/restartpolicy" };
2343 constexpr Param<int> RESTARTLIMIT { "estimation/restarts/restartlimit" };
2345 constexpr Param<long long> MINNODES { "estimation/restarts/minnodes" };
2347 constexpr Param<bool> COUNTONLYLEAVES { "estimation/restarts/countonlyleaves" };
2349 constexpr Param<double> RESTARTFACTOR { "estimation/restarts/restartfactor" };
2351 constexpr Param<bool> RESTARTNONLINEAR { "estimation/restarts/restartnonlinear" };
2353 constexpr Param<bool> RESTARTACTPRICERS { "estimation/restarts/restartactpricers" };
2355 constexpr Param<int> HITCOUNTERLIM { "estimation/restarts/hitcounterlim" };
2356}
2358namespace ESTIMATION::SSG {
2360 constexpr Param<int> NMAXSUBTREES { "estimation/ssg/nmaxsubtrees" };
2362 constexpr Param<long long> NMINNODESLASTSPLIT { "estimation/ssg/nminnodeslastsplit" };
2363}
2365namespace ESTIMATION::TREEPROFILE {
2367 constexpr Param<bool> ENABLED { "estimation/treeprofile/enabled" };
2369 constexpr Param<double> MINNODESPERDEPTH { "estimation/treeprofile/minnodesperdepth" };
2370}
2372namespace EXPR::LOG {
2374 constexpr Param<double> MINZERODISTANCE { "expr/log/minzerodistance" };
2375}
2377namespace EXPR::POW {
2379 constexpr Param<double> MINZERODISTANCE { "expr/pow/minzerodistance" };
2381 constexpr Param<int> EXPANDMAXEXPONENT { "expr/pow/expandmaxexponent" };
2383 constexpr Param<bool> DISTRIBFRACEXPONENT { "expr/pow/distribfracexponent" };
2384}
2386namespace EXPR::PROD {
2388 constexpr Param<bool> EXPANDALWAYS { "expr/prod/expandalways" };
2389}
2391namespace HEURISTICS {
2393 constexpr Param<bool> USEUCTSUBSCIP { "heuristics/useuctsubscip" };
2394}
2396namespace HEURISTICS::ACTCONSDIVING {
2398 constexpr Param<int> PRIORITY { "heuristics/actconsdiving/priority" };
2400 constexpr Param<int> FREQ { "heuristics/actconsdiving/freq" };
2402 constexpr Param<int> FREQOFS { "heuristics/actconsdiving/freqofs" };
2404 constexpr Param<int> MAXDEPTH { "heuristics/actconsdiving/maxdepth" };
2406 constexpr Param<double> MINRELDEPTH { "heuristics/actconsdiving/minreldepth" };
2408 constexpr Param<double> MAXRELDEPTH { "heuristics/actconsdiving/maxreldepth" };
2410 constexpr Param<double> MAXLPITERQUOT { "heuristics/actconsdiving/maxlpiterquot" };
2412 constexpr Param<int> MAXLPITEROFS { "heuristics/actconsdiving/maxlpiterofs" };
2415 constexpr Param<double> MAXDIVEUBQUOT { "heuristics/actconsdiving/maxdiveubquot" };
2418 constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/actconsdiving/maxdiveavgquot" };
2420 constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/actconsdiving/maxdiveubquotnosol" };
2422 constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/actconsdiving/maxdiveavgquotnosol" };
2424 constexpr Param<bool> BACKTRACK { "heuristics/actconsdiving/backtrack" };
2426 constexpr Param<double> LPRESOLVEDOMCHGQUOT { "heuristics/actconsdiving/lpresolvedomchgquot" };
2428 constexpr Param<int> LPSOLVEFREQ { "heuristics/actconsdiving/lpsolvefreq" };
2431 constexpr Param<bool> ONLYLPBRANCHCANDS { "heuristics/actconsdiving/onlylpbranchcands" };
2432}
2434namespace HEURISTICS::ADAPTIVEDIVING {
2436 constexpr Param<int> PRIORITY { "heuristics/adaptivediving/priority" };
2438 constexpr Param<int> FREQ { "heuristics/adaptivediving/freq" };
2440 constexpr Param<int> FREQOFS { "heuristics/adaptivediving/freqofs" };
2442 constexpr Param<int> MAXDEPTH { "heuristics/adaptivediving/maxdepth" };
2444 constexpr Param<double> EPSILON { "heuristics/adaptivediving/epsilon" };
2447 constexpr Param<char> SCORETYPE { "heuristics/adaptivediving/scoretype" };
2449 constexpr Param<char> SELTYPE { "heuristics/adaptivediving/seltype" };
2451 constexpr Param<bool> USEADAPTIVECONTEXT { "heuristics/adaptivediving/useadaptivecontext" };
2453 constexpr Param<double> SELCONFIDENCECOEFF { "heuristics/adaptivediving/selconfidencecoeff" };
2455 constexpr Param<double> MAXLPITERQUOT { "heuristics/adaptivediving/maxlpiterquot" };
2457 constexpr Param<long long> MAXLPITEROFS { "heuristics/adaptivediving/maxlpiterofs" };
2459 constexpr Param<double> BESTSOLWEIGHT { "heuristics/adaptivediving/bestsolweight" };
2460}
2462namespace HEURISTICS::ALNS {
2464 constexpr Param<int> PRIORITY { "heuristics/alns/priority" };
2466 constexpr Param<int> FREQ { "heuristics/alns/freq" };
2468 constexpr Param<int> FREQOFS { "heuristics/alns/freqofs" };
2470 constexpr Param<int> MAXDEPTH { "heuristics/alns/maxdepth" };
2472 constexpr Param<bool> SHOWNBSTATS { "heuristics/alns/shownbstats" };
2474 constexpr Param<long long> MAXNODES { "heuristics/alns/maxnodes" };
2476 constexpr Param<long long> NODESOFS { "heuristics/alns/nodesofs" };
2478 constexpr Param<long long> MINNODES { "heuristics/alns/minnodes" };
2480 constexpr Param<long long> WAITINGNODES { "heuristics/alns/waitingnodes" };
2482 constexpr Param<double> NODESQUOT { "heuristics/alns/nodesquot" };
2484 constexpr Param<double> NODESQUOTMIN { "heuristics/alns/nodesquotmin" };
2486 constexpr Param<double> STARTMINIMPROVE { "heuristics/alns/startminimprove" };
2488 constexpr Param<double> MINIMPROVELOW { "heuristics/alns/minimprovelow" };
2490 constexpr Param<double> MINIMPROVEHIGH { "heuristics/alns/minimprovehigh" };
2492 constexpr Param<int> NSOLSLIM { "heuristics/alns/nsolslim" };
2494 constexpr Param<char> BANDITALGO { "heuristics/alns/banditalgo" };
2496 constexpr Param<double> GAMMA { "heuristics/alns/gamma" };
2498 constexpr Param<double> BETA { "heuristics/alns/beta" };
2500 constexpr Param<double> ALPHA { "heuristics/alns/alpha" };
2502 constexpr Param<bool> USEDISTANCES { "heuristics/alns/usedistances" };
2504 constexpr Param<bool> USEREDCOST { "heuristics/alns/useredcost" };
2507 constexpr Param<bool> DOMOREFIXINGS { "heuristics/alns/domorefixings" };
2509 constexpr Param<bool> ADJUSTFIXINGRATE { "heuristics/alns/adjustfixingrate" };
2511 constexpr Param<bool> USESUBSCIPHEURS { "heuristics/alns/usesubscipheurs" };
2514 constexpr Param<double> REWARDCONTROL { "heuristics/alns/rewardcontrol" };
2516 constexpr Param<double> TARGETNODEFACTOR { "heuristics/alns/targetnodefactor" };
2518 constexpr Param<int> SEED { "heuristics/alns/seed" };
2521 constexpr Param<int> MAXCALLSSAMESOL { "heuristics/alns/maxcallssamesol" };
2523 constexpr Param<bool> ADJUSTMINIMPROVE { "heuristics/alns/adjustminimprove" };
2525 constexpr Param<bool> ADJUSTTARGETNODES { "heuristics/alns/adjusttargetnodes" };
2527 constexpr Param<double> EPS { "heuristics/alns/eps" };
2529 constexpr Param<double> REWARDBASELINE { "heuristics/alns/rewardbaseline" };
2531 constexpr Param<bool> RESETWEIGHTS { "heuristics/alns/resetweights" };
2533 constexpr Param<std::string> REWARDFILENAME { "heuristics/alns/rewardfilename" };
2535 constexpr Param<bool> SUBSCIPRANDSEEDS { "heuristics/alns/subsciprandseeds" };
2537 constexpr Param<bool> SCALEBYEFFORT { "heuristics/alns/scalebyeffort" };
2539 constexpr Param<bool> COPYCUTS { "heuristics/alns/copycuts" };
2541 constexpr Param<double> FIXTOL { "heuristics/alns/fixtol" };
2543 constexpr Param<double> UNFIXTOL { "heuristics/alns/unfixtol" };
2545 constexpr Param<bool> USELOCALREDCOST { "heuristics/alns/uselocalredcost" };
2547 constexpr Param<bool> USEPSCOST { "heuristics/alns/usepscost" };
2549 constexpr Param<bool> INITDURINGROOT { "heuristics/alns/initduringroot" };
2550}
2552namespace HEURISTICS::ALNS::CROSSOVER {
2554 constexpr Param<double> MINFIXINGRATE { "heuristics/alns/crossover/minfixingrate" };
2556 constexpr Param<double> MAXFIXINGRATE { "heuristics/alns/crossover/maxfixingrate" };
2558 constexpr Param<bool> ACTIVE { "heuristics/alns/crossover/active" };
2560 constexpr Param<double> PRIORITY { "heuristics/alns/crossover/priority" };
2562 constexpr Param<int> NSOLS { "heuristics/alns/crossover/nsols" };
2563}
2565namespace HEURISTICS::ALNS::DINS {
2567 constexpr Param<double> MINFIXINGRATE { "heuristics/alns/dins/minfixingrate" };
2569 constexpr Param<double> MAXFIXINGRATE { "heuristics/alns/dins/maxfixingrate" };
2571 constexpr Param<bool> ACTIVE { "heuristics/alns/dins/active" };
2573 constexpr Param<double> PRIORITY { "heuristics/alns/dins/priority" };
2575 constexpr Param<int> NPOOLSOLS { "heuristics/alns/dins/npoolsols" };
2576}
2578namespace HEURISTICS::ALNS::LOCALBRANCHING {
2580 constexpr Param<double> MINFIXINGRATE { "heuristics/alns/localbranching/minfixingrate" };
2582 constexpr Param<double> MAXFIXINGRATE { "heuristics/alns/localbranching/maxfixingrate" };
2584 constexpr Param<bool> ACTIVE { "heuristics/alns/localbranching/active" };
2586 constexpr Param<double> PRIORITY { "heuristics/alns/localbranching/priority" };
2587}
2589namespace HEURISTICS::ALNS::MUTATION {
2591 constexpr Param<double> MINFIXINGRATE { "heuristics/alns/mutation/minfixingrate" };
2593 constexpr Param<double> MAXFIXINGRATE { "heuristics/alns/mutation/maxfixingrate" };
2595 constexpr Param<bool> ACTIVE { "heuristics/alns/mutation/active" };
2597 constexpr Param<double> PRIORITY { "heuristics/alns/mutation/priority" };
2598}
2600namespace HEURISTICS::ALNS::PROXIMITY {
2602 constexpr Param<double> MINFIXINGRATE { "heuristics/alns/proximity/minfixingrate" };
2604 constexpr Param<double> MAXFIXINGRATE { "heuristics/alns/proximity/maxfixingrate" };
2606 constexpr Param<bool> ACTIVE { "heuristics/alns/proximity/active" };
2608 constexpr Param<double> PRIORITY { "heuristics/alns/proximity/priority" };
2609}
2611namespace HEURISTICS::ALNS::RENS {
2613 constexpr Param<double> MINFIXINGRATE { "heuristics/alns/rens/minfixingrate" };
2615 constexpr Param<double> MAXFIXINGRATE { "heuristics/alns/rens/maxfixingrate" };
2617 constexpr Param<bool> ACTIVE { "heuristics/alns/rens/active" };
2619 constexpr Param<double> PRIORITY { "heuristics/alns/rens/priority" };
2620}
2622namespace HEURISTICS::ALNS::RINS {
2624 constexpr Param<double> MINFIXINGRATE { "heuristics/alns/rins/minfixingrate" };
2626 constexpr Param<double> MAXFIXINGRATE { "heuristics/alns/rins/maxfixingrate" };
2628 constexpr Param<bool> ACTIVE { "heuristics/alns/rins/active" };
2630 constexpr Param<double> PRIORITY { "heuristics/alns/rins/priority" };
2631}
2633namespace HEURISTICS::ALNS::TRUSTREGION {
2635 constexpr Param<double> MINFIXINGRATE { "heuristics/alns/trustregion/minfixingrate" };
2637 constexpr Param<double> MAXFIXINGRATE { "heuristics/alns/trustregion/maxfixingrate" };
2639 constexpr Param<bool> ACTIVE { "heuristics/alns/trustregion/active" };
2641 constexpr Param<double> PRIORITY { "heuristics/alns/trustregion/priority" };
2643 constexpr Param<double> VIOLPENALTY { "heuristics/alns/trustregion/violpenalty" };
2644}
2646namespace HEURISTICS::ALNS::ZEROOBJECTIVE {
2648 constexpr Param<double> MINFIXINGRATE { "heuristics/alns/zeroobjective/minfixingrate" };
2650 constexpr Param<double> MAXFIXINGRATE { "heuristics/alns/zeroobjective/maxfixingrate" };
2652 constexpr Param<bool> ACTIVE { "heuristics/alns/zeroobjective/active" };
2654 constexpr Param<double> PRIORITY { "heuristics/alns/zeroobjective/priority" };
2655}
2657namespace HEURISTICS::BOUND {
2659 constexpr Param<int> PRIORITY { "heuristics/bound/priority" };
2661 constexpr Param<int> FREQ { "heuristics/bound/freq" };
2663 constexpr Param<int> FREQOFS { "heuristics/bound/freqofs" };
2665 constexpr Param<int> MAXDEPTH { "heuristics/bound/maxdepth" };
2667 constexpr Param<bool> ONLYWITHOUTSOL { "heuristics/bound/onlywithoutsol" };
2669 constexpr Param<int> MAXPROPROUNDS { "heuristics/bound/maxproprounds" };
2671 constexpr Param<char> BOUND { "heuristics/bound/bound" };
2672}
2674namespace HEURISTICS::CLIQUE {
2676 constexpr Param<int> PRIORITY { "heuristics/clique/priority" };
2678 constexpr Param<int> FREQ { "heuristics/clique/freq" };
2680 constexpr Param<int> FREQOFS { "heuristics/clique/freqofs" };
2682 constexpr Param<int> MAXDEPTH { "heuristics/clique/maxdepth" };
2684 constexpr Param<double> MININTFIXINGRATE { "heuristics/clique/minintfixingrate" };
2686 constexpr Param<double> MINMIPFIXINGRATE { "heuristics/clique/minmipfixingrate" };
2688 constexpr Param<long long> MAXNODES { "heuristics/clique/maxnodes" };
2690 constexpr Param<long long> NODESOFS { "heuristics/clique/nodesofs" };
2692 constexpr Param<long long> MINNODES { "heuristics/clique/minnodes" };
2694 constexpr Param<double> NODESQUOT { "heuristics/clique/nodesquot" };
2696 constexpr Param<double> MINIMPROVE { "heuristics/clique/minimprove" };
2698 constexpr Param<int> MAXPROPROUNDS { "heuristics/clique/maxproprounds" };
2700 constexpr Param<bool> COPYCUTS { "heuristics/clique/copycuts" };
2702 constexpr Param<bool> USELOCKFIXINGS { "heuristics/clique/uselockfixings" };
2704 constexpr Param<int> MAXBACKTRACKS { "heuristics/clique/maxbacktracks" };
2705}
2707namespace HEURISTICS::COEFDIVING {
2709 constexpr Param<int> PRIORITY { "heuristics/coefdiving/priority" };
2711 constexpr Param<int> FREQ { "heuristics/coefdiving/freq" };
2713 constexpr Param<int> FREQOFS { "heuristics/coefdiving/freqofs" };
2715 constexpr Param<int> MAXDEPTH { "heuristics/coefdiving/maxdepth" };
2717 constexpr Param<double> MINRELDEPTH { "heuristics/coefdiving/minreldepth" };
2719 constexpr Param<double> MAXRELDEPTH { "heuristics/coefdiving/maxreldepth" };
2721 constexpr Param<double> MAXLPITERQUOT { "heuristics/coefdiving/maxlpiterquot" };
2723 constexpr Param<int> MAXLPITEROFS { "heuristics/coefdiving/maxlpiterofs" };
2726 constexpr Param<double> MAXDIVEUBQUOT { "heuristics/coefdiving/maxdiveubquot" };
2729 constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/coefdiving/maxdiveavgquot" };
2731 constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/coefdiving/maxdiveubquotnosol" };
2733 constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/coefdiving/maxdiveavgquotnosol" };
2735 constexpr Param<bool> BACKTRACK { "heuristics/coefdiving/backtrack" };
2737 constexpr Param<double> LPRESOLVEDOMCHGQUOT { "heuristics/coefdiving/lpresolvedomchgquot" };
2739 constexpr Param<int> LPSOLVEFREQ { "heuristics/coefdiving/lpsolvefreq" };
2742 constexpr Param<bool> ONLYLPBRANCHCANDS { "heuristics/coefdiving/onlylpbranchcands" };
2743}
2745namespace HEURISTICS::COMPLETESOL {
2747 constexpr Param<int> PRIORITY { "heuristics/completesol/priority" };
2749 constexpr Param<int> FREQ { "heuristics/completesol/freq" };
2751 constexpr Param<int> FREQOFS { "heuristics/completesol/freqofs" };
2753 constexpr Param<int> MAXDEPTH { "heuristics/completesol/maxdepth" };
2755 constexpr Param<long long> MAXNODES { "heuristics/completesol/maxnodes" };
2757 constexpr Param<long long> MINNODES { "heuristics/completesol/minnodes" };
2759 constexpr Param<double> MAXUNKNOWNRATE { "heuristics/completesol/maxunknownrate" };
2761 constexpr Param<bool> ADDALLSOLS { "heuristics/completesol/addallsols" };
2763 constexpr Param<long long> NODESOFS { "heuristics/completesol/nodesofs" };
2765 constexpr Param<double> NODESQUOT { "heuristics/completesol/nodesquot" };
2767 constexpr Param<double> LPLIMFAC { "heuristics/completesol/lplimfac" };
2769 constexpr Param<double> OBJWEIGHT { "heuristics/completesol/objweight" };
2772 constexpr Param<double> BOUNDWIDENING { "heuristics/completesol/boundwidening" };
2774 constexpr Param<double> MINIMPROVE { "heuristics/completesol/minimprove" };
2776 constexpr Param<bool> IGNORECONT { "heuristics/completesol/ignorecont" };
2778 constexpr Param<int> SOLUTIONS { "heuristics/completesol/solutions" };
2780 constexpr Param<int> MAXPROPROUNDS { "heuristics/completesol/maxproprounds" };
2782 constexpr Param<bool> BEFOREPRESOL { "heuristics/completesol/beforepresol" };
2784 constexpr Param<long long> MAXLPITER { "heuristics/completesol/maxlpiter" };
2786 constexpr Param<int> MAXCONTVARS { "heuristics/completesol/maxcontvars" };
2787}
2789namespace HEURISTICS::CONFLICTDIVING {
2791 constexpr Param<int> PRIORITY { "heuristics/conflictdiving/priority" };
2793 constexpr Param<int> FREQ { "heuristics/conflictdiving/freq" };
2795 constexpr Param<int> FREQOFS { "heuristics/conflictdiving/freqofs" };
2797 constexpr Param<int> MAXDEPTH { "heuristics/conflictdiving/maxdepth" };
2799 constexpr Param<double> MINRELDEPTH { "heuristics/conflictdiving/minreldepth" };
2801 constexpr Param<double> MAXRELDEPTH { "heuristics/conflictdiving/maxreldepth" };
2803 constexpr Param<double> MAXLPITERQUOT { "heuristics/conflictdiving/maxlpiterquot" };
2805 constexpr Param<int> MAXLPITEROFS { "heuristics/conflictdiving/maxlpiterofs" };
2808 constexpr Param<double> MAXDIVEUBQUOT { "heuristics/conflictdiving/maxdiveubquot" };
2811 constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/conflictdiving/maxdiveavgquot" };
2813 constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/conflictdiving/maxdiveubquotnosol" };
2815 constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/conflictdiving/maxdiveavgquotnosol" };
2817 constexpr Param<bool> BACKTRACK { "heuristics/conflictdiving/backtrack" };
2819 constexpr Param<double> LPRESOLVEDOMCHGQUOT { "heuristics/conflictdiving/lpresolvedomchgquot" };
2821 constexpr Param<int> LPSOLVEFREQ { "heuristics/conflictdiving/lpsolvefreq" };
2824 constexpr Param<bool> ONLYLPBRANCHCANDS { "heuristics/conflictdiving/onlylpbranchcands" };
2826 constexpr Param<bool> MAXVIOL { "heuristics/conflictdiving/maxviol" };
2828 constexpr Param<bool> LIKECOEF { "heuristics/conflictdiving/likecoef" };
2830 constexpr Param<int> MINCONFLICTLOCKS { "heuristics/conflictdiving/minconflictlocks" };
2832 constexpr Param<double> LOCKWEIGHT { "heuristics/conflictdiving/lockweight" };
2833}
2835namespace HEURISTICS::CROSSOVER {
2837 constexpr Param<int> PRIORITY { "heuristics/crossover/priority" };
2839 constexpr Param<int> FREQ { "heuristics/crossover/freq" };
2841 constexpr Param<int> FREQOFS { "heuristics/crossover/freqofs" };
2843 constexpr Param<int> MAXDEPTH { "heuristics/crossover/maxdepth" };
2845 constexpr Param<long long> NODESOFS { "heuristics/crossover/nodesofs" };
2847 constexpr Param<long long> MAXNODES { "heuristics/crossover/maxnodes" };
2849 constexpr Param<long long> MINNODES { "heuristics/crossover/minnodes" };
2851 constexpr Param<int> NUSEDSOLS { "heuristics/crossover/nusedsols" };
2853 constexpr Param<long long> NWAITINGNODES { "heuristics/crossover/nwaitingnodes" };
2855 constexpr Param<double> NODESQUOT { "heuristics/crossover/nodesquot" };
2857 constexpr Param<double> MINFIXINGRATE { "heuristics/crossover/minfixingrate" };
2859 constexpr Param<double> MINIMPROVE { "heuristics/crossover/minimprove" };
2861 constexpr Param<double> LPLIMFAC { "heuristics/crossover/lplimfac" };
2863 constexpr Param<bool> RANDOMIZATION { "heuristics/crossover/randomization" };
2865 constexpr Param<bool> DONTWAITATROOT { "heuristics/crossover/dontwaitatroot" };
2867 constexpr Param<bool> USELPROWS { "heuristics/crossover/uselprows" };
2869 constexpr Param<bool> COPYCUTS { "heuristics/crossover/copycuts" };
2871 constexpr Param<bool> PERMUTE { "heuristics/crossover/permute" };
2873 constexpr Param<int> BESTSOLLIMIT { "heuristics/crossover/bestsollimit" };
2875 constexpr Param<bool> USEUCT { "heuristics/crossover/useuct" };
2876}
2878namespace HEURISTICS::DINS {
2880 constexpr Param<int> PRIORITY { "heuristics/dins/priority" };
2882 constexpr Param<int> FREQ { "heuristics/dins/freq" };
2884 constexpr Param<int> FREQOFS { "heuristics/dins/freqofs" };
2886 constexpr Param<int> MAXDEPTH { "heuristics/dins/maxdepth" };
2888 constexpr Param<long long> NODESOFS { "heuristics/dins/nodesofs" };
2890 constexpr Param<double> NODESQUOT { "heuristics/dins/nodesquot" };
2892 constexpr Param<long long> MINNODES { "heuristics/dins/minnodes" };
2894 constexpr Param<int> SOLNUM { "heuristics/dins/solnum" };
2896 constexpr Param<int> NEIGHBORHOODSIZE { "heuristics/dins/neighborhoodsize" };
2898 constexpr Param<long long> MAXNODES { "heuristics/dins/maxnodes" };
2900 constexpr Param<double> MINIMPROVE { "heuristics/dins/minimprove" };
2902 constexpr Param<long long> NWAITINGNODES { "heuristics/dins/nwaitingnodes" };
2904 constexpr Param<double> LPLIMFAC { "heuristics/dins/lplimfac" };
2906 constexpr Param<double> MINFIXINGRATE { "heuristics/dins/minfixingrate" };
2908 constexpr Param<bool> USELPROWS { "heuristics/dins/uselprows" };
2910 constexpr Param<bool> COPYCUTS { "heuristics/dins/copycuts" };
2912 constexpr Param<bool> USEUCT { "heuristics/dins/useuct" };
2914 constexpr Param<int> BESTSOLLIMIT { "heuristics/dins/bestsollimit" };
2915}
2917namespace HEURISTICS::DISTRIBUTIONDIVING {
2919 constexpr Param<int> PRIORITY { "heuristics/distributiondiving/priority" };
2921 constexpr Param<int> FREQ { "heuristics/distributiondiving/freq" };
2923 constexpr Param<int> FREQOFS { "heuristics/distributiondiving/freqofs" };
2925 constexpr Param<int> MAXDEPTH { "heuristics/distributiondiving/maxdepth" };
2927 constexpr Param<double> MINRELDEPTH { "heuristics/distributiondiving/minreldepth" };
2929 constexpr Param<double> MAXRELDEPTH { "heuristics/distributiondiving/maxreldepth" };
2931 constexpr Param<double> MAXLPITERQUOT { "heuristics/distributiondiving/maxlpiterquot" };
2933 constexpr Param<int> MAXLPITEROFS { "heuristics/distributiondiving/maxlpiterofs" };
2936 constexpr Param<double> MAXDIVEUBQUOT { "heuristics/distributiondiving/maxdiveubquot" };
2939 constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/distributiondiving/maxdiveavgquot" };
2941 constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/distributiondiving/maxdiveubquotnosol" };
2943 constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/distributiondiving/maxdiveavgquotnosol" };
2945 constexpr Param<bool> BACKTRACK { "heuristics/distributiondiving/backtrack" };
2947 constexpr Param<double> LPRESOLVEDOMCHGQUOT { "heuristics/distributiondiving/lpresolvedomchgquot" };
2949 constexpr Param<int> LPSOLVEFREQ { "heuristics/distributiondiving/lpsolvefreq" };
2952 constexpr Param<bool> ONLYLPBRANCHCANDS { "heuristics/distributiondiving/onlylpbranchcands" };
2955 constexpr Param<char> SCOREPARAM { "heuristics/distributiondiving/scoreparam" };
2956}
2958namespace HEURISTICS::DPS {
2960 constexpr Param<int> PRIORITY { "heuristics/dps/priority" };
2962 constexpr Param<int> FREQ { "heuristics/dps/freq" };
2964 constexpr Param<int> FREQOFS { "heuristics/dps/freqofs" };
2966 constexpr Param<int> MAXDEPTH { "heuristics/dps/maxdepth" };
2968 constexpr Param<int> MAXITERATIONS { "heuristics/dps/maxiterations" };
2970 constexpr Param<double> MAXLINKSCORE { "heuristics/dps/maxlinkscore" };
2972 constexpr Param<double> PENALTY { "heuristics/dps/penalty" };
2974 constexpr Param<bool> REOPTIMIZE { "heuristics/dps/reoptimize" };
2976 constexpr Param<bool> REUSE { "heuristics/dps/reuse" };
2978 constexpr Param<bool> REOPTLIMITS { "heuristics/dps/reoptlimits" };
2980 constexpr Param<int> TIMING { "heuristics/dps/timing" };
2981}
2983namespace HEURISTICS::DUALVAL {
2985 constexpr Param<int> PRIORITY { "heuristics/dualval/priority" };
2987 constexpr Param<int> FREQ { "heuristics/dualval/freq" };
2989 constexpr Param<int> FREQOFS { "heuristics/dualval/freqofs" };
2991 constexpr Param<int> MAXDEPTH { "heuristics/dualval/maxdepth" };
2993 constexpr Param<bool> FORCEIMPROVEMENTS { "heuristics/dualval/forceimprovements" };
2995 constexpr Param<bool> ONLYCHEAPER { "heuristics/dualval/onlycheaper" };
2997 constexpr Param<bool> ONLYLEAVES { "heuristics/dualval/onlyleaves" };
2999 constexpr Param<bool> RELAXINDICATORS { "heuristics/dualval/relaxindicators" };
3001 constexpr Param<bool> RELAXCONTVARS { "heuristics/dualval/relaxcontvars" };
3003 constexpr Param<int> HEURVERBLEVEL { "heuristics/dualval/heurverblevel" };
3005 constexpr Param<int> NLPVERBLEVEL { "heuristics/dualval/nlpverblevel" };
3007 constexpr Param<int> RANKVALUE { "heuristics/dualval/rankvalue" };
3009 constexpr Param<int> MAXCALLS { "heuristics/dualval/maxcalls" };
3011 constexpr Param<int> DYNAMICDEPTH { "heuristics/dualval/dynamicdepth" };
3013 constexpr Param<int> MAXEQUALRANKS { "heuristics/dualval/maxequalranks" };
3015 constexpr Param<double> MINGAP { "heuristics/dualval/mingap" };
3017 constexpr Param<double> LAMBDASLACK { "heuristics/dualval/lambdaslack" };
3019 constexpr Param<double> LAMBDAOBJ { "heuristics/dualval/lambdaobj" };
3020}
3022namespace HEURISTICS::FARKASDIVING {
3024 constexpr Param<int> PRIORITY { "heuristics/farkasdiving/priority" };
3026 constexpr Param<int> FREQ { "heuristics/farkasdiving/freq" };
3028 constexpr Param<int> FREQOFS { "heuristics/farkasdiving/freqofs" };
3030 constexpr Param<int> MAXDEPTH { "heuristics/farkasdiving/maxdepth" };
3032 constexpr Param<double> MINRELDEPTH { "heuristics/farkasdiving/minreldepth" };
3034 constexpr Param<double> MAXRELDEPTH { "heuristics/farkasdiving/maxreldepth" };
3036 constexpr Param<double> MAXLPITERQUOT { "heuristics/farkasdiving/maxlpiterquot" };
3038 constexpr Param<int> MAXLPITEROFS { "heuristics/farkasdiving/maxlpiterofs" };
3041 constexpr Param<double> MAXDIVEUBQUOT { "heuristics/farkasdiving/maxdiveubquot" };
3044 constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/farkasdiving/maxdiveavgquot" };
3046 constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/farkasdiving/maxdiveubquotnosol" };
3048 constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/farkasdiving/maxdiveavgquotnosol" };
3050 constexpr Param<bool> BACKTRACK { "heuristics/farkasdiving/backtrack" };
3052 constexpr Param<double> LPRESOLVEDOMCHGQUOT { "heuristics/farkasdiving/lpresolvedomchgquot" };
3054 constexpr Param<int> LPSOLVEFREQ { "heuristics/farkasdiving/lpsolvefreq" };
3057 constexpr Param<bool> ONLYLPBRANCHCANDS { "heuristics/farkasdiving/onlylpbranchcands" };
3059 constexpr Param<bool> CHECKCANDS { "heuristics/farkasdiving/checkcands" };
3061 constexpr Param<bool> SCALESCORE { "heuristics/farkasdiving/scalescore" };
3063 constexpr Param<bool> ROOTSUCCESS { "heuristics/farkasdiving/rootsuccess" };
3065 constexpr Param<double> MAXOBJOCC { "heuristics/farkasdiving/maxobjocc" };
3067 constexpr Param<double> OBJDYNAMISM { "heuristics/farkasdiving/objdynamism" };
3069 constexpr Param<char> SCALETYPE { "heuristics/farkasdiving/scaletype" };
3070}
3072namespace HEURISTICS::FEASPUMP {
3074 constexpr Param<int> PRIORITY { "heuristics/feaspump/priority" };
3076 constexpr Param<int> FREQ { "heuristics/feaspump/freq" };
3078 constexpr Param<int> FREQOFS { "heuristics/feaspump/freqofs" };
3080 constexpr Param<int> MAXDEPTH { "heuristics/feaspump/maxdepth" };
3082 constexpr Param<double> MAXLPITERQUOT { "heuristics/feaspump/maxlpiterquot" };
3084 constexpr Param<double> OBJFACTOR { "heuristics/feaspump/objfactor" };
3086 constexpr Param<double> ALPHA { "heuristics/feaspump/alpha" };
3088 constexpr Param<double> ALPHADIFF { "heuristics/feaspump/alphadiff" };
3090 constexpr Param<int> MAXLPITEROFS { "heuristics/feaspump/maxlpiterofs" };
3092 constexpr Param<int> MAXSOLS { "heuristics/feaspump/maxsols" };
3094 constexpr Param<int> MAXLOOPS { "heuristics/feaspump/maxloops" };
3096 constexpr Param<int> MAXSTALLLOOPS { "heuristics/feaspump/maxstallloops" };
3098 constexpr Param<int> MINFLIPS { "heuristics/feaspump/minflips" };
3100 constexpr Param<int> CYCLELENGTH { "heuristics/feaspump/cyclelength" };
3102 constexpr Param<int> PERTURBFREQ { "heuristics/feaspump/perturbfreq" };
3104 constexpr Param<int> NEIGHBORHOODSIZE { "heuristics/feaspump/neighborhoodsize" };
3106 constexpr Param<bool> BEFORECUTS { "heuristics/feaspump/beforecuts" };
3108 constexpr Param<bool> USEFP20 { "heuristics/feaspump/usefp20" };
3110 constexpr Param<bool> PERTSOLFOUND { "heuristics/feaspump/pertsolfound" };
3112 constexpr Param<bool> STAGE3 { "heuristics/feaspump/stage3" };
3114 constexpr Param<bool> COPYCUTS { "heuristics/feaspump/copycuts" };
3115}
3117namespace HEURISTICS::FIXANDINFER {
3119 constexpr Param<int> PRIORITY { "heuristics/fixandinfer/priority" };
3121 constexpr Param<int> FREQ { "heuristics/fixandinfer/freq" };
3123 constexpr Param<int> FREQOFS { "heuristics/fixandinfer/freqofs" };
3125 constexpr Param<int> MAXDEPTH { "heuristics/fixandinfer/maxdepth" };
3127 constexpr Param<int> PROPROUNDS { "heuristics/fixandinfer/proprounds" };
3129 constexpr Param<int> MINFIXINGS { "heuristics/fixandinfer/minfixings" };
3130}
3132namespace HEURISTICS::FRACDIVING {
3134 constexpr Param<int> PRIORITY { "heuristics/fracdiving/priority" };
3136 constexpr Param<int> FREQ { "heuristics/fracdiving/freq" };
3138 constexpr Param<int> FREQOFS { "heuristics/fracdiving/freqofs" };
3140 constexpr Param<int> MAXDEPTH { "heuristics/fracdiving/maxdepth" };
3142 constexpr Param<double> MINRELDEPTH { "heuristics/fracdiving/minreldepth" };
3144 constexpr Param<double> MAXRELDEPTH { "heuristics/fracdiving/maxreldepth" };
3146 constexpr Param<double> MAXLPITERQUOT { "heuristics/fracdiving/maxlpiterquot" };
3148 constexpr Param<int> MAXLPITEROFS { "heuristics/fracdiving/maxlpiterofs" };
3151 constexpr Param<double> MAXDIVEUBQUOT { "heuristics/fracdiving/maxdiveubquot" };
3154 constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/fracdiving/maxdiveavgquot" };
3156 constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/fracdiving/maxdiveubquotnosol" };
3158 constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/fracdiving/maxdiveavgquotnosol" };
3160 constexpr Param<bool> BACKTRACK { "heuristics/fracdiving/backtrack" };
3162 constexpr Param<double> LPRESOLVEDOMCHGQUOT { "heuristics/fracdiving/lpresolvedomchgquot" };
3164 constexpr Param<int> LPSOLVEFREQ { "heuristics/fracdiving/lpsolvefreq" };
3167 constexpr Param<bool> ONLYLPBRANCHCANDS { "heuristics/fracdiving/onlylpbranchcands" };
3168}
3170namespace HEURISTICS::GINS {
3172 constexpr Param<int> PRIORITY { "heuristics/gins/priority" };
3174 constexpr Param<int> FREQ { "heuristics/gins/freq" };
3176 constexpr Param<int> FREQOFS { "heuristics/gins/freqofs" };
3178 constexpr Param<int> MAXDEPTH { "heuristics/gins/maxdepth" };
3180 constexpr Param<int> NODESOFS { "heuristics/gins/nodesofs" };
3182 constexpr Param<int> MAXNODES { "heuristics/gins/maxnodes" };
3184 constexpr Param<int> MINNODES { "heuristics/gins/minnodes" };
3186 constexpr Param<int> NWAITINGNODES { "heuristics/gins/nwaitingnodes" };
3188 constexpr Param<double> NODESQUOT { "heuristics/gins/nodesquot" };
3190 constexpr Param<double> MINFIXINGRATE { "heuristics/gins/minfixingrate" };
3192 constexpr Param<double> MINIMPROVE { "heuristics/gins/minimprove" };
3194 constexpr Param<bool> USELPROWS { "heuristics/gins/uselprows" };
3196 constexpr Param<bool> COPYCUTS { "heuristics/gins/copycuts" };
3198 constexpr Param<bool> FIXCONTVARS { "heuristics/gins/fixcontvars" };
3200 constexpr Param<int> BESTSOLLIMIT { "heuristics/gins/bestsollimit" };
3203 constexpr Param<int> MAXDISTANCE { "heuristics/gins/maxdistance" };
3205 constexpr Param<char> POTENTIAL { "heuristics/gins/potential" };
3207 constexpr Param<bool> USEROLLINGHORIZON { "heuristics/gins/userollinghorizon" };
3209 constexpr Param<bool> RELAXDENSECONSS { "heuristics/gins/relaxdenseconss" };
3211 constexpr Param<double> ROLLHORIZONLIMFAC { "heuristics/gins/rollhorizonlimfac" };
3213 constexpr Param<double> OVERLAP { "heuristics/gins/overlap" };
3215 constexpr Param<bool> USEDECOMP { "heuristics/gins/usedecomp" };
3217 constexpr Param<bool> USEDECOMPROLLHORIZON { "heuristics/gins/usedecomprollhorizon" };
3219 constexpr Param<bool> USESELFALLBACK { "heuristics/gins/useselfallback" };
3221 constexpr Param<bool> CONSECUTIVEBLOCKS { "heuristics/gins/consecutiveblocks" };
3222}
3224namespace HEURISTICS::GUIDEDDIVING {
3226 constexpr Param<int> PRIORITY { "heuristics/guideddiving/priority" };
3228 constexpr Param<int> FREQ { "heuristics/guideddiving/freq" };
3230 constexpr Param<int> FREQOFS { "heuristics/guideddiving/freqofs" };
3232 constexpr Param<int> MAXDEPTH { "heuristics/guideddiving/maxdepth" };
3234 constexpr Param<double> MINRELDEPTH { "heuristics/guideddiving/minreldepth" };
3236 constexpr Param<double> MAXRELDEPTH { "heuristics/guideddiving/maxreldepth" };
3238 constexpr Param<double> MAXLPITERQUOT { "heuristics/guideddiving/maxlpiterquot" };
3240 constexpr Param<int> MAXLPITEROFS { "heuristics/guideddiving/maxlpiterofs" };
3243 constexpr Param<double> MAXDIVEUBQUOT { "heuristics/guideddiving/maxdiveubquot" };
3246 constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/guideddiving/maxdiveavgquot" };
3248 constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/guideddiving/maxdiveubquotnosol" };
3250 constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/guideddiving/maxdiveavgquotnosol" };
3252 constexpr Param<bool> BACKTRACK { "heuristics/guideddiving/backtrack" };
3254 constexpr Param<double> LPRESOLVEDOMCHGQUOT { "heuristics/guideddiving/lpresolvedomchgquot" };
3256 constexpr Param<int> LPSOLVEFREQ { "heuristics/guideddiving/lpsolvefreq" };
3259 constexpr Param<bool> ONLYLPBRANCHCANDS { "heuristics/guideddiving/onlylpbranchcands" };
3260}
3262namespace HEURISTICS::INDICATOR {
3264 constexpr Param<int> PRIORITY { "heuristics/indicator/priority" };
3266 constexpr Param<int> FREQ { "heuristics/indicator/freq" };
3268 constexpr Param<int> FREQOFS { "heuristics/indicator/freqofs" };
3270 constexpr Param<int> MAXDEPTH { "heuristics/indicator/maxdepth" };
3272 constexpr Param<bool> ONEOPT { "heuristics/indicator/oneopt" };
3274 constexpr Param<bool> IMPROVESOLS { "heuristics/indicator/improvesols" };
3275}
3277namespace HEURISTICS::INDICATORDIVING {
3279 constexpr Param<int> PRIORITY { "heuristics/indicatordiving/priority" };
3281 constexpr Param<int> FREQ { "heuristics/indicatordiving/freq" };
3283 constexpr Param<int> FREQOFS { "heuristics/indicatordiving/freqofs" };
3285 constexpr Param<int> MAXDEPTH { "heuristics/indicatordiving/maxdepth" };
3287 constexpr Param<double> MINRELDEPTH { "heuristics/indicatordiving/minreldepth" };
3289 constexpr Param<double> MAXRELDEPTH { "heuristics/indicatordiving/maxreldepth" };
3291 constexpr Param<double> MAXLPITERQUOT { "heuristics/indicatordiving/maxlpiterquot" };
3293 constexpr Param<int> MAXLPITEROFS { "heuristics/indicatordiving/maxlpiterofs" };
3296 constexpr Param<double> MAXDIVEUBQUOT { "heuristics/indicatordiving/maxdiveubquot" };
3299 constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/indicatordiving/maxdiveavgquot" };
3301 constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/indicatordiving/maxdiveubquotnosol" };
3303 constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/indicatordiving/maxdiveavgquotnosol" };
3305 constexpr Param<bool> BACKTRACK { "heuristics/indicatordiving/backtrack" };
3307 constexpr Param<double> LPRESOLVEDOMCHGQUOT { "heuristics/indicatordiving/lpresolvedomchgquot" };
3309 constexpr Param<int> LPSOLVEFREQ { "heuristics/indicatordiving/lpsolvefreq" };
3312 constexpr Param<bool> ONLYLPBRANCHCANDS { "heuristics/indicatordiving/onlylpbranchcands" };
3314 constexpr Param<double> ROUNDINGFRAC { "heuristics/indicatordiving/roundingfrac" };
3316 constexpr Param<int> ROUNDINGMODE { "heuristics/indicatordiving/roundingmode" };
3318 constexpr Param<int> SEMICONTSCOREMODE { "heuristics/indicatordiving/semicontscoremode" };
3320 constexpr Param<bool> USEVARBOUNDS { "heuristics/indicatordiving/usevarbounds" };
3322 constexpr Param<bool> RUNWITHOUTSCINDS { "heuristics/indicatordiving/runwithoutscinds" };
3323}
3325namespace HEURISTICS::INTDIVING {
3327 constexpr Param<int> PRIORITY { "heuristics/intdiving/priority" };
3329 constexpr Param<int> FREQ { "heuristics/intdiving/freq" };
3331 constexpr Param<int> FREQOFS { "heuristics/intdiving/freqofs" };
3333 constexpr Param<int> MAXDEPTH { "heuristics/intdiving/maxdepth" };
3335 constexpr Param<double> MINRELDEPTH { "heuristics/intdiving/minreldepth" };
3337 constexpr Param<double> MAXRELDEPTH { "heuristics/intdiving/maxreldepth" };
3339 constexpr Param<double> MAXLPITERQUOT { "heuristics/intdiving/maxlpiterquot" };
3341 constexpr Param<int> MAXLPITEROFS { "heuristics/intdiving/maxlpiterofs" };
3344 constexpr Param<double> MAXDIVEUBQUOT { "heuristics/intdiving/maxdiveubquot" };
3347 constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/intdiving/maxdiveavgquot" };
3349 constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/intdiving/maxdiveubquotnosol" };
3351 constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/intdiving/maxdiveavgquotnosol" };
3353 constexpr Param<bool> BACKTRACK { "heuristics/intdiving/backtrack" };
3354}
3356namespace HEURISTICS::INTSHIFTING {
3358 constexpr Param<int> PRIORITY { "heuristics/intshifting/priority" };
3360 constexpr Param<int> FREQ { "heuristics/intshifting/freq" };
3362 constexpr Param<int> FREQOFS { "heuristics/intshifting/freqofs" };
3364 constexpr Param<int> MAXDEPTH { "heuristics/intshifting/maxdepth" };
3365}
3367namespace HEURISTICS::LINESEARCHDIVING {
3369 constexpr Param<int> PRIORITY { "heuristics/linesearchdiving/priority" };
3371 constexpr Param<int> FREQ { "heuristics/linesearchdiving/freq" };
3373 constexpr Param<int> FREQOFS { "heuristics/linesearchdiving/freqofs" };
3375 constexpr Param<int> MAXDEPTH { "heuristics/linesearchdiving/maxdepth" };
3377 constexpr Param<double> MINRELDEPTH { "heuristics/linesearchdiving/minreldepth" };
3379 constexpr Param<double> MAXRELDEPTH { "heuristics/linesearchdiving/maxreldepth" };
3381 constexpr Param<double> MAXLPITERQUOT { "heuristics/linesearchdiving/maxlpiterquot" };
3383 constexpr Param<int> MAXLPITEROFS { "heuristics/linesearchdiving/maxlpiterofs" };
3386 constexpr Param<double> MAXDIVEUBQUOT { "heuristics/linesearchdiving/maxdiveubquot" };
3389 constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/linesearchdiving/maxdiveavgquot" };
3391 constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/linesearchdiving/maxdiveubquotnosol" };
3393 constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/linesearchdiving/maxdiveavgquotnosol" };
3395 constexpr Param<bool> BACKTRACK { "heuristics/linesearchdiving/backtrack" };
3397 constexpr Param<double> LPRESOLVEDOMCHGQUOT { "heuristics/linesearchdiving/lpresolvedomchgquot" };
3399 constexpr Param<int> LPSOLVEFREQ { "heuristics/linesearchdiving/lpsolvefreq" };
3402 constexpr Param<bool> ONLYLPBRANCHCANDS { "heuristics/linesearchdiving/onlylpbranchcands" };
3403}
3405namespace HEURISTICS::LOCALBRANCHING {
3407 constexpr Param<int> PRIORITY { "heuristics/localbranching/priority" };
3409 constexpr Param<int> FREQ { "heuristics/localbranching/freq" };
3411 constexpr Param<int> FREQOFS { "heuristics/localbranching/freqofs" };
3413 constexpr Param<int> MAXDEPTH { "heuristics/localbranching/maxdepth" };
3415 constexpr Param<int> NODESOFS { "heuristics/localbranching/nodesofs" };
3417 constexpr Param<int> NEIGHBORHOODSIZE { "heuristics/localbranching/neighborhoodsize" };
3419 constexpr Param<double> NODESQUOT { "heuristics/localbranching/nodesquot" };
3421 constexpr Param<double> LPLIMFAC { "heuristics/localbranching/lplimfac" };
3423 constexpr Param<int> MINNODES { "heuristics/localbranching/minnodes" };
3425 constexpr Param<int> MAXNODES { "heuristics/localbranching/maxnodes" };
3427 constexpr Param<int> NWAITINGNODES { "heuristics/localbranching/nwaitingnodes" };
3429 constexpr Param<double> MINIMPROVE { "heuristics/localbranching/minimprove" };
3431 constexpr Param<bool> USELPROWS { "heuristics/localbranching/uselprows" };
3433 constexpr Param<bool> COPYCUTS { "heuristics/localbranching/copycuts" };
3435 constexpr Param<int> BESTSOLLIMIT { "heuristics/localbranching/bestsollimit" };
3436}
3438namespace HEURISTICS::LOCKS {
3440 constexpr Param<int> PRIORITY { "heuristics/locks/priority" };
3442 constexpr Param<int> FREQ { "heuristics/locks/freq" };
3444 constexpr Param<int> FREQOFS { "heuristics/locks/freqofs" };
3446 constexpr Param<int> MAXDEPTH { "heuristics/locks/maxdepth" };
3449 constexpr Param<int> MAXPROPROUNDS { "heuristics/locks/maxproprounds" };
3451 constexpr Param<double> MINFIXINGRATE { "heuristics/locks/minfixingrate" };
3453 constexpr Param<double> ROUNDUPPROBABILITY { "heuristics/locks/roundupprobability" };
3455 constexpr Param<bool> USEFINALSUBMIP { "heuristics/locks/usefinalsubmip" };
3457 constexpr Param<long long> MAXNODES { "heuristics/locks/maxnodes" };
3459 constexpr Param<long long> NODESOFS { "heuristics/locks/nodesofs" };
3461 constexpr Param<long long> MINNODES { "heuristics/locks/minnodes" };
3463 constexpr Param<double> NODESQUOT { "heuristics/locks/nodesquot" };
3465 constexpr Param<double> MINIMPROVE { "heuristics/locks/minimprove" };
3467 constexpr Param<bool> COPYCUTS { "heuristics/locks/copycuts" };
3469 constexpr Param<bool> UPDATELOCKS { "heuristics/locks/updatelocks" };
3471 constexpr Param<double> MINFIXINGRATELP { "heuristics/locks/minfixingratelp" };
3472}
3474namespace HEURISTICS::LPFACE {
3476 constexpr Param<int> PRIORITY { "heuristics/lpface/priority" };
3478 constexpr Param<int> FREQ { "heuristics/lpface/freq" };
3480 constexpr Param<int> FREQOFS { "heuristics/lpface/freqofs" };
3482 constexpr Param<int> MAXDEPTH { "heuristics/lpface/maxdepth" };
3484 constexpr Param<long long> NODESOFS { "heuristics/lpface/nodesofs" };
3486 constexpr Param<long long> MAXNODES { "heuristics/lpface/maxnodes" };
3488 constexpr Param<long long> MINNODES { "heuristics/lpface/minnodes" };
3490 constexpr Param<double> NODESQUOT { "heuristics/lpface/nodesquot" };
3492 constexpr Param<double> MINFIXINGRATE { "heuristics/lpface/minfixingrate" };
3494 constexpr Param<double> LPLIMFAC { "heuristics/lpface/lplimfac" };
3496 constexpr Param<bool> USELPROWS { "heuristics/lpface/uselprows" };
3498 constexpr Param<bool> DUALBASISEQUATIONS { "heuristics/lpface/dualbasisequations" };
3500 constexpr Param<bool> KEEPSUBSCIP { "heuristics/lpface/keepsubscip" };
3502 constexpr Param<bool> COPYCUTS { "heuristics/lpface/copycuts" };
3504 constexpr Param<char> SUBSCIPOBJECTIVE { "heuristics/lpface/subscipobjective" };
3507 constexpr Param<int> MINPATHLEN { "heuristics/lpface/minpathlen" };
3508}
3510namespace HEURISTICS::MPEC {
3512 constexpr Param<int> PRIORITY { "heuristics/mpec/priority" };
3514 constexpr Param<int> FREQ { "heuristics/mpec/freq" };
3516 constexpr Param<int> FREQOFS { "heuristics/mpec/freqofs" };
3518 constexpr Param<int> MAXDEPTH { "heuristics/mpec/maxdepth" };
3520 constexpr Param<double> INITTHETA { "heuristics/mpec/inittheta" };
3522 constexpr Param<double> SIGMA { "heuristics/mpec/sigma" };
3524 constexpr Param<double> SUBNLPTRIGGER { "heuristics/mpec/subnlptrigger" };
3526 constexpr Param<double> MAXNLPCOST { "heuristics/mpec/maxnlpcost" };
3528 constexpr Param<double> MINIMPROVE { "heuristics/mpec/minimprove" };
3530 constexpr Param<double> MINGAPLEFT { "heuristics/mpec/mingapleft" };
3532 constexpr Param<int> MAXITER { "heuristics/mpec/maxiter" };
3534 constexpr Param<int> MAXNLPITER { "heuristics/mpec/maxnlpiter" };
3536 constexpr Param<int> MAXNUNSUCC { "heuristics/mpec/maxnunsucc" };
3537}
3539namespace HEURISTICS::MULTISTART {
3541 constexpr Param<int> PRIORITY { "heuristics/multistart/priority" };
3543 constexpr Param<int> FREQ { "heuristics/multistart/freq" };
3545 constexpr Param<int> FREQOFS { "heuristics/multistart/freqofs" };
3547 constexpr Param<int> MAXDEPTH { "heuristics/multistart/maxdepth" };
3549 constexpr Param<int> NRNDPOINTS { "heuristics/multistart/nrndpoints" };
3551 constexpr Param<double> MAXBOUNDSIZE { "heuristics/multistart/maxboundsize" };
3553 constexpr Param<int> MAXITER { "heuristics/multistart/maxiter" };
3555 constexpr Param<double> MINIMPRFAC { "heuristics/multistart/minimprfac" };
3557 constexpr Param<int> MINIMPRITER { "heuristics/multistart/minimpriter" };
3559 constexpr Param<double> MAXRELDIST { "heuristics/multistart/maxreldist" };
3561 constexpr Param<double> GRADLIMIT { "heuristics/multistart/gradlimit" };
3563 constexpr Param<int> MAXNCLUSTER { "heuristics/multistart/maxncluster" };
3565 constexpr Param<bool> ONLYNLPS { "heuristics/multistart/onlynlps" };
3566}
3568namespace HEURISTICS::MUTATION {
3570 constexpr Param<int> PRIORITY { "heuristics/mutation/priority" };
3572 constexpr Param<int> FREQ { "heuristics/mutation/freq" };
3574 constexpr Param<int> FREQOFS { "heuristics/mutation/freqofs" };
3576 constexpr Param<int> MAXDEPTH { "heuristics/mutation/maxdepth" };
3578 constexpr Param<int> NODESOFS { "heuristics/mutation/nodesofs" };
3580 constexpr Param<int> MAXNODES { "heuristics/mutation/maxnodes" };
3582 constexpr Param<int> MINNODES { "heuristics/mutation/minnodes" };
3584 constexpr Param<int> NWAITINGNODES { "heuristics/mutation/nwaitingnodes" };
3586 constexpr Param<double> NODESQUOT { "heuristics/mutation/nodesquot" };
3588 constexpr Param<double> MINFIXINGRATE { "heuristics/mutation/minfixingrate" };
3590 constexpr Param<double> MINIMPROVE { "heuristics/mutation/minimprove" };
3592 constexpr Param<bool> USELPROWS { "heuristics/mutation/uselprows" };
3594 constexpr Param<bool> COPYCUTS { "heuristics/mutation/copycuts" };
3596 constexpr Param<int> BESTSOLLIMIT { "heuristics/mutation/bestsollimit" };
3598 constexpr Param<bool> USEUCT { "heuristics/mutation/useuct" };
3599}
3601namespace HEURISTICS::NLPDIVING {
3603 constexpr Param<int> PRIORITY { "heuristics/nlpdiving/priority" };
3605 constexpr Param<int> FREQ { "heuristics/nlpdiving/freq" };
3607 constexpr Param<int> FREQOFS { "heuristics/nlpdiving/freqofs" };
3609 constexpr Param<int> MAXDEPTH { "heuristics/nlpdiving/maxdepth" };
3611 constexpr Param<double> MINRELDEPTH { "heuristics/nlpdiving/minreldepth" };
3613 constexpr Param<double> MAXRELDEPTH { "heuristics/nlpdiving/maxreldepth" };
3615 constexpr Param<int> MAXNLPITERABS { "heuristics/nlpdiving/maxnlpiterabs" };
3617 constexpr Param<int> MAXNLPITERREL { "heuristics/nlpdiving/maxnlpiterrel" };
3620 constexpr Param<double> MAXDIVEUBQUOT { "heuristics/nlpdiving/maxdiveubquot" };
3623 constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/nlpdiving/maxdiveavgquot" };
3625 constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/nlpdiving/maxdiveubquotnosol" };
3627 constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/nlpdiving/maxdiveavgquotnosol" };
3629 constexpr Param<int> MAXFEASNLPS { "heuristics/nlpdiving/maxfeasnlps" };
3631 constexpr Param<bool> BACKTRACK { "heuristics/nlpdiving/backtrack" };
3633 constexpr Param<bool> LP { "heuristics/nlpdiving/lp" };
3635 constexpr Param<bool> PREFERLPFRACS { "heuristics/nlpdiving/preferlpfracs" };
3637 constexpr Param<double> MINSUCCQUOT { "heuristics/nlpdiving/minsuccquot" };
3639 constexpr Param<double> FIXQUOT { "heuristics/nlpdiving/fixquot" };
3641 constexpr Param<bool> PREFERCOVER { "heuristics/nlpdiving/prefercover" };
3643 constexpr Param<bool> SOLVESUBMIP { "heuristics/nlpdiving/solvesubmip" };
3645 constexpr Param<bool> NLPFASTFAIL { "heuristics/nlpdiving/nlpfastfail" };
3647 constexpr Param<char> NLPSTART { "heuristics/nlpdiving/nlpstart" };
3650 constexpr Param<char> VARSELRULE { "heuristics/nlpdiving/varselrule" };
3651}
3653namespace HEURISTICS::OBJPSCOSTDIVING {
3655 constexpr Param<int> PRIORITY { "heuristics/objpscostdiving/priority" };
3657 constexpr Param<int> FREQ { "heuristics/objpscostdiving/freq" };
3659 constexpr Param<int> FREQOFS { "heuristics/objpscostdiving/freqofs" };
3661 constexpr Param<int> MAXDEPTH { "heuristics/objpscostdiving/maxdepth" };
3663 constexpr Param<double> MINRELDEPTH { "heuristics/objpscostdiving/minreldepth" };
3665 constexpr Param<double> MAXRELDEPTH { "heuristics/objpscostdiving/maxreldepth" };
3667 constexpr Param<double> MAXLPITERQUOT { "heuristics/objpscostdiving/maxlpiterquot" };
3669 constexpr Param<int> MAXLPITEROFS { "heuristics/objpscostdiving/maxlpiterofs" };
3671 constexpr Param<int> MAXSOLS { "heuristics/objpscostdiving/maxsols" };
3673 constexpr Param<double> DEPTHFAC { "heuristics/objpscostdiving/depthfac" };
3675 constexpr Param<double> DEPTHFACNOSOL { "heuristics/objpscostdiving/depthfacnosol" };
3676}
3678namespace HEURISTICS::OCTANE {
3680 constexpr Param<int> PRIORITY { "heuristics/octane/priority" };
3682 constexpr Param<int> FREQ { "heuristics/octane/freq" };
3684 constexpr Param<int> FREQOFS { "heuristics/octane/freqofs" };
3686 constexpr Param<int> MAXDEPTH { "heuristics/octane/maxdepth" };
3688 constexpr Param<int> FMAX { "heuristics/octane/fmax" };
3690 constexpr Param<int> FFIRST { "heuristics/octane/ffirst" };
3692 constexpr Param<bool> USEFRACSPACE { "heuristics/octane/usefracspace" };
3694 constexpr Param<bool> USEOBJRAY { "heuristics/octane/useobjray" };
3696 constexpr Param<bool> USEAVGRAY { "heuristics/octane/useavgray" };
3698 constexpr Param<bool> USEDIFFRAY { "heuristics/octane/usediffray" };
3700 constexpr Param<bool> USEAVGWGTRAY { "heuristics/octane/useavgwgtray" };
3702 constexpr Param<bool> USEAVGNBRAY { "heuristics/octane/useavgnbray" };
3703}
3705namespace HEURISTICS::OFINS {
3707 constexpr Param<int> PRIORITY { "heuristics/ofins/priority" };
3709 constexpr Param<int> FREQ { "heuristics/ofins/freq" };
3711 constexpr Param<int> FREQOFS { "heuristics/ofins/freqofs" };
3713 constexpr Param<int> MAXDEPTH { "heuristics/ofins/maxdepth" };
3715 constexpr Param<long long> MAXNODES { "heuristics/ofins/maxnodes" };
3717 constexpr Param<long long> MINNODES { "heuristics/ofins/minnodes" };
3719 constexpr Param<double> MAXCHANGERATE { "heuristics/ofins/maxchangerate" };
3721 constexpr Param<double> MAXCHANGE { "heuristics/ofins/maxchange" };
3723 constexpr Param<bool> COPYCUTS { "heuristics/ofins/copycuts" };
3725 constexpr Param<bool> ADDALLSOLS { "heuristics/ofins/addallsols" };
3727 constexpr Param<long long> NODESOFS { "heuristics/ofins/nodesofs" };
3729 constexpr Param<double> NODESQUOT { "heuristics/ofins/nodesquot" };
3731 constexpr Param<double> MINIMPROVE { "heuristics/ofins/minimprove" };
3733 constexpr Param<double> LPLIMFAC { "heuristics/ofins/lplimfac" };
3734}
3736namespace HEURISTICS::ONEOPT {
3738 constexpr Param<int> PRIORITY { "heuristics/oneopt/priority" };
3740 constexpr Param<int> FREQ { "heuristics/oneopt/freq" };
3742 constexpr Param<int> FREQOFS { "heuristics/oneopt/freqofs" };
3744 constexpr Param<int> MAXDEPTH { "heuristics/oneopt/maxdepth" };
3746 constexpr Param<bool> WEIGHTEDOBJ { "heuristics/oneopt/weightedobj" };
3748 constexpr Param<bool> DURINGROOT { "heuristics/oneopt/duringroot" };
3750 constexpr Param<bool> FORCELPCONSTRUCTION { "heuristics/oneopt/forcelpconstruction" };
3752 constexpr Param<bool> BEFOREPRESOL { "heuristics/oneopt/beforepresol" };
3754 constexpr Param<bool> USELOOP { "heuristics/oneopt/useloop" };
3755}
3757namespace HEURISTICS::PADM {
3759 constexpr Param<int> PRIORITY { "heuristics/padm/priority" };
3761 constexpr Param<int> FREQ { "heuristics/padm/freq" };
3763 constexpr Param<int> FREQOFS { "heuristics/padm/freqofs" };
3765 constexpr Param<int> MAXDEPTH { "heuristics/padm/maxdepth" };
3767 constexpr Param<long long> MAXNODES { "heuristics/padm/maxnodes" };
3769 constexpr Param<long long> MINNODES { "heuristics/padm/minnodes" };
3771 constexpr Param<double> NODEFAC { "heuristics/padm/nodefac" };
3773 constexpr Param<int> ADMITERATIONS { "heuristics/padm/admiterations" };
3775 constexpr Param<int> PENALTYITERATIONS { "heuristics/padm/penaltyiterations" };
3777 constexpr Param<double> GAP { "heuristics/padm/gap" };
3779 constexpr Param<bool> REOPTIMIZE { "heuristics/padm/reoptimize" };
3781 constexpr Param<bool> SCALING { "heuristics/padm/scaling" };
3783 constexpr Param<bool> ASSIGNLINKING { "heuristics/padm/assignlinking" };
3785 constexpr Param<bool> ORIGINAL { "heuristics/padm/original" };
3787 constexpr Param<int> TIMING { "heuristics/padm/timing" };
3788}
3790namespace HEURISTICS::PROXIMITY {
3792 constexpr Param<int> PRIORITY { "heuristics/proximity/priority" };
3794 constexpr Param<int> FREQ { "heuristics/proximity/freq" };
3796 constexpr Param<int> FREQOFS { "heuristics/proximity/freqofs" };
3798 constexpr Param<int> MAXDEPTH { "heuristics/proximity/maxdepth" };
3800 constexpr Param<bool> USELPROWS { "heuristics/proximity/uselprows" };
3802 constexpr Param<bool> RESTART { "heuristics/proximity/restart" };
3804 constexpr Param<bool> USEFINALLP { "heuristics/proximity/usefinallp" };
3806 constexpr Param<long long> MAXNODES { "heuristics/proximity/maxnodes" };
3808 constexpr Param<long long> NODESOFS { "heuristics/proximity/nodesofs" };
3810 constexpr Param<long long> MINNODES { "heuristics/proximity/minnodes" };
3812 constexpr Param<long long> MAXLPITERS { "heuristics/proximity/maxlpiters" };
3814 constexpr Param<long long> MINLPITERS { "heuristics/proximity/minlpiters" };
3816 constexpr Param<long long> WAITINGNODES { "heuristics/proximity/waitingnodes" };
3818 constexpr Param<double> MINIMPROVE { "heuristics/proximity/minimprove" };
3820 constexpr Param<double> NODESQUOT { "heuristics/proximity/nodesquot" };
3822 constexpr Param<double> BINVARQUOT { "heuristics/proximity/binvarquot" };
3824 constexpr Param<double> LPITERSQUOT { "heuristics/proximity/lpitersquot" };
3826 constexpr Param<double> MINGAP { "heuristics/proximity/mingap" };
3828 constexpr Param<bool> USEUCT { "heuristics/proximity/useuct" };
3829}
3831namespace HEURISTICS::PSCOSTDIVING {
3833 constexpr Param<int> PRIORITY { "heuristics/pscostdiving/priority" };
3835 constexpr Param<int> FREQ { "heuristics/pscostdiving/freq" };
3837 constexpr Param<int> FREQOFS { "heuristics/pscostdiving/freqofs" };
3839 constexpr Param<int> MAXDEPTH { "heuristics/pscostdiving/maxdepth" };
3841 constexpr Param<double> MINRELDEPTH { "heuristics/pscostdiving/minreldepth" };
3843 constexpr Param<double> MAXRELDEPTH { "heuristics/pscostdiving/maxreldepth" };
3845 constexpr Param<double> MAXLPITERQUOT { "heuristics/pscostdiving/maxlpiterquot" };
3847 constexpr Param<int> MAXLPITEROFS { "heuristics/pscostdiving/maxlpiterofs" };
3850 constexpr Param<double> MAXDIVEUBQUOT { "heuristics/pscostdiving/maxdiveubquot" };
3853 constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/pscostdiving/maxdiveavgquot" };
3855 constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/pscostdiving/maxdiveubquotnosol" };
3857 constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/pscostdiving/maxdiveavgquotnosol" };
3859 constexpr Param<bool> BACKTRACK { "heuristics/pscostdiving/backtrack" };
3861 constexpr Param<double> LPRESOLVEDOMCHGQUOT { "heuristics/pscostdiving/lpresolvedomchgquot" };
3863 constexpr Param<int> LPSOLVEFREQ { "heuristics/pscostdiving/lpsolvefreq" };
3866 constexpr Param<bool> ONLYLPBRANCHCANDS { "heuristics/pscostdiving/onlylpbranchcands" };
3867}
3869namespace HEURISTICS::RANDROUNDING {
3871 constexpr Param<int> PRIORITY { "heuristics/randrounding/priority" };
3873 constexpr Param<int> FREQ { "heuristics/randrounding/freq" };
3875 constexpr Param<int> FREQOFS { "heuristics/randrounding/freqofs" };
3877 constexpr Param<int> MAXDEPTH { "heuristics/randrounding/maxdepth" };
3879 constexpr Param<bool> ONCEPERNODE { "heuristics/randrounding/oncepernode" };
3881 constexpr Param<bool> USESIMPLEROUNDING { "heuristics/randrounding/usesimplerounding" };
3883 constexpr Param<bool> PROPAGATEONLYROOT { "heuristics/randrounding/propagateonlyroot" };
3885 constexpr Param<int> MAXPROPROUNDS { "heuristics/randrounding/maxproprounds" };
3886}
3888namespace HEURISTICS::RENS {
3890 constexpr Param<int> PRIORITY { "heuristics/rens/priority" };
3892 constexpr Param<int> FREQ { "heuristics/rens/freq" };
3894 constexpr Param<int> FREQOFS { "heuristics/rens/freqofs" };
3896 constexpr Param<int> MAXDEPTH { "heuristics/rens/maxdepth" };
3898 constexpr Param<double> MINFIXINGRATE { "heuristics/rens/minfixingrate" };
3900 constexpr Param<long long> MAXNODES { "heuristics/rens/maxnodes" };
3902 constexpr Param<long long> NODESOFS { "heuristics/rens/nodesofs" };
3904 constexpr Param<long long> MINNODES { "heuristics/rens/minnodes" };
3906 constexpr Param<double> NODESQUOT { "heuristics/rens/nodesquot" };
3908 constexpr Param<double> MINIMPROVE { "heuristics/rens/minimprove" };
3910 constexpr Param<double> LPLIMFAC { "heuristics/rens/lplimfac" };
3912 constexpr Param<char> STARTSOL { "heuristics/rens/startsol" };
3914 constexpr Param<bool> BINARYBOUNDS { "heuristics/rens/binarybounds" };
3916 constexpr Param<bool> USELPROWS { "heuristics/rens/uselprows" };
3918 constexpr Param<bool> COPYCUTS { "heuristics/rens/copycuts" };
3920 constexpr Param<bool> EXTRATIME { "heuristics/rens/extratime" };
3922 constexpr Param<bool> ADDALLSOLS { "heuristics/rens/addallsols" };
3925 constexpr Param<bool> FULLSCALE { "heuristics/rens/fullscale" };
3927 constexpr Param<int> BESTSOLLIMIT { "heuristics/rens/bestsollimit" };
3929 constexpr Param<bool> USEUCT { "heuristics/rens/useuct" };
3930}
3932namespace HEURISTICS::REOPTSOLS {
3934 constexpr Param<int> PRIORITY { "heuristics/reoptsols/priority" };
3936 constexpr Param<int> FREQ { "heuristics/reoptsols/freq" };
3938 constexpr Param<int> FREQOFS { "heuristics/reoptsols/freqofs" };
3940 constexpr Param<int> MAXDEPTH { "heuristics/reoptsols/maxdepth" };
3942 constexpr Param<int> MAXSOLS { "heuristics/reoptsols/maxsols" };
3944 constexpr Param<int> MAXRUNS { "heuristics/reoptsols/maxruns" };
3945}
3947namespace HEURISTICS::REPAIR {
3949 constexpr Param<int> PRIORITY { "heuristics/repair/priority" };
3951 constexpr Param<int> FREQ { "heuristics/repair/freq" };
3953 constexpr Param<int> FREQOFS { "heuristics/repair/freqofs" };
3955 constexpr Param<int> MAXDEPTH { "heuristics/repair/maxdepth" };
3957 constexpr Param<std::string> FILENAME { "heuristics/repair/filename" };
3960 constexpr Param<bool> ROUNDIT { "heuristics/repair/roundit" };
3962 constexpr Param<bool> USEOBJFACTOR { "heuristics/repair/useobjfactor" };
3964 constexpr Param<bool> USEVARFIX { "heuristics/repair/usevarfix" };
3966 constexpr Param<bool> USESLACKVARS { "heuristics/repair/useslackvars" };
3968 constexpr Param<double> ALPHA { "heuristics/repair/alpha" };
3970 constexpr Param<int> NODESOFS { "heuristics/repair/nodesofs" };
3972 constexpr Param<int> MAXNODES { "heuristics/repair/maxnodes" };
3974 constexpr Param<int> MINNODES { "heuristics/repair/minnodes" };
3976 constexpr Param<double> NODESQUOT { "heuristics/repair/nodesquot" };
3978 constexpr Param<double> MINFIXINGRATE { "heuristics/repair/minfixingrate" };
3979}
3981namespace HEURISTICS::RINS {
3983 constexpr Param<int> PRIORITY { "heuristics/rins/priority" };
3985 constexpr Param<int> FREQ { "heuristics/rins/freq" };
3987 constexpr Param<int> FREQOFS { "heuristics/rins/freqofs" };
3989 constexpr Param<int> MAXDEPTH { "heuristics/rins/maxdepth" };
3991 constexpr Param<int> NODESOFS { "heuristics/rins/nodesofs" };
3993 constexpr Param<int> MAXNODES { "heuristics/rins/maxnodes" };
3995 constexpr Param<int> MINNODES { "heuristics/rins/minnodes" };
3997 constexpr Param<double> NODESQUOT { "heuristics/rins/nodesquot" };
3999 constexpr Param<int> NWAITINGNODES { "heuristics/rins/nwaitingnodes" };
4001 constexpr Param<double> MINIMPROVE { "heuristics/rins/minimprove" };
4003 constexpr Param<double> MINFIXINGRATE { "heuristics/rins/minfixingrate" };
4005 constexpr Param<double> LPLIMFAC { "heuristics/rins/lplimfac" };
4007 constexpr Param<bool> USELPROWS { "heuristics/rins/uselprows" };
4009 constexpr Param<bool> COPYCUTS { "heuristics/rins/copycuts" };
4011 constexpr Param<bool> USEUCT { "heuristics/rins/useuct" };
4012}
4014namespace HEURISTICS::ROOTSOLDIVING {
4016 constexpr Param<int> PRIORITY { "heuristics/rootsoldiving/priority" };
4018 constexpr Param<int> FREQ { "heuristics/rootsoldiving/freq" };
4020 constexpr Param<int> FREQOFS { "heuristics/rootsoldiving/freqofs" };
4022 constexpr Param<int> MAXDEPTH { "heuristics/rootsoldiving/maxdepth" };
4024 constexpr Param<double> MINRELDEPTH { "heuristics/rootsoldiving/minreldepth" };
4026 constexpr Param<double> MAXRELDEPTH { "heuristics/rootsoldiving/maxreldepth" };
4028 constexpr Param<double> MAXLPITERQUOT { "heuristics/rootsoldiving/maxlpiterquot" };
4030 constexpr Param<int> MAXLPITEROFS { "heuristics/rootsoldiving/maxlpiterofs" };
4032 constexpr Param<int> MAXSOLS { "heuristics/rootsoldiving/maxsols" };
4034 constexpr Param<double> DEPTHFAC { "heuristics/rootsoldiving/depthfac" };
4036 constexpr Param<double> DEPTHFACNOSOL { "heuristics/rootsoldiving/depthfacnosol" };
4038 constexpr Param<double> ALPHA { "heuristics/rootsoldiving/alpha" };
4039}
4041namespace HEURISTICS::ROUNDING {
4043 constexpr Param<int> PRIORITY { "heuristics/rounding/priority" };
4045 constexpr Param<int> FREQ { "heuristics/rounding/freq" };
4047 constexpr Param<int> FREQOFS { "heuristics/rounding/freqofs" };
4049 constexpr Param<int> MAXDEPTH { "heuristics/rounding/maxdepth" };
4052 constexpr Param<int> SUCCESSFACTOR { "heuristics/rounding/successfactor" };
4054 constexpr Param<bool> ONCEPERNODE { "heuristics/rounding/oncepernode" };
4055}
4057namespace HEURISTICS::SCHEDULER {
4059 constexpr Param<int> PRIORITY { "heuristics/scheduler/priority" };
4061 constexpr Param<int> FREQ { "heuristics/scheduler/freq" };
4063 constexpr Param<int> FREQOFS { "heuristics/scheduler/freqofs" };
4065 constexpr Param<int> MAXDEPTH { "heuristics/scheduler/maxdepth" };
4067 constexpr Param<long long> MAXNODES { "heuristics/scheduler/maxnodes" };
4069 constexpr Param<long long> NODESOFS { "heuristics/scheduler/nodesofs" };
4071 constexpr Param<long long> MINNODES { "heuristics/scheduler/minnodes" };
4073 constexpr Param<long long> WAITINGNODES { "heuristics/scheduler/waitingnodes" };
4075 constexpr Param<int> INITLNSNODELIMIT { "heuristics/scheduler/initlnsnodelimit" };
4077 constexpr Param<long long> INITDIVINGNODELIMIT { "heuristics/scheduler/initdivingnodelimit" };
4079 constexpr Param<double> NODESQUOT { "heuristics/scheduler/nodesquot" };
4081 constexpr Param<double> NODESQUOTMIN { "heuristics/scheduler/nodesquotmin" };
4083 constexpr Param<int> NSOLSLIM { "heuristics/scheduler/nsolslim" };
4085 constexpr Param<char> BANDITALGO { "heuristics/scheduler/banditalgo" };
4087 constexpr Param<double> GAMMA { "heuristics/scheduler/gamma" };
4089 constexpr Param<double> BETA { "heuristics/scheduler/beta" };
4091 constexpr Param<double> ALPHA { "heuristics/scheduler/alpha" };
4093 constexpr Param<bool> USEDISTANCES { "heuristics/scheduler/usedistances" };
4095 constexpr Param<bool> USEREDCOST { "heuristics/scheduler/useredcost" };
4097 constexpr Param<bool> USEPSCOST { "heuristics/scheduler/usepscost" };
4099 constexpr Param<bool> USELOCALREDCOST { "heuristics/scheduler/uselocalredcost" };
4101 constexpr Param<bool> USESUBSCIPHEURS { "heuristics/scheduler/usesubscipheurs" };
4103 constexpr Param<double> TARGETNODEFACTOR { "heuristics/scheduler/targetnodefactor" };
4105 constexpr Param<int> SEED { "heuristics/scheduler/seed" };
4108 constexpr Param<int> MAXCALLSSAMESOL { "heuristics/scheduler/maxcallssamesol" };
4110 constexpr Param<double> EPS { "heuristics/scheduler/eps" };
4112 constexpr Param<bool> EPSGREEDY_USEMOD { "heuristics/scheduler/epsgreedy_usemod" };
4114 constexpr Param<double> SOLREWARDWEIGHT { "heuristics/scheduler/solrewardweight" };
4116 constexpr Param<double> EFFORTREWARDWEIGHT { "heuristics/scheduler/effortrewardweight" };
4118 constexpr Param<double> QUALREWARDWEIGHT { "heuristics/scheduler/qualrewardweight" };
4120 constexpr Param<double> CONFLICTREWARDWEIGHT { "heuristics/scheduler/conflictrewardweight" };
4122 constexpr Param<bool> RESETWEIGHTS { "heuristics/scheduler/resetweights" };
4124 constexpr Param<bool> SUBSCIPRANDSEEDS { "heuristics/scheduler/subsciprandseeds" };
4126 constexpr Param<bool> COPYCUTS { "heuristics/scheduler/copycuts" };
4128 constexpr Param<double> FIXTOL { "heuristics/scheduler/fixtol" };
4130 constexpr Param<double> UNFIXTOL { "heuristics/scheduler/unfixtol" };
4132 constexpr Param<double> HEURTIMELIMIT { "heuristics/scheduler/heurtimelimit" };
4134 constexpr Param<bool> INITDURINGROOT { "heuristics/scheduler/initduringroot" };
4136 constexpr Param<bool> DEFAULTROOT { "heuristics/scheduler/defaultroot" };
4139 constexpr Param<int> NSELECTIONS { "heuristics/scheduler/nselections" };
4140}
4142namespace HEURISTICS::SCHEDULER::CROSSOVER {
4144 constexpr Param<double> MINFIXINGRATE { "heuristics/scheduler/crossover/minfixingrate" };
4146 constexpr Param<double> MAXFIXINGRATE { "heuristics/scheduler/crossover/maxfixingrate" };
4148 constexpr Param<bool> ACTIVE { "heuristics/scheduler/crossover/active" };
4150 constexpr Param<double> PRIORITY { "heuristics/scheduler/crossover/priority" };
4152 constexpr Param<int> NSOLS { "heuristics/scheduler/crossover/nsols" };
4153}
4155namespace HEURISTICS::SCHEDULER::DINS {
4157 constexpr Param<double> MINFIXINGRATE { "heuristics/scheduler/dins/minfixingrate" };
4159 constexpr Param<double> MAXFIXINGRATE { "heuristics/scheduler/dins/maxfixingrate" };
4161 constexpr Param<bool> ACTIVE { "heuristics/scheduler/dins/active" };
4163 constexpr Param<double> PRIORITY { "heuristics/scheduler/dins/priority" };
4165 constexpr Param<int> NPOOLSOLS { "heuristics/scheduler/dins/npoolsols" };
4166}
4168namespace HEURISTICS::SCHEDULER::LOCALBRANCHING {
4170 constexpr Param<double> MINFIXINGRATE { "heuristics/scheduler/localbranching/minfixingrate" };
4172 constexpr Param<double> MAXFIXINGRATE { "heuristics/scheduler/localbranching/maxfixingrate" };
4174 constexpr Param<bool> ACTIVE { "heuristics/scheduler/localbranching/active" };
4176 constexpr Param<double> PRIORITY { "heuristics/scheduler/localbranching/priority" };
4177}
4179namespace HEURISTICS::SCHEDULER::MUTATION {
4181 constexpr Param<double> MINFIXINGRATE { "heuristics/scheduler/mutation/minfixingrate" };
4183 constexpr Param<double> MAXFIXINGRATE { "heuristics/scheduler/mutation/maxfixingrate" };
4185 constexpr Param<bool> ACTIVE { "heuristics/scheduler/mutation/active" };
4187 constexpr Param<double> PRIORITY { "heuristics/scheduler/mutation/priority" };
4188}
4190namespace HEURISTICS::SCHEDULER::PROXIMITY {
4192 constexpr Param<double> MINFIXINGRATE { "heuristics/scheduler/proximity/minfixingrate" };
4194 constexpr Param<double> MAXFIXINGRATE { "heuristics/scheduler/proximity/maxfixingrate" };
4196 constexpr Param<bool> ACTIVE { "heuristics/scheduler/proximity/active" };
4198 constexpr Param<double> PRIORITY { "heuristics/scheduler/proximity/priority" };
4199}
4201namespace HEURISTICS::SCHEDULER::RENS {
4203 constexpr Param<double> MINFIXINGRATE { "heuristics/scheduler/rens/minfixingrate" };
4205 constexpr Param<double> MAXFIXINGRATE { "heuristics/scheduler/rens/maxfixingrate" };
4207 constexpr Param<bool> ACTIVE { "heuristics/scheduler/rens/active" };
4209 constexpr Param<double> PRIORITY { "heuristics/scheduler/rens/priority" };
4210}
4212namespace HEURISTICS::SCHEDULER::RINS {
4214 constexpr Param<double> MINFIXINGRATE { "heuristics/scheduler/rins/minfixingrate" };
4216 constexpr Param<double> MAXFIXINGRATE { "heuristics/scheduler/rins/maxfixingrate" };
4218 constexpr Param<bool> ACTIVE { "heuristics/scheduler/rins/active" };
4220 constexpr Param<double> PRIORITY { "heuristics/scheduler/rins/priority" };
4221}
4223namespace HEURISTICS::SCHEDULER::TRUSTREGION {
4225 constexpr Param<double> MINFIXINGRATE { "heuristics/scheduler/trustregion/minfixingrate" };
4227 constexpr Param<double> MAXFIXINGRATE { "heuristics/scheduler/trustregion/maxfixingrate" };
4229 constexpr Param<bool> ACTIVE { "heuristics/scheduler/trustregion/active" };
4231 constexpr Param<double> PRIORITY { "heuristics/scheduler/trustregion/priority" };
4233 constexpr Param<double> VIOLPENALTY { "heuristics/scheduler/trustregion/violpenalty" };
4234}
4236namespace HEURISTICS::SCHEDULER::ZEROOBJECTIVE {
4238 constexpr Param<double> MINFIXINGRATE { "heuristics/scheduler/zeroobjective/minfixingrate" };
4240 constexpr Param<double> MAXFIXINGRATE { "heuristics/scheduler/zeroobjective/maxfixingrate" };
4242 constexpr Param<bool> ACTIVE { "heuristics/scheduler/zeroobjective/active" };
4244 constexpr Param<double> PRIORITY { "heuristics/scheduler/zeroobjective/priority" };
4245}
4247namespace HEURISTICS::SHIFTANDPROPAGATE {
4249 constexpr Param<int> PRIORITY { "heuristics/shiftandpropagate/priority" };
4251 constexpr Param<int> FREQ { "heuristics/shiftandpropagate/freq" };
4253 constexpr Param<int> FREQOFS { "heuristics/shiftandpropagate/freqofs" };
4255 constexpr Param<int> MAXDEPTH { "heuristics/shiftandpropagate/maxdepth" };
4257 constexpr Param<int> NPROPROUNDS { "heuristics/shiftandpropagate/nproprounds" };
4259 constexpr Param<bool> RELAX { "heuristics/shiftandpropagate/relax" };
4261 constexpr Param<bool> PROBING { "heuristics/shiftandpropagate/probing" };
4263 constexpr Param<bool> ONLYWITHOUTSOL { "heuristics/shiftandpropagate/onlywithoutsol" };
4265 constexpr Param<int> CUTOFFBREAKER { "heuristics/shiftandpropagate/cutoffbreaker" };
4267 constexpr Param<char> SORTKEY { "heuristics/shiftandpropagate/sortkey" };
4269 constexpr Param<bool> SORTVARS { "heuristics/shiftandpropagate/sortvars" };
4271 constexpr Param<bool> COLLECTSTATS { "heuristics/shiftandpropagate/collectstats" };
4273 constexpr Param<bool> STOPAFTERFEASIBLE { "heuristics/shiftandpropagate/stopafterfeasible" };
4275 constexpr Param<bool> PREFERBINARIES { "heuristics/shiftandpropagate/preferbinaries" };
4277 constexpr Param<bool> NOZEROFIXING { "heuristics/shiftandpropagate/nozerofixing" };
4279 constexpr Param<bool> FIXBINLOCKS { "heuristics/shiftandpropagate/fixbinlocks" };
4281 constexpr Param<bool> BINLOCKSFIRST { "heuristics/shiftandpropagate/binlocksfirst" };
4283 constexpr Param<bool> NORMALIZE { "heuristics/shiftandpropagate/normalize" };
4285 constexpr Param<bool> UPDATEWEIGHTS { "heuristics/shiftandpropagate/updateweights" };
4287 constexpr Param<bool> IMPLISCONTINUOUS { "heuristics/shiftandpropagate/impliscontinuous" };
4289 constexpr Param<bool> SELECTBEST { "heuristics/shiftandpropagate/selectbest" };
4291 constexpr Param<double> MAXCUTOFFQUOT { "heuristics/shiftandpropagate/maxcutoffquot" };
4293 constexpr Param<double> MINFIXINGRATELP { "heuristics/shiftandpropagate/minfixingratelp" };
4294}
4296namespace HEURISTICS::SHIFTING {
4298 constexpr Param<int> PRIORITY { "heuristics/shifting/priority" };
4300 constexpr Param<int> FREQ { "heuristics/shifting/freq" };
4302 constexpr Param<int> FREQOFS { "heuristics/shifting/freqofs" };
4304 constexpr Param<int> MAXDEPTH { "heuristics/shifting/maxdepth" };
4305}
4307namespace HEURISTICS::SIMPLEROUNDING {
4309 constexpr Param<int> PRIORITY { "heuristics/simplerounding/priority" };
4311 constexpr Param<int> FREQ { "heuristics/simplerounding/freq" };
4313 constexpr Param<int> FREQOFS { "heuristics/simplerounding/freqofs" };
4315 constexpr Param<int> MAXDEPTH { "heuristics/simplerounding/maxdepth" };
4317 constexpr Param<bool> ONCEPERNODE { "heuristics/simplerounding/oncepernode" };
4318}
4320namespace HEURISTICS::SUBNLP {
4322 constexpr Param<int> PRIORITY { "heuristics/subnlp/priority" };
4324 constexpr Param<int> FREQ { "heuristics/subnlp/freq" };
4326 constexpr Param<int> FREQOFS { "heuristics/subnlp/freqofs" };
4328 constexpr Param<int> MAXDEPTH { "heuristics/subnlp/maxdepth" };
4330 constexpr Param<int> NLPVERBLEVEL { "heuristics/subnlp/nlpverblevel" };
4333 constexpr Param<int> NODESOFFSET { "heuristics/subnlp/nodesoffset" };
4336 constexpr Param<double> NODESFACTOR { "heuristics/subnlp/nodesfactor" };
4339 constexpr Param<double> SUCCESSRATEEXP { "heuristics/subnlp/successrateexp" };
4341 constexpr Param<int> ITERINIT { "heuristics/subnlp/iterinit" };
4343 constexpr Param<int> NINITSOLVES { "heuristics/subnlp/ninitsolves" };
4345 constexpr Param<int> ITERMIN { "heuristics/subnlp/itermin" };
4347 constexpr Param<double> OPTTOL { "heuristics/subnlp/opttol" };
4349 constexpr Param<double> FEASTOLFACTOR { "heuristics/subnlp/feastolfactor" };
4351 constexpr Param<int> MAXPRESOLVEROUNDS { "heuristics/subnlp/maxpresolverounds" };
4353 constexpr Param<int> PRESOLVEEMPHASIS { "heuristics/subnlp/presolveemphasis" };
4355 constexpr Param<bool> SETCUTOFF { "heuristics/subnlp/setcutoff" };
4357 constexpr Param<bool> FORBIDFIXINGS { "heuristics/subnlp/forbidfixings" };
4359 constexpr Param<bool> KEEPCOPY { "heuristics/subnlp/keepcopy" };
4361 constexpr Param<double> EXPECTINFEAS { "heuristics/subnlp/expectinfeas" };
4362}
4364namespace HEURISTICS::TRIVIAL {
4366 constexpr Param<int> PRIORITY { "heuristics/trivial/priority" };
4368 constexpr Param<int> FREQ { "heuristics/trivial/freq" };
4370 constexpr Param<int> FREQOFS { "heuristics/trivial/freqofs" };
4372 constexpr Param<int> MAXDEPTH { "heuristics/trivial/maxdepth" };
4373}
4375namespace HEURISTICS::TRIVIALNEGATION {
4377 constexpr Param<int> PRIORITY { "heuristics/trivialnegation/priority" };
4379 constexpr Param<int> FREQ { "heuristics/trivialnegation/freq" };
4381 constexpr Param<int> FREQOFS { "heuristics/trivialnegation/freqofs" };
4383 constexpr Param<int> MAXDEPTH { "heuristics/trivialnegation/maxdepth" };
4384}
4386namespace HEURISTICS::TRUSTREGION {
4388 constexpr Param<int> PRIORITY { "heuristics/trustregion/priority" };
4390 constexpr Param<int> FREQ { "heuristics/trustregion/freq" };
4392 constexpr Param<int> FREQOFS { "heuristics/trustregion/freqofs" };
4394 constexpr Param<int> MAXDEPTH { "heuristics/trustregion/maxdepth" };
4396 constexpr Param<int> NODESOFS { "heuristics/trustregion/nodesofs" };
4398 constexpr Param<int> MINBINVARS { "heuristics/trustregion/minbinvars" };
4400 constexpr Param<double> NODESQUOT { "heuristics/trustregion/nodesquot" };
4402 constexpr Param<double> LPLIMFAC { "heuristics/trustregion/lplimfac" };
4404 constexpr Param<int> MINNODES { "heuristics/trustregion/minnodes" };
4406 constexpr Param<int> MAXNODES { "heuristics/trustregion/maxnodes" };
4408 constexpr Param<int> NWAITINGNODES { "heuristics/trustregion/nwaitingnodes" };
4410 constexpr Param<bool> USELPROWS { "heuristics/trustregion/uselprows" };
4412 constexpr Param<bool> COPYCUTS { "heuristics/trustregion/copycuts" };
4414 constexpr Param<int> BESTSOLLIMIT { "heuristics/trustregion/bestsollimit" };
4416 constexpr Param<double> VIOLPENALTY { "heuristics/trustregion/violpenalty" };
4418 constexpr Param<double> OBJMINIMPROVE { "heuristics/trustregion/objminimprove" };
4419}
4421namespace HEURISTICS::TRYSOL {
4423 constexpr Param<int> PRIORITY { "heuristics/trysol/priority" };
4425 constexpr Param<int> FREQ { "heuristics/trysol/freq" };
4427 constexpr Param<int> FREQOFS { "heuristics/trysol/freqofs" };
4429 constexpr Param<int> MAXDEPTH { "heuristics/trysol/maxdepth" };
4430}
4432namespace HEURISTICS::TWOOPT {
4434 constexpr Param<int> PRIORITY { "heuristics/twoopt/priority" };
4436 constexpr Param<int> FREQ { "heuristics/twoopt/freq" };
4438 constexpr Param<int> FREQOFS { "heuristics/twoopt/freqofs" };
4440 constexpr Param<int> MAXDEPTH { "heuristics/twoopt/maxdepth" };
4442 constexpr Param<bool> INTOPT { "heuristics/twoopt/intopt" };
4444 constexpr Param<int> WAITINGNODES { "heuristics/twoopt/waitingnodes" };
4446 constexpr Param<int> MAXNSLAVES { "heuristics/twoopt/maxnslaves" };
4448 constexpr Param<double> MATCHINGRATE { "heuristics/twoopt/matchingrate" };
4449}
4451namespace HEURISTICS::UNDERCOVER {
4453 constexpr Param<int> PRIORITY { "heuristics/undercover/priority" };
4455 constexpr Param<int> FREQ { "heuristics/undercover/freq" };
4457 constexpr Param<int> FREQOFS { "heuristics/undercover/freqofs" };
4459 constexpr Param<int> MAXDEPTH { "heuristics/undercover/maxdepth" };
4461 constexpr Param<std::string> FIXINGALTS { "heuristics/undercover/fixingalts" };
4463 constexpr Param<long long> MAXNODES { "heuristics/undercover/maxnodes" };
4465 constexpr Param<long long> MINNODES { "heuristics/undercover/minnodes" };
4467 constexpr Param<long long> NODESOFS { "heuristics/undercover/nodesofs" };
4469 constexpr Param<double> CONFLICTWEIGHT { "heuristics/undercover/conflictweight" };
4471 constexpr Param<double> CUTOFFWEIGHT { "heuristics/undercover/cutoffweight" };
4473 constexpr Param<double> INFERENCEWEIGHT { "heuristics/undercover/inferenceweight" };
4475 constexpr Param<double> MAXCOVERSIZEVARS { "heuristics/undercover/maxcoversizevars" };
4477 constexpr Param<double> MAXCOVERSIZECONSS { "heuristics/undercover/maxcoversizeconss" };
4479 constexpr Param<double> MINCOVEREDREL { "heuristics/undercover/mincoveredrel" };
4481 constexpr Param<double> MINIMPROVE { "heuristics/undercover/minimprove" };
4483 constexpr Param<double> NODESQUOT { "heuristics/undercover/nodesquot" };
4485 constexpr Param<double> RECOVERDIV { "heuristics/undercover/recoverdiv" };
4487 constexpr Param<int> MINCOVEREDABS { "heuristics/undercover/mincoveredabs" };
4489 constexpr Param<int> MAXBACKTRACKS { "heuristics/undercover/maxbacktracks" };
4491 constexpr Param<int> MAXRECOVERS { "heuristics/undercover/maxrecovers" };
4493 constexpr Param<int> MAXREORDERS { "heuristics/undercover/maxreorders" };
4496 constexpr Param<char> COVERINGOBJ { "heuristics/undercover/coveringobj" };
4499 constexpr Param<char> FIXINGORDER { "heuristics/undercover/fixingorder" };
4501 constexpr Param<bool> BEFORECUTS { "heuristics/undercover/beforecuts" };
4503 constexpr Param<bool> FIXINTFIRST { "heuristics/undercover/fixintfirst" };
4505 constexpr Param<bool> LOCKSROUNDING { "heuristics/undercover/locksrounding" };
4507 constexpr Param<bool> ONLYCONVEXIFY { "heuristics/undercover/onlyconvexify" };
4509 constexpr Param<bool> POSTNLP { "heuristics/undercover/postnlp" };
4511 constexpr Param<bool> COVERAND { "heuristics/undercover/coverand" };
4513 constexpr Param<bool> COVERBD { "heuristics/undercover/coverbd" };
4515 constexpr Param<bool> COVERIND { "heuristics/undercover/coverind" };
4517 constexpr Param<bool> COVERNL { "heuristics/undercover/covernl" };
4519 constexpr Param<bool> COPYCUTS { "heuristics/undercover/copycuts" };
4521 constexpr Param<bool> REUSECOVER { "heuristics/undercover/reusecover" };
4522}
4524namespace HEURISTICS::VBOUNDS {
4526 constexpr Param<int> PRIORITY { "heuristics/vbounds/priority" };
4528 constexpr Param<int> FREQ { "heuristics/vbounds/freq" };
4530 constexpr Param<int> FREQOFS { "heuristics/vbounds/freqofs" };
4532 constexpr Param<int> MAXDEPTH { "heuristics/vbounds/maxdepth" };
4534 constexpr Param<double> MININTFIXINGRATE { "heuristics/vbounds/minintfixingrate" };
4536 constexpr Param<double> MINMIPFIXINGRATE { "heuristics/vbounds/minmipfixingrate" };
4538 constexpr Param<long long> MAXNODES { "heuristics/vbounds/maxnodes" };
4540 constexpr Param<long long> NODESOFS { "heuristics/vbounds/nodesofs" };
4542 constexpr Param<long long> MINNODES { "heuristics/vbounds/minnodes" };
4544 constexpr Param<double> NODESQUOT { "heuristics/vbounds/nodesquot" };
4546 constexpr Param<double> MINIMPROVE { "heuristics/vbounds/minimprove" };
4548 constexpr Param<int> MAXPROPROUNDS { "heuristics/vbounds/maxproprounds" };
4550 constexpr Param<bool> COPYCUTS { "heuristics/vbounds/copycuts" };
4552 constexpr Param<bool> USELOCKFIXINGS { "heuristics/vbounds/uselockfixings" };
4554 constexpr Param<int> MAXBACKTRACKS { "heuristics/vbounds/maxbacktracks" };
4557 constexpr Param<int> FEASVARIANT { "heuristics/vbounds/feasvariant" };
4560 constexpr Param<int> TIGHTENVARIANT { "heuristics/vbounds/tightenvariant" };
4561}
4563namespace HEURISTICS::VECLENDIVING {
4565 constexpr Param<int> PRIORITY { "heuristics/veclendiving/priority" };
4567 constexpr Param<int> FREQ { "heuristics/veclendiving/freq" };
4569 constexpr Param<int> FREQOFS { "heuristics/veclendiving/freqofs" };
4571 constexpr Param<int> MAXDEPTH { "heuristics/veclendiving/maxdepth" };
4573 constexpr Param<double> MINRELDEPTH { "heuristics/veclendiving/minreldepth" };
4575 constexpr Param<double> MAXRELDEPTH { "heuristics/veclendiving/maxreldepth" };
4577 constexpr Param<double> MAXLPITERQUOT { "heuristics/veclendiving/maxlpiterquot" };
4579 constexpr Param<int> MAXLPITEROFS { "heuristics/veclendiving/maxlpiterofs" };
4582 constexpr Param<double> MAXDIVEUBQUOT { "heuristics/veclendiving/maxdiveubquot" };
4585 constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/veclendiving/maxdiveavgquot" };
4587 constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/veclendiving/maxdiveubquotnosol" };
4589 constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/veclendiving/maxdiveavgquotnosol" };
4591 constexpr Param<bool> BACKTRACK { "heuristics/veclendiving/backtrack" };
4593 constexpr Param<double> LPRESOLVEDOMCHGQUOT { "heuristics/veclendiving/lpresolvedomchgquot" };
4595 constexpr Param<int> LPSOLVEFREQ { "heuristics/veclendiving/lpsolvefreq" };
4598 constexpr Param<bool> ONLYLPBRANCHCANDS { "heuristics/veclendiving/onlylpbranchcands" };
4599}
4601namespace HEURISTICS::ZEROOBJ {
4603 constexpr Param<int> PRIORITY { "heuristics/zeroobj/priority" };
4605 constexpr Param<int> FREQ { "heuristics/zeroobj/freq" };
4607 constexpr Param<int> FREQOFS { "heuristics/zeroobj/freqofs" };
4609 constexpr Param<int> MAXDEPTH { "heuristics/zeroobj/maxdepth" };
4611 constexpr Param<long long> MAXNODES { "heuristics/zeroobj/maxnodes" };
4613 constexpr Param<long long> NODESOFS { "heuristics/zeroobj/nodesofs" };
4615 constexpr Param<long long> MINNODES { "heuristics/zeroobj/minnodes" };
4617 constexpr Param<long long> MAXLPITERS { "heuristics/zeroobj/maxlpiters" };
4619 constexpr Param<double> NODESQUOT { "heuristics/zeroobj/nodesquot" };
4621 constexpr Param<double> MINIMPROVE { "heuristics/zeroobj/minimprove" };
4623 constexpr Param<bool> ADDALLSOLS { "heuristics/zeroobj/addallsols" };
4625 constexpr Param<bool> ONLYWITHOUTSOL { "heuristics/zeroobj/onlywithoutsol" };
4627 constexpr Param<bool> USEUCT { "heuristics/zeroobj/useuct" };
4628}
4630namespace HEURISTICS::ZIROUNDING {
4632 constexpr Param<int> PRIORITY { "heuristics/zirounding/priority" };
4634 constexpr Param<int> FREQ { "heuristics/zirounding/freq" };
4636 constexpr Param<int> FREQOFS { "heuristics/zirounding/freqofs" };
4638 constexpr Param<int> MAXDEPTH { "heuristics/zirounding/maxdepth" };
4640 constexpr Param<int> MAXROUNDINGLOOPS { "heuristics/zirounding/maxroundingloops" };
4642 constexpr Param<bool> STOPZIROUND { "heuristics/zirounding/stopziround" };
4644 constexpr Param<double> STOPPERCENTAGE { "heuristics/zirounding/stoppercentage" };
4646 constexpr Param<int> MINSTOPNCALLS { "heuristics/zirounding/minstopncalls" };
4647}
4649namespace HISTORY {
4651 constexpr Param<bool> VALUEBASED { "history/valuebased" };
4653 constexpr Param<bool> ALLOWMERGE { "history/allowmerge" };
4655 constexpr Param<bool> ALLOWTRANSFER { "history/allowtransfer" };
4656}
4658namespace LIMITS {
4660 constexpr Param<double> TIME { "limits/time" };
4662 constexpr Param<long long> NODES { "limits/nodes" };
4664 constexpr Param<long long> TOTALNODES { "limits/totalnodes" };
4667 constexpr Param<long long> STALLNODES { "limits/stallnodes" };
4669 constexpr Param<double> MEMORY { "limits/memory" };
4672 constexpr Param<double> GAP { "limits/gap" };
4674 constexpr Param<double> ABSGAP { "limits/absgap" };
4676 constexpr Param<double> PRIMAL { "limits/primal" };
4678 constexpr Param<double> DUAL { "limits/dual" };
4681 constexpr Param<int> SOLUTIONS { "limits/solutions" };
4683 constexpr Param<int> BESTSOL { "limits/bestsol" };
4685 constexpr Param<int> MAXSOL { "limits/maxsol" };
4687 constexpr Param<int> MAXORIGSOL { "limits/maxorigsol" };
4689 constexpr Param<int> RESTARTS { "limits/restarts" };
4692 constexpr Param<int> AUTORESTARTNODES { "limits/autorestartnodes" };
4694 constexpr Param<double> SOFTTIME { "limits/softtime" };
4695}
4697namespace LP {
4699 constexpr Param<int> SOLVEFREQ { "lp/solvefreq" };
4701 constexpr Param<long long> ITERLIM { "lp/iterlim" };
4703 constexpr Param<long long> ROOTITERLIM { "lp/rootiterlim" };
4705 constexpr Param<int> SOLVEDEPTH { "lp/solvedepth" };
4708 constexpr Param<char> INITALGORITHM { "lp/initalgorithm" };
4711 constexpr Param<char> RESOLVEALGORITHM { "lp/resolvealgorithm" };
4714 constexpr Param<char> PRICING { "lp/pricing" };
4717 constexpr Param<bool> CLEARINITIALPROBINGLP { "lp/clearinitialprobinglp" };
4719 constexpr Param<bool> RESOLVERESTORE { "lp/resolverestore" };
4721 constexpr Param<bool> FREESOLVALBUFFERS { "lp/freesolvalbuffers" };
4723 constexpr Param<int> COLAGELIMIT { "lp/colagelimit" };
4725 constexpr Param<int> ROWAGELIMIT { "lp/rowagelimit" };
4727 constexpr Param<bool> CLEANUPCOLS { "lp/cleanupcols" };
4729 constexpr Param<bool> CLEANUPCOLSROOT { "lp/cleanupcolsroot" };
4731 constexpr Param<bool> CLEANUPROWS { "lp/cleanuprows" };
4733 constexpr Param<bool> CLEANUPROWSROOT { "lp/cleanuprowsroot" };
4735 constexpr Param<bool> CHECKSTABILITY { "lp/checkstability" };
4737 constexpr Param<double> CONDITIONLIMIT { "lp/conditionlimit" };
4739 constexpr Param<double> MINMARKOWITZ { "lp/minmarkowitz" };
4741 constexpr Param<bool> CHECKPRIMFEAS { "lp/checkprimfeas" };
4743 constexpr Param<bool> CHECKDUALFEAS { "lp/checkdualfeas" };
4745 constexpr Param<bool> CHECKFARKAS { "lp/checkfarkas" };
4747 constexpr Param<int> FASTMIP { "lp/fastmip" };
4749 constexpr Param<int> SCALING { "lp/scaling" };
4751 constexpr Param<bool> PRESOLVING { "lp/presolving" };
4753 constexpr Param<bool> LEXDUALALGO { "lp/lexdualalgo" };
4755 constexpr Param<bool> LEXDUALROOTONLY { "lp/lexdualrootonly" };
4757 constexpr Param<int> LEXDUALMAXROUNDS { "lp/lexdualmaxrounds" };
4759 constexpr Param<bool> LEXDUALBASIC { "lp/lexdualbasic" };
4761 constexpr Param<bool> LEXDUALSTALLING { "lp/lexdualstalling" };
4763 constexpr Param<int> DISABLECUTOFF { "lp/disablecutoff" };
4766 constexpr Param<double> ROWREPSWITCH { "lp/rowrepswitch" };
4768 constexpr Param<int> THREADS { "lp/threads" };
4770 constexpr Param<double> RESOLVEITERFAC { "lp/resolveiterfac" };
4772 constexpr Param<int> RESOLVEITERMIN { "lp/resolveitermin" };
4774 constexpr Param<int> SOLUTIONPOLISHING { "lp/solutionpolishing" };
4776 constexpr Param<int> REFACTORINTERVAL { "lp/refactorinterval" };
4778 constexpr Param<bool> ALWAYSGETDUALS { "lp/alwaysgetduals" };
4779}
4781namespace MEMORY {
4783 constexpr Param<double> SAVEFAC { "memory/savefac" };
4785 constexpr Param<double> ARRAYGROWFAC { "memory/arraygrowfac" };
4787 constexpr Param<int> ARRAYGROWINIT { "memory/arraygrowinit" };
4789 constexpr Param<double> TREEGROWFAC { "memory/treegrowfac" };
4791 constexpr Param<int> TREEGROWINIT { "memory/treegrowinit" };
4793 constexpr Param<double> PATHGROWFAC { "memory/pathgrowfac" };
4795 constexpr Param<int> PATHGROWINIT { "memory/pathgrowinit" };
4796}
4798namespace MISC {
4800 constexpr Param<bool> CATCHCTRLC { "misc/catchctrlc" };
4802 constexpr Param<bool> USEVARTABLE { "misc/usevartable" };
4804 constexpr Param<bool> USECONSTABLE { "misc/useconstable" };
4806 constexpr Param<bool> USESMALLTABLES { "misc/usesmalltables" };
4809 constexpr Param<bool> RESETSTAT { "misc/resetstat" };
4811 constexpr Param<bool> IMPROVINGSOLS { "misc/improvingsols" };
4813 constexpr Param<bool> PRINTREASON { "misc/printreason" };
4815 constexpr Param<bool> ESTIMEXTERNMEM { "misc/estimexternmem" };
4817 constexpr Param<bool> AVOIDMEMOUT { "misc/avoidmemout" };
4819 constexpr Param<bool> TRANSORIGSOLS { "misc/transorigsols" };
4821 constexpr Param<bool> TRANSSOLSORIG { "misc/transsolsorig" };
4823 constexpr Param<bool> CALCINTEGRAL { "misc/calcintegral" };
4825 constexpr Param<bool> FINITESOLUTIONSTORE { "misc/finitesolutionstore" };
4827 constexpr Param<bool> OUTPUTORIGSOL { "misc/outputorigsol" };
4829 constexpr Param<bool> ALLOWSTRONGDUALREDS { "misc/allowstrongdualreds" };
4831 constexpr Param<bool> ALLOWWEAKDUALREDS { "misc/allowweakdualreds" };
4833 constexpr Param<bool> SCALEOBJ { "misc/scaleobj" };
4835 constexpr Param<bool> SHOWDIVINGSTATS { "misc/showdivingstats" };
4837 constexpr Param<double> REFERENCEVALUE { "misc/referencevalue" };
4842 constexpr Param<int> USESYMMETRY { "misc/usesymmetry" };
4843}
4845namespace NLHDLR::BILINEAR {
4847 constexpr Param<bool> ENABLED { "nlhdlr/bilinear/enabled" };
4849 constexpr Param<bool> USEINTEVAL { "nlhdlr/bilinear/useinteval" };
4851 constexpr Param<bool> USEREVERSEPROP { "nlhdlr/bilinear/usereverseprop" };
4853 constexpr Param<int> MAXSEPAROUNDSROOT { "nlhdlr/bilinear/maxseparoundsroot" };
4855 constexpr Param<int> MAXSEPAROUNDS { "nlhdlr/bilinear/maxseparounds" };
4857 constexpr Param<int> MAXSEPADEPTH { "nlhdlr/bilinear/maxsepadepth" };
4858}
4860namespace NLHDLR::CONCAVE {
4862 constexpr Param<bool> ENABLED { "nlhdlr/concave/enabled" };
4864 constexpr Param<bool> DETECTSUM { "nlhdlr/concave/detectsum" };
4866 constexpr Param<bool> CVXQUADRATIC { "nlhdlr/concave/cvxquadratic" };
4868 constexpr Param<bool> CVXSIGNOMIAL { "nlhdlr/concave/cvxsignomial" };
4870 constexpr Param<bool> CVXPRODCOMP { "nlhdlr/concave/cvxprodcomp" };
4872 constexpr Param<bool> HANDLETRIVIAL { "nlhdlr/concave/handletrivial" };
4873}
4875namespace NLHDLR::CONVEX {
4877 constexpr Param<bool> ENABLED { "nlhdlr/convex/enabled" };
4879 constexpr Param<bool> DETECTSUM { "nlhdlr/convex/detectsum" };
4881 constexpr Param<bool> EXTENDEDFORM { "nlhdlr/convex/extendedform" };
4883 constexpr Param<double> MAXPERTURB { "nlhdlr/convex/maxperturb" };
4885 constexpr Param<bool> CVXQUADRATIC { "nlhdlr/convex/cvxquadratic" };
4887 constexpr Param<bool> CVXSIGNOMIAL { "nlhdlr/convex/cvxsignomial" };
4889 constexpr Param<bool> CVXPRODCOMP { "nlhdlr/convex/cvxprodcomp" };
4891 constexpr Param<bool> HANDLETRIVIAL { "nlhdlr/convex/handletrivial" };
4892}
4894namespace NLHDLR::DEFAULT {
4896 constexpr Param<bool> ENABLED { "nlhdlr/default/enabled" };
4897}
4899namespace NLHDLR::PERSPECTIVE {
4901 constexpr Param<bool> ENABLED { "nlhdlr/perspective/enabled" };
4903 constexpr Param<int> MAXPROPROUNDS { "nlhdlr/perspective/maxproprounds" };
4905 constexpr Param<double> MINDOMREDUCTION { "nlhdlr/perspective/mindomreduction" };
4907 constexpr Param<double> MINVIOLPROBING { "nlhdlr/perspective/minviolprobing" };
4909 constexpr Param<bool> PROBINGONLYINSEPA { "nlhdlr/perspective/probingonlyinsepa" };
4911 constexpr Param<int> PROBINGFREQ { "nlhdlr/perspective/probingfreq" };
4913 constexpr Param<bool> CONVEXONLY { "nlhdlr/perspective/convexonly" };
4915 constexpr Param<bool> TIGHTENBOUNDS { "nlhdlr/perspective/tightenbounds" };
4917 constexpr Param<bool> ADJREFPOINT { "nlhdlr/perspective/adjrefpoint" };
4918}
4920namespace NLHDLR::QUADRATIC {
4922 constexpr Param<bool> ENABLED { "nlhdlr/quadratic/enabled" };
4924 constexpr Param<bool> USEINTERSECTIONCUTS { "nlhdlr/quadratic/useintersectioncuts" };
4926 constexpr Param<bool> USESTRENGTHENING { "nlhdlr/quadratic/usestrengthening" };
4928 constexpr Param<bool> USEMONOIDAL { "nlhdlr/quadratic/usemonoidal" };
4930 constexpr Param<bool> USEMINREP { "nlhdlr/quadratic/useminrep" };
4932 constexpr Param<bool> USEBOUNDSASRAYS { "nlhdlr/quadratic/useboundsasrays" };
4934 constexpr Param<int> NCUTSLIMIT { "nlhdlr/quadratic/ncutslimit" };
4936 constexpr Param<int> NCUTSLIMITROOT { "nlhdlr/quadratic/ncutslimitroot" };
4938 constexpr Param<int> MAXRANK { "nlhdlr/quadratic/maxrank" };
4940 constexpr Param<double> MINCUTVIOLATION { "nlhdlr/quadratic/mincutviolation" };
4942 constexpr Param<double> MINVIOLATION { "nlhdlr/quadratic/minviolation" };
4945 constexpr Param<int> ATWHICHNODES { "nlhdlr/quadratic/atwhichnodes" };
4947 constexpr Param<int> NSTRENGTHLIMIT { "nlhdlr/quadratic/nstrengthlimit" };
4949 constexpr Param<bool> SPARSIFYCUTS { "nlhdlr/quadratic/sparsifycuts" };
4951 constexpr Param<bool> IGNOREBADRAYRESTRICTION { "nlhdlr/quadratic/ignorebadrayrestriction" };
4953 constexpr Param<bool> IGNORENHIGHRE { "nlhdlr/quadratic/ignorenhighre" };
4955 constexpr Param<bool> TRACKMORE { "nlhdlr/quadratic/trackmore" };
4956}
4958namespace NLHDLR::QUOTIENT {
4960 constexpr Param<bool> ENABLED { "nlhdlr/quotient/enabled" };
4961}
4963namespace NLHDLR::SIGNOMIAL {
4965 constexpr Param<bool> ENABLED { "nlhdlr/signomial/enabled" };
4967 constexpr Param<int> MAXNUNDERVARS { "nlhdlr/signomial/maxnundervars" };
4969 constexpr Param<double> MINCUTSCALE { "nlhdlr/signomial/mincutscale" };
4970}
4972namespace NLHDLR::SOC {
4974 constexpr Param<bool> ENABLED { "nlhdlr/soc/enabled" };
4976 constexpr Param<double> MINCUTEFFICACY { "nlhdlr/soc/mincutefficacy" };
4978 constexpr Param<bool> COMPEIGENVALUES { "nlhdlr/soc/compeigenvalues" };
4979}
4981namespace NLP {
4983 constexpr Param<std::string> SOLVER { "nlp/solver" };
4985 constexpr Param<bool> DISABLE { "nlp/disable" };
4986}
4988namespace NODESELECTION {
4991 constexpr Param<char> CHILDSEL { "nodeselection/childsel" };
4992}
4994namespace NODESELECTION::BFS {
4996 constexpr Param<int> STDPRIORITY { "nodeselection/bfs/stdpriority" };
4998 constexpr Param<int> MEMSAVEPRIORITY { "nodeselection/bfs/memsavepriority" };
5000 constexpr Param<int> MINPLUNGEDEPTH { "nodeselection/bfs/minplungedepth" };
5002 constexpr Param<int> MAXPLUNGEDEPTH { "nodeselection/bfs/maxplungedepth" };
5004 constexpr Param<double> MAXPLUNGEQUOT { "nodeselection/bfs/maxplungequot" };
5005}
5007namespace NODESELECTION::BREADTHFIRST {
5009 constexpr Param<int> STDPRIORITY { "nodeselection/breadthfirst/stdpriority" };
5011 constexpr Param<int> MEMSAVEPRIORITY { "nodeselection/breadthfirst/memsavepriority" };
5012}
5014namespace NODESELECTION::DFS {
5016 constexpr Param<int> STDPRIORITY { "nodeselection/dfs/stdpriority" };
5018 constexpr Param<int> MEMSAVEPRIORITY { "nodeselection/dfs/memsavepriority" };
5019}
5021namespace NODESELECTION::ESTIMATE {
5023 constexpr Param<int> STDPRIORITY { "nodeselection/estimate/stdpriority" };
5025 constexpr Param<int> MEMSAVEPRIORITY { "nodeselection/estimate/memsavepriority" };
5027 constexpr Param<int> MINPLUNGEDEPTH { "nodeselection/estimate/minplungedepth" };
5029 constexpr Param<int> MAXPLUNGEDEPTH { "nodeselection/estimate/maxplungedepth" };
5031 constexpr Param<double> MAXPLUNGEQUOT { "nodeselection/estimate/maxplungequot" };
5033 constexpr Param<int> BESTNODEFREQ { "nodeselection/estimate/bestnodefreq" };
5035 constexpr Param<int> BREADTHFIRSTDEPTH { "nodeselection/estimate/breadthfirstdepth" };
5037 constexpr Param<int> PLUNGEOFFSET { "nodeselection/estimate/plungeoffset" };
5038}
5040namespace NODESELECTION::HYBRIDESTIM {
5042 constexpr Param<int> STDPRIORITY { "nodeselection/hybridestim/stdpriority" };
5044 constexpr Param<int> MEMSAVEPRIORITY { "nodeselection/hybridestim/memsavepriority" };
5046 constexpr Param<int> MINPLUNGEDEPTH { "nodeselection/hybridestim/minplungedepth" };
5048 constexpr Param<int> MAXPLUNGEDEPTH { "nodeselection/hybridestim/maxplungedepth" };
5050 constexpr Param<double> MAXPLUNGEQUOT { "nodeselection/hybridestim/maxplungequot" };
5052 constexpr Param<int> BESTNODEFREQ { "nodeselection/hybridestim/bestnodefreq" };
5054 constexpr Param<double> ESTIMWEIGHT { "nodeselection/hybridestim/estimweight" };
5055}
5057namespace NODESELECTION::RESTARTDFS {
5059 constexpr Param<int> STDPRIORITY { "nodeselection/restartdfs/stdpriority" };
5061 constexpr Param<int> MEMSAVEPRIORITY { "nodeselection/restartdfs/memsavepriority" };
5063 constexpr Param<int> SELECTBESTFREQ { "nodeselection/restartdfs/selectbestfreq" };
5065 constexpr Param<bool> COUNTONLYLEAVES { "nodeselection/restartdfs/countonlyleaves" };
5066}
5068namespace NODESELECTION::UCT {
5070 constexpr Param<int> STDPRIORITY { "nodeselection/uct/stdpriority" };
5072 constexpr Param<int> MEMSAVEPRIORITY { "nodeselection/uct/memsavepriority" };
5074 constexpr Param<int> NODELIMIT { "nodeselection/uct/nodelimit" };
5076 constexpr Param<double> WEIGHT { "nodeselection/uct/weight" };
5078 constexpr Param<bool> USEESTIMATE { "nodeselection/uct/useestimate" };
5079}
5081namespace NUMERICS {
5083 constexpr Param<double> INFINITY { "numerics/infinity" };
5085 constexpr Param<double> EPSILON { "numerics/epsilon" };
5087 constexpr Param<double> SUMEPSILON { "numerics/sumepsilon" };
5089 constexpr Param<double> FEASTOL { "numerics/feastol" };
5091 constexpr Param<double> CHECKFEASTOLFAC { "numerics/checkfeastolfac" };
5094 constexpr Param<double> LPFEASTOLFACTOR { "numerics/lpfeastolfactor" };
5096 constexpr Param<double> DUALFEASTOL { "numerics/dualfeastol" };
5098 constexpr Param<double> BARRIERCONVTOL { "numerics/barrierconvtol" };
5100 constexpr Param<double> BOUNDSTREPS { "numerics/boundstreps" };
5102 constexpr Param<double> PSEUDOCOSTEPS { "numerics/pseudocosteps" };
5104 constexpr Param<double> PSEUDOCOSTDELTA { "numerics/pseudocostdelta" };
5106 constexpr Param<double> RECOMPUTEFAC { "numerics/recomputefac" };
5108 constexpr Param<double> HUGEVAL { "numerics/hugeval" };
5109}
5111namespace PARALLEL {
5113 constexpr Param<int> MODE { "parallel/mode" };
5115 constexpr Param<int> MINNTHREADS { "parallel/minnthreads" };
5117 constexpr Param<int> MAXNTHREADS { "parallel/maxnthreads" };
5118}
5120namespace PRESOLVING {
5122 constexpr Param<int> MAXROUNDS { "presolving/maxrounds" };
5124 constexpr Param<double> ABORTFAC { "presolving/abortfac" };
5126 constexpr Param<int> MAXRESTARTS { "presolving/maxrestarts" };
5129 constexpr Param<double> RESTARTFAC { "presolving/restartfac" };
5131 constexpr Param<double> CLQTABLEFAC { "presolving/clqtablefac" };
5134 constexpr Param<double> IMMRESTARTFAC { "presolving/immrestartfac" };
5137 constexpr Param<double> SUBRESTARTFAC { "presolving/subrestartfac" };
5139 constexpr Param<double> RESTARTMINRED { "presolving/restartminred" };
5141 constexpr Param<bool> DONOTMULTAGGR { "presolving/donotmultaggr" };
5143 constexpr Param<bool> DONOTAGGR { "presolving/donotaggr" };
5144}
5146namespace PRESOLVING::BOUNDSHIFT {
5148 constexpr Param<int> PRIORITY { "presolving/boundshift/priority" };
5150 constexpr Param<int> MAXROUNDS { "presolving/boundshift/maxrounds" };
5152 constexpr Param<int> TIMING { "presolving/boundshift/timing" };
5154 constexpr Param<long long> MAXSHIFT { "presolving/boundshift/maxshift" };
5156 constexpr Param<bool> FLIPPING { "presolving/boundshift/flipping" };
5158 constexpr Param<bool> INTEGER { "presolving/boundshift/integer" };
5159}
5161namespace PRESOLVING::CONVERTINTTOBIN {
5163 constexpr Param<int> PRIORITY { "presolving/convertinttobin/priority" };
5165 constexpr Param<int> MAXROUNDS { "presolving/convertinttobin/maxrounds" };
5167 constexpr Param<int> TIMING { "presolving/convertinttobin/timing" };
5169 constexpr Param<long long> MAXDOMAINSIZE { "presolving/convertinttobin/maxdomainsize" };
5172 constexpr Param<bool> ONLYPOWEROFTWO { "presolving/convertinttobin/onlypoweroftwo" };
5174 constexpr Param<bool> SAMELOCKSINBOTHDIRECTIONS { "presolving/convertinttobin/samelocksinbothdirections" };
5175}
5177namespace PRESOLVING::DOMCOL {
5179 constexpr Param<int> PRIORITY { "presolving/domcol/priority" };
5181 constexpr Param<int> MAXROUNDS { "presolving/domcol/maxrounds" };
5183 constexpr Param<int> TIMING { "presolving/domcol/timing" };
5185 constexpr Param<int> NUMMINPAIRS { "presolving/domcol/numminpairs" };
5187 constexpr Param<int> NUMMAXPAIRS { "presolving/domcol/nummaxpairs" };
5189 constexpr Param<bool> PREDBNDSTR { "presolving/domcol/predbndstr" };
5191 constexpr Param<bool> CONTINUOUSRED { "presolving/domcol/continuousred" };
5192}
5194namespace PRESOLVING::DUALAGG {
5196 constexpr Param<int> PRIORITY { "presolving/dualagg/priority" };
5198 constexpr Param<int> MAXROUNDS { "presolving/dualagg/maxrounds" };
5200 constexpr Param<int> TIMING { "presolving/dualagg/timing" };
5201}
5203namespace PRESOLVING::DUALCOMP {
5205 constexpr Param<int> PRIORITY { "presolving/dualcomp/priority" };
5207 constexpr Param<int> MAXROUNDS { "presolving/dualcomp/maxrounds" };
5209 constexpr Param<int> TIMING { "presolving/dualcomp/timing" };
5211 constexpr Param<bool> COMPONLYDISVARS { "presolving/dualcomp/componlydisvars" };
5212}
5214namespace PRESOLVING::DUALINFER {
5216 constexpr Param<int> PRIORITY { "presolving/dualinfer/priority" };
5218 constexpr Param<int> MAXROUNDS { "presolving/dualinfer/maxrounds" };
5220 constexpr Param<int> TIMING { "presolving/dualinfer/timing" };
5222 constexpr Param<bool> TWOCOLCOMBINE { "presolving/dualinfer/twocolcombine" };
5224 constexpr Param<int> MAXDUALBNDLOOPS { "presolving/dualinfer/maxdualbndloops" };
5226 constexpr Param<int> MAXCONSIDEREDNONZEROS { "presolving/dualinfer/maxconsiderednonzeros" };
5228 constexpr Param<int> MAXRETRIEVEFAILS { "presolving/dualinfer/maxretrievefails" };
5230 constexpr Param<int> MAXCOMBINEFAILS { "presolving/dualinfer/maxcombinefails" };
5232 constexpr Param<int> MAXHASHFAC { "presolving/dualinfer/maxhashfac" };
5234 constexpr Param<int> MAXPAIRFAC { "presolving/dualinfer/maxpairfac" };
5236 constexpr Param<int> MAXROWSUPPORT { "presolving/dualinfer/maxrowsupport" };
5237}
5239namespace PRESOLVING::DUALSPARSIFY {
5241 constexpr Param<int> PRIORITY { "presolving/dualsparsify/priority" };
5243 constexpr Param<int> MAXROUNDS { "presolving/dualsparsify/maxrounds" };
5245 constexpr Param<int> TIMING { "presolving/dualsparsify/timing" };
5247 constexpr Param<bool> ENABLECOPY { "presolving/dualsparsify/enablecopy" };
5249 constexpr Param<bool> PRESERVEINTCOEFS { "presolving/dualsparsify/preserveintcoefs" };
5251 constexpr Param<bool> PRESERVEGOODLOCKS { "presolving/dualsparsify/preservegoodlocks" };
5253 constexpr Param<int> MAXCONTFILLIN { "presolving/dualsparsify/maxcontfillin" };
5255 constexpr Param<int> MAXBINFILLIN { "presolving/dualsparsify/maxbinfillin" };
5257 constexpr Param<int> MAXINTFILLIN { "presolving/dualsparsify/maxintfillin" };
5259 constexpr Param<int> MAXCONSIDEREDNONZEROS { "presolving/dualsparsify/maxconsiderednonzeros" };
5261 constexpr Param<int> MINELIMINATEDNONZEROS { "presolving/dualsparsify/mineliminatednonzeros" };
5263 constexpr Param<double> MAXRETRIEVEFAC { "presolving/dualsparsify/maxretrievefac" };
5265 constexpr Param<double> WAITINGFAC { "presolving/dualsparsify/waitingfac" };
5266}
5268namespace PRESOLVING::GATEEXTRACTION {
5270 constexpr Param<int> PRIORITY { "presolving/gateextraction/priority" };
5272 constexpr Param<int> MAXROUNDS { "presolving/gateextraction/maxrounds" };
5274 constexpr Param<int> TIMING { "presolving/gateextraction/timing" };
5276 constexpr Param<bool> ONLYSETPART { "presolving/gateextraction/onlysetpart" };
5279 constexpr Param<bool> SEARCHEQUATIONS { "presolving/gateextraction/searchequations" };
5282 constexpr Param<int> SORTING { "presolving/gateextraction/sorting" };
5283}
5285namespace PRESOLVING::IMPLICS {
5287 constexpr Param<int> PRIORITY { "presolving/implics/priority" };
5289 constexpr Param<int> MAXROUNDS { "presolving/implics/maxrounds" };
5291 constexpr Param<int> TIMING { "presolving/implics/timing" };
5292}
5294namespace PRESOLVING::INTTOBINARY {
5296 constexpr Param<int> PRIORITY { "presolving/inttobinary/priority" };
5298 constexpr Param<int> MAXROUNDS { "presolving/inttobinary/maxrounds" };
5300 constexpr Param<int> TIMING { "presolving/inttobinary/timing" };
5301}
5303namespace PRESOLVING::QPKKTREF {
5305 constexpr Param<int> PRIORITY { "presolving/qpkktref/priority" };
5307 constexpr Param<int> MAXROUNDS { "presolving/qpkktref/maxrounds" };
5309 constexpr Param<int> TIMING { "presolving/qpkktref/timing" };
5311 constexpr Param<bool> ADDKKTBINARY { "presolving/qpkktref/addkktbinary" };
5314 constexpr Param<bool> UPDATEQUADBOUNDED { "presolving/qpkktref/updatequadbounded" };
5316 constexpr Param<bool> UPDATEQUADINDEF { "presolving/qpkktref/updatequadindef" };
5317}
5319namespace PRESOLVING::REDVUB {
5321 constexpr Param<int> PRIORITY { "presolving/redvub/priority" };
5323 constexpr Param<int> MAXROUNDS { "presolving/redvub/maxrounds" };
5325 constexpr Param<int> TIMING { "presolving/redvub/timing" };
5326}
5328namespace PRESOLVING::SPARSIFY {
5330 constexpr Param<int> PRIORITY { "presolving/sparsify/priority" };
5332 constexpr Param<int> MAXROUNDS { "presolving/sparsify/maxrounds" };
5334 constexpr Param<int> TIMING { "presolving/sparsify/timing" };
5336 constexpr Param<bool> ENABLECOPY { "presolving/sparsify/enablecopy" };
5338 constexpr Param<bool> CANCELLINEAR { "presolving/sparsify/cancellinear" };
5340 constexpr Param<bool> PRESERVEINTCOEFS { "presolving/sparsify/preserveintcoefs" };
5342 constexpr Param<int> MAXCONTFILLIN { "presolving/sparsify/maxcontfillin" };
5344 constexpr Param<int> MAXBINFILLIN { "presolving/sparsify/maxbinfillin" };
5346 constexpr Param<int> MAXINTFILLIN { "presolving/sparsify/maxintfillin" };
5348 constexpr Param<int> MAXNONZEROS { "presolving/sparsify/maxnonzeros" };
5350 constexpr Param<int> MAXCONSIDEREDNONZEROS { "presolving/sparsify/maxconsiderednonzeros" };
5352 constexpr Param<char> ROWSORT { "presolving/sparsify/rowsort" };
5354 constexpr Param<double> MAXRETRIEVEFAC { "presolving/sparsify/maxretrievefac" };
5356 constexpr Param<double> WAITINGFAC { "presolving/sparsify/waitingfac" };
5357}
5359namespace PRESOLVING::STUFFING {
5361 constexpr Param<int> PRIORITY { "presolving/stuffing/priority" };
5363 constexpr Param<int> MAXROUNDS { "presolving/stuffing/maxrounds" };
5365 constexpr Param<int> TIMING { "presolving/stuffing/timing" };
5366}
5368namespace PRESOLVING::TRIVIAL {
5370 constexpr Param<int> PRIORITY { "presolving/trivial/priority" };
5372 constexpr Param<int> MAXROUNDS { "presolving/trivial/maxrounds" };
5374 constexpr Param<int> TIMING { "presolving/trivial/timing" };
5375}
5377namespace PRESOLVING::TWOROWBND {
5379 constexpr Param<int> PRIORITY { "presolving/tworowbnd/priority" };
5381 constexpr Param<int> MAXROUNDS { "presolving/tworowbnd/maxrounds" };
5383 constexpr Param<int> TIMING { "presolving/tworowbnd/timing" };
5385 constexpr Param<bool> ENABLECOPY { "presolving/tworowbnd/enablecopy" };
5387 constexpr Param<int> MAXCONSIDEREDNONZEROS { "presolving/tworowbnd/maxconsiderednonzeros" };
5389 constexpr Param<int> MAXRETRIEVEFAILS { "presolving/tworowbnd/maxretrievefails" };
5391 constexpr Param<int> MAXCOMBINEFAILS { "presolving/tworowbnd/maxcombinefails" };
5393 constexpr Param<int> MAXHASHFAC { "presolving/tworowbnd/maxhashfac" };
5395 constexpr Param<int> MAXPAIRFAC { "presolving/tworowbnd/maxpairfac" };
5396}
5398namespace PRICING {
5400 constexpr Param<int> MAXVARS { "pricing/maxvars" };
5402 constexpr Param<int> MAXVARSROOT { "pricing/maxvarsroot" };
5404 constexpr Param<double> ABORTFAC { "pricing/abortfac" };
5407 constexpr Param<bool> DELVARS { "pricing/delvars" };
5410 constexpr Param<bool> DELVARSROOT { "pricing/delvarsroot" };
5411}
5413namespace PROPAGATING {
5415 constexpr Param<int> MAXROUNDS { "propagating/maxrounds" };
5417 constexpr Param<int> MAXROUNDSROOT { "propagating/maxroundsroot" };
5420 constexpr Param<bool> ABORTONCUTOFF { "propagating/abortoncutoff" };
5421}
5423namespace PROPAGATING::DUALFIX {
5425 constexpr Param<int> PRIORITY { "propagating/dualfix/priority" };
5427 constexpr Param<int> FREQ { "propagating/dualfix/freq" };
5429 constexpr Param<bool> DELAY { "propagating/dualfix/delay" };
5431 constexpr Param<int> TIMINGMASK { "propagating/dualfix/timingmask" };
5433 constexpr Param<int> PRESOLPRIORITY { "propagating/dualfix/presolpriority" };
5435 constexpr Param<int> MAXPREROUNDS { "propagating/dualfix/maxprerounds" };
5437 constexpr Param<int> PRESOLTIMING { "propagating/dualfix/presoltiming" };
5438}
5440namespace PROPAGATING::GENVBOUNDS {
5442 constexpr Param<int> PRIORITY { "propagating/genvbounds/priority" };
5444 constexpr Param<int> FREQ { "propagating/genvbounds/freq" };
5446 constexpr Param<bool> DELAY { "propagating/genvbounds/delay" };
5448 constexpr Param<int> TIMINGMASK { "propagating/genvbounds/timingmask" };
5450 constexpr Param<int> PRESOLPRIORITY { "propagating/genvbounds/presolpriority" };
5452 constexpr Param<int> MAXPREROUNDS { "propagating/genvbounds/maxprerounds" };
5454 constexpr Param<int> PRESOLTIMING { "propagating/genvbounds/presoltiming" };
5456 constexpr Param<bool> GLOBAL { "propagating/genvbounds/global" };
5458 constexpr Param<bool> PROPINROOTNODE { "propagating/genvbounds/propinrootnode" };
5460 constexpr Param<bool> SORT { "propagating/genvbounds/sort" };
5462 constexpr Param<bool> PROPASCONSS { "propagating/genvbounds/propasconss" };
5463}
5465namespace PROPAGATING::NLOBBT {
5467 constexpr Param<int> PRIORITY { "propagating/nlobbt/priority" };
5469 constexpr Param<int> FREQ { "propagating/nlobbt/freq" };
5471 constexpr Param<bool> DELAY { "propagating/nlobbt/delay" };
5473 constexpr Param<int> TIMINGMASK { "propagating/nlobbt/timingmask" };
5475 constexpr Param<int> PRESOLPRIORITY { "propagating/nlobbt/presolpriority" };
5477 constexpr Param<int> MAXPREROUNDS { "propagating/nlobbt/maxprerounds" };
5479 constexpr Param<int> PRESOLTIMING { "propagating/nlobbt/presoltiming" };
5481 constexpr Param<double> FEASTOLFAC { "propagating/nlobbt/feastolfac" };
5483 constexpr Param<double> RELOBJTOLFAC { "propagating/nlobbt/relobjtolfac" };
5485 constexpr Param<double> MINNONCONVEXFRAC { "propagating/nlobbt/minnonconvexfrac" };
5487 constexpr Param<double> MINLINEARFRAC { "propagating/nlobbt/minlinearfrac" };
5489 constexpr Param<bool> ADDLPROWS { "propagating/nlobbt/addlprows" };
5491 constexpr Param<int> NLPITERLIMIT { "propagating/nlobbt/nlpiterlimit" };
5493 constexpr Param<double> NLPTIMELIMIT { "propagating/nlobbt/nlptimelimit" };
5495 constexpr Param<int> NLPVERBLEVEL { "propagating/nlobbt/nlpverblevel" };
5497 constexpr Param<double> ITLIMITFACTOR { "propagating/nlobbt/itlimitfactor" };
5498}
5500namespace PROPAGATING::OBBT {
5502 constexpr Param<int> PRIORITY { "propagating/obbt/priority" };
5504 constexpr Param<int> FREQ { "propagating/obbt/freq" };
5506 constexpr Param<bool> DELAY { "propagating/obbt/delay" };
5508 constexpr Param<int> TIMINGMASK { "propagating/obbt/timingmask" };
5510 constexpr Param<int> PRESOLPRIORITY { "propagating/obbt/presolpriority" };
5512 constexpr Param<int> MAXPREROUNDS { "propagating/obbt/maxprerounds" };
5514 constexpr Param<int> PRESOLTIMING { "propagating/obbt/presoltiming" };
5516 constexpr Param<bool> CREATEGENVBOUNDS { "propagating/obbt/creategenvbounds" };
5518 constexpr Param<bool> NORMALIZE { "propagating/obbt/normalize" };
5520 constexpr Param<bool> APPLYFILTERROUNDS { "propagating/obbt/applyfilterrounds" };
5522 constexpr Param<bool> APPLYTRIVIALFILTER { "propagating/obbt/applytrivialfilter" };
5524 constexpr Param<bool> GENVBDSDURINGFILTER { "propagating/obbt/genvbdsduringfilter" };
5526 constexpr Param<bool> GENVBDSDURINGSEPA { "propagating/obbt/genvbdsduringsepa" };
5528 constexpr Param<int> MINFILTER { "propagating/obbt/minfilter" };
5530 constexpr Param<double> ITLIMITFACTOR { "propagating/obbt/itlimitfactor" };
5533 constexpr Param<double> ITLIMITFACTORBILIN { "propagating/obbt/itlimitfactorbilin" };
5535 constexpr Param<double> MINNONCONVEXITY { "propagating/obbt/minnonconvexity" };
5537 constexpr Param<long long> MINITLIMIT { "propagating/obbt/minitlimit" };
5539 constexpr Param<double> DUALFEASTOL { "propagating/obbt/dualfeastol" };
5541 constexpr Param<double> CONDITIONLIMIT { "propagating/obbt/conditionlimit" };
5543 constexpr Param<double> BOUNDSTREPS { "propagating/obbt/boundstreps" };
5545 constexpr Param<double> INDICATORTHRESHOLD { "propagating/obbt/indicatorthreshold" };
5547 constexpr Param<bool> ONLYNONCONVEXVARS { "propagating/obbt/onlynonconvexvars" };
5549 constexpr Param<bool> INDICATORS { "propagating/obbt/indicators" };
5551 constexpr Param<bool> TIGHTINTBOUNDSPROBING { "propagating/obbt/tightintboundsprobing" };
5553 constexpr Param<bool> TIGHTCONTBOUNDSPROBING { "propagating/obbt/tightcontboundsprobing" };
5555 constexpr Param<bool> CREATEBILININEQS { "propagating/obbt/createbilinineqs" };
5557 constexpr Param<bool> CREATELINCONS { "propagating/obbt/createlincons" };
5560 constexpr Param<int> ORDERINGALGO { "propagating/obbt/orderingalgo" };
5562 constexpr Param<bool> SEPARATESOL { "propagating/obbt/separatesol" };
5564 constexpr Param<int> SEPAMINITER { "propagating/obbt/sepaminiter" };
5566 constexpr Param<int> SEPAMAXITER { "propagating/obbt/sepamaxiter" };
5568 constexpr Param<int> PROPAGATEFREQ { "propagating/obbt/propagatefreq" };
5569}
5571namespace PROPAGATING::PROBING {
5573 constexpr Param<int> PRIORITY { "propagating/probing/priority" };
5575 constexpr Param<int> FREQ { "propagating/probing/freq" };
5577 constexpr Param<bool> DELAY { "propagating/probing/delay" };
5579 constexpr Param<int> TIMINGMASK { "propagating/probing/timingmask" };
5581 constexpr Param<int> PRESOLPRIORITY { "propagating/probing/presolpriority" };
5583 constexpr Param<int> MAXPREROUNDS { "propagating/probing/maxprerounds" };
5585 constexpr Param<int> PRESOLTIMING { "propagating/probing/presoltiming" };
5587 constexpr Param<int> MAXRUNS { "propagating/probing/maxruns" };
5589 constexpr Param<int> PROPROUNDS { "propagating/probing/proprounds" };
5591 constexpr Param<int> MAXFIXINGS { "propagating/probing/maxfixings" };
5593 constexpr Param<int> MAXUSELESS { "propagating/probing/maxuseless" };
5596 constexpr Param<int> MAXTOTALUSELESS { "propagating/probing/maxtotaluseless" };
5598 constexpr Param<int> MAXSUMUSELESS { "propagating/probing/maxsumuseless" };
5600 constexpr Param<int> MAXDEPTH { "propagating/probing/maxdepth" };
5601}
5603namespace PROPAGATING::PSEUDOOBJ {
5605 constexpr Param<int> PRIORITY { "propagating/pseudoobj/priority" };
5607 constexpr Param<int> FREQ { "propagating/pseudoobj/freq" };
5609 constexpr Param<bool> DELAY { "propagating/pseudoobj/delay" };
5611 constexpr Param<int> TIMINGMASK { "propagating/pseudoobj/timingmask" };
5613 constexpr Param<int> PRESOLPRIORITY { "propagating/pseudoobj/presolpriority" };
5615 constexpr Param<int> MAXPREROUNDS { "propagating/pseudoobj/maxprerounds" };
5617 constexpr Param<int> PRESOLTIMING { "propagating/pseudoobj/presoltiming" };
5619 constexpr Param<int> MINUSELESS { "propagating/pseudoobj/minuseless" };
5621 constexpr Param<double> MAXVARSFRAC { "propagating/pseudoobj/maxvarsfrac" };
5623 constexpr Param<bool> PROPFULLINROOT { "propagating/pseudoobj/propfullinroot" };
5625 constexpr Param<bool> PROPCUTOFFBOUND { "propagating/pseudoobj/propcutoffbound" };
5627 constexpr Param<bool> FORCE { "propagating/pseudoobj/force" };
5629 constexpr Param<int> MAXNEWVARS { "propagating/pseudoobj/maxnewvars" };
5631 constexpr Param<bool> PROPUSEIMPLICS { "propagating/pseudoobj/propuseimplics" };
5633 constexpr Param<bool> RESPROPUSEIMPLICS { "propagating/pseudoobj/respropuseimplics" };
5635 constexpr Param<int> MAXIMPLVARS { "propagating/pseudoobj/maximplvars" };
5636}
5638namespace PROPAGATING::REDCOST {
5640 constexpr Param<int> PRIORITY { "propagating/redcost/priority" };
5642 constexpr Param<int> FREQ { "propagating/redcost/freq" };
5644 constexpr Param<bool> DELAY { "propagating/redcost/delay" };
5646 constexpr Param<int> TIMINGMASK { "propagating/redcost/timingmask" };
5648 constexpr Param<int> PRESOLPRIORITY { "propagating/redcost/presolpriority" };
5650 constexpr Param<int> MAXPREROUNDS { "propagating/redcost/maxprerounds" };
5652 constexpr Param<int> PRESOLTIMING { "propagating/redcost/presoltiming" };
5654 constexpr Param<bool> CONTINUOUS { "propagating/redcost/continuous" };
5656 constexpr Param<bool> USEIMPLICS { "propagating/redcost/useimplics" };
5658 constexpr Param<bool> FORCE { "propagating/redcost/force" };
5659}
5661namespace PROPAGATING::ROOTREDCOST {
5663 constexpr Param<int> PRIORITY { "propagating/rootredcost/priority" };
5665 constexpr Param<int> FREQ { "propagating/rootredcost/freq" };
5667 constexpr Param<bool> DELAY { "propagating/rootredcost/delay" };
5669 constexpr Param<int> TIMINGMASK { "propagating/rootredcost/timingmask" };
5671 constexpr Param<int> PRESOLPRIORITY { "propagating/rootredcost/presolpriority" };
5673 constexpr Param<int> MAXPREROUNDS { "propagating/rootredcost/maxprerounds" };
5675 constexpr Param<int> PRESOLTIMING { "propagating/rootredcost/presoltiming" };
5677 constexpr Param<bool> ONLYBINARY { "propagating/rootredcost/onlybinary" };
5679 constexpr Param<bool> FORCE { "propagating/rootredcost/force" };
5680}
5682namespace PROPAGATING::SYMMETRY {
5684 constexpr Param<int> PRIORITY { "propagating/symmetry/priority" };
5686 constexpr Param<int> FREQ { "propagating/symmetry/freq" };
5688 constexpr Param<bool> DELAY { "propagating/symmetry/delay" };
5690 constexpr Param<int> TIMINGMASK { "propagating/symmetry/timingmask" };
5692 constexpr Param<int> PRESOLPRIORITY { "propagating/symmetry/presolpriority" };
5694 constexpr Param<int> MAXPREROUNDS { "propagating/symmetry/maxprerounds" };
5696 constexpr Param<int> PRESOLTIMING { "propagating/symmetry/presoltiming" };
5698 constexpr Param<int> MAXGENERATORS { "propagating/symmetry/maxgenerators" };
5700 constexpr Param<bool> CHECKSYMMETRIES { "propagating/symmetry/checksymmetries" };
5702 constexpr Param<bool> DISPLAYNORBITVARS { "propagating/symmetry/displaynorbitvars" };
5704 constexpr Param<bool> DOUBLEEQUATIONS { "propagating/symmetry/doubleequations" };
5706 constexpr Param<bool> CONSSADDLP { "propagating/symmetry/conssaddlp" };
5708 constexpr Param<bool> ADDSYMRESACKS { "propagating/symmetry/addsymresacks" };
5710 constexpr Param<bool> DETECTDOUBLELEX { "propagating/symmetry/detectdoublelex" };
5712 constexpr Param<bool> DETECTORBITOPES { "propagating/symmetry/detectorbitopes" };
5714 constexpr Param<bool> DETECTSUBGROUPS { "propagating/symmetry/detectsubgroups" };
5716 constexpr Param<bool> ADDWEAKSBCS { "propagating/symmetry/addweaksbcs" };
5719 constexpr Param<int> ADDCONSSTIMING { "propagating/symmetry/addconsstiming" };
5722 constexpr Param<int> OFSYMCOMPTIMING { "propagating/symmetry/ofsymcomptiming" };
5724 constexpr Param<bool> PERFORMPRESOLVING { "propagating/symmetry/performpresolving" };
5726 constexpr Param<int> RECOMPUTERESTART { "propagating/symmetry/recomputerestart" };
5728 constexpr Param<bool> COMPRESSSYMMETRIES { "propagating/symmetry/compresssymmetries" };
5730 constexpr Param<double> COMPRESSTHRESHOLD { "propagating/symmetry/compressthreshold" };
5732 constexpr Param<bool> USECOLUMNSPARSITY { "propagating/symmetry/usecolumnsparsity" };
5734 constexpr Param<int> MAXNCONSSSUBGROUP { "propagating/symmetry/maxnconsssubgroup" };
5736 constexpr Param<bool> USEDYNAMICPROP { "propagating/symmetry/usedynamicprop" };
5738 constexpr Param<bool> ADDSTRONGSBCS { "propagating/symmetry/addstrongsbcs" };
5741 constexpr Param<int> SSTTIEBREAKRULE { "propagating/symmetry/ssttiebreakrule" };
5743 constexpr Param<int> SSTLEADERRULE { "propagating/symmetry/sstleaderrule" };
5746 constexpr Param<int> SSTLEADERVARTYPE { "propagating/symmetry/sstleadervartype" };
5748 constexpr Param<bool> ADDCONFLICTCUTS { "propagating/symmetry/addconflictcuts" };
5750 constexpr Param<bool> SSTADDCUTS { "propagating/symmetry/sstaddcuts" };
5752 constexpr Param<bool> SSTMIXEDCOMPONENTS { "propagating/symmetry/sstmixedcomponents" };
5754 constexpr Param<bool> SYMFIXNONBINARYVARS { "propagating/symmetry/symfixnonbinaryvars" };
5756 constexpr Param<bool> ENFORCECOMPUTESYMMETRY { "propagating/symmetry/enforcecomputesymmetry" };
5758 constexpr Param<bool> PREFERLESSROWS { "propagating/symmetry/preferlessrows" };
5760 constexpr Param<int> SYMTYPE { "propagating/symmetry/symtype" };
5762 constexpr Param<int> SYMTIMING { "propagating/symmetry/symtiming" };
5764 constexpr Param<int> NAUTYMAXNCELLS { "propagating/symmetry/nautymaxncells" };
5766 constexpr Param<int> NAUTYMAXNNODES { "propagating/symmetry/nautymaxnnodes" };
5767}
5769namespace PROPAGATING::SYMMETRY::ORBITOPALREDUCTION {
5771 constexpr Param<int> COLUMNORDERING { "propagating/symmetry/orbitopalreduction/columnordering" };
5772}
5774namespace PROPAGATING::VBOUNDS {
5776 constexpr Param<int> PRIORITY { "propagating/vbounds/priority" };
5778 constexpr Param<int> FREQ { "propagating/vbounds/freq" };
5780 constexpr Param<bool> DELAY { "propagating/vbounds/delay" };
5782 constexpr Param<int> TIMINGMASK { "propagating/vbounds/timingmask" };
5784 constexpr Param<int> PRESOLPRIORITY { "propagating/vbounds/presolpriority" };
5786 constexpr Param<int> MAXPREROUNDS { "propagating/vbounds/maxprerounds" };
5788 constexpr Param<int> PRESOLTIMING { "propagating/vbounds/presoltiming" };
5790 constexpr Param<bool> USEBDWIDENING { "propagating/vbounds/usebdwidening" };
5792 constexpr Param<bool> USEIMPLICS { "propagating/vbounds/useimplics" };
5794 constexpr Param<bool> USECLIQUES { "propagating/vbounds/usecliques" };
5796 constexpr Param<bool> USEVBOUNDS { "propagating/vbounds/usevbounds" };
5798 constexpr Param<bool> DOTOPOSORT { "propagating/vbounds/dotoposort" };
5800 constexpr Param<bool> SORTCLIQUES { "propagating/vbounds/sortcliques" };
5802 constexpr Param<bool> DETECTCYCLES { "propagating/vbounds/detectcycles" };
5804 constexpr Param<double> MINNEWCLIQUES { "propagating/vbounds/minnewcliques" };
5806 constexpr Param<double> MAXCLIQUESMEDIUM { "propagating/vbounds/maxcliquesmedium" };
5808 constexpr Param<double> MAXCLIQUESEXHAUSTIVE { "propagating/vbounds/maxcliquesexhaustive" };
5809}
5811namespace RANDOMIZATION {
5813 constexpr Param<int> RANDOMSEEDSHIFT { "randomization/randomseedshift" };
5815 constexpr Param<int> PERMUTATIONSEED { "randomization/permutationseed" };
5817 constexpr Param<bool> PERMUTECONSS { "randomization/permuteconss" };
5819 constexpr Param<bool> PERMUTEVARS { "randomization/permutevars" };
5821 constexpr Param<int> LPSEED { "randomization/lpseed" };
5822}
5824namespace READING {
5826 constexpr Param<bool> INITIALCONSS { "reading/initialconss" };
5828 constexpr Param<bool> DYNAMICCONSS { "reading/dynamicconss" };
5830 constexpr Param<bool> DYNAMICCOLS { "reading/dynamiccols" };
5832 constexpr Param<bool> DYNAMICROWS { "reading/dynamicrows" };
5833}
5835namespace READING::BNDREADER {
5837 constexpr Param<bool> IMPROVEONLY { "reading/bndreader/improveonly" };
5838}
5840namespace READING::CIPREADER {
5842 constexpr Param<bool> WRITEFIXEDVARS { "reading/cipreader/writefixedvars" };
5843}
5845namespace READING::CNFREADER {
5847 constexpr Param<bool> USEOBJ { "reading/cnfreader/useobj" };
5848}
5850namespace READING::GMSREADER {
5852 constexpr Param<bool> REPLACEFORBIDDENCHARS { "reading/gmsreader/replaceforbiddenchars" };
5854 constexpr Param<double> BIGMDEFAULT { "reading/gmsreader/bigmdefault" };
5856 constexpr Param<char> INDICATORREFORM { "reading/gmsreader/indicatorreform" };
5858 constexpr Param<bool> SIGNPOWER { "reading/gmsreader/signpower" };
5859}
5861namespace READING::LPREADER {
5863 constexpr Param<bool> LINEARIZE_AND_CONSTRAINTS { "reading/lpreader/linearize-and-constraints" };
5865 constexpr Param<bool> AGGRLINEARIZATION_ANDS { "reading/lpreader/aggrlinearization-ands" };
5866}
5868namespace READING::MPSREADER {
5870 constexpr Param<bool> LINEARIZE_AND_CONSTRAINTS { "reading/mpsreader/linearize-and-constraints" };
5872 constexpr Param<bool> AGGRLINEARIZATION_ANDS { "reading/mpsreader/aggrlinearization-ands" };
5873}
5875namespace READING::OPBREADER {
5877 constexpr Param<bool> DYNAMICCONSS { "reading/opbreader/dynamicconss" };
5879 constexpr Param<bool> MULTISYMBOL { "reading/opbreader/multisymbol" };
5880}
5882namespace READING::PBMREADER {
5884 constexpr Param<bool> BINARY { "reading/pbmreader/binary" };
5886 constexpr Param<int> MAXROWS { "reading/pbmreader/maxrows" };
5888 constexpr Param<int> MAXCOLS { "reading/pbmreader/maxcols" };
5889}
5891namespace READING::PPMREADER {
5893 constexpr Param<bool> RGBRELATIV { "reading/ppmreader/rgbrelativ" };
5895 constexpr Param<bool> RGBASCII { "reading/ppmreader/rgbascii" };
5897 constexpr Param<int> COEFFICIENTLIMIT { "reading/ppmreader/coefficientlimit" };
5899 constexpr Param<int> RGBLIMIT { "reading/ppmreader/rgblimit" };
5900}
5902namespace READING::STOREADER {
5904 constexpr Param<bool> USEBENDERS { "reading/storeader/usebenders" };
5905}
5907namespace REOPTIMIZATION {
5909 constexpr Param<bool> ENABLE { "reoptimization/enable" };
5911 constexpr Param<int> MAXSAVEDNODES { "reoptimization/maxsavednodes" };
5913 constexpr Param<int> MAXDIFFOFNODES { "reoptimization/maxdiffofnodes" };
5915 constexpr Param<bool> SEPABESTSOL { "reoptimization/sepabestsol" };
5917 constexpr Param<bool> STOREVARHISTORY { "reoptimization/storevarhistory" };
5919 constexpr Param<bool> USEPSCOST { "reoptimization/usepscost" };
5922 constexpr Param<int> SOLVELP { "reoptimization/solvelp" };
5924 constexpr Param<int> SOLVELPDIFF { "reoptimization/solvelpdiff" };
5926 constexpr Param<int> SAVESOLS { "reoptimization/savesols" };
5928 constexpr Param<double> OBJSIMROOTLP { "reoptimization/objsimrootLP" };
5930 constexpr Param<double> OBJSIMSOL { "reoptimization/objsimsol" };
5932 constexpr Param<double> DELAY { "reoptimization/delay" };
5934 constexpr Param<bool> COMMONTIMELIMIT { "reoptimization/commontimelimit" };
5936 constexpr Param<bool> SHRINKINNER { "reoptimization/shrinkinner" };
5938 constexpr Param<bool> STRONGBRANCHINGINIT { "reoptimization/strongbranchinginit" };
5940 constexpr Param<bool> REDUCETOFRONTIER { "reoptimization/reducetofrontier" };
5942 constexpr Param<int> FORCEHEURRESTART { "reoptimization/forceheurrestart" };
5944 constexpr Param<bool> SAVECONSPROP { "reoptimization/saveconsprop" };
5946 constexpr Param<bool> USESPLITCONS { "reoptimization/usesplitcons" };
5949 constexpr Param<char> VARORDERINTERDICTION { "reoptimization/varorderinterdiction" };
5951 constexpr Param<bool> USECUTS { "reoptimization/usecuts" };
5953 constexpr Param<int> MAXCUTAGE { "reoptimization/maxcutage" };
5954}
5956namespace REOPTIMIZATION::GLOBALCONS {
5958 constexpr Param<bool> SEPAINFSUBTREES { "reoptimization/globalcons/sepainfsubtrees" };
5959}
5961namespace SEPARATING {
5964 constexpr Param<double> MAXBOUNDDIST { "separating/maxbounddist" };
5967 constexpr Param<double> MAXLOCALBOUNDDIST { "separating/maxlocalbounddist" };
5969 constexpr Param<double> MAXCOEFRATIO { "separating/maxcoefratio" };
5971 constexpr Param<double> MAXCOEFRATIOFACROWPREP { "separating/maxcoefratiofacrowprep" };
5973 constexpr Param<double> MINEFFICACY { "separating/minefficacy" };
5975 constexpr Param<double> MINEFFICACYROOT { "separating/minefficacyroot" };
5977 constexpr Param<double> MINACTIVITYQUOT { "separating/minactivityquot" };
5980 constexpr Param<double> MAXCUTSGENFACTOR { "separating/maxcutsgenfactor" };
5983 constexpr Param<double> MAXCUTSROOTGENFACTOR { "separating/maxcutsrootgenfactor" };
5985 constexpr Param<char> ORTHOFUNC { "separating/orthofunc" };
5987 constexpr Param<char> EFFICACYNORM { "separating/efficacynorm" };
5989 constexpr Param<char> CUTSELRESTART { "separating/cutselrestart" };
5991 constexpr Param<char> CUTSELSUBSCIP { "separating/cutselsubscip" };
5993 constexpr Param<bool> FILTERCUTPOOLREL { "separating/filtercutpoolrel" };
5995 constexpr Param<int> MAXRUNS { "separating/maxruns" };
5997 constexpr Param<int> MAXROUNDS { "separating/maxrounds" };
5999 constexpr Param<int> MAXROUNDSROOT { "separating/maxroundsroot" };
6001 constexpr Param<int> MAXROUNDSROOTSUBRUN { "separating/maxroundsrootsubrun" };
6003 constexpr Param<int> MAXADDROUNDS { "separating/maxaddrounds" };
6006 constexpr Param<int> MAXSTALLROUNDS { "separating/maxstallrounds" };
6009 constexpr Param<int> MAXSTALLROUNDSROOT { "separating/maxstallroundsroot" };
6011 constexpr Param<int> MAXCUTS { "separating/maxcuts" };
6013 constexpr Param<int> MAXCUTSROOT { "separating/maxcutsroot" };
6015 constexpr Param<int> CUTAGELIMIT { "separating/cutagelimit" };
6017 constexpr Param<int> POOLFREQ { "separating/poolfreq" };
6018}
6020namespace SEPARATING::AGGREGATION {
6022 constexpr Param<int> PRIORITY { "separating/aggregation/priority" };
6024 constexpr Param<int> FREQ { "separating/aggregation/freq" };
6027 constexpr Param<double> MAXBOUNDDIST { "separating/aggregation/maxbounddist" };
6029 constexpr Param<bool> DELAY { "separating/aggregation/delay" };
6032 constexpr Param<int> EXPBACKOFF { "separating/aggregation/expbackoff" };
6034 constexpr Param<int> MAXROUNDS { "separating/aggregation/maxrounds" };
6036 constexpr Param<int> MAXROUNDSROOT { "separating/aggregation/maxroundsroot" };
6038 constexpr Param<int> MAXTRIES { "separating/aggregation/maxtries" };
6040 constexpr Param<int> MAXTRIESROOT { "separating/aggregation/maxtriesroot" };
6042 constexpr Param<int> MAXFAILS { "separating/aggregation/maxfails" };
6044 constexpr Param<int> MAXFAILSROOT { "separating/aggregation/maxfailsroot" };
6046 constexpr Param<int> MAXAGGRS { "separating/aggregation/maxaggrs" };
6048 constexpr Param<int> MAXAGGRSROOT { "separating/aggregation/maxaggrsroot" };
6050 constexpr Param<int> MAXSEPACUTS { "separating/aggregation/maxsepacuts" };
6052 constexpr Param<int> MAXSEPACUTSROOT { "separating/aggregation/maxsepacutsroot" };
6054 constexpr Param<double> MAXSLACK { "separating/aggregation/maxslack" };
6056 constexpr Param<double> MAXSLACKROOT { "separating/aggregation/maxslackroot" };
6058 constexpr Param<double> DENSITYSCORE { "separating/aggregation/densityscore" };
6060 constexpr Param<double> SLACKSCORE { "separating/aggregation/slackscore" };
6062 constexpr Param<double> MAXAGGDENSITY { "separating/aggregation/maxaggdensity" };
6064 constexpr Param<double> MAXROWDENSITY { "separating/aggregation/maxrowdensity" };
6066 constexpr Param<int> DENSITYOFFSET { "separating/aggregation/densityoffset" };
6068 constexpr Param<double> MAXROWFAC { "separating/aggregation/maxrowfac" };
6070 constexpr Param<int> MAXTESTDELTA { "separating/aggregation/maxtestdelta" };
6073 constexpr Param<double> AGGRTOL { "separating/aggregation/aggrtol" };
6075 constexpr Param<bool> TRYNEGSCALING { "separating/aggregation/trynegscaling" };
6077 constexpr Param<bool> FIXINTEGRALRHS { "separating/aggregation/fixintegralrhs" };
6079 constexpr Param<bool> DYNAMICCUTS { "separating/aggregation/dynamiccuts" };
6080}
6082namespace SEPARATING::CGMIP {
6084 constexpr Param<int> PRIORITY { "separating/cgmip/priority" };
6086 constexpr Param<int> FREQ { "separating/cgmip/freq" };
6089 constexpr Param<double> MAXBOUNDDIST { "separating/cgmip/maxbounddist" };
6091 constexpr Param<bool> DELAY { "separating/cgmip/delay" };
6094 constexpr Param<int> EXPBACKOFF { "separating/cgmip/expbackoff" };
6096 constexpr Param<int> MAXROUNDS { "separating/cgmip/maxrounds" };
6098 constexpr Param<int> MAXROUNDSROOT { "separating/cgmip/maxroundsroot" };
6100 constexpr Param<int> MAXDEPTH { "separating/cgmip/maxdepth" };
6102 constexpr Param<bool> DECISIONTREE { "separating/cgmip/decisiontree" };
6104 constexpr Param<double> TIMELIMIT { "separating/cgmip/timelimit" };
6106 constexpr Param<double> MEMORYLIMIT { "separating/cgmip/memorylimit" };
6108 constexpr Param<long long> MINNODELIMIT { "separating/cgmip/minnodelimit" };
6110 constexpr Param<long long> MAXNODELIMIT { "separating/cgmip/maxnodelimit" };
6112 constexpr Param<double> CUTCOEFBND { "separating/cgmip/cutcoefbnd" };
6114 constexpr Param<bool> ONLYACTIVEROWS { "separating/cgmip/onlyactiverows" };
6116 constexpr Param<int> MAXROWAGE { "separating/cgmip/maxrowage" };
6118 constexpr Param<bool> ONLYRANKONE { "separating/cgmip/onlyrankone" };
6120 constexpr Param<bool> ONLYINTVARS { "separating/cgmip/onlyintvars" };
6122 constexpr Param<bool> CONTCONVERT { "separating/cgmip/contconvert" };
6124 constexpr Param<double> CONTCONVFRAC { "separating/cgmip/contconvfrac" };
6126 constexpr Param<int> CONTCONVMIN { "separating/cgmip/contconvmin" };
6128 constexpr Param<bool> INTCONVERT { "separating/cgmip/intconvert" };
6130 constexpr Param<double> INTCONVFRAC { "separating/cgmip/intconvfrac" };
6132 constexpr Param<int> INTCONVMIN { "separating/cgmip/intconvmin" };
6134 constexpr Param<bool> SKIPMULTBOUNDS { "separating/cgmip/skipmultbounds" };
6136 constexpr Param<bool> OBJLONE { "separating/cgmip/objlone" };
6138 constexpr Param<double> OBJWEIGHT { "separating/cgmip/objweight" };
6140 constexpr Param<bool> OBJWEIGHTSIZE { "separating/cgmip/objweightsize" };
6142 constexpr Param<bool> DYNAMICCUTS { "separating/cgmip/dynamiccuts" };
6144 constexpr Param<bool> USECMIR { "separating/cgmip/usecmir" };
6146 constexpr Param<bool> USESTRONGCG { "separating/cgmip/usestrongcg" };
6148 constexpr Param<bool> CMIROWNBOUNDS { "separating/cgmip/cmirownbounds" };
6150 constexpr Param<bool> USECUTPOOL { "separating/cgmip/usecutpool" };
6152 constexpr Param<bool> PRIMALSEPARATION { "separating/cgmip/primalseparation" };
6154 constexpr Param<bool> EARLYTERM { "separating/cgmip/earlyterm" };
6156 constexpr Param<bool> ADDVIOLATIONCONS { "separating/cgmip/addviolationcons" };
6158 constexpr Param<bool> ADDVIOLCONSHDLR { "separating/cgmip/addviolconshdlr" };
6160 constexpr Param<bool> CONSHDLRUSENORM { "separating/cgmip/conshdlrusenorm" };
6162 constexpr Param<bool> USEOBJUB { "separating/cgmip/useobjub" };
6164 constexpr Param<bool> USEOBJLB { "separating/cgmip/useobjlb" };
6166 constexpr Param<bool> SUBSCIPFAST { "separating/cgmip/subscipfast" };
6168 constexpr Param<bool> OUTPUT { "separating/cgmip/output" };
6170 constexpr Param<bool> GENPRIMALSOLS { "separating/cgmip/genprimalsols" };
6171}
6173namespace SEPARATING::CLIQUE {
6175 constexpr Param<int> PRIORITY { "separating/clique/priority" };
6177 constexpr Param<int> FREQ { "separating/clique/freq" };
6180 constexpr Param<double> MAXBOUNDDIST { "separating/clique/maxbounddist" };
6182 constexpr Param<bool> DELAY { "separating/clique/delay" };
6185 constexpr Param<int> EXPBACKOFF { "separating/clique/expbackoff" };
6187 constexpr Param<double> SCALEVAL { "separating/clique/scaleval" };
6189 constexpr Param<int> MAXTREENODES { "separating/clique/maxtreenodes" };
6191 constexpr Param<int> BACKTRACKFREQ { "separating/clique/backtrackfreq" };
6193 constexpr Param<int> MAXSEPACUTS { "separating/clique/maxsepacuts" };
6195 constexpr Param<int> MAXZEROEXTENSIONS { "separating/clique/maxzeroextensions" };
6197 constexpr Param<double> CLIQUETABLEMEM { "separating/clique/cliquetablemem" };
6199 constexpr Param<double> CLIQUEDENSITY { "separating/clique/cliquedensity" };
6200}
6202namespace SEPARATING::CLOSECUTS {
6204 constexpr Param<int> PRIORITY { "separating/closecuts/priority" };
6206 constexpr Param<int> FREQ { "separating/closecuts/freq" };
6209 constexpr Param<double> MAXBOUNDDIST { "separating/closecuts/maxbounddist" };
6211 constexpr Param<bool> DELAY { "separating/closecuts/delay" };
6214 constexpr Param<int> EXPBACKOFF { "separating/closecuts/expbackoff" };
6216 constexpr Param<bool> SEPARELINT { "separating/closecuts/separelint" };
6218 constexpr Param<double> SEPACOMBVALUE { "separating/closecuts/sepacombvalue" };
6220 constexpr Param<int> CLOSETHRES { "separating/closecuts/closethres" };
6222 constexpr Param<bool> INCLOBJCUTOFF { "separating/closecuts/inclobjcutoff" };
6224 constexpr Param<bool> RECOMPUTERELINT { "separating/closecuts/recomputerelint" };
6226 constexpr Param<int> MAXUNSUCCESSFUL { "separating/closecuts/maxunsuccessful" };
6229 constexpr Param<double> MAXLPITERFACTOR { "separating/closecuts/maxlpiterfactor" };
6230}
6232namespace SEPARATING::CMIR {
6234 constexpr Param<int> PRIORITY { "separating/cmir/priority" };
6236 constexpr Param<int> FREQ { "separating/cmir/freq" };
6239 constexpr Param<double> MAXBOUNDDIST { "separating/cmir/maxbounddist" };
6241 constexpr Param<bool> DELAY { "separating/cmir/delay" };
6244 constexpr Param<int> EXPBACKOFF { "separating/cmir/expbackoff" };
6245}
6247namespace SEPARATING::CONVEXPROJ {
6249 constexpr Param<int> PRIORITY { "separating/convexproj/priority" };
6251 constexpr Param<int> FREQ { "separating/convexproj/freq" };
6254 constexpr Param<double> MAXBOUNDDIST { "separating/convexproj/maxbounddist" };
6256 constexpr Param<bool> DELAY { "separating/convexproj/delay" };
6259 constexpr Param<int> EXPBACKOFF { "separating/convexproj/expbackoff" };
6261 constexpr Param<int> MAXDEPTH { "separating/convexproj/maxdepth" };
6263 constexpr Param<int> NLPITERLIMIT { "separating/convexproj/nlpiterlimit" };
6264}
6266namespace SEPARATING::DISJUNCTIVE {
6268 constexpr Param<int> PRIORITY { "separating/disjunctive/priority" };
6270 constexpr Param<int> FREQ { "separating/disjunctive/freq" };
6273 constexpr Param<double> MAXBOUNDDIST { "separating/disjunctive/maxbounddist" };
6275 constexpr Param<bool> DELAY { "separating/disjunctive/delay" };
6278 constexpr Param<int> EXPBACKOFF { "separating/disjunctive/expbackoff" };
6280 constexpr Param<bool> STRENGTHEN { "separating/disjunctive/strengthen" };
6282 constexpr Param<int> MAXDEPTH { "separating/disjunctive/maxdepth" };
6284 constexpr Param<int> MAXROUNDS { "separating/disjunctive/maxrounds" };
6286 constexpr Param<int> MAXROUNDSROOT { "separating/disjunctive/maxroundsroot" };
6288 constexpr Param<int> MAXINVCUTS { "separating/disjunctive/maxinvcuts" };
6290 constexpr Param<int> MAXINVCUTSROOT { "separating/disjunctive/maxinvcutsroot" };
6292 constexpr Param<int> MAXCONFSDELAY { "separating/disjunctive/maxconfsdelay" };
6294 constexpr Param<int> MAXRANK { "separating/disjunctive/maxrank" };
6296 constexpr Param<int> MAXRANKINTEGRAL { "separating/disjunctive/maxrankintegral" };
6298 constexpr Param<double> MAXWEIGHTRANGE { "separating/disjunctive/maxweightrange" };
6299}
6301namespace SEPARATING::ECCUTS {
6303 constexpr Param<int> PRIORITY { "separating/eccuts/priority" };
6305 constexpr Param<int> FREQ { "separating/eccuts/freq" };
6308 constexpr Param<double> MAXBOUNDDIST { "separating/eccuts/maxbounddist" };
6310 constexpr Param<bool> DELAY { "separating/eccuts/delay" };
6313 constexpr Param<int> EXPBACKOFF { "separating/eccuts/expbackoff" };
6315 constexpr Param<bool> DYNAMICCUTS { "separating/eccuts/dynamiccuts" };
6317 constexpr Param<int> MAXROUNDS { "separating/eccuts/maxrounds" };
6319 constexpr Param<int> MAXROUNDSROOT { "separating/eccuts/maxroundsroot" };
6321 constexpr Param<int> MAXDEPTH { "separating/eccuts/maxdepth" };
6323 constexpr Param<int> MAXSEPACUTS { "separating/eccuts/maxsepacuts" };
6325 constexpr Param<int> MAXSEPACUTSROOT { "separating/eccuts/maxsepacutsroot" };
6327 constexpr Param<double> CUTMAXRANGE { "separating/eccuts/cutmaxrange" };
6329 constexpr Param<double> MINVIOLATION { "separating/eccuts/minviolation" };
6331 constexpr Param<int> MINAGGRSIZE { "separating/eccuts/minaggrsize" };
6333 constexpr Param<int> MAXAGGRSIZE { "separating/eccuts/maxaggrsize" };
6335 constexpr Param<int> MAXBILINTERMS { "separating/eccuts/maxbilinterms" };
6337 constexpr Param<int> MAXSTALLROUNDS { "separating/eccuts/maxstallrounds" };
6338}
6340namespace SEPARATING::FLOWCOVER {
6342 constexpr Param<int> PRIORITY { "separating/flowcover/priority" };
6344 constexpr Param<int> FREQ { "separating/flowcover/freq" };
6347 constexpr Param<double> MAXBOUNDDIST { "separating/flowcover/maxbounddist" };
6349 constexpr Param<bool> DELAY { "separating/flowcover/delay" };
6352 constexpr Param<int> EXPBACKOFF { "separating/flowcover/expbackoff" };
6353}
6355namespace SEPARATING::GAUGE {
6357 constexpr Param<int> PRIORITY { "separating/gauge/priority" };
6359 constexpr Param<int> FREQ { "separating/gauge/freq" };
6362 constexpr Param<double> MAXBOUNDDIST { "separating/gauge/maxbounddist" };
6364 constexpr Param<bool> DELAY { "separating/gauge/delay" };
6367 constexpr Param<int> EXPBACKOFF { "separating/gauge/expbackoff" };
6369 constexpr Param<int> NLPITERLIMIT { "separating/gauge/nlpiterlimit" };
6370}
6372namespace SEPARATING::GOMORY {
6374 constexpr Param<int> PRIORITY { "separating/gomory/priority" };
6376 constexpr Param<int> FREQ { "separating/gomory/freq" };
6379 constexpr Param<double> MAXBOUNDDIST { "separating/gomory/maxbounddist" };
6381 constexpr Param<bool> DELAY { "separating/gomory/delay" };
6384 constexpr Param<int> EXPBACKOFF { "separating/gomory/expbackoff" };
6386 constexpr Param<int> MAXROUNDS { "separating/gomory/maxrounds" };
6388 constexpr Param<int> MAXROUNDSROOT { "separating/gomory/maxroundsroot" };
6390 constexpr Param<int> MAXSEPACUTS { "separating/gomory/maxsepacuts" };
6392 constexpr Param<int> MAXSEPACUTSROOT { "separating/gomory/maxsepacutsroot" };
6394 constexpr Param<int> MAXRANK { "separating/gomory/maxrank" };
6396 constexpr Param<int> MAXRANKINTEGRAL { "separating/gomory/maxrankintegral" };
6398 constexpr Param<double> AWAY { "separating/gomory/away" };
6400 constexpr Param<bool> DYNAMICCUTS { "separating/gomory/dynamiccuts" };
6402 constexpr Param<bool> MAKEINTEGRAL { "separating/gomory/makeintegral" };
6404 constexpr Param<bool> FORCECUTS { "separating/gomory/forcecuts" };
6406 constexpr Param<bool> SEPARATEROWS { "separating/gomory/separaterows" };
6408 constexpr Param<bool> DELAYEDCUTS { "separating/gomory/delayedcuts" };
6410 constexpr Param<bool> SIDETYPEBASIS { "separating/gomory/sidetypebasis" };
6412 constexpr Param<bool> TRYSTRONGCG { "separating/gomory/trystrongcg" };
6414 constexpr Param<bool> GENBOTHGOMSCG { "separating/gomory/genbothgomscg" };
6415}
6417namespace SEPARATING::GOMORYMI {
6419 constexpr Param<int> PRIORITY { "separating/gomorymi/priority" };
6421 constexpr Param<int> FREQ { "separating/gomorymi/freq" };
6424 constexpr Param<double> MAXBOUNDDIST { "separating/gomorymi/maxbounddist" };
6426 constexpr Param<bool> DELAY { "separating/gomorymi/delay" };
6429 constexpr Param<int> EXPBACKOFF { "separating/gomorymi/expbackoff" };
6430}
6432namespace SEPARATING::IMPLIEDBOUNDS {
6434 constexpr Param<int> PRIORITY { "separating/impliedbounds/priority" };
6436 constexpr Param<int> FREQ { "separating/impliedbounds/freq" };
6439 constexpr Param<double> MAXBOUNDDIST { "separating/impliedbounds/maxbounddist" };
6441 constexpr Param<bool> DELAY { "separating/impliedbounds/delay" };
6444 constexpr Param<int> EXPBACKOFF { "separating/impliedbounds/expbackoff" };
6446 constexpr Param<bool> USETWOSIZECLIQUES { "separating/impliedbounds/usetwosizecliques" };
6447}
6449namespace SEPARATING::INTERMINOR {
6451 constexpr Param<int> PRIORITY { "separating/interminor/priority" };
6453 constexpr Param<int> FREQ { "separating/interminor/freq" };
6456 constexpr Param<double> MAXBOUNDDIST { "separating/interminor/maxbounddist" };
6458 constexpr Param<bool> DELAY { "separating/interminor/delay" };
6461 constexpr Param<int> EXPBACKOFF { "separating/interminor/expbackoff" };
6463 constexpr Param<bool> USESTRENGTHENING { "separating/interminor/usestrengthening" };
6465 constexpr Param<bool> USEBOUNDS { "separating/interminor/usebounds" };
6467 constexpr Param<double> MINCUTVIOL { "separating/interminor/mincutviol" };
6469 constexpr Param<int> MAXROUNDS { "separating/interminor/maxrounds" };
6471 constexpr Param<int> MAXROUNDSROOT { "separating/interminor/maxroundsroot" };
6472}
6474namespace SEPARATING::INTOBJ {
6476 constexpr Param<int> PRIORITY { "separating/intobj/priority" };
6478 constexpr Param<int> FREQ { "separating/intobj/freq" };
6481 constexpr Param<double> MAXBOUNDDIST { "separating/intobj/maxbounddist" };
6483 constexpr Param<bool> DELAY { "separating/intobj/delay" };
6486 constexpr Param<int> EXPBACKOFF { "separating/intobj/expbackoff" };
6487}
6489namespace SEPARATING::KNAPSACKCOVER {
6491 constexpr Param<int> PRIORITY { "separating/knapsackcover/priority" };
6493 constexpr Param<int> FREQ { "separating/knapsackcover/freq" };
6496 constexpr Param<double> MAXBOUNDDIST { "separating/knapsackcover/maxbounddist" };
6498 constexpr Param<bool> DELAY { "separating/knapsackcover/delay" };
6501 constexpr Param<int> EXPBACKOFF { "separating/knapsackcover/expbackoff" };
6502}
6504namespace SEPARATING::LAGROMORY {
6506 constexpr Param<int> PRIORITY { "separating/lagromory/priority" };
6508 constexpr Param<int> FREQ { "separating/lagromory/freq" };
6511 constexpr Param<double> MAXBOUNDDIST { "separating/lagromory/maxbounddist" };
6513 constexpr Param<bool> DELAY { "separating/lagromory/delay" };
6516 constexpr Param<int> EXPBACKOFF { "separating/lagromory/expbackoff" };
6518 constexpr Param<double> AWAY { "separating/lagromory/away" };
6521 constexpr Param<double> ROOTLPITERLIMITFACTOR { "separating/lagromory/rootlpiterlimitfactor" };
6523 constexpr Param<double> TOTALLPITERLIMITFACTOR { "separating/lagromory/totallpiterlimitfactor" };
6526 constexpr Param<double> PERROUNDLPITERLIMITFACTOR { "separating/lagromory/perroundlpiterlimitfactor" };
6528 constexpr Param<double> PERROUNDCUTSFACTORROOT { "separating/lagromory/perroundcutsfactorroot" };
6530 constexpr Param<double> PERROUNDCUTSFACTOR { "separating/lagromory/perroundcutsfactor" };
6532 constexpr Param<double> TOTALCUTSFACTOR { "separating/lagromory/totalcutsfactor" };
6534 constexpr Param<double> MUPARAMINIT { "separating/lagromory/muparaminit" };
6536 constexpr Param<double> MUPARAMLB { "separating/lagromory/muparamlb" };
6538 constexpr Param<double> MUPARAMUB { "separating/lagromory/muparamub" };
6540 constexpr Param<double> MUBACKTRACKFACTOR { "separating/lagromory/mubacktrackfactor" };
6542 constexpr Param<double> MUSLAB1FACTOR { "separating/lagromory/muslab1factor" };
6544 constexpr Param<double> MUSLAB2FACTOR { "separating/lagromory/muslab2factor" };
6546 constexpr Param<double> MUSLAB3FACTOR { "separating/lagromory/muslab3factor" };
6548 constexpr Param<double> DELTASLAB1UB { "separating/lagromory/deltaslab1ub" };
6550 constexpr Param<double> DELTASLAB2UB { "separating/lagromory/deltaslab2ub" };
6552 constexpr Param<double> UBPARAMPOSFACTOR { "separating/lagromory/ubparamposfactor" };
6554 constexpr Param<double> UBPARAMNEGFACTOR { "separating/lagromory/ubparamnegfactor" };
6556 constexpr Param<double> PERROOTLPITERFACTOR { "separating/lagromory/perrootlpiterfactor" };
6558 constexpr Param<double> PERLPITERFACTOR { "separating/lagromory/perlpiterfactor" };
6560 constexpr Param<double> CUTSFILTERFACTOR { "separating/lagromory/cutsfilterfactor" };
6562 constexpr Param<double> RADIUSINIT { "separating/lagromory/radiusinit" };
6564 constexpr Param<double> RADIUSMAX { "separating/lagromory/radiusmax" };
6566 constexpr Param<double> RADIUSMIN { "separating/lagromory/radiusmin" };
6568 constexpr Param<double> CONSTANT { "separating/lagromory/constant" };
6570 constexpr Param<double> RADIUSUPDATEWEIGHT { "separating/lagromory/radiusupdateweight" };
6572 constexpr Param<double> DUALDEGENERACYRATETHRESHOLD { "separating/lagromory/dualdegeneracyratethreshold" };
6574 constexpr Param<double> VARCONSRATIOTHRESHOLD { "separating/lagromory/varconsratiothreshold" };
6576 constexpr Param<bool> MUPARAMCONST { "separating/lagromory/muparamconst" };
6578 constexpr Param<bool> SEPARATEROWS { "separating/lagromory/separaterows" };
6580 constexpr Param<bool> SORTCUTOFFSOL { "separating/lagromory/sortcutoffsol" };
6582 constexpr Param<bool> SIDETYPEBASIS { "separating/lagromory/sidetypebasis" };
6584 constexpr Param<bool> DYNAMICCUTS { "separating/lagromory/dynamiccuts" };
6586 constexpr Param<bool> MAKEINTEGRAL { "separating/lagromory/makeintegral" };
6588 constexpr Param<bool> FORCECUTS { "separating/lagromory/forcecuts" };
6590 constexpr Param<bool> DELAYEDCUTS { "separating/lagromory/delayedcuts" };
6592 constexpr Param<bool> ALLOWLOCAL { "separating/lagromory/allowlocal" };
6594 constexpr Param<bool> AGGREGATECUTS { "separating/lagromory/aggregatecuts" };
6596 constexpr Param<int> MAXROUNDS { "separating/lagromory/maxrounds" };
6598 constexpr Param<int> MAXROUNDSROOT { "separating/lagromory/maxroundsroot" };
6600 constexpr Param<int> PERROUNDNMAXLPITERS { "separating/lagromory/perroundnmaxlpiters" };
6602 constexpr Param<int> NMAXCUTSPERLP { "separating/lagromory/nmaxcutsperlp" };
6604 constexpr Param<int> NMAXCUTSPERLPROOT { "separating/lagromory/nmaxcutsperlproot" };
6606 constexpr Param<int> NMAXMAINITERS { "separating/lagromory/nmaxmainiters" };
6608 constexpr Param<int> NMAXSUBGRADIENTITERS { "separating/lagromory/nmaxsubgradientiters" };
6610 constexpr Param<int> CUTGENFREQ { "separating/lagromory/cutgenfreq" };
6612 constexpr Param<int> CUTADDFREQ { "separating/lagromory/cutaddfreq" };
6614 constexpr Param<int> NMAXLAGRANGIANVALSFORAVG { "separating/lagromory/nmaxlagrangianvalsforavg" };
6616 constexpr Param<int> NMAXCONSECITERSFORMUUPDATE { "separating/lagromory/nmaxconsecitersformuupdate" };
6619 constexpr Param<int> PROJECTIONTYPE { "separating/lagromory/projectiontype" };
6622 constexpr Param<int> STABILITYCENTERTYPE { "separating/lagromory/stabilitycentertype" };
6624 constexpr Param<int> OPTIMALFACEPRIORITY { "separating/lagromory/optimalfacepriority" };
6627 constexpr Param<int> MINRESTART { "separating/lagromory/minrestart" };
6628}
6630namespace SEPARATING::MCF {
6632 constexpr Param<int> PRIORITY { "separating/mcf/priority" };
6634 constexpr Param<int> FREQ { "separating/mcf/freq" };
6637 constexpr Param<double> MAXBOUNDDIST { "separating/mcf/maxbounddist" };
6639 constexpr Param<bool> DELAY { "separating/mcf/delay" };
6642 constexpr Param<int> EXPBACKOFF { "separating/mcf/expbackoff" };
6644 constexpr Param<int> NCLUSTERS { "separating/mcf/nclusters" };
6646 constexpr Param<double> MAXWEIGHTRANGE { "separating/mcf/maxweightrange" };
6648 constexpr Param<int> MAXTESTDELTA { "separating/mcf/maxtestdelta" };
6650 constexpr Param<bool> TRYNEGSCALING { "separating/mcf/trynegscaling" };
6652 constexpr Param<bool> FIXINTEGRALRHS { "separating/mcf/fixintegralrhs" };
6654 constexpr Param<bool> DYNAMICCUTS { "separating/mcf/dynamiccuts" };
6656 constexpr Param<int> MODELTYPE { "separating/mcf/modeltype" };
6658 constexpr Param<int> MAXSEPACUTS { "separating/mcf/maxsepacuts" };
6660 constexpr Param<int> MAXSEPACUTSROOT { "separating/mcf/maxsepacutsroot" };
6662 constexpr Param<double> MAXINCONSISTENCYRATIO { "separating/mcf/maxinconsistencyratio" };
6664 constexpr Param<double> MAXARCINCONSISTENCYRATIO { "separating/mcf/maxarcinconsistencyratio" };
6666 constexpr Param<bool> CHECKCUTSHORECONNECTIVITY { "separating/mcf/checkcutshoreconnectivity" };
6668 constexpr Param<bool> SEPARATESINGLENODECUTS { "separating/mcf/separatesinglenodecuts" };
6670 constexpr Param<bool> SEPARATEFLOWCUTSET { "separating/mcf/separateflowcutset" };
6672 constexpr Param<bool> SEPARATEKNAPSACK { "separating/mcf/separateknapsack" };
6673}
6675namespace SEPARATING::MINOR {
6677 constexpr Param<int> PRIORITY { "separating/minor/priority" };
6679 constexpr Param<int> FREQ { "separating/minor/freq" };
6682 constexpr Param<double> MAXBOUNDDIST { "separating/minor/maxbounddist" };
6684 constexpr Param<bool> DELAY { "separating/minor/delay" };
6687 constexpr Param<int> EXPBACKOFF { "separating/minor/expbackoff" };
6689 constexpr Param<int> MAXMINORSCONST { "separating/minor/maxminorsconst" };
6691 constexpr Param<double> MAXMINORSFAC { "separating/minor/maxminorsfac" };
6693 constexpr Param<double> MINCUTVIOL { "separating/minor/mincutviol" };
6695 constexpr Param<int> MAXROUNDS { "separating/minor/maxrounds" };
6697 constexpr Param<int> MAXROUNDSROOT { "separating/minor/maxroundsroot" };
6699 constexpr Param<bool> IGNOREPACKINGCONSS { "separating/minor/ignorepackingconss" };
6700}
6702namespace SEPARATING::MIXING {
6704 constexpr Param<int> PRIORITY { "separating/mixing/priority" };
6706 constexpr Param<int> FREQ { "separating/mixing/freq" };
6709 constexpr Param<double> MAXBOUNDDIST { "separating/mixing/maxbounddist" };
6711 constexpr Param<bool> DELAY { "separating/mixing/delay" };
6714 constexpr Param<int> EXPBACKOFF { "separating/mixing/expbackoff" };
6716 constexpr Param<bool> USELOCALBOUNDS { "separating/mixing/uselocalbounds" };
6718 constexpr Param<bool> ISCUTSONINTS { "separating/mixing/iscutsonints" };
6720 constexpr Param<int> MAXROUNDS { "separating/mixing/maxrounds" };
6722 constexpr Param<int> MAXROUNDSROOT { "separating/mixing/maxroundsroot" };
6724 constexpr Param<int> MAXNUNSUCCESSFUL { "separating/mixing/maxnunsuccessful" };
6725}
6727namespace SEPARATING::ODDCYCLE {
6729 constexpr Param<int> PRIORITY { "separating/oddcycle/priority" };
6731 constexpr Param<int> FREQ { "separating/oddcycle/freq" };
6734 constexpr Param<double> MAXBOUNDDIST { "separating/oddcycle/maxbounddist" };
6736 constexpr Param<bool> DELAY { "separating/oddcycle/delay" };
6739 constexpr Param<int> EXPBACKOFF { "separating/oddcycle/expbackoff" };
6742 constexpr Param<bool> USEGLS { "separating/oddcycle/usegls" };
6744 constexpr Param<bool> LIFTODDCYCLES { "separating/oddcycle/liftoddcycles" };
6746 constexpr Param<int> MAXSEPACUTS { "separating/oddcycle/maxsepacuts" };
6748 constexpr Param<int> MAXSEPACUTSROOT { "separating/oddcycle/maxsepacutsroot" };
6750 constexpr Param<int> MAXROUNDS { "separating/oddcycle/maxrounds" };
6752 constexpr Param<int> MAXROUNDSROOT { "separating/oddcycle/maxroundsroot" };
6754 constexpr Param<int> SCALINGFACTOR { "separating/oddcycle/scalingfactor" };
6756 constexpr Param<bool> ADDSELFARCS { "separating/oddcycle/addselfarcs" };
6758 constexpr Param<bool> REPAIRCYCLES { "separating/oddcycle/repaircycles" };
6760 constexpr Param<bool> INCLUDETRIANGLES { "separating/oddcycle/includetriangles" };
6762 constexpr Param<bool> MULTIPLECUTS { "separating/oddcycle/multiplecuts" };
6764 constexpr Param<bool> ALLOWMULTIPLECUTS { "separating/oddcycle/allowmultiplecuts" };
6766 constexpr Param<bool> LPLIFTCOEF { "separating/oddcycle/lpliftcoef" };
6768 constexpr Param<bool> RECALCLIFTCOEF { "separating/oddcycle/recalcliftcoef" };
6770 constexpr Param<int> SORTSWITCH { "separating/oddcycle/sortswitch" };
6772 constexpr Param<bool> SORTROOTNEIGHBORS { "separating/oddcycle/sortrootneighbors" };
6774 constexpr Param<int> PERCENTTESTVARS { "separating/oddcycle/percenttestvars" };
6776 constexpr Param<int> OFFSETTESTVARS { "separating/oddcycle/offsettestvars" };
6778 constexpr Param<int> MAXPERNODESLEVEL { "separating/oddcycle/maxpernodeslevel" };
6780 constexpr Param<int> OFFSETNODESLEVEL { "separating/oddcycle/offsetnodeslevel" };
6782 constexpr Param<int> MAXNLEVELS { "separating/oddcycle/maxnlevels" };
6784 constexpr Param<int> MAXCUTSROOT { "separating/oddcycle/maxcutsroot" };
6786 constexpr Param<int> MAXCUTSLEVEL { "separating/oddcycle/maxcutslevel" };
6788 constexpr Param<int> MAXREFERENCE { "separating/oddcycle/maxreference" };
6790 constexpr Param<int> MAXUNSUCESSFULL { "separating/oddcycle/maxunsucessfull" };
6792 constexpr Param<int> CUTTHRESHOLD { "separating/oddcycle/cutthreshold" };
6793}
6795namespace SEPARATING::RAPIDLEARNING {
6797 constexpr Param<int> PRIORITY { "separating/rapidlearning/priority" };
6799 constexpr Param<int> FREQ { "separating/rapidlearning/freq" };
6802 constexpr Param<double> MAXBOUNDDIST { "separating/rapidlearning/maxbounddist" };
6804 constexpr Param<bool> DELAY { "separating/rapidlearning/delay" };
6807 constexpr Param<int> EXPBACKOFF { "separating/rapidlearning/expbackoff" };
6809 constexpr Param<bool> APPLYCONFLICTS { "separating/rapidlearning/applyconflicts" };
6811 constexpr Param<bool> APPLYBDCHGS { "separating/rapidlearning/applybdchgs" };
6813 constexpr Param<bool> APPLYINFERVALS { "separating/rapidlearning/applyinfervals" };
6815 constexpr Param<bool> REDUCEDINFER { "separating/rapidlearning/reducedinfer" };
6817 constexpr Param<bool> APPLYPRIMALSOL { "separating/rapidlearning/applyprimalsol" };
6819 constexpr Param<bool> APPLYSOLVED { "separating/rapidlearning/applysolved" };
6821 constexpr Param<bool> CHECKDEGENERACY { "separating/rapidlearning/checkdegeneracy" };
6823 constexpr Param<bool> CHECKDUALBOUND { "separating/rapidlearning/checkdualbound" };
6825 constexpr Param<bool> CHECKLEAVES { "separating/rapidlearning/checkleaves" };
6827 constexpr Param<bool> CHECKEXEC { "separating/rapidlearning/checkexec" };
6829 constexpr Param<bool> CHECKOBJ { "separating/rapidlearning/checkobj" };
6831 constexpr Param<bool> CHECKNSOLS { "separating/rapidlearning/checknsols" };
6833 constexpr Param<bool> CONTVARS { "separating/rapidlearning/contvars" };
6835 constexpr Param<double> CONTVARSQUOT { "separating/rapidlearning/contvarsquot" };
6837 constexpr Param<double> LPITERQUOT { "separating/rapidlearning/lpiterquot" };
6839 constexpr Param<double> MINDEGENERACY { "separating/rapidlearning/mindegeneracy" };
6841 constexpr Param<double> MININFLPRATIO { "separating/rapidlearning/mininflpratio" };
6843 constexpr Param<double> MINVARCONSRATIO { "separating/rapidlearning/minvarconsratio" };
6845 constexpr Param<int> MAXNVARS { "separating/rapidlearning/maxnvars" };
6847 constexpr Param<int> MAXNCONSS { "separating/rapidlearning/maxnconss" };
6849 constexpr Param<int> MAXCALLS { "separating/rapidlearning/maxcalls" };
6851 constexpr Param<int> MAXNODES { "separating/rapidlearning/maxnodes" };
6853 constexpr Param<int> MINNODES { "separating/rapidlearning/minnodes" };
6856 constexpr Param<long long> NWAITINGNODES { "separating/rapidlearning/nwaitingnodes" };
6858 constexpr Param<bool> COPYCUTS { "separating/rapidlearning/copycuts" };
6859}
6861namespace SEPARATING::RLT {
6863 constexpr Param<int> PRIORITY { "separating/rlt/priority" };
6865 constexpr Param<int> FREQ { "separating/rlt/freq" };
6868 constexpr Param<double> MAXBOUNDDIST { "separating/rlt/maxbounddist" };
6870 constexpr Param<bool> DELAY { "separating/rlt/delay" };
6873 constexpr Param<int> EXPBACKOFF { "separating/rlt/expbackoff" };
6875 constexpr Param<int> MAXNCUTS { "separating/rlt/maxncuts" };
6877 constexpr Param<int> MAXUNKNOWNTERMS { "separating/rlt/maxunknownterms" };
6879 constexpr Param<int> MAXUSEDVARS { "separating/rlt/maxusedvars" };
6881 constexpr Param<int> MAXROUNDS { "separating/rlt/maxrounds" };
6883 constexpr Param<int> MAXROUNDSROOT { "separating/rlt/maxroundsroot" };
6885 constexpr Param<bool> ONLYEQROWS { "separating/rlt/onlyeqrows" };
6887 constexpr Param<bool> ONLYCONTROWS { "separating/rlt/onlycontrows" };
6889 constexpr Param<bool> ONLYORIGINAL { "separating/rlt/onlyoriginal" };
6891 constexpr Param<bool> USEINSUBSCIP { "separating/rlt/useinsubscip" };
6893 constexpr Param<bool> USEPROJECTION { "separating/rlt/useprojection" };
6895 constexpr Param<bool> DETECTHIDDEN { "separating/rlt/detecthidden" };
6897 constexpr Param<bool> HIDDENRLT { "separating/rlt/hiddenrlt" };
6899 constexpr Param<bool> ADDTOPOOL { "separating/rlt/addtopool" };
6902 constexpr Param<double> GOODSCORE { "separating/rlt/goodscore" };
6904 constexpr Param<double> BADSCORE { "separating/rlt/badscore" };
6906 constexpr Param<double> OBJPARALWEIGHT { "separating/rlt/objparalweight" };
6908 constexpr Param<double> EFFICACYWEIGHT { "separating/rlt/efficacyweight" };
6910 constexpr Param<double> DIRCUTOFFDISTWEIGHT { "separating/rlt/dircutoffdistweight" };
6912 constexpr Param<double> GOODMAXPARALL { "separating/rlt/goodmaxparall" };
6914 constexpr Param<double> MAXPARALL { "separating/rlt/maxparall" };
6915}
6917namespace SEPARATING::STRONGCG {
6919 constexpr Param<int> PRIORITY { "separating/strongcg/priority" };
6921 constexpr Param<int> FREQ { "separating/strongcg/freq" };
6924 constexpr Param<double> MAXBOUNDDIST { "separating/strongcg/maxbounddist" };
6926 constexpr Param<bool> DELAY { "separating/strongcg/delay" };
6929 constexpr Param<int> EXPBACKOFF { "separating/strongcg/expbackoff" };
6930}
6932namespace SEPARATING::ZEROHALF {
6934 constexpr Param<int> PRIORITY { "separating/zerohalf/priority" };
6936 constexpr Param<int> FREQ { "separating/zerohalf/freq" };
6939 constexpr Param<double> MAXBOUNDDIST { "separating/zerohalf/maxbounddist" };
6941 constexpr Param<bool> DELAY { "separating/zerohalf/delay" };
6944 constexpr Param<int> EXPBACKOFF { "separating/zerohalf/expbackoff" };
6946 constexpr Param<int> MAXROUNDS { "separating/zerohalf/maxrounds" };
6948 constexpr Param<int> MAXROUNDSROOT { "separating/zerohalf/maxroundsroot" };
6950 constexpr Param<int> MAXSEPACUTS { "separating/zerohalf/maxsepacuts" };
6952 constexpr Param<int> INITSEED { "separating/zerohalf/initseed" };
6954 constexpr Param<int> MAXSEPACUTSROOT { "separating/zerohalf/maxsepacutsroot" };
6956 constexpr Param<int> MAXCUTCANDS { "separating/zerohalf/maxcutcands" };
6958 constexpr Param<double> MAXSLACK { "separating/zerohalf/maxslack" };
6960 constexpr Param<double> MAXSLACKROOT { "separating/zerohalf/maxslackroot" };
6963 constexpr Param<double> GOODSCORE { "separating/zerohalf/goodscore" };
6965 constexpr Param<double> BADSCORE { "separating/zerohalf/badscore" };
6967 constexpr Param<double> OBJPARALWEIGHT { "separating/zerohalf/objparalweight" };
6969 constexpr Param<double> EFFICACYWEIGHT { "separating/zerohalf/efficacyweight" };
6971 constexpr Param<double> DIRCUTOFFDISTWEIGHT { "separating/zerohalf/dircutoffdistweight" };
6973 constexpr Param<double> GOODMAXPARALL { "separating/zerohalf/goodmaxparall" };
6975 constexpr Param<double> MAXPARALL { "separating/zerohalf/maxparall" };
6977 constexpr Param<double> MINVIOL { "separating/zerohalf/minviol" };
6979 constexpr Param<bool> DYNAMICCUTS { "separating/zerohalf/dynamiccuts" };
6981 constexpr Param<double> MAXROWDENSITY { "separating/zerohalf/maxrowdensity" };
6983 constexpr Param<int> DENSITYOFFSET { "separating/zerohalf/densityoffset" };
6984}
6986namespace SOLVINGPHASES {
6988 constexpr Param<bool> ENABLED { "solvingphases/enabled" };
6990 constexpr Param<bool> TESTMODE { "solvingphases/testmode" };
6992 constexpr Param<std::string> FEASSETNAME { "solvingphases/feassetname" };
6994 constexpr Param<std::string> IMPROVESETNAME { "solvingphases/improvesetname" };
6996 constexpr Param<std::string> PROOFSETNAME { "solvingphases/proofsetname" };
6998 constexpr Param<long long> NODEOFFSET { "solvingphases/nodeoffset" };
7000 constexpr Param<bool> FALLBACK { "solvingphases/fallback" };
7002 constexpr Param<char> TRANSITIONMETHOD { "solvingphases/transitionmethod" };
7004 constexpr Param<bool> INTERRUPTOPTIMAL { "solvingphases/interruptoptimal" };
7006 constexpr Param<bool> USERESTART1TO2 { "solvingphases/userestart1to2" };
7008 constexpr Param<bool> USERESTART2TO3 { "solvingphases/userestart2to3" };
7010 constexpr Param<double> OPTIMALVALUE { "solvingphases/optimalvalue" };
7012 constexpr Param<char> XTYPE { "solvingphases/xtype" };
7014 constexpr Param<bool> USEEMPHSETTINGS { "solvingphases/useemphsettings" };
7015}
7017namespace TABLE::BENDERS {
7019 constexpr Param<bool> ACTIVE { "table/benders/active" };
7020}
7022namespace TABLE::BRANCHRULES {
7024 constexpr Param<bool> ACTIVE { "table/branchrules/active" };
7025}
7027namespace TABLE::COMPRESSION {
7029 constexpr Param<bool> ACTIVE { "table/compression/active" };
7030}
7032namespace TABLE::CONCURRENTSOLVER {
7034 constexpr Param<bool> ACTIVE { "table/concurrentsolver/active" };
7035}
7037namespace TABLE::CONFLICT {
7039 constexpr Param<bool> ACTIVE { "table/conflict/active" };
7040}
7042namespace TABLE::CONSTIMING {
7044 constexpr Param<bool> ACTIVE { "table/constiming/active" };
7045}
7047namespace TABLE::CONSTRAINT {
7049 constexpr Param<bool> ACTIVE { "table/constraint/active" };
7050}
7052namespace TABLE::CONS_NONLINEAR {
7054 constexpr Param<bool> ACTIVE { "table/cons_nonlinear/active" };
7055}
7057namespace TABLE::CUTSEL {
7059 constexpr Param<bool> ACTIVE { "table/cutsel/active" };
7060}
7062namespace TABLE::ESTIM {
7064 constexpr Param<bool> ACTIVE { "table/estim/active" };
7065}
7067namespace TABLE::EXPRHDLR {
7069 constexpr Param<bool> ACTIVE { "table/exprhdlr/active" };
7070}
7072namespace TABLE::HEURISTICS {
7074 constexpr Param<bool> ACTIVE { "table/heuristics/active" };
7075}
7077namespace TABLE::LP {
7079 constexpr Param<bool> ACTIVE { "table/lp/active" };
7080}
7082namespace TABLE::NEIGHBORHOOD {
7084 constexpr Param<bool> ACTIVE { "table/neighborhood/active" };
7085}
7087namespace TABLE::NLHDLR {
7089 constexpr Param<bool> ACTIVE { "table/nlhdlr/active" };
7090}
7092namespace TABLE::NLHDLR_BILINEAR {
7094 constexpr Param<bool> ACTIVE { "table/nlhdlr_bilinear/active" };
7095}
7097namespace TABLE::NLHDLR_QUADRATIC {
7099 constexpr Param<bool> ACTIVE { "table/nlhdlr_quadratic/active" };
7100}
7102namespace TABLE::NLP {
7104 constexpr Param<bool> ACTIVE { "table/nlp/active" };
7105}
7107namespace TABLE::NLPI {
7109 constexpr Param<bool> ACTIVE { "table/nlpi/active" };
7110}
7112namespace TABLE::ORIGPROB {
7114 constexpr Param<bool> ACTIVE { "table/origprob/active" };
7115}
7117namespace TABLE::PRESOLVEDPROB {
7119 constexpr Param<bool> ACTIVE { "table/presolvedprob/active" };
7120}
7122namespace TABLE::PRESOLVER {
7124 constexpr Param<bool> ACTIVE { "table/presolver/active" };
7125}
7127namespace TABLE::PRICER {
7129 constexpr Param<bool> ACTIVE { "table/pricer/active" };
7130}
7132namespace TABLE::PROPAGATOR {
7134 constexpr Param<bool> ACTIVE { "table/propagator/active" };
7135}
7137namespace TABLE::RELAXATOR {
7139 constexpr Param<bool> ACTIVE { "table/relaxator/active" };
7140}
7142namespace TABLE::ROOT {
7144 constexpr Param<bool> ACTIVE { "table/root/active" };
7145}
7147namespace TABLE::SCHEDULER {
7149 constexpr Param<bool> ACTIVE { "table/scheduler/active" };
7150}
7152namespace TABLE::SEPARATOR {
7154 constexpr Param<bool> ACTIVE { "table/separator/active" };
7155}
7157namespace TABLE::SOLUTION {
7159 constexpr Param<bool> ACTIVE { "table/solution/active" };
7160}
7162namespace TABLE::STATUS {
7164 constexpr Param<bool> ACTIVE { "table/status/active" };
7165}
7167namespace TABLE::SYMMETRY {
7169 constexpr Param<bool> ACTIVE { "table/symmetry/active" };
7170}
7172namespace TABLE::TIMING {
7174 constexpr Param<bool> ACTIVE { "table/timing/active" };
7175}
7177namespace TABLE::TREE {
7179 constexpr Param<bool> ACTIVE { "table/tree/active" };
7180}
7182namespace TIMING {
7184 constexpr Param<int> CLOCKTYPE { "timing/clocktype" };
7186 constexpr Param<bool> ENABLED { "timing/enabled" };
7188 constexpr Param<bool> READING { "timing/reading" };
7190 constexpr Param<bool> RARECLOCKCHECK { "timing/rareclockcheck" };
7192 constexpr Param<bool> STATISTICTIMING { "timing/statistictiming" };
7194 constexpr Param<bool> NLPIEVAL { "timing/nlpieval" };
7195}
7197namespace VISUAL {
7199 constexpr Param<std::string> VBCFILENAME { "visual/vbcfilename" };
7201 constexpr Param<std::string> BAKFILENAME { "visual/bakfilename" };
7203 constexpr Param<bool> REALTIME { "visual/realtime" };
7205 constexpr Param<bool> DISPSOLS { "visual/dispsols" };
7207 constexpr Param<bool> DISPLB { "visual/displb" };
7209 constexpr Param<bool> OBJEXTERN { "visual/objextern" };
7210}
7212namespace WRITE {
7214 constexpr Param<bool> ALLCONSS { "write/allconss" };
7216 constexpr Param<bool> PRINTZEROS { "write/printzeros" };
7218 constexpr Param<int> GENERICNAMESOFFSET { "write/genericnamesoffset" };
7219}
7220
7221// NOLINTEND(readability-identifier-naming)
7222
7223}
constexpr Param< int > PRIORITY
priority of Benders' cut <feasalt>
constexpr Param< bool > ENABLED
is this Benders' decomposition cut method used to generate cuts?
constexpr Param< int > PRIORITY
priority of Benders' cut <feas>
constexpr Param< bool > ENABLED
is this Benders' decomposition cut method used to generate cuts?
constexpr Param< bool > ENABLED
is this Benders' decomposition cut method used to generate cuts?
constexpr Param< double > CUTSCONSTANT
the constant term of the integer Benders' cuts.
constexpr Param< bool > ADDCUTS
should cuts be generated and added to the cutpool instead of global constraints directly added to the...
constexpr Param< int > PRIORITY
priority of Benders' cut <integer>
constexpr Param< int > PRIORITY
priority of Benders' cut <nogood>
constexpr Param< bool > ENABLED
is this Benders' decomposition cut method used to generate cuts?
constexpr Param< bool > ADDCUTS
should cuts be generated and added to the cutpool instead of global constraints directly added to the...
constexpr Param< bool > ENABLED
is this Benders' decomposition cut method used to generate cuts?
constexpr Param< int > PRIORITY
priority of Benders' cut <optimality>
constexpr Param< bool > ADDCUTS
should cuts be generated and added to the cutpool instead of global constraints directly added to the...
constexpr Param< bool > MIR
should the mixed integer rounding procedure be applied to cuts
constexpr Param< bool > CUTCHECK
should Benders' cuts be generated while checking solutions?
constexpr Param< int > PRIORITY
priority of Benders' decomposition <default>
constexpr Param< bool > CUTPSEUDO
should Benders' cuts be generated for pseudo solutions?
constexpr Param< double > MAXSLACKVARCOEF
the maximal objective coefficient of the slack variables in the subproblem
constexpr Param< char > CUTSTRENGTHENINTPOINT
where should the strengthening interior point be sourced from ('l'p relaxation, 'f'irst solution,...
constexpr Param< bool > CUTLP
should Benders' cuts be generated for LP solutions?
constexpr Param< bool > LNSCHECK
should Benders' decomposition be used in LNS heurisics?
constexpr Param< bool > AUXVARSIMPLINT
if the subproblem objective is integer, then define the auxiliary variables as implicit integers?
constexpr Param< int > NUMTHREADS
the number of threads to use when solving the subproblems
constexpr Param< double > COREPOINTPERTURB
the constant use to perturb the cut strengthening core point
constexpr Param< int > LNSMAXCALLS
the maximum number of Benders' decomposition calls in LNS heuristics (-1: no limit)
constexpr Param< bool > CHECKCONSCONVEXITY
should the constraints of the subproblems be checked for convexity?
constexpr Param< bool > EXECFEASPHASE
should a feasibility phase be executed during the root node, i.e.
constexpr Param< bool > TRANSFERCUTS
should Benders' cuts from LNS heuristics be transferred to the main SCIP instance?
constexpr Param< double > CUTSTRENGTHENMULT
the convex combination multiplier for the cut strengthening
constexpr Param< bool > CUTRELAX
should Benders' cuts be generated for relaxation solutions?
constexpr Param< bool > CUTSTRENGTHENENABLED
should the core point cut strengthening be employed (only applied to fractional solutions or continuo...
constexpr Param< int > LNSMAXCALLSROOT
the maximum number of root node Benders' decomposition calls in LNS heuristics (-1: no limit)
constexpr Param< int > NOIMPROVELIMIT
the maximum number of cut strengthening without improvement
constexpr Param< bool > CUTSASCONSS
should the transferred cuts be added as constraints?
constexpr Param< bool > UPDATEAUXVARBOUND
should the auxiliary variable bound be updated by solving the subproblem?
constexpr Param< int > LNSMAXDEPTH
maximum depth at which the LNS check is performed (-1: no limit)
constexpr Param< double > SLACKVARCOEF
the initial objective coefficient of the slack variables in the subproblem
constexpr Param< double > SUBPROBFRAC
fraction of subproblems that are solved in each iteration
constexpr Param< int > NLPITERLIMIT
iteration limit for NLP solver
constexpr Param< bool > COPYBENDERS
should Benders' decomposition be copied for use in sub-SCIPs?
constexpr Param< bool > CUTLPSOL
should Benders' cuts be generated from the solution to the LP relaxation?
constexpr Param< double > SOLUTIONTOL
the tolerance used for checking optimality in Benders' decomposition.
constexpr Param< int > MAXDEPTH
maximal depth level, up to which branching rule <allfullstrong> should be used (-1 for no limit)
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< int > PRIORITY
priority of branching rule <allfullstrong>
constexpr Param< double > MINSUCCESSRATE
minimum success rate for the cloud
constexpr Param< bool > USECLOUD
should a cloud of points be used?
constexpr Param< double > MINSUCCESSUNION
minimum success rate for the union
constexpr Param< int > PRIORITY
priority of branching rule <cloud>
constexpr Param< bool > ONLYF2
should only F2 be used?
constexpr Param< bool > USEUNION
should the union of candidates be used?
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< int > MAXPOINTS
maximum number of points for the cloud (-1 means no limit)
constexpr Param< int > MAXDEPTHUNION
maximum depth for the union
constexpr Param< int > MAXDEPTH
maximal depth level, up to which branching rule <cloud> should be used (-1 for no limit)
constexpr Param< int > PRIORITY
priority of branching rule <distribution>
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< char > SCOREPARAM
the score;largest 'd'ifference, 'l'owest cumulative probability,'h'ighest c.p., 'v'otes lowest c....
constexpr Param< int > MAXDEPTH
maximal depth level, up to which branching rule <distribution> should be used (-1 for no limit)
constexpr Param< bool > WEIGHTEDSCORE
should the branching score weigh up- and down-scores of a variable
constexpr Param< bool > ONLYACTIVEROWS
should only rows which are active at the current node be considered?
constexpr Param< bool > PROBINGBOUNDS
should valid bounds be identified in a probing-like fashion during strong branching (only with propag...
constexpr Param< int > MAXPROPROUNDS
maximum number of propagation rounds to be performed during strong branching before solving the LP (-...
constexpr Param< int > MAXDEPTH
maximal depth level, up to which branching rule <fullstrong> should be used (-1 for no limit)
constexpr Param< int > PRIORITY
priority of branching rule <fullstrong>
constexpr Param< bool > FORCESTRONGBRANCH
should strong branching be applied even if there is just a single candidate?
constexpr Param< long long > REEVALAGE
number of intermediate LPs solved to trigger reevaluation of strong branching value for a variable th...
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< int > MAXDEPTH
maximal depth level, up to which branching rule <gomory> should be used (-1 for no limit)
constexpr Param< double > EFFICACYWEIGHT
weight of efficacy in the weighted sum cut scoring rule
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< int > MAXNCANDS
maximum amount of branching candidates to generate Gomory cuts for (-1: all candidates)
constexpr Param< double > INTSUPPORTWEIGHT
weight of integer support in the weighted sum cut scoring rule
constexpr Param< bool > PERFORMRELPSCOST
whether relpscost branching should be called without branching (used for bound inferences and conflic...
constexpr Param< bool > USEWEAKERCUTS
use weaker cuts that are exactly derived from the branching split disjunction
constexpr Param< double > OBJPARALLELWEIGHT
weight of objective parallelism in the weighted sum cut scoring rule
constexpr Param< int > PRIORITY
priority of branching rule <gomory>
constexpr Param< double > CUTOFFWEIGHT
weight in score calculations for cutoff score
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< double > RELIABLESCORE
weight in score calculations for conflict score
constexpr Param< double > INFERENCEWEIGHT
weight in score calculations for inference score
constexpr Param< bool > FRACTIONALS
should branching on LP solution be restricted to the fractional variables?
constexpr Param< int > MAXDEPTH
maximal depth level, up to which branching rule <inference> should be used (-1 for no limit)
constexpr Param< int > CONFLICTPRIO
priority value for using conflict weights in lex. order
constexpr Param< int > PRIORITY
priority of branching rule <inference>
constexpr Param< int > CUTOFFPRIO
priority value for using cutoff weights in lex. order
constexpr Param< double > CONFLICTWEIGHT
weight in score calculations for conflict score
constexpr Param< bool > USEWEIGHTEDSUM
should a weighted sum of inference, conflict and cutoff weights be used?
constexpr Param< int > MAXDEPTH
maximal depth level, up to which branching rule <leastinf> should be used (-1 for no limit)
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< int > PRIORITY
priority of branching rule <leastinf>
constexpr Param< int > MAXDEPTH
maximal depth level, up to which branching rule <lookahead> should be used (-1 for no limit)
constexpr Param< bool > LEVEL2ZEROSCORE
should uninitialized scores in level 2 be set to 0?
constexpr Param< int > ADDBINCONSROW
should binary constraints be added as rows to the base LP? (0: no, 1: separate, 2: as initial rows)
constexpr Param< bool > LEVEL2AVGSCORE
should the average score be used for uninitialized scores in level 2?
constexpr Param< bool > REUSEBASIS
if abbreviated: Should the information gathered to obtain the best candidates be reused?
constexpr Param< bool > APPLYCHILDBOUNDS
should bounds known for child nodes be applied?
constexpr Param< bool > ABBREVIATED
toggles the abbreviated LAB.
constexpr Param< double > MINWEIGHT
if scoringfunction is 's', this value is used to weight the min of the gains of two child problems in...
constexpr Param< int > MAXNDEEPERCANDS
if abbreviated: The max number of candidates to consider per deeper node.
constexpr Param< long long > REEVALAGE
max number of LPs solved after which a previous prob branching results are recalculated
constexpr Param< int > MAXPROPROUNDS
maximum number of propagation rounds to perform at each temporary node (-1: unlimited,...
constexpr Param< bool > FILTERBYMAXGAIN
should lookahead branching only be applied if the max gain in level 1 is not uniquely that of the bes...
constexpr Param< bool > PROPAGATE
should domain propagation be executed before each temporary node is solved?
constexpr Param< bool > ADDNONVIOCONS
should binary constraints, that are not violated by the base LP, be collected and added?
constexpr Param< bool > STOREUNVIOLATEDSOL
if only non violating constraints are added, should the branching decision be stored till the next ca...
constexpr Param< bool > USEIMPLIEDBINCONS
should binary constraints be collected and applied?
constexpr Param< bool > MERGEDOMAINREDUCTIONS
should domain reductions of feasible siblings should be merged?
constexpr Param< bool > ADDCLIQUE
add binary constraints with two variables found at the root node also as a clique
constexpr Param< char > SCORINGFUNCTION
scoring function to be used at the base level
constexpr Param< int > MAXNVIOLATEDCONS
how many constraints that are violated by the base lp solution should be gathered until the rule is s...
constexpr Param< bool > USEDOMAINREDUCTION
should domain reductions be collected and applied?
constexpr Param< bool > UPDATEBRANCHINGRESULTS
should branching results (and scores) be updated w.r.t. proven dual bounds?
constexpr Param< bool > PREFERSIMPLEBOUNDS
should domain reductions only be applied if there are simple bound changes?
constexpr Param< char > DEEPERSCORINGFUNCTION
scoring function to be used at deeper levels
constexpr Param< bool > USELEVEL2DATA
should branching data generated at depth level 2 be stored for re-using it?
constexpr Param< int > MAXNCANDS
if abbreviated: The max number of candidates to consider at the node.
constexpr Param< bool > ENFORCEMAXDOMREDS
should the maximum number of domain reductions maxnviolateddomreds be enforced?
constexpr Param< int > MAXNVIOLATEDDOMREDS
how many domain reductions that are violated by the base lp solution should be gathered until the rul...
constexpr Param< bool > ONLYVIOLDOMREDS
should only domain reductions that violate the LP solution be applied?
constexpr Param< int > PRIORITY
priority of branching rule <lookahead>
constexpr Param< int > RECURSIONDEPTH
the max depth of LAB.
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< long long > REEVALAGEFSB
max number of LPs solved after which a previous FSB scoring results are recalculated
constexpr Param< double > WORSEFACTOR
if the FSB score is of a candidate is worse than the best by this factor, skip this candidate (-1: di...
constexpr Param< bool > ABBREVPSEUDO
if abbreviated: Use pseudo costs to estimate the score of a candidate.
constexpr Param< int > MAXNVIOLATEDBINCONS
how many binary constraints that are violated by the base lp solution should be gathered until the ru...
constexpr Param< char > SCORINGSCORINGFUNCTION
scoring function to be used during FSB scoring
constexpr Param< int > MAXDEPTH
maximal depth level, up to which branching rule <mostinf> should be used (-1 for no limit)
constexpr Param< int > PRIORITY
priority of branching rule <mostinf>
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< long long > REEVALAGE
number of intermediate LPs solved to trigger reevaluation of strong branching value for a variable th...
constexpr Param< int > MAXPROPROUNDS
maximum number of propagation rounds to be performed during multaggr branching before solving the LP ...
constexpr Param< int > PRIORITY
priority of branching rule <multaggr>
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< bool > PROBINGBOUNDS
should valid bounds be identified in a probing-like fashion during multaggr branching (only with prop...
constexpr Param< int > MAXDEPTH
maximal depth level, up to which branching rule <multaggr> should be used (-1 for no limit)
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< int > PRIORITY
priority of branching rule <nodereopt>
constexpr Param< int > MAXDEPTH
maximal depth level, up to which branching rule <nodereopt> should be used (-1 for no limit)
constexpr Param< double > MINSCOREWEIGHT
weight for minimum of scores of a branching candidate when building weighted sum of min/max/sum of sc...
constexpr Param< double > NARYMINWIDTH
minimal domain width in children when doing n-ary branching, relative to global bounds
constexpr Param< int > NARYMAXDEPTH
maximal depth where to do n-ary branching, -1 to turn off
constexpr Param< char > STRATEGY
strategy for utilizing pseudo-costs of external branching candidates (multiply as in pseudo costs 'u'...
constexpr Param< double > NARYWIDTHFACTOR
factor of domain width in n-ary branching when creating nodes with increasing distance from branching...
constexpr Param< int > NCHILDREN
number of children to create in n-ary branching
constexpr Param< int > MAXDEPTH
maximal depth level, up to which branching rule <pscost> should be used (-1 for no limit)
constexpr Param< int > PRIORITY
priority of branching rule <pscost>
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< double > SUMSCOREWEIGHT
weight for sum of scores of a branching candidate when building weighted sum of min/max/sum of scores
constexpr Param< double > MAXSCOREWEIGHT
weight for maximum of scores of a branching candidate when building weighted sum of min/max/sum of sc...
constexpr Param< int > SEED
initial random seed value
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< int > MAXDEPTH
maximal depth level, up to which branching rule <random> should be used (-1 for no limit)
constexpr Param< int > PRIORITY
priority of branching rule <random>
constexpr Param< int > MAXPROPROUNDS
maximum number of propagation rounds to be performed during strong branching before solving the LP (-...
constexpr Param< bool > FILTERCANDSSYM
Use symmetry to filter branching candidates?
constexpr Param< int > MAXBDCHGS
maximal number of bound tightenings before the node is reevaluated (-1: unlimited)
constexpr Param< double > SBITERQUOT
maximal fraction of strong branching LP iterations compared to node relaxation LP iterations
constexpr Param< double > LOWERRORTOL
low relative error tolerance for reliability
constexpr Param< int > MAXLOOKAHEAD
maximal number of further variables evaluated without better score
constexpr Param< double > MAXRELIABLE
maximal value for minimum pseudo cost size to regard pseudo cost value as reliable
constexpr Param< bool > TRANSSYMPSCOST
Transfer pscost information to symmetric variables?
constexpr Param< int > CONFIDENCELEVEL
the confidence level for statistical methods, between 0 (Min) and 4 (Max).
constexpr Param< bool > USERELERRORRELIABILITY
should reliability be based on relative errors?
constexpr Param< bool > USESMALLWEIGHTSITLIM
should smaller weights be used for pseudo cost updates after hitting the LP iteration limit?
constexpr Param< int > INITITER
iteration limit for strong branching initializations of pseudo cost entries (0: auto)
constexpr Param< bool > PROBINGBOUNDS
should valid bounds be identified in a probing-like fashion during strong branching (only with propag...
constexpr Param< bool > RANDINITORDER
should candidates be initialized in randomized order?
constexpr Param< int > PRIORITY
priority of branching rule <relpscost>
constexpr Param< double > PSCOSTWEIGHT
weight in score calculations for pseudo cost score
constexpr Param< bool > STORESEMIINITCOSTS
should strong branching result be considered for pseudo costs if the other direction was infeasible?
constexpr Param< double > MINRELIABLE
minimal value for minimum pseudo cost size to regard pseudo cost value as reliable
constexpr Param< int > INITCAND
maximal number of candidates initialized with strong branching per node
constexpr Param< double > GMILASTEFFWEIGHT
weight in score calculations for last GMI cuts normalized efficacy
constexpr Param< bool > USEDYNAMICCONFIDENCE
should the confidence level be adjusted dynamically?
constexpr Param< bool > USESBLOCALINFO
should the scoring function use only local cutoff and inference information obtained for strong branc...
constexpr Param< double > HIGHERRORTOL
high relative error tolerance for reliability
constexpr Param< double > GMIAVGEFFWEIGHT
weight in score calculations for average GMI cuts normalized efficacy
constexpr Param< int > STARTRANDSEED
start seed for random number generation
constexpr Param< double > CONFLICTWEIGHT
weight in score calculations for conflict score
constexpr Param< int > DEGENERACYAWARE
should degeneracy be taken into account to update weights and skip strong branching?...
constexpr Param< double > NLSCOREWEIGHT
weight in score calculations for nlcount score
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< bool > USEHYPTESTFORRELIABILITY
should the strong branching decision be based on a hypothesis test?
constexpr Param< double > INFERENCEWEIGHT
weight in score calculations for inference score
constexpr Param< int > SBITEROFS
additional number of allowed strong branching LP iterations
constexpr Param< int > MAXDEPTH
maximal depth level, up to which branching rule <relpscost> should be used (-1 for no limit)
constexpr Param< bool > DYNAMICWEIGHTS
should the weights of the branching rule be adjusted dynamically during solving based on objective an...
constexpr Param< double > CONFLICTLENGTHWEIGHT
weight in score calculations for conflict length score
constexpr Param< bool > SKIPBADINITCANDS
should branching rule skip candidates that have a low probability to be better than the best strong-b...
constexpr Param< double > CUTOFFWEIGHT
weight in score calculations for cutoff score
constexpr Param< int > MAXFPITER
maximum number of fixed-point iterations when computing the ratio
constexpr Param< char > FALLBACKINF
which method should be used as a fallback if the tree size estimates are infinite?...
constexpr Param< char > FILTERLOW
should dominated candidates be filtered before using the low scoring function? ('a'uto,...
constexpr Param< bool > ENABLE
should candidate branching variables be scored using the Treemodel branching rules?
constexpr Param< char > FALLBACKNOPRIM
which method should be used as a fallback if there is no primal bound available? ('d'efault,...
constexpr Param< int > MAXSVTSHEIGHT
maximum height to compute the SVTS score exactly before approximating
constexpr Param< char > FILTERHIGH
should dominated candidates be filtered before using the high scoring function? ('a'uto,...
constexpr Param< int > HEIGHT
estimated tree height at which we switch from using the low rule to the high rule
constexpr Param< char > LOWRULE
scoring function to use at nodes predicted to be low in the tree ('d'efault, 's'vts,...
constexpr Param< char > HIGHRULE
scoring function to use at nodes predicted to be high in the tree ('d'efault, 's'vts,...
constexpr Param< double > SMALLPSCOST
threshold at which pseudocosts are considered small, making hybrid scores more likely to be the decid...
constexpr Param< bool > IDEMPOTENT
should strong branching side-effects be prevented (e.g., domain changes, stat updates etc....
constexpr Param< bool > INTEGRALCANDS
should integral variables in the current LP solution be considered as branching candidates?
constexpr Param< bool > DONOTBRANCH
should candidates only be scored, but no branching be performed?
constexpr Param< int > PRIORITY
priority of branching rule <vanillafullstrong>
constexpr Param< int > MAXDEPTH
maximal depth level, up to which branching rule <vanillafullstrong> should be used (-1 for no limit)
constexpr Param< bool > COLLECTSCORES
should strong branching scores be collected?
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< bool > SCOREALL
should strong branching scores be computed for all candidates, or can we early stop when a variable h...
constexpr Param< double > MIDPULLRELDOMTRIG
multiply midpull by relative domain width if the latter is below this value
constexpr Param< bool > CHECKSOL
should LP solutions during strong branching with propagation be checked for feasibility?
constexpr Param< bool > ROUNDSBSOL
should LP solutions during strong branching with propagation be rounded? (only when checksbsol=TRUE)
constexpr Param< bool > PREFERBINARY
should branching on binary variables be preferred?
constexpr Param< char > LPGAINNORMALIZE
strategy for normalization of LP gain when updating pseudocosts of continuous variables (divide by mo...
constexpr Param< bool > SUMADJUSTSCORE
score adjustment near zero by adding epsilon (TRUE) or using maximum (FALSE)
constexpr Param< char > SCOREFUNC
branching score function ('s'um, 'p'roduct, 'q'uotient)
constexpr Param< double > CLAMP
minimal relative distance of branching point to bounds when branching on a continuous variable
constexpr Param< bool > DIVINGPSCOST
should pseudo costs be updated also in diving and probing mode?
constexpr Param< double > MIDPULL
fraction by which to move branching point of a continuous variable towards the middle of the domain; ...
constexpr Param< bool > DELAYPSCOSTUPDATE
should updating pseudo costs for continuous variables be delayed to the time after separation?
constexpr Param< bool > FORCEALLCHILDREN
should all strong branching children be regarded even if one is detected to be infeasible?...
constexpr Param< double > SCOREFAC
branching score factor to weigh downward and upward gain prediction in sum score function
constexpr Param< char > FIRSTSBCHILD
child node to be regarded first during strong branching (only with propagation): 'u'p child,...
constexpr Param< int > MINCOMMONVARS
minimal number of common variables.
constexpr Param< int > PRIORITY
priority of compression <largestrepr>
constexpr Param< int > ITERATIONS
number of runs in the constrained part.
constexpr Param< int > MINNLEAVES
minimal number of leave nodes for calling tree compression <largestrepr>
constexpr Param< int > PRIORITY
priority of compression <weakcompr>
constexpr Param< bool > CONVERTCONSS
convert constraints into nodes
constexpr Param< int > MINNLEAVES
minimal number of leave nodes for calling tree compression <weakcompr>
constexpr Param< bool > ENABLE
should automatic tree compression after the presolving be enabled?
constexpr Param< double > PREFPRIO
the preferred number concurrent solvers of type <scip-counter> with respect to the number of threads
constexpr Param< double > PREFPRIO
the preferred number concurrent solvers of type <scip-cpsolver> with respect to the number of threads
constexpr Param< double > PREFPRIO
the preferred number concurrent solvers of type <scip-default> with respect to the number of threads
constexpr Param< double > PREFPRIO
the preferred number concurrent solvers of type <scip-easycip> with respect to the number of threads
constexpr Param< double > PREFPRIO
the preferred number concurrent solvers of type <scip-feas> with respect to the number of threads
constexpr Param< double > PREFPRIO
the preferred number concurrent solvers of type <scip-hardlp> with respect to the number of threads
constexpr Param< double > PREFPRIO
the preferred number concurrent solvers of type <scip-opti> with respect to the number of threads
constexpr Param< double > PREFPRIO
the preferred number concurrent solvers of type <scip> with respect to the number of threads
constexpr Param< double > MINSYNCDELAY
minimum delay before synchronization data is read
constexpr Param< int > NBESTSOLS
how many of the N best solutions should be considered for synchronization?
constexpr Param< double > FREQMAX
maximal frequency of synchronization with other threads
constexpr Param< int > MAXNSOLS
maximum number of solutions that will be shared in a single synchronization
constexpr Param< double > FREQINIT
initial frequency of synchronization with other threads
constexpr Param< double > FREQFACTOR
factor by which the frequency of synchronization is changed
constexpr Param< double > TARGETPROGRESS
when adapting the synchronization frequency this value is the targeted relative difference by which t...
constexpr Param< int > MAXNSYNCDELAY
maximum number of synchronizations before reading is enforced regardless of delay
constexpr Param< bool > PRESOLVEBEFORE
should the problem be presolved before it is copied to the concurrent solvers?
constexpr Param< bool > CHANGECHILDSEL
use different child selection rules in each concurrent solver?
constexpr Param< bool > COMMVARBNDS
should the concurrent solvers communicate global variable bound changes?
constexpr Param< std::string > PARAMSETPREFIX
path prefix for parameter setting files of concurrent solvers
constexpr Param< bool > CHANGESEEDS
set different random seeds in each concurrent solver?
constexpr Param< int > INITSEED
maximum number of solutions that will be shared in a one synchronization
constexpr Param< double > CONTINUOUSFRAC
maximal percantage of continuous variables within a conflict
constexpr Param< int > PRIORITY
priority of conflict handler <bounddisjunction>
constexpr Param< double > DEPTHSCOREFAC
score factor for depth level in bound relaxation heuristic
constexpr Param< int > PRIORITY
priority of conflict handler <indicatorconflict>
constexpr Param< int > PRIORITY
priority of conflict handler <linear>
constexpr Param< int > PRIORITY
priority of conflict handler <logicor>
constexpr Param< int > PRIORITY
priority of conflict handler <setppc>
constexpr Param< bool > USESB
should infeasible/bound exceeding strong branching conflict analysis be used?
constexpr Param< bool > SEPARATE
should the conflict constraints be separated?
constexpr Param< double > WEIGHTREPROPDEPTH
weight of the repropagation depth of a conflict used in score calculation
constexpr Param< bool > REMOVABLE
should the conflict's relaxations be subject to LP aging and cleanup?
constexpr Param< bool > SETTLELOCAL
should conflict constraints be attached only to the local subtree where they can be useful?
constexpr Param< bool > USEPROP
should propagation conflict analysis be used?
constexpr Param< double > DOWNLOCKSCOREFAC
score factor for down locks in bound relaxation heuristic
constexpr Param< int > MINMAXVARS
minimal absolute maximum of variables involved in a conflict constraint
constexpr Param< int > MAXVARSDETECTIMPLIEDBOUNDS
maximal number of variables to try to detect global bound implications and shorten the whole conflict...
constexpr Param< bool > ALLOWLOCAL
should conflict constraints be generated that are only valid locally?
constexpr Param< double > MAXVARSFAC
maximal fraction of variables involved in a conflict constraint
constexpr Param< bool > SEPAALTPROOFS
apply cut generating functions to construct alternative proofs
constexpr Param< bool > CLEANBOUNDEXCEEDINGS
should conflicts based on an old cutoff bound be removed from the conflict pool after improving the p...
constexpr Param< char > USEBOUNDLP
should bound exceeding LP conflict analysis be used? ('o'ff, 'c'onflict graph, 'd'ual ray,...
constexpr Param< int > MAXCONSS
maximal number of conflict constraints accepted at an infeasible node (-1: use all generated conflict...
constexpr Param< double > CONFLICTWEIGHT
the weight the VSIDS score is weight by updating the VSIDS for a variable if it is part of a conflict
constexpr Param< int > RECONVLEVELS
number of depth levels up to which UIP reconvergence constraints are generated (-1: generate reconver...
constexpr Param< double > WEIGHTVALIDDEPTH
weight of the valid depth of a conflict used in score calculation
constexpr Param< bool > REPROPAGATE
should earlier nodes be repropagated in order to replace branching decisions by deductions?
constexpr Param< bool > IGNORERELAXEDBD
should relaxed bounds be ignored?
constexpr Param< bool > USELOCALROWS
use local rows to construct infeasibility proofs
constexpr Param< int > MAXLPLOOPS
maximal number of LP resolving loops during conflict analysis (-1: no limit)
constexpr Param< int > RESTARTNUM
number of successful conflict analysis calls that trigger a restart (0: disable conflict restarts)
constexpr Param< double > PROOFSCOREFAC
score factor for impact on acticity in bound relaxation heuristic
constexpr Param< char > USEINFLP
should infeasible LP conflict analysis be used? ('o'ff, 'c'onflict graph, 'd'ual ray,...
constexpr Param< double > RESTARTFAC
factor to increase restartnum with after each restart
constexpr Param< bool > PREFERBINARY
should binary conflicts be preferred?
constexpr Param< double > SCOREFAC
factor to decrease importance of variables' earlier conflict scores
constexpr Param< int > LPITERATIONS
maximal number of LP iterations in each LP resolving loop (-1: no limit)
constexpr Param< double > WEIGHTSIZE
weight of the size of a conflict used in score calculation
constexpr Param< double > CONFLICTGRAPHWEIGHT
the weight the VSIDS score is weight by updating the VSIDS for a variable if it is part of a conflict...
constexpr Param< bool > DYNAMIC
should the conflict constraints be subject to aging?
constexpr Param< bool > PREFINFPROOF
prefer infeasibility proof to boundexceeding proof
constexpr Param< bool > KEEPREPROP
should constraints be kept for repropagation even if they are too long?
constexpr Param< bool > ENABLE
should conflict analysis be enabled?
constexpr Param< bool > FULLSHORTENCONFLICT
try to shorten the whole conflict set or terminate early (depending on the 'maxvarsdetectimpliedbound...
constexpr Param< bool > USEPSEUDO
should pseudo solution conflict analysis be used?
constexpr Param< double > UPLOCKSCOREFAC
score factor for up locks in bound relaxation heuristic
constexpr Param< int > MAXSTORESIZE
maximal size of conflict store (-1: auto, 0: disable storage)
constexpr Param< double > MINIMPROVE
minimal improvement of primal bound to remove conflicts based on a previous incumbent
constexpr Param< int > INTERCONSS
maximal number of intermediate conflict constraints generated in conflict graph (-1: use every interm...
constexpr Param< int > FUIPLEVELS
number of depth levels up to which first UIP's are used in conflict analysis (-1: use All-FirstUIP ru...
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< bool > PRESOLPAIRWISE
should pairwise constraint comparison be performed in presolving?
constexpr Param< bool > LINEARIZE
should the AND-constraint get linearized and removed (in presolving)?
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< bool > UPGRADERESULTANT
should all binary resultant variables be upgraded to implicit binary variables?
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< bool > PRESOLUSEHASHING
should hash table be used for detecting redundant constraints in advance
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< bool > ENFORCECUTS
should cuts be separated during LP enforcing?
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< bool > DUALPRESOLVING
should dual presolving be performed?
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< bool > AGGRLINEARIZATION
should an aggregated linearization be used?
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< bool > ACTIVE
is the Benders' decomposition constraint handler active?
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< int > MAXDEPTH
depth at which Benders' decomposition cuts are generated from the LP solution (-1: always,...
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< bool > ACTIVE
is the Benders' decomposition LP cut constraint handler active?
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< int > STALLLIMIT
the number of nodes processed without a dual bound improvement before enforcing the LP relaxation,...
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< int > ITERLIMIT
after the root node, only iterlimit fractional LP solutions are used at each node to generate Benders...
constexpr Param< int > DEPTHFREQ
the depth frequency for generating LP cuts after the max depth is reached (0: never,...
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< bool > BRANCHBALANCED
whether to use balanced instead of unbalanced branching
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< double > BALANCEDCUTOFF
determines that balanced branching is only used if the branching cut off value w.r....
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< int > BALANCEDDEPTH
maximum depth for using balanced branching (-1: no limit)
constexpr Param< int > MINSIZE
minimum absolute size (in terms of variables) to solve a component individually during branch-and-bou...
constexpr Param< int > MAXDEPTH
maximum depth of a node to run components detection (-1: disable component detection during solving)
constexpr Param< double > FEASTOLFACTOR
factor to increase the feasibility tolerance of the main SCIP in all sub-SCIPs, default value 1....
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< double > MINRELSIZE
minimum relative size (in terms of variables) to solve a component individually during branch-and-bou...
constexpr Param< long long > NODELIMIT
maximum number of nodes to be solved in subproblems during presolving
constexpr Param< double > MAXCOMPWEIGHT
the maximum weight of a component, in terms of the used factors
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< double > INTFACTOR
the weight of an integer variable compared to binary variables
constexpr Param< double > CONTFACTOR
the weight of a continuous variable compared to binary variables
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< int > MAXINTVARS
maximum number of integer (or binary) variables to solve a subproblem during presolving (-1: unlimite...
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< bool > DISCARDSOLS
is it allowed to discard solutions?
constexpr Param< bool > ACTIVE
is the constraint handler active?
constexpr Param< long long > SOLLIMIT
counting stops, if the given number of solutions were found (-1: no limit)
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< bool > COLLECT
should the solutions be collected?
constexpr Param< bool > SPARSETEST
should the sparse solution test be turned on?
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< bool > USEBDWIDENING
should bound widening be used during the conflict analysis?
constexpr Param< bool > USECOVERCUTS
should covering cuts be added every node?
constexpr Param< bool > TTEFINFER
should time-table edge-finding be used to infer bounds?
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< long long > MAXNODES
number of branch-and-bound nodes to solve an independent cumulative constraint (-1: no limit)?
constexpr Param< bool > SEPAOLD
shall old sepa algo be applied?
constexpr Param< bool > TTINFER
should time-table (core-times) propagator be used to infer bounds?
constexpr Param< bool > DETECTVARBOUNDS
search for conflict set via maximal cliques to detect variable bound constraints
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< bool > EFCHECK
should edge-finding be used to detect an overload?
constexpr Param< bool > USEADJUSTEDJOBS
should edge-finding be executed?
constexpr Param< bool > DISJUNCTIVE
extract disjunctive constraints?
constexpr Param< bool > USEBINVARS
should the binary representation be used?
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< bool > EFINFER
should edge-finding be used to infer bounds?
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< bool > LOCALCUTS
should cuts be added only locally?
constexpr Param< bool > CUTSASCONSS
should the cumulative constraint create cuts as knapsack constraints?
constexpr Param< bool > COEFTIGHTENING
should coefficient tightening be applied?
constexpr Param< bool > PRESOLPAIRWISE
should pairwise constraint comparison be performed in presolving?
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< bool > DUALPRESOLVE
should dual presolving be applied?
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< bool > FILLBRANCHCANDS
should branching candidates be added to storage?
constexpr Param< bool > TTEFCHECK
should time-table edge-finding be used to detect an overload?
constexpr Param< bool > NORMALIZE
should demands and capacity be normalized?
constexpr Param< bool > DETECTDISJUNCTIVE
search for conflict set via maximal cliques to detect disjunctive constraints
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< bool > ALWAYSBRANCH
alawys perform branching if one of the constraints is violated, otherwise only if all integers are fi...
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< bool > ENABLED
whether to check and enforce bounds on fixed variables
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< bool > SUBSCIPS
whether to act on subSCIPs
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< bool > PREFERCUT
whether to prefer separation over tightening LP feastol in enforcement
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< int > MAXSEPACUTSROOT
maximal number of cuts separated per separation round in the root node
constexpr Param< bool > REMOVEINDICATORS
Remove indicator constraint if corresponding variable bound constraint has been added?
constexpr Param< bool > SEPACOUPLINGLOCAL
Allow to use local bounds in order to separate coupling inequalities?
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< int > MAXSEPANONVIOLATED
maximal number of separated non violated IISs, before separation is stopped
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< bool > ADDCOUPLING
Add coupling constraints or rows if big-M is small enough?
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< bool > SEPAPERSPECTIVE
Separate cuts based on perspective formulation?
constexpr Param< bool > FORCERESTART
Force restart if absolute gap is 1 or enough binary variables have been fixed?
constexpr Param< bool > USEOTHERCONSS
Collect other constraints to alternative LP?
constexpr Param< bool > DUALREDUCTIONS
Should dual reduction steps be performed?
constexpr Param< bool > CONFLICTSUPGRADE
Try to upgrade bounddisjunction conflicts by replacing slack variables?
constexpr Param< double > RESTARTFRAC
fraction of binary variables that need to be fixed before restart occurs (in forcerestart)
constexpr Param< bool > TRYSOLFROMCOVER
Try to construct a feasible solution from a cover?
constexpr Param< double > SEPACOUPLINGVALUE
maximum coefficient for binary variable in separated coupling constraint
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< bool > TRYSOLUTIONS
Try to make solutions feasible by setting indicator variables?
constexpr Param< bool > NOLINCONSCONT
Decompose problem (do not generate linear constraint if all variables are continuous)?
constexpr Param< bool > BRANCHINDICATORS
Branch on indicator constraints in enforcing?
constexpr Param< bool > UPDATEBOUNDS
Update bounds of original variables for separation?
constexpr Param< bool > SEPAPERSPLOCAL
Allow to use local bounds in order to separate perspective cuts?
constexpr Param< double > MAXCOUPLINGVALUE
maximum coefficient for binary variable in coupling constraint
constexpr Param< bool > USEOBJECTIVECUT
Use objective cut with current best solution to alternative LP?
constexpr Param< double > MAXCONDITIONALTLP
maximum estimated condition of the solution basis matrix of the alternative LP to be trustworthy (0....
constexpr Param< bool > ADDCOUPLINGCONS
Add initial variable upper bound constraints, if 'addcoupling' is true?
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< bool > ADDOPPOSITE
Add opposite inequality in nodes in which the binary variable has been fixed to 0?
constexpr Param< bool > USESAMESLACKVAR
Use same slack variable for indicator constraints with common binary variable?
constexpr Param< bool > SCALESLACKVAR
Scale slack variable coefficient at construction time?
constexpr Param< bool > ENFORCECUTS
In enforcing try to generate cuts (only if sepaalternativelp is true)?
constexpr Param< int > MAXSEPACUTS
maximal number of cuts separated per separation round
constexpr Param< bool > UPGRADELINEAR
Try to upgrade linear constraints to indicator constraints?
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< bool > GENLOGICOR
Generate logicor constraints instead of cuts?
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< bool > SEPACOUPLINGCUTS
Should the coupling inequalities be separated dynamically?
constexpr Param< bool > SEPAALTERNATIVELP
Separate using the alternative LP?
constexpr Param< bool > GENERATEBILINEAR
Do not generate indicator constraint, but a bilinear constraint instead?
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< int > MAXROUNDSROOT
maximal number of separation rounds per node in the root node (-1: unlimited)
constexpr Param< bool > PRESOLPAIRWISE
should pairwise constraint comparison be performed in presolving?
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< int > MAXSEPACUTSROOT
maximal number of cuts separated per separation round in the root node
constexpr Param< bool > USEGUBS
should GUB information be used for separation?
constexpr Param< double > CLQPARTUPDATEFAC
factor on the growth of global cliques to decide when to update a previous (negated) clique partition...
constexpr Param< bool > DISAGGREGATION
should disaggregation of knapsack constraints be allowed in preprocessing?
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< double > MAXCARDBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< int > MAXSEPACUTS
maximal number of cuts separated per separation round
constexpr Param< bool > UPDATECLIQUEPARTITIONS
should clique partition information be updated when old partition seems outdated?
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< bool > SIMPLIFYINEQUALITIES
should presolving try to simplify knapsacks
constexpr Param< double > CLIQUEEXTRACTFACTOR
lower clique size limit for greedy clique extraction algorithm (relative to largest clique)
constexpr Param< int > MAXROUNDS
maximal number of separation rounds per node (-1: unlimited)
constexpr Param< int > SEPACARDFREQ
multiplier on separation frequency, how often knapsack cuts are separated (-1: never,...
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< bool > DUALPRESOLVING
should dual presolving steps be performed?
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< bool > DETECTLOWERBOUND
should presolving try to detect constraints parallel to the objective function defining a lower bound...
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< bool > PRESOLUSEHASHING
should hash table be used for detecting redundant constraints in advance
constexpr Param< bool > DETECTCUTOFFBOUND
should presolving try to detect constraints parallel to the objective function defining an upper boun...
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< bool > NEGATEDCLIQUE
should negated clique information be used in solving process
constexpr Param< bool > XOR
enable linear upgrading for constraint handler <xor>
constexpr Param< bool > LOGICOR
enable linear upgrading for constraint handler <logicor>
constexpr Param< bool > VARBOUND
enable linear upgrading for constraint handler <varbound>
constexpr Param< bool > INDICATOR
enable linear upgrading for constraint handler <indicator>
constexpr Param< bool > SETPPC
enable linear upgrading for constraint handler <setppc>
constexpr Param< bool > KNAPSACK
enable linear upgrading for constraint handler <knapsack>
constexpr Param< bool > CHECKRELMAXABS
should the violation for a constraint with side 0.0 be checked relative to 1.0 (FALSE) or to the maxi...
constexpr Param< int > RANGEDROWMAXDEPTH
maximum depth to apply ranged row propagation
constexpr Param< double > MINGAINPERNMINCOMPARISONS
minimal gain per minimal pairwise presolve comparisons to repeat pairwise comparison round
constexpr Param< int > MAXROUNDS
maximal number of separation rounds per node (-1: unlimited)
constexpr Param< bool > SIMPLIFYINEQUALITIES
should presolving try to simplify inequalities
constexpr Param< int > MAXSEPACUTS
maximal number of cuts separated per separation round
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< bool > SEPARATEALL
should all constraints be subject to cardinality cut generation instead of only the ones with non-zer...
constexpr Param< bool > DETECTLOWERBOUND
should presolving try to detect constraints parallel to the objective function defining a lower bound...
constexpr Param< double > MAXAGGRNORMSCALE
maximal allowed relative gain in maximum norm for constraint aggregation (0.0: disable constraint agg...
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< double > MAXMULTAGGRQUOT
maximum coefficient dynamism (ie. maxabsval / minabsval) for primal multiaggregation
constexpr Param< bool > MULTAGGRREMOVE
should multi-aggregations only be performed if the constraint can be removed afterwards?
constexpr Param< int > MAXROUNDSROOT
maximal number of separation rounds per node in the root node (-1: unlimited)
constexpr Param< bool > DUALPRESOLVING
should dual presolving steps be performed?
constexpr Param< double > MAXDUALMULTAGGRQUOT
maximum coefficient dynamism (ie. maxabsval / minabsval) for dual multiaggregation
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< bool > SINGLETONSTUFFING
should stuffing of singleton continuous variables be performed?
constexpr Param< int > TIGHTENBOUNDSFREQ
multiplier on propagation frequency, how often the bounds are tightened (-1: never,...
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< int > MAXSEPACUTSROOT
maximal number of cuts separated per separation round in the root node
constexpr Param< bool > SINGLEVARSTUFFING
should single variable stuffing be performed, which tries to fulfill constraints using the cheapest v...
constexpr Param< bool > PRESOLPAIRWISE
should pairwise constraint comparison be performed in presolving?
constexpr Param< double > MAXEASYACTIVITYDELTA
maximum activity delta to run easy propagation on linear constraint (faster, but numerically less sta...
constexpr Param< bool > DETECTCUTOFFBOUND
should presolving try to detect constraints parallel to the objective function defining an upper boun...
constexpr Param< bool > DETECTPARTIALOBJECTIVE
should presolving try to detect subsets of constraints parallel to the objective function?
constexpr Param< bool > PRESOLUSEHASHING
should hash table be used for detecting redundant constraints in advance
constexpr Param< bool > RANGEDROWARTCONS
should presolving and propagation extract sub-constraints from ranged rows and equations?
constexpr Param< int > RANGEDROWFREQ
frequency for applying ranged row propagation
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< bool > AGGREGATEVARIABLES
should presolving search for aggregations in equations
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< bool > SORTVARS
apply binaries sorting in decr. order of coeff abs value?
constexpr Param< int > NMINCOMPARISONS
number for minimal pairwise presolve comparisons
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< bool > EXTRACTCLIQUES
should Cliques be extracted?
constexpr Param< double > MAXCARDBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< bool > RANGEDROWPROPAGATION
should presolving and propagation try to improve bounds, detect infeasibility, and extract sub-constr...
constexpr Param< bool > LINEARIZE
this constraint will not propagate or separate, linear and setppc are used?
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< bool > PRESOLPAIRWISE
should pairwise constraint comparison be performed in presolving?
constexpr Param< bool > STRENGTHEN
should pairwise constraint comparison try to strengthen constraints by removing superflous non-zeros?
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< bool > PRESOLUSEHASHING
should hash table be used for detecting redundant constraints in advance
constexpr Param< bool > NEGATEDCLIQUE
should negated clique information be used in presolving
constexpr Param< bool > DUALPRESOLVING
should dual presolving steps be performed?
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< bool > IMPLICATIONS
should implications/cliques be used in presolving
constexpr Param< char > SCOREAGG
how to aggregate several branching scores given for the same expression: 'a'verage,...
constexpr Param< bool > EXTERNAL
whether to use external branching candidates and branching rules for branching
constexpr Param< double > VARTYPEWEIGHT
weight by how much to consider variable type (continuous: 0, binary: 1, integer: 0....
constexpr Param< double > DUALWEIGHT
weight by how much to consider the dual values of rows that contain a variable for its branching scor...
constexpr Param< double > HIGHSCOREFACTOR
consider a variable branching score high if its branching score >= this factor * maximal branching sc...
constexpr Param< char > VIOLSPLIT
method used to split violation in expression onto variables: 'u'niform, 'm'idness of solution,...
constexpr Param< double > PSCOSTWEIGHT
weight by how much to consider the pseudo cost of a variable for its branching score
constexpr Param< double > PSCOSTRELIABLE
minimum pseudo-cost update count required to consider pseudo-costs reliable
constexpr Param< double > HIGHVIOLFACTOR
consider a constraint highly violated if its violation is >= this factor * maximal violation among al...
constexpr Param< double > VIOLWEIGHT
weight by how much to consider the violation assigned to a variable for its branching score
constexpr Param< int > AUX
from which depth on in the tree to allow branching on auxiliary variables (variables added for extend...
constexpr Param< double > FRACWEIGHT
weight by how much to consider fractionality of integer variables in branching score for spatial bran...
constexpr Param< double > DOMAINWEIGHT
weight by how much to consider the domain width in branching score
constexpr Param< double > MIXFRACTIONAL
minimal average pseudo cost count for discrete variables at which to start considering spatial branch...
constexpr Param< bool > SETPPC
enable nonlinear upgrading for constraint handler <setppc>
constexpr Param< bool > LINEAR
enable nonlinear upgrading for constraint handler <linear>
constexpr Param< int > MAXPROPROUNDS
limit on number of propagation rounds for a set of constraints within one round of SCIP propagation
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< bool > STRONGCUTEFFICACY
consider efficacy requirement when deciding whether a cut is "strong"
constexpr Param< double > ENFOAUXVIOLFACTOR
an expression will be enforced if the "auxiliary" violation is at least this factor times the "origin...
constexpr Param< double > VARBOUNDRELAXAMOUNT
by how much to relax variable bounds during bound tightening if strategy 'a', 'b',...
constexpr Param< bool > ASSUMECONVEX
whether to assume that any constraint is convex
constexpr Param< bool > REFORMBINPRODSAND
whether to use the AND constraint handler for reformulating binary products
constexpr Param< double > STRONGCUTMAXCOEF
"strong" cuts will be scaled to have their maximal coef in [1/strongcutmaxcoef,strongcutmaxcoef]
constexpr Param< bool > PROPINENFORCE
whether to (re)run propagation in enforcement
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< double > CONSSIDERELAXAMOUNT
by how much to relax constraint sides during bound tightening
constexpr Param< double > WEAKCUTTHRESHOLD
threshold for when to regard a cut from an estimator as weak (lower values allow more weak cuts)
constexpr Param< char > CHECKVARLOCKS
whether variables contained in a single constraint should be forced to be at their lower or upper bou...
constexpr Param< double > WEAKCUTMINVIOLFACTOR
retry enfo of constraint with weak cuts if violation is least this factor of maximal violated constra...
constexpr Param< int > REFORMBINPRODSFAC
minimum number of terms to reformulate bilinear binary products by factorizing variables (<= 1: disab...
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< double > VPMAXPERTURB
maximal relative perturbation of reference point when computing facet of envelope of vertex-polyhedra...
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< int > BILINMAXNAUXEXPRS
maximal number of auxiliary expressions per bilinear term
constexpr Param< bool > PROPAUXVARS
whether to check bounds of all auxiliary variable to seed reverse propagation
constexpr Param< char > LINEARIZEHEURSOL
whether tight linearizations of nonlinear constraints should be added to cutpool when some heuristics...
constexpr Param< double > VPADJFACETTHRESH
adjust computed facet of envelope of vertex-polyhedral function up to a violation of this value times...
constexpr Param< bool > FORBIDMULTAGGRNLVAR
whether to forbid multiaggregation of nonlinear variables
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< char > ROWNOTREMOVABLE
whether to make rows to be non-removable in the node where they are added (can prevent some cycling):...
constexpr Param< bool > REFORMBINPRODS
whether to reformulate products of binary variables during presolving
constexpr Param< bool > VPDUALSIMPLEX
whether to use dual simplex instead of primal simplex for LP that computes facet of vertex-polyhedral...
constexpr Param< bool > FORCESTRONGCUT
whether to force "strong" cuts in enforcement
constexpr Param< char > VARBOUNDRELAX
strategy on how to relax variable bounds during bound tightening: relax (n)ot, relax by (a)bsolute va...
constexpr Param< bool > TIGHTENLPFEASTOL
whether to tighten LP feasibility tolerance during enforcement, if it seems useful
constexpr Param< char > VIOLSCALE
method how to scale violations to make them comparable (not used for feasibility check): (n)one,...
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< bool > FORCECONSCOPY
Whether orbisack constraints should be forced to be copied to sub SCIPs.
constexpr Param< bool > ORBISEPARATION
Separate orbisack inequalities?
constexpr Param< double > COEFFBOUND
Maximum size of coefficients for orbisack inequalities.
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< bool > CHECKPPORBISACK
Upgrade orbisack constraints to packing/partioning orbisacks?
constexpr Param< bool > COVERSEPARATION
Separate cover inequalities for orbisacks?
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< bool > SEPAFULLORBITOPE
Whether we separate inequalities for full orbitopes?
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< bool > CHECKPPORBITOPE
Strengthen orbitope constraints to packing/partioning orbitopes?
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< bool > FORCECONSCOPY
Whether orbitope constraints should be forced to be copied to sub SCIPs.
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< bool > NLCREMOVABLE
should the nonlinear constraints be removable?
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< bool > DECOMPOSENORMAL
decompose every normal pseudo boolean constraint into a "linear" constraint and "and" constraints
constexpr Param< bool > NLCSEPARATE
should the nonlinear constraints be separated during LP processing?
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< bool > NLCPROPAGATE
should the nonlinear constraints be propagated during node processing?
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< bool > DECOMPOSEINDICATOR
decompose every soft pseudo boolean constraint into "indicator" constraints and "and" constraints
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< int > NPSEUDOBRANCHES
number of children created in pseudo branching (0: disable pseudo branching)
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< bool > PRESOLPAIRWISE
should pairwise constraint comparison be performed in presolving?
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< bool > DUALPRESOLVING
should dual presolving steps be performed?
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< bool > PRESOLUSEHASHING
should hash table be used for detecting redundant constraints in advance
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< bool > CLIQUESHRINKING
should we try to shrink the number of variables in a clique constraints, by replacing more than one v...
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< bool > CLIQUELIFTING
should we try to lift variables into other clique constraints, fix variables, aggregate them,...
constexpr Param< bool > ADDVARIABLESASCLIQUES
should we try to generate extra cliques out of all binary variables to maybe fasten redundant constra...
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< int > MAXADDCOMPS
maximal number of complementarity constraints added per branching node (-1: no limit)
constexpr Param< int > MAXBOUNDCUTSROOT
maximal number of bound cuts separated per iteration in the root node
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< int > MAXIMPLCUTS
maximal number of implied bound cuts separated per branching node
constexpr Param< int > MAXIMPLCUTSROOT
maximal number of implied bound cuts separated per iteration in the root node
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< int > IMPLCUTSFREQ
frequency for separating implied bound cuts; zero means to separate only in the root node
constexpr Param< int > ADDCOMPSDEPTH
only add complementarity constraints to branching nodes for predefined depth (-1: no limit)
constexpr Param< bool > STRTHENBOUNDCUTS
if TRUE then bound cuts are strengthened in case bound variables are available
constexpr Param< int > DEPTHIMPLANALYSIS
number of recursive calls of implication graph analysis (-1: no limit)
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< double > ADDBDSFEAS
minimal feasibility value for bound inequalities in order to be added to the branching node
constexpr Param< int > NSTRONGROUNDS
maximal number of strong branching rounds to perform for each node (-1: auto); only available for nei...
constexpr Param< int > BOUNDCUTSFREQ
frequency for separating bound cuts; zero means to separate only in the root node
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< bool > ADDCOMPS
if TRUE then add complementarity constraints to the branching nodes (can be used in combination with ...
constexpr Param< bool > SOSCONSPROP
whether to use SOS1 constraint propagation
constexpr Param< int > NSTRONGITER
maximal number LP iterations to perform for each strong branching round (-2: auto,...
constexpr Param< bool > IMPLPROP
whether to use implication graph propagation
constexpr Param< bool > ADDEXTENDEDBDS
should added complementarity constraints be extended to SOS1 constraints to get tighter bound inequal...
constexpr Param< bool > PERFIMPLANALYSIS
if TRUE then perform implication graph analysis (might add additional SOS1 constraints)
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< int > MAXSOSADJACENCY
do not create an adjacency matrix if number of SOS1 variables is larger than predefined value (-1: no...
constexpr Param< bool > BRANCHWEIGHT
Branch on SOS cons. with highest nonzero-variable weight for branching (needs branchnonzeros = false)...
constexpr Param< bool > AUTOSOS1BRANCH
if TRUE then automatically switch to SOS1 branching if the SOS1 constraints do not overlap
constexpr Param< double > ADDCOMPSFEAS
minimal feasibility value for complementarity constraints in order to be added to the branching node
constexpr Param< int > MAXTIGHTENBDS
maximal number of bound tightening rounds per presolving round (-1: no limit)
constexpr Param< bool > BRANCHNONZEROS
Branch on SOS constraint with most number of nonzeros?
constexpr Param< bool > BRANCHSOS
Use SOS1 branching in enforcing (otherwise leave decision to branching rules)? This value can only be...
constexpr Param< bool > BOUNDCUTSFROMGRAPH
if TRUE separate bound inequalities from the conflict graph
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< bool > BOUNDCUTSFROMSOS1
if TRUE separate bound inequalities from initial SOS1 constraints
constexpr Param< bool > AUTOCUTSFROMSOS1
if TRUE then automatically switch to separating initial SOS1 constraints if the SOS1 constraints do n...
constexpr Param< char > BRANCHINGRULE
which branching rule should be applied ? ('n': neighborhood, 'b': bipartite, 's': SOS1/clique) (note:...
constexpr Param< int > MAXBOUNDCUTS
maximal number of bound cuts separated per branching node
constexpr Param< int > MAXEXTENSIONS
maximal number of extensions that will be computed for each SOS1 constraint (-1: no limit)
constexpr Param< bool > FIXNONZERO
if neighborhood branching is used, then fix the branching variable (if positive in sign) to the value...
constexpr Param< int > BOUNDCUTSDEPTH
node depth of separating bound cuts (-1: no limit)
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< int > IMPLCUTSDEPTH
node depth of separating implied bound cuts (-1: no limit)
constexpr Param< bool > CONFLICTPROP
whether to use conflict graph propagation
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< double > MAXUPGDCOEFLINEAR
maximum big-M coefficient of binary variable in upgrade to a linear constraint (relative to smallest ...
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< bool > CHECKSLACKTYPE
should type of slack constraint be checked when creating superindicator constraint?
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< int > UPGDPRIOLINEAR
priority for upgrading to an indicator constraint (-1: never)
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< int > UPGDPRIOINDICATOR
priority for upgrading to an indicator constraint (-1: never)
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< bool > CHECKMONOTONICITY
Check whether permutation is monotone when upgrading to packing/partioning symresacks?
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< bool > PPSYMRESACK
Upgrade symresack constraints to packing/partioning symresacks?
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< bool > FORCECONSCOPY
Whether symresack constraints should be forced to be copied to sub SCIPs.
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< bool > USEBDWIDENING
should bound widening be used in conflict analysis?
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< double > MAXLPCOEF
maximum coefficient in varbound constraint to be added as a row into LP
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< bool > PRESOLPAIRWISE
should pairwise constraint comparison be performed in presolving?
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< bool > DELAYSEPA
should separation method be delayed, if other separators found cuts?
constexpr Param< bool > PRESOLPAIRWISE
should pairwise constraint comparison be performed in presolving?
constexpr Param< int > PROPFREQ
frequency for propagating domains (-1: never, 0: only in root node)
constexpr Param< int > EAGERFREQ
frequency for using all instead of only the useful constraints in separation, propagation and enforce...
constexpr Param< int > SEPAFREQ
frequency for separating cuts (-1: never, 0: only in root node)
constexpr Param< int > GAUSSPROPFREQ
frequency for applying the Gauss propagator
constexpr Param< bool > SEPARATEPARITY
should parity inequalities be separated?
constexpr Param< bool > PRESOLUSEHASHING
should hash table be used for detecting redundant constraints in advance?
constexpr Param< bool > ADDFLOWEXTENDED
should the extended flow formulation be added (nonsymmetric formulation otherwise)?
constexpr Param< int > PROPTIMING
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< int > PRESOLTIMING
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< bool > DELAYPROP
should propagation method be delayed, if other propagators found reductions?
constexpr Param< bool > ADDEXTENDEDFORM
should the extended formulation be added in presolving?
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the constraint handler participates in (-1: no limit)
constexpr Param< int > AGELIMIT
maximum age an unnecessary constraint can reach before it is deleted (0: dynamic, -1: keep all constr...
constexpr Param< int > OBSOLETEAGE
age of a constraint after which it is marked obsolete (0: dynamic, -1 do not mark constraints obsolet...
constexpr Param< bool > DISABLEENFOPS
should enforcement of pseudo solution be disabled?
constexpr Param< int > PRIORITY
priority of cut selection rule <dynamic>
constexpr Param< double > OBJPARALWEIGHT
weight of objective parallelism in cut score calculation
constexpr Param< double > INTSUPPORTWEIGHT
weight of integral support in cut score calculation
constexpr Param< double > EFFICACYWEIGHT
weight of efficacy in cut score calculation
constexpr Param< double > MINORTHO
minimal orthogonality for a cut to enter the LP
constexpr Param< int > MAXDEPTH
maximum depth at which this cutselector is employed
constexpr Param< double > DIRCUTOFFDISTWEIGHT
weight of directed cutoff distance in cut score calculation
constexpr Param< double > MINGAIN
minimal efficacy gain for a cut to enter the LP
constexpr Param< char > FILTERMODE
filtering strategy during cut selection
constexpr Param< int > MAXNUMVARS
max number of variables such that cut selector is applied.
constexpr Param< bool > PENALISELOCKS
should the number of locks be penalised instead of rewarded
constexpr Param< double > DIRCUTOFFDISTWEIGHT
weight of normed-directed cutoff distance in cut score calculation
constexpr Param< double > MAXCUTDENSITY
max allowed cut density if filtering dense cuts
constexpr Param< double > MINSCORE
minimum score s.t. a cut can be added
constexpr Param< double > MAXNONZEROROOTROUND
max non-zeros per round applied cuts (root). multiple num LP cols.
constexpr Param< int > MAXCOEFRATIOBONUS
max coefficient ratio for which numeric bonus is applied.
constexpr Param< int > MAXCUTS
max number of cuts such that cut selector is applied.
constexpr Param< double > OBJPARALWEIGHT
weight of objective parallelism in cut score calculation
constexpr Param< double > GOODNUMERICSBONUS
weight of good numerics bonus (ratio of coefficients) in cut score calculation
constexpr Param< double > PARALPENALTY
penalty for weaker of two parallel cuts if penalising parallel cuts
constexpr Param< bool > FILTERDENSECUTS
should cuts over a given density threshold be filtered
constexpr Param< int > PRIORITY
priority of cut selection rule <ensemble>
constexpr Param< bool > FILTERPARALCUTS
should cuts be filtered so no two parallel cuts are added
constexpr Param< double > MAXPARAL
threshold for when two cuts are considered parallel to each other
constexpr Param< double > EFFICACYWEIGHT
weight of normed-efficacy in cut score calculation
constexpr Param< double > MAXNONZEROTREEROUND
max non-zeros per round applied cuts (tree). multiple num LP cols.
constexpr Param< bool > PENALISEOBJPARAL
should objective parallelism be penalised instead of rewarded
constexpr Param< double > PSCOSTWEIGHT
weight of normed-pseudo-costs in cut score calculation
constexpr Param< bool > PENALISEPARALCUTS
should two parallel cuts be penalised instead of outright filtered
constexpr Param< double > INTSUPPORTWEIGHT
weight of integral support in cut score calculation
constexpr Param< double > EXPIMPROVWEIGHT
weight of normed-expected obj improvement in cut score calculation
constexpr Param< double > LOCKSWEIGHT
weight of normed-num-locks in cut score calculation
constexpr Param< double > ENDSPARSITYBONUS
max sparsity value for which a bonus is applied in cut score calculation
constexpr Param< double > MAXSPARSITYBONUS
weight of maximum sparsity reward in cut score calculation
constexpr Param< double > DIRCUTOFFDISTWEIGHT
weight of directed cutoff distance in cut score calculation
constexpr Param< double > EFFICACYWEIGHT
weight of efficacy in cut score calculation
constexpr Param< double > OBJPARALWEIGHT
weight of objective parallelism in cut score calculation
constexpr Param< double > INTSUPPORTWEIGHT
weight of integral support in cut score calculation
constexpr Param< double > MINORTHO
minimal orthogonality for a cut to enter the LP
constexpr Param< double > MINORTHOROOT
minimal orthogonality for a cut to enter the LP in the root node
constexpr Param< int > PRIORITY
priority of cut selection rule <hybrid>
constexpr Param< bool > APPLYBENDERS
if a decomposition exists, should Benders' decomposition be applied?
constexpr Param< bool > BENDERSLABELS
should the variables be labelled for the application of Benders' decomposition?
constexpr Param< bool > DISABLEMEASURES
disable expensive measures
constexpr Param< int > MAXGRAPHEDGE
maximum number of edges in block graph computation (-1: no limit, 0: disable block graph computation)
constexpr Param< int > ACTIVE
display activation status of display column <avgdualbound> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <completed> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <concdualbound> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <concgap> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <concmemused> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <concprimalbound> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <concsolfound> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <conflicts> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <conss> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <curcols> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <curconss> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <curdualbound> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <currows> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <cutoffbound> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <cuts> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <depth> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <dualbound> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <estimate> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <feasST> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <gap> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <lpavgiterations> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <lpcond> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <lpiterations> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <lpobj> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <maxdepth> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <memtotal> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <memused> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <nexternbranchcands> (0: off, 1: auto,...
constexpr Param< int > ACTIVE
display activation status of display column <nfrac> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <ninfeasleaves> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <nnodesbelowinc> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <nnodes> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <nobjleaves> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <nodesleft> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <nrank1nodes> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <nsols> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <plungedepth> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <poolsize> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <primalbound> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <primalgap> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <pseudoobj> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <separounds> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <solfound> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <sols> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <strongbranchs> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <time> (0: off, 1: auto, 2:on)
constexpr Param< int > ACTIVE
display activation status of display column <vars> (0: off, 1: auto, 2:on)
constexpr Param< int > VERBLEVEL
verbosity level of output
constexpr Param< bool > RELEVANTSTATS
should the relevant statistics be displayed at the end of solving?
constexpr Param< int > WIDTH
maximal number of characters in a node information line
constexpr Param< bool > LPINFO
should the LP solver display status messages?
constexpr Param< int > FREQ
frequency for displaying node information lines
constexpr Param< int > HEADERFREQ
frequency for displaying header lines (every n'th node information line)
constexpr Param< bool > ALLVIOLS
display all violations for a given start solution / the best solution after the solving process?
constexpr Param< bool > RESTARTACTPRICERS
whether to apply a restart when active pricers are used
constexpr Param< long long > MINNODES
minimum number of nodes before restart
constexpr Param< int > RESTARTLIMIT
restart limit
constexpr Param< char > RESTARTPOLICY
restart policy: (a)lways, (c)ompletion, (e)stimation, (n)ever
constexpr Param< int > HITCOUNTERLIM
limit on the number of successive samples to really trigger a restart
constexpr Param< double > RESTARTFACTOR
factor by which the estimated number of nodes should exceed the current number of nodes
constexpr Param< bool > RESTARTNONLINEAR
whether to apply a restart when nonlinear constraints are present
constexpr Param< bool > COUNTONLYLEAVES
should only leaves count for the minnodes parameter?
constexpr Param< int > NMAXSUBTREES
the maximum number of individual SSG subtrees; -1: no limit
constexpr Param< long long > NMINNODESLASTSPLIT
minimum number of nodes to process between two consecutive SSG splits
constexpr Param< bool > ENABLED
should the event handler collect data?
constexpr Param< double > MINNODESPERDEPTH
minimum average number of nodes at each depth before producing estimations
constexpr Param< bool > SHOWSTATS
should statistics be shown at the end?
constexpr Param< double > COEFMONOSSG
coefficient of 1 - SSG in monotone approximation of search completion
constexpr Param< bool > USELEAFTS
use leaf nodes as basic observations for time series, or all nodes?
constexpr Param< char > METHOD
tree size estimation method: (c)ompletion, (e)nsemble, time series forecasts on either (g)ap,...
constexpr Param< int > REPORTFREQ
report frequency on estimation: -1: never, 0:always, k >= 1: k times evenly during search
constexpr Param< std::string > REGFORESTFILENAME
user regression forest in RFCSV format
constexpr Param< double > COEFMONOWEIGHT
coefficient of tree weight in monotone approximation of search completion
constexpr Param< char > COMPLETIONTYPE
approximation of search tree completion: (a)uto, (g)ap, tree (w)eight, (m)onotone regression,...
constexpr Param< double > MINZERODISTANCE
minimal distance from zero to enforce for child in bound tightening
constexpr Param< int > EXPANDMAXEXPONENT
maximal exponent when to expand power of sum in simplify
constexpr Param< bool > DISTRIBFRACEXPONENT
whether a fractional exponent is distributed onto factors on power of product
constexpr Param< double > MINZERODISTANCE
minimal distance from zero to enforce for child in bound tightening
constexpr Param< bool > EXPANDALWAYS
whether to expand products of a sum and several factors in simplify
constexpr Param< bool > ONLYLPBRANCHCANDS
should only LP branching candidates be considered instead of the slower but more general constraint h...
constexpr Param< double > MAXDIVEUBQUOT
maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0...
constexpr Param< double > MAXDIVEUBQUOTNOSOL
maximal UBQUOT when no solution was found yet (0.0: no limit)
constexpr Param< double > MAXLPITERQUOT
maximal fraction of diving LP iterations compared to node LP iterations
constexpr Param< int > LPSOLVEFREQ
LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
constexpr Param< int > MAXLPITEROFS
additional number of allowed LP iterations
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <actconsdiving> (-1: no limit)
constexpr Param< bool > BACKTRACK
use one level of backtracking if infeasibility is encountered?
constexpr Param< int > PRIORITY
priority of heuristic <actconsdiving>
constexpr Param< double > LPRESOLVEDOMCHGQUOT
percentage of immediate domain changes during probing to trigger LP resolve
constexpr Param< int > FREQ
frequency for calling primal heuristic <actconsdiving> (-1: never, 0: only at depth freqofs)
constexpr Param< double > MAXDIVEAVGQUOT
maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed ...
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <actconsdiving>
constexpr Param< double > MINRELDEPTH
minimal relative depth to start diving
constexpr Param< double > MAXRELDEPTH
maximal relative depth to start diving
constexpr Param< double > MAXDIVEAVGQUOTNOSOL
maximal AVGQUOT when no solution was found yet (0.0: no limit)
constexpr Param< bool > USEADAPTIVECONTEXT
should the heuristic use its own statistics, or shared statistics?
constexpr Param< int > PRIORITY
priority of heuristic <adaptivediving>
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <adaptivediving>
constexpr Param< double > MAXLPITERQUOT
maximal fraction of diving LP iterations compared to node LP iterations
constexpr Param< char > SCORETYPE
score parameter for selection: minimize either average 'n'odes, LP 'i'terations,backtrack/'c'onflict ...
constexpr Param< double > SELCONFIDENCECOEFF
coefficient c to decrease initial confidence (calls + 1.0) / (calls + c) in scores
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <adaptivediving> (-1: no limit)
constexpr Param< double > EPSILON
parameter that increases probability of exploration among divesets (only active if seltype is 'e')
constexpr Param< long long > MAXLPITEROFS
additional number of allowed LP iterations
constexpr Param< char > SELTYPE
selection strategy: (e)psilon-greedy, (w)eighted distribution, (n)ext diving
constexpr Param< int > FREQ
frequency for calling primal heuristic <adaptivediving> (-1: never, 0: only at depth freqofs)
constexpr Param< double > BESTSOLWEIGHT
weight of incumbent solutions compared to other solutions in computation of LP iteration limit
constexpr Param< double > MAXFIXINGRATE
maximum fixing rate for this neighborhood
constexpr Param< int > NSOLS
the number of solutions that crossover should combine
constexpr Param< double > MINFIXINGRATE
minimum fixing rate for this neighborhood
constexpr Param< bool > ACTIVE
is this neighborhood active?
constexpr Param< double > PRIORITY
positive call priority to initialize bandit algorithms
constexpr Param< double > MINFIXINGRATE
minimum fixing rate for this neighborhood
constexpr Param< double > MAXFIXINGRATE
maximum fixing rate for this neighborhood
constexpr Param< bool > ACTIVE
is this neighborhood active?
constexpr Param< double > PRIORITY
positive call priority to initialize bandit algorithms
constexpr Param< int > NPOOLSOLS
number of pool solutions where binary solution values must agree
constexpr Param< bool > ACTIVE
is this neighborhood active?
constexpr Param< double > MAXFIXINGRATE
maximum fixing rate for this neighborhood
constexpr Param< double > PRIORITY
positive call priority to initialize bandit algorithms
constexpr Param< double > MINFIXINGRATE
minimum fixing rate for this neighborhood
constexpr Param< double > PRIORITY
positive call priority to initialize bandit algorithms
constexpr Param< double > MAXFIXINGRATE
maximum fixing rate for this neighborhood
constexpr Param< bool > ACTIVE
is this neighborhood active?
constexpr Param< double > MINFIXINGRATE
minimum fixing rate for this neighborhood
constexpr Param< bool > ACTIVE
is this neighborhood active?
constexpr Param< double > PRIORITY
positive call priority to initialize bandit algorithms
constexpr Param< double > MAXFIXINGRATE
maximum fixing rate for this neighborhood
constexpr Param< double > MINFIXINGRATE
minimum fixing rate for this neighborhood
constexpr Param< bool > ACTIVE
is this neighborhood active?
constexpr Param< double > MINFIXINGRATE
minimum fixing rate for this neighborhood
constexpr Param< double > PRIORITY
positive call priority to initialize bandit algorithms
constexpr Param< double > MAXFIXINGRATE
maximum fixing rate for this neighborhood
constexpr Param< double > MAXFIXINGRATE
maximum fixing rate for this neighborhood
constexpr Param< bool > ACTIVE
is this neighborhood active?
constexpr Param< double > PRIORITY
positive call priority to initialize bandit algorithms
constexpr Param< double > MINFIXINGRATE
minimum fixing rate for this neighborhood
constexpr Param< double > MINFIXINGRATE
minimum fixing rate for this neighborhood
constexpr Param< double > PRIORITY
positive call priority to initialize bandit algorithms
constexpr Param< bool > ACTIVE
is this neighborhood active?
constexpr Param< double > MAXFIXINGRATE
maximum fixing rate for this neighborhood
constexpr Param< double > VIOLPENALTY
the penalty for each change in the binary variables from the candidate solution
constexpr Param< double > MAXFIXINGRATE
maximum fixing rate for this neighborhood
constexpr Param< double > MINFIXINGRATE
minimum fixing rate for this neighborhood
constexpr Param< bool > ACTIVE
is this neighborhood active?
constexpr Param< double > PRIORITY
positive call priority to initialize bandit algorithms
constexpr Param< bool > RESETWEIGHTS
should the bandit algorithms be reset when a new problem is read?
constexpr Param< bool > SUBSCIPRANDSEEDS
should random seeds of sub-SCIPs be altered to increase diversification?
constexpr Param< long long > MINNODES
minimum number of nodes required to start a sub-SCIP
constexpr Param< int > FREQ
frequency for calling primal heuristic <alns> (-1: never, 0: only at depth freqofs)
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <alns> (-1: no limit)
constexpr Param< double > UNFIXTOL
tolerance by which the fixing rate may be exceeded without generic unfixing
constexpr Param< bool > SCALEBYEFFORT
should the reward be scaled by the effort?
constexpr Param< double > TARGETNODEFACTOR
factor by which target node number is eventually increased
constexpr Param< bool > COPYCUTS
should cutting planes be copied to the sub-SCIP?
constexpr Param< bool > DOMOREFIXINGS
should the ALNS heuristic do more fixings by itself based on variable prioritization until the target...
constexpr Param< int > SEED
initial random seed for bandit algorithms and random decisions by neighborhoods
constexpr Param< double > BETA
reward offset between 0 and 1 at every observation for Exp.3
constexpr Param< bool > USESUBSCIPHEURS
should the heuristic activate other sub-SCIP heuristics during its search?
constexpr Param< int > NSOLSLIM
limit on the number of improving solutions in a sub-SCIP call
constexpr Param< bool > USEDISTANCES
distances from fixed variables be used for variable prioritization
constexpr Param< double > GAMMA
weight between uniform (gamma ~ 1) and weight driven (gamma ~ 0) probability distribution for exp3
constexpr Param< bool > INITDURINGROOT
should the heuristic be executed multiple times during the root node?
constexpr Param< char > BANDITALGO
the bandit algorithm: (u)pper confidence bounds, (e)xp.3, epsilon (g)reedy, exp.3-(i)x
constexpr Param< double > FIXTOL
tolerance by which the fixing rate may be missed without generic fixing
constexpr Param< double > EPS
increase exploration in epsilon-greedy bandit algorithm
constexpr Param< double > NODESQUOT
fraction of nodes compared to the main SCIP for budget computation
constexpr Param< double > MINIMPROVEHIGH
upper bound for the minimal improvement over the incumbent
constexpr Param< double > REWARDBASELINE
the reward baseline to separate successful and failed calls
constexpr Param< long long > NODESOFS
offset added to the nodes budget
constexpr Param< bool > SHOWNBSTATS
show statistics on neighborhoods?
constexpr Param< long long > MAXNODES
maximum number of nodes to regard in the subproblem
constexpr Param< double > STARTMINIMPROVE
initial factor by which ALNS should at least improve the incumbent
constexpr Param< double > NODESQUOTMIN
lower bound fraction of nodes compared to the main SCIP for budget computation
constexpr Param< double > REWARDCONTROL
reward control to increase the weight of the simple solution indicator and decrease the weight of the...
constexpr Param< bool > ADJUSTTARGETNODES
should the target nodes be dynamically adjusted?
constexpr Param< bool > USEREDCOST
should reduced cost scores be used for variable prioritization?
constexpr Param< long long > WAITINGNODES
number of nodes since last incumbent solution that the heuristic should wait
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <alns>
constexpr Param< int > MAXCALLSSAMESOL
number of allowed executions of the heuristic on the same incumbent solution (-1: no limit,...
constexpr Param< bool > ADJUSTFIXINGRATE
should the heuristic adjust the target fixing rate based on the success?
constexpr Param< bool > ADJUSTMINIMPROVE
should the factor by which the minimum improvement is bound be dynamically updated?
constexpr Param< std::string > REWARDFILENAME
file name to store all rewards and the selection of the bandit
constexpr Param< double > MINIMPROVELOW
lower threshold for the minimal improvement over the incumbent
constexpr Param< double > ALPHA
parameter to increase the confidence width in UCB
constexpr Param< bool > USELOCALREDCOST
should local reduced costs be used for generic (un)fixing?
constexpr Param< bool > USEPSCOST
should pseudo cost scores be used for variable priorization?
constexpr Param< int > PRIORITY
priority of heuristic <alns>
constexpr Param< int > PRIORITY
priority of heuristic <bound>
constexpr Param< int > FREQ
frequency for calling primal heuristic <bound> (-1: never, 0: only at depth freqofs)
constexpr Param< bool > ONLYWITHOUTSOL
Should heuristic only be executed if no primal solution was found, yet?
constexpr Param< char > BOUND
to which bound should integer variables be fixed? ('l'ower, 'u'pper, or 'b'oth)
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <bound>
constexpr Param< int > MAXPROPROUNDS
maximum number of propagation rounds during probing (-1 infinity, -2 parameter settings)
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <bound> (-1: no limit)
constexpr Param< int > PRIORITY
priority of heuristic <clique>
constexpr Param< int > MAXPROPROUNDS
maximum number of propagation rounds during probing (-1 infinity)
constexpr Param< double > NODESQUOT
contingent of sub problem nodes in relation to the number of nodes of the original problem
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <clique> (-1: no limit)
constexpr Param< double > MINMIPFIXINGRATE
minimum percentage of fixed variables in the sub-MIP
constexpr Param< double > MININTFIXINGRATE
minimum percentage of integer variables that have to be fixable
constexpr Param< long long > NODESOFS
number of nodes added to the contingent of the total nodes
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <clique>
constexpr Param< bool > USELOCKFIXINGS
should more variables be fixed based on variable locks if the fixing rate was not reached?
constexpr Param< int > MAXBACKTRACKS
maximum number of backtracks during the fixing process
constexpr Param< double > MINIMPROVE
factor by which clique heuristic should at least improve the incumbent
constexpr Param< long long > MAXNODES
maximum number of nodes to regard in the subproblem
constexpr Param< long long > MINNODES
minimum number of nodes required to start the subproblem
constexpr Param< bool > COPYCUTS
should all active cuts from cutpool be copied to constraints in subproblem?
constexpr Param< int > FREQ
frequency for calling primal heuristic <clique> (-1: never, 0: only at depth freqofs)
constexpr Param< double > MAXDIVEAVGQUOT
maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed ...
constexpr Param< int > LPSOLVEFREQ
LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
constexpr Param< double > MAXDIVEAVGQUOTNOSOL
maximal AVGQUOT when no solution was found yet (0.0: no limit)
constexpr Param< int > FREQ
frequency for calling primal heuristic <coefdiving> (-1: never, 0: only at depth freqofs)
constexpr Param< double > MAXRELDEPTH
maximal relative depth to start diving
constexpr Param< bool > ONLYLPBRANCHCANDS
should only LP branching candidates be considered instead of the slower but more general constraint h...
constexpr Param< bool > BACKTRACK
use one level of backtracking if infeasibility is encountered?
constexpr Param< double > MAXDIVEUBQUOTNOSOL
maximal UBQUOT when no solution was found yet (0.0: no limit)
constexpr Param< double > MAXDIVEUBQUOT
maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0...
constexpr Param< int > PRIORITY
priority of heuristic <coefdiving>
constexpr Param< double > MAXLPITERQUOT
maximal fraction of diving LP iterations compared to node LP iterations
constexpr Param< double > MINRELDEPTH
minimal relative depth to start diving
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <coefdiving> (-1: no limit)
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <coefdiving>
constexpr Param< double > LPRESOLVEDOMCHGQUOT
percentage of immediate domain changes during probing to trigger LP resolve
constexpr Param< int > MAXLPITEROFS
additional number of allowed LP iterations
constexpr Param< long long > MAXLPITER
maximal number of LP iterations (-1: no limit)
constexpr Param< int > MAXCONTVARS
maximal number of continuous variables after presolving
constexpr Param< long long > MINNODES
minimum number of nodes required to start the subproblem
constexpr Param< double > MINIMPROVE
factor by which the incumbent should be improved at least
constexpr Param< long long > NODESOFS
number of nodes added to the contingent of the total nodes
constexpr Param< double > BOUNDWIDENING
bound widening factor applied to continuous variables (0: fix variables to given solution values,...
constexpr Param< double > LPLIMFAC
factor by which the limit on the number of LP depends on the node limit
constexpr Param< int > SOLUTIONS
heuristic stops, if the given number of improving solutions were found (-1: no limit)
constexpr Param< int > MAXPROPROUNDS
maximal number of iterations in propagation (-1: no limit)
constexpr Param< int > FREQ
frequency for calling primal heuristic <completesol> (-1: never, 0: only at depth freqofs)
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <completesol>
constexpr Param< bool > BEFOREPRESOL
should the heuristic run before presolving?
constexpr Param< double > NODESQUOT
contingent of sub problem nodes in relation to the number of nodes of the original problem
constexpr Param< long long > MAXNODES
maximum number of nodes to regard in the subproblem
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <completesol> (-1: no limit)
constexpr Param< double > MAXUNKNOWNRATE
maximal rate of unknown solution values
constexpr Param< int > PRIORITY
priority of heuristic <completesol>
constexpr Param< double > OBJWEIGHT
weight of the original objective function (1: only original objective)
constexpr Param< bool > ADDALLSOLS
should all subproblem solutions be added to the original SCIP?
constexpr Param< bool > IGNORECONT
should number of continuous variables be ignored?
constexpr Param< double > MAXRELDEPTH
maximal relative depth to start diving
constexpr Param< double > MINRELDEPTH
minimal relative depth to start diving
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <conflictdiving> (-1: no limit)
constexpr Param< int > FREQ
frequency for calling primal heuristic <conflictdiving> (-1: never, 0: only at depth freqofs)
constexpr Param< bool > BACKTRACK
use one level of backtracking if infeasibility is encountered?
constexpr Param< bool > MAXVIOL
try to maximize the violation
constexpr Param< double > MAXDIVEUBQUOT
maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0...
constexpr Param< bool > ONLYLPBRANCHCANDS
should only LP branching candidates be considered instead of the slower but more general constraint h...
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <conflictdiving>
constexpr Param< double > MAXDIVEAVGQUOT
maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed ...
constexpr Param< int > MINCONFLICTLOCKS
minimal number of conflict locks per variable
constexpr Param< double > LOCKWEIGHT
weight used in a convex combination of conflict and variable locks
constexpr Param< int > PRIORITY
priority of heuristic <conflictdiving>
constexpr Param< double > MAXDIVEUBQUOTNOSOL
maximal UBQUOT when no solution was found yet (0.0: no limit)
constexpr Param< int > LPSOLVEFREQ
LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
constexpr Param< double > LPRESOLVEDOMCHGQUOT
percentage of immediate domain changes during probing to trigger LP resolve
constexpr Param< double > MAXDIVEAVGQUOTNOSOL
maximal AVGQUOT when no solution was found yet (0.0: no limit)
constexpr Param< int > MAXLPITEROFS
additional number of allowed LP iterations
constexpr Param< double > MAXLPITERQUOT
maximal fraction of diving LP iterations compared to node LP iterations
constexpr Param< bool > LIKECOEF
perform rounding like coefficient diving
constexpr Param< bool > PERMUTE
should the subproblem be permuted to increase diversification?
constexpr Param< int > BESTSOLLIMIT
limit on number of improving incumbent solutions in sub-CIP
constexpr Param< int > NUSEDSOLS
number of solutions to be taken into account
constexpr Param< long long > MINNODES
minimum number of nodes required to start the subproblem
constexpr Param< bool > DONTWAITATROOT
should the nwaitingnodes parameter be ignored at the root node?
constexpr Param< long long > MAXNODES
maximum number of nodes to regard in the subproblem
constexpr Param< double > NODESQUOT
contingent of sub problem nodes in relation to the number of nodes of the original problem
constexpr Param< bool > USEUCT
should uct node selection be used at the beginning of the search?
constexpr Param< bool > USELPROWS
should subproblem be created out of the rows in the LP rows?
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <crossover> (-1: no limit)
constexpr Param< bool > RANDOMIZATION
should the choice which sols to take be randomized?
constexpr Param< double > MINIMPROVE
factor by which Crossover should at least improve the incumbent
constexpr Param< int > PRIORITY
priority of heuristic <crossover>
constexpr Param< bool > COPYCUTS
if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
constexpr Param< long long > NWAITINGNODES
number of nodes without incumbent change that heuristic should wait
constexpr Param< double > MINFIXINGRATE
minimum percentage of integer variables that have to be fixed
constexpr Param< long long > NODESOFS
number of nodes added to the contingent of the total nodes
constexpr Param< int > FREQ
frequency for calling primal heuristic <crossover> (-1: never, 0: only at depth freqofs)
constexpr Param< double > LPLIMFAC
factor by which the limit on the number of LP depends on the node limit
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <crossover>
constexpr Param< bool > USEUCT
should uct node selection be used at the beginning of the search?
constexpr Param< bool > USELPROWS
should subproblem be created out of the rows in the LP rows?
constexpr Param< double > LPLIMFAC
factor by which the limit on the number of LP depends on the node limit
constexpr Param< int > NEIGHBORHOODSIZE
radius (using Manhattan metric) of the incumbent's neighborhood to be searched
constexpr Param< long long > NODESOFS
number of nodes added to the contingent of the total nodes
constexpr Param< double > MINIMPROVE
factor by which dins should at least improve the incumbent
constexpr Param< bool > COPYCUTS
if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
constexpr Param< int > SOLNUM
number of pool-solutions to be checked for flag array update (for hard fixing of binary variables)
constexpr Param< int > BESTSOLLIMIT
limit on number of improving incumbent solutions in sub-CIP
constexpr Param< long long > MAXNODES
maximum number of nodes to regard in the subproblem
constexpr Param< long long > MINNODES
minimum number of nodes required to start the subproblem
constexpr Param< int > FREQ
frequency for calling primal heuristic <dins> (-1: never, 0: only at depth freqofs)
constexpr Param< double > NODESQUOT
contingent of sub problem nodes in relation to the number of nodes of the original problem
constexpr Param< int > PRIORITY
priority of heuristic <dins>
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <dins>
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <dins> (-1: no limit)
constexpr Param< long long > NWAITINGNODES
number of nodes without incumbent change that heuristic should wait
constexpr Param< double > MINFIXINGRATE
minimum percentage of integer variables that have to be fixable
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <distributiondiving> (-1: no limit)
constexpr Param< bool > BACKTRACK
use one level of backtracking if infeasibility is encountered?
constexpr Param< double > MAXLPITERQUOT
maximal fraction of diving LP iterations compared to node LP iterations
constexpr Param< double > MAXDIVEUBQUOT
maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0...
constexpr Param< int > PRIORITY
priority of heuristic <distributiondiving>
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <distributiondiving>
constexpr Param< double > MAXDIVEUBQUOTNOSOL
maximal UBQUOT when no solution was found yet (0.0: no limit)
constexpr Param< int > FREQ
frequency for calling primal heuristic <distributiondiving> (-1: never, 0: only at depth freqofs)
constexpr Param< double > MAXRELDEPTH
maximal relative depth to start diving
constexpr Param< char > SCOREPARAM
the score;largest 'd'ifference, 'l'owest cumulative probability,'h'ighest c.p., 'v'otes lowest c....
constexpr Param< int > MAXLPITEROFS
additional number of allowed LP iterations
constexpr Param< double > MAXDIVEAVGQUOTNOSOL
maximal AVGQUOT when no solution was found yet (0.0: no limit)
constexpr Param< double > MINRELDEPTH
minimal relative depth to start diving
constexpr Param< double > MAXDIVEAVGQUOT
maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed ...
constexpr Param< bool > ONLYLPBRANCHCANDS
should only LP branching candidates be considered instead of the slower but more general constraint h...
constexpr Param< int > LPSOLVEFREQ
LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
constexpr Param< double > LPRESOLVEDOMCHGQUOT
percentage of immediate domain changes during probing to trigger LP resolve
constexpr Param< int > PRIORITY
priority of heuristic <dps>
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <dps>
constexpr Param< bool > REUSE
should solutions get reused in subproblems?
constexpr Param< double > PENALTY
multiplier for absolute increase of penalty parameters (0: no increase)
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <dps> (-1: no limit)
constexpr Param< int > TIMING
should the heuristic run before or after the processing of the node? (0: before, 1: after,...
constexpr Param< double > MAXLINKSCORE
maximal linking score of used decomposition (equivalent to percentage of linking constraints)
constexpr Param< int > FREQ
frequency for calling primal heuristic <dps> (-1: never, 0: only at depth freqofs)
constexpr Param< bool > REOPTIMIZE
should the problem get reoptimized with the original objective function?
constexpr Param< int > MAXITERATIONS
maximal number of iterations
constexpr Param< bool > REOPTLIMITS
should strict limits for reoptimization be set?
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <dualval>
constexpr Param< int > DYNAMICDEPTH
says if and how the recursion depth is computed at runtime
constexpr Param< bool > ONLYCHEAPER
add constraint to ensure that discrete vars are improving
constexpr Param< bool > FORCEIMPROVEMENTS
exit if objective doesn't improve
constexpr Param< bool > RELAXINDICATORS
relax the indicator variables by introducing continuous copies
constexpr Param< bool > RELAXCONTVARS
relax the continous variables
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <dualval> (-1: no limit)
constexpr Param< int > NLPVERBLEVEL
verblevel of the nlp solver, can be 0 or 1
constexpr Param< int > PRIORITY
priority of heuristic <dualval>
constexpr Param< double > LAMBDAOBJ
scaling factor for the objective function
constexpr Param< double > MINGAP
minimal gap for which we still run the heuristic, if gap is less we return without doing anything
constexpr Param< int > MAXCALLS
maximal number of recursive calls of the heuristic (if dynamicdepth is off)
constexpr Param< int > FREQ
frequency for calling primal heuristic <dualval> (-1: never, 0: only at depth freqofs)
constexpr Param< int > MAXEQUALRANKS
maximal number of variables that may have maximal rank, quit if there are more, turn off by setting -...
constexpr Param< int > RANKVALUE
number of ranks that should be displayed when the heuristic is called
constexpr Param< bool > ONLYLEAVES
disable the heuristic if it was not called at a leaf of the B&B tree
constexpr Param< double > LAMBDASLACK
value added to objective of slack variables, must not be zero
constexpr Param< int > HEURVERBLEVEL
verblevel of the heuristic, default is 0 to display nothing
constexpr Param< bool > ONLYLPBRANCHCANDS
should only LP branching candidates be considered instead of the slower but more general constraint h...
constexpr Param< double > LPRESOLVEDOMCHGQUOT
percentage of immediate domain changes during probing to trigger LP resolve
constexpr Param< double > MAXRELDEPTH
maximal relative depth to start diving
constexpr Param< bool > BACKTRACK
use one level of backtracking if infeasibility is encountered?
constexpr Param< int > FREQ
frequency for calling primal heuristic <farkasdiving> (-1: never, 0: only at depth freqofs)
constexpr Param< double > MAXDIVEUBQUOTNOSOL
maximal UBQUOT when no solution was found yet (0.0: no limit)
constexpr Param< double > OBJDYNAMISM
minimal objective dynamism (log) to run
constexpr Param< double > MAXOBJOCC
maximal occurance factor of an objective coefficient
constexpr Param< int > MAXLPITEROFS
additional number of allowed LP iterations
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <farkasdiving> (-1: no limit)
constexpr Param< double > MAXDIVEAVGQUOTNOSOL
maximal AVGQUOT when no solution was found yet (0.0: no limit)
constexpr Param< bool > SCALESCORE
should the score be scaled?
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <farkasdiving>
constexpr Param< double > MAXDIVEUBQUOT
maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0...
constexpr Param< bool > ROOTSUCCESS
should the heuristic only run within the tree if at least one solution was found at the root node?
constexpr Param< double > MAXLPITERQUOT
maximal fraction of diving LP iterations compared to node LP iterations
constexpr Param< char > SCALETYPE
scale score by [f]ractionality or [i]mpact on farkasproof
constexpr Param< int > PRIORITY
priority of heuristic <farkasdiving>
constexpr Param< int > LPSOLVEFREQ
LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
constexpr Param< double > MAXDIVEAVGQUOT
maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed ...
constexpr Param< bool > CHECKCANDS
should diving candidates be checked before running?
constexpr Param< double > MINRELDEPTH
minimal relative depth to start diving
constexpr Param< int > CYCLELENGTH
maximum length of cycles to be checked explicitly in each round
constexpr Param< int > MAXSOLS
total number of feasible solutions found up to which heuristic is called (-1: no limit)
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <feaspump>
constexpr Param< int > FREQ
frequency for calling primal heuristic <feaspump> (-1: never, 0: only at depth freqofs)
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <feaspump> (-1: no limit)
constexpr Param< int > MAXLOOPS
maximal number of pumping loops (-1: no limit)
constexpr Param< double > ALPHA
initial weight of the objective function in the convex combination
constexpr Param< bool > STAGE3
should we solve a local branching sub-MIP if no solution could be found?
constexpr Param< double > MAXLPITERQUOT
maximal fraction of diving LP iterations compared to node LP iterations
constexpr Param< int > MAXLPITEROFS
additional number of allowed LP iterations
constexpr Param< double > ALPHADIFF
threshold difference for the convex parameter to perform perturbation
constexpr Param< int > PRIORITY
priority of heuristic <feaspump>
constexpr Param< double > OBJFACTOR
factor by which the regard of the objective is decreased in each round, 1.0 for dynamic
constexpr Param< int > MAXSTALLLOOPS
maximal number of pumping rounds without fractionality improvement (-1: no limit)
constexpr Param< int > NEIGHBORHOODSIZE
radius (using Manhattan metric) of the neighborhood to be searched in stage 3
constexpr Param< int > PERTURBFREQ
number of iterations until a random perturbation is forced
constexpr Param< bool > BEFORECUTS
should the feasibility pump be called at root node before cut separation?
constexpr Param< bool > PERTSOLFOUND
should a random perturbation be performed if a feasible solution was found?
constexpr Param< bool > COPYCUTS
should all active cuts from cutpool be copied to constraints in subproblem?
constexpr Param< int > MINFLIPS
minimum number of random variables to flip, if a 1-cycle is encountered
constexpr Param< bool > USEFP20
should an iterative round-and-propagate scheme be used to find the integral points?
constexpr Param< int > PRIORITY
priority of heuristic <fixandinfer>
constexpr Param< int > FREQ
frequency for calling primal heuristic <fixandinfer> (-1: never, 0: only at depth freqofs)
constexpr Param< int > MINFIXINGS
minimal number of fixings to apply before dive may be aborted
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <fixandinfer> (-1: no limit)
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <fixandinfer>
constexpr Param< int > PROPROUNDS
maximal number of propagation rounds in probing subproblems (-1: no limit, 0: auto)
constexpr Param< double > LPRESOLVEDOMCHGQUOT
percentage of immediate domain changes during probing to trigger LP resolve
constexpr Param< double > MAXRELDEPTH
maximal relative depth to start diving
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <fracdiving> (-1: no limit)
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <fracdiving>
constexpr Param< bool > BACKTRACK
use one level of backtracking if infeasibility is encountered?
constexpr Param< int > MAXLPITEROFS
additional number of allowed LP iterations
constexpr Param< int > FREQ
frequency for calling primal heuristic <fracdiving> (-1: never, 0: only at depth freqofs)
constexpr Param< double > MAXLPITERQUOT
maximal fraction of diving LP iterations compared to node LP iterations
constexpr Param< bool > ONLYLPBRANCHCANDS
should only LP branching candidates be considered instead of the slower but more general constraint h...
constexpr Param< double > MINRELDEPTH
minimal relative depth to start diving
constexpr Param< double > MAXDIVEUBQUOT
maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0...
constexpr Param< double > MAXDIVEAVGQUOTNOSOL
maximal AVGQUOT when no solution was found yet (0.0: no limit)
constexpr Param< int > LPSOLVEFREQ
LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
constexpr Param< int > PRIORITY
priority of heuristic <fracdiving>
constexpr Param< double > MAXDIVEUBQUOTNOSOL
maximal UBQUOT when no solution was found yet (0.0: no limit)
constexpr Param< double > MAXDIVEAVGQUOT
maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed ...
constexpr Param< bool > FIXCONTVARS
should continuous variables outside the neighborhoods be fixed?
constexpr Param< int > MAXDISTANCE
maximum distance to selected variable to enter the subproblem, or -1 to select the distance that best...
constexpr Param< int > NODESOFS
number of nodes added to the contingent of the total nodes
constexpr Param< int > FREQ
frequency for calling primal heuristic <gins> (-1: never, 0: only at depth freqofs)
constexpr Param< double > OVERLAP
overlap of blocks between runs - 0.0: no overlap, 1.0: shift by only 1 block
constexpr Param< int > PRIORITY
priority of heuristic <gins>
constexpr Param< bool > COPYCUTS
if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
constexpr Param< int > MAXNODES
maximum number of nodes to regard in the subproblem
constexpr Param< double > MINFIXINGRATE
percentage of integer variables that have to be fixed
constexpr Param< char > POTENTIAL
the reference point to compute the neighborhood potential: (r)oot, (l)ocal lp, or (p)seudo solution
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <gins>
constexpr Param< double > ROLLHORIZONLIMFAC
limiting percentage for variables already used in sub-SCIPs to terminate rolling horizon approach
constexpr Param< double > NODESQUOT
contingent of sub problem nodes in relation to the number of nodes of the original problem
constexpr Param< double > MINIMPROVE
factor by which gins should at least improve the incumbent
constexpr Param< bool > USEROLLINGHORIZON
should the heuristic solve a sequence of sub-MIP's around the first selected variable
constexpr Param< bool > USESELFALLBACK
should random initial variable selection be used if decomposition was not successful?
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <gins> (-1: no limit)
constexpr Param< bool > CONSECUTIVEBLOCKS
should blocks be treated consecutively (sorted by ascending label?)
constexpr Param< int > MINNODES
minimum number of nodes required to start the subproblem
constexpr Param< bool > USEDECOMP
should user decompositions be considered, if available?
constexpr Param< int > BESTSOLLIMIT
limit on number of improving incumbent solutions in sub-CIP
constexpr Param< int > NWAITINGNODES
number of nodes without incumbent change that heuristic should wait
constexpr Param< bool > RELAXDENSECONSS
should dense constraints (at least as dense as 1 - minfixingrate) be ignored by connectivity graph?
constexpr Param< bool > USEDECOMPROLLHORIZON
should user decompositions be considered for initial selection in rolling horizon,...
constexpr Param< bool > USELPROWS
should subproblem be created out of the rows in the LP rows?
constexpr Param< int > PRIORITY
priority of heuristic <guideddiving>
constexpr Param< double > LPRESOLVEDOMCHGQUOT
percentage of immediate domain changes during probing to trigger LP resolve
constexpr Param< bool > ONLYLPBRANCHCANDS
should only LP branching candidates be considered instead of the slower but more general constraint h...
constexpr Param< double > MINRELDEPTH
minimal relative depth to start diving
constexpr Param< double > MAXDIVEAVGQUOTNOSOL
maximal AVGQUOT when no solution was found yet (0.0: no limit)
constexpr Param< double > MAXDIVEUBQUOT
maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0...
constexpr Param< bool > BACKTRACK
use one level of backtracking if infeasibility is encountered?
constexpr Param< double > MAXRELDEPTH
maximal relative depth to start diving
constexpr Param< double > MAXDIVEAVGQUOT
maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed ...
constexpr Param< double > MAXLPITERQUOT
maximal fraction of diving LP iterations compared to node LP iterations
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <guideddiving> (-1: no limit)
constexpr Param< double > MAXDIVEUBQUOTNOSOL
maximal UBQUOT when no solution was found yet (0.0: no limit)
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <guideddiving>
constexpr Param< int > MAXLPITEROFS
additional number of allowed LP iterations
constexpr Param< int > FREQ
frequency for calling primal heuristic <guideddiving> (-1: never, 0: only at depth freqofs)
constexpr Param< int > LPSOLVEFREQ
LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
constexpr Param< int > LPSOLVEFREQ
LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
constexpr Param< bool > ONLYLPBRANCHCANDS
should only LP branching candidates be considered instead of the slower but more general constraint h...
constexpr Param< double > MAXDIVEUBQUOT
maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0...
constexpr Param< double > MAXDIVEAVGQUOT
maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed ...
constexpr Param< int > PRIORITY
priority of heuristic <indicatordiving>
constexpr Param< bool > RUNWITHOUTSCINDS
should heur run if there are no indicator constraints modeling semicont. vars?
constexpr Param< int > FREQ
frequency for calling primal heuristic <indicatordiving> (-1: never, 0: only at depth freqofs)
constexpr Param< double > MINRELDEPTH
minimal relative depth to start diving
constexpr Param< double > MAXLPITERQUOT
maximal fraction of diving LP iterations compared to node LP iterations
constexpr Param< double > MAXDIVEUBQUOTNOSOL
maximal UBQUOT when no solution was found yet (0.0: no limit)
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <indicatordiving>
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <indicatordiving> (-1: no limit)
constexpr Param< bool > BACKTRACK
use one level of backtracking if infeasibility is encountered?
constexpr Param< int > ROUNDINGMODE
decides which roundingmode is selected (0: conservative, 1: aggressive)
constexpr Param< double > ROUNDINGFRAC
in violation case all fractional below this value are fixed to constant
constexpr Param< int > SEMICONTSCOREMODE
which values of semi-continuous variables should get a high score? (0: low, 1: middle,...
constexpr Param< bool > USEVARBOUNDS
should varbound constraints be considered?
constexpr Param< int > MAXLPITEROFS
additional number of allowed LP iterations
constexpr Param< double > LPRESOLVEDOMCHGQUOT
percentage of immediate domain changes during probing to trigger LP resolve
constexpr Param< double > MAXDIVEAVGQUOTNOSOL
maximal AVGQUOT when no solution was found yet (0.0: no limit)
constexpr Param< double > MAXRELDEPTH
maximal relative depth to start diving
constexpr Param< bool > IMPROVESOLS
Try to improve other solutions by one-opt?
constexpr Param< int > PRIORITY
priority of heuristic <indicator>
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <indicator> (-1: no limit)
constexpr Param< bool > ONEOPT
whether the one-opt heuristic should be started
constexpr Param< int > FREQ
frequency for calling primal heuristic <indicator> (-1: never, 0: only at depth freqofs)
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <indicator>
constexpr Param< bool > BACKTRACK
use one level of backtracking if infeasibility is encountered?
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <intdiving>
constexpr Param< double > MAXLPITERQUOT
maximal fraction of diving LP iterations compared to node LP iterations
constexpr Param< double > MAXDIVEAVGQUOTNOSOL
maximal AVGQUOT when no solution was found yet (0.0: no limit)
constexpr Param< double > MAXDIVEUBQUOT
maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0...
constexpr Param< int > MAXLPITEROFS
additional number of allowed LP iterations
constexpr Param< int > PRIORITY
priority of heuristic <intdiving>
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <intdiving> (-1: no limit)
constexpr Param< double > MAXDIVEUBQUOTNOSOL
maximal UBQUOT when no solution was found yet (0.0: no limit)
constexpr Param< int > FREQ
frequency for calling primal heuristic <intdiving> (-1: never, 0: only at depth freqofs)
constexpr Param< double > MAXDIVEAVGQUOT
maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed ...
constexpr Param< double > MINRELDEPTH
minimal relative depth to start diving
constexpr Param< double > MAXRELDEPTH
maximal relative depth to start diving
constexpr Param< int > PRIORITY
priority of heuristic <intshifting>
constexpr Param< int > FREQ
frequency for calling primal heuristic <intshifting> (-1: never, 0: only at depth freqofs)
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <intshifting>
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <intshifting> (-1: no limit)
constexpr Param< bool > BACKTRACK
use one level of backtracking if infeasibility is encountered?
constexpr Param< int > FREQ
frequency for calling primal heuristic <linesearchdiving> (-1: never, 0: only at depth freqofs)
constexpr Param< double > MAXDIVEUBQUOT
maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0...
constexpr Param< double > MAXRELDEPTH
maximal relative depth to start diving
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <linesearchdiving>
constexpr Param< double > MAXDIVEUBQUOTNOSOL
maximal UBQUOT when no solution was found yet (0.0: no limit)
constexpr Param< bool > ONLYLPBRANCHCANDS
should only LP branching candidates be considered instead of the slower but more general constraint h...
constexpr Param< int > PRIORITY
priority of heuristic <linesearchdiving>
constexpr Param< int > LPSOLVEFREQ
LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
constexpr Param< double > MAXDIVEAVGQUOTNOSOL
maximal AVGQUOT when no solution was found yet (0.0: no limit)
constexpr Param< double > LPRESOLVEDOMCHGQUOT
percentage of immediate domain changes during probing to trigger LP resolve
constexpr Param< double > MINRELDEPTH
minimal relative depth to start diving
constexpr Param< int > MAXLPITEROFS
additional number of allowed LP iterations
constexpr Param< double > MAXLPITERQUOT
maximal fraction of diving LP iterations compared to node LP iterations
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <linesearchdiving> (-1: no limit)
constexpr Param< double > MAXDIVEAVGQUOT
maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed ...
constexpr Param< double > LPLIMFAC
factor by which the limit on the number of LP depends on the node limit
constexpr Param< bool > COPYCUTS
if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
constexpr Param< int > NWAITINGNODES
number of nodes without incumbent change that heuristic should wait
constexpr Param< double > NODESQUOT
contingent of sub problem nodes in relation to the number of nodes of the original problem
constexpr Param< int > FREQ
frequency for calling primal heuristic <localbranching> (-1: never, 0: only at depth freqofs)
constexpr Param< double > MINIMPROVE
factor by which localbranching should at least improve the incumbent
constexpr Param< int > MINNODES
minimum number of nodes required to start the subproblem
constexpr Param< int > BESTSOLLIMIT
limit on number of improving incumbent solutions in sub-CIP
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <localbranching>
constexpr Param< bool > USELPROWS
should subproblem be created out of the rows in the LP rows?
constexpr Param< int > PRIORITY
priority of heuristic <localbranching>
constexpr Param< int > MAXNODES
maximum number of nodes to regard in the subproblem
constexpr Param< int > NEIGHBORHOODSIZE
radius (using Manhattan metric) of the incumbent's neighborhood to be searched
constexpr Param< int > NODESOFS
number of nodes added to the contingent of the total nodes
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <localbranching> (-1: no limit)
constexpr Param< double > MINFIXINGRATE
minimum percentage of integer variables that have to be fixable
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <locks> (-1: no limit)
constexpr Param< double > NODESQUOT
contingent of sub problem nodes in relation to the number of nodes of the original problem
constexpr Param< double > MINFIXINGRATELP
minimum fixing rate over all variables (including continuous) to solve LP
constexpr Param< int > PRIORITY
priority of heuristic <locks>
constexpr Param< double > ROUNDUPPROBABILITY
probability for rounding a variable up in case of ties
constexpr Param< double > MINIMPROVE
factor by which locks heuristic should at least improve the incumbent
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <locks>
constexpr Param< int > MAXPROPROUNDS
maximum number of propagation rounds to be performed in each propagation call (-1: no limit,...
constexpr Param< long long > MAXNODES
maximum number of nodes to regard in the subproblem
constexpr Param< bool > UPDATELOCKS
should the locks be updated based on LP rows?
constexpr Param< bool > USEFINALSUBMIP
should a final sub-MIP be solved to costruct a feasible solution if the LP was not roundable?
constexpr Param< long long > MINNODES
minimum number of nodes required to start the subproblem
constexpr Param< bool > COPYCUTS
should all active cuts from cutpool be copied to constraints in subproblem?
constexpr Param< int > FREQ
frequency for calling primal heuristic <locks> (-1: never, 0: only at depth freqofs)
constexpr Param< long long > NODESOFS
number of nodes added to the contingent of the total nodes
constexpr Param< long long > MAXNODES
maximum number of nodes to regard in the subproblem
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <lpface>
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <lpface> (-1: no limit)
constexpr Param< char > SUBSCIPOBJECTIVE
objective function in the sub-SCIP: (z)ero, (r)oot-LP-difference, (i)nference, LP (f)ractionality,...
constexpr Param< long long > NODESOFS
number of nodes added to the contingent of the total nodes
constexpr Param< bool > COPYCUTS
if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
constexpr Param< double > MINFIXINGRATE
required percentage of fixed integer variables in sub-MIP to run
constexpr Param< int > PRIORITY
priority of heuristic <lpface>
constexpr Param< bool > DUALBASISEQUATIONS
should dually nonbasic rows be turned into equations?
constexpr Param< bool > USELPROWS
should subproblem be created out of the rows in the LP rows?
constexpr Param< double > NODESQUOT
contingent of sub problem nodes in relation to the number of nodes of the original problem
constexpr Param< int > FREQ
frequency for calling primal heuristic <lpface> (-1: never, 0: only at depth freqofs)
constexpr Param< double > LPLIMFAC
factor by which the limit on the number of LP depends on the node limit
constexpr Param< bool > KEEPSUBSCIP
should the heuristic continue solving the same sub-SCIP?
constexpr Param< int > MINPATHLEN
the minimum active search tree path length along which lower bound hasn't changed before heuristic be...
constexpr Param< long long > MINNODES
minimum number of nodes required to start the subproblem
constexpr Param< double > SUBNLPTRIGGER
maximum number of NLP iterations per solve
constexpr Param< double > MINIMPROVE
factor by which heuristic should at least improve the incumbent
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <mpec>
constexpr Param< double > SIGMA
regularization update factor
constexpr Param< int > PRIORITY
priority of heuristic <mpec>
constexpr Param< double > MAXNLPCOST
maximum cost available for solving NLPs per call of the heuristic
constexpr Param< int > MAXNLPITER
maximum number of NLP iterations per solve
constexpr Param< int > MAXNUNSUCC
maximum number of consecutive calls for which the heuristic did not find an improving solution
constexpr Param< int > MAXITER
maximum number of iterations of the MPEC loop
constexpr Param< double > INITTHETA
initial regularization right-hand side value
constexpr Param< int > FREQ
frequency for calling primal heuristic <mpec> (-1: never, 0: only at depth freqofs)
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <mpec> (-1: no limit)
constexpr Param< double > MINGAPLEFT
minimum amount of gap left in order to call the heuristic
constexpr Param< bool > ONLYNLPS
should the heuristic run only on continuous problems?
constexpr Param< int > PRIORITY
priority of heuristic <multistart>
constexpr Param< double > MINIMPRFAC
minimum required improving factor to proceed in improvement of a single point
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <multistart>
constexpr Param< int > MINIMPRITER
number of iteration when checking the minimum improvement
constexpr Param< int > MAXITER
number of iterations to reduce the maximum violation of a point
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <multistart> (-1: no limit)
constexpr Param< double > MAXBOUNDSIZE
maximum variable domain size for unbounded variables
constexpr Param< int > NRNDPOINTS
number of random points generated per execution call
constexpr Param< double > GRADLIMIT
limit for gradient computations for all improvePoint() calls (0 for no limit)
constexpr Param< int > FREQ
frequency for calling primal heuristic <multistart> (-1: never, 0: only at depth freqofs)
constexpr Param< double > MAXRELDIST
maximum distance between two points in the same cluster
constexpr Param< int > MAXNCLUSTER
maximum number of considered clusters per heuristic call
constexpr Param< int > BESTSOLLIMIT
limit on number of improving incumbent solutions in sub-CIP
constexpr Param< double > NODESQUOT
contingent of sub problem nodes in relation to the number of nodes of the original problem
constexpr Param< int > MAXNODES
maximum number of nodes to regard in the subproblem
constexpr Param< bool > USEUCT
should uct node selection be used at the beginning of the search?
constexpr Param< bool > USELPROWS
should subproblem be created out of the rows in the LP rows?
constexpr Param< int > NWAITINGNODES
number of nodes without incumbent change that heuristic should wait
constexpr Param< double > MINFIXINGRATE
percentage of integer variables that have to be fixed
constexpr Param< double > MINIMPROVE
factor by which mutation should at least improve the incumbent
constexpr Param< int > MINNODES
minimum number of nodes required to start the subproblem
constexpr Param< int > NODESOFS
number of nodes added to the contingent of the total nodes
constexpr Param< int > PRIORITY
priority of heuristic <mutation>
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <mutation>
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <mutation> (-1: no limit)
constexpr Param< bool > COPYCUTS
if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
constexpr Param< int > FREQ
frequency for calling primal heuristic <mutation> (-1: never, 0: only at depth freqofs)
constexpr Param< double > MINRELDEPTH
minimal relative depth to start diving
constexpr Param< bool > PREFERLPFRACS
prefer variables that are also fractional in LP solution?
constexpr Param< double > MINSUCCQUOT
heuristic will not run if less then this percentage of calls succeeded (0.0: no limit)
constexpr Param< bool > NLPFASTFAIL
should the NLP solver stop early if it converges slow?
constexpr Param< int > MAXNLPITERREL
additional allowed number of NLP iterations relative to successfully found solutions
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <nlpdiving>
constexpr Param< double > MAXDIVEUBQUOTNOSOL
maximal UBQUOT when no solution was found yet (0.0: no limit)
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <nlpdiving> (-1: no limit)
constexpr Param< double > MAXDIVEAVGQUOT
maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed ...
constexpr Param< char > VARSELRULE
which variable selection should be used? ('f'ractionality, 'c'oefficient, 'p'seudocost,...
constexpr Param< double > MAXDIVEUBQUOT
maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0...
constexpr Param< char > NLPSTART
which point should be used as starting point for the NLP solver? ('n'one, last 'f'easible,...
constexpr Param< bool > SOLVESUBMIP
should a sub-MIP be solved if all cover variables are fixed?
constexpr Param< double > MAXRELDEPTH
maximal relative depth to start diving
constexpr Param< int > MAXNLPITERABS
minimial absolute number of allowed NLP iterations
constexpr Param< bool > BACKTRACK
use one level of backtracking if infeasibility is encountered?
constexpr Param< int > MAXFEASNLPS
maximal number of NLPs with feasible solution to solve during one dive
constexpr Param< double > MAXDIVEAVGQUOTNOSOL
maximal AVGQUOT when no solution was found yet (0.0: no limit)
constexpr Param< bool > PREFERCOVER
should variables in a minimal cover be preferred?
constexpr Param< int > PRIORITY
priority of heuristic <nlpdiving>
constexpr Param< double > FIXQUOT
percentage of fractional variables that should be fixed before the next NLP solve
constexpr Param< int > FREQ
frequency for calling primal heuristic <nlpdiving> (-1: never, 0: only at depth freqofs)
constexpr Param< bool > LP
should the LP relaxation be solved before the NLP relaxation?
constexpr Param< int > FREQ
frequency for calling primal heuristic <objpscostdiving> (-1: never, 0: only at depth freqofs)
constexpr Param< int > PRIORITY
priority of heuristic <objpscostdiving>
constexpr Param< double > DEPTHFAC
maximal diving depth: number of binary/integer variables times depthfac
constexpr Param< double > DEPTHFACNOSOL
maximal diving depth factor if no feasible solution was found yet
constexpr Param< int > MAXSOLS
total number of feasible solutions found up to which heuristic is called (-1: no limit)
constexpr Param< int > MAXLPITEROFS
additional number of allowed LP iterations
constexpr Param< double > MAXLPITERQUOT
maximal fraction of diving LP iterations compared to total iteration number
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <objpscostdiving>
constexpr Param< double > MAXRELDEPTH
maximal relative depth to start diving
constexpr Param< double > MINRELDEPTH
minimal relative depth to start diving
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <objpscostdiving> (-1: no limit)
constexpr Param< bool > USEDIFFRAY
should the difference between the root solution and the current LP solution be used as one ray direct...
constexpr Param< bool > USEAVGRAY
should the average of the basic cone be used as one ray direction?
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <octane> (-1: no limit)
constexpr Param< int > PRIORITY
priority of heuristic <octane>
constexpr Param< int > FMAX
number of 0-1-points to be tested as possible solutions by OCTANE
constexpr Param< int > FREQ
frequency for calling primal heuristic <octane> (-1: never, 0: only at depth freqofs)
constexpr Param< bool > USEFRACSPACE
execute OCTANE only in the space of fractional variables (TRUE) or in the full space?
constexpr Param< int > FFIRST
number of 0-1-points to be tested at first whether they violate a common row
constexpr Param< bool > USEOBJRAY
should the inner normal of the objective be used as one ray direction?
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <octane>
constexpr Param< bool > USEAVGNBRAY
should the weighted average of the nonbasic cone be used as one ray direction?
constexpr Param< bool > USEAVGWGTRAY
should the weighted average of the basic cone be used as one ray direction?
constexpr Param< bool > ADDALLSOLS
should all subproblem solutions be added to the original SCIP?
constexpr Param< long long > MINNODES
minimum number of nodes required to start the subproblem
constexpr Param< bool > COPYCUTS
should all active cuts from cutpool be copied to constraints in subproblem?
constexpr Param< double > NODESQUOT
contingent of sub problem nodes in relation to the number of nodes of the original problem
constexpr Param< long long > NODESOFS
number of nodes added to the contingent of the total nodes
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <ofins>
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <ofins> (-1: no limit)
constexpr Param< double > MAXCHANGERATE
maximal rate of changed coefficients
constexpr Param< double > MAXCHANGE
maximal rate of change per coefficient to get fixed
constexpr Param< double > MINIMPROVE
factor by which RENS should at least improve the incumbent
constexpr Param< long long > MAXNODES
maximum number of nodes to regard in the subproblem
constexpr Param< double > LPLIMFAC
factor by which the limit on the number of LP depends on the node limit
constexpr Param< int > PRIORITY
priority of heuristic <ofins>
constexpr Param< int > FREQ
frequency for calling primal heuristic <ofins> (-1: never, 0: only at depth freqofs)
constexpr Param< bool > USELOOP
should the heuristic continue to run as long as improvements are found?
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <oneopt>
constexpr Param< int > PRIORITY
priority of heuristic <oneopt>
constexpr Param< bool > BEFOREPRESOL
should the heuristic be called before presolving?
constexpr Param< bool > DURINGROOT
should the heuristic be called before and during the root node?
constexpr Param< bool > WEIGHTEDOBJ
should the objective be weighted with the potential shifting value when sorting the shifting candidat...
constexpr Param< bool > FORCELPCONSTRUCTION
should the construction of the LP be forced even if LP solving is deactivated?
constexpr Param< int > FREQ
frequency for calling primal heuristic <oneopt> (-1: never, 0: only at depth freqofs)
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <oneopt> (-1: no limit)
constexpr Param< int > ADMITERATIONS
maximal number of ADM iterations in each penalty loop
constexpr Param< long long > MAXNODES
maximum number of nodes to regard in all subproblems
constexpr Param< int > PRIORITY
priority of heuristic <padm>
constexpr Param< bool > SCALING
enable sigmoid rescaling of penalty parameters
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <padm> (-1: no limit)
constexpr Param< bool > ASSIGNLINKING
should linking constraints be assigned?
constexpr Param< bool > ORIGINAL
should the original problem be used? This is only for testing and not recommended!
constexpr Param< int > PENALTYITERATIONS
maximal number of penalty iterations
constexpr Param< int > TIMING
should the heuristic run before or after the processing of the node? (0: before, 1: after,...
constexpr Param< double > NODEFAC
factor to control nodelimits of subproblems
constexpr Param< int > FREQ
frequency for calling primal heuristic <padm> (-1: never, 0: only at depth freqofs)
constexpr Param< bool > REOPTIMIZE
should the problem get reoptimized with the original objective function?
constexpr Param< long long > MINNODES
minimum number of nodes to regard in one subproblem
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <padm>
constexpr Param< double > GAP
mipgap at start
constexpr Param< long long > MAXLPITERS
maximum number of LP iterations to be performed in the subproblem
constexpr Param< int > FREQ
frequency for calling primal heuristic <proximity> (-1: never, 0: only at depth freqofs)
constexpr Param< double > NODESQUOT
sub-MIP node limit w.r.t number of original nodes
constexpr Param< bool > RESTART
should the heuristic immediately run again on its newly found solution?
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <proximity> (-1: no limit)
constexpr Param< long long > WAITINGNODES
waiting nodes since last incumbent before heuristic is executed
constexpr Param< bool > USEFINALLP
should the heuristic solve a final LP in case of continuous objective variables?
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <proximity>
constexpr Param< long long > MAXNODES
maximum number of nodes to regard in the subproblem
constexpr Param< double > MINGAP
minimum primal-dual gap for which the heuristic is executed
constexpr Param< int > PRIORITY
priority of heuristic <proximity>
constexpr Param< long long > MINLPITERS
minimum number of LP iterations performed in subproblem
constexpr Param< bool > USEUCT
should uct node selection be used at the beginning of the search?
constexpr Param< double > BINVARQUOT
threshold for percentage of binary variables required to start
constexpr Param< double > LPITERSQUOT
quotient of sub-MIP LP iterations with respect to LP iterations so far
constexpr Param< double > MINIMPROVE
factor by which proximity should at least improve the incumbent
constexpr Param< long long > MINNODES
minimum number of nodes required to start the subproblem
constexpr Param< bool > USELPROWS
should subproblem be constructed based on LP row information?
constexpr Param< long long > NODESOFS
number of nodes added to the contingent of the total nodes
constexpr Param< bool > ONLYLPBRANCHCANDS
should only LP branching candidates be considered instead of the slower but more general constraint h...
constexpr Param< double > MAXDIVEAVGQUOT
maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed ...
constexpr Param< double > MAXRELDEPTH
maximal relative depth to start diving
constexpr Param< int > MAXLPITEROFS
additional number of allowed LP iterations
constexpr Param< double > MAXDIVEAVGQUOTNOSOL
maximal AVGQUOT when no solution was found yet (0.0: no limit)
constexpr Param< int > PRIORITY
priority of heuristic <pscostdiving>
constexpr Param< double > MAXDIVEUBQUOTNOSOL
maximal UBQUOT when no solution was found yet (0.0: no limit)
constexpr Param< int > FREQ
frequency for calling primal heuristic <pscostdiving> (-1: never, 0: only at depth freqofs)
constexpr Param< double > MAXLPITERQUOT
maximal fraction of diving LP iterations compared to node LP iterations
constexpr Param< bool > BACKTRACK
use one level of backtracking if infeasibility is encountered?
constexpr Param< double > MINRELDEPTH
minimal relative depth to start diving
constexpr Param< double > MAXDIVEUBQUOT
maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0...
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <pscostdiving>
constexpr Param< int > LPSOLVEFREQ
LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
constexpr Param< double > LPRESOLVEDOMCHGQUOT
percentage of immediate domain changes during probing to trigger LP resolve
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <pscostdiving> (-1: no limit)
constexpr Param< bool > PROPAGATEONLYROOT
should the probing part of the heuristic be applied exclusively at the root node?
constexpr Param< int > FREQ
frequency for calling primal heuristic <randrounding> (-1: never, 0: only at depth freqofs)
constexpr Param< int > MAXPROPROUNDS
limit of rounds for each propagation call
constexpr Param< bool > USESIMPLEROUNDING
should the heuristic apply the variable lock strategy of simple rounding, if possible?
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <randrounding>
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <randrounding> (-1: no limit)
constexpr Param< bool > ONCEPERNODE
should the heuristic only be called once per node?
constexpr Param< int > PRIORITY
priority of heuristic <randrounding>
constexpr Param< long long > NODESOFS
number of nodes added to the contingent of the total nodes
constexpr Param< char > STARTSOL
solution that is used for fixing values ('l'p relaxation, 'n'lp relaxation)
constexpr Param< bool > BINARYBOUNDS
should general integers get binary bounds [floor(.),ceil(.)] ?
constexpr Param< bool > USEUCT
should uct node selection be used at the beginning of the search?
constexpr Param< bool > COPYCUTS
if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
constexpr Param< bool > USELPROWS
should subproblem be created out of the rows in the LP rows?
constexpr Param< int > FREQ
frequency for calling primal heuristic <rens> (-1: never, 0: only at depth freqofs)
constexpr Param< double > NODESQUOT
contingent of sub problem nodes in relation to the number of nodes of the original problem
constexpr Param< double > LPLIMFAC
factor by which the limit on the number of LP depends on the node limit
constexpr Param< double > MINIMPROVE
factor by which RENS should at least improve the incumbent
constexpr Param< bool > ADDALLSOLS
should all subproblem solutions be added to the original SCIP?
constexpr Param< long long > MINNODES
minimum number of nodes required to start the subproblem
constexpr Param< int > PRIORITY
priority of heuristic <rens>
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <rens>
constexpr Param< int > BESTSOLLIMIT
limit on number of improving incumbent solutions in sub-CIP
constexpr Param< double > MINFIXINGRATE
minimum percentage of integer variables that have to be fixable
constexpr Param< bool > EXTRATIME
should the RENS sub-CIP get its own full time limit? This is only for testing and not recommended!
constexpr Param< long long > MAXNODES
maximum number of nodes to regard in the subproblem
constexpr Param< bool > FULLSCALE
should the RENS sub-CIP be solved with cuts, conflicts, strong branching,... This is only for testing...
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <rens> (-1: no limit)
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <reoptsols>
constexpr Param< int > FREQ
frequency for calling primal heuristic <reoptsols> (-1: never, 0: only at depth freqofs)
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <reoptsols> (-1: no limit)
constexpr Param< int > MAXRUNS
check solutions of the last k runs. (-1: all)
constexpr Param< int > PRIORITY
priority of heuristic <reoptsols>
constexpr Param< int > MAXSOLS
maximal number solutions which should be checked. (-1: all)
constexpr Param< bool > USESLACKVARS
should slack variables be used in repair subproblem?
constexpr Param< double > NODESQUOT
contingent of sub problem nodes in relation to the number of nodes of the original problem
constexpr Param< int > PRIORITY
priority of heuristic <repair>
constexpr Param< double > MINFIXINGRATE
minimum percentage of integer variables that have to be fixed
constexpr Param< int > MINNODES
minimum number of nodes required to start the subproblem
constexpr Param< std::string > FILENAME
file name of a solution to be used as infeasible starting point, [-] if not available
constexpr Param< int > NODESOFS
number of nodes added to the contingent of the total nodes
constexpr Param< bool > USEOBJFACTOR
should a scaled objective function for original variables be used in repair subproblem?
constexpr Param< int > FREQ
frequency for calling primal heuristic <repair> (-1: never, 0: only at depth freqofs)
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <repair>
constexpr Param< bool > ROUNDIT
True : fractional variables which are not fractional in the given solution are rounded,...
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <repair> (-1: no limit)
constexpr Param< bool > USEVARFIX
should variable fixings be used in repair subproblem?
constexpr Param< int > MAXNODES
maximum number of nodes to regard in the subproblem
constexpr Param< double > ALPHA
factor for the potential of var fixings
constexpr Param< double > MINIMPROVE
factor by which rins should at least improve the incumbent
constexpr Param< int > NWAITINGNODES
number of nodes without incumbent change that heuristic should wait
constexpr Param< double > NODESQUOT
contingent of sub problem nodes in relation to the number of nodes of the original problem
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <rins> (-1: no limit)
constexpr Param< int > MAXNODES
maximum number of nodes to regard in the subproblem
constexpr Param< int > MINNODES
minimum number of nodes required to start the subproblem
constexpr Param< int > PRIORITY
priority of heuristic <rins>
constexpr Param< int > FREQ
frequency for calling primal heuristic <rins> (-1: never, 0: only at depth freqofs)
constexpr Param< double > MINFIXINGRATE
minimum percentage of integer variables that have to be fixed
constexpr Param< double > LPLIMFAC
factor by which the limit on the number of LP depends on the node limit
constexpr Param< bool > USEUCT
should uct node selection be used at the beginning of the search?
constexpr Param< bool > COPYCUTS
if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
constexpr Param< int > NODESOFS
number of nodes added to the contingent of the total nodes
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <rins>
constexpr Param< bool > USELPROWS
should subproblem be created out of the rows in the LP rows?
constexpr Param< double > DEPTHFACNOSOL
maximal diving depth factor if no feasible solution was found yet
constexpr Param< double > DEPTHFAC
maximal diving depth: number of binary/integer variables times depthfac
constexpr Param< int > FREQ
frequency for calling primal heuristic <rootsoldiving> (-1: never, 0: only at depth freqofs)
constexpr Param< int > MAXLPITEROFS
additional number of allowed LP iterations
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <rootsoldiving>
constexpr Param< double > MAXRELDEPTH
maximal relative depth to start diving
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <rootsoldiving> (-1: no limit)
constexpr Param< double > ALPHA
soft rounding factor to fade out objective coefficients
constexpr Param< int > PRIORITY
priority of heuristic <rootsoldiving>
constexpr Param< double > MINRELDEPTH
minimal relative depth to start diving
constexpr Param< int > MAXSOLS
total number of feasible solutions found up to which heuristic is called (-1: no limit)
constexpr Param< double > MAXLPITERQUOT
maximal fraction of diving LP iterations compared to node LP iterations
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <rounding> (-1: no limit)
constexpr Param< int > SUCCESSFACTOR
number of calls per found solution that are considered as standard success, a higher factor causes th...
constexpr Param< int > PRIORITY
priority of heuristic <rounding>
constexpr Param< bool > ONCEPERNODE
should the heuristic only be called once per node?
constexpr Param< int > FREQ
frequency for calling primal heuristic <rounding> (-1: never, 0: only at depth freqofs)
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <rounding>
constexpr Param< bool > ACTIVE
is this neighborhood active?
constexpr Param< double > MINFIXINGRATE
minimum fixing rate for this neighborhood
constexpr Param< double > PRIORITY
positive call priority to initialize bandit algorithms
constexpr Param< int > NSOLS
the number of solutions that crossover should combine
constexpr Param< double > MAXFIXINGRATE
maximum fixing rate for this neighborhood
constexpr Param< int > NPOOLSOLS
number of pool solutions where binary solution values must agree
constexpr Param< double > PRIORITY
positive call priority to initialize bandit algorithms
constexpr Param< bool > ACTIVE
is this neighborhood active?
constexpr Param< double > MINFIXINGRATE
minimum fixing rate for this neighborhood
constexpr Param< double > MAXFIXINGRATE
maximum fixing rate for this neighborhood
constexpr Param< double > PRIORITY
positive call priority to initialize bandit algorithms
constexpr Param< double > MINFIXINGRATE
minimum fixing rate for this neighborhood
constexpr Param< double > MAXFIXINGRATE
maximum fixing rate for this neighborhood
constexpr Param< bool > ACTIVE
is this neighborhood active?
constexpr Param< double > PRIORITY
positive call priority to initialize bandit algorithms
constexpr Param< bool > ACTIVE
is this neighborhood active?
constexpr Param< double > MINFIXINGRATE
minimum fixing rate for this neighborhood
constexpr Param< double > MAXFIXINGRATE
maximum fixing rate for this neighborhood
constexpr Param< double > PRIORITY
positive call priority to initialize bandit algorithms
constexpr Param< double > MINFIXINGRATE
minimum fixing rate for this neighborhood
constexpr Param< bool > ACTIVE
is this neighborhood active?
constexpr Param< double > MAXFIXINGRATE
maximum fixing rate for this neighborhood
constexpr Param< double > MINFIXINGRATE
minimum fixing rate for this neighborhood
constexpr Param< bool > ACTIVE
is this neighborhood active?
constexpr Param< double > PRIORITY
positive call priority to initialize bandit algorithms
constexpr Param< double > MAXFIXINGRATE
maximum fixing rate for this neighborhood
constexpr Param< double > MINFIXINGRATE
minimum fixing rate for this neighborhood
constexpr Param< double > PRIORITY
positive call priority to initialize bandit algorithms
constexpr Param< bool > ACTIVE
is this neighborhood active?
constexpr Param< double > MAXFIXINGRATE
maximum fixing rate for this neighborhood
constexpr Param< bool > ACTIVE
is this neighborhood active?
constexpr Param< double > MINFIXINGRATE
minimum fixing rate for this neighborhood
constexpr Param< double > PRIORITY
positive call priority to initialize bandit algorithms
constexpr Param< double > MAXFIXINGRATE
maximum fixing rate for this neighborhood
constexpr Param< double > VIOLPENALTY
the penalty for each change in the binary variables from the candidate solution
constexpr Param< double > PRIORITY
positive call priority to initialize bandit algorithms
constexpr Param< double > MAXFIXINGRATE
maximum fixing rate for this neighborhood
constexpr Param< bool > ACTIVE
is this neighborhood active?
constexpr Param< double > MINFIXINGRATE
minimum fixing rate for this neighborhood
constexpr Param< bool > SUBSCIPRANDSEEDS
should random seeds of sub-SCIPs be altered to increase diversification?
constexpr Param< double > FIXTOL
tolerance by which the fixing rate may be missed without generic fixing
constexpr Param< bool > INITDURINGROOT
should the heuristic be executed multiple times during the root node?
constexpr Param< long long > NODESOFS
offset added to the nodes budget
constexpr Param< int > SEED
initial random seed for bandit algorithms and random decisions by neighborhoods
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <scheduler>
constexpr Param< char > BANDITALGO
the bandit algorithm: (u)pper confidence bounds, (e)xp.3, epsilon (g)reedy, exp.3-(i)x
constexpr Param< int > FREQ
frequency for calling primal heuristic <scheduler> (-1: never, 0: only at depth freqofs)
constexpr Param< double > BETA
reward offset between 0 and 1 at every observation for Exp.3
constexpr Param< double > EPS
increase exploration in epsilon-greedy bandit algorithm
constexpr Param< bool > DEFAULTROOT
should the default priorities be used at the root node?
constexpr Param< bool > USESUBSCIPHEURS
should the heuristic activate other sub-SCIP heuristics during its search?
constexpr Param< long long > MINNODES
minimum number of nodes required to start a sub-SCIP
constexpr Param< double > SOLREWARDWEIGHT
weight by how much finding a new incumbent is rewarded in reward function
constexpr Param< double > EFFORTREWARDWEIGHT
weight by how much effort is rewarded in reward function
constexpr Param< double > ALPHA
parameter to increase the confidence width in UCB
constexpr Param< bool > COPYCUTS
should cutting planes be copied to the sub-SCIP?
constexpr Param< long long > INITDIVINGNODELIMIT
initial node limit for diving heuristics
constexpr Param< double > NODESQUOT
fraction of nodes compared to the main SCIP for budget computation
constexpr Param< int > NSOLSLIM
limit on the number of improving solutions in a sub-SCIP call
constexpr Param< bool > USEREDCOST
should reduced cost scores be used for variable prioritization?
constexpr Param< double > QUALREWARDWEIGHT
weight by how much quality of a new incumbent is rewarded in reward function
constexpr Param< int > INITLNSNODELIMIT
initial node limit for LNS heuristics
constexpr Param< int > NSELECTIONS
number of heuristics picked by the scheduler in one call (-1: number of controlled heuristics,...
constexpr Param< long long > WAITINGNODES
number of nodes since last incumbent solution that the heuristic should wait
constexpr Param< bool > RESETWEIGHTS
should the bandit algorithms be reset when a new problem is read?
constexpr Param< double > NODESQUOTMIN
lower bound fraction of nodes compared to the main SCIP for budget computation
constexpr Param< bool > USEPSCOST
should pseudo cost scores be used for variable priorization?
constexpr Param< double > CONFLICTREWARDWEIGHT
weight by how much number of conflicts found by diving is rewarded in reward function
constexpr Param< bool > USEDISTANCES
distances from fixed variables be used for variable prioritization
constexpr Param< double > GAMMA
weight between uniform (gamma ~ 1) and weight driven (gamma ~ 0) probability distribution for exp3
constexpr Param< long long > MAXNODES
maximum number of nodes to regard in the subproblem
constexpr Param< bool > USELOCALREDCOST
should local reduced costs be used for generic (un)fixing?
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <scheduler> (-1: no limit)
constexpr Param< double > TARGETNODEFACTOR
factor by which target node number is eventually increased
constexpr Param< int > MAXCALLSSAMESOL
number of allowed executions of the heuristic on the same incumbent solution (-1: no limit,...
constexpr Param< double > HEURTIMELIMIT
time limit for a single heuristic run
constexpr Param< int > PRIORITY
priority of heuristic <scheduler>
constexpr Param< double > UNFIXTOL
tolerance by which the fixing rate may be exceeded without generic unfixing
constexpr Param< bool > EPSGREEDY_USEMOD
TRUE if modified version of the epsilon-greedy bandit algorithm should be used.
constexpr Param< bool > PREFERBINARIES
Should binary variables be shifted first?
constexpr Param< bool > SORTVARS
Should variables be sorted for the heuristic?
constexpr Param< int > FREQ
frequency for calling primal heuristic <shiftandpropagate> (-1: never, 0: only at depth freqofs)
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <shiftandpropagate> (-1: no limit)
constexpr Param< bool > IMPLISCONTINUOUS
should implicit integer variables be treated as continuous variables?
constexpr Param< bool > RELAX
Should continuous variables be relaxed?
constexpr Param< bool > FIXBINLOCKS
should binary variables with no locks in one direction be fixed to that direction?
constexpr Param< double > MINFIXINGRATELP
minimum fixing rate over all variables (including continuous) to solve LP
constexpr Param< int > PRIORITY
priority of heuristic <shiftandpropagate>
constexpr Param< bool > SELECTBEST
should the heuristic choose the best candidate in every round? (set to FALSE for static order)?
constexpr Param< bool > STOPAFTERFEASIBLE
Should the heuristic stop calculating optimal shift values when no more rows are violated?
constexpr Param< bool > COLLECTSTATS
should variable statistics be collected during probing?
constexpr Param< int > CUTOFFBREAKER
The number of cutoffs before heuristic stops.
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <shiftandpropagate>
constexpr Param< char > SORTKEY
the key for variable sorting: (n)orms down, norms (u)p, (v)iolations down, viola(t)ions up,...
constexpr Param< int > NPROPROUNDS
The number of propagation rounds used for each propagation.
constexpr Param< bool > PROBING
Should domains be reduced by probing?
constexpr Param< bool > ONLYWITHOUTSOL
Should heuristic only be executed if no primal solution was found, yet?
constexpr Param< bool > NORMALIZE
should coefficients be normalized by max row coeff for col norm?
constexpr Param< bool > BINLOCKSFIRST
should binary variables with no locks be preferred in the ordering?
constexpr Param< double > MAXCUTOFFQUOT
maximum percentage of allowed cutoffs before stopping the heuristic
constexpr Param< bool > NOZEROFIXING
should variables with a zero shifting value be delayed instead of being fixed?
constexpr Param< bool > UPDATEWEIGHTS
should row weight be increased every time the row is violated?
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <shifting> (-1: no limit)
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <shifting>
constexpr Param< int > PRIORITY
priority of heuristic <shifting>
constexpr Param< int > FREQ
frequency for calling primal heuristic <shifting> (-1: never, 0: only at depth freqofs)
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <simplerounding>
constexpr Param< int > PRIORITY
priority of heuristic <simplerounding>
constexpr Param< int > FREQ
frequency for calling primal heuristic <simplerounding> (-1: never, 0: only at depth freqofs)
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <simplerounding> (-1: no limit)
constexpr Param< bool > ONCEPERNODE
should the heuristic only be called once per node?
constexpr Param< int > ITERMIN
minimal number of iterations for NLP solves
constexpr Param< bool > FORBIDFIXINGS
whether to add constraints that forbid specific fixings that turned out to be infeasible
constexpr Param< double > FEASTOLFACTOR
factor on SCIP feasibility tolerance for NLP solves if resolving when NLP solution not feasible in CI...
constexpr Param< int > NODESOFFSET
number of nodes added to the current number of nodes when computing itercontingent (higher value runs...
constexpr Param< int > FREQ
frequency for calling primal heuristic <subnlp> (-1: never, 0: only at depth freqofs)
constexpr Param< int > NLPVERBLEVEL
verbosity level of NLP solver
constexpr Param< double > EXPECTINFEAS
percentage of NLP solves with infeasible status required to tell NLP solver to expect an infeasible N...
constexpr Param< int > ITERINIT
number of iterations used for initial NLP solves
constexpr Param< double > NODESFACTOR
factor on number of nodes in SCIP (plus nodesoffset) to compute itercontingent (higher value runs heu...
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <subnlp>
constexpr Param< bool > SETCUTOFF
whether to set cutoff in sub-SCIP to current primal bound
constexpr Param< int > PRIORITY
priority of heuristic <subnlp>
constexpr Param< double > SUCCESSRATEEXP
exponent for power of success rate to be multiplied with itercontingent (lower value decreases impact...
constexpr Param< double > OPTTOL
absolute optimality tolerance to use for NLP solves
constexpr Param< int > NINITSOLVES
number of successful NLP solves until switching to iterlimit guess and using success rate
constexpr Param< bool > KEEPCOPY
whether to keep SCIP copy or to create new copy each time heuristic is applied
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <subnlp> (-1: no limit)
constexpr Param< int > MAXPRESOLVEROUNDS
limit on number of presolve rounds in sub-SCIP (-1 for unlimited, 0 for no presolve)
constexpr Param< int > PRESOLVEEMPHASIS
presolve emphasis in sub-SCIP (0: default, 1: aggressive, 2: fast, 3: off)
constexpr Param< int > FREQ
frequency for calling primal heuristic <trivial> (-1: never, 0: only at depth freqofs)
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <trivial>
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <trivial> (-1: no limit)
constexpr Param< int > PRIORITY
priority of heuristic <trivial>
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <trivialnegation> (-1: no limit)
constexpr Param< int > FREQ
frequency for calling primal heuristic <trivialnegation> (-1: never, 0: only at depth freqofs)
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <trivialnegation>
constexpr Param< int > PRIORITY
priority of heuristic <trivialnegation>
constexpr Param< bool > USELPROWS
should subproblem be created out of the rows in the LP rows?
constexpr Param< double > VIOLPENALTY
the penalty for each change in the binary variables from the candidate solution
constexpr Param< int > FREQ
frequency for calling primal heuristic <trustregion> (-1: never, 0: only at depth freqofs)
constexpr Param< double > OBJMINIMPROVE
the minimum absolute improvement in the objective function value
constexpr Param< double > NODESQUOT
contingent of sub problem nodes in relation to the number of nodes of the original problem
constexpr Param< int > PRIORITY
priority of heuristic <trustregion>
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <trustregion> (-1: no limit)
constexpr Param< double > LPLIMFAC
factor by which the limit on the number of LP depends on the node limit
constexpr Param< int > BESTSOLLIMIT
limit on number of improving incumbent solutions in sub-CIP
constexpr Param< bool > COPYCUTS
if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?
constexpr Param< int > MINBINVARS
the number of binary variables necessary to run the heuristic
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <trustregion>
constexpr Param< int > MAXNODES
maximum number of nodes to regard in the subproblem
constexpr Param< int > MINNODES
minimum number of nodes required to start the subproblem
constexpr Param< int > NWAITINGNODES
number of nodes without incumbent change that heuristic should wait
constexpr Param< int > NODESOFS
number of nodes added to the contingent of the total nodes
constexpr Param< int > PRIORITY
priority of heuristic <trysol>
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <trysol>
constexpr Param< int > FREQ
frequency for calling primal heuristic <trysol> (-1: never, 0: only at depth freqofs)
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <trysol> (-1: no limit)
constexpr Param< int > PRIORITY
priority of heuristic <twoopt>
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <twoopt>
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <twoopt> (-1: no limit)
constexpr Param< int > MAXNSLAVES
maximum number of slaves for one master variable
constexpr Param< int > FREQ
frequency for calling primal heuristic <twoopt> (-1: never, 0: only at depth freqofs)
constexpr Param< double > MATCHINGRATE
parameter to determine the percentage of rows two variables have to share before they are considered ...
constexpr Param< int > WAITINGNODES
user parameter to determine number of nodes to wait after last best solution before calling heuristic
constexpr Param< bool > INTOPT
Should Integer-2-Optimization be applied or not?
constexpr Param< std::string > FIXINGALTS
prioritized sequence of fixing values used ('l'p relaxation, 'n'lp relaxation, 'i'ncumbent solution)
constexpr Param< char > FIXINGORDER
order in which variables should be fixed (increasing 'C'onflict score, decreasing 'c'onflict score,...
constexpr Param< char > COVERINGOBJ
objective function of the covering problem (influenced nonlinear 'c'onstraints/'t'erms,...
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <undercover> (-1: no limit)
constexpr Param< double > RECOVERDIV
fraction of covering variables in the last cover which need to change their value when recovering
constexpr Param< double > MINIMPROVE
factor by which the heuristic should at least improve the incumbent
constexpr Param< long long > MINNODES
minimum number of nodes required to start the subproblem
constexpr Param< bool > FIXINTFIRST
should integer variables in the cover be fixed first?
constexpr Param< int > FREQ
frequency for calling primal heuristic <undercover> (-1: never, 0: only at depth freqofs)
constexpr Param< long long > MAXNODES
maximum number of nodes to regard in the subproblem
constexpr Param< int > MINCOVEREDABS
minimum number of nonlinear constraints in the original problem
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <undercover>
constexpr Param< bool > LOCKSROUNDING
shall LP values for integer vars be rounded according to locks?
constexpr Param< bool > COPYCUTS
should all active cuts from cutpool be copied to constraints in subproblem?
constexpr Param< bool > COVERBD
should bounddisjunction constraints be covered (or just copied)?
constexpr Param< int > MAXRECOVERS
maximum number of recoverings
constexpr Param< double > MAXCOVERSIZECONSS
maximum coversize (as ratio to the percentage of non-affected constraints)
constexpr Param< double > NODESQUOT
contingent of sub problem nodes in relation to the number of nodes of the original problem
constexpr Param< double > MAXCOVERSIZEVARS
maximum coversize (as fraction of total number of variables)
constexpr Param< bool > BEFORECUTS
should the heuristic be called at root node before cut separation?
constexpr Param< bool > COVERNL
should nonlinear constraints be covered (or just copied)?
constexpr Param< bool > ONLYCONVEXIFY
should we only fix variables in order to obtain a convex problem?
constexpr Param< int > MAXBACKTRACKS
maximum number of backtracks in fix-and-propagate
constexpr Param< long long > NODESOFS
number of nodes added to the contingent of the total nodes
constexpr Param< double > INFERENCEWEIGHT
weight for inference score in fixing order
constexpr Param< bool > POSTNLP
should the NLP heuristic be called to polish a feasible solution?
constexpr Param< int > MAXREORDERS
maximum number of reorderings of the fixing order
constexpr Param< double > CUTOFFWEIGHT
weight for cutoff score in fixing order
constexpr Param< bool > COVERIND
should indicator constraints be covered (or just copied)?
constexpr Param< double > CONFLICTWEIGHT
weight for conflict score in fixing order
constexpr Param< double > MINCOVEREDREL
minimum percentage of nonlinear constraints in the original problem
constexpr Param< bool > COVERAND
should and constraints be covered (or just copied)?
constexpr Param< bool > REUSECOVER
shall the cover be reused if a conflict was added after an infeasible subproblem?
constexpr Param< int > PRIORITY
priority of heuristic <undercover>
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <vbounds> (-1: no limit)
constexpr Param< long long > NODESOFS
number of nodes added to the contingent of the total nodes
constexpr Param< int > MAXBACKTRACKS
maximum number of backtracks during the fixing process
constexpr Param< double > MINIMPROVE
factor by which vbounds heuristic should at least improve the incumbent
constexpr Param< long long > MINNODES
minimum number of nodes required to start the subproblem
constexpr Param< int > MAXPROPROUNDS
maximum number of propagation rounds during probing (-1 infinity)
constexpr Param< long long > MAXNODES
maximum number of nodes to regard in the subproblem
constexpr Param< double > MINMIPFIXINGRATE
minimum percentage of variables that have to be fixed within sub-SCIP (integer and continuous)
constexpr Param< bool > USELOCKFIXINGS
should more variables be fixed based on variable locks if the fixing rate was not reached?
constexpr Param< int > FREQ
frequency for calling primal heuristic <vbounds> (-1: never, 0: only at depth freqofs)
constexpr Param< bool > COPYCUTS
should all active cuts from cutpool be copied to constraints in subproblem?
constexpr Param< int > TIGHTENVARIANT
which tightening variants of the vbounds heuristic should be called? (0: off, 1: w/o looking at obj,...
constexpr Param< int > PRIORITY
priority of heuristic <vbounds>
constexpr Param< double > NODESQUOT
contingent of sub problem nodes in relation to the number of nodes of the original problem
constexpr Param< double > MININTFIXINGRATE
minimum percentage of integer variables that have to be fixed
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <vbounds>
constexpr Param< int > FEASVARIANT
which variants of the vbounds heuristic that try to stay feasible should be called?...
constexpr Param< double > MAXDIVEUBQUOTNOSOL
maximal UBQUOT when no solution was found yet (0.0: no limit)
constexpr Param< int > LPSOLVEFREQ
LP solve frequency for diving heuristics (0: only after enough domain changes have been found)
constexpr Param< bool > ONLYLPBRANCHCANDS
should only LP branching candidates be considered instead of the slower but more general constraint h...
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <veclendiving> (-1: no limit)
constexpr Param< double > MAXDIVEAVGQUOT
maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed ...
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <veclendiving>
constexpr Param< bool > BACKTRACK
use one level of backtracking if infeasibility is encountered?
constexpr Param< double > MAXRELDEPTH
maximal relative depth to start diving
constexpr Param< double > MAXDIVEUBQUOT
maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0...
constexpr Param< double > MAXDIVEAVGQUOTNOSOL
maximal AVGQUOT when no solution was found yet (0.0: no limit)
constexpr Param< double > MAXLPITERQUOT
maximal fraction of diving LP iterations compared to node LP iterations
constexpr Param< int > PRIORITY
priority of heuristic <veclendiving>
constexpr Param< int > MAXLPITEROFS
additional number of allowed LP iterations
constexpr Param< double > LPRESOLVEDOMCHGQUOT
percentage of immediate domain changes during probing to trigger LP resolve
constexpr Param< double > MINRELDEPTH
minimal relative depth to start diving
constexpr Param< int > FREQ
frequency for calling primal heuristic <veclendiving> (-1: never, 0: only at depth freqofs)
constexpr Param< bool > USEUCT
should uct node selection be used at the beginning of the search?
constexpr Param< double > NODESQUOT
contingent of sub problem nodes in relation to the number of nodes of the original problem
constexpr Param< bool > ONLYWITHOUTSOL
should heuristic only be executed if no primal solution was found, yet?
constexpr Param< long long > MINNODES
minimum number of nodes required to start the subproblem
constexpr Param< int > PRIORITY
priority of heuristic <zeroobj>
constexpr Param< bool > ADDALLSOLS
should all subproblem solutions be added to the original SCIP?
constexpr Param< long long > NODESOFS
number of nodes added to the contingent of the total nodes
constexpr Param< double > MINIMPROVE
factor by which zeroobj should at least improve the incumbent
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <zeroobj> (-1: no limit)
constexpr Param< long long > MAXNODES
maximum number of nodes to regard in the subproblem
constexpr Param< int > FREQ
frequency for calling primal heuristic <zeroobj> (-1: never, 0: only at depth freqofs)
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <zeroobj>
constexpr Param< long long > MAXLPITERS
maximum number of LP iterations to be performed in the subproblem
constexpr Param< int > PRIORITY
priority of heuristic <zirounding>
constexpr Param< int > MAXROUNDINGLOOPS
determines maximum number of rounding loops
constexpr Param< bool > STOPZIROUND
flag to determine if Zirounding is deactivated after a certain percentage of unsuccessful calls
constexpr Param< int > FREQ
frequency for calling primal heuristic <zirounding> (-1: never, 0: only at depth freqofs)
constexpr Param< double > STOPPERCENTAGE
if percentage of found solutions falls below this parameter, Zirounding will be deactivated
constexpr Param< int > FREQOFS
frequency offset for calling primal heuristic <zirounding>
constexpr Param< int > MAXDEPTH
maximal depth level to call primal heuristic <zirounding> (-1: no limit)
constexpr Param< int > MINSTOPNCALLS
determines the minimum number of calls before percentage-based deactivation of Zirounding is applied
constexpr Param< bool > USEUCTSUBSCIP
should setting of common subscip parameters include the activation of the UCT node selector?
constexpr Param< bool > ALLOWTRANSFER
should variable histories be transferred to initialize SCIP copies?
constexpr Param< bool > ALLOWMERGE
should variable histories be merged from sub-SCIPs whenever possible?
constexpr Param< bool > VALUEBASED
should statistics be collected for variable domain value pairs?
constexpr Param< double > MEMORY
maximal memory usage in MB; reported memory usage is lower than real memory usage!
constexpr Param< long long > TOTALNODES
maximal number of total nodes (incl. restarts) to process (-1: no limit)
constexpr Param< long long > STALLNODES
solving stops, if the given number of nodes was processed since the last improvement of the primal so...
constexpr Param< double > DUAL
solving stops, if dual bound is at least as good as given value
constexpr Param< int > RESTARTS
solving stops, if the given number of restarts was triggered (-1: no limit)
constexpr Param< double > TIME
maximal time in seconds to run
constexpr Param< long long > NODES
maximal number of nodes to process (-1: no limit)
constexpr Param< int > MAXSOL
maximal number of solutions to store in the solution storage
constexpr Param< double > PRIMAL
solving stops, if primal bound is at least as good as given value (alias objectivestop)
constexpr Param< double > GAP
solving stops, if the relative gap = |primal - dual|/MIN(|dual|,|primal|) is below the given value,...
constexpr Param< int > AUTORESTARTNODES
if solve exceeds this number of nodes for the first time, an automatic restart is triggered (-1: no a...
constexpr Param< int > SOLUTIONS
solving stops, if the given number of solutions were found; this limit is first checked in presolving...
constexpr Param< double > ABSGAP
solving stops, if the absolute gap = |primalbound - dualbound| is below the given value
constexpr Param< int > MAXORIGSOL
maximal number of solutions candidates to store in the solution storage of the original problem
constexpr Param< double > SOFTTIME
soft time limit which should be applied after first solution was found (-1.0: disabled)
constexpr Param< int > BESTSOL
solving stops, if the given number of solution improvements were found (-1: no limit)
constexpr Param< double > MINMARKOWITZ
minimal Markowitz threshold to control sparsity/stability in LU factorization
constexpr Param< int > DISABLECUTOFF
disable the cutoff bound in the LP solver? (0: enabled, 1: disabled, 2: auto)
constexpr Param< int > SCALING
LP scaling (0: none, 1: normal, 2: aggressive)
constexpr Param< int > COLAGELIMIT
maximum age a dynamic column can reach before it is deleted from the LP (-1: don't delete columns due...
constexpr Param< bool > CHECKDUALFEAS
should LP solutions be checked for dual feasibility, resolving LP when numerical troubles occur?
constexpr Param< bool > FREESOLVALBUFFERS
should the buffers for storing LP solution values during diving be freed at end of diving?
constexpr Param< bool > PRESOLVING
should presolving of LP solver be used?
constexpr Param< char > RESOLVEALGORITHM
LP algorithm for resolving LP relaxations if a starting basis exists (automatic 's'implex,...
constexpr Param< bool > LEXDUALROOTONLY
should the lexicographic dual algorithm be applied only at the root node
constexpr Param< bool > CLEANUPCOLSROOT
should new non-basic columns be removed after root LP solving?
constexpr Param< bool > RESOLVERESTORE
should the LP be resolved to restore the state at start of diving (if FALSE we buffer the solution va...
constexpr Param< long long > ROOTITERLIM
iteration limit for initial root LP solve (-1: no limit)
constexpr Param< bool > LEXDUALSTALLING
turn on the lex dual algorithm only when stalling?
constexpr Param< bool > LEXDUALBASIC
choose fractional basic variables in lexicographic dual algorithm?
constexpr Param< bool > CLEARINITIALPROBINGLP
should lp state be cleared at the end of probing mode when lp was initially unsolved,...
constexpr Param< char > PRICING
LP pricing strategy ('l'pi default, 'a'uto, 'f'ull pricing, 'p'artial, 's'teepest edge pricing,...
constexpr Param< bool > LEXDUALALGO
should the lexicographic dual algorithm be used?
constexpr Param< int > FASTMIP
which FASTMIP setting of LP solver should be used? 0: off, 1: low
constexpr Param< bool > CLEANUPROWSROOT
should new basic rows be removed after root LP solving?
constexpr Param< int > RESOLVEITERMIN
minimum number of iterations that are allowed for LP resolve
constexpr Param< bool > CLEANUPCOLS
should new non-basic columns be removed after LP solving?
constexpr Param< int > REFACTORINTERVAL
LP refactorization interval (0: auto)
constexpr Param< bool > CLEANUPROWS
should new basic rows be removed after LP solving?
constexpr Param< int > THREADS
number of threads used for solving the LP (0: automatic)
constexpr Param< double > RESOLVEITERFAC
factor of average LP iterations that is used as LP iteration limit for LP resolve (-1: unlimited)
constexpr Param< int > LEXDUALMAXROUNDS
maximum number of rounds in the lexicographic dual algorithm (-1: unbounded)
constexpr Param< int > SOLUTIONPOLISHING
LP solution polishing method (0: disabled, 1: only root, 2: always, 3: auto)
constexpr Param< int > ROWAGELIMIT
maximum age a dynamic row can reach before it is deleted from the LP (-1: don't delete rows due to ag...
constexpr Param< double > ROWREPSWITCH
simplex algorithm shall use row representation of the basis if number of rows divided by number of co...
constexpr Param< int > SOLVEFREQ
frequency for solving LP at the nodes (-1: never; 0: only root LP)
constexpr Param< bool > CHECKFARKAS
should infeasibility proofs from the LP be checked?
constexpr Param< char > INITALGORITHM
LP algorithm for solving initial LP relaxations (automatic 's'implex, 'p'rimal simplex,...
constexpr Param< bool > CHECKPRIMFEAS
should LP solutions be checked for primal feasibility, resolving LP when numerical troubles occur?
constexpr Param< bool > CHECKSTABILITY
should LP solver's return status be checked for stability?
constexpr Param< bool > ALWAYSGETDUALS
should the Farkas duals always be collected when an LP is found to be infeasible?
constexpr Param< double > CONDITIONLIMIT
maximum condition number of LP basis counted as stable (-1.0: no limit)
constexpr Param< int > SOLVEDEPTH
maximal depth for solving LP at the nodes (-1: no depth limit)
constexpr Param< long long > ITERLIM
iteration limit for each single LP solve (-1: no limit)
constexpr Param< double > SAVEFAC
fraction of maximal memory usage resulting in switch to memory saving mode
constexpr Param< double > TREEGROWFAC
memory growing factor for tree array
constexpr Param< int > TREEGROWINIT
initial size of tree array
constexpr Param< int > ARRAYGROWINIT
initial size of dynamically allocated arrays
constexpr Param< int > PATHGROWINIT
initial size of path array
constexpr Param< double > ARRAYGROWFAC
memory growing factor for dynamically allocated arrays
constexpr Param< double > PATHGROWFAC
memory growing factor for path array
constexpr Param< bool > CALCINTEGRAL
should SCIP calculate the primal dual integral value?
constexpr Param< bool > USESMALLTABLES
should smaller hashtables be used? yields better performance for small problems with about 100 variab...
constexpr Param< bool > ALLOWSTRONGDUALREDS
should strong dual reductions be allowed in propagation and presolving?
constexpr Param< bool > SCALEOBJ
should the objective function be scaled so that it is always integer?
constexpr Param< int > USESYMMETRY
bitset describing used symmetry handling technique: (0: off; 1: constraint-based (orbitopes and/or sy...
constexpr Param< bool > RESETSTAT
should the statistics be reset if the transformed problem is freed (in case of a Benders' decompositi...
constexpr Param< bool > OUTPUTORIGSOL
should the best solution be transformed to the orignal space and be output in command line run?
constexpr Param< double > REFERENCEVALUE
objective value for reference purposes
constexpr Param< bool > SHOWDIVINGSTATS
should detailed statistics for diving heuristics be shown?
constexpr Param< bool > USEVARTABLE
should a hashtable be used to map from variable names to variables?
constexpr Param< bool > PRINTREASON
should the reason be printed if a given start solution is infeasible
constexpr Param< bool > ALLOWWEAKDUALREDS
should weak dual reductions be allowed in propagation and presolving?
constexpr Param< bool > AVOIDMEMOUT
try to avoid running into memory limit by restricting plugins like heuristics?
constexpr Param< bool > TRANSSOLSORIG
should SCIP try to transfer transformed solutions to the original space (after solving)?
constexpr Param< bool > CATCHCTRLC
should the CTRL-C interrupt be caught by SCIP?
constexpr Param< bool > TRANSORIGSOLS
should SCIP try to transfer original solutions to the transformed space (after presolving)?
constexpr Param< bool > USECONSTABLE
should a hashtable be used to map from constraint names to constraints?
constexpr Param< bool > IMPROVINGSOLS
should only solutions be checked which improve the primal bound
constexpr Param< bool > ESTIMEXTERNMEM
should the usage of external memory be estimated?
constexpr Param< bool > FINITESOLUTIONSTORE
should SCIP try to remove infinite fixings from solutions copied to the solution store?
constexpr Param< int > MAXSEPADEPTH
maximum depth to apply separation
constexpr Param< int > MAXSEPAROUNDS
maximum number of separation rounds in a local node
constexpr Param< bool > USEINTEVAL
whether to use the interval evaluation callback of the nlhdlr
constexpr Param< bool > USEREVERSEPROP
whether to use the reverse propagation callback of the nlhdlr
constexpr Param< int > MAXSEPAROUNDSROOT
maximum number of separation rounds in the root node
constexpr Param< bool > ENABLED
should this nonlinear handler be used
constexpr Param< bool > CVXQUADRATIC
whether to use convexity check on quadratics
constexpr Param< bool > DETECTSUM
whether to run convexity detection when the root of an expression is a sum
constexpr Param< bool > HANDLETRIVIAL
whether to also handle trivial convex expressions
constexpr Param< bool > ENABLED
should this nonlinear handler be used
constexpr Param< bool > CVXSIGNOMIAL
whether to use convexity check on signomials
constexpr Param< bool > CVXPRODCOMP
whether to use convexity check on product composition f(h)*h
constexpr Param< bool > DETECTSUM
whether to run convexity detection when the root of an expression is a non-quadratic sum
constexpr Param< double > MAXPERTURB
maximal relative perturbation of non-differentiable reference point
constexpr Param< bool > HANDLETRIVIAL
whether to also handle trivial convex expressions
constexpr Param< bool > ENABLED
should this nonlinear handler be used
constexpr Param< bool > CVXSIGNOMIAL
whether to use convexity check on signomials
constexpr Param< bool > CVXPRODCOMP
whether to use convexity check on product composition f(h)*h
constexpr Param< bool > EXTENDEDFORM
whether to create extended formulations instead of looking for maximal convex expressions
constexpr Param< bool > CVXQUADRATIC
whether to use convexity check on quadratics
constexpr Param< bool > ENABLED
should this nonlinear handler be used
constexpr Param< int > PROBINGFREQ
probing frequency (-1 - no probing, 0 - root node only)
constexpr Param< bool > ENABLED
should this nonlinear handler be used
constexpr Param< bool > CONVEXONLY
whether perspective cuts are added only for convex expressions
constexpr Param< bool > TIGHTENBOUNDS
whether variable semicontinuity is used to tighten variable bounds
constexpr Param< int > MAXPROPROUNDS
maximal number of propagation rounds in probing
constexpr Param< bool > PROBINGONLYINSEPA
whether to do probing only in separation
constexpr Param< bool > ADJREFPOINT
whether to adjust the reference point
constexpr Param< double > MINDOMREDUCTION
minimal relative reduction in a variable's domain for applying probing
constexpr Param< double > MINVIOLPROBING
minimal violation w.r.t. auxiliary variables for applying probing
constexpr Param< int > NCUTSLIMITROOT
limit for number of cuts generated at root node
constexpr Param< bool > USESTRENGTHENING
whether the strengthening should be used
constexpr Param< double > MINVIOLATION
minimal violation the constraint must fulfill such that a cut is generated
constexpr Param< bool > IGNOREBADRAYRESTRICTION
should cut be generated even with bad numerics when restricting to ray?
constexpr Param< bool > TRACKMORE
for monoidal strengthening, should we track more statistics (more expensive)?
constexpr Param< int > NSTRENGTHLIMIT
limit for number of rays we do the strengthening for
constexpr Param< bool > SPARSIFYCUTS
should we try to sparisfy the intersection cut?
constexpr Param< bool > USEINTERSECTIONCUTS
whether to use intersection cuts for quadratic constraints to separate
constexpr Param< int > MAXRANK
maximal rank a slackvar can have
constexpr Param< bool > USEBOUNDSASRAYS
use bounds of variables in quadratic as rays for intersection cuts
constexpr Param< int > ATWHICHNODES
determines at which nodes cut is used (if it's -1, it's used only at the root node,...
constexpr Param< bool > USEMINREP
whether the minimal representation of the S-free set should be used (instead of the gauge)
constexpr Param< int > NCUTSLIMIT
limit for number of cuts generated consecutively
constexpr Param< bool > ENABLED
should this nonlinear handler be used
constexpr Param< bool > IGNORENHIGHRE
should cut be added even when range / efficacy is large?
constexpr Param< double > MINCUTVIOLATION
minimal cut violation the generated cuts must fulfill to be added to the LP
constexpr Param< bool > USEMONOIDAL
whether monoidal strengthening should be used
constexpr Param< bool > ENABLED
should this nonlinear handler be used
constexpr Param< bool > ENABLED
should this nonlinear handler be used
constexpr Param< double > MINCUTSCALE
minimum scale factor when scaling a cut
constexpr Param< int > MAXNUNDERVARS
maximum number of variables when underestimating a concave power function
constexpr Param< double > MINCUTEFFICACY
Minimum efficacy which a cut needs in order to be added.
constexpr Param< bool > COMPEIGENVALUES
Should Eigenvalue computations be done to detect complex cases in quadratic constraints?
constexpr Param< bool > ENABLED
should this nonlinear handler be used
constexpr Param< std::string > SOLVER
solver to use for solving NLPs; leave empty to select NLPI with highest priority
constexpr Param< bool > DISABLE
should the NLP relaxation be always disabled (also for NLPs/MINLPs)?
constexpr Param< double > MAXPLUNGEQUOT
maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where plunging is performed
constexpr Param< int > MINPLUNGEDEPTH
minimal plunging depth, before new best node may be selected (-1 for dynamic setting)
constexpr Param< int > MEMSAVEPRIORITY
priority of node selection rule <bfs> in memory saving mode
constexpr Param< int > STDPRIORITY
priority of node selection rule <bfs> in standard mode
constexpr Param< int > MAXPLUNGEDEPTH
maximal plunging depth, before new best node is forced to be selected (-1 for dynamic setting)
constexpr Param< int > MEMSAVEPRIORITY
priority of node selection rule <breadthfirst> in memory saving mode
constexpr Param< int > STDPRIORITY
priority of node selection rule <breadthfirst> in standard mode
constexpr Param< int > STDPRIORITY
priority of node selection rule <dfs> in standard mode
constexpr Param< int > MEMSAVEPRIORITY
priority of node selection rule <dfs> in memory saving mode
constexpr Param< int > MINPLUNGEDEPTH
minimal plunging depth, before new best node may be selected (-1 for dynamic setting)
constexpr Param< int > MAXPLUNGEDEPTH
maximal plunging depth, before new best node is forced to be selected (-1 for dynamic setting)
constexpr Param< int > MEMSAVEPRIORITY
priority of node selection rule <estimate> in memory saving mode
constexpr Param< int > PLUNGEOFFSET
number of nodes before doing plunging the first time
constexpr Param< int > BESTNODEFREQ
frequency at which the best node instead of the best estimate is selected (0: never)
constexpr Param< int > BREADTHFIRSTDEPTH
depth until breadth-first search is applied
constexpr Param< int > STDPRIORITY
priority of node selection rule <estimate> in standard mode
constexpr Param< double > MAXPLUNGEQUOT
maximal quotient (estimate - lowerbound)/(cutoffbound - lowerbound) where plunging is performed
constexpr Param< int > MAXPLUNGEDEPTH
maximal plunging depth, before new best node is forced to be selected (-1 for dynamic setting)
constexpr Param< int > MEMSAVEPRIORITY
priority of node selection rule <hybridestim> in memory saving mode
constexpr Param< int > BESTNODEFREQ
frequency at which the best node instead of the hybrid best estimate / best bound is selected (0: nev...
constexpr Param< double > ESTIMWEIGHT
weight of estimate value in node selection score (0: pure best bound search, 1: pure best estimate se...
constexpr Param< int > MINPLUNGEDEPTH
minimal plunging depth, before new best node may be selected (-1 for dynamic setting)
constexpr Param< double > MAXPLUNGEQUOT
maximal quotient (estimate - lowerbound)/(cutoffbound - lowerbound) where plunging is performed
constexpr Param< int > STDPRIORITY
priority of node selection rule <hybridestim> in standard mode
constexpr Param< bool > COUNTONLYLEAVES
count only leaf nodes (otherwise all nodes)?
constexpr Param< int > MEMSAVEPRIORITY
priority of node selection rule <restartdfs> in memory saving mode
constexpr Param< int > SELECTBESTFREQ
frequency for selecting the best node instead of the deepest one
constexpr Param< int > STDPRIORITY
priority of node selection rule <restartdfs> in standard mode
constexpr Param< int > STDPRIORITY
priority of node selection rule <uct> in standard mode
constexpr Param< int > MEMSAVEPRIORITY
priority of node selection rule <uct> in memory saving mode
constexpr Param< int > NODELIMIT
maximum number of nodes before switching to default rule
constexpr Param< bool > USEESTIMATE
should the estimate (TRUE) or lower bound of a node be used for UCT score?
constexpr Param< double > WEIGHT
weight for visit quotient of node selection rule
constexpr Param< char > CHILDSEL
child selection rule ('d'own, 'u'p, 'p'seudo costs, 'i'nference, 'l'p value, 'r'oot LP value differen...
constexpr Param< double > CHECKFEASTOLFAC
feasibility tolerance factor; for checking the feasibility of the best solution
constexpr Param< double > BARRIERCONVTOL
LP convergence tolerance used in barrier algorithm.
constexpr Param< double > LPFEASTOLFACTOR
factor w.r.t.
constexpr Param< double > EPSILON
absolute values smaller than this are considered zero
constexpr Param< double > SUMEPSILON
absolute values of sums smaller than this are considered zero
constexpr Param< double > FEASTOL
feasibility tolerance for constraints
constexpr Param< double > BOUNDSTREPS
minimal relative improve for strengthening bounds
constexpr Param< double > PSEUDOCOSTDELTA
minimal objective distance value to use for branching pseudo cost updates
constexpr Param< double > DUALFEASTOL
feasibility tolerance for reduced costs in LP solution
constexpr Param< double > PSEUDOCOSTEPS
minimal variable distance value to use for branching pseudo cost updates
constexpr Param< double > INFINITY
values larger than this are considered infinity
constexpr Param< double > HUGEVAL
values larger than this are considered huge and should be handled separately (e.g....
constexpr Param< double > RECOMPUTEFAC
minimal decrease factor that causes the recomputation of a value (e.g., pseudo objective) instead of ...
constexpr Param< int > MINNTHREADS
the minimum number of threads used during parallel solve
constexpr Param< int > MODE
parallel optimisation mode, 0: opportunistic or 1: deterministic.
constexpr Param< int > MAXNTHREADS
the maximum number of threads used during parallel solve
constexpr Param< bool > FLIPPING
is flipping allowed (multiplying with -1)?
constexpr Param< int > PRIORITY
priority of presolver <boundshift>
constexpr Param< int > TIMING
timing mask of presolver <boundshift> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
constexpr Param< bool > INTEGER
shift only integer ranges?
constexpr Param< int > MAXROUNDS
maximal number of presolving rounds the presolver participates in (-1: no limit)
constexpr Param< long long > MAXSHIFT
absolute value of maximum shift
constexpr Param< long long > MAXDOMAINSIZE
absolute value of maximum domain size for converting an integer variable to binaries variables
constexpr Param< int > PRIORITY
priority of presolver <convertinttobin>
constexpr Param< int > TIMING
timing mask of presolver <convertinttobin> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
constexpr Param< bool > SAMELOCKSINBOTHDIRECTIONS
should only integer variables with uplocks equals downlocks be converted
constexpr Param< bool > ONLYPOWEROFTWO
should only integer variables with a domain size of 2^p - 1 be converted(, there we don't need an kna...
constexpr Param< int > MAXROUNDS
maximal number of presolving rounds the presolver participates in (-1: no limit)
constexpr Param< int > PRIORITY
priority of presolver <domcol>
constexpr Param< int > NUMMINPAIRS
minimal number of pair comparisons
constexpr Param< int > NUMMAXPAIRS
maximal number of pair comparisons
constexpr Param< int > TIMING
timing mask of presolver <domcol> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
constexpr Param< bool > PREDBNDSTR
should predictive bound strengthening be applied?
constexpr Param< int > MAXROUNDS
maximal number of presolving rounds the presolver participates in (-1: no limit)
constexpr Param< bool > CONTINUOUSRED
should reductions for continuous variables be performed?
constexpr Param< int > PRIORITY
priority of presolver <dualagg>
constexpr Param< int > MAXROUNDS
maximal number of presolving rounds the presolver participates in (-1: no limit)
constexpr Param< int > TIMING
timing mask of presolver <dualagg> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
constexpr Param< int > PRIORITY
priority of presolver <dualcomp>
constexpr Param< int > MAXROUNDS
maximal number of presolving rounds the presolver participates in (-1: no limit)
constexpr Param< int > TIMING
timing mask of presolver <dualcomp> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
constexpr Param< bool > COMPONLYDISVARS
should only discrete variables be compensated?
constexpr Param< int > MAXRETRIEVEFAILS
maximal number of consecutive useless hashtable retrieves
constexpr Param< int > MAXHASHFAC
Maximum number of hashlist entries as multiple of number of columns in the problem (-1: no limit)
constexpr Param< int > PRIORITY
priority of presolver <dualinfer>
constexpr Param< int > MAXPAIRFAC
Maximum number of processed column pairs as multiple of the number of columns in the problem (-1: no ...
constexpr Param< int > MAXDUALBNDLOOPS
maximal number of dual bound strengthening loops
constexpr Param< int > TIMING
timing mask of presolver <dualinfer> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
constexpr Param< int > MAXROUNDS
maximal number of presolving rounds the presolver participates in (-1: no limit)
constexpr Param< int > MAXROWSUPPORT
Maximum number of row's non-zeros for changing inequality to equality.
constexpr Param< bool > TWOCOLCOMBINE
use convex combination of columns for determining dual bounds
constexpr Param< int > MAXCOMBINEFAILS
maximal number of consecutive useless column combines
constexpr Param< int > MAXCONSIDEREDNONZEROS
maximal number of considered non-zeros within one column (-1: no limit)
constexpr Param< int > MAXROUNDS
maximal number of presolving rounds the presolver participates in (-1: no limit)
constexpr Param< int > TIMING
timing mask of presolver <dualsparsify> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
constexpr Param< int > MAXCONTFILLIN
maximal fillin for continuous variables (-1: unlimited)
constexpr Param< int > PRIORITY
priority of presolver <dualsparsify>
constexpr Param< bool > PRESERVEGOODLOCKS
should we preserve good locked properties of variables (at most one lock in one direction)?
constexpr Param< int > MINELIMINATEDNONZEROS
minimal eliminated nonzeros within one column if we need to add a constraint to the problem
constexpr Param< bool > ENABLECOPY
should dualsparsify presolver be copied to sub-SCIPs?
constexpr Param< int > MAXINTFILLIN
maximal fillin for integer variables including binaries (-1: unlimited)
constexpr Param< int > MAXCONSIDEREDNONZEROS
maximal number of considered nonzeros within one column (-1: no limit)
constexpr Param< bool > PRESERVEINTCOEFS
should we forbid cancellations that destroy integer coefficients?
constexpr Param< double > WAITINGFAC
number of calls to wait until next execution as a multiple of the number of useless calls
constexpr Param< double > MAXRETRIEVEFAC
limit on the number of useless vs. useful hashtable retrieves as a multiple of the number of constrai...
constexpr Param< int > MAXBINFILLIN
maximal fillin for binary variables (-1: unlimited)
constexpr Param< int > SORTING
order logicor contraints to extract big-gates before smaller ones (-1), do not order them (0) or orde...
constexpr Param< bool > SEARCHEQUATIONS
should we try to extract set-partitioning constraint out of one logicor and one corresponding set-pac...
constexpr Param< int > PRIORITY
priority of presolver <gateextraction>
constexpr Param< bool > ONLYSETPART
should we only try to extract set-partitioning constraints and no and-constraints
constexpr Param< int > TIMING
timing mask of presolver <gateextraction> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
constexpr Param< int > MAXROUNDS
maximal number of presolving rounds the presolver participates in (-1: no limit)
constexpr Param< int > PRIORITY
priority of presolver <implics>
constexpr Param< int > MAXROUNDS
maximal number of presolving rounds the presolver participates in (-1: no limit)
constexpr Param< int > TIMING
timing mask of presolver <implics> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
constexpr Param< int > MAXROUNDS
maximal number of presolving rounds the presolver participates in (-1: no limit)
constexpr Param< int > TIMING
timing mask of presolver <inttobinary> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
constexpr Param< int > PRIORITY
priority of presolver <inttobinary>
constexpr Param< int > PRIORITY
priority of presolver <qpkktref>
constexpr Param< bool > UPDATEQUADINDEF
if TRUE then apply quadratic constraint update even if the quadratic constraint matrix is known to be...
constexpr Param< bool > ADDKKTBINARY
if TRUE then allow binary variables for KKT update
constexpr Param< int > MAXROUNDS
maximal number of presolving rounds the presolver participates in (-1: no limit)
constexpr Param< bool > UPDATEQUADBOUNDED
if TRUE then only apply the update to QPs with bounded variables; if the variables are not bounded th...
constexpr Param< int > TIMING
timing mask of presolver <qpkktref> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
constexpr Param< int > PRIORITY
priority of presolver <redvub>
constexpr Param< int > TIMING
timing mask of presolver <redvub> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
constexpr Param< int > MAXROUNDS
maximal number of presolving rounds the presolver participates in (-1: no limit)
constexpr Param< bool > CANCELLINEAR
should we cancel nonzeros in constraints of the linear constraint handler?
constexpr Param< int > MAXROUNDS
maximal number of presolving rounds the presolver participates in (-1: no limit)
constexpr Param< bool > ENABLECOPY
should sparsify presolver be copied to sub-SCIPs?
constexpr Param< int > MAXCONSIDEREDNONZEROS
maximal number of considered non-zeros within one row (-1: no limit)
constexpr Param< int > TIMING
timing mask of presolver <sparsify> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
constexpr Param< double > WAITINGFAC
number of calls to wait until next execution as a multiple of the number of useless calls
constexpr Param< int > MAXNONZEROS
maximal support of one equality to be used for cancelling (-1: no limit)
constexpr Param< int > MAXINTFILLIN
maximal fillin for integer variables including binaries (-1: unlimited)
constexpr Param< int > MAXBINFILLIN
maximal fillin for binary variables (-1: unlimited)
constexpr Param< double > MAXRETRIEVEFAC
limit on the number of useless vs. useful hashtable retrieves as a multiple of the number of constrai...
constexpr Param< int > MAXCONTFILLIN
maximal fillin for continuous variables (-1: unlimited)
constexpr Param< bool > PRESERVEINTCOEFS
should we forbid cancellations that destroy integer coefficients?
constexpr Param< char > ROWSORT
order in which to process inequalities ('n'o sorting, 'i'ncreasing nonzeros, 'd'ecreasing nonzeros)
constexpr Param< int > PRIORITY
priority of presolver <sparsify>
constexpr Param< int > MAXROUNDS
maximal number of presolving rounds the presolver participates in (-1: no limit)
constexpr Param< int > TIMING
timing mask of presolver <stuffing> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
constexpr Param< int > PRIORITY
priority of presolver <stuffing>
constexpr Param< int > MAXROUNDS
maximal number of presolving rounds the presolver participates in (-1: no limit)
constexpr Param< int > TIMING
timing mask of presolver <trivial> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
constexpr Param< int > PRIORITY
priority of presolver <trivial>
constexpr Param< int > MAXCOMBINEFAILS
maximal number of consecutive useless row combines
constexpr Param< int > TIMING
timing mask of presolver <tworowbnd> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL)
constexpr Param< int > MAXRETRIEVEFAILS
maximal number of consecutive useless hashtable retrieves
constexpr Param< bool > ENABLECOPY
should tworowbnd presolver be copied to sub-SCIPs?
constexpr Param< int > MAXROUNDS
maximal number of presolving rounds the presolver participates in (-1: no limit)
constexpr Param< int > PRIORITY
priority of presolver <tworowbnd>
constexpr Param< int > MAXCONSIDEREDNONZEROS
maximal number of considered non-zeros within one row (-1: no limit)
constexpr Param< int > MAXPAIRFAC
Maximum number of processed row pairs as multiple of the number of rows in the problem (-1: no limit)
constexpr Param< int > MAXHASHFAC
Maximum number of hashlist entries as multiple of number of rows in the problem (-1: no limit)
constexpr Param< double > RESTARTMINRED
minimal fraction of integer variables removed after restart to allow for an additional restart
constexpr Param< double > CLQTABLEFAC
limit on number of entries in clique table relative to number of problem nonzeros
constexpr Param< bool > DONOTAGGR
should aggregation of variables be forbidden?
constexpr Param< bool > DONOTMULTAGGR
should multi-aggregation of variables be forbidden?
constexpr Param< int > MAXROUNDS
maximal number of presolving rounds (-1: unlimited, 0: off)
constexpr Param< int > MAXRESTARTS
maximal number of restarts (-1: unlimited)
constexpr Param< double > RESTARTFAC
fraction of integer variables that were fixed in the root node triggering a restart with preprocessin...
constexpr Param< double > IMMRESTARTFAC
fraction of integer variables that were fixed in the root node triggering an immediate restart with p...
constexpr Param< double > SUBRESTARTFAC
fraction of integer variables that were globally fixed during the solving process triggering a restar...
constexpr Param< double > ABORTFAC
abort presolve, if at most this fraction of the problem was changed in last presolve round
constexpr Param< double > ABORTFAC
pricing is aborted, if fac * pricing/maxvars pricing candidates were found
constexpr Param< int > MAXVARS
maximal number of variables priced in per pricing round
constexpr Param< bool > DELVARSROOT
should variables created at the root node be deleted when the root is solved in case they are not pre...
constexpr Param< bool > DELVARS
should variables created at the current node be deleted when the node is solved in case they are not ...
constexpr Param< int > MAXVARSROOT
maximal number of priced variables at the root node
constexpr Param< int > PRESOLTIMING
timing mask of the presolving method of propagator <dualfix> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< bool > DELAY
should propagator be delayed, if other propagators found reductions?
constexpr Param< int > PRIORITY
priority of propagator <dualfix>
constexpr Param< int > PRESOLPRIORITY
presolving priority of propagator <dualfix>
constexpr Param< int > FREQ
frequency for calling propagator <dualfix> (-1: never, 0: only in root node)
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the propagator participates in (-1: no limit)
constexpr Param< int > TIMINGMASK
timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< int > PRIORITY
priority of propagator <genvbounds>
constexpr Param< bool > GLOBAL
apply global propagation?
constexpr Param< int > TIMINGMASK
timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< bool > PROPASCONSS
should genvbounds be transformed to (linear) constraints?
constexpr Param< bool > DELAY
should propagator be delayed, if other propagators found reductions?
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the propagator participates in (-1: no limit)
constexpr Param< int > FREQ
frequency for calling propagator <genvbounds> (-1: never, 0: only in root node)
constexpr Param< bool > PROPINROOTNODE
apply genvbounds in root node if no new incumbent was found?
constexpr Param< int > PRESOLPRIORITY
presolving priority of propagator <genvbounds>
constexpr Param< int > PRESOLTIMING
timing mask of the presolving method of propagator <genvbounds> (4:FAST, 8:MEDIUM,...
constexpr Param< bool > SORT
sort genvbounds and wait for bound change events?
constexpr Param< int > PRIORITY
priority of propagator <nlobbt>
constexpr Param< int > PRESOLPRIORITY
presolving priority of propagator <nlobbt>
constexpr Param< int > FREQ
frequency for calling propagator <nlobbt> (-1: never, 0: only in root node)
constexpr Param< bool > DELAY
should propagator be delayed, if other propagators found reductions?
constexpr Param< int > NLPITERLIMIT
iteration limit of NLP solver; 0 for no limit
constexpr Param< bool > ADDLPROWS
should non-initial LP rows be used?
constexpr Param< double > RELOBJTOLFAC
factor for NLP relative objective tolerance
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the propagator participates in (-1: no limit)
constexpr Param< double > MINNONCONVEXFRAC
(#convex nlrows)/(#nonconvex nlrows) threshold to apply propagator
constexpr Param< double > MINLINEARFRAC
minimum (#convex nlrows)/(#linear nlrows) threshold to apply propagator
constexpr Param< double > ITLIMITFACTOR
LP iteration limit for nlobbt will be this factor times total LP iterations in root node.
constexpr Param< int > TIMINGMASK
timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< int > PRESOLTIMING
timing mask of the presolving method of propagator <nlobbt> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< int > NLPVERBLEVEL
verbosity level of NLP solver
constexpr Param< double > FEASTOLFAC
factor for NLP feasibility tolerance
constexpr Param< double > NLPTIMELIMIT
time limit of NLP solver; 0.0 for no limit
constexpr Param< bool > TIGHTINTBOUNDSPROBING
should integral bounds be tightened during the probing mode?
constexpr Param< bool > GENVBDSDURINGFILTER
should we try to generate genvbounds during trivial and aggressive filtering?
constexpr Param< int > SEPAMINITER
minimum number of iteration spend to separate an obbt LP solution
constexpr Param< bool > SEPARATESOL
should the obbt LP solution be separated?
constexpr Param< bool > ONLYNONCONVEXVARS
only apply obbt on non-convex variables
constexpr Param< bool > TIGHTCONTBOUNDSPROBING
should continuous bounds be tightened during the probing mode?
constexpr Param< int > TIMINGMASK
timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< double > DUALFEASTOL
feasibility tolerance for reduced costs used in obbt; this value is used if SCIP's dual feastol is gr...
constexpr Param< bool > APPLYTRIVIALFILTER
try to filter bounds with the LP solution after each solve?
constexpr Param< int > SEPAMAXITER
maximum number of iteration spend to separate an obbt LP solution
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the propagator participates in (-1: no limit)
constexpr Param< bool > GENVBDSDURINGSEPA
try to create genvbounds during separation process?
constexpr Param< int > PRESOLTIMING
timing mask of the presolving method of propagator <obbt> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< bool > NORMALIZE
should coefficients in filtering be normalized w.r.t. the domains sizes?
constexpr Param< bool > INDICATORS
apply obbt on variables of indicator constraints? (independent of convexity)
constexpr Param< int > PRIORITY
priority of propagator <obbt>
constexpr Param< double > ITLIMITFACTOR
multiple of root node LP iterations used as total LP iteration limit for obbt (<= 0: no limit )
constexpr Param< int > PROPAGATEFREQ
trigger a propagation round after that many bound tightenings (0: no propagation)
constexpr Param< double > MINNONCONVEXITY
minimum absolute value of nonconvex eigenvalues for a bilinear term
constexpr Param< int > MINFILTER
minimal number of filtered bounds to apply another filter round
constexpr Param< int > PRESOLPRIORITY
presolving priority of propagator <obbt>
constexpr Param< bool > CREATEGENVBOUNDS
should obbt try to provide genvbounds if possible?
constexpr Param< bool > DELAY
should propagator be delayed, if other propagators found reductions?
constexpr Param< double > CONDITIONLIMIT
maximum condition limit used in LP solver (-1.0: no limit)
constexpr Param< bool > CREATELINCONS
create linear constraints from inequalities for bilinear terms?
constexpr Param< double > INDICATORTHRESHOLD
threshold whether upper bounds of vars of indicator conss are considered or tightened
constexpr Param< int > FREQ
frequency for calling propagator <obbt> (-1: never, 0: only in root node)
constexpr Param< long long > MINITLIMIT
minimum LP iteration limit
constexpr Param< int > ORDERINGALGO
select the type of ordering algorithm which should be used (0: no special ordering,...
constexpr Param< double > BOUNDSTREPS
minimal relative improve for strengthening bounds
constexpr Param< double > ITLIMITFACTORBILIN
multiple of OBBT LP limit used as total LP iteration limit for solving bilinear inequality LPs (< 0 f...
constexpr Param< bool > APPLYFILTERROUNDS
try to filter bounds in so-called filter rounds by solving auxiliary LPs?
constexpr Param< bool > CREATEBILININEQS
solve auxiliary LPs in order to find valid inequalities for bilinear terms?
constexpr Param< int > PRESOLPRIORITY
presolving priority of propagator <probing>
constexpr Param< int > PROPROUNDS
maximal number of propagation rounds in probing subproblems (-1: no limit, 0: auto)
constexpr Param< int > MAXRUNS
maximal number of runs, probing participates in (-1: no limit)
constexpr Param< int > FREQ
frequency for calling propagator <probing> (-1: never, 0: only in root node)
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the propagator participates in (-1: no limit)
constexpr Param< bool > DELAY
should propagator be delayed, if other propagators found reductions?
constexpr Param< int > MAXSUMUSELESS
maximal number of probings without fixings, until probing is aborted (0: don't abort)
constexpr Param< int > TIMINGMASK
timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< int > MAXUSELESS
maximal number of successive probings without fixings, until probing is aborted (0: don't abort)
constexpr Param< int > MAXFIXINGS
maximal number of fixings found, until probing is interrupted (0: don't iterrupt)
constexpr Param< int > PRESOLTIMING
timing mask of the presolving method of propagator <probing> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< int > PRIORITY
priority of propagator <probing>
constexpr Param< int > MAXDEPTH
maximal depth until propagation is executed(-1: no limit)
constexpr Param< int > MAXTOTALUSELESS
maximal number of successive probings without fixings, bound changes, and implications,...
constexpr Param< int > PRESOLPRIORITY
presolving priority of propagator <pseudoobj>
constexpr Param< bool > PROPCUTOFFBOUND
propagate new cutoff bound directly globally
constexpr Param< bool > FORCE
should the propagator be forced even if active pricer are present?
constexpr Param< double > MAXVARSFRAC
maximal fraction of non-binary variables with non-zero objective without a bound reduction before abo...
constexpr Param< bool > PROPUSEIMPLICS
use implications to strengthen the propagation of binary variable (increasing the objective change)?
constexpr Param< int > PRIORITY
priority of propagator <pseudoobj>
constexpr Param< bool > RESPROPUSEIMPLICS
use implications to strengthen the resolve propagation of binary variable (increasing the objective c...
constexpr Param< bool > DELAY
should propagator be delayed, if other propagators found reductions?
constexpr Param< int > MAXIMPLVARS
maximum number of binary variables the implications are used if turned on (-1: unlimited)?
constexpr Param< int > TIMINGMASK
timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< int > MINUSELESS
minimal number of successive non-binary variable propagations without a bound reduction before aborte...
constexpr Param< int > MAXNEWVARS
number of variables added after the propagator is reinitialized?
constexpr Param< bool > PROPFULLINROOT
whether to propagate all non-binary variables when we are propagating the root node
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the propagator participates in (-1: no limit)
constexpr Param< int > FREQ
frequency for calling propagator <pseudoobj> (-1: never, 0: only in root node)
constexpr Param< int > PRESOLTIMING
timing mask of the presolving method of propagator <pseudoobj> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< int > PRESOLTIMING
timing mask of the presolving method of propagator <redcost> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< bool > CONTINUOUS
should reduced cost fixing be also applied to continuous variables?
constexpr Param< bool > DELAY
should propagator be delayed, if other propagators found reductions?
constexpr Param< int > TIMINGMASK
timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the propagator participates in (-1: no limit)
constexpr Param< int > PRESOLPRIORITY
presolving priority of propagator <redcost>
constexpr Param< int > FREQ
frequency for calling propagator <redcost> (-1: never, 0: only in root node)
constexpr Param< bool > FORCE
should the propagator be forced even if active pricer are present?
constexpr Param< bool > USEIMPLICS
should implications be used to strength the reduced cost for binary variables?
constexpr Param< int > PRIORITY
priority of propagator <redcost>
constexpr Param< int > FREQ
frequency for calling propagator <rootredcost> (-1: never, 0: only in root node)
constexpr Param< bool > FORCE
should the propagator be forced even if active pricer are present?
constexpr Param< int > PRESOLPRIORITY
presolving priority of propagator <rootredcost>
constexpr Param< bool > ONLYBINARY
should only binary variables be propagated?
constexpr Param< int > TIMINGMASK
timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< int > PRESOLTIMING
timing mask of the presolving method of propagator <rootredcost> (4:FAST, 8:MEDIUM,...
constexpr Param< bool > DELAY
should propagator be delayed, if other propagators found reductions?
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the propagator participates in (-1: no limit)
constexpr Param< int > PRIORITY
priority of propagator <rootredcost>
constexpr Param< int > COLUMNORDERING
The column ordering variant, respects enum SCIP_ColumnOrdering.
constexpr Param< bool > PERFORMPRESOLVING
run orbital fixing during presolving? (disabled)
constexpr Param< int > OFSYMCOMPTIMING
timing of symmetry computation (0 = before presolving, 1 = during presolving, 2 = at first call) [dis...
constexpr Param< bool > ADDSTRONGSBCS
Should strong SBCs for enclosing orbit of symmetric subgroups be added if orbitopes are not used?
constexpr Param< bool > ADDCONFLICTCUTS
Should Schreier Sims constraints be added if we use a conflict based rule?
constexpr Param< int > ADDCONSSTIMING
timing of adding constraints (0 = before presolving, 1 = during presolving, 2 = after presolving) [di...
constexpr Param< bool > DETECTDOUBLELEX
Should we check whether the components of the symmetry group can be handled by double lex matrices?
constexpr Param< int > RECOMPUTERESTART
recompute symmetries after a restart has occurred? (0 = never)
constexpr Param< int > FREQ
frequency for calling propagator <symmetry> (-1: never, 0: only in root node)
constexpr Param< int > TIMINGMASK
timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< bool > ADDWEAKSBCS
Should we add weak SBCs for enclosing orbit of symmetric subgroups?
constexpr Param< int > PRESOLTIMING
timing mask of the presolving method of propagator <symmetry> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< int > SSTLEADERVARTYPE
bitset encoding which variable types can be leaders (1: binary; 2: integer; 4: impl.
constexpr Param< bool > CONSSADDLP
Should the symmetry breaking constraints be added to the LP?
constexpr Param< int > MAXNCONSSSUBGROUP
maximum number of constraints up to which subgroup structures are detected
constexpr Param< int > PRIORITY
priority of propagator <symmetry>
constexpr Param< bool > COMPRESSSYMMETRIES
Should non-affected variables be removed from permutation to save memory?
constexpr Param< bool > USECOLUMNSPARSITY
Should the number of conss a variable is contained in be exploited in symmetry detection?
constexpr Param< bool > DISPLAYNORBITVARS
Should the number of variables affected by some symmetry be displayed?
constexpr Param< bool > SYMFIXNONBINARYVARS
Whether all non-binary variables shall be not affected by symmetries if OF is active?...
constexpr Param< int > SYMTIMING
timing of symmetry computation and handling (0 = before presolving, 1 = during presolving,...
constexpr Param< bool > USEDYNAMICPROP
whether dynamified symmetry handling constraint methods should be used
constexpr Param< int > MAXGENERATORS
limit on the number of generators that should be produced within symmetry detection (0 = no limit)
constexpr Param< int > NAUTYMAXNCELLS
terminate symmetry detection using Nauty when number of cells in color refinment is at least this num...
constexpr Param< bool > ENFORCECOMPUTESYMMETRY
Is only symmetry on binary variables used?
constexpr Param< int > SYMTYPE
Type of symmetries that shall be computed?
constexpr Param< bool > SSTMIXEDCOMPONENTS
Should Schreier Sims constraints be added if a symmetry component contains variables of different typ...
constexpr Param< bool > CHECKSYMMETRIES
Should all symmetries be checked after computation?
constexpr Param< int > PRESOLPRIORITY
presolving priority of propagator <symmetry>
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the propagator participates in (-1: no limit)
constexpr Param< bool > DETECTORBITOPES
Should we check whether the components of the symmetry group can be handled by orbitopes?
constexpr Param< bool > DELAY
should propagator be delayed, if other propagators found reductions?
constexpr Param< bool > DETECTSUBGROUPS
Should we try to detect symmetric subgroups of the symmetry group on binary variables?
constexpr Param< int > SSTTIEBREAKRULE
rule to select the orbit in Schreier Sims inequalities (variable in 0: minimum size orbit; 1: maximum...
constexpr Param< int > NAUTYMAXNNODES
terminate symmetry detection using Nauty when its search tree has at least this number of nodes
constexpr Param< bool > ADDSYMRESACKS
Add inequalities for symresacks for each generator?
constexpr Param< int > SSTLEADERRULE
rule to select the leader in an orbit (0: first var; 1: last var; 2: var having most conflicting vars...
constexpr Param< bool > PREFERLESSROWS
Shall orbitopes with less rows be preferred in detection?
constexpr Param< bool > DOUBLEEQUATIONS
Double equations to positive/negative version?
constexpr Param< bool > SSTADDCUTS
Should Schreier Sims constraints be added?
constexpr Param< double > COMPRESSTHRESHOLD
Compression is used if percentage of moved vars is at most the threshold.
constexpr Param< int > PRIORITY
priority of propagator <vbounds>
constexpr Param< double > MAXCLIQUESMEDIUM
maximum number of cliques per variable to run clique table analysis in medium presolving
constexpr Param< double > MAXCLIQUESEXHAUSTIVE
maximum number of cliques per variable to run clique table analysis in exhaustive presolving
constexpr Param< bool > DELAY
should propagator be delayed, if other propagators found reductions?
constexpr Param< bool > DOTOPOSORT
should the bounds be topologically sorted in advance?
constexpr Param< int > PRESOLPRIORITY
presolving priority of propagator <vbounds>
constexpr Param< int > PRESOLTIMING
timing mask of the presolving method of propagator <vbounds> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE,...
constexpr Param< int > MAXPREROUNDS
maximal number of presolving rounds the propagator participates in (-1: no limit)
constexpr Param< bool > USEBDWIDENING
should bound widening be used to initialize conflict analysis?
constexpr Param< bool > SORTCLIQUES
should cliques be regarded for the topological sort?
constexpr Param< bool > USECLIQUES
should cliques be propagated?
constexpr Param< double > MINNEWCLIQUES
minimum percentage of new cliques to trigger another clique table analysis
constexpr Param< int > FREQ
frequency for calling propagator <vbounds> (-1: never, 0: only in root node)
constexpr Param< bool > DETECTCYCLES
should cycles in the variable bound graph be identified?
constexpr Param< bool > USEIMPLICS
should implications be propagated?
constexpr Param< int > TIMINGMASK
timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP,...
constexpr Param< bool > USEVBOUNDS
should vbounds be propagated?
constexpr Param< int > MAXROUNDS
maximal number of propagation rounds per node (-1: unlimited)
constexpr Param< bool > ABORTONCUTOFF
should propagation be aborted immediately? setting this to FALSE could help conflict analysis to prod...
constexpr Param< int > MAXROUNDSROOT
maximal number of propagation rounds in the root node (-1: unlimited)
constexpr Param< int > RANDOMSEEDSHIFT
global shift of all random seeds in the plugins and the LP random seed
constexpr Param< bool > PERMUTECONSS
should order of constraints be permuted (depends on permutationseed)?
constexpr Param< int > LPSEED
random seed for LP solver, e.g. for perturbations in the simplex (0: LP default)
constexpr Param< int > PERMUTATIONSEED
seed value for permuting the problem after reading/transformation (0: no permutation)
constexpr Param< bool > PERMUTEVARS
should order of variables be permuted (depends on permutationseed)?
constexpr Param< bool > IMPROVEONLY
only use improving bounds
constexpr Param< bool > WRITEFIXEDVARS
should fixed and aggregated variables be printed (if not, re-parsing might fail)
constexpr Param< bool > USEOBJ
should an artificial objective, depending on the number of clauses a variable appears in,...
constexpr Param< bool > REPLACEFORBIDDENCHARS
shall characters '#', '*', '+', '/', and '-' in variable and constraint names be replaced by '_'?
constexpr Param< bool > SIGNPOWER
is it allowed to use the gams function signpower(x,a)?
constexpr Param< char > INDICATORREFORM
which reformulation to use for indicator constraints: 'b'ig-M, 's'os1
constexpr Param< double > BIGMDEFAULT
default M value for big-M reformulation of indicator constraints in case no bound on slack variable i...
constexpr Param< bool > LINEARIZE_AND_CONSTRAINTS
should possible "and" constraint be linearized when writing the lp file?
constexpr Param< bool > AGGRLINEARIZATION_ANDS
should an aggregated linearization for and constraints be used?
constexpr Param< bool > AGGRLINEARIZATION_ANDS
should an aggregated linearization for and constraints be used?
constexpr Param< bool > LINEARIZE_AND_CONSTRAINTS
should possible "and" constraint be linearized when writing the mps file?
constexpr Param< bool > MULTISYMBOL
use '*' between coefficients and variables by writing to problem?
constexpr Param< bool > DYNAMICCONSS
should model constraints be subject to aging?
constexpr Param< bool > BINARY
should the output format be binary(P4) (otherwise plain(P1) format)
constexpr Param< int > MAXROWS
maximum number of rows in the scaled picture (-1 for no limit)
constexpr Param< int > MAXCOLS
maximum number of columns in the scaled picture (-1 for no limit)
constexpr Param< bool > RGBRELATIV
should the coloring values be relativ or absolute
constexpr Param< int > RGBLIMIT
maximal color value
constexpr Param< int > COEFFICIENTLIMIT
splitting coefficients in this number of intervals
constexpr Param< bool > RGBASCII
should the output format be binary(P6) (otherwise plain(P3) format)
constexpr Param< bool > USEBENDERS
should Benders' decomposition be used?
constexpr Param< bool > DYNAMICCOLS
should columns be added and removed dynamically to the LP?
constexpr Param< bool > DYNAMICCONSS
should model constraints be subject to aging?
constexpr Param< bool > INITIALCONSS
should model constraints be marked as initial?
constexpr Param< bool > DYNAMICROWS
should rows be added and removed dynamically to the LP?
constexpr Param< bool > SEPAINFSUBTREES
save global constraints to separate infeasible subtrees.
constexpr Param< int > SOLVELP
at which reopttype should the LP be solved? (1: transit, 3: strong branched, 4: w/ added logicor,...
constexpr Param< int > MAXDIFFOFNODES
maximal number of bound changes between two stored nodes on one path
constexpr Param< bool > USESPLITCONS
use constraints to reconstruct the subtree pruned be dual reduction when reactivating the node
constexpr Param< int > MAXSAVEDNODES
maximal number of saved nodes
constexpr Param< bool > USECUTS
reoptimize cuts found at the root node
constexpr Param< bool > COMMONTIMELIMIT
time limit over all reoptimization rounds?.
constexpr Param< char > VARORDERINTERDICTION
use 'd'efault, 'r'andom or a variable ordering based on 'i'nference score for interdiction branching ...
constexpr Param< double > OBJSIMROOTLP
similarity of two sequential objective function to disable solving the root LP.
constexpr Param< int > MAXCUTAGE
maximal age of a cut to be use for reoptimization
constexpr Param< bool > SEPABESTSOL
separate the optimal solution, i.e., for constrained shortest path
constexpr Param< bool > STOREVARHISTORY
use variable history of the previous solve if the objctive function has changed only slightly
constexpr Param< double > OBJSIMSOL
similarity of two objective functions to re-use stored solutions
constexpr Param< int > SOLVELPDIFF
maximal number of bound changes at node to skip solving the LP
constexpr Param< int > SAVESOLS
number of best solutions which should be saved for the following runs. (-1: save all)
constexpr Param< bool > STRONGBRANCHINGINIT
try to fix variables at the root node before reoptimizing by probing like strong branching
constexpr Param< bool > SHRINKINNER
replace branched inner nodes by their child nodes, if the number of bound changes is not to large
constexpr Param< bool > SAVECONSPROP
save constraint and propagator propagations
constexpr Param< int > FORCEHEURRESTART
force a restart if the last n optimal solutions were found by heuristic reoptsols
constexpr Param< bool > REDUCETOFRONTIER
delete stored nodes which were not reoptimized
constexpr Param< bool > ENABLE
should reoptimization used?
constexpr Param< double > DELAY
minimum similarity for using reoptimization of the search tree.
constexpr Param< bool > USEPSCOST
re-use pseudo costs if the objective function changed only slightly
constexpr Param< int > MAXROUNDSROOT
maximal number of cmir separation rounds in the root node (-1: unlimited)
constexpr Param< int > MAXAGGRS
maximal number of aggregations for each row per separation round
constexpr Param< double > MAXSLACKROOT
maximal slack of rows to be used in aggregation in the root node
constexpr Param< int > MAXAGGRSROOT
maximal number of aggregations for each row per separation round in the root node
constexpr Param< bool > TRYNEGSCALING
should negative values also be tested in scaling?
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< double > MAXAGGDENSITY
maximal density of aggregated row
constexpr Param< double > MAXROWDENSITY
maximal density of row to be used in aggregation
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< int > MAXTRIESROOT
maximal number of rows to start aggregation with per separation round in the root node (-1: unlimited...
constexpr Param< int > MAXSEPACUTS
maximal number of cmir cuts separated per separation round
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <aggregation> is called (1: call at eac...
constexpr Param< int > MAXSEPACUTSROOT
maximal number of cmir cuts separated per separation round in the root node
constexpr Param< double > AGGRTOL
tolerance for bound distances used to select continuous variable in current aggregated constraint to ...
constexpr Param< bool > DYNAMICCUTS
should generated cuts be removed from the LP if they are no longer tight?
constexpr Param< int > PRIORITY
priority of separator <aggregation>
constexpr Param< double > MAXSLACK
maximal slack of rows to be used in aggregation
constexpr Param< int > MAXTRIES
maximal number of rows to start aggregation with per separation round (-1: unlimited)
constexpr Param< double > DENSITYSCORE
weight of row density in the aggregation scoring of the rows
constexpr Param< int > MAXTESTDELTA
maximal number of different deltas to try (-1: unlimited)
constexpr Param< int > MAXFAILSROOT
maximal number of consecutive unsuccessful aggregation tries in the root node (-1: unlimited)
constexpr Param< double > SLACKSCORE
weight of slack in the aggregation scoring of the rows
constexpr Param< int > MAXFAILS
maximal number of consecutive unsuccessful aggregation tries (-1: unlimited)
constexpr Param< double > MAXROWFAC
maximal row aggregation factor
constexpr Param< bool > FIXINTEGRALRHS
should an additional variable be complemented if f0 = 0?
constexpr Param< int > MAXROUNDS
maximal number of cmir separation rounds per node (-1: unlimited)
constexpr Param< int > FREQ
frequency for calling separator <aggregation> (-1: never, 0: only in root node)
constexpr Param< int > DENSITYOFFSET
additional number of variables allowed in row on top of density
constexpr Param< bool > CONSHDLRUSENORM
should the violation constraint handler use the norm of a cut to check for feasibility?
constexpr Param< double > INTCONVFRAC
fraction of frac. integral variables converted to have integral value (if intconvert)
constexpr Param< bool > ONLYACTIVEROWS
Use only active rows to generate cuts?
constexpr Param< long long > MAXNODELIMIT
maximum number of nodes considered for sub-MIP (-1: unlimited)
constexpr Param< int > FREQ
frequency for calling separator <cgmip> (-1: never, 0: only in root node)
constexpr Param< bool > OBJWEIGHTSIZE
Weight each row by its size?
constexpr Param< bool > PRIMALSEPARATION
only separate cuts that are tight for the best feasible solution?
constexpr Param< bool > ONLYRANKONE
Separate only rank 1 inequalities w.r.t. CG-MIP separator?
constexpr Param< int > MAXDEPTH
maximal depth at which the separator is applied (-1: unlimited)
constexpr Param< bool > OBJLONE
Should the objective of the sub-MIP minimize the l1-norm of the multipliers?
constexpr Param< int > MAXROWAGE
maximal age of rows to consider if onlyactiverows is false
constexpr Param< bool > INTCONVERT
Convert some integral variables attaining fractional values to have integral value?
constexpr Param< bool > DYNAMICCUTS
should generated cuts be removed from the LP if they are no longer tight?
constexpr Param< double > CUTCOEFBND
bounds on the values of the coefficients in the CG-cut
constexpr Param< bool > USEOBJLB
Use lower bound on objective function (via primal solution)?
constexpr Param< bool > USESTRONGCG
use strong CG-function to strengthen cut?
constexpr Param< bool > USECUTPOOL
use cutpool to store CG-cuts even if the are not efficient?
constexpr Param< long long > MINNODELIMIT
minimum number of nodes considered for sub-MIP (-1: unlimited)
constexpr Param< bool > ADDVIOLATIONCONS
add constraint to subscip that only allows violated cuts (otherwise add obj. limit)?
constexpr Param< bool > DECISIONTREE
Use decision tree to turn separation on/off?
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< bool > SKIPMULTBOUNDS
Skip the upper bounds on the multipliers in the sub-MIP?
constexpr Param< int > MAXROUNDSROOT
maximal number of cgmip separation rounds in the root node (-1: unlimited)
constexpr Param< bool > OUTPUT
Should information about the sub-MIP and cuts be displayed?
constexpr Param< bool > GENPRIMALSOLS
Try to generate primal solutions from Gomory cuts?
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< double > OBJWEIGHT
weight used for the row combination coefficient in the sub-MIP objective
constexpr Param< double > CONTCONVFRAC
fraction of integral variables converted to be continuous (if contconvert)
constexpr Param< bool > ADDVIOLCONSHDLR
add constraint handler to filter out violated cuts?
constexpr Param< int > MAXROUNDS
maximal number of cgmip separation rounds per node (-1: unlimited)
constexpr Param< int > CONTCONVMIN
minimum number of integral variables before some are converted to be continuous
constexpr Param< double > TIMELIMIT
time limit for sub-MIP
constexpr Param< double > MEMORYLIMIT
memory limit for sub-MIP
constexpr Param< int > INTCONVMIN
minimum number of integral variables before some are converted to have integral value
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <cgmip> is called (1: call at each mult...
constexpr Param< int > PRIORITY
priority of separator <cgmip>
constexpr Param< bool > USEOBJUB
Use upper bound on objective function (via primal solution)?
constexpr Param< bool > CONTCONVERT
Convert some integral variables to be continuous to reduce the size of the sub-MIP?
constexpr Param< bool > CMIROWNBOUNDS
tell CMIR-generator which bounds to used in rounding?
constexpr Param< bool > SUBSCIPFAST
Should the settings for the sub-MIP be optimized for speed?
constexpr Param< bool > ONLYINTVARS
Generate cuts for problems with only integer variables?
constexpr Param< bool > USECMIR
use CMIR-generator (otherwise add cut directly)?
constexpr Param< bool > EARLYTERM
terminate separation if a violated (but possibly sub-optimal) cut has been found?
constexpr Param< double > CLIQUEDENSITY
minimal density of cliques to use a dense clique table
constexpr Param< int > FREQ
frequency for calling separator <clique> (-1: never, 0: only in root node)
constexpr Param< int > MAXZEROEXTENSIONS
maximal number of zero-valued variables extending the clique (-1: no limit)
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <clique> is called (1: call at each mul...
constexpr Param< int > MAXTREENODES
maximal number of nodes in branch and bound tree (-1: no limit)
constexpr Param< int > PRIORITY
priority of separator <clique>
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< int > MAXSEPACUTS
maximal number of clique cuts separated per separation round (-1: no limit)
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< double > CLIQUETABLEMEM
maximal memory size of dense clique table (in kb)
constexpr Param< double > SCALEVAL
factor for scaling weights
constexpr Param< int > BACKTRACKFREQ
frequency for premature backtracking up to tree level 1 (0: no backtracking)
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< int > CLOSETHRES
threshold on number of generated cuts below which the ordinary separation is started
constexpr Param< bool > INCLOBJCUTOFF
include an objective cutoff when computing the relative interior?
constexpr Param< bool > RECOMPUTERELINT
recompute relative interior point in each separation call?
constexpr Param< int > PRIORITY
priority of separator <closecuts>
constexpr Param< int > MAXUNSUCCESSFUL
turn off separation in current node after unsuccessful calls (-1 never turn off)
constexpr Param< double > SEPACOMBVALUE
convex combination value for close cuts
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <closecuts> is called (1: call at each ...
constexpr Param< int > FREQ
frequency for calling separator <closecuts> (-1: never, 0: only in root node)
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< double > MAXLPITERFACTOR
factor for maximal LP iterations in relative interior computation compared to node LP iterations (neg...
constexpr Param< bool > SEPARELINT
generate close cuts w.r.t. relative interior point (best solution otherwise)?
constexpr Param< int > PRIORITY
priority of separator <cmir>
constexpr Param< int > FREQ
frequency for calling separator <cmir> (-1: never, 0: only in root node)
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <cmir> is called (1: call at each multi...
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< int > PRIORITY
priority of separator <convexproj>
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< int > MAXDEPTH
maximal depth at which the separator is applied (-1: unlimited)
constexpr Param< int > NLPITERLIMIT
iteration limit of NLP solver; 0 for no limit
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <convexproj> is called (1: call at each...
constexpr Param< int > FREQ
frequency for calling separator <convexproj> (-1: never, 0: only in root node)
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< int > MAXROUNDS
maximal number of separation rounds per iteration in a branching node (-1: no limit)
constexpr Param< int > MAXINVCUTSROOT
maximal number of cuts investigated per iteration in the root node
constexpr Param< double > MAXWEIGHTRANGE
maximal valid range max(|weights|)/min(|weights|) of row weights
constexpr Param< bool > STRENGTHEN
strengthen cut if integer variables are present.
constexpr Param< int > MAXROUNDSROOT
maximal number of separation rounds in the root node (-1: no limit)
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< int > MAXRANKINTEGRAL
maximal rank of a disj. cut that could be scaled to integral coefficients (-1: unlimited)
constexpr Param< int > MAXINVCUTS
maximal number of cuts investigated per iteration in a branching node
constexpr Param< int > PRIORITY
priority of separator <disjunctive>
constexpr Param< int > MAXCONFSDELAY
delay separation if number of conflict graph edges is larger than predefined value (-1: no limit)
constexpr Param< int > MAXDEPTH
node depth of separating bipartite disjunctive cuts (-1: no limit)
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< int > MAXRANK
maximal rank of a disj. cut that could not be scaled to integral coefficients (-1: unlimited)
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <disjunctive> is called (1: call at eac...
constexpr Param< int > FREQ
frequency for calling separator <disjunctive> (-1: never, 0: only in root node)
constexpr Param< bool > DYNAMICCUTS
should generated cuts be removed from the LP if they are no longer tight?
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< double > MINVIOLATION
minimal violation of an edge-concave cut to be separated
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <eccuts> is called (1: call at each mul...
constexpr Param< int > MAXSEPACUTS
maximal number of edge-concave cuts separated per separation round
constexpr Param< double > CUTMAXRANGE
maximal coef. range of a cut (max coef. divided by min coef.) in order to be added to LP relaxation
constexpr Param< int > MAXAGGRSIZE
search for edge-concave aggregations of at most this size
constexpr Param< int > MINAGGRSIZE
search for edge-concave aggregations of at least this size
constexpr Param< int > MAXBILINTERMS
maximum number of bilinear terms allowed to be in a quadratic constraint
constexpr Param< int > FREQ
frequency for calling separator <eccuts> (-1: never, 0: only in root node)
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< int > MAXSTALLROUNDS
maximum number of unsuccessful rounds in the edge-concave aggregation search
constexpr Param< int > PRIORITY
priority of separator <eccuts>
constexpr Param< int > MAXSEPACUTSROOT
maximal number of edge-concave cuts separated per separation round in the root node
constexpr Param< int > MAXROUNDS
maximal number of eccuts separation rounds per node (-1: unlimited)
constexpr Param< int > MAXROUNDSROOT
maximal number of eccuts separation rounds in the root node (-1: unlimited)
constexpr Param< int > MAXDEPTH
maximal depth at which the separator is applied (-1: unlimited)
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< int > PRIORITY
priority of separator <flowcover>
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <flowcover> is called (1: call at each ...
constexpr Param< int > FREQ
frequency for calling separator <flowcover> (-1: never, 0: only in root node)
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< int > PRIORITY
priority of separator <gauge>
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< int > FREQ
frequency for calling separator <gauge> (-1: never, 0: only in root node)
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <gauge> is called (1: call at each mult...
constexpr Param< int > NLPITERLIMIT
iteration limit of NLP solver; 0 for no limit
constexpr Param< int > MAXRANK
maximal rank of a gomory cut that could not be scaled to integral coefficients (-1: unlimited)
constexpr Param< int > MAXSEPACUTSROOT
maximal number of gomory cuts separated per separation round in the root node
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< int > MAXRANKINTEGRAL
maximal rank of a gomory cut that could be scaled to integral coefficients (-1: unlimited)
constexpr Param< bool > DYNAMICCUTS
should generated cuts be removed from the LP if they are no longer tight?
constexpr Param< bool > SIDETYPEBASIS
choose side types of row (lhs/rhs) based on basis information?
constexpr Param< bool > FORCECUTS
if conversion to integral coefficients failed still consider the cut
constexpr Param< double > AWAY
minimal integrality violation of a basis variable in order to try Gomory cut
constexpr Param< int > FREQ
frequency for calling separator <gomory> (-1: never, 0: only in root node)
constexpr Param< bool > SEPARATEROWS
separate rows with integral slack
constexpr Param< int > MAXSEPACUTS
maximal number of gomory cuts separated per separation round
constexpr Param< bool > DELAYEDCUTS
should cuts be added to the delayed cut pool?
constexpr Param< bool > MAKEINTEGRAL
try to scale cuts to integral coefficients
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< bool > GENBOTHGOMSCG
Should both Gomory and strong CG cuts be generated (otherwise take best)?
constexpr Param< int > MAXROUNDS
maximal number of gomory separation rounds per node (-1: unlimited)
constexpr Param< int > MAXROUNDSROOT
maximal number of gomory separation rounds in the root node (-1: unlimited)
constexpr Param< int > PRIORITY
priority of separator <gomory>
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <gomory> is called (1: call at each mul...
constexpr Param< bool > TRYSTRONGCG
try to generate strengthened Chvatal-Gomory cuts?
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< int > FREQ
frequency for calling separator <gomorymi> (-1: never, 0: only in root node)
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <gomorymi> is called (1: call at each m...
constexpr Param< int > PRIORITY
priority of separator <gomorymi>
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< int > PRIORITY
priority of separator <impliedbounds>
constexpr Param< bool > USETWOSIZECLIQUES
should violated inequalities for cliques with 2 variables be separated?
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <impliedbounds> is called (1: call at e...
constexpr Param< int > FREQ
frequency for calling separator <impliedbounds> (-1: never, 0: only in root node)
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <interminor> is called (1: call at each...
constexpr Param< double > MINCUTVIOL
minimum required violation of a cut
constexpr Param< bool > USEBOUNDS
whether to also enforce nonegativity bounds of principle minors
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< int > MAXROUNDSROOT
maximal number of separation rounds in the root node (-1: unlimited)
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< int > MAXROUNDS
maximal number of separation rounds per node (-1: unlimited)
constexpr Param< int > FREQ
frequency for calling separator <interminor> (-1: never, 0: only in root node)
constexpr Param< bool > USESTRENGTHENING
whether to use strengthened intersection cuts to separate minors
constexpr Param< int > PRIORITY
priority of separator <interminor>
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< int > FREQ
frequency for calling separator <intobj> (-1: never, 0: only in root node)
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <intobj> is called (1: call at each mul...
constexpr Param< int > PRIORITY
priority of separator <intobj>
constexpr Param< int > FREQ
frequency for calling separator <knapsackcover> (-1: never, 0: only in root node)
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< int > PRIORITY
priority of separator <knapsackcover>
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <knapsackcover> is called (1: call at e...
constexpr Param< bool > ALLOWLOCAL
should locally valid cuts be generated?
constexpr Param< int > MAXROUNDS
maximal number of separation rounds per node (-1: unlimited)
constexpr Param< double > AWAY
minimal integrality violation of a basis variable to try separation
constexpr Param< double > PERROOTLPITERFACTOR
factor w.r.t. root node LP iterations for iteration limit of each separating LP (negative for no limi...
constexpr Param< bool > MUPARAMCONST
is the mu parameter (factor for step length) constant?
constexpr Param< bool > SIDETYPEBASIS
choose side types of row (lhs/rhs) based on basis information?
constexpr Param< bool > SORTCUTOFFSOL
sort fractional integer columnsbased on fractionality?
constexpr Param< bool > DYNAMICCUTS
should generated cuts be removed from LP if they are no longer tight?
constexpr Param< double > RADIUSMAX
maximum radius of the ball used in stabilization of Lagrangian multipliers
constexpr Param< double > DELTASLAB1UB
factor of delta deciding larger increment of mu parameter (factor for step length)
constexpr Param< double > MUSLAB2FACTOR
factor of mu parameter (factor for step length) for smaller increment
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< double > TOTALLPITERLIMITFACTOR
factor w.r.t. root node LP iterations for maximal separating LP iterations in the tree (negative for ...
constexpr Param< double > PERLPITERFACTOR
factor w.r.t. non-root node LP iterations for iteration limit of each separating LP (negative for no ...
constexpr Param< double > MUSLAB3FACTOR
factor of mu parameter (factor for step length) for reduction
constexpr Param< double > PERROUNDCUTSFACTORROOT
factor w.r.t. number of integer columns for number of cuts separated per separation round in root nod...
constexpr Param< double > MUBACKTRACKFACTOR
factor of mu while backtracking the mu parameter (factor for step length)
constexpr Param< int > MINRESTART
minimum restart round for separator execution (0: from beginning of the instance solving,...
constexpr Param< int > CUTGENFREQ
frequency of subgradient iterations for generating cuts
constexpr Param< int > NMAXLAGRANGIANVALSFORAVG
maximal number of iterations for rolling average of Lagrangian value
constexpr Param< double > DUALDEGENERACYRATETHRESHOLD
minimum dual degeneracy rate for separator execution
constexpr Param< double > MUPARAMINIT
initial value of the mu parameter (factor for step length)
constexpr Param< double > MUSLAB1FACTOR
factor of mu parameter (factor for step length) for larger increment
constexpr Param< double > CONSTANT
a constant for stablity center based stabilization of Lagrangian multipliers
constexpr Param< double > RADIUSINIT
initial radius of the ball used in stabilization of Lagrangian multipliers
constexpr Param< double > DELTASLAB2UB
factor of delta deciding smaller increment of mu parameter (factor for step length)
constexpr Param< double > VARCONSRATIOTHRESHOLD
minimum variable-constraint ratio on optimal face for separator execution
constexpr Param< int > FREQ
frequency for calling separator <lagromory> (-1: never, 0: only in root node)
constexpr Param< int > NMAXCUTSPERLPROOT
maximal number of cuts separated per Lagromory LP in the root node
constexpr Param< double > UBPARAMNEGFACTOR
factor for negative upper bound used as an estimate for the optimal Lagrangian dual value
constexpr Param< double > MUPARAMUB
upper bound of the mu parameter (factor for step length)
constexpr Param< double > UBPARAMPOSFACTOR
factor for positive upper bound used as an estimate for the optimal Lagrangian dual value
constexpr Param< int > CUTADDFREQ
frequency of subgradient iterations for adding cuts to objective function
constexpr Param< bool > SEPARATEROWS
separate rows with integral slack?
constexpr Param< int > OPTIMALFACEPRIORITY
priority of the optimal face for separator execution (0: low priority, 1: medium priority,...
constexpr Param< int > PERROUNDNMAXLPITERS
maximal number of separating LP iterations per separation round (-1: unlimited)
constexpr Param< int > NMAXCUTSPERLP
maximal number of cuts separated per Lagromory LP in the non-root node
constexpr Param< int > PRIORITY
priority of separator <lagromory>
constexpr Param< double > RADIUSUPDATEWEIGHT
multiplier to evaluate cut violation score used for updating ball radius
constexpr Param< int > STABILITYCENTERTYPE
type of stability center for taking weighted average of Lagrangian multipliers for stabilization (0: ...
constexpr Param< double > RADIUSMIN
minimum radius of the ball used in stabilization of Lagrangian multipliers
constexpr Param< double > TOTALCUTSFACTOR
factor w.r.t. number of integer columns for total number of cuts separated
constexpr Param< bool > AGGREGATECUTS
aggregate all generated cuts using the Lagrangian multipliers?
constexpr Param< int > NMAXMAINITERS
maximal number of main loop iterations of the relax-and-cut algorithm
constexpr Param< int > PROJECTIONTYPE
the ball into which the Lagrangian multipliers are projected for stabilization (0: no projection,...
constexpr Param< int > NMAXSUBGRADIENTITERS
maximal number of subgradient loop iterations of the relax-and-cut algorithm
constexpr Param< double > PERROUNDLPITERLIMITFACTOR
factor w.r.t.
constexpr Param< int > MAXROUNDSROOT
maximal number of separation rounds in the root node (-1: unlimited)
constexpr Param< bool > MAKEINTEGRAL
try to scale all cuts to integral coefficients?
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <lagromory> is called (1: call at each ...
constexpr Param< bool > FORCECUTS
force cuts to be added to the LP?
constexpr Param< double > CUTSFILTERFACTOR
fraction of generated cuts per explored basis to accept from separator
constexpr Param< double > ROOTLPITERLIMITFACTOR
factor w.r.t.
constexpr Param< bool > DELAYEDCUTS
should cuts be added to the delayed cut pool
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< double > MUPARAMLB
lower bound of the mu parameter (factor for step length)
constexpr Param< double > PERROUNDCUTSFACTOR
factor w.r.t. number of integer columns for number of cuts separated per separation round at a non-ro...
constexpr Param< int > NMAXCONSECITERSFORMUUPDATE
consecutive number of iterations used to determine if mu needs to be backtracked
constexpr Param< bool > FIXINTEGRALRHS
should an additional variable be complemented if f0 = 0?
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< int > NCLUSTERS
number of clusters to generate in the shrunken network – default separation
constexpr Param< int > MAXTESTDELTA
maximal number of different deltas to try (-1: unlimited) – default separation
constexpr Param< int > MODELTYPE
model type of network (0: auto, 1:directed, 2:undirected)
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< bool > DYNAMICCUTS
should generated cuts be removed from the LP if they are no longer tight?
constexpr Param< bool > SEPARATEKNAPSACK
should we separate knapsack cover inequalities on the network cuts?
constexpr Param< int > MAXSEPACUTSROOT
maximal number of mcf cuts separated per separation round in the root node – default separation
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <mcf> is called (1: call at each multip...
constexpr Param< bool > SEPARATEFLOWCUTSET
should we separate flowcutset inequalities on the network cuts?
constexpr Param< double > MAXARCINCONSISTENCYRATIO
maximum inconsistency ratio of arcs not to be deleted
constexpr Param< bool > SEPARATESINGLENODECUTS
should we separate inequalities based on single-node cuts?
constexpr Param< int > FREQ
frequency for calling separator <mcf> (-1: never, 0: only in root node)
constexpr Param< bool > TRYNEGSCALING
should negative values also be tested in scaling?
constexpr Param< double > MAXINCONSISTENCYRATIO
maximum inconsistency ratio for separation at all
constexpr Param< bool > CHECKCUTSHORECONNECTIVITY
should we separate only if the cuts shores are connected?
constexpr Param< int > PRIORITY
priority of separator <mcf>
constexpr Param< double > MAXWEIGHTRANGE
maximal valid range max(|weights|)/min(|weights|) of row weights
constexpr Param< int > MAXSEPACUTS
maximal number of mcf cuts separated per separation round
constexpr Param< int > MAXROUNDS
maximal number of separation rounds per node (-1: unlimited)
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< int > MAXROUNDSROOT
maximal number of separation rounds in the root node (-1: unlimited)
constexpr Param< bool > IGNOREPACKINGCONSS
whether to ignore circle packing constraints during minor detection
constexpr Param< double > MINCUTVIOL
minimum required violation of a cut
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <minor> is called (1: call at each mult...
constexpr Param< double > MAXMINORSFAC
factor for the maximum number of minors, i.e., max(const, fac * # quadratic terms)
constexpr Param< int > MAXMINORSCONST
constant for the maximum number of minors, i.e., max(const, fac * # quadratic terms)
constexpr Param< int > FREQ
frequency for calling separator <minor> (-1: never, 0: only in root node)
constexpr Param< int > PRIORITY
priority of separator <minor>
constexpr Param< int > PRIORITY
priority of separator <mixing>
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< int > FREQ
frequency for calling separator <mixing> (-1: never, 0: only in root node)
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <mixing> is called (1: call at each mul...
constexpr Param< int > MAXROUNDS
maximal number of mixing separation rounds per node (-1: unlimited)
constexpr Param< bool > ISCUTSONINTS
Should general integer variables be used to generate cuts?
constexpr Param< int > MAXNUNSUCCESSFUL
maximal number of consecutive unsuccessful iterations
constexpr Param< bool > USELOCALBOUNDS
Should local bounds be used?
constexpr Param< int > MAXROUNDSROOT
maximal number of mixing separation rounds in the root node (-1: unlimited)
constexpr Param< int > OFFSETNODESLEVEL
offset of nodes allowed in the same level of the level graph (additional to the percentage of levelno...
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< int > SORTSWITCH
use sorted variable array (unsorted(0), maxlp(1), minlp(2), maxfrac(3), minfrac(4))
constexpr Param< int > MAXCUTSLEVEL
maximal number of oddcycle cuts generated in every level of the level graph
constexpr Param< int > MAXREFERENCE
minimal weight on an edge (in level graph or bipartite graph)
constexpr Param< bool > ADDSELFARCS
add links between a variable and its negated
constexpr Param< int > MAXUNSUCESSFULL
number of unsuccessful calls at current node
constexpr Param< int > MAXSEPACUTS
maximal number of oddcycle cuts separated per separation round
constexpr Param< bool > INCLUDETRIANGLES
separate triangles found as 3-cycles or repaired larger cycles
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< bool > REPAIRCYCLES
try to repair violated cycles with double appearance of a variable
constexpr Param< int > MAXCUTSROOT
maximal number of oddcycle cuts generated per chosen variable as root of the level graph
constexpr Param< bool > LIFTODDCYCLES
Should odd cycle cuts be lifted?
constexpr Param< int > SCALINGFACTOR
factor for scaling of the arc-weights
constexpr Param< bool > SORTROOTNEIGHBORS
sort level of the root neighbors by fractionality (maxfrac)
constexpr Param< int > FREQ
frequency for calling separator <oddcycle> (-1: never, 0: only in root node)
constexpr Param< int > MAXROUNDS
maximal number of oddcycle separation rounds per node (-1: unlimited)
constexpr Param< bool > USEGLS
Should the search method by Groetschel, Lovasz, Schrijver be used? Otherwise use levelgraph method by...
constexpr Param< int > MAXPERNODESLEVEL
percentage of nodes allowed in the same level of the level graph [0-100]
constexpr Param< int > PRIORITY
priority of separator <oddcycle>
constexpr Param< int > MAXSEPACUTSROOT
maximal number of oddcycle cuts separated per separation round in the root node
constexpr Param< bool > MULTIPLECUTS
Even if a variable is already covered by a cut, still try it as start node for a cycle search?
constexpr Param< bool > RECALCLIFTCOEF
Calculate lifting coefficient of every candidate in every step (or only if its chosen)?
constexpr Param< int > PERCENTTESTVARS
percentage of variables to try the chosen method on [0-100]
constexpr Param< bool > ALLOWMULTIPLECUTS
Even if a variable is already covered by a cut, still allow another cut to cover it too?
constexpr Param< int > CUTTHRESHOLD
maximal number of other cuts s.t. separation is applied (-1 for direct call)
constexpr Param< int > MAXROUNDSROOT
maximal number of oddcycle separation rounds in the root node (-1: unlimited)
constexpr Param< bool > LPLIFTCOEF
Choose lifting candidate by coef*lpvalue or only by coef?
constexpr Param< int > OFFSETTESTVARS
offset of variables to try the chosen method on (additional to the percentage of testvars)
constexpr Param< int > MAXNLEVELS
maximal number of levels in level graph
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <oddcycle> is called (1: call at each m...
constexpr Param< bool > APPLYBDCHGS
should the found global bound deductions be applied in the original SCIP?
constexpr Param< bool > REDUCEDINFER
should the inference values only be used when rapidlearning found other reductions?
constexpr Param< long long > NWAITINGNODES
number of nodes that should be processed before rapid learning is executed locally based on the progr...
constexpr Param< int > MAXNODES
maximum number of nodes considered in rapid learning run
constexpr Param< bool > APPLYSOLVED
should a solved status be copied to the original SCIP?
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <rapidlearning> is called (1: call at e...
constexpr Param< int > FREQ
frequency for calling separator <rapidlearning> (-1: never, 0: only in root node)
constexpr Param< bool > CHECKDUALBOUND
should the progress on the dual bound be checked?
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< double > MINVARCONSRATIO
minimal ratio of unfixed variables in relation to basis size to allow local rapid learning
constexpr Param< int > PRIORITY
priority of separator <rapidlearning>
constexpr Param< double > LPITERQUOT
maximal fraction of LP iterations compared to node LP iterations
constexpr Param< bool > CHECKEXEC
check whether rapid learning should be executed
constexpr Param< bool > CHECKOBJ
should the (local) objective function be checked?
constexpr Param< bool > APPLYCONFLICTS
should the found conflicts be applied in the original SCIP?
constexpr Param< bool > APPLYINFERVALS
should the inference values be used as initialization in the original SCIP?
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< bool > COPYCUTS
should all active cuts from cutpool be copied to constraints in subproblem?
constexpr Param< int > MINNODES
minimum number of nodes considered in rapid learning run
constexpr Param< int > MAXNVARS
maximum problem size (variables) for which rapid learning will be called
constexpr Param< bool > CHECKDEGENERACY
should local LP degeneracy be checked?
constexpr Param< int > MAXCALLS
maximum number of overall calls
constexpr Param< int > MAXNCONSS
maximum problem size (constraints) for which rapid learning will be called
constexpr Param< double > MININFLPRATIO
minimal threshold of inf/obj leaves to allow local rapid learning
constexpr Param< bool > CHECKNSOLS
should the number of solutions found so far be checked?
constexpr Param< bool > CHECKLEAVES
should the ratio of leaves proven to be infeasible and exceeding the cutoff bound be checked?
constexpr Param< double > MINDEGENERACY
minimal degeneracy threshold to allow local rapid learning
constexpr Param< bool > APPLYPRIMALSOL
should the incumbent solution be copied to the original SCIP?
constexpr Param< bool > CONTVARS
should rapid learning be applied when there are continuous variables?
constexpr Param< double > CONTVARSQUOT
maximal portion of continuous variables to apply rapid learning
constexpr Param< int > MAXROUNDS
maximal number of separation rounds per node (-1: unlimited)
constexpr Param< bool > ONLYCONTROWS
if set to true, only continuous rows are used for rlt cuts
constexpr Param< double > DIRCUTOFFDISTWEIGHT
weight of directed cutoff distance in cut score calculation
constexpr Param< bool > HIDDENRLT
whether RLT cuts (TRUE) or only McCormick inequalities (FALSE) should be added for hidden products
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< bool > USEPROJECTION
if set to true, projected rows are checked first
constexpr Param< double > OBJPARALWEIGHT
weight of objective parallelism in cut score calculation
constexpr Param< int > FREQ
frequency for calling separator <rlt> (-1: never, 0: only in root node)
constexpr Param< double > EFFICACYWEIGHT
weight of efficacy in cut score calculation
constexpr Param< bool > DETECTHIDDEN
if set to true, hidden products are detected and separated by McCormick cuts
constexpr Param< double > BADSCORE
threshold for score of cut relative to best score to be discarded
constexpr Param< int > MAXUNKNOWNTERMS
maximal number of unknown bilinear terms a row is still used with (-1: unlimited)
constexpr Param< int > MAXROUNDSROOT
maximal number of separation rounds in the root node (-1: unlimited)
constexpr Param< bool > ADDTOPOOL
if set to true, globally valid RLT cuts are added to the global cut pool
constexpr Param< double > GOODMAXPARALL
maximum parallelism for good cuts
constexpr Param< double > GOODSCORE
threshold for score of cut relative to best score to be considered good, so that less strict filterin...
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <rlt> is called (1: call at each multip...
constexpr Param< int > MAXUSEDVARS
maximal number of variables used to compute rlt cuts (-1: unlimited)
constexpr Param< bool > USEINSUBSCIP
if set to true, rlt is also used in sub-scips
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< double > MAXPARALL
maximum parallelism for non-good cuts
constexpr Param< int > MAXNCUTS
maximal number of rlt-cuts that are added per round (-1: unlimited)
constexpr Param< bool > ONLYEQROWS
if set to true, only equality rows are used for rlt cuts
constexpr Param< bool > ONLYORIGINAL
if set to true, only original rows and variables are used
constexpr Param< int > PRIORITY
priority of separator <rlt>
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <strongcg> is called (1: call at each m...
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< int > FREQ
frequency for calling separator <strongcg> (-1: never, 0: only in root node)
constexpr Param< int > PRIORITY
priority of separator <strongcg>
constexpr Param< int > MAXSEPACUTS
maximal number of zerohalf cuts separated per separation round
constexpr Param< double > GOODMAXPARALL
maximum parallelism for good cuts
constexpr Param< double > OBJPARALWEIGHT
weight of objective parallelism in cut score calculation
constexpr Param< int > MAXCUTCANDS
maximal number of zerohalf cuts considered per separation round
constexpr Param< double > MAXROWDENSITY
maximal density of row to be used in aggregation
constexpr Param< double > EFFICACYWEIGHT
weight of efficacy in cut score calculation
constexpr Param< int > MAXSEPACUTSROOT
maximal number of zerohalf cuts separated per separation round in the root node
constexpr Param< double > MAXSLACKROOT
maximal slack of rows to be used in aggregation in the root node
constexpr Param< int > DENSITYOFFSET
additional number of variables allowed in row on top of density
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< double > MAXPARALL
maximum parallelism for non-good cuts
constexpr Param< int > MAXROUNDS
maximal number of zerohalf separation rounds per node (-1: unlimited)
constexpr Param< double > MINVIOL
minimal violation to generate zerohalfcut for
constexpr Param< bool > DYNAMICCUTS
should generated cuts be removed from the LP if they are no longer tight?
constexpr Param< int > MAXROUNDSROOT
maximal number of zerohalf separation rounds in the root node (-1: unlimited)
constexpr Param< double > DIRCUTOFFDISTWEIGHT
weight of directed cutoff distance in cut score calculation
constexpr Param< bool > DELAY
should separator be delayed, if other separators found cuts?
constexpr Param< double > GOODSCORE
threshold for score of cut relative to best score to be considered good, so that less strict filterin...
constexpr Param< int > INITSEED
initial seed used for random tie-breaking in cut selection
constexpr Param< int > PRIORITY
priority of separator <zerohalf>
constexpr Param< double > MAXSLACK
maximal slack of rows to be used in aggregation
constexpr Param< double > BADSCORE
threshold for score of cut relative to best score to be discarded
constexpr Param< int > EXPBACKOFF
base for exponential increase of frequency at which separator <zerohalf> is called (1: call at each m...
constexpr Param< int > FREQ
frequency for calling separator <zerohalf> (-1: never, 0: only in root node)
constexpr Param< char > EFFICACYNORM
row norm to use for efficacy calculation ('e'uclidean, 'm'aximum, 's'um, 'd'iscrete)
constexpr Param< double > MAXCUTSGENFACTOR
factor w.r.t.
constexpr Param< int > CUTAGELIMIT
maximum age a cut can reach before it is deleted from the global cut pool, or -1 to keep all cuts
constexpr Param< int > POOLFREQ
separation frequency for the global cut pool (-1: disable global cut pool, 0: only separate pool at t...
constexpr Param< int > MAXCUTSROOT
maximal number of separated cuts per separation round at the root node (0: disable root node separati...
constexpr Param< double > MAXBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< int > MAXSTALLROUNDSROOT
maximal number of consecutive separation rounds without objective or integrality improvement in the r...
constexpr Param< char > ORTHOFUNC
function used for calc. scalar prod. in orthogonality test ('e'uclidean, 'd'iscrete)
constexpr Param< double > MINEFFICACYROOT
minimal efficacy for a cut to enter the LP in the root node
constexpr Param< double > MAXLOCALBOUNDDIST
maximal relative distance from current node's dual bound to primal bound compared to best node's dual...
constexpr Param< double > MINEFFICACY
minimal efficacy for a cut to enter the LP
constexpr Param< int > MAXADDROUNDS
maximal additional number of separation rounds in subsequent price-and-cut loops (-1: no additional r...
constexpr Param< double > MAXCUTSROOTGENFACTOR
factor w.r.t.
constexpr Param< int > MAXROUNDSROOTSUBRUN
maximal number of separation rounds in the root node of a subsequent run (-1: unlimited)
constexpr Param< double > MINACTIVITYQUOT
minimum cut activity quotient to convert cuts into constraints during a restart (0....
constexpr Param< char > CUTSELRESTART
cut selection during restart ('a'ge, activity 'q'uotient)
constexpr Param< double > MAXCOEFRATIOFACROWPREP
maximal ratio between coefficients (as factor of 1/feastol) to ensure in rowprep cleanup
constexpr Param< char > CUTSELSUBSCIP
cut selection for sub SCIPs ('a'ge, activity 'q'uotient)
constexpr Param< int > MAXROUNDSROOT
maximal number of separation rounds in the root node (-1: unlimited)
constexpr Param< int > MAXROUNDS
maximal number of separation rounds per node (-1: unlimited)
constexpr Param< bool > FILTERCUTPOOLREL
should cutpool separate only cuts with high relative efficacy?
constexpr Param< int > MAXCUTS
maximal number of cuts separated per separation round (0: disable local separation)
constexpr Param< int > MAXRUNS
maximal number of runs for which separation is enabled (-1: unlimited)
constexpr Param< double > MAXCOEFRATIO
maximal ratio between coefficients in strongcg, cmir, and flowcover cuts
constexpr Param< int > MAXSTALLROUNDS
maximal number of consecutive separation rounds without objective or integrality improvement in local...
constexpr Param< bool > ENABLED
should the event handler adapt the solver behavior?
constexpr Param< long long > NODEOFFSET
node offset for rank-1 and estimate transitions
constexpr Param< bool > USEEMPHSETTINGS
should emphasis settings for the solving phases be used, or settings files?
constexpr Param< bool > USERESTART1TO2
should a restart be applied between the feasibility and improvement phase?
constexpr Param< bool > FALLBACK
should the event handler fall back from optimal phase?
constexpr Param< std::string > IMPROVESETNAME
settings file for improvement phase – precedence over emphasis settings
constexpr Param< double > OPTIMALVALUE
optimal solution value for problem
constexpr Param< char > TRANSITIONMETHOD
transition method: Possible options are 'e'stimate,'l'ogarithmic regression,'o'ptimal-value based,...
constexpr Param< char > XTYPE
x-type for logarithmic regression - (t)ime, (n)odes, (l)p iterations
constexpr Param< std::string > FEASSETNAME
settings file for feasibility phase – precedence over emphasis settings
constexpr Param< bool > TESTMODE
should the event handler test all phase transitions?
constexpr Param< bool > INTERRUPTOPTIMAL
should the event handler interrupt the solving process after optimal solution was found?
constexpr Param< std::string > PROOFSETNAME
settings file for proof phase – precedence over emphasis settings
constexpr Param< bool > USERESTART2TO3
should a restart be applied between the improvement and the proof phase?
constexpr Param< bool > ACTIVE
is statistics table <benders> active
constexpr Param< bool > ACTIVE
is statistics table <branchrules> active
constexpr Param< bool > ACTIVE
is statistics table <compression> active
constexpr Param< bool > ACTIVE
is statistics table <concurrentsolver> active
constexpr Param< bool > ACTIVE
is statistics table <conflict> active
constexpr Param< bool > ACTIVE
is statistics table <cons_nonlinear> active
constexpr Param< bool > ACTIVE
is statistics table <constiming> active
constexpr Param< bool > ACTIVE
is statistics table <constraint> active
constexpr Param< bool > ACTIVE
is statistics table <cutsel> active
constexpr Param< bool > ACTIVE
is statistics table <estim> active
constexpr Param< bool > ACTIVE
is statistics table <exprhdlr> active
constexpr Param< bool > ACTIVE
is statistics table <heuristics> active
constexpr Param< bool > ACTIVE
is statistics table <lp> active
constexpr Param< bool > ACTIVE
is statistics table <neighborhood> active
constexpr Param< bool > ACTIVE
is statistics table <nlhdlr_bilinear> active
constexpr Param< bool > ACTIVE
is statistics table <nlhdlr_quadratic> active
constexpr Param< bool > ACTIVE
is statistics table <nlhdlr> active
constexpr Param< bool > ACTIVE
is statistics table <nlp> active
constexpr Param< bool > ACTIVE
is statistics table <nlpi> active
constexpr Param< bool > ACTIVE
is statistics table <origprob> active
constexpr Param< bool > ACTIVE
is statistics table <presolvedprob> active
constexpr Param< bool > ACTIVE
is statistics table <presolver> active
constexpr Param< bool > ACTIVE
is statistics table <pricer> active
constexpr Param< bool > ACTIVE
is statistics table <propagator> active
constexpr Param< bool > ACTIVE
is statistics table <relaxator> active
constexpr Param< bool > ACTIVE
is statistics table <root> active
constexpr Param< bool > ACTIVE
is statistics table <scheduler> active
constexpr Param< bool > ACTIVE
is statistics table <separator> active
constexpr Param< bool > ACTIVE
is statistics table <solution> active
constexpr Param< bool > ACTIVE
is statistics table <status> active
constexpr Param< bool > ACTIVE
is statistics table <symmetry> active
constexpr Param< bool > ACTIVE
is statistics table <timing> active
constexpr Param< bool > ACTIVE
is statistics table <tree> active
constexpr Param< bool > READING
belongs reading time to solving time?
constexpr Param< bool > ENABLED
is timing enabled?
constexpr Param< bool > STATISTICTIMING
should timing for statistic output be performed?
constexpr Param< bool > RARECLOCKCHECK
should clock checks of solving time be performed less frequently (note: time limit could be exceeded ...
constexpr Param< int > CLOCKTYPE
default clock type (1: CPU user seconds, 2: wall clock time)
constexpr Param< bool > NLPIEVAL
should time for evaluation in NLP solves be measured?
constexpr Param< bool > DISPSOLS
should the node where solutions are found be visualized?
constexpr Param< std::string > BAKFILENAME
name of the BAK tool output file, or - if no BAK tool output should be created
constexpr Param< bool > DISPLB
should lower bound information be visualized?
constexpr Param< bool > REALTIME
should the real solving time be used instead of a time step counter in visualization?
constexpr Param< bool > OBJEXTERN
should be output the external value of the objective?
constexpr Param< std::string > VBCFILENAME
name of the VBC tool output file, or - if no VBC tool output should be created
constexpr Param< bool > PRINTZEROS
should variables set to zero be printed?
constexpr Param< bool > ALLCONSS
should all constraints be written (including the redundant constraints)?
constexpr Param< int > GENERICNAMESOFFSET
when writing a generic problem the index for the first variable should start with?
Enum equivalent of SCIP's string parameters.
Definition param.hpp:6
Stores the argument type and string representation of a parameter.
Definition param.hpp:14