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