1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2 /* */ 3 /* This file is part of the program and library */ 4 /* SCIP --- Solving Constraint Integer Programs */ 5 /* */ 6 /* Copyright (C) 2002-2021 Konrad-Zuse-Zentrum */ 7 /* fuer Informationstechnik Berlin */ 8 /* */ 9 /* SCIP is distributed under the terms of the ZIB Academic License. */ 10 /* */ 11 /* You should have received a copy of the ZIB Academic License */ 12 /* along with SCIP; see the file COPYING. If not visit scipopt.org. */ 13 /* */ 14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 15 16 /**@file struct_set.h 17 * @ingroup INTERNALAPI 18 * @brief datastructures for global SCIP settings 19 * @author Tobias Achterberg 20 */ 21 22 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/ 23 24 #ifndef __SCIP_STRUCT_SET_H__ 25 #define __SCIP_STRUCT_SET_H__ 26 27 28 #include "scip/def.h" 29 #include "scip/message.h" 30 #include "scip/type_bandit.h" 31 #include "scip/type_set.h" 32 #include "scip/type_clock.h" 33 #include "scip/type_paramset.h" 34 #include "scip/type_event.h" 35 #include "scip/type_scip.h" 36 #include "scip/type_branch.h" 37 #include "scip/type_conflict.h" 38 #include "scip/type_cons.h" 39 #include "scip/type_disp.h" 40 #include "scip/type_dialog.h" 41 #include "scip/type_heur.h" 42 #include "scip/type_compr.h" 43 #include "scip/type_nodesel.h" 44 #include "scip/type_presol.h" 45 #include "scip/type_pricer.h" 46 #include "scip/type_reader.h" 47 #include "scip/type_relax.h" 48 #include "scip/type_sepa.h" 49 #include "scip/type_table.h" 50 #include "scip/type_prop.h" 51 #include "nlpi/type_nlpi.h" 52 #include "scip/type_concsolver.h" 53 #include "scip/type_benders.h" 54 #include "scip/debug.h" 55 56 #ifdef __cplusplus 57 extern "C" { 58 #endif 59 60 /** global SCIP settings */ 61 struct SCIP_Set 62 { 63 SCIP_STAGE stage; /**< SCIP operation stage */ 64 SCIP* scip; /**< very ugly: pointer to scip main data structure for callback methods */ 65 SCIP_PARAMSET* paramset; /**< set of parameters */ 66 BMS_BUFMEM* buffer; /**< memory buffers for short living temporary objects */ 67 BMS_BUFMEM* cleanbuffer; /**< memory buffers for short living temporary objects init. to all zero */ 68 SCIP_READER** readers; /**< file readers */ 69 SCIP_PRICER** pricers; /**< variable pricers */ 70 SCIP_CONSHDLR** conshdlrs; /**< constraint handlers (sorted by check priority) */ 71 SCIP_CONSHDLR** conshdlrs_sepa; /**< constraint handlers (sorted by separation priority) */ 72 SCIP_CONSHDLR** conshdlrs_enfo; /**< constraint handlers (sorted by enforcement priority) */ 73 SCIP_CONSHDLR** conshdlrs_include; /**< constraint handlers (sorted by inclusion order) */ 74 SCIP_CONFLICTHDLR** conflicthdlrs; /**< conflict handlers */ 75 SCIP_PRESOL** presols; /**< presolvers */ 76 SCIP_RELAX** relaxs; /**< relaxators */ 77 SCIP_SEPA** sepas; /**< separators */ 78 SCIP_PROP** props; /**< propagators */ 79 SCIP_PROP** props_presol; /**< propagators (sorted by presol priority) */ 80 SCIP_HEUR** heurs; /**< primal heuristics */ 81 SCIP_COMPR** comprs; /**< tree compressions */ 82 SCIP_EVENTHDLR** eventhdlrs; /**< event handlers */ 83 SCIP_NODESEL** nodesels; /**< node selectors */ 84 SCIP_NODESEL* nodesel; /**< currently used node selector, or NULL if invalid */ 85 SCIP_BRANCHRULE** branchrules; /**< branching rules */ 86 SCIP_DISP** disps; /**< display columns */ 87 SCIP_TABLE** tables; /**< statistics tables */ 88 SCIP_DIALOG** dialogs; /**< dialogs */ 89 SCIP_NLPI** nlpis; /**< interfaces to NLP solvers */ 90 SCIP_CONCSOLVERTYPE** concsolvertypes; /**< concurrent solver types */ 91 SCIP_CONCSOLVER** concsolvers; /**< the concurrent solvers used for solving */ 92 SCIP_BENDERS** benders; /**< the data structures managing the Benders' decomposition algorithm */ 93 SCIP_DEBUGSOLDATA* debugsoldata; /**< data for debug solutions */ 94 SCIP_BANDITVTABLE** banditvtables; /**< virtual function tables for bandit algorithms */ 95 char** extcodenames; /**< names of externals codes */ 96 char** extcodedescs; /**< descriptions of external codes */ 97 int nreaders; /**< number of file readers */ 98 int readerssize; /**< size of readers array */ 99 int npricers; /**< number of variable pricers */ 100 int nactivepricers; /**< number of variable pricers used in the current problem */ 101 int pricerssize; /**< size of pricers array */ 102 int nconshdlrs; /**< number of constraint handlers */ 103 int conshdlrssize; /**< size of conshdlrs array */ 104 int nconflicthdlrs; /**< number of conflict handlers */ 105 int conflicthdlrssize; /**< size of conflicthdlrs array */ 106 int npresols; /**< number of presolvers */ 107 int presolssize; /**< size of presols array */ 108 int nrelaxs; /**< number of relaxators */ 109 int relaxssize; /**< size of relaxs array */ 110 int nsepas; /**< number of separators */ 111 int sepassize; /**< size of sepas array */ 112 int nprops; /**< number of propagators */ 113 int propssize; /**< size of props array */ 114 int nheurs; /**< number of primal heuristics */ 115 int heurssize; /**< size of heurs array */ 116 int ncomprs; /**< number of tree compressions */ 117 int comprssize; /**< size of comprs array */ 118 int neventhdlrs; /**< number of event handlers */ 119 int eventhdlrssize; /**< size of eventhdlrs array */ 120 int nnodesels; /**< number of node selectors */ 121 int nodeselssize; /**< size of nodesels array */ 122 int nbranchrules; /**< number of branching rules */ 123 int branchrulessize; /**< size of branchrules array */ 124 int ndisps; /**< number of display columns */ 125 int dispssize; /**< size of disps array */ 126 int ntables; /**< number of statistics tables */ 127 int tablessize; /**< size of tables array */ 128 int ndialogs; /**< number of dialogs */ 129 int dialogssize; /**< size of dialogs array */ 130 int nnlpis; /**< number of NLPIs */ 131 int nlpissize; /**< size of NLPIs array */ 132 int nconcsolvertypes; /**< number of concurrent solver types */ 133 int concsolvertypessize;/**< size of concurrent solver types array */ 134 int nconcsolvers; /**< number of concurrent solvers used for solving */ 135 int concsolverssize; /**< size of concurrent solvers array */ 136 int nbenders; /**< number of Benders' decomposition algorithms */ 137 int nactivebenders; /**< number of Benders' decomposition algorithms that are used */ 138 int benderssize; /**< size of Benders' decomposition algorithms array */ 139 int nextcodes; /**< number of external codes */ 140 int extcodessize; /**< size of external code arrays */ 141 int nbanditvtables; /**< number of bandit algorithm virtual function tables */ 142 int banditvtablessize; /**< size of banditvtables array */ 143 SCIP_Bool pricerssorted; /**< are the pricers sorted by activity and priority? */ 144 SCIP_Bool pricersnamesorted; /**< are the pricers sorted by name? */ 145 SCIP_Bool conflicthdlrssorted;/**< are the conflict handlers sorted by priority? */ 146 SCIP_Bool conflicthdlrsnamesorted;/**< are the conflict handlers sorted by name? */ 147 SCIP_Bool presolssorted; /**< are the presolvers sorted by priority? */ 148 SCIP_Bool presolsnamesorted; /**< are the presolvers sorted by name? */ 149 SCIP_Bool relaxssorted; /**< are the relaxators sorted by priority? */ 150 SCIP_Bool relaxsnamesorted; /**< are the relaxators sorted by name? */ 151 SCIP_Bool sepassorted; /**< are the separators sorted by priority? */ 152 SCIP_Bool sepasnamesorted; /**< are the separators sorted by name? */ 153 SCIP_Bool propssorted; /**< are the propagators sorted by priority? */ 154 SCIP_Bool propspresolsorted; /**< are the propagators in prop_presol sorted? */ 155 SCIP_Bool propsnamesorted; /**< are the propagators sorted by name? */ 156 SCIP_Bool heurssorted; /**< are the heuristics sorted by priority? */ 157 SCIP_Bool heursnamesorted; /**< are the heuristics sorted by name? */ 158 SCIP_Bool comprssorted; /**< are the compressions sorted by priority? */ 159 SCIP_Bool comprsnamesorted; /**< are the compressions sorted by name? */ 160 SCIP_Bool branchrulessorted; /**< are the branching rules sorted by priority? */ 161 SCIP_Bool branchrulesnamesorted;/**< are the branching rules sorted by name? */ 162 SCIP_Bool tablessorted; /**< are the tables sorted by position? */ 163 SCIP_Bool nlpissorted; /**< are the NLPIs sorted by priority? */ 164 SCIP_Bool benderssorted; /**< are the Benders' algorithms sorted by activity and priority? */ 165 SCIP_Bool bendersnamesorted; /**< are the Benders' algorithms sorted by name? */ 166 SCIP_Bool limitchanged; /**< marks whether any of the limit parameters was changed */ 167 SCIP_Bool subscipsoff; /**< marks whether the sub-SCIPs have been deactivated */ 168 169 /* branching settings */ 170 char branch_scorefunc; /**< branching score function ('s'um, 'p'roduct, 'q'uotient) */ 171 char branch_firstsbchild;/**< child node to be regarded first during strong branching (only with propagation): 'u'p child, 'd'own child, 'h'istory-based, or 'a'utomatic */ 172 SCIP_Real branch_scorefac; /**< branching score factor to weigh downward and upward gain prediction 173 * in sum score function */ 174 SCIP_Bool branch_preferbinary;/**< should branching on binary variables be preferred? */ 175 SCIP_Real branch_clamp; /**< minimal fractional distance of branching point to a continuous variable' bounds; a value of 0.5 leads to branching always in the middle of a bounded domain */ 176 SCIP_Real branch_midpull; /**< fraction by which to move branching point of a continuous variable towards the middle of the domain; a value of 1.0 leads to branching always in the middle of the domain */ 177 SCIP_Real branch_midpullreldomtrig; /**< multiply midpull by relative domain width if the latter is below this value */ 178 char branch_lpgainnorm; /**< strategy for normalizing LP gain when updating pseudo costs of continuous variables */ 179 SCIP_Bool branch_delaypscost; /**< whether to delay pseudo costs updates for continuous variables to after separation */ 180 SCIP_Bool branch_divingpscost;/**< should pseudo costs be updated also in diving and probing mode? */ 181 SCIP_Bool branch_forceall; /**< should all strong branching children be regarded even if 182 * one is detected to be infeasible? (only with propagation) */ 183 SCIP_Bool branch_checksbsol; /**< should LP solutions during strong branching with propagation be checked for feasibility? */ 184 SCIP_Bool branch_roundsbsol; /**< should LP solutions during strong branching with propagation be rounded? (only when checksbsol=TRUE) */ 185 SCIP_Bool branch_sumadjustscore; /**< score adjustment near zero by \b adding epsilon (TRUE) or using maximum (FALSE) */ 186 187 /* conflict analysis settings */ 188 SCIP_Real conf_maxvarsfac; /**< maximal fraction of variables involved in a conflict constraint */ 189 int conf_minmaxvars; /**< minimal absolute maximum of variables involved in a conflict constraint */ 190 int conf_maxlploops; /**< maximal number of LP resolving loops during conflict analysis 191 * (-1: no limit) */ 192 int conf_lpiterations; /**< maximal number of LP iterations in each LP resolving loop 193 * (-1: no limit) */ 194 int conf_fuiplevels; /**< number of depth levels up to which first UIP's are used in conflict 195 * analysis (-1: use All-FirstUIP rule) */ 196 int conf_interconss; /**< maximal number of intermediate conflict constraints generated in conflict 197 * graph (-1: use every intermediate constraint) */ 198 int conf_maxconss; /**< maximal number of conflict constraints accepted at an infeasible node 199 * (-1: use all generated conflict constraints) */ 200 int conf_maxstoresize; /**< maximal size of conflict store */ 201 int conf_reconvlevels; /**< number of depth levels up to which UIP reconvergence constraints are 202 * generated (-1: generate reconvergence constraints in all depth levels) */ 203 SCIP_Bool conf_enable; /**< should conflict analysis be enabled? */ 204 SCIP_Bool conf_cleanbnddepend;/**< should conflicts related to an old cutoff bound be removed? */ 205 SCIP_Bool conf_useprop; /**< should propagation conflict analysis be used? (uses conflict graph only) */ 206 char conf_useinflp; /**< should infeasible LP conflict analysis be used? 207 * ('o'ff, 'c'onflict graph, 'd'ual ray, 'b'oth conflict graph and dual ray) 208 */ 209 char conf_useboundlp; /**< should bound exceeding LP conflict analysis be used? 210 * ('o'ff, 'c'onflict graph, 'd'ual ray, 'b'oth conflict graph and dual ray) 211 */ 212 SCIP_Bool conf_usesb; /**< should infeasible/bound exceeding strong branching conflict analysis be 213 * used? */ 214 SCIP_Bool conf_usepseudo; /**< should pseudo solution conflict analysis be used? */ 215 SCIP_Bool conf_prefinfproof; /**< prefer infeasibility proof to boundexceeding proof */ 216 SCIP_Bool conf_preferbinary; /**< should binary conflicts be preferred? */ 217 SCIP_Bool conf_allowlocal; /**< should conflict constraints be generated that are only valid locally? */ 218 SCIP_Bool conf_settlelocal; /**< should conflict constraints be attached only to the local subtree where 219 * they can be useful? */ 220 SCIP_Bool conf_repropagate; /**< should earlier nodes be repropagated in order to replace branching 221 * decisions by deductions? */ 222 SCIP_Bool conf_keepreprop; /**< should constraints be kept for repropagation even if they are too long? */ 223 SCIP_Bool conf_separate; /**< should the conflict constraints be separated? */ 224 SCIP_Bool conf_dynamic; /**< should the conflict constraints be subject to aging? */ 225 SCIP_Bool conf_removable; /**< should the conflict's relaxations be subject to LP aging and cleanup? */ 226 SCIP_Real conf_depthscorefac; /**< score factor for depth level in bound relaxation heuristic */ 227 SCIP_Real conf_proofscorefac; /**< score factor for contribution to infeasibility proof in bound relaxation heuristic */ 228 SCIP_Real conf_uplockscorefac;/**< score factor for number of up locks in bound relaxation heuristic */ 229 SCIP_Real conf_downlockscorefac;/**< score factor for number of down locks in bound relaxation heuristic */ 230 SCIP_Real conf_scorefac; /**< factor to decrease importance of variables' earlier conflict scores */ 231 int conf_restartnum; /**< number of successful conflict analysis calls that trigger a restart 232 * (0: disable conflict restarts) */ 233 SCIP_Real conf_restartfac; /**< factor to increase restartnum with after each restart */ 234 SCIP_Bool conf_ignorerelaxedbd;/**< should relaxed bounds be ignored? */ 235 int conf_maxvarsdetectimpliedbounds;/**< maximal number of variables to try to detect global bound 236 * implications and shorten the whole conflict set (0: 237 * disabled ) 238 */ 239 SCIP_Bool conf_fullshortenconflict;/**< try to shorten the whole conflict set or terminate early 240 * (depending on the 'maxvarsdetectimpliedbounds' parameter) 241 */ 242 SCIP_Real conf_conflictweight;/**< the weight the VSIDS score is weight by updating the VSIDS for a 243 * variable if it is part of a conflict 244 */ 245 SCIP_Real conf_conflictgraphweight; /**< the weight the VSIDS score is weight by updating the VSIDS for a 246 * variable if it is part of a conflict graph 247 */ 248 SCIP_Real conf_weightsize; /**< weight of the size of a conflict used in score calculation */ 249 SCIP_Real conf_weightrepropdepth;/**< weight of the prepropagtion depth of a conflict used in score calculation */ 250 SCIP_Real conf_weightvaliddepth;/**< weight of the valid depth of a conflict used in score calculation */ 251 SCIP_Bool conf_sepaaltproofs; /**< separate valid inequalities from dualray proofs */ 252 SCIP_Real conf_minimprove; /**< minimal improvement of primal bound to remove conflicts depending on 253 * a previous incumbent. 254 */ 255 SCIP_Bool conf_uselocalrows; /**< use local rows to construct infeasibility proofs */ 256 257 /* constraint settings */ 258 int cons_agelimit; /**< maximum age an unnecessary constraint can reach before it is deleted 259 * (0: dynamic, -1: disable aging) */ 260 int cons_obsoleteage; /**< age of a constraint after which it is marked obsolete 261 * (0: dynamic, -1: disable obsoletion) */ 262 SCIP_Bool cons_disableenfops; /**< should enforcement of pseudo solution be disabled? */ 263 264 /* display settings */ 265 SCIP_VERBLEVEL disp_verblevel; /**< verbosity level of output */ 266 int disp_width; /**< maximal number of characters in a node information line */ 267 int disp_freq; /**< frequency for displaying node information lines */ 268 int disp_headerfreq; /**< frequency for displaying header lines (every n'th node information line) */ 269 SCIP_Bool disp_lpinfo; /**< should the LP solver display status messages? */ 270 SCIP_Bool disp_allviols; /**< display all violations of the best solution after the solving process finished? */ 271 SCIP_Bool disp_relevantstats; /**< should the relevant statistics be displayed at the end of solving? */ 272 273 /* heuristics settings */ 274 SCIP_Bool heur_useuctsubscip; /**< should setting of common subscip parameters include the activation of the UCT node selector? */ 275 276 /* history settings */ 277 SCIP_Bool history_valuebased; /**< should statistics be collected for variable domain value pairs? */ 278 SCIP_Bool history_allowmerge; /**< should variable histories be merged from sub-SCIPs whenever possible? */ 279 SCIP_Bool history_allowtransfer; /**< should variable histories be transferred to initialize SCIP copies? */ 280 281 /* limit settings */ 282 SCIP_Real limit_time; /**< maximal time in seconds to run */ 283 SCIP_Real limit_memory; /**< maximal memory usage in MB */ 284 SCIP_Real limit_gap; /**< solving stops, if the given gap is reached */ 285 SCIP_Real limit_absgap; /**< solving stops, if the absolute difference between primal and dual bound 286 * reaches this value */ 287 SCIP_Longint limit_nodes; /**< maximal number of nodes to process (-1: no limit) */ 288 SCIP_Longint limit_totalnodes; /**< maximal number of total nodes (incl. restarts) to process (-1: no limit) */ 289 SCIP_Longint limit_stallnodes; /**< solving stops, if the given number of nodes was processed since the 290 * last improvement of the primal solution value (-1: no limit) */ 291 int limit_solutions; /**< solving stops, if the given number of solutions were found (-1: no limit) */ 292 int limit_bestsol; /**< solving stops, if the given number of solution improvements were found 293 * (-1: no limit) */ 294 int limit_maxsol; /**< maximal number of solutions to store in the solution storage */ 295 int limit_maxorigsol; /**< maximal number of solutions candidates to store in the solution storage of the original problem */ 296 int limit_restarts; /**< solving stops, if the given number of restarts was triggered (-1: no limit) */ 297 int limit_autorestartnodes;/**< nodes to trigger automatic restart */ 298 299 SCIP_Bool istimelimitfinite; /**< is the time limit finite */ 300 301 /* LP settings */ 302 int lp_solvefreq; /**< frequency for solving LP at the nodes (-1: never; 0: only root LP) */ 303 SCIP_Longint lp_iterlim; /**< iteration limit for each single LP solve; -1: no limit */ 304 SCIP_Longint lp_rootiterlim; /**< iteration limit for initial root LP solve; -1: no limit */ 305 int lp_solvedepth; /**< maximal depth for solving LP at the nodes (-1: no depth limit) */ 306 char lp_initalgorithm; /**< LP algorithm for solving initial LP relaxations ('s'implex, 'b'arrier, 307 * barrier with 'c'rossover) */ 308 char lp_resolvealgorithm;/**< LP algorithm for resolving LP relaxations if a starting basis exists 309 * ('s'implex, 'b'arrier, barrier with 'c'rossover) */ 310 char lp_pricing; /**< LP pricing strategy ('a'uto, 'f'ull pricing, 's'teepest edge pricing, 311 * 'q'uickstart steepest edge pricing, 'd'evex pricing) */ 312 SCIP_Bool lp_clearinitialprobinglp;/**< should lp state be cleared at the end of probing mode when LP 313 * was initially unsolved, e.g., when called right after presolving? */ 314 SCIP_Bool lp_resolverestore; /**< should the LP be resolved to restore the state at start of diving (if 315 * FALSE we buffer the solution values)? */ 316 SCIP_Bool lp_freesolvalbuffers; /**< should the buffers for storing LP solution values during diving be 317 * freed at end of diving? */ 318 int lp_colagelimit; /**< maximum age a column can reach before it is deleted from the SCIP_LP 319 * (-1: don't delete columns due to aging) */ 320 int lp_rowagelimit; /**< maximum age a row can reach before it is deleted from the LP 321 * (-1: don't delete rows due to aging) */ 322 SCIP_Bool lp_cleanupcols; /**< should new non-basic columns be removed after LP solving? */ 323 SCIP_Bool lp_cleanupcolsroot; /**< should new non-basic columns be removed after root LP solving? */ 324 SCIP_Bool lp_cleanuprows; /**< should new basic rows be removed after LP solving? */ 325 SCIP_Bool lp_cleanuprowsroot; /**< should new basic rows be removed after root LP solving? */ 326 SCIP_Bool lp_checkstability; /**< should LP solver's return status be checked for stability? */ 327 SCIP_Real lp_conditionlimit; /**< maximum condition number of LP basis counted as stable (-1.0: no check) */ 328 SCIP_Real lp_markowitz; /**< minimal Markowitz threshold to control sparsity/stability in LU factorization */ 329 SCIP_Bool lp_checkprimfeas; /**< should LP solutions be checked for primal feasibility, resolving LP when numerical troubles occur? */ 330 SCIP_Bool lp_checkdualfeas; /**< should LP solutions be checked for dual feasibility, resolving LP when numerical troubles occur? */ 331 SCIP_Bool lp_checkfarkas; /**< should infeasibility proofs from the LP be checked? */ 332 int lp_fastmip; /**< which FASTMIP setting of LP solver should be used? 0: off, 1: medium, 2: full */ 333 int lp_scaling; /**< LP scaling (0: none, 1: normal, 2: aggressive) */ 334 SCIP_Bool lp_presolving; /**< should presolving of LP solver be used? */ 335 SCIP_Bool lp_lexdualalgo; /**< should the lexicographic dual algorithm be used? */ 336 SCIP_Bool lp_lexdualrootonly; /**< should the lexicographic dual algorithm be applied only at the root node */ 337 int lp_lexdualmaxrounds;/**< maximum number of rounds in the lexicographic dual algorithm */ 338 SCIP_Bool lp_lexdualbasic; /**< choose fractional basic variables in lexicographic dual algorithm */ 339 SCIP_Bool lp_lexdualstalling; /**< turn on the lex dual algorithm only when stalling? */ 340 int lp_disablecutoff; /**< disable the cutoff bound in the LP solver? (0: enabled, 1: disabled, 2: auto) */ 341 SCIP_Real lp_rowrepswitch; /**< simplex algorithm shall use row representation of the basis 342 * if number of rows divided by number of columns exceeds this value */ 343 int lp_threads; /**< number of threads used for solving the LP (0: automatic) */ 344 SCIP_Real lp_resolveiterfac; /**< factor of average LP iterations that is used as LP iteration limit 345 * for LP resolve (-1: unlimited) */ 346 int lp_resolveitermin; /**< minimum number of iterations that are allowed for LP resolve */ 347 int lp_solutionpolishing;/**< LP solution polishing method (0: disabled, 1: only root, 2: always, 3: auto) */ 348 int lp_refactorinterval;/**< LP refactorization interval (0: automatic) */ 349 SCIP_Bool lp_alwaysgetduals; /**< should the dual solution always be collected for LP solutions. */ 350 351 /* NLP settings */ 352 SCIP_Bool nlp_disable; /**< should the NLP be disabled even if a constraint handler enabled it? */ 353 char* nlp_solver; /**< name of NLP solver to use */ 354 355 /* memory settings */ 356 SCIP_Real mem_savefac; /**< fraction of maximal memory usage resulting in switch to memory saving mode */ 357 SCIP_Real mem_arraygrowfac; /**< memory growing factor for dynamically allocated arrays */ 358 SCIP_Real mem_treegrowfac; /**< memory growing factor for tree array */ 359 SCIP_Real mem_pathgrowfac; /**< memory growing factor for path array */ 360 int mem_arraygrowinit; /**< initial size of dynamically allocated arrays */ 361 int mem_treegrowinit; /**< initial size of tree array */ 362 int mem_pathgrowinit; /**< initial size of path array */ 363 364 /* miscellaneous settings */ 365 SCIP_Bool misc_catchctrlc; /**< should the CTRL-C interrupt be caught by SCIP? */ 366 SCIP_Bool misc_usevartable; /**< should a hashtable be used to map from variable names to variables? */ 367 SCIP_Bool misc_useconstable; /**< should a hashtable be used to map from constraint names to constraints? */ 368 SCIP_Bool misc_usesmalltables;/**< should smaller hashtables be used? yields better performance for small problems with about 100 variables */ 369 SCIP_Bool misc_exactsolve; /**< should the problem be solved exactly (with proven dual bounds)? */ 370 SCIP_Bool misc_resetstat; /**< should the statistics be reset if the transformed problem is freed 371 * otherwise the statistics get reset after original problem is freed (in 372 * case of bender decomposition this parameter should be set to FALSE and 373 * therefore can be used to collect statistics over all runs) */ 374 SCIP_Bool misc_improvingsols; /**< should only solutions be checked which improve the primal bound */ 375 SCIP_Bool misc_printreason; /**< should the reason be printed if a given start solution is infeasible? */ 376 SCIP_Bool misc_estimexternmem;/**< should the usage of external memory be estimated? */ 377 SCIP_Bool misc_transorigsols; /**< should SCIP try to transfer original solutions to the transformed space (after presolving)? */ 378 SCIP_Bool misc_transsolsorig; /**< should SCIP try to transfer transformed solutions to the original space (after solving)? */ 379 SCIP_Bool misc_calcintegral; /**< should SCIP calculate the primal dual integral value which may require 380 * a large number of additional clock calls (and decrease the performance)? */ 381 SCIP_Bool misc_finitesolstore;/**< should SCIP try to remove infinite fixings from solutions copied to the solution store? */ 382 SCIP_Bool misc_outputorigsol; /**< should the best solution be transformed to the orignal space and be output in command line run? */ 383 SCIP_Bool misc_allowstrongdualreds; /**< should strong dual reductions be allowed in propagation and presolving? */ 384 SCIP_Bool misc_allowweakdualreds; /**< should weak dual reductions be allowed in propagation and presolving? */ 385 SCIP_Real misc_referencevalue;/**< objective value for reference purposes */ 386 int misc_usesymmetry; /**< bitset describing used symmetry handling technique (0: off; 1: polyhedral (orbitopes and/or symresacks); 387 * 2: orbital fixing; 3: orbitopes and orbital fixing) */ 388 char* misc_debugsol; /**< path to a debug solution */ 389 SCIP_Bool misc_scaleobj; /**< should the objective function be scaled? */ 390 391 /* randomization parameters */ 392 int random_randomseedshift;/**< global shift of all random seeds in the plugins, this will have no impact on the permutation and LP seeds */ 393 int random_permutationseed;/**< seed value for permuting the problem after reading/transformation 394 * (0: no permutation) */ 395 int random_randomseed; /**< random seed for LP solver, e.g. for perturbations in the simplex (0: LP default) */ 396 SCIP_Bool random_permuteconss; /**< should order of constraints be permuted (depends on permutationseed)? */ 397 SCIP_Bool random_permutevars; /**< should order of variables be permuted (depends on permutationseed)? */ 398 399 /* node selection settings */ 400 char nodesel_childsel; /**< child selection rule ('d'own, 'u'p, 'p'seudo costs, 'i'nference, 'l'p value, 401 * 'r'oot LP value difference, 'h'brid inference/root LP value difference) */ 402 403 /* numerical settings */ 404 SCIP_Real num_infinity; /**< values larger than this are considered infinity */ 405 SCIP_Real num_epsilon; /**< absolute values smaller than this are considered zero */ 406 SCIP_Real num_sumepsilon; /**< absolute values of sums smaller than this are considered zero */ 407 SCIP_Real num_feastol; /**< feasibility tolerance for constraints */ 408 SCIP_Real num_checkfeastolfac;/**< factor to change the feasibility tolerance when testing the best 409 * solution for feasibility (after solving process) */ 410 SCIP_Real num_lpfeastolfactor;/**< factor w.r.t. primal feasibility tolerance that determines default (and maximal) primal feasibility tolerance of LP solver (user parameter, see also num_relaxfeastol) */ 411 SCIP_Real num_dualfeastol; /**< feasibility tolerance for reduced costs */ 412 SCIP_Real num_barrierconvtol; /**< convergence tolerance used in barrier algorithm */ 413 SCIP_Real num_boundstreps; /**< minimal improve for strengthening bounds */ 414 SCIP_Real num_pseudocosteps; /**< minimal variable distance value to use for pseudo cost updates */ 415 SCIP_Real num_pseudocostdelta;/**< minimal objective distance value to use for pseudo cost updates */ 416 SCIP_Real num_recompfac; /**< minimal decrease factor that causes the recomputation of a value 417 * (e.g., pseudo objective) instead of an update */ 418 SCIP_Real num_hugeval; /**< values larger than this are considered huge and should be handled 419 * separately (e.g., in activity computation) */ 420 SCIP_Real num_relaxfeastol; /**< primal feasibility tolerance for relaxations (set by core or plugins, not a parameter) */ 421 422 /* presolving settings */ 423 SCIP_Real presol_abortfac; /**< abort presolve, if l.t. this frac of the problem was changed in last round */ 424 int presol_maxrounds; /**< maximal number of presolving rounds (-1: unlimited) */ 425 int presol_maxrestarts; /**< maximal number of restarts (-1: unlimited) */ 426 SCIP_Real presol_clqtablefac; /**< limit on number of entries in clique table relative to number of problem nonzeros */ 427 SCIP_Real presol_restartfac; /**< fraction of integer variables that were fixed in the root node 428 * triggering a restart with preprocessing after root node evaluation */ 429 SCIP_Real presol_immrestartfac;/**< fraction of integer variables that were fixed in the root node triggering an 430 * immediate restart with preprocessing */ 431 SCIP_Real presol_subrestartfac;/**< fraction of integer variables that were globally fixed during the 432 * solving process triggering a restart with preprocessing */ 433 SCIP_Real presol_restartminred;/**< minimal fraction of integer variables removed after restart to allow for 434 * an additional restart */ 435 SCIP_Bool presol_donotmultaggr;/**< should multi-aggregation of variables be forbidden? */ 436 SCIP_Bool presol_donotaggr; /**< shouldaggregation of variables be forbidden? */ 437 438 /* pricing settings */ 439 SCIP_Real price_abortfac; /**< pricing is aborted, if fac * maxpricevars pricing candidates were found */ 440 int price_maxvars; /**< maximal number of variables priced in per pricing round */ 441 int price_maxvarsroot; /**< maximal number of priced variables at the root node */ 442 SCIP_Bool price_delvars; /**< should variables created at the current node be deleted when the node is solved 443 * in case they are not present in the LP anymore? */ 444 SCIP_Bool price_delvarsroot; /**< should variables created at the root node be deleted when the root is solved 445 * in case they are not present in the LP anymore? */ 446 447 /* Decomposition settings */ 448 SCIP_Bool decomp_benderslabels; /**< should the variables be labeled for the application of Benders' 449 * decomposition */ 450 SCIP_Bool decomp_applybenders; /**< if a decomposition exists, should Benders' decomposition be applied*/ 451 int decomp_maxgraphedge; /**< maximum number of edges in block graph computation, or -1 for no limit */ 452 453 /* Benders' decomposition settings */ 454 SCIP_Real benders_soltol; /**< the tolerance for checking optimality in Benders' decomposition */ 455 SCIP_Bool benders_cutlpsol; /**< should cuts be generated from the solution to the LP relaxation? */ 456 SCIP_Bool benders_copybenders;/**< should Benders' decomposition be copied for sub-SCIPs? */ 457 458 /* propagation settings */ 459 int prop_maxrounds; /**< maximal number of propagation rounds per node (-1: unlimited) */ 460 int prop_maxroundsroot; /**< maximal number of propagation rounds in the root node (-1: unlimited) */ 461 SCIP_Bool prop_abortoncutoff; /**< should propagation be aborted immediately? setting this to FALSE could 462 * help conflict analysis to produce more conflict constraints */ 463 464 /* reoptimization settings */ 465 SCIP_Real reopt_objsimsol; /**< similarity of two objective functions to reuse stored solutions. */ 466 SCIP_Real reopt_objsimrootlp; /**< similarity of two sequential objective function to disable solving the 467 * root LP. 468 */ 469 SCIP_Real reopt_objsimdelay; /**< minimum similarity for using reoptimization of the search tree. */ 470 char reopt_varorderinterdiction; /** use the 'd'efault or a 'r'andom variable order for interdiction 471 * branching when applying the reoptimization 472 */ 473 int reopt_forceheurrestart; /**< force a restart if the last n optimal solutions were found by 474 * heuristic reoptsols 475 */ 476 int reopt_maxcutage; /**< maximal age of cuts to use them in reoptimization */ 477 int reopt_maxdiffofnodes;/**< maximal number of bound changes between two stored nodes on one path */ 478 int reopt_maxsavednodes;/**< maximal number of saved nodes */ 479 int reopt_solvelp; /**< strategy for solving the LP at nodes from reoptimization */ 480 int reopt_solvelpdiff; /**< maximal number of bound changes at node to skip solving the LP */ 481 int reopt_savesols; /**< number of best solutions which should be saved for the following runs. 482 * (-1: save all) 483 */ 484 SCIP_Bool reopt_commontimelimit;/**< time limit over all reoptimization rounds? */ 485 SCIP_Bool reopt_enable; /**< enable reoptimization */ 486 SCIP_Bool reopt_reducetofrontier; /**< delete stored nodes which were not reoptimized */ 487 SCIP_Bool reopt_saveconsprop; /**< save constraint propagations */ 488 SCIP_Bool reopt_sbinit; /**< try to fix variables before reoptimizing by probing like strong 489 * branching 490 */ 491 SCIP_Bool reopt_shrinkinner; /**< replace branched inner nodes by their child nodes, if the number of 492 * bound changes is not to large 493 */ 494 SCIP_Bool reopt_sepaglbinfsubtrees;/**< save global constraints to separate infeasible subtrees */ 495 SCIP_Bool reopt_sepabestsol; /**< separate only the best solution, i.e., for constrained shortest path */ 496 SCIP_Bool reopt_storevarhistory;/**< use variable history of the previous solve if the objective function 497 * has changed only slightly 498 */ 499 SCIP_Bool reopt_usepscost; /**< reuse pseudo costs if the objective function changed only slightly */ 500 SCIP_Bool reopt_usecuts; /**< reoptimize cuts found at the root node */ 501 SCIP_Bool reopt_usesplitcons; /**< use constraints to reconstruct the subtree pruned be dual reduction 502 * when reactivating the node 503 */ 504 505 /* separation settings */ 506 SCIP_Real sepa_maxbounddist; /**< maximal relative distance from current node's dual bound to primal bound 507 * compared to best node's dual bound for applying separation 508 * (0.0: only on current best node, 1.0: on all nodes) */ 509 SCIP_Real sepa_maxlocalbounddist;/**< maximal relative distance from current node's dual bound to primal bound 510 * compared to best node's dual bound for applying local separation 511 * (0.0: only on current best node, 1.0: on all nodes) */ 512 SCIP_Real sepa_maxcoefratio; /**< maximal ratio between coefficients in strongcg, cmir, and flowcover cuts */ 513 SCIP_Real sepa_minefficacy; /**< minimal efficacy for a cut to enter the LP */ 514 SCIP_Real sepa_minefficacyroot; /**< minimal efficacy for a cut to enter the LP in the root node */ 515 SCIP_Real sepa_minortho; /**< minimal orthogonality for a cut to enter the LP */ 516 SCIP_Real sepa_minorthoroot; /**< minimal orthogonality for a cut to enter the LP in the root node */ 517 SCIP_Real sepa_efficacyfac; /**< factor to scale efficacy of cut in score calc. */ 518 SCIP_Real sepa_dircutoffdistfac;/**< factor to scale directed cutoff distance of cut in score calc. */ 519 SCIP_Real sepa_objparalfac; /**< factor to scale objective parallelism of cut in score calc. */ 520 SCIP_Real sepa_intsupportfac; /**< factor to scale integral support of cut in score calculation */ 521 SCIP_Real sepa_minactivityquot; /**< minimum cut activity quotient to convert cuts into constraints 522 * during a restart (0.0: all cuts are converted) */ 523 char sepa_orthofunc; /**< function used for calc. scalar prod. in orthogonality test ('e'uclidean, 'd'iscrete) */ 524 char sepa_efficacynorm; /**< row norm to use for efficacy calculation ('e'uclidean, 'm'aximum, 's'um, 525 * 'd'iscrete) */ 526 char sepa_cutselrestart; /**< cut selection during restart ('a'ge, activity 'q'uotient) */ 527 char sepa_cutselsubscip; /**< cut selection for sub SCIPs ('a'ge, activity 'q'uotient) */ 528 int sepa_maxruns; /**< maximal number of runs for which separation is enabled (-1: unlimited) */ 529 int sepa_maxrounds; /**< maximal number of separation rounds per node (-1: unlimited) */ 530 int sepa_maxroundsroot; /**< maximal number of separation rounds in the root node (-1: unlimited) */ 531 int sepa_maxroundsrootsubrun; /**< maximal number of separation rounds in the root node of a subsequent run (-1: unlimited) */ 532 int sepa_maxaddrounds; /**< maximal additional number of separation rounds in subsequent price-and-cut 533 * loops (-1: no additional restriction) */ 534 int sepa_maxstallrounds;/**< maximal number of consecutive separation rounds without objective 535 * or integrality improvement (-1: no additional restriction) */ 536 int sepa_maxstallroundsroot;/**< maximal number of consecutive separation rounds without objective 537 * or integrality improvement (-1: no additional restriction) */ 538 int sepa_maxcuts; /**< maximal number of cuts separated per separation round */ 539 int sepa_maxcutsroot; /**< maximal number of separated cuts at the root node */ 540 int sepa_cutagelimit; /**< maximum age a cut can reach before it is deleted from the global cut pool */ 541 int sepa_poolfreq; /**< separation frequency for the global cut pool */ 542 543 /* parallel settings */ 544 int parallel_mode; /**< the mode for the parallel implementation. 0: opportunistic or 545 * 1: deterministic */ 546 int parallel_minnthreads;/**< the minimum number of threads used for parallel code */ 547 int parallel_maxnthreads;/**< the maximum number of threads used for parallel code */ 548 549 /* concurrent solver settings */ 550 SCIP_Bool concurrent_changeseeds; /**< change the seeds in the different solvers? */ 551 SCIP_Bool concurrent_changechildsel; /**< change the child selection rule in different solvers? */ 552 SCIP_Bool concurrent_commvarbnds; /**< should the concurrent solvers communicate global variable bound changes? */ 553 SCIP_Bool concurrent_presolvebefore; /**< should the problem be presolved before it is copied to the concurrent solvers? */ 554 int concurrent_initseed; /**< the seed for computing the concurrent solver seeds */ 555 SCIP_Real concurrent_freqinit; /**< initial frequency of synchronization */ 556 SCIP_Real concurrent_freqmax; /**< maximal frequency of synchronization */ 557 SCIP_Real concurrent_freqfactor; /**< factor by which the frequency of synchronization changes */ 558 SCIP_Real concurrent_targetprogress; /**< when adapting the synchronization frequency this value is the targeted 559 * relative difference by which the absolute gap decreases per synchronization */ 560 int concurrent_maxnsols; /**< maximum number of solutions that will get stored in one synchronization */ 561 int concurrent_nbestsols; /**< number of best solutions that should be considered for synchronization */ 562 int concurrent_maxnsyncdelay; /**< max number of synchronizations before data is used */ 563 SCIP_Real concurrent_minsyncdelay; /**< min offset before synchronization data is used */ 564 char* concurrent_paramsetprefix; /**< path prefix for parameter setting files of concurrent solver scip-custom */ 565 566 /* timing settings */ 567 SCIP_CLOCKTYPE time_clocktype; /**< default clock type to use */ 568 SCIP_Bool time_enabled; /**< is timing enabled? */ 569 SCIP_Bool time_reading; /**< belongs reading time to solving time? */ 570 SCIP_Bool time_rareclockcheck;/**< should clock checks of solving time be performed less frequently (might exceed time limit slightly) */ 571 SCIP_Bool time_statistictiming; /**< should timing for statistic output be enabled? */ 572 573 /* tree compression parameters (for reoptimization) */ 574 SCIP_Bool compr_enable; /**< should automatic tree compression after presolving be enabled? (only for reoptimization) */ 575 SCIP_Real compr_time; /**< maximum time to run tree compression heuristics */ 576 577 /* visualization settings */ 578 char* visual_vbcfilename; /**< name of the VBC tool output file, or - if no VBC output should be created */ 579 char* visual_bakfilename; /**< name of the BAK tool output file, or - if no BAK output should be created */ 580 SCIP_Bool visual_realtime; /**< should the real solving time be used instead of time step counter in visualization? */ 581 SCIP_Bool visual_dispsols; /**< should the node where solutions are found be visualized? */ 582 SCIP_Bool visual_displb; /**< should lower bound information be visualized? */ 583 SCIP_Bool visual_objextern; /**< should be output the external value of the objective? */ 584 585 /* Reading */ 586 SCIP_Bool read_initialconss; /**< should model constraints be marked as initial? */ 587 SCIP_Bool read_dynamicconss; /**< should model constraints be subject to aging? */ 588 SCIP_Bool read_dynamiccols; /**< should columns be added and removed dynamically to the LP? */ 589 SCIP_Bool read_dynamicrows; /**< should rows be added and removed dynamically to the LP? */ 590 591 /* Writing */ 592 SCIP_Bool write_allconss; /**< should all constraints be written (including the redundant constraints)? */ 593 SCIP_Bool write_printzeros; /**< should variables set to zero be printed? */ 594 int write_genoffset; /**< when writing the problem with generic names, we start with index 595 * 0; using this parameter we can change the starting index to be 596 * different */ 597 }; 598 599 #ifdef __cplusplus 600 } 601 #endif 602 603 #endif 604