Scippy

SCIP

Solving Constraint Integer Programs

struct_set.h
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright (C) 2002-2020 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
int nconcsolvertypes
Definition: struct_set.h:132
char branch_lpgainnorm
Definition: struct_set.h:178
char sepa_orthofunc
Definition: struct_set.h:523
int ndisps
Definition: struct_set.h:124
int decomp_maxgraphedge
Definition: struct_set.h:451
SCIP_Real num_sumepsilon
Definition: struct_set.h:406
SCIP_Real num_dualfeastol
Definition: struct_set.h:411
SCIP_Real sepa_minefficacyroot
Definition: struct_set.h:514
SCIP_Real num_infinity
Definition: struct_set.h:404
SCIP_Bool benders_copybenders
Definition: struct_set.h:456
SCIP_Bool heur_useuctsubscip
Definition: struct_set.h:274
int lp_solvefreq
Definition: struct_set.h:302
SCIP_READER ** readers
Definition: struct_set.h:68
int mem_treegrowinit
Definition: struct_set.h:361
SCIP_Bool visual_objextern
Definition: struct_set.h:583
SCIP_Bool sepassorted
Definition: struct_set.h:151
int pricerssize
Definition: struct_set.h:101
int nnodesels
Definition: struct_set.h:120
SCIP_Bool conf_keepreprop
Definition: struct_set.h:222
SCIP_Bool misc_estimexternmem
Definition: struct_set.h:376
SCIP_Bool compr_enable
Definition: struct_set.h:574
int sepa_cutagelimit
Definition: struct_set.h:540
int random_permutationseed
Definition: struct_set.h:393
SCIP_Bool lp_lexdualrootonly
Definition: struct_set.h:336
int conf_interconss
Definition: struct_set.h:196
SCIP_CONFLICTHDLR ** conflicthdlrs
Definition: struct_set.h:74
int write_genoffset
Definition: struct_set.h:594
SCIP_BANDITVTABLE ** banditvtables
Definition: struct_set.h:94
SCIP_Bool reopt_usepscost
Definition: struct_set.h:499
SCIP_CONCSOLVER ** concsolvers
Definition: struct_set.h:91
SCIP_Bool nlpissorted
Definition: struct_set.h:163
SCIP_Bool price_delvars
Definition: struct_set.h:442
SCIP_Bool conf_dynamic
Definition: struct_set.h:224
int reopt_maxdiffofnodes
Definition: struct_set.h:477
char * visual_vbcfilename
Definition: struct_set.h:578
SCIP_Bool conf_repropagate
Definition: struct_set.h:220
int reopt_maxcutage
Definition: struct_set.h:476
SCIP_Real conf_weightvaliddepth
Definition: struct_set.h:250
SCIP_Bool misc_finitesolstore
Definition: struct_set.h:381
SCIP_Real num_pseudocostdelta
Definition: struct_set.h:415
SCIP_Bool concurrent_commvarbnds
Definition: struct_set.h:552
SCIP_NODESEL ** nodesels
Definition: struct_set.h:83
int presol_maxrounds
Definition: struct_set.h:424
SCIP_Real sepa_efficacyfac
Definition: struct_set.h:517
SCIP_Bool conf_usesb
Definition: struct_set.h:212
int concurrent_initseed
Definition: struct_set.h:554
SCIP_Bool propsnamesorted
Definition: struct_set.h:155
SCIP_Bool conf_usepseudo
Definition: struct_set.h:214
SCIP_Bool conf_useprop
Definition: struct_set.h:205
SCIP_Bool concurrent_changeseeds
Definition: struct_set.h:550
char branch_scorefunc
Definition: struct_set.h:170
int nprops
Definition: struct_set.h:112
int sepa_maxroundsroot
Definition: struct_set.h:530
SCIP_Bool presol_donotaggr
Definition: struct_set.h:436
char lp_resolvealgorithm
Definition: struct_set.h:308
int nconcsolvers
Definition: struct_set.h:134
SCIP_Bool pricersnamesorted
Definition: struct_set.h:144
SCIP_Bool presolsnamesorted
Definition: struct_set.h:148
int reopt_maxsavednodes
Definition: struct_set.h:478
int sepa_maxcutsroot
Definition: struct_set.h:539
int prop_maxroundsroot
Definition: struct_set.h:460
SCIP_Bool propssorted
Definition: struct_set.h:153
SCIP_Real concurrent_minsyncdelay
Definition: struct_set.h:563
SCIP_Bool time_reading
Definition: struct_set.h:569
char * visual_bakfilename
Definition: struct_set.h:579
SCIP_Bool history_allowmerge
Definition: struct_set.h:278
int conf_maxlploops
Definition: struct_set.h:190
SCIP_Real conf_restartfac
Definition: struct_set.h:233
SCIP_Bool limitchanged
Definition: struct_set.h:166
SCIP_Real benders_soltol
Definition: struct_set.h:454
SCIP_Bool time_statistictiming
Definition: struct_set.h:571
int mem_pathgrowinit
Definition: struct_set.h:362
SCIP_Bool tablessorted
Definition: struct_set.h:162
enum SCIP_ClockType SCIP_CLOCKTYPE
Definition: type_clock.h:38
SCIP_Bool price_delvarsroot
Definition: struct_set.h:444
SCIP_SEPA ** sepas
Definition: struct_set.h:77
SCIP_Bool branch_delaypscost
Definition: struct_set.h:179
SCIP_Bool misc_allowweakdualreds
Definition: struct_set.h:384
SCIP_Bool misc_scaleobj
Definition: struct_set.h:389
char sepa_cutselrestart
Definition: struct_set.h:526
SCIP_Real lp_rowrepswitch
Definition: struct_set.h:341
int lp_resolveitermin
Definition: struct_set.h:346
int limit_maxorigsol
Definition: struct_set.h:295
SCIP_Bool conf_fullshortenconflict
Definition: struct_set.h:239
BMS_BUFMEM * buffer
Definition: struct_set.h:66
int parallel_maxnthreads
Definition: struct_set.h:547
int nodeselssize
Definition: struct_set.h:121
SCIP_STAGE stage
Definition: struct_set.h:63
SCIP_Real sepa_minortho
Definition: struct_set.h:515
SCIP_Real misc_referencevalue
Definition: struct_set.h:385
SCIP_Real sepa_minefficacy
Definition: struct_set.h:513
SCIP_Real branch_clamp
Definition: struct_set.h:175
type definitions for global SCIP settings
SCIP_Bool branch_checksbsol
Definition: struct_set.h:183
SCIP_Bool pricerssorted
Definition: struct_set.h:143
SCIP_Bool branch_divingpscost
Definition: struct_set.h:180
SCIP_Bool conf_removable
Definition: struct_set.h:225
enum SCIP_VerbLevel SCIP_VERBLEVEL
Definition: type_message.h:48
int disp_freq
Definition: struct_set.h:267
SCIP_Bool presol_donotmultaggr
Definition: struct_set.h:435
SCIP_Bool lp_presolving
Definition: struct_set.h:334
SCIP_Real concurrent_freqfactor
Definition: struct_set.h:557
SCIP_Longint lp_rootiterlim
Definition: struct_set.h:304
SCIP_Real mem_arraygrowfac
Definition: struct_set.h:357
int nheurs
Definition: struct_set.h:114
int heurssize
Definition: struct_set.h:115
SCIP_Bool lp_cleanuprowsroot
Definition: struct_set.h:325
int limit_maxsol
Definition: struct_set.h:294
type definitions for presolvers
message output methods
SCIP_Bool lp_lexdualstalling
Definition: struct_set.h:339
SCIP_Bool conf_enable
Definition: struct_set.h:203
SCIP_PRESOL ** presols
Definition: struct_set.h:75
int ndialogs
Definition: struct_set.h:128
SCIP_Bool lp_cleanuprows
Definition: struct_set.h:324
SCIP_RELAX ** relaxs
Definition: struct_set.h:76
SCIP_CONSHDLR ** conshdlrs_include
Definition: struct_set.h:73
char lp_initalgorithm
Definition: struct_set.h:306
SCIP_Real mem_pathgrowfac
Definition: struct_set.h:359
int nactivebenders
Definition: struct_set.h:137
SCIP_Bool branch_forceall
Definition: struct_set.h:181
SCIP_Bool misc_improvingsols
Definition: struct_set.h:374
SCIP_Bool disp_allviols
Definition: struct_set.h:270
SCIP_Bool visual_dispsols
Definition: struct_set.h:581
int readerssize
Definition: struct_set.h:98
SCIP_Bool cons_disableenfops
Definition: struct_set.h:262
SCIP_Real lp_resolveiterfac
Definition: struct_set.h:344
int nbranchrules
Definition: struct_set.h:122
type definitions for branching rules
SCIP_Real limit_absgap
Definition: struct_set.h:285
SCIP_Bool conf_preferbinary
Definition: struct_set.h:216
SCIP_Bool sepasnamesorted
Definition: struct_set.h:152
int tablessize
Definition: struct_set.h:127
SCIP_Bool comprssorted
Definition: struct_set.h:158
SCIP_Real lp_markowitz
Definition: struct_set.h:328
SCIP_Bool heursnamesorted
Definition: struct_set.h:157
int dispssize
Definition: struct_set.h:125
SCIP_Bool reopt_enable
Definition: struct_set.h:485
SCIP * scip
Definition: struct_set.h:64
char conf_useboundlp
Definition: struct_set.h:209
int conf_maxvarsdetectimpliedbounds
Definition: struct_set.h:235
int lp_lexdualmaxrounds
Definition: struct_set.h:337
SCIP_Bool reopt_usecuts
Definition: struct_set.h:500
int neventhdlrs
Definition: struct_set.h:118
int concsolverssize
Definition: struct_set.h:135
SCIP_Bool read_dynamicconss
Definition: struct_set.h:587
SCIP_Bool reopt_storevarhistory
Definition: struct_set.h:496
SCIP_Bool disp_lpinfo
Definition: struct_set.h:269
SCIP_NLPI ** nlpis
Definition: struct_set.h:89
int sepa_maxcuts
Definition: struct_set.h:538
SCIP_Real sepa_maxbounddist
Definition: struct_set.h:506
SCIP_Bool lp_lexdualbasic
Definition: struct_set.h:338
SCIP_Real conf_downlockscorefac
Definition: struct_set.h:229
int lp_solvedepth
Definition: struct_set.h:305
struct SCIP_DebugSolData SCIP_DEBUGSOLDATA
Definition: debug.h:50
SCIP_Bool lp_freesolvalbuffers
Definition: struct_set.h:316
char ** extcodedescs
Definition: struct_set.h:96
int presolssize
Definition: struct_set.h:107
SCIP_Bool decomp_benderslabels
Definition: struct_set.h:448
SCIP_Bool misc_allowstrongdualreds
Definition: struct_set.h:383
SCIP_Real num_recompfac
Definition: struct_set.h:416
SCIP_Real num_relaxfeastol
Definition: struct_set.h:420
SCIP_Real num_checkfeastolfac
Definition: struct_set.h:408
SCIP_Real branch_midpullreldomtrig
Definition: struct_set.h:177
SCIP_Bool write_allconss
Definition: struct_set.h:592
SCIP_Bool history_valuebased
Definition: struct_set.h:277
SCIP_CONSHDLR ** conshdlrs_enfo
Definition: struct_set.h:72
type definitions for variable pricers
SCIP_Real conf_maxvarsfac
Definition: struct_set.h:188
SCIP_Real concurrent_freqmax
Definition: struct_set.h:556
SCIP_Bool subscipsoff
Definition: struct_set.h:167
int benderssize
Definition: struct_set.h:138
SCIP_Bool presolssorted
Definition: struct_set.h:147
char lp_pricing
Definition: struct_set.h:310
type definitions for primal heuristics
SCIP_Bool misc_resetstat
Definition: struct_set.h:370
int sepa_maxruns
Definition: struct_set.h:528
SCIP_Bool misc_printreason
Definition: struct_set.h:375
int concsolvertypessize
Definition: struct_set.h:133
SCIP_Bool propspresolsorted
Definition: struct_set.h:154
SCIP_Bool prop_abortoncutoff
Definition: struct_set.h:461
SCIP_Real presol_subrestartfac
Definition: struct_set.h:431
int lp_disablecutoff
Definition: struct_set.h:340
int concurrent_nbestsols
Definition: struct_set.h:561
SCIP_Bool random_permutevars
Definition: struct_set.h:397
type definitions for SCIP&#39;s main datastructure
SCIP_Bool lp_checkfarkas
Definition: struct_set.h:331
char sepa_cutselsubscip
Definition: struct_set.h:527
SCIP_Real conf_uplockscorefac
Definition: struct_set.h:228
int limit_solutions
Definition: struct_set.h:291
int nbenders
Definition: struct_set.h:136
SCIP_CONSHDLR ** conshdlrs
Definition: struct_set.h:70
int cons_agelimit
Definition: struct_set.h:258
char branch_firstsbchild
Definition: struct_set.h:171
int conf_restartnum
Definition: struct_set.h:231
SCIP_Real sepa_maxcoefratio
Definition: struct_set.h:512
SCIP_Real conf_depthscorefac
Definition: struct_set.h:226
type definitions for bandit selection algorithms
int nrelaxs
Definition: struct_set.h:108
SCIP_Bool misc_outputorigsol
Definition: struct_set.h:382
SCIP_Real lp_conditionlimit
Definition: struct_set.h:327
int concurrent_maxnsyncdelay
Definition: struct_set.h:562
SCIP_Bool read_initialconss
Definition: struct_set.h:586
SCIP_CONCSOLVERTYPE ** concsolvertypes
Definition: struct_set.h:90
int conflicthdlrssize
Definition: struct_set.h:105
SCIP_Bool time_rareclockcheck
Definition: struct_set.h:570
SCIP_Bool conf_separate
Definition: struct_set.h:223
SCIP_Bool conflicthdlrsnamesorted
Definition: struct_set.h:146
SCIP_Bool lp_cleanupcols
Definition: struct_set.h:322
SCIP_Bool lp_checkprimfeas
Definition: struct_set.h:329
SCIP_Real conf_weightsize
Definition: struct_set.h:248
int sepassize
Definition: struct_set.h:111
int branchrulessize
Definition: struct_set.h:123
SCIP_Bool relaxsnamesorted
Definition: struct_set.h:150
SCIP_Bool branchrulesnamesorted
Definition: struct_set.h:161
type definitions for relaxators
SCIP_Bool conf_settlelocal
Definition: struct_set.h:218
int sepa_maxroundsrootsubrun
Definition: struct_set.h:531
int nsepas
Definition: struct_set.h:110
int lp_scaling
Definition: struct_set.h:333
SCIP_Real num_hugeval
Definition: struct_set.h:418
SCIP_Real conf_conflictgraphweight
Definition: struct_set.h:245
SCIP_Real conf_scorefac
Definition: struct_set.h:230
type definitions for conflict analysis
SCIP_DEBUGSOLDATA * debugsoldata
Definition: struct_set.h:93
SCIP_Bool benderssorted
Definition: struct_set.h:164
SCIP_Bool reopt_shrinkinner
Definition: struct_set.h:491
type definitions for managing events
SCIP_Real reopt_objsimdelay
Definition: struct_set.h:469
SCIP_Longint limit_stallnodes
Definition: struct_set.h:289
int nbanditvtables
Definition: struct_set.h:141
SCIP_BRANCHRULE ** branchrules
Definition: struct_set.h:85
SCIP_Bool benders_cutlpsol
Definition: struct_set.h:455
SCIP_Real compr_time
Definition: struct_set.h:575
int comprssize
Definition: struct_set.h:117
int conf_lpiterations
Definition: struct_set.h:192
int lp_fastmip
Definition: struct_set.h:332
SCIP_Longint limit_nodes
Definition: struct_set.h:287
SCIP_Bool reopt_sepabestsol
Definition: struct_set.h:495
int random_randomseedshift
Definition: struct_set.h:392
#define SCIP_Bool
Definition: def.h:70
int banditvtablessize
Definition: struct_set.h:142
SCIP_Bool visual_displb
Definition: struct_set.h:582
char reopt_varorderinterdiction
Definition: struct_set.h:470
SCIP_PARAMSET * paramset
Definition: struct_set.h:65
type definitions for input file readers
int misc_usesymmetry
Definition: struct_set.h:386
int dialogssize
Definition: struct_set.h:129
SCIP_Bool read_dynamiccols
Definition: struct_set.h:588
SCIP_Bool lp_checkdualfeas
Definition: struct_set.h:330
int mem_arraygrowinit
Definition: struct_set.h:360
SCIP_Bool reopt_usesplitcons
Definition: struct_set.h:501
SCIP_HEUR ** heurs
Definition: struct_set.h:80
SCIP_Bool branch_roundsbsol
Definition: struct_set.h:184
SCIP_Real num_boundstreps
Definition: struct_set.h:413
int nreaders
Definition: struct_set.h:97
int lp_colagelimit
Definition: struct_set.h:318
int relaxssize
Definition: struct_set.h:109
methods for debugging
int sepa_maxstallrounds
Definition: struct_set.h:534
int conf_minmaxvars
Definition: struct_set.h:189
int prop_maxrounds
Definition: struct_set.h:459
SCIP_BENDERS ** benders
Definition: struct_set.h:92
int parallel_minnthreads
Definition: struct_set.h:546
SCIP_Real concurrent_freqinit
Definition: struct_set.h:555
SCIP_Real sepa_intsupportfac
Definition: struct_set.h:520
int parallel_mode
Definition: struct_set.h:544
SCIP_Bool conf_cleanbnddepend
Definition: struct_set.h:204
SCIP_Real limit_memory
Definition: struct_set.h:283
SCIP_Real num_pseudocosteps
Definition: struct_set.h:414
SCIP_NODESEL * nodesel
Definition: struct_set.h:84
int lp_solutionpolishing
Definition: struct_set.h:347
SCIP_Real num_lpfeastolfactor
Definition: struct_set.h:410
SCIP_Bool history_allowtransfer
Definition: struct_set.h:279
int presol_maxrestarts
Definition: struct_set.h:425
int ntables
Definition: struct_set.h:126
SCIP_DIALOG ** dialogs
Definition: struct_set.h:88
SCIP_Bool conf_sepaaltproofs
Definition: struct_set.h:251
SCIP_Real limit_time
Definition: struct_set.h:282
char sepa_efficacynorm
Definition: struct_set.h:524
int reopt_solvelpdiff
Definition: struct_set.h:480
char * concurrent_paramsetprefix
Definition: struct_set.h:564
int nconflicthdlrs
Definition: struct_set.h:104
SCIP_Bool lp_alwaysgetduals
Definition: struct_set.h:349
int reopt_savesols
Definition: struct_set.h:481
type definitions for Benders&#39; decomposition methods
type definitions for clocks and timing issues
SCIP_Real concurrent_targetprogress
Definition: struct_set.h:558
int sepa_poolfreq
Definition: struct_set.h:541
SCIP_Bool branch_sumadjustscore
Definition: struct_set.h:185
SCIP_Real num_epsilon
Definition: struct_set.h:405
SCIP_TABLE ** tables
Definition: struct_set.h:87
int lp_threads
Definition: struct_set.h:343
SCIP_Real mem_savefac
Definition: struct_set.h:356
SCIP_Bool reopt_sepaglbinfsubtrees
Definition: struct_set.h:494
SCIP_Bool branchrulessorted
Definition: struct_set.h:160
SCIP_COMPR ** comprs
Definition: struct_set.h:81
type definitions for propagators
SCIP_Bool lp_resolverestore
Definition: struct_set.h:314
char * misc_debugsol
Definition: struct_set.h:388
int limit_bestsol
Definition: struct_set.h:292
SCIP_Bool misc_exactsolve
Definition: struct_set.h:369
int price_maxvars
Definition: struct_set.h:440
int cons_obsoleteage
Definition: struct_set.h:260
int npricers
Definition: struct_set.h:99
int propssize
Definition: struct_set.h:113
SCIP_Bool disp_relevantstats
Definition: struct_set.h:271
SCIP_Real sepa_minorthoroot
Definition: struct_set.h:516
int lp_refactorinterval
Definition: struct_set.h:348
SCIP_Bool misc_usevartable
Definition: struct_set.h:366
char ** extcodenames
Definition: struct_set.h:95
int concurrent_maxnsols
Definition: struct_set.h:560
SCIP_Real price_abortfac
Definition: struct_set.h:439
SCIP_Bool misc_catchctrlc
Definition: struct_set.h:365
SCIP_Real conf_minimprove
Definition: struct_set.h:252
int extcodessize
Definition: struct_set.h:140
SCIP_Bool misc_useconstable
Definition: struct_set.h:367
type definitions for tree compression
SCIP_VERBLEVEL disp_verblevel
Definition: struct_set.h:265
int nactivepricers
Definition: struct_set.h:100
SCIP_Bool misc_usesmalltables
Definition: struct_set.h:368
SCIP_Bool write_printzeros
Definition: struct_set.h:593
int lp_rowagelimit
Definition: struct_set.h:320
SCIP_Real sepa_objparalfac
Definition: struct_set.h:519
int sepa_maxrounds
Definition: struct_set.h:529
SCIP_Bool reopt_saveconsprop
Definition: struct_set.h:487
SCIP_Real branch_midpull
Definition: struct_set.h:176
SCIP_Real reopt_objsimrootlp
Definition: struct_set.h:466
type definitions for separators
int conf_maxstoresize
Definition: struct_set.h:200
SCIP_Real sepa_dircutoffdistfac
Definition: struct_set.h:518
SCIP_Real num_feastol
Definition: struct_set.h:407
SCIP_Bool branch_preferbinary
Definition: struct_set.h:174
SCIP_Bool misc_transsolsorig
Definition: struct_set.h:378
SCIP_PROP ** props
Definition: struct_set.h:78
SCIP_Bool conf_ignorerelaxedbd
Definition: struct_set.h:234
SCIP_Bool read_dynamicrows
Definition: struct_set.h:589
SCIP_CLOCKTYPE time_clocktype
Definition: struct_set.h:567
SCIP_Bool reopt_reducetofrontier
Definition: struct_set.h:486
SCIP_Real presol_restartminred
Definition: struct_set.h:433
SCIP_Bool conf_allowlocal
Definition: struct_set.h:217
SCIP_Bool conf_uselocalrows
Definition: struct_set.h:255
int disp_headerfreq
Definition: struct_set.h:268
int ncomprs
Definition: struct_set.h:116
int random_randomseed
Definition: struct_set.h:395
SCIP_Real sepa_minactivityquot
Definition: struct_set.h:521
type definitions for handling parameter settings
SCIP_Bool misc_transorigsols
Definition: struct_set.h:377
#define SCIP_Real
Definition: def.h:163
type definitions for user interface dialog
SCIP_PRICER ** pricers
Definition: struct_set.h:69
enum SCIP_Stage SCIP_STAGE
Definition: type_set.h:50
SCIP_Real sepa_maxlocalbounddist
Definition: struct_set.h:509
int conf_maxconss
Definition: struct_set.h:198
SCIP_Bool reopt_commontimelimit
Definition: struct_set.h:484
SCIP_Real conf_weightrepropdepth
Definition: struct_set.h:249
SCIP_Bool lp_cleanupcolsroot
Definition: struct_set.h:323
SCIP_CONSHDLR ** conshdlrs_sepa
Definition: struct_set.h:71
SCIP_Bool random_permuteconss
Definition: struct_set.h:396
SCIP_Real conf_proofscorefac
Definition: struct_set.h:227
int nnlpis
Definition: struct_set.h:130
int nextcodes
Definition: struct_set.h:139
SCIP_Bool conf_prefinfproof
Definition: struct_set.h:215
SCIP_Real limit_gap
Definition: struct_set.h:284
#define SCIP_Longint
Definition: def.h:148
SCIP_Bool heurssorted
Definition: struct_set.h:156
char nodesel_childsel
Definition: struct_set.h:400
int eventhdlrssize
Definition: struct_set.h:119
int limit_restarts
Definition: struct_set.h:296
char * nlp_solver
Definition: struct_set.h:353
SCIP_Longint lp_iterlim
Definition: struct_set.h:303
SCIP_Real presol_immrestartfac
Definition: struct_set.h:429
int reopt_forceheurrestart
Definition: struct_set.h:473
SCIP_Bool lp_clearinitialprobinglp
Definition: struct_set.h:312
int conshdlrssize
Definition: struct_set.h:103
SCIP_Real num_barrierconvtol
Definition: struct_set.h:412
SCIP_Bool lp_lexdualalgo
Definition: struct_set.h:335
SCIP_Bool istimelimitfinite
Definition: struct_set.h:299
SCIP_Real presol_restartfac
Definition: struct_set.h:427
SCIP_Bool decomp_applybenders
Definition: struct_set.h:450
int sepa_maxaddrounds
Definition: struct_set.h:532
int nconshdlrs
Definition: struct_set.h:102
SCIP_Bool concurrent_presolvebefore
Definition: struct_set.h:553
SCIP_Bool lp_checkstability
Definition: struct_set.h:326
SCIP_Longint limit_totalnodes
Definition: struct_set.h:288
SCIP_Bool concurrent_changechildsel
Definition: struct_set.h:551
int sepa_maxstallroundsroot
Definition: struct_set.h:536
SCIP_Bool conflicthdlrssorted
Definition: struct_set.h:145
common defines and data types used in all packages of SCIP
BMS_BUFMEM * cleanbuffer
Definition: struct_set.h:67
SCIP_Bool misc_calcintegral
Definition: struct_set.h:379
SCIP_Real conf_conflictweight
Definition: struct_set.h:242
SCIP_Real mem_treegrowfac
Definition: struct_set.h:358
SCIP_Real reopt_objsimsol
Definition: struct_set.h:465
type definitions for node selectors
SCIP_DISP ** disps
Definition: struct_set.h:86
SCIP_Bool time_enabled
Definition: struct_set.h:568
SCIP_Bool bendersnamesorted
Definition: struct_set.h:165
int npresols
Definition: struct_set.h:106
SCIP_Bool nlp_disable
Definition: struct_set.h:352
int disp_width
Definition: struct_set.h:266
SCIP_Real presol_clqtablefac
Definition: struct_set.h:426
SCIP_Bool comprsnamesorted
Definition: struct_set.h:159
SCIP_Real presol_abortfac
Definition: struct_set.h:423
int conf_reconvlevels
Definition: struct_set.h:201
int limit_autorestartnodes
Definition: struct_set.h:297
char conf_useinflp
Definition: struct_set.h:206
int nlpissize
Definition: struct_set.h:131
type definitions for displaying statistics tables
SCIP_Bool reopt_sbinit
Definition: struct_set.h:488
SCIP_EVENTHDLR ** eventhdlrs
Definition: struct_set.h:82
SCIP_Real branch_scorefac
Definition: struct_set.h:172
type definitions for constraints and constraint handlers
SCIP_PROP ** props_presol
Definition: struct_set.h:79
SCIP_Bool relaxssorted
Definition: struct_set.h:149
type definitions for specific NLP solver interfaces
int price_maxvarsroot
Definition: struct_set.h:441
int reopt_solvelp
Definition: struct_set.h:479
type definitions for concurrent solvers
SCIP_Bool visual_realtime
Definition: struct_set.h:580
type definitions for displaying runtime statistics
int conf_fuiplevels
Definition: struct_set.h:194