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-2014 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 email to scip@zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file struct_set.h
17  * @brief datastructures for global SCIP settings
18  * @author Tobias Achterberg
19  */
20 
21 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
22 
23 #ifndef __SCIP_STRUCT_SET_H__
24 #define __SCIP_STRUCT_SET_H__
25 
26 
27 #include "scip/def.h"
28 #include "scip/message.h"
29 #include "scip/type_set.h"
30 #include "scip/type_buffer.h"
31 #include "scip/type_clock.h"
32 #include "scip/type_paramset.h"
33 #include "scip/type_event.h"
34 #include "scip/type_scip.h"
35 #include "scip/type_branch.h"
36 #include "scip/type_conflict.h"
37 #include "scip/type_cons.h"
38 #include "scip/type_disp.h"
39 #include "scip/type_dialog.h"
40 #include "scip/type_heur.h"
41 #include "scip/type_nodesel.h"
42 #include "scip/type_presol.h"
43 #include "scip/type_pricer.h"
44 #include "scip/type_reader.h"
45 #include "scip/type_relax.h"
46 #include "scip/type_sepa.h"
47 #include "scip/type_prop.h"
48 #include "nlpi/type_nlpi.h"
49 
50 #ifdef __cplusplus
51 extern "C" {
52 #endif
53 
54 /** global SCIP settings */
55 struct SCIP_Set
56 {
57  SCIP_STAGE stage; /**< SCIP operation stage */
58  SCIP* scip; /**< very ugly: pointer to scip main data structure for callback methods */
59  SCIP_PARAMSET* paramset; /**< set of parameters */
60  SCIP_BUFFER* buffer; /**< memory buffers for short living temporary objects */
61  SCIP_READER** readers; /**< file readers */
62  SCIP_PRICER** pricers; /**< variable pricers */
63  SCIP_CONSHDLR** conshdlrs; /**< constraint handlers (sorted by check priority) */
64  SCIP_CONSHDLR** conshdlrs_sepa; /**< constraint handlers (sorted by separation priority) */
65  SCIP_CONSHDLR** conshdlrs_enfo; /**< constraint handlers (sorted by enforcement priority) */
66  SCIP_CONSHDLR** conshdlrs_include; /**< constraint handlers (sorted by inclusion order) */
67  SCIP_CONFLICTHDLR** conflicthdlrs; /**< conflict handlers */
68  SCIP_PRESOL** presols; /**< presolvers */
69  SCIP_RELAX** relaxs; /**< relaxators */
70  SCIP_SEPA** sepas; /**< separators */
71  SCIP_PROP** props; /**< propagators */
72  SCIP_HEUR** heurs; /**< primal heuristics */
73  SCIP_EVENTHDLR** eventhdlrs; /**< event handlers */
74  SCIP_NODESEL** nodesels; /**< node selectors */
75  SCIP_NODESEL* nodesel; /**< currently used node selector, or NULL if invalid */
76  SCIP_BRANCHRULE** branchrules; /**< branching rules */
77  SCIP_DISP** disps; /**< display columns */
78  SCIP_DIALOG** dialogs; /**< dialogs */
79  SCIP_NLPI** nlpis; /**< interfaces to NLP solvers */
80  char** extcodenames; /**< names of externals codes */
81  char** extcodedescs; /**< descriptions of external codes */
82  int nreaders; /**< number of file readers */
83  int readerssize; /**< size of readers array */
84  int npricers; /**< number of variable pricers */
85  int nactivepricers; /**< number of variable pricers used in the current problem */
86  int pricerssize; /**< size of pricers array */
87  int nconshdlrs; /**< number of constraint handlers */
88  int conshdlrssize; /**< size of conshdlrs array */
89  int nconflicthdlrs; /**< number of conflict handlers */
90  int conflicthdlrssize; /**< size of conflicthdlrs array */
91  int npresols; /**< number of presolvers */
92  int presolssize; /**< size of presols array */
93  int nrelaxs; /**< number of relaxators */
94  int relaxssize; /**< size of relaxs array */
95  int nsepas; /**< number of separators */
96  int sepassize; /**< size of sepas array */
97  int nprops; /**< number of propagators */
98  int propssize; /**< size of props array */
99  int nheurs; /**< number of primal heuristics */
100  int heurssize; /**< size of heurs array */
101  int neventhdlrs; /**< number of event handlers */
102  int eventhdlrssize; /**< size of eventhdlrs array */
103  int nnodesels; /**< number of node selectors */
104  int nodeselssize; /**< size of nodesels array */
105  int nbranchrules; /**< number of branching rules */
106  int branchrulessize; /**< size of branchrules array */
107  int ndisps; /**< number of display columns */
108  int dispssize; /**< size of disps array */
109  int ndialogs; /**< number of dialogs */
110  int dialogssize; /**< size of dialogs array */
111  int nnlpis; /**< number of NLPIs */
112  int nlpissize; /**< size of NLPIs array */
113  int nextcodes; /**< number of external codes */
114  int extcodessize; /**< size of external code arrays */
115  SCIP_Bool pricerssorted; /**< are the pricers sorted by activity and priority? */
116  SCIP_Bool pricersnamesorted; /**< are the pricers sorted by name? */
117  SCIP_Bool conflicthdlrssorted;/**< are the conflict handlers sorted by priority? */
118  SCIP_Bool conflicthdlrsnamesorted;/**< are the conflict handlers sorted by name? */
119  SCIP_Bool presolssorted; /**< are the presolvers sorted by priority? */
120  SCIP_Bool presolsnamesorted; /**< are the presolvers sorted by name? */
121  SCIP_Bool relaxssorted; /**< are the relaxators sorted by priority? */
122  SCIP_Bool relaxsnamesorted; /**< are the relaxators sorted by name? */
123  SCIP_Bool sepassorted; /**< are the separators sorted by priority? */
124  SCIP_Bool sepasnamesorted; /**< are the separators sorted by name? */
125  SCIP_Bool propssorted; /**< are the propagators sorted by priority? */
126  SCIP_Bool propspresolsorted; /**< are the propagators sorted by priority for presolving? */
127  SCIP_Bool propsnamesorted; /**< are the propagators sorted by name? */
128  SCIP_Bool heurssorted; /**< are the heuristics sorted by priority? */
129  SCIP_Bool heursnamesorted; /**< are the heuristics sorted by name? */
130  SCIP_Bool branchrulessorted; /**< are the branching rules sorted by priority? */
131  SCIP_Bool branchrulesnamesorted;/**< are the branching rules sorted by name? */
132  SCIP_Bool nlpissorted; /**< are the NLPIs sorted by priority? */
133  SCIP_Bool limitchanged; /**< marks whether any of the limit parameters was changed */
134  SCIP_Bool nlpenabled; /**< marks whether an NLP relaxation should be constructed */
135 
136  /* branching settings */
137  char branch_scorefunc; /**< branching score function ('s'um, 'p'roduct, 'q'uotient) */
138  char branch_firstsbchild;/**< child node to be regarded first during strong branching (only with propagation): 'u'p child, 'd'own child, or 'a'utomatic */
139  SCIP_Real branch_scorefac; /**< branching score factor to weigh downward and upward gain prediction
140  * in sum score function */
141  SCIP_Bool branch_preferbinary;/**< should branching on binary variables be preferred? */
142  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 */
143  char branch_lpgainnorm; /**< strategy for normalizing LP gain when updating pseudo costs of continuous variables */
144  SCIP_Bool branch_delaypscost; /**< whether to delay pseudo costs updates for continuous variables to after separation */
145  SCIP_Bool branch_forceall; /**< should all strong branching children be regarded even if
146  * one is detected to be infeasible? (only with propagation) */
147  SCIP_Bool branch_checksbsol; /**< should LP solutions during strong branching with propagation be checked for feasibility? */
148  SCIP_Bool branch_roundsbsol; /**< should LP solutions during strong branching with propagation be rounded? (only when checksbsol=TRUE) */
149 
150  /* conflict analysis settings */
151  SCIP_Real conf_maxvarsfac; /**< maximal fraction of variables involved in a conflict constraint */
152  int conf_minmaxvars; /**< minimal absolute maximum of variables involved in a conflict constraint */
153  int conf_maxlploops; /**< maximal number of LP resolving loops during conflict analysis
154  * (-1: no limit) */
155  int conf_lpiterations; /**< maximal number of LP iterations in each LP resolving loop
156  * (-1: no limit) */
157  int conf_fuiplevels; /**< number of depth levels up to which first UIP's are used in conflict
158  * analysis (-1: use All-FirstUIP rule) */
159  int conf_interconss; /**< maximal number of intermediate conflict constraints generated in conflict
160  * graph (-1: use every intermediate constraint) */
161  int conf_maxconss; /**< maximal number of conflict constraints accepted at an infeasible node
162  * (-1: use all generated conflict constraints) */
163  int conf_reconvlevels; /**< number of depth levels up to which UIP reconvergence constraints are
164  * generated (-1: generate reconvergence constraints in all depth levels) */
165  SCIP_Bool conf_enable; /**< should conflict analysis be enabled? */
166  SCIP_Bool conf_useprop; /**< should propagation conflict analysis be used? */
167  SCIP_Bool conf_useinflp; /**< should infeasible LP conflict analysis be used? */
168  SCIP_Bool conf_useboundlp; /**< should bound exceeding LP conflict analysis be used? */
169  SCIP_Bool conf_usesb; /**< should infeasible/bound exceeding strong branching conflict analysis be
170  * used? */
171  SCIP_Bool conf_usepseudo; /**< should pseudo solution conflict analysis be used? */
172  SCIP_Bool conf_preferbinary; /**< should binary conflicts be preferred? */
173  SCIP_Bool conf_allowlocal; /**< should conflict constraints be generated that are only valid locally? */
174  SCIP_Bool conf_settlelocal; /**< should conflict constraints be attached only to the local subtree where
175  * they can be useful? */
176  SCIP_Bool conf_repropagate; /**< should earlier nodes be repropagated in order to replace branching
177  * decisions by deductions? */
178  SCIP_Bool conf_keepreprop; /**< should constraints be kept for repropagation even if they are too long? */
179  SCIP_Bool conf_seperate; /**< should the conflict constraints be separated? */
180  SCIP_Bool conf_dynamic; /**< should the conflict constraints be subject to aging? */
181  SCIP_Bool conf_removable; /**< should the conflict's relaxations be subject to LP aging and cleanup? */
182  SCIP_Real conf_depthscorefac; /**< score factor for depth level in bound relaxation heuristic of LP analysis */
183  SCIP_Real conf_scorefac; /**< factor to decrease importance of variables' earlier conflict scores */
184  int conf_restartnum; /**< number of successful conflict analysis calls that trigger a restart
185  * (0: disable conflict restarts) */
186  SCIP_Real conf_restartfac; /**< factor to increase restartnum with after each restart */
187  SCIP_Bool conf_ignorerelaxedbd;/**< should relaxed bounds be ignored? */
188  int conf_maxvarsdetectimpliedbounds;/**< maximal number of variables to try to detect global bound
189  * implications and shorten the whole conflict set (0:
190  * disabled )
191  */
192  SCIP_Bool conf_fullshortenconflict;/**< try to shorten the whole conflict set or terminate early
193  * (depending on the 'maxvarsdetectimpliedbounds' parameter)
194  */
195  SCIP_Real conf_conflictweight;/**< the weight the VSIDS score is weight by updating the VSIDS for a
196  * variable if it is part of a conflict
197  */
198  SCIP_Real conf_conflictgraphweight; /**< the weight the VSIDS score is weight by updating the VSIDS for a
199  * variable if it is part of a conflict graph
200  */
201 
202  /* constraint settings */
203  int cons_agelimit; /**< maximum age an unnecessary constraint can reach before it is deleted
204  * (0: dynamic, -1: disable aging) */
205  int cons_obsoleteage; /**< age of a constraint after which it is marked obsolete
206  * (0: dynamic, -1: disable obsoletion) */
207  SCIP_Bool cons_disableenfops; /**< should enforcement of pseudo solution be disabled? */
208 
209  /* display settings */
210  SCIP_VERBLEVEL disp_verblevel; /**< verbosity level of output */
211  int disp_width; /**< maximal number of characters in a node information line */
212  int disp_freq; /**< frequency for displaying node information lines */
213  int disp_headerfreq; /**< frequency for displaying header lines (every n'th node information line) */
214  SCIP_Bool disp_lpinfo; /**< should the LP solver display status messages? */
215 
216  /* history settings */
217  SCIP_Bool history_valuebased; /**< should statistics be collected for variable domain value pairs? */
218 
219  /* limit settings */
220  SCIP_Real limit_time; /**< maximal time in seconds to run */
221  SCIP_Real limit_memory; /**< maximal memory usage in MB */
222  SCIP_Real limit_gap; /**< solving stops, if the given gap is reached */
223  SCIP_Real limit_absgap; /**< solving stops, if the absolute difference between primal and dual bound
224  * reaches this value */
225  SCIP_Longint limit_nodes; /**< maximal number of nodes to process (-1: no limit) */
226  SCIP_Longint limit_totalnodes; /**< maximal number of total nodes (incl. restarts) to process (-1: no limit) */
227  SCIP_Longint limit_stallnodes; /**< solving stops, if the given number of nodes was processed since the
228  * last improvement of the primal solution value (-1: no limit) */
229  int limit_solutions; /**< solving stops, if the given number of solutions were found (-1: no limit) */
230  int limit_bestsol; /**< solving stops, if the given number of solution improvements were found
231  * (-1: no limit) */
232  int limit_maxsol; /**< maximal number of solutions to store in the solution storage */
233  int limit_maxorigsol; /**< maximal number of solutions candidates to store in the solution storage of the original problem */
234  int limit_restarts; /**< solving stops, if the given number of restarts was triggered (-1: no limit) */
235 
236  /* LP settings */
237  int lp_solvefreq; /**< frequency for solving LP at the nodes (-1: never; 0: only root LP) */
238  SCIP_Longint lp_iterlim; /**< iteration limit for each single LP solve; -1: no limit */
239  SCIP_Longint lp_rootiterlim; /**< iteration limit for initial root LP solve; -1: no limit */
240  int lp_solvedepth; /**< maximal depth for solving LP at the nodes (-1: no depth limit) */
241  char lp_initalgorithm; /**< LP algorithm for solving initial LP relaxations ('s'implex, 'b'arrier,
242  * barrier with 'c'rossover) */
243  char lp_resolvealgorithm;/**< LP algorithm for resolving LP relaxations if a starting basis exists
244  * ('s'implex, 'b'arrier, barrier with 'c'rossover) */
245  char lp_pricing; /**< LP pricing strategy ('a'uto, 'f'ull pricing, 's'teepest edge pricing,
246  * 'q'uickstart steepest edge pricing, 'd'evex pricing) */
247  SCIP_Bool lp_clearinitialprobinglp;/**< should lp state be cleared at the end of probing mode when LP
248  * was initially unsolved, e.g., when called right after presolving? */
249  SCIP_Bool lp_resolverestore; /**< should the LP be resolved to restore the state at start of diving (if
250  * FALSE we buffer the solution values)? */
251  SCIP_Bool lp_freesolvalbuffers; /**< should the buffers for storing LP solution values during diving be
252  * freed at end of diving? */
253  int lp_colagelimit; /**< maximum age a column can reach before it is deleted from the SCIP_LP
254  * (-1: don't delete columns due to aging) */
255  int lp_rowagelimit; /**< maximum age a row can reach before it is deleted from the LP
256  * (-1: don't delete rows due to aging) */
257  SCIP_Bool lp_cleanupcols; /**< should new non-basic columns be removed after LP solving? */
258  SCIP_Bool lp_cleanupcolsroot; /**< should new non-basic columns be removed after root LP solving? */
259  SCIP_Bool lp_cleanuprows; /**< should new basic rows be removed after LP solving? */
260  SCIP_Bool lp_cleanuprowsroot; /**< should new basic rows be removed after root LP solving? */
261  SCIP_Bool lp_checkstability; /**< should LP solver's return status be checked for stability? */
262  SCIP_Real lp_conditionlimit; /**< maximum condition number of LP basis counted as stable (-1.0: no check) */
263  SCIP_Bool lp_checkprimfeas; /**< should LP solutions be checked for primal feasibility, resolving LP when numerical troubles occur? */
264  SCIP_Bool lp_checkdualfeas; /**< should LP solutions be checked for dual feasibility, resolving LP when numerical troubles occur? */
265  int lp_fastmip; /**< which FASTMIP setting of LP solver should be used? 0: off, 1: medium, 2: full */
266  SCIP_Bool lp_scaling; /**< should scaling of LP solver be used? */
267  SCIP_Bool lp_presolving; /**< should presolving of LP solver be used? */
268  SCIP_Bool lp_lexdualalgo; /**< should the lexicographic dual algorithm be used? */
269  SCIP_Bool lp_lexdualrootonly; /**< should the lexicographic dual algorithm be applied only at the root node */
270  int lp_lexdualmaxrounds;/**< maximum number of rounds in the lexicographic dual algorithm */
271  SCIP_Bool lp_lexdualbasic; /**< choose fractional basic variables in lexicographic dual algorithm */
272  SCIP_Bool lp_lexdualstalling; /**< turn on the lex dual algorithm only when stalling? */
273  int lp_disablecutoff; /**< disable the cutoff bound in the LP solver? (0: enabled, 1: disabled, 2: auto) */
274  SCIP_Real lp_rowrepswitch; /**< simplex algorithm shall use row representation of the basis
275  * if number of rows divided by number of columns exceeds this value */
276  int lp_threads; /**< number of threads used for solving the LP (0: automatic) */
277  SCIP_Real lp_resolveiterfac; /**< factor of average LP iterations that is used as LP iteration limit
278  * for LP resolve (-1: unlimited) */
279  int lp_resolveitermin; /**< minimum number of iterations that are allowed for LP resolve */
280 
281  /* NLP settings */
282  SCIP_Bool nlp_disable; /**< should the NLP be disabled even if a constraint handler enabled it? */
283  char* nlp_solver; /**< name of NLP solver to use */
284 
285  /* memory settings */
286  SCIP_Longint mem_externestim; /**< estimation of external memory usage, e.g., by LP solver */
287  SCIP_Real mem_savefac; /**< fraction of maximal memory usage resulting in switch to memory saving mode */
288  SCIP_Real mem_arraygrowfac; /**< memory growing factor for dynamically allocated arrays */
289  SCIP_Real mem_treegrowfac; /**< memory growing factor for tree array */
290  SCIP_Real mem_pathgrowfac; /**< memory growing factor for path array */
291  int mem_arraygrowinit; /**< initial size of dynamically allocated arrays */
292  int mem_treegrowinit; /**< initial size of tree array */
293  int mem_pathgrowinit; /**< initial size of path array */
294 
295  /* miscellaneous settings */
296  SCIP_Bool misc_catchctrlc; /**< should the CTRL-C interrupt be caught by SCIP? */
297  SCIP_Bool misc_usevartable; /**< should a hashtable be used to map from variable names to variables? */
298  SCIP_Bool misc_useconstable; /**< should a hashtable be used to map from constraint names to constraints? */
299  SCIP_Bool misc_usesmalltables;/**< should smaller hashtables be used? yields better performance for small problems with about 100 variables */
300  SCIP_Bool misc_exactsolve; /**< should the problem be solved exactly (with proven dual bounds)? */
301  int misc_permutationseed;/**< seed value for permuting the problem after the problem was tranformed
302  * (-1: no permutation) */
303  SCIP_Bool misc_permuteconss; /**< should order of constraints be permuted (depends on permutationseed)? */
304  SCIP_Bool misc_permutevars; /**< should order of variables be permuted (depends on permutationseed)? */
305  SCIP_Bool misc_resetstat; /**< should the statistics be reset if the transformed problem is freed
306  * otherwise the statistics get reset after original problem is freed (in
307  * case of bender decomposition this parameter should be set to FALSE and
308  * therefore can be used to collect statistics over all runs) */
309  SCIP_Bool misc_improvingsols; /**< should only solutions be checked which improve the primal bound */
310  SCIP_Bool misc_printreason; /**< should the reason be printed if a given start solution is infeasible? */
311  SCIP_Bool misc_estimexternmem;/**< should the usage of external memory be estimated? */
312  SCIP_Bool misc_transorigsols; /**< should SCIP try to transfer original solutions to the extended space (after presolving)? */
313  SCIP_Bool misc_calcintegral; /**< should SCIP calculate the primal dual integral value which may require
314  * a large number of additional clock calls (and decrease the performance)? */
315  SCIP_Bool misc_finitesolstore;/**< should SCIP try to remove infinite fixings from solutions copied to the solution store? */
316 
317  /* node selection settings */
318  char nodesel_childsel; /**< child selection rule ('d'own, 'u'p, 'p'seudo costs, 'i'nference, 'l'p value,
319  * 'r'oot LP value difference, 'h'brid inference/root LP value difference) */
320 
321  /* numerical settings */
322  SCIP_Real num_infinity; /**< values larger than this are considered infinity */
323  SCIP_Real num_epsilon; /**< absolute values smaller than this are considered zero */
324  SCIP_Real num_sumepsilon; /**< absolute values of sums smaller than this are considered zero */
325  SCIP_Real num_feastol; /**< feasibility tolerance for constraints */
326  SCIP_Real num_lpfeastol; /**< primal feasibility tolerance of LP solver */
327  SCIP_Real num_dualfeastol; /**< feasibility tolerance for reduced costs */
328  SCIP_Real num_barrierconvtol; /**< convergence tolerance used in barrier algorithm */
329  SCIP_Real num_boundstreps; /**< minimal improve for strengthening bounds */
330  SCIP_Real num_pseudocosteps; /**< minimal variable distance value to use for pseudo cost updates */
331  SCIP_Real num_pseudocostdelta;/**< minimal objective distance value to use for pseudo cost updates */
332  SCIP_Real num_recompfac; /**< minimal decrease factor that causes the recomputation of a value
333  * (e.g., pseudo objective) instead of an update */
334  SCIP_Real num_hugeval; /**< values larger than this are considered huge and should be handled
335  * separately (e.g., in activity computation) */
336 
337  /* presolving settings */
338  SCIP_Real presol_abortfac; /**< abort presolve, if l.t. this frac of the problem was changed in last round */
339  int presol_maxrounds; /**< maximal number of presolving rounds (-1: unlimited) */
340  int presol_maxrestarts; /**< maximal number of restarts (-1: unlimited) */
341  SCIP_Real presol_restartfac; /**< fraction of integer variables that were fixed in the root node
342  * triggering a restart with preprocessing after root node evaluation */
343  SCIP_Real presol_immrestartfac;/**< fraction of integer variables that were fixed in the root node triggering an
344  * immediate restart with preprocessing */
345  SCIP_Real presol_subrestartfac;/**< fraction of integer variables that were globally fixed during the
346  * solving process triggering a restart with preprocessing */
347  SCIP_Real presol_restartminred;/**< minimal fraction of integer variables removed after restart to allow for
348  * an additional restart */
349  SCIP_Bool presol_donotmultaggr;/**< should multi-aggregation of variables be forbidden? */
350  SCIP_Bool presol_donotaggr; /**< shouldaggregation of variables be forbidden? */
351 
352  /* pricing settings */
353  SCIP_Real price_abortfac; /**< pricing is aborted, if fac * maxpricevars pricing candidates were found */
354  int price_maxvars; /**< maximal number of variables priced in per pricing round */
355  int price_maxvarsroot; /**< maximal number of priced variables at the root node */
356  SCIP_Bool price_delvars; /**< should variables created at the current node be deleted when the node is solved
357  * in case they are not present in the LP anymore? */
358  SCIP_Bool price_delvarsroot; /**< should variables created at the root node be deleted when the root is solved
359  * in case they are not present in the LP anymore? */
360 
361  /* propagation settings */
362  int prop_maxrounds; /**< maximal number of propagation rounds per node (-1: unlimited) */
363  int prop_maxroundsroot; /**< maximal number of propagation rounds in the root node (-1: unlimited) */
364  SCIP_Bool prop_abortoncutoff; /**< should propagation be aborted immediately? setting this to FALSE could
365  * help conflict analysis to produce more conflict constraints */
366 
367  /* separation settings */
368  SCIP_Real sepa_maxbounddist; /**< maximal relative distance from current node's dual bound to primal bound
369  * compared to best node's dual bound for applying separation
370  * (0.0: only on current best node, 1.0: on all nodes) */
371  SCIP_Real sepa_minefficacy; /**< minimal efficacy for a cut to enter the LP */
372  SCIP_Real sepa_minefficacyroot; /**< minimal efficacy for a cut to enter the LP in the root node */
373  SCIP_Real sepa_minortho; /**< minimal orthogonality for a cut to enter the LP */
374  SCIP_Real sepa_minorthoroot; /**< minimal orthogonality for a cut to enter the LP in the root node */
375  SCIP_Real sepa_objparalfac; /**< factor to scale objective parallelism of cut in separation score calc. */
376  SCIP_Real sepa_orthofac; /**< factor to scale orthogonality of cut in separation score calculation */
377  SCIP_Real sepa_feastolfac; /**< factor on cut infeasibility to limit feasibility tolerance for relaxation solver (-1: off) */
378  SCIP_Real sepa_primfeastol; /**< primal feasibility tolerance derived from cut feasibility (set by sepastore, not a parameter) */
379  char sepa_orthofunc; /**< function used for calc. scalar prod. in orthogonality test ('e'uclidean, 'd'iscrete) */
380  char sepa_efficacynorm; /**< row norm to use for efficacy calculation ('e'uclidean, 'm'aximum, 's'um,
381  * 'd'iscrete) */
382  int sepa_maxruns; /**< maximal number of runs for which separation is enabled (-1: unlimited) */
383  int sepa_maxrounds; /**< maximal number of separation rounds per node (-1: unlimited) */
384  int sepa_maxroundsroot; /**< maximal number of separation rounds in the root node (-1: unlimited) */
385  int sepa_maxroundsrootsubrun; /**< maximal number of separation rounds in the root node of a subsequent run (-1: unlimited) */
386  int sepa_maxaddrounds; /**< maximal additional number of separation rounds in subsequent price-and-cut
387  * loops (-1: no additional restriction) */
388  int sepa_maxstallrounds;/**< maximal number of consecutive separation rounds without objective
389  * or integrality improvement (-1: no additional restriction) */
390  int sepa_maxcuts; /**< maximal number of cuts separated per separation round */
391  int sepa_maxcutsroot; /**< maximal number of separated cuts at the root node */
392  int sepa_cutagelimit; /**< maximum age a cut can reach before it is deleted from the global cut pool */
393  int sepa_poolfreq; /**< separation frequency for the global cut pool */
394 
395  /* timing settings */
396  SCIP_CLOCKTYPE time_clocktype; /**< default clock type to use */
397  SCIP_Bool time_enabled; /**< is timing enabled? */
398  SCIP_Bool time_reading; /**< belongs reading time to solving time? */
399 
400  /* VBC tool settings */
401  char* vbc_filename; /**< name of the VBC Tool output file, or - if no output should be created */
402  SCIP_Bool vbc_realtime; /**< should the real solving time be used instead of time step counter in VBC output? */
403  SCIP_Bool vbc_dispsols; /**< should the node where solutions are found be visualized? */
404 
405  /* Reading */
406  SCIP_Bool read_initialconss; /**< should model constraints be marked as initial? */
407  SCIP_Bool read_dynamicconss; /**< should model constraints be subject to aging? */
408  SCIP_Bool read_dynamiccols; /**< should columns be added and removed dynamically to the LP? */
409  SCIP_Bool read_dynamicrows; /**< should rows be added and removed dynamically to the LP? */
410 
411  /* Writing */
412  SCIP_Bool write_allconss; /**< should all constraints be written (including the redundant constraints)? */
413  int write_genoffset; /**< when writing the problem with generic names, we start with index
414  * 0; using this parameter we can change the starting index to be
415  * different */
416 };
417 
418 #ifdef __cplusplus
419 }
420 #endif
421 
422 #endif
423