Scippy

SCIP

Solving Constraint Integer Programs

set.c
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-2019 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 scip.zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file set.c
17  * @brief methods for global SCIP settings
18  * @author Tobias Achterberg
19  * @author Timo Berthold
20  *
21  * @todo Functions like SCIPsetFeastol() are misleading (it seems that the feasibility tolerance can be set).
22  * Rename all functions starting with SCIPsetXXX, e.g., SCIPsetGetFeastol() and SCIPsetSetFeastol().
23  */
24 
25 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
26 
27 #include <assert.h>
28 #include <string.h>
29 #include <math.h>
30 
31 #include "scip/def.h"
32 #include "scip/set.h"
33 #include "scip/stat.h"
34 #include "scip/clock.h"
35 #include "scip/event.h"
36 #include "scip/lp.h"
37 #include "scip/paramset.h"
38 #include "scip/scip.h"
39 #include "scip/bandit.h"
40 #include "scip/branch.h"
41 #include "scip/conflict.h"
42 #include "scip/cons.h"
43 #include "scip/disp.h"
44 #include "scip/dialog.h"
45 #include "scip/heur.h"
46 #include "scip/concsolver.h"
47 #include "scip/compr.h"
48 #include "scip/nodesel.h"
49 #include "scip/presol.h"
50 #include "scip/pricer.h"
51 #include "scip/reader.h"
52 #include "scip/relax.h"
53 #include "scip/sepa.h"
54 #include "scip/table.h"
55 #include "scip/prop.h"
56 #include "scip/benders.h"
57 #include "nlpi/nlpi.h"
58 #include "scip/struct_scip.h" /* for SCIPsetPrintDebugMessage() */
59 
60 /*
61  * Default settings
62  */
63 
64 
65 /* Branching */
66 
67 #define SCIP_DEFAULT_BRANCH_SCOREFUNC 'p' /**< branching score function ('s'um, 'p'roduct) */
68 #define SCIP_DEFAULT_BRANCH_SCOREFAC 0.167 /**< branching score factor to weigh downward and upward gain prediction
69  * in sum score function */
70 #define SCIP_DEFAULT_BRANCH_PREFERBINARY FALSE /**< should branching on binary variables be preferred? */
71 #define SCIP_DEFAULT_BRANCH_CLAMP 0.2 /**< minimal fractional distance of branching point to a continuous variable'
72  * bounds; a value of 0.5 leads to branching always in the middle of a bounded domain */
73 #define SCIP_DEFAULT_BRANCH_LPGAINNORMALIZE 's' /**< strategy for normalizing LP gain when updating pseudo costs of continuous variables */
74 #define SCIP_DEFAULT_BRANCH_DELAYPSCOST TRUE /**< should updating pseudo costs of continuous variables be delayed to after separation */
75 #define SCIP_DEFAULT_BRANCH_DIVINGPSCOST TRUE /**< should pseudo costs be updated also in diving and probing mode? */
76 #define SCIP_DEFAULT_BRANCH_FORCEALL FALSE /**< should all strong branching children be regarded even if
77  * one is detected to be infeasible? (only with propagation) */
78 #define SCIP_DEFAULT_BRANCH_FIRSTSBCHILD 'a' /**< child node to be regarded first during strong branching (only with propagation): 'u'p child, 'd'own child, 'h'istory-based, or 'a'utomatic */
79 #define SCIP_DEFAULT_BRANCH_CHECKSBSOL TRUE /**< should LP solutions during strong branching with propagation be checked for feasibility? */
80 #define SCIP_DEFAULT_BRANCH_ROUNDSBSOL TRUE /**< should LP solutions during strong branching with propagation be rounded? (only when checksbsol=TRUE) */
81 #define SCIP_DEFAULT_BRANCH_SUMADJUSTSCORE FALSE /**< score adjustment near zero by adding epsilon (TRUE) or using maximum (FALSE) */
82 
83 /* Tree Compression */
84 
85 #define SCIP_DEFAULT_COMPR_ENABLE FALSE /**< should automatic tree compression in reoptimization after presolving be enabled? */
86 
87 
88 /* Conflict Analysis (general) */
89 
90 #define SCIP_DEFAULT_CONF_ENABLE TRUE /**< conflict analysis be enabled? */
91 #define SCIP_DEFAULT_CONF_MAXVARSFAC 0.15 /**< maximal fraction of variables involved in a conflict constraint */
92 #define SCIP_DEFAULT_CONF_MINMAXVARS 0 /**< minimal absolute maximum of variables involved in a conflict constraint */
93 #define SCIP_DEFAULT_CONF_MAXLPLOOPS 2 /**< maximal number of LP resolving loops during conflict analysis
94  * (-1: no limit) */
95 #define SCIP_DEFAULT_CONF_LPITERATIONS 10 /**< maximal number of LP iterations in each LP resolving loop
96  * (-1: no limit) */
97 #define SCIP_DEFAULT_CONF_USEPROP TRUE /**< should propagation conflict analysis be used? */
98 #define SCIP_DEFAULT_CONF_USEINFLP 'b' /**< should infeasible LP conflict analysis be used?
99  * ('o'ff, 'c'onflict graph, 'd'ual ray, 'b'oth conflict graph and dual ray)
100  */
101 #define SCIP_DEFAULT_CONF_USEBOUNDLP 'b' /**< should bound exceeding LP conflict analysis be used?
102  * ('o'ff, 'c'onflict graph, 'd'ual ray, 'b'oth conflict graph and dual solution)
103  */
104 #define SCIP_DEFAULT_CONF_USESB TRUE /**< should infeasible/bound exceeding strong branching conflict analysis
105  * be used? */
106 #define SCIP_DEFAULT_CONF_USEPSEUDO TRUE /**< should pseudo solution conflict analysis be used? */
107 #define SCIP_DEFAULT_CONF_PREFINFPROOF TRUE /**< prefer infeasibility proof to boundexceeding proof */
108 #define SCIP_DEFAULT_CONF_SEPARATE TRUE /**< should the conflict constraints be separated? */
109 #define SCIP_DEFAULT_CONF_DYNAMIC TRUE /**< should the conflict constraints be subject to aging? */
110 
111 
112 /* Conflict Analysis (conflict graph) */
114 #define SCIP_DEFAULT_CONF_MAXSTORESIZE 10000 /**< maximal size of the conflict pool */
115 #define SCIP_DEFAULT_CONF_RECONVLEVELS -1 /**< number of depth levels up to which UIP reconvergence constraints are
116  * generated (-1: generate reconvergence constraints in all depth levels) */
117 #define SCIP_DEFAULT_CONF_CLEANBNDDEPEND TRUE /**< should conflicts based on an old cutoff bound removed? */
118 #define SCIP_DEFAULT_CONF_FUIPLEVELS -1 /**< number of depth levels up to which first UIP's are used in conflict
119  * analysis (-1: use All-FirstUIP rule) */
120 #define SCIP_DEFAULT_CONF_INTERCONSS -1 /**< maximal number of intermediate conflict constraints generated in
121  * conflict graph (-1: use every intermediate constraint) */
122 #define SCIP_DEFAULT_CONF_MAXCONSS 10 /**< maximal number of conflict constraints accepted at an infeasible node
123  * (-1: use all generated conflict constraints) */
124 #define SCIP_DEFAULT_CONF_PREFERBINARY FALSE /**< should binary conflicts be preferred? */
125 #define SCIP_DEFAULT_CONF_ALLOWLOCAL TRUE /**< should conflict constraints be generated that are only valid locally? */
126 #define SCIP_DEFAULT_CONF_SETTLELOCAL FALSE /**< should conflict constraints be attached only to the local subtree
127  * where they can be useful? */
128 #define SCIP_DEFAULT_CONF_REPROPAGATE TRUE /**< should earlier nodes be repropagated in order to replace branching
129  * decisions by deductions? */
130 #define SCIP_DEFAULT_CONF_KEEPREPROP TRUE /**< should constraints be kept for repropagation even if they are too long? */
131 #define SCIP_DEFAULT_CONF_REMOVEABLE TRUE /**< should the conflict's relaxations be subject to LP aging and cleanup? */
132 #define SCIP_DEFAULT_CONF_DEPTHSCOREFAC 1.0 /**< score factor for depth level in bound relaxation heuristic of LP analysis */
133 #define SCIP_DEFAULT_CONF_PROOFSCOREFAC 1.0 /**< score factor for impact on acticity in bound relaxation heuristic of LP analysis */
134 #define SCIP_DEFAULT_CONF_UPLOCKSCOREFAC 0.0 /**< score factor for up locks in bound relaxation heuristic of LP analysis */
135 #define SCIP_DEFAULT_CONF_DOWNLOCKSCOREFAC 0.0 /**< score factor for down locks in bound relaxation heuristic of LP analysis */
136 #define SCIP_DEFAULT_CONF_SCOREFAC 0.98 /**< factor to decrease importance of variables' earlier conflict scores */
137 #define SCIP_DEFAULT_CONF_RESTARTNUM 0 /**< number of successful conflict analysis calls that trigger a restart
138  * (0: disable conflict restarts) */
139 #define SCIP_DEFAULT_CONF_RESTARTFAC 1.5 /**< factor to increase restartnum with after each restart */
140 #define SCIP_DEFAULT_CONF_IGNORERELAXEDBD FALSE /**< should relaxed bounds be ignored? */
141 #define SCIP_DEFAULT_CONF_MAXVARSDETECTIMPLIEDBOUNDS 250 /**< maximal number of variables to try to detect global bound implications and shorten the whole conflict set (0: disabled) */
142 #define SCIP_DEFAULT_CONF_FULLSHORTENCONFLICT TRUE /**< try to shorten the whole conflict set or terminate early (depending on the 'maxvarsdetectimpliedbounds' parameter) */
143 #define SCIP_DEFAULT_CONF_CONFLITWEIGHT 0.0 /**< the weight the VSIDS score is weight by updating the VSIDS for a variable if it is part of a conflict */
144 #define SCIP_DEFAULT_CONF_CONFLITGRAPHWEIGHT 1.0/**< the weight the VSIDS score is weight by updating the VSIDS for a variable if it is part of a conflict graph */
145 #define SCIP_DEFAULT_CONF_WEIGHTSIZE 0.001 /**< weight of the size of a conflict used in score calculation */
146 #define SCIP_DEFAULT_CONF_WEIGHTREPROPDEPTH 0.1 /**< weight of the repropagation depth of a conflict used in score calculation */
147 #define SCIP_DEFAULT_CONF_WEIGHTVALIDDEPTH 1.0 /**< weight of the valid depth of a conflict used in score calculation */
148 #define SCIP_DEFAULT_CONF_MINIMPROVE 0.05 /**< minimal improvement of primal bound to remove conflicts based on a previous incumbent */
150 /* Conflict Analysis (dual ray) */
152 #define SCIP_DEFAULT_CONF_SEPAALTPROOFS FALSE /**< apply cut generating functions to construct alternative proofs */
154 /* Constraints */
155 
156 #define SCIP_DEFAULT_CONS_AGELIMIT 0 /**< maximum age an unnecessary constraint can reach before it is deleted
157  * (0: dynamic adjustment, -1: constraints are never deleted) */
158 #define SCIP_DEFAULT_CONS_OBSOLETEAGE -1 /**< age of a constraint after which it is marked obsolete
159  * (0: dynamic adjustment, -1: constraints are never marked obsolete) */
160 #define SCIP_DEFAULT_CONS_DISABLEENFOPS FALSE /**< should enforcement of pseudo solution be disabled? */
163 /* Display */
165 #define SCIP_DEFAULT_DISP_VERBLEVEL SCIP_VERBLEVEL_HIGH /**< verbosity level of output */
166 #define SCIP_DEFAULT_DISP_WIDTH 139 /**< maximal number of characters in a node information line */
167 #define SCIP_DEFAULT_DISP_FREQ 100 /**< frequency for displaying node information lines */
168 #define SCIP_DEFAULT_DISP_HEADERFREQ 15 /**< frequency for displaying header lines (every n'th node info line) */
169 #define SCIP_DEFAULT_DISP_LPINFO FALSE /**< should the LP solver display status messages? */
170 #define SCIP_DEFAULT_DISP_ALLVIOLS FALSE /**< display all violations of the best solution after the solving process finished? */
171 #define SCIP_DEFAULT_DISP_RELEVANTSTATS TRUE /**< should the relevant statistics be displayed at the end of solving? */
172 
173 /* History */
174 
175 #define SCIP_DEFAULT_HISTORY_VALUEBASED FALSE /**< should statistics be collected for variable domain value pairs */
176 #define SCIP_DEFAULT_HISTORY_ALLOWMERGE FALSE /**< should variable histories be merged from sub-SCIPs whenever possible? */
177 #define SCIP_DEFAULT_HISTORY_ALLOWTRANSFER FALSE /**< should variable histories be transferred to initialize SCIP copies? */
178 
179 /* Limits */
180 
181 #define SCIP_DEFAULT_LIMIT_TIME 1e+20 /**< maximal time in seconds to run */
182 #define SCIP_DEFAULT_LIMIT_MEMORY SCIP_MEM_NOLIMIT/**< maximal memory usage in MB */
183 #define SCIP_DEFAULT_LIMIT_GAP 0.0 /**< solving stops, if the gap is below the given value */
184 #define SCIP_DEFAULT_LIMIT_ABSGAP 0.0 /**< solving stops, if the absolute difference between primal and dual
185  * bound reaches this value */
186 #define SCIP_DEFAULT_LIMIT_NODES -1LL /**< maximal number of nodes to process (-1: no limit) */
187 #define SCIP_DEFAULT_LIMIT_STALLNODES -1LL /**< solving stops, if the given number of nodes was processed since the
188  * last improvement of the primal solution value (-1: no limit) */
189 #define SCIP_DEFAULT_LIMIT_SOLUTIONS -1 /**< solving stops, if given number of sols were found (-1: no limit) */
190 #define SCIP_DEFAULT_LIMIT_BESTSOL -1 /**< solving stops, if given number of solution improvements were found
191  * (-1: no limit) */
192 #define SCIP_DEFAULT_LIMIT_MAXSOL 100 /**< maximal number of solutions to store in the solution storage */
193 #define SCIP_DEFAULT_LIMIT_MAXORIGSOL 10 /**< maximal number of solutions candidates to store in the solution storage of the original problem */
194 #define SCIP_DEFAULT_LIMIT_RESTARTS -1 /**< solving stops, if the given number of restarts was triggered (-1: no limit) */
195 #define SCIP_DEFAULT_LIMIT_AUTORESTARTNODES -1 /**< if solve exceeds this number of nodes, an automatic restart is triggered (-1: no automatic restart)*/
197 
198 /* LP */
199 
200 #define SCIP_DEFAULT_LP_SOLVEFREQ 1 /**< frequency for solving LP at the nodes; -1: never; 0: only root LP */
201 #define SCIP_DEFAULT_LP_ITERLIM -1LL /**< iteration limit for each single LP solve; -1: no limit */
202 #define SCIP_DEFAULT_LP_ROOTITERLIM -1LL /**< iteration limit for initial root LP solve; -1: no limit */
203 #define SCIP_DEFAULT_LP_SOLVEDEPTH -1 /**< maximal depth for solving LPs (-1: no depth limit) */
204 #define SCIP_DEFAULT_LP_INITALGORITHM 's' /**< LP algorithm for solving initial LP relaxations ('s'implex, 'b'arrier,
205  * barrier with 'c'rossover) */
206 #define SCIP_DEFAULT_LP_RESOLVEALGORITHM 's' /**< LP algorithm for resolving LP relaxations if a starting basis exists
207  * ('s'implex, 'b'arrier, barrier with 'c'rossover) */
208 #define SCIP_DEFAULT_LP_PRICING 'l' /**< LP pricing strategy ('l'pi default, 'a'uto, 'f'ull pricing, 'p'artial,
209  * 's'teepest edge pricing, 'q'uickstart steepest edge pricing,
210  * 'd'evex pricing) */
211 #define SCIP_DEFAULT_LP_CLEARINITIALPROBINGLP TRUE/**< should lp state be cleared at the end of probing mode when lp
212  * was initially unsolved, e.g., when called right after presolving? */
213 #define SCIP_DEFAULT_LP_RESOLVERESTORE FALSE /**< should the LP be resolved to restore the state at start of diving (if FALSE we buffer the solution values)? */
214 #define SCIP_DEFAULT_LP_FREESOLVALBUFFERS FALSE /**< should the buffers for storing LP solution values during diving be freed at end of diving? */
215 #define SCIP_DEFAULT_LP_COLAGELIMIT 10 /**< maximum age a dynamic column can reach before it is deleted from SCIP_LP
216  * (-1: don't delete columns due to aging) */
217 #define SCIP_DEFAULT_LP_ROWAGELIMIT 10 /**< maximum age a dynamic row can reach before it is deleted from SCIP_LP
218  * (-1: don't delete rows due to aging) */
219 #define SCIP_DEFAULT_LP_CLEANUPCOLS FALSE /**< should new non-basic columns be removed after LP solving? */
220 #define SCIP_DEFAULT_LP_CLEANUPCOLSROOT FALSE /**< should new non-basic columns be removed after root LP solving? */
221 #define SCIP_DEFAULT_LP_CLEANUPROWS TRUE /**< should new basic rows be removed after LP solving? */
222 #define SCIP_DEFAULT_LP_CLEANUPROWSROOT TRUE /**< should new basic rows be removed after root LP solving? */
223 #define SCIP_DEFAULT_LP_CHECKSTABILITY TRUE /**< should LP solver's return status be checked for stability? */
224 #define SCIP_DEFAULT_LP_CONDITIONLIMIT -1.0 /**< maximum condition number of LP basis counted as stable (-1.0: no limit) */
225 #define SCIP_DEFAULT_LP_CHECKPRIMFEAS TRUE /**< should LP solutions be checked for primal feasibility to resolve LP at numerical troubles? */
226 #define SCIP_DEFAULT_LP_CHECKDUALFEAS TRUE /**< should LP solutions be checked for dual feasibility to resolve LP at numerical troubles? */
227 #define SCIP_DEFAULT_LP_CHECKFARKAS TRUE /**< should infeasibility proofs from the LP be checked? */
228 #define SCIP_DEFAULT_LP_FASTMIP 1 /**< should FASTMIP setting of LP solver be used? */
229 #define SCIP_DEFAULT_LP_SCALING 1 /**< LP scaling (0: none, 1: normal, 2: aggressive) */
230 #define SCIP_DEFAULT_LP_PRESOLVING TRUE /**< should presolving of LP solver be used? */
231 #define SCIP_DEFAULT_LP_LEXDUALALGO FALSE /**< should the dual lexicographic algorithm be used? */
232 #define SCIP_DEFAULT_LP_LEXDUALROOTONLY TRUE /**< should the lexicographic dual algorithm be applied only at the root node */
233 #define SCIP_DEFAULT_LP_LEXDUALMAXROUNDS 2 /**< maximum number of rounds in the dual lexicographic algorithm */
234 #define SCIP_DEFAULT_LP_LEXDUALBASIC FALSE /**< choose fractional basic variables in lexicographic dual algorithm */
235 #define SCIP_DEFAULT_LP_LEXDUALSTALLING TRUE /**< turn on the lex dual algorithm only when stalling? */
236 #define SCIP_DEFAULT_LP_DISABLECUTOFF 2 /**< disable the cutoff bound in the LP solver? (0: enabled, 1: disabled, 2: auto) */
237 #define SCIP_DEFAULT_LP_ROWREPSWITCH 1.2 /**< simplex algorithm shall use row representation of the basis
238  * if number of rows divided by number of columns exceeds this value */
239 #define SCIP_DEFAULT_LP_THREADS 0 /**< number of threads used for solving the LP (0: automatic) */
240 #define SCIP_DEFAULT_LP_RESOLVEITERFAC -1.0 /**< factor of average LP iterations that is used as LP iteration limit
241  * for LP resolve (-1.0: unlimited) */
242 #define SCIP_DEFAULT_LP_RESOLVEITERMIN 1000 /**< minimum number of iterations that are allowed for LP resolve */
243 #define SCIP_DEFAULT_LP_SOLUTIONPOLISHING 3 /**< LP solution polishing method (0: disabled, 1: only root, 2: always, 3: auto) */
244 #define SCIP_DEFAULT_LP_REFACTORINTERVAL 0 /**< LP refactorization interval (0: automatic) */
245 #define SCIP_DEFAULT_LP_ALWAYSGETDUALS FALSE /**< should the dual solution always be collected */
246 
247 /* NLP */
249 #define SCIP_DEFAULT_NLP_SOLVER "" /**< name of NLP solver to use, or "" if solver should be chosen by priority */
250 #define SCIP_DEFAULT_NLP_DISABLE FALSE /**< should the NLP be always disabled? */
253 /* Memory */
255 #define SCIP_DEFAULT_MEM_SAVEFAC 0.8 /**< fraction of maximal mem usage when switching to memory saving mode */
256 #define SCIP_DEFAULT_MEM_TREEGROWFAC 2.0 /**< memory growing factor for tree array */
257 #define SCIP_DEFAULT_MEM_PATHGROWFAC 2.0 /**< memory growing factor for path array */
258 #define SCIP_DEFAULT_MEM_TREEGROWINIT 65536 /**< initial size of tree array */
259 #define SCIP_DEFAULT_MEM_PATHGROWINIT 256 /**< initial size of path array */
262 /* Miscellaneous */
264 #define SCIP_DEFAULT_MISC_CATCHCTRLC TRUE /**< should the CTRL-C interrupt be caught by SCIP? */
265 #define SCIP_DEFAULT_MISC_USEVARTABLE TRUE /**< should a hashtable be used to map from variable names to variables? */
266 #define SCIP_DEFAULT_MISC_USECONSTABLE TRUE /**< should a hashtable be used to map from constraint names to constraints? */
267 #define SCIP_DEFAULT_MISC_USESMALLTABLES FALSE /**< should smaller hashtables be used? yields better performance for small problems with about 100 variables */
268 #define SCIP_DEFAULT_MISC_EXACTSOLVE FALSE /**< should the problem be solved exactly (with proven dual bounds)? */
269 #define SCIP_DEFAULT_MISC_RESETSTAT TRUE /**< should the statistics be reset if the transformed problem is
270  * freed otherwise the statistics get reset after original problem is
271  * freed (in case of Benders' decomposition this parameter should be set
272  * to FALSE and therefore can be used to collect statistics over all
273  * runs) */
274 #define SCIP_DEFAULT_MISC_IMPROVINGSOLS FALSE /**< should only solutions be checked which improve the primal bound */
275 #define SCIP_DEFAULT_MISC_PRINTREASON TRUE /**< should the reason be printed if a given start solution is infeasible? */
276 #define SCIP_DEFAULT_MISC_ESTIMEXTERNMEM TRUE /**< should the usage of external memory be estimated? */
277 #define SCIP_DEFAULT_MISC_TRANSORIGSOLS TRUE /**< should SCIP try to transfer original solutions to the transformed space (after presolving)? */
278 #define SCIP_DEFAULT_MISC_TRANSSOLSORIG TRUE /**< should SCIP try to transfer transformed solutions to the original space (after solving)? */
279 #define SCIP_DEFAULT_MISC_CALCINTEGRAL TRUE /**< should SCIP calculate the primal dual integral? */
280 #define SCIP_DEFAULT_MISC_FINITESOLSTORE FALSE /**< should SCIP try to remove infinite fixings from solutions copied to the solution store? */
281 #define SCIP_DEFAULT_MISC_OUTPUTORIGSOL TRUE /**< should the best solution be transformed to the orignal space and be output in command line run? */
282 #define SCIP_DEFAULT_MISC_ALLOWDUALREDS TRUE /**< should dual reductions in propagation methods and presolver be allowed? */
283 #define SCIP_DEFAULT_MISC_ALLOWOBJPROP TRUE /**< should propagation to the current objective be allowed in propagation methods? */
284 #define SCIP_DEFAULT_MISC_REFERENCEVALUE 1e99 /**< objective value for reference purposes */
285 #define SCIP_DEFAULT_MISC_USESYMMETRY 2 /**< used symmetry handling technique (0: off; 1: polyhedral; 2: orbital fixing) */
286 #define SCIP_DEFAULT_MISC_SCALEOBJ TRUE /**< should the objective function be scaled? */
288 #ifdef WITH_DEBUG_SOLUTION
289 #define SCIP_DEFAULT_MISC_DEBUGSOLUTION "-" /**< path to a debug solution */
290 #endif
291 
292 /* Randomization */
293 #define SCIP_DEFAULT_RANDOM_RANDSEEDSHIFT 0 /**< global shift of all random seeds in the plugins, this will have no impact on the permutation and LP seeds */
294 #define SCIP_DEFAULT_RANDOM_PERMUTATIONSEED 0 /**< seed value for permuting the problem after reading/transformation (0: no permutation) */
295 #define SCIP_DEFAULT_RANDOM_LPSEED 0 /**< random seed for LP solver, e.g. for perturbations in the simplex (0: LP default) */
296 #define SCIP_DEFAULT_RANDOM_PERMUTECONSS TRUE /**< should order of constraints be permuted (depends on permutationseed)? */
297 #define SCIP_DEFAULT_RANDOM_PERMUTEVARS FALSE /**< should order of variables be permuted (depends on permutationseed)? */
300 /* Node Selection */
301 
302 #define SCIP_DEFAULT_NODESEL_CHILDSEL 'h' /**< child selection rule ('d'own, 'u'p, 'p'seudo costs, 'i'nference, 'l'p value,
303  * 'r'oot LP value difference, 'h'brid inference/root LP value difference) */
304 
305 
306 /* Presolving */
307 
308 #define SCIP_DEFAULT_PRESOL_ABORTFAC 8e-04 /**< abort presolve, if at most this fraction of the problem was changed
309  * in last presolve round */
310 #define SCIP_DEFAULT_PRESOL_MAXROUNDS -1 /**< maximal number of presolving rounds (-1: unlimited, 0: off) */
311 #define SCIP_DEFAULT_PRESOL_MAXRESTARTS -1 /**< maximal number of restarts (-1: unlimited) */
312 #define SCIP_DEFAULT_PRESOL_RESTARTFAC 0.025 /**< fraction of integer variables that were fixed in the root node
313  * triggering a restart with preprocessing after root node evaluation */
314 #define SCIP_DEFAULT_PRESOL_IMMRESTARTFAC 0.10 /**< fraction of integer variables that were fixed in the root node triggering an
315  * immediate restart with preprocessing */
316 #define SCIP_DEFAULT_PRESOL_SUBRESTARTFAC 1.00 /**< fraction of integer variables that were globally fixed during the
317  * solving process triggering a restart with preprocessing */
318 #define SCIP_DEFAULT_PRESOL_RESTARTMINRED 0.10 /**< minimal fraction of integer variables removed after restart to allow
319  * for an additional restart */
320 #define SCIP_DEFAULT_PRESOL_DONOTMULTAGGR FALSE /**< should multi-aggregation of variables be forbidden? */
321 #define SCIP_DEFAULT_PRESOL_DONOTAGGR FALSE /**< should aggregation of variables be forbidden? */
322 
323 
324 /* Pricing */
325 
326 #define SCIP_DEFAULT_PRICE_ABORTFAC 2.0 /**< pricing is aborted, if fac * price_maxvars pricing candidates were
327  * found */
328 #define SCIP_DEFAULT_PRICE_MAXVARS 100 /**< maximal number of variables priced in per pricing round */
329 #define SCIP_DEFAULT_PRICE_MAXVARSROOT 2000 /**< maximal number of priced variables at the root node */
330 #define SCIP_DEFAULT_PRICE_DELVARS FALSE /**< should variables created at the current node be deleted when the node is solved
331  * in case they are not present in the LP anymore? */
332 #define SCIP_DEFAULT_PRICE_DELVARSROOT FALSE /**< should variables created at the root node be deleted when the root is solved
333  * in case they are not present in the LP anymore? */
334 
335 /* Benders' decomposition */
336 #define SCIP_DEFAULT_BENDERS_SOLTOL 1e-6 /**< the tolerance used to determine optimality in Benders' decomposition */
337 #define SCIP_DEFAULT_BENDERS_CUTLPSOL TRUE /**< should Benders' cuts be generated from the LP solution? */
338 #define SCIP_DEFAULT_BENDERS_COPYBENDERS TRUE /**< should Benders' decomposition be copied for sub-SCIPs? */
339 
340 /* Reoptimization */
341 
342 #define SCIP_DEFAULT_REOPT_OBJSIMSOL -1.0 /**< re-use stored solutions only if the similarity of the new and the old objective
343  function is greater or equal than this value */
344 #define SCIP_DEFAULT_REOPT_OBJSIMROOTLP 0.8 /**< similarity of two sequential objective function to disable solving the root LP. */
345 #define SCIP_DEFAULT_REOPT_OBJSIMDELAY -1.0 /**< start reoptimizing the search if the new objective function has similarity of
346  * at least SCIP_DEFAULT_REOPT_DELAY w.r.t. the previous objective function. */
347 #define SCIP_DEFAULT_REOPT_VARORDERINTERDICTION 'd' /** use 'd'efault, 'r'andom or 'i'nference score for variable
348  * ordering when performing interdiction branching during
349  * reoptimization of nodes
350  */
351 #define SCIP_DEFAULT_REOPT_MAXSAVEDNODES INT_MAX/**< maximum number of saved nodes */
352 #define SCIP_DEFAULT_REOPT_MAXDIFFOFNODES INT_MAX/**< maximum number of bound changes of two ancestor nodes
353  * such that the path get not shrunk */
354 #define SCIP_DEFAULT_REOPT_FORCEHEURRESTART 3 /**< force a restart if the last n optimal solutions are found by
355  * reoptsols heuristic
356  */
357 #define SCIP_DEFAULT_REOPT_SAVESOLS INT_MAX/**< save n best solutions found so far. */
358 #define SCIP_DEFAULT_REOPT_SOLVELP 1 /**< strategy for solving the LP at nodes from reoptimization */
359 #define SCIP_DEFAULT_REOPT_SOLVELPDIFF 1 /**< difference of path length between two ancestor nodes to solve the LP */
360 #define SCIP_DEFAULT_REOPT_ENABLE FALSE /**< enable reoptimization */
361 #define SCIP_DEFAULT_REOPT_SEPAGLBINFSUBTREES TRUE/**< save global constraints to separate infeasible subtrees */
362 #define SCIP_DEFAULT_REOPT_SEPABESTSOL FALSE /**< separate the optimal solution, e.g., for solving constraint shortest
363  * path problems
364  */
365 #define SCIP_DEFAULT_REOPT_STOREVARHISTOTY FALSE/**< use the variable history of the previous solve if the objective
366  * function has changed only slightly
367  */
368 #define SCIP_DEFAULT_REOPT_USEPSCOST FALSE /**< re-use pseudo costs of the objective function changed only slightly */
369 #define SCIP_DEFAULT_REOPT_COMMONTIMELIMIT FALSE/**< is the given time limit for all reoptimization round? */
370 #define SCIP_DEFAULT_REOPT_SHRINKINNER TRUE /**< replace branched transit nodes by their child nodes, if the number
371  * of bound changes is not to large
372  */
373 #define SCIP_DEFAULT_REOPT_STRONGBRANCHINIT TRUE/**< try to fix variables before reoptimizing by probing like strong
374  * branching
375  */
376 #define SCIP_DEFAULT_REOPT_REDUCETOFRONTIER TRUE/**< delete stored nodes which were not reoptimized */
377 #define SCIP_DEFAULT_REOPT_SAVECONSPROP FALSE/**< save constraint propagation */
378 #define SCIP_DEFAULT_REOPT_USESPLITCONS TRUE /**< use constraints to reconstruct the subtree pruned be dual reduction
379  * when reactivating the node
380  */
381 #define SCIP_DEFAULT_REOPT_USECUTS FALSE /**< reoptimize cuts found at the root node */
382 #define SCIP_DEFAULT_REOPT_MAXCUTAGE 0 /**< maximal age of a cut to be use for reoptimization */
383 
384 /* Propagating */
385 
386 #define SCIP_DEFAULT_PROP_MAXROUNDS 100 /**< maximal number of propagation rounds per node (-1: unlimited) */
387 #define SCIP_DEFAULT_PROP_MAXROUNDSROOT 1000 /**< maximal number of propagation rounds in root node (-1: unlimited) */
388 #define SCIP_DEFAULT_PROP_ABORTONCUTOFF TRUE /**< should propagation be aborted immediately? setting this to FALSE could
389  * help conflict analysis to produce more conflict constraints */
391 
392 /* Separation */
394 #define SCIP_DEFAULT_SEPA_MAXBOUNDDIST 1.0 /**< maximal relative distance from current node's dual bound to primal
395  * bound compared to best node's dual bound for applying separation
396  * (0.0: only on current best node, 1.0: on all nodes) */
397 #define SCIP_DEFAULT_SEPA_MAXLOCALBOUNDDIST 0.0 /**< maximal relative distance from current node's dual bound to primal
398  * bound compared to best node's dual bound for applying local separation
399  * (0.0: only on current best node, 1.0: on all nodes) */
400 #define SCIP_DEFAULT_SEPA_MAXCOEFRATIO 1e+4 /**< maximal ratio between coefficients in strongcg, cmir, and flowcover cuts */
401 #define SCIP_DEFAULT_SEPA_MINEFFICACY 1e-4 /**< minimal efficacy for a cut to enter the LP */
402 #define SCIP_DEFAULT_SEPA_MINEFFICACYROOT 1e-4 /**< minimal efficacy for a cut to enter the LP in the root node */
403 #define SCIP_DEFAULT_SEPA_MINORTHO 0.90 /**< minimal orthogonality for a cut to enter the LP */
404 #define SCIP_DEFAULT_SEPA_MINORTHOROOT 0.90 /**< minimal orthogonality for a cut to enter the LP in the root node */
405 #define SCIP_DEFAULT_SEPA_OBJPARALFAC 0.1 /**< factor to scale objective parallelism of cut in score calculation */
406 #define SCIP_DEFAULT_SEPA_DIRCUTOFFDISTFAC 0.5 /**< factor to scale directed cutoff distance of cut in score calculation */
407 #define SCIP_DEFAULT_SEPA_EFFICACYFAC 1.0 /**< factor to scale efficacy of cut in score calculation */
408 #define SCIP_DEFAULT_SEPA_INTSUPPORTFAC 0.1 /**< factor to scale integral support of cut in score calculation */
409 #define SCIP_DEFAULT_SEPA_ORTHOFUNC 'e' /**< function used for calc. scalar prod. in orthogonality test ('e'uclidean, 'd'iscrete) */
410 #define SCIP_DEFAULT_SEPA_EFFICACYNORM 'e' /**< row norm to use for efficacy calculation ('e'uclidean, 'm'aximum,
411  * 's'um, 'd'iscrete) */
412 #define SCIP_DEFAULT_SEPA_CUTSELRESTART 'a' /**< cut selection during restart ('a'ge, activity 'q'uotient) */
413 #define SCIP_DEFAULT_SEPA_CUTSELSUBSCIP 'a' /**< cut selection for sub SCIPs ('a'ge, activity 'q'uotient) */
414 #define SCIP_DEFAULT_SEPA_MAXRUNS -1 /**< maximal number of runs for which separation is enabled (-1: unlimited) */
415 #define SCIP_DEFAULT_SEPA_MAXROUNDS -1 /**< maximal number of separation rounds per node (-1: unlimited) */
416 #define SCIP_DEFAULT_SEPA_MAXROUNDSROOT -1 /**< maximal number of separation rounds in the root node (-1: unlimited) */
417 #define SCIP_DEFAULT_SEPA_MAXROUNDSROOTSUBRUN -1 /**< maximal number of separation rounds in the root node of a subsequent run (-1: unlimited) */
418 #define SCIP_DEFAULT_SEPA_MAXADDROUNDS 1 /**< maximal additional number of separation rounds in subsequent
419  * price-and-cut loops (-1: no additional restriction) */
420 #define SCIP_DEFAULT_SEPA_MAXSTALLROUNDSROOT 10 /**< maximal number of consecutive separation rounds without objective
421  * or integrality improvement in the root node (-1: no additional restriction) */
422 #define SCIP_DEFAULT_SEPA_MAXSTALLROUNDS 1 /**< maximal number of consecutive separation rounds without objective
423  * or integrality improvement in local nodes (-1: no additional restriction) */
424 #define SCIP_DEFAULT_SEPA_MAXCUTS 100 /**< maximal number of cuts separated per separation round */
425 #define SCIP_DEFAULT_SEPA_MAXCUTSROOT 2000 /**< maximal separated cuts at the root node */
426 #define SCIP_DEFAULT_SEPA_CUTAGELIMIT 80 /**< maximum age a cut can reach before it is deleted from global cut pool
427  * (-1: cuts are never deleted from the global cut pool) */
428 #define SCIP_DEFAULT_SEPA_POOLFREQ 10 /**< separation frequency for the global cut pool */
429 #define SCIP_DEFAULT_SEPA_MINACTIVITYQUOT 0.8 /**< minimum cut activity quotient to convert cuts into constraints
430  * during a restart (0.0: all cuts are converted) */
431 
432 /* Parallel */
433 #define SCIP_DEFAULT_PARALLEL_MODE 1 /**< the mode for the parallel implementation. Either 0: opportunistic or
434  * 1: deterministic */
435 #define SCIP_DEFAULT_PARALLEL_MINNTHREADS 1 /**< the minimum number of threads used in parallel code */
436 #define SCIP_DEFAULT_PARALLEL_MAXNTHREADS 8 /**< the maximum number of threads used in parallel code */
437 
438 /* Concurrent solvers */
439 #define SCIP_DEFAULT_CONCURRENT_CHANGESEEDS TRUE /**< should the concurrent solvers use different random seeds? */
440 #define SCIP_DEFAULT_CONCURRENT_CHANGECHILDSEL TRUE /**< should the concurrent solvers use different child selection rules? */
441 #define SCIP_DEFAULT_CONCURRENT_COMMVARBNDS TRUE /**< should the concurrent solvers communicate variable bounds? */
442 #define SCIP_DEFAULT_CONCURRENT_PRESOLVEBEFORE TRUE /**< should the problem be presolved before it is copied to the concurrent solvers? */
443 #define SCIP_DEFAULT_CONCURRENT_INITSEED 5131912 /**< the seed used to initialize the random seeds for the concurrent solvers */
444 #define SCIP_DEFAULT_CONCURRENT_FREQINIT 10.0 /**< initial frequency of synchronization with other threads
445  * (fraction of time required for solving the root LP) */
446 #define SCIP_DEFAULT_CONCURRENT_FREQMAX 10.0 /**< maximal frequency of synchronization with other threads
447  * (fraction of time required for solving the root LP) */
448 #define SCIP_DEFAULT_CONCURRENT_FREQFACTOR 1.5 /**< factor by which the frequency of synchronization is changed */
449 #define SCIP_DEFAULT_CONCURRENT_TARGETPROGRESS 0.001 /**< when adapting the synchronization frequency this value is the targeted
450  * relative difference by which the absolute gap decreases per synchronization */
451 #define SCIP_DEFAULT_CONCURRENT_MAXNSOLS 3 /**< maximum number of solutions that will be shared in a single synchronization */
452 #define SCIP_DEFAULT_CONCURRENT_MAXNSYNCDELAY 7 /**< maximum number of synchronizations before reading is enforced regardless of delay */
453 #define SCIP_DEFAULT_CONCURRENT_MINSYNCDELAY 10.0 /**< minimum delay before synchronization data is read */
454 #define SCIP_DEFAULT_CONCURRENT_NBESTSOLS 10 /**< how many of the N best solutions should be considered for synchronization */
455 #define SCIP_DEFAULT_CONCURRENT_PARAMSETPREFIX "" /**< path prefix for parameter setting files of concurrent solvers */
456 
457 
458 /* Timing */
460 #define SCIP_DEFAULT_TIME_CLOCKTYPE SCIP_CLOCKTYPE_WALL /**< default clock type for timing */
461 #define SCIP_DEFAULT_TIME_ENABLED TRUE /**< is timing enabled? */
462 #define SCIP_DEFAULT_TIME_READING FALSE /**< belongs reading time to solving time? */
463 #define SCIP_DEFAULT_TIME_RARECLOCKCHECK FALSE /**< should clock checks of solving time be performed less frequently (might exceed time limit slightly) */
464 #define SCIP_DEFAULT_TIME_STATISTICTIMING TRUE /**< should timing for statistic output be enabled? */
467 /* visualization output */
469 #define SCIP_DEFAULT_VISUAL_VBCFILENAME "-" /**< name of the VBC tool output file, or "-" if no VBC tool output should be created */
470 #define SCIP_DEFAULT_VISUAL_BAKFILENAME "-" /**< name of the BAK tool output file, or "-" if no BAK tool output should be created */
471 #define SCIP_DEFAULT_VISUAL_REALTIME TRUE /**< should the real solving time be used instead of a time step counter in visualization? */
472 #define SCIP_DEFAULT_VISUAL_DISPSOLS FALSE /**< should the node where solutions are found be visualized? */
473 #define SCIP_DEFAULT_VISUAL_DISPLB FALSE /**< should lower bound information be visualized? */
474 #define SCIP_DEFAULT_VISUAL_OBJEXTERN TRUE /**< should be output the external value of the objective? */
475 
476 
477 /* Reading */
479 #define SCIP_DEFAULT_READ_INITIALCONSS TRUE /**< should model constraints be marked as initial? */
480 #define SCIP_DEFAULT_READ_DYNAMICCONSS TRUE /**< should model constraints be subject to aging? */
481 #define SCIP_DEFAULT_READ_DYNAMICCOLS FALSE /**< should columns be added and removed dynamically to the LP? */
482 #define SCIP_DEFAULT_READ_DYNAMICROWS FALSE /**< should rows be added and removed dynamically to the LP? */
483 #define SCIP_DEFAULT_WRITE_GENNAMES_OFFSET 0 /**< when writing the problem with generic names, we start with index
484  * 0; using this parameter we can change the starting index to be
485  * different */
487 
488 /* Writing */
490 #define SCIP_DEFAULT_WRITE_ALLCONSS FALSE /**< should all constraints be written (including the redundant constraints)? */
491 #define SCIP_DEFAULT_PRINTZEROS FALSE /**< should variables set to zero be printed? */
495 /** calculate memory size for dynamically allocated arrays */
496 static
498  int initsize, /**< initial size of array */
499  SCIP_Real growfac, /**< growing factor of array */
500  int num /**< minimum number of entries to store */
501  )
502 {
503  int size;
504 
505  assert(initsize >= 0);
506  assert(growfac >= 1.0);
507  assert(num >= 0);
508 
509  if( growfac == 1.0 )
510  size = MAX(initsize, num);
511  else
512  {
513  int oldsize;
515  /* calculate the size with this loop, such that the resulting numbers are always the same (-> block memory) */
516  initsize = MAX(initsize, 4);
517  size = initsize;
518  oldsize = size - 1;
519 
520  /* second condition checks against overflow */
521  while( size < num && size > oldsize )
522  {
523  oldsize = size;
524  size = (int)(growfac * size + initsize);
525  }
527  /* if an overflow happened, set the correct value */
528  if( size <= oldsize )
529  size = num;
530  }
531 
532  assert(size >= initsize);
533  assert(size >= num);
535  return size;
536 }
539 /** information method for a parameter change of feastol */
540 static
541 SCIP_DECL_PARAMCHGD(paramChgdFeastol)
542 { /*lint --e{715}*/
543  SCIP_Real newfeastol;
545  newfeastol = SCIPparamGetReal(param);
547  /* change the feastol through the SCIP call in order to adjust lpfeastol if necessary */
548  SCIP_CALL( SCIPchgFeastol(scip, newfeastol) );
549 
550  return SCIP_OKAY;
551 }
552 
553 /** information method for a parameter change of lpfeastol */
554 static
555 SCIP_DECL_PARAMCHGD(paramChgdLpfeastol)
556 { /*lint --e{715}*/
557  SCIP_Real newlpfeastol;
558 
559  newlpfeastol = SCIPparamGetReal(param);
560 
561  /* change the lpfeastol through the SCIP call in order to mark the LP unsolved and control that it does not exceed
562  * SCIP's feastol
563  */
564  SCIP_CALL( SCIPchgLpfeastol(scip, newlpfeastol, FALSE) );
565 
566  return SCIP_OKAY;
567 }
568 
569 /** information method for a parameter change of dualfeastol */
570 static
571 SCIP_DECL_PARAMCHGD(paramChgdDualfeastol)
572 { /*lint --e{715}*/
573  SCIP_Real newdualfeastol;
574 
575  newdualfeastol = SCIPparamGetReal(param);
576 
577  /* change the dualfeastol through the SCIP call in order to mark the LP unsolved */
578  SCIP_CALL( SCIPchgDualfeastol(scip, newdualfeastol) );
579 
580  return SCIP_OKAY;
581 }
582 
583 /** information method for a parameter change of barrierconvtol */
584 static
585 SCIP_DECL_PARAMCHGD(paramChgdBarrierconvtol)
586 { /*lint --e{715}*/
587  SCIP_Real newbarrierconvtol;
588 
589  newbarrierconvtol = SCIPparamGetReal(param);
590 
591  /* change the barrierconvtol through the SCIP call in order to mark the LP unsolved */
592  SCIP_CALL( SCIPchgBarrierconvtol(scip, newbarrierconvtol) );
593 
594  return SCIP_OKAY;
595 }
596 
597 /** information method for a parameter change of infinity value */
598 static
599 SCIP_DECL_PARAMCHGD(paramChgInfinity)
600 { /*lint --e{715}*/
602 
603  infinity = SCIPparamGetReal(param);
604 
605  /* Check that infinity value of LP-solver is at least as large as the one used in SCIP. This is necessary, because we
606  * transfer SCIP infinity values to the ones by the LPI, but not the converse. */
607  if ( scip->lp != NULL && scip->lp->lpi != NULL && infinity > SCIPlpiInfinity(scip->lp->lpi) )
608  {
609  SCIPerrorMessage("The infinity value of the LP solver has to be at least as large as the one of SCIP.\n");
610  return SCIP_PARAMETERWRONGVAL;
611  }
612 
613  return SCIP_OKAY;
614 }
615 
616 /** parameter change information method to autoselect display columns again */
617 static
618 SCIP_DECL_PARAMCHGD(SCIPparamChgdDispWidth)
619 { /*lint --e{715}*/
620  /* automatically select the new active display columns */
622 
623  return SCIP_OKAY;
624 }
625 
626 /** parameter change information method that some limit was changed */
627 static
628 SCIP_DECL_PARAMCHGD(SCIPparamChgdLimit)
629 { /*lint --e{715}*/
631  return SCIP_OKAY;
632 }
633 
634 /** information method for a parameter change of mem_arraygrowfac */
635 static
636 SCIP_DECL_PARAMCHGD(paramChgdArraygrowfac)
637 { /*lint --e{715}*/
638  SCIP_Real newarraygrowfac;
639 
640  newarraygrowfac = SCIPparamGetReal(param);
641 
642  /* change arraygrowfac */
645 
646  return SCIP_OKAY;
647 }
648 
649 /** information method for a parameter change of mem_arraygrowinit */
650 static
651 SCIP_DECL_PARAMCHGD(paramChgdArraygrowinit)
652 { /*lint --e{715}*/
653  int newarraygrowinit;
654 
655  newarraygrowinit = SCIPparamGetInt(param);
656 
657  /* change arraygrowinit */
658  BMSsetBufferMemoryArraygrowinit(SCIPbuffer(scip), newarraygrowinit);
660 
661  return SCIP_OKAY;
662 }
663 
664 /** information method for a parameter change of reopt_enable */
665 static
666 SCIP_DECL_PARAMCHGD(paramChgdEnableReopt)
667 { /*lint --e{715}*/
668  assert( scip != NULL );
669  assert( param != NULL );
670 
671  /* create or deconstruct the reoptimization data structures */
673 
674  return SCIP_OKAY;
675 }
676 
677 /** information method for a parameter change of usesymmetry */
678 static
679 SCIP_DECL_PARAMCHGD(paramChgdUsesymmetry)
680 { /*lint --e{715}*/
681  assert( scip != NULL );
682  assert( param != NULL );
683 
685  {
686  if ( SCIPparamGetInt(param) > 0 )
687  {
688  SCIPerrorMessage("Cannot turn on symmetry handling during (pre)solving.\n");
689  }
690  }
691 
692  return SCIP_OKAY;
693 }
695 /** set parameters for reoptimization */
697  SCIP_SET* set, /**< SCIP data structure */
698  SCIP_MESSAGEHDLR* messagehdlr /**< message handler */
699  )
700 {
701  assert(set != NULL);
702  assert(messagehdlr != NULL);
703 
704  if( set->reopt_enable )
705  {
706  /* disable some parts of conflict analysis */
707  SCIP_CALL( SCIPsetSetCharParam(set, messagehdlr, "conflict/useboundlp", 'o') );
708  SCIP_CALL( SCIPsetSetBoolParam(set, messagehdlr, "conflict/usepseudo", FALSE) );
709 
710  /* TODO check wheather multi aggregation can be enabled in reoptimization */
711  if( SCIPsetIsParamFixed(set, "presolving/donotmultaggr") )
712  {
713  SCIP_CALL( SCIPsetChgParamFixed(set, "presolving/donotmultaggr", FALSE) );
714  }
715  SCIP_CALL( SCIPsetSetBoolParam(set, messagehdlr, "presolving/donotmultaggr", TRUE) );
716 
717  if( SCIPsetIsParamFixed(set, "branching/nodereopt/priority") )
718  {
719  SCIP_CALL( SCIPsetChgParamFixed(set, "branching/nodereopt/priority", FALSE) );
720  }
721  SCIP_CALL( SCIPsetSetIntParam(set, messagehdlr, "branching/nodereopt/priority", INT_MAX/4) );
722  }
723  else
724  {
725  /* disable conflict analysis */
726  if( SCIPsetIsParamFixed(set, "conflict/enable") )
727  {
728  SCIP_CALL( SCIPsetChgParamFixed(set, "conflict/enable", FALSE) );
729  }
730  SCIP_CALL( SCIPsetResetParam(set, messagehdlr, "conflict/enable") );
731 
732  /* TODO check wheather multi aggregation can be enabled in reoptimization */
733  if( SCIPsetIsParamFixed(set, "presolving/donotmultaggr") )
734  {
735  SCIP_CALL( SCIPsetChgParamFixed(set, "presolving/donotmultaggr", FALSE) );
736  }
737  SCIP_CALL( SCIPsetResetParam(set, messagehdlr, "presolving/donotmultaggr") );
738 
739  /* set priority to defeault */
740  if( SCIPsetFindBranchrule(set, "nodereopt") != NULL )
741  {
742  if( SCIPsetIsParamFixed(set, "branching/nodereopt/priority") )
743  {
744  SCIP_CALL( SCIPsetChgParamFixed(set, "branching/nodereopt/priority", FALSE) );
745  }
746  SCIP_CALL( SCIPsetResetParam(set, messagehdlr, "branching/nodereopt/priority") );
747  }
748  }
749 
750  return SCIP_OKAY;
751 }
752 
753 /** enable or disable all plugin timers depending on the value of the flag \p enabled */
755  SCIP_SET* set, /**< SCIP settings */
756  SCIP_Bool enabled /**< should plugin clocks be enabled? */
757  )
758 {
759  int i;
760 
761  assert(set != NULL);
762 
763  /* go through all plugin types and enable or disable their respective clocks */
764  for( i = set->nreaders - 1; i >= 0; --i )
765  SCIPreaderEnableOrDisableClocks(set->readers[i], enabled);
766 
767  for( i = set->npricers - 1; i >= 0; --i )
768  SCIPpricerEnableOrDisableClocks(set->pricers[i], enabled);
769 
770  for( i = set->nconshdlrs - 1; i >= 0; --i )
771  SCIPconshdlrEnableOrDisableClocks(set->conshdlrs[i], enabled);
773  for( i = set->nconflicthdlrs - 1; i >= 0; --i )
774  SCIPconflicthdlrEnableOrDisableClocks(set->conflicthdlrs[i], enabled);
775 
776  for( i = set->npresols - 1; i >= 0; --i )
777  SCIPpresolEnableOrDisableClocks(set->presols[i], enabled);
778 
779  for( i = set->nrelaxs - 1; i >= 0; --i )
780  SCIPrelaxEnableOrDisableClocks(set->relaxs[i], enabled);
781 
782  for( i = set->nsepas - 1; i >= 0; --i )
783  SCIPsepaEnableOrDisableClocks(set->sepas[i], enabled);
784 
785  for( i = set->nprops - 1; i >= 0; --i )
786  SCIPpropEnableOrDisableClocks(set->props[i], enabled);
787 
788  for( i = set->nheurs - 1; i >= 0; --i )
789  SCIPheurEnableOrDisableClocks(set->heurs[i], enabled);
790 
791  for( i = set->neventhdlrs - 1; i >= 0; --i )
792  SCIPeventhdlrEnableOrDisableClocks(set->eventhdlrs[i], enabled);
793 
794  for( i = set->nnodesels - 1; i >= 0; --i )
795  SCIPnodeselEnableOrDisableClocks(set->nodesels[i], enabled);
796 
797  for( i = set->nbranchrules - 1; i >= 0; --i )
798  SCIPbranchruleEnableOrDisableClocks(set->branchrules[i], enabled);
799 }
800 
801 /* method to be invoked when the parameter timing/statistictiming is changed */
802 static
803 SCIP_DECL_PARAMCHGD(paramChgdStatistictiming)
804 { /*lint --e{715}*/
806 
807  return SCIP_OKAY;
808 }
809 
810 /** copies plugins from sourcescip to targetscip; in case that a constraint handler which does not need constraints
811  * cannot be copied, valid will return FALSE. All plugins can declare that, if their copy process failed, the
812  * copied SCIP instance might not represent the same problem semantics as the original.
813  * Note that in this case dual reductions might be invalid. */
815  SCIP_SET* sourceset, /**< source SCIP_SET data structure */
816  SCIP_SET* targetset, /**< target SCIP_SET data structure */
817  SCIP_Bool copyreaders, /**< should the file readers be copied */
818  SCIP_Bool copypricers, /**< should the variable pricers be copied */
819  SCIP_Bool copyconshdlrs, /**< should the constraint handlers be copied */
820  SCIP_Bool copyconflicthdlrs, /**< should the conflict handlers be copied */
821  SCIP_Bool copypresolvers, /**< should the presolvers be copied */
822  SCIP_Bool copyrelaxators, /**< should the relaxators be copied */
823  SCIP_Bool copyseparators, /**< should the separators be copied */
824  SCIP_Bool copypropagators, /**< should the propagators be copied */
825  SCIP_Bool copyheuristics, /**< should the heuristics be copied */
826  SCIP_Bool copyeventhdlrs, /**< should the event handlers be copied */
827  SCIP_Bool copynodeselectors, /**< should the node selectors be copied */
828  SCIP_Bool copybranchrules, /**< should the branchrules be copied */
829  SCIP_Bool copydisplays, /**< should the display columns be copied */
830  SCIP_Bool copydialogs, /**< should the dialogs be copied */
831  SCIP_Bool copytables, /**< should the statistics tables be copied */
832  SCIP_Bool copynlpis, /**< should the NLP interfaces be copied */
833  SCIP_Bool* allvalid /**< pointer to store whether all plugins were validly copied */
834  )
835 {
836  int p;
837  SCIP_Bool valid;
838 
839  assert(sourceset != NULL);
840  assert(targetset != NULL);
841  assert(sourceset != targetset);
842  assert(allvalid != NULL);
843 
844  *allvalid = TRUE;
845 
846  /* copy all reader plugins */
847  if( copyreaders && sourceset->readers != NULL )
848  {
849  for( p = sourceset->nreaders - 1; p >= 0; --p )
850  {
851  SCIP_CALL( SCIPreaderCopyInclude(sourceset->readers[p], targetset) );
852  }
853  }
854 
855  /* copy all variable pricer plugins */
856  if( copypricers && sourceset->pricers != NULL )
857  {
858  for( p = sourceset->npricers - 1; p >= 0; --p )
859  {
860  valid = FALSE;
861  SCIP_CALL( SCIPpricerCopyInclude(sourceset->pricers[p], targetset, &valid) );
862  *allvalid = *allvalid && valid;
863  if( SCIPpricerIsActive(sourceset->pricers[p]) )
864  {
865  SCIP_CALL( SCIPactivatePricer(targetset->scip, targetset->pricers[p]) );
866  }
867  }
868  }
869 
870  /* copy all constraint handler plugins */
871  if( copyconshdlrs && sourceset->conshdlrs_include != NULL )
872  {
873  /* copy them in order they were added to the sourcescip
874  *
875  * @note we only have to set the valid pointer to FALSE in case that a constraint handler, which does not need
876  * constraints, does not copy; in the case that a constraint handler does not copy and it needs constraint
877  * we will detect later that the problem is not valid if a constraint of that type exits
878  */
879  for( p = 0; p < sourceset->nconshdlrs; ++p )
880  {
881  if( SCIPconshdlrIsClonable(sourceset->conshdlrs_include[p]) )
882  {
883  valid = FALSE;
884  SCIP_CALL( SCIPconshdlrCopyInclude(sourceset->conshdlrs_include[p], targetset, &valid) );
885  *allvalid = *allvalid && valid;
886  SCIPsetDebugMsg(sourceset, "Copying conshdlr <%s> was%s valid.\n", SCIPconshdlrGetName(sourceset->conshdlrs_include[p]), valid ? "" : " not");
887  }
888  else if( !SCIPconshdlrNeedsCons(sourceset->conshdlrs_include[p]) )
889  {
890  SCIPsetDebugMsg(sourceset, "Copying Conshdlr <%s> without constraints not valid.\n", SCIPconshdlrGetName(sourceset->conshdlrs_include[p]));
891  *allvalid = FALSE;
892  }
893  }
894  }
895 
896  /* copy all conflict handler plugins */
897  if( copyconflicthdlrs && sourceset->conflicthdlrs != NULL )
898  {
899  for( p = sourceset->nconflicthdlrs - 1; p >= 0; --p )
900  {
901  SCIP_CALL( SCIPconflicthdlrCopyInclude(sourceset->conflicthdlrs[p], targetset) );
902  }
903  }
904 
905  /* copy all presolver plugins */
906  if( copypresolvers && sourceset->presols != NULL )
907  {
908  for( p = sourceset->npresols - 1; p >= 0; --p )
909  {
910  SCIP_CALL( SCIPpresolCopyInclude(sourceset->presols[p], targetset) );
911  }
912  }
913 
914  /* copy all relaxator plugins */
915  if( copyrelaxators && sourceset->relaxs != NULL )
916  {
917  for( p = sourceset->nrelaxs - 1; p >= 0; --p )
918  {
919  SCIP_CALL( SCIPrelaxCopyInclude(sourceset->relaxs[p], targetset) );
920  }
921  }
922 
923  /* copy all separator plugins */
924  if( copyseparators && sourceset->sepas != NULL )
925  {
926  for( p = sourceset->nsepas - 1; p >= 0; --p )
927  {
928  SCIP_CALL( SCIPsepaCopyInclude(sourceset->sepas[p], targetset) );
929  }
930  }
931 
932  /* copy all propagators plugins */
933  if( copypropagators && sourceset->props != NULL )
934  {
935  for( p = sourceset->nprops - 1; p >= 0; --p )
936  {
937  SCIP_CALL( SCIPpropCopyInclude(sourceset->props[p], targetset) );
938  }
939  }
940 
941  /* copy all primal heuristics plugins */
942  if( copyheuristics && sourceset->heurs != NULL )
943  {
944  for( p = sourceset->nheurs - 1; p >= 0; --p )
945  {
946  SCIP_CALL( SCIPheurCopyInclude(sourceset->heurs[p], targetset) );
947  }
948  }
949 
950  /* copy all event handler plugins */
951  if( copyeventhdlrs && sourceset->eventhdlrs != NULL )
952  {
953  for( p = sourceset->neventhdlrs - 1; p >= 0; --p )
954  {
955  /* @todo: the copying process of event handlers is currently not checked for consistency */
956  SCIP_CALL( SCIPeventhdlrCopyInclude(sourceset->eventhdlrs[p], targetset) );
957  }
958  }
959 
960  /* copy all node selector plugins */
961  if( copynodeselectors && sourceset->nodesels != NULL )
962  {
963  for( p = sourceset->nnodesels - 1; p >= 0; --p )
964  {
965  SCIP_CALL( SCIPnodeselCopyInclude(sourceset->nodesels[p], targetset) );
966  }
967  }
968 
969  /* copy all branchrule plugins */
970  if( copybranchrules && sourceset->branchrules != NULL )
971  {
972  for( p = sourceset->nbranchrules - 1; p >= 0; --p )
973  {
974  SCIP_CALL( SCIPbranchruleCopyInclude(sourceset->branchrules[p], targetset) );
975  }
976  }
977 
978  /* copy all display plugins */
979  if( copydisplays && sourceset->disps != NULL )
980  {
981  for( p = sourceset->ndisps - 1; p >= 0; --p )
982  {
983  SCIP_CALL( SCIPdispCopyInclude(sourceset->disps[p], targetset) );
984  }
985  }
986 
987  /* copy all dialog plugins */
988  if( copydialogs && sourceset->dialogs != NULL )
989  {
990  for( p = sourceset->ndialogs - 1; p >= 0; --p )
991  {
992  /* @todo: the copying process of dialog handlers is currently not checked for consistency */
993  SCIP_CALL( SCIPdialogCopyInclude(sourceset->dialogs[p], targetset) );
994  }
995  }
996 
997  /* copy all table plugins */
998  if( copytables && sourceset->tables != NULL )
999  {
1000  for( p = sourceset->ntables - 1; p >= 0; --p )
1001  {
1002  SCIP_CALL( SCIPtableCopyInclude(sourceset->tables[p], targetset) );
1003  }
1004  }
1005 
1006  /* copy all NLP interfaces */
1007  if( copynlpis && sourceset->nlpis != NULL )
1008  {
1009  for( p = sourceset->nnlpis - 1; p >= 0; --p )
1010  {
1011  SCIP_NLPI* nlpicopy;
1012 
1013  SCIP_CALL_FINALLY( SCIPnlpiCopy(SCIPblkmem(targetset->scip), sourceset->nlpis[p], &nlpicopy), (void)SCIPnlpiFree(&nlpicopy) );
1014  SCIP_CALL( SCIPincludeNlpi(targetset->scip, nlpicopy) );
1015  }
1016  }
1017 
1018  return SCIP_OKAY;
1019 }
1020 
1021 
1022 /** copies parameters from sourcescip to targetscip */
1024  SCIP_SET* sourceset, /**< source SCIP_SET data structure */
1025  SCIP_SET* targetset, /**< target SCIP_SET data structure */
1026  SCIP_MESSAGEHDLR* messagehdlr /**< message handler of target SCIP */
1027  )
1028 {
1029  assert(sourceset != NULL);
1030  assert(targetset != NULL);
1031  assert(sourceset != targetset);
1032  assert(targetset->scip != NULL);
1033 
1034  SCIP_CALL( SCIPparamsetCopyParams(sourceset->paramset, targetset->paramset, targetset, messagehdlr) );
1035 
1036  return SCIP_OKAY;
1037 }
1038 
1039 /** creates global SCIP settings */
1041  SCIP_SET** set, /**< pointer to SCIP settings */
1042  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1043  BMS_BLKMEM* blkmem, /**< block memory */
1044  SCIP* scip /**< SCIP data structure */
1045  )
1046 {
1047  assert(set != NULL);
1048  assert(scip != NULL);
1049 
1050  SCIP_ALLOC( BMSallocMemory(set) );
1051 
1052  (*set)->stage = SCIP_STAGE_INIT;
1053  (*set)->scip = scip;
1054  (*set)->buffer = SCIPbuffer(scip);
1055  (*set)->cleanbuffer = SCIPcleanbuffer(scip);
1056 
1057  SCIP_CALL( SCIPparamsetCreate(&(*set)->paramset, blkmem) );
1058 
1059  (*set)->readers = NULL;
1060  (*set)->nreaders = 0;
1061  (*set)->readerssize = 0;
1062  (*set)->pricers = NULL;
1063  (*set)->npricers = 0;
1064  (*set)->nactivepricers = 0;
1065  (*set)->pricerssize = 0;
1066  (*set)->pricerssorted = FALSE;
1067  (*set)->pricersnamesorted = FALSE;
1068  (*set)->conshdlrs = NULL;
1069  (*set)->conshdlrs_sepa = NULL;
1070  (*set)->conshdlrs_enfo = NULL;
1071  (*set)->conshdlrs_include = NULL;
1072  (*set)->nconshdlrs = 0;
1073  (*set)->conshdlrssize = 0;
1074  (*set)->conflicthdlrs = NULL;
1075  (*set)->nconflicthdlrs = 0;
1076  (*set)->conflicthdlrssize = 0;
1077  (*set)->conflicthdlrssorted = FALSE;
1078  (*set)->conflicthdlrsnamesorted = FALSE;
1079  (*set)->benders = NULL;
1080  (*set)->nbenders = 0;
1081  (*set)->nactivebenders = 0;
1082  (*set)->benderssize = 0;
1083  (*set)->benderssorted = FALSE;
1084  (*set)->bendersnamesorted = FALSE;
1085 
1086  (*set)->debugsoldata = NULL;
1087  SCIP_CALL( SCIPdebugSolDataCreate(&(*set)->debugsoldata) ); /*lint !e506 !e774*/
1088 
1089  (*set)->presols = NULL;
1090  (*set)->npresols = 0;
1091  (*set)->presolssize = 0;
1092  (*set)->presolssorted = FALSE;
1093  (*set)->presolsnamesorted = FALSE;
1094  (*set)->relaxs = NULL;
1095  (*set)->nrelaxs = 0;
1096  (*set)->relaxssize = 0;
1097  (*set)->relaxssorted = FALSE;
1098  (*set)->relaxsnamesorted = FALSE;
1099  (*set)->sepas = NULL;
1100  (*set)->nsepas = 0;
1101  (*set)->sepassize = 0;
1102  (*set)->sepassorted = FALSE;
1103  (*set)->sepasnamesorted = FALSE;
1104  (*set)->props = NULL;
1105  (*set)->props_presol = NULL;
1106  (*set)->nprops = 0;
1107  (*set)->propssize = 0;
1108  (*set)->propssorted = FALSE;
1109  (*set)->propspresolsorted = FALSE;
1110  (*set)->propsnamesorted = FALSE;
1111  (*set)->concsolvertypes = NULL;
1112  (*set)->nconcsolvertypes = 0;
1113  (*set)->concsolvertypessize = 0;
1114  (*set)->concsolvers = NULL;
1115  (*set)->nconcsolvers = 0;
1116  (*set)->concsolverssize = 0;
1117  (*set)->concurrent_paramsetprefix = NULL;
1118  (*set)->heurs = NULL;
1119  (*set)->nheurs = 0;
1120  (*set)->heurssize = 0;
1121  (*set)->heurssorted = FALSE;
1122  (*set)->heursnamesorted = FALSE;
1123  (*set)->comprs = NULL;
1124  (*set)->ncomprs = 0;
1125  (*set)->comprssize = 0;
1126  (*set)->comprssorted = FALSE;
1127  (*set)->comprsnamesorted = FALSE;
1128  (*set)->eventhdlrs = NULL;
1129  (*set)->neventhdlrs = 0;
1130  (*set)->eventhdlrssize = 0;
1131  (*set)->nodesels = NULL;
1132  (*set)->nnodesels = 0;
1133  (*set)->nodeselssize = 0;
1134  (*set)->nodesel = NULL;
1135  (*set)->branchrules = NULL;
1136  (*set)->nbranchrules = 0;
1137  (*set)->branchrulessize = 0;
1138  (*set)->branchrulessorted = FALSE;
1139  (*set)->branchrulesnamesorted = FALSE;
1140  (*set)->banditvtables = NULL;
1141  (*set)->banditvtablessize = 0;
1142  (*set)->nbanditvtables = 0;
1143  (*set)->disps = NULL;
1144  (*set)->ndisps = 0;
1145  (*set)->dispssize = 0;
1146  (*set)->tables = NULL;
1147  (*set)->ntables = 0;
1148  (*set)->tablessize = 0;
1149  (*set)->tablessorted = FALSE;
1150  (*set)->dialogs = NULL;
1151  (*set)->ndialogs = 0;
1152  (*set)->dialogssize = 0;
1153  (*set)->nlpis = NULL;
1154  (*set)->nnlpis = 0;
1155  (*set)->nlpissize = 0;
1156  (*set)->nlpissorted = FALSE;
1157  (*set)->limitchanged = FALSE;
1158  (*set)->extcodenames = NULL;
1159  (*set)->extcodedescs = NULL;
1160  (*set)->nextcodes = 0;
1161  (*set)->extcodessize = 0;
1162  (*set)->visual_vbcfilename = NULL;
1163  (*set)->visual_bakfilename = NULL;
1164  (*set)->nlp_solver = NULL;
1165  (*set)->nlp_disable = FALSE;
1166  (*set)->num_relaxfeastol = SCIP_INVALID;
1167  (*set)->misc_debugsol = NULL;
1168 
1169  /* the default time limit is infinite */
1170  (*set)->istimelimitfinite = FALSE;
1171 
1172  /* branching parameters */
1173  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
1174  "branching/scorefunc",
1175  "branching score function ('s'um, 'p'roduct, 'q'uotient)",
1176  &(*set)->branch_scorefunc, TRUE, SCIP_DEFAULT_BRANCH_SCOREFUNC, "spq",
1177  NULL, NULL) );
1178  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1179  "branching/scorefac",
1180  "branching score factor to weigh downward and upward gain prediction in sum score function",
1181  &(*set)->branch_scorefac, TRUE, SCIP_DEFAULT_BRANCH_SCOREFAC, 0.0, 1.0,
1182  NULL, NULL) );
1183  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1184  "branching/preferbinary",
1185  "should branching on binary variables be preferred?",
1186  &(*set)->branch_preferbinary, FALSE, SCIP_DEFAULT_BRANCH_PREFERBINARY,
1187  NULL, NULL) );
1188  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1189  "branching/clamp",
1190  "minimal relative distance of branching point to bounds when branching on a continuous variable",
1191  &(*set)->branch_clamp, FALSE, SCIP_DEFAULT_BRANCH_CLAMP, 0.0, 0.5,
1192  NULL, NULL) );
1193  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
1194  "branching/lpgainnormalize",
1195  "strategy for normalization of LP gain when updating pseudocosts of continuous variables (divide by movement of 'l'p value, reduction in 'd'omain width, or reduction in domain width of 's'ibling)",
1196  &(*set)->branch_lpgainnorm, FALSE, SCIP_DEFAULT_BRANCH_LPGAINNORMALIZE, "dls",
1197  NULL, NULL) );
1198  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1199  "branching/delaypscostupdate",
1200  "should updating pseudo costs for continuous variables be delayed to the time after separation?",
1201  &(*set)->branch_delaypscost, FALSE, SCIP_DEFAULT_BRANCH_DELAYPSCOST,
1202  NULL, NULL) );
1203  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1204  "branching/divingpscost",
1205  "should pseudo costs be updated also in diving and probing mode?",
1206  &(*set)->branch_divingpscost, FALSE, SCIP_DEFAULT_BRANCH_DIVINGPSCOST,
1207  NULL, NULL) );
1208  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1209  "branching/forceallchildren",
1210  "should all strong branching children be regarded even if one is detected to be infeasible? (only with propagation)",
1211  &(*set)->branch_forceall, TRUE, SCIP_DEFAULT_BRANCH_FORCEALL,
1212  NULL, NULL) );
1213  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
1214  "branching/firstsbchild",
1215  "child node to be regarded first during strong branching (only with propagation): 'u'p child, 'd'own child, 'h'istory-based, or 'a'utomatic",
1216  &(*set)->branch_firstsbchild, TRUE, SCIP_DEFAULT_BRANCH_FIRSTSBCHILD, "aduh",
1217  NULL, NULL) );
1218  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1219  "branching/checksol",
1220  "should LP solutions during strong branching with propagation be checked for feasibility?",
1221  &(*set)->branch_checksbsol, TRUE, SCIP_DEFAULT_BRANCH_CHECKSBSOL,
1222  NULL, NULL) );
1223  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1224  "branching/roundsbsol",
1225  "should LP solutions during strong branching with propagation be rounded? (only when checksbsol=TRUE)",
1226  &(*set)->branch_roundsbsol, TRUE, SCIP_DEFAULT_BRANCH_ROUNDSBSOL,
1227  NULL, NULL) );
1228  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1229  "branching/sumadjustscore",
1230  "score adjustment near zero by adding epsilon (TRUE) or using maximum (FALSE)",
1231  &(*set)->branch_sumadjustscore, TRUE, SCIP_DEFAULT_BRANCH_SUMADJUSTSCORE,
1232  NULL, NULL) );
1233 
1234  /* tree compression parameters */
1235  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1236  "compression/enable",
1237  "should automatic tree compression after the presolving be enabled?",
1238  &(*set)->compr_enable, TRUE, SCIP_DEFAULT_COMPR_ENABLE,
1239  NULL, NULL) );
1240 
1241  /* conflict analysis parameters */
1242  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1243  "conflict/enable",
1244  "should conflict analysis be enabled?",
1245  &(*set)->conf_enable, FALSE, SCIP_DEFAULT_CONF_ENABLE,
1246  NULL, NULL) );
1247  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1248  "conflict/cleanboundexceedings",
1249  "should conflicts based on an old cutoff bound be removed from the conflict pool after improving the primal bound?",
1250  &(*set)->conf_cleanbnddepend, TRUE, SCIP_DEFAULT_CONF_CLEANBNDDEPEND,
1251  NULL, NULL) );
1252  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1253  "conflict/useprop",
1254  "should propagation conflict analysis be used?",
1255  &(*set)->conf_useprop, FALSE, SCIP_DEFAULT_CONF_USEPROP,
1256  NULL, NULL) );
1257  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
1258  "conflict/useinflp",
1259  "should infeasible LP conflict analysis be used? ('o'ff, 'c'onflict graph, 'd'ual ray, 'b'oth conflict graph and dual ray)",
1260  &(*set)->conf_useinflp, FALSE, SCIP_DEFAULT_CONF_USEINFLP, "ocdb",
1261  NULL, NULL) );
1262  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
1263  "conflict/useboundlp",
1264  "should bound exceeding LP conflict analysis be used? ('o'ff, 'c'onflict graph, 'd'ual ray, 'b'oth conflict graph and dual ray)",
1265  &(*set)->conf_useboundlp, FALSE, SCIP_DEFAULT_CONF_USEBOUNDLP, "ocdb",
1266  NULL, NULL) );
1267  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1268  "conflict/usesb",
1269  "should infeasible/bound exceeding strong branching conflict analysis be used?",
1270  &(*set)->conf_usesb, FALSE, SCIP_DEFAULT_CONF_USESB,
1271  NULL, NULL) );
1272  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1273  "conflict/usepseudo",
1274  "should pseudo solution conflict analysis be used?",
1275  &(*set)->conf_usepseudo, FALSE, SCIP_DEFAULT_CONF_USEPSEUDO,
1276  NULL, NULL) );
1277  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1278  "conflict/maxvarsfac",
1279  "maximal fraction of variables involved in a conflict constraint",
1280  &(*set)->conf_maxvarsfac, TRUE, SCIP_DEFAULT_CONF_MAXVARSFAC, 0.0, SCIP_REAL_MAX,
1281  NULL, NULL) );
1282  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1283  "conflict/minmaxvars",
1284  "minimal absolute maximum of variables involved in a conflict constraint",
1285  &(*set)->conf_minmaxvars, TRUE, SCIP_DEFAULT_CONF_MINMAXVARS, 0, INT_MAX,
1286  NULL, NULL) );
1287  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1288  "conflict/maxlploops",
1289  "maximal number of LP resolving loops during conflict analysis (-1: no limit)",
1290  &(*set)->conf_maxlploops, TRUE, SCIP_DEFAULT_CONF_MAXLPLOOPS, -1, INT_MAX,
1291  NULL, NULL) );
1292  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1293  "conflict/lpiterations",
1294  "maximal number of LP iterations in each LP resolving loop (-1: no limit)",
1295  &(*set)->conf_lpiterations, TRUE, SCIP_DEFAULT_CONF_LPITERATIONS, -1, INT_MAX,
1296  NULL, NULL) );
1297  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1298  "conflict/fuiplevels",
1299  "number of depth levels up to which first UIP's are used in conflict analysis (-1: use All-FirstUIP rule)",
1300  &(*set)->conf_fuiplevels, TRUE, SCIP_DEFAULT_CONF_FUIPLEVELS, -1, INT_MAX,
1301  NULL, NULL) );
1302  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1303  "conflict/interconss",
1304  "maximal number of intermediate conflict constraints generated in conflict graph (-1: use every intermediate constraint)",
1305  &(*set)->conf_interconss, TRUE, SCIP_DEFAULT_CONF_INTERCONSS, -1, INT_MAX,
1306  NULL, NULL) );
1307  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1308  "conflict/reconvlevels",
1309  "number of depth levels up to which UIP reconvergence constraints are generated (-1: generate reconvergence constraints in all depth levels)",
1310  &(*set)->conf_reconvlevels, TRUE, SCIP_DEFAULT_CONF_RECONVLEVELS, -1, INT_MAX,
1311  NULL, NULL) );
1312  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1313  "conflict/maxconss",
1314  "maximal number of conflict constraints accepted at an infeasible node (-1: use all generated conflict constraints)",
1315  &(*set)->conf_maxconss, TRUE, SCIP_DEFAULT_CONF_MAXCONSS, -1, INT_MAX,
1316  NULL, NULL) );
1317  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1318  "conflict/maxstoresize",
1319  "maximal size of conflict store (-1: auto, 0: disable storage)",
1320  &(*set)->conf_maxstoresize, TRUE, SCIP_DEFAULT_CONF_MAXSTORESIZE, -1, INT_MAX,
1321  NULL, NULL) );
1322  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1323  "conflict/preferbinary",
1324  "should binary conflicts be preferred?",
1325  &(*set)->conf_preferbinary, FALSE, SCIP_DEFAULT_CONF_PREFERBINARY,
1326  NULL, NULL) );
1327  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1328  "conflict/prefinfproof",
1329  "prefer infeasibility proof to boundexceeding proof",
1330  &(*set)->conf_prefinfproof, TRUE, SCIP_DEFAULT_CONF_PREFINFPROOF,
1331  NULL, NULL) );
1332  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1333  "conflict/allowlocal",
1334  "should conflict constraints be generated that are only valid locally?",
1335  &(*set)->conf_allowlocal, TRUE, SCIP_DEFAULT_CONF_ALLOWLOCAL,
1336  NULL, NULL) );
1337  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1338  "conflict/settlelocal",
1339  "should conflict constraints be attached only to the local subtree where they can be useful?",
1340  &(*set)->conf_settlelocal, TRUE, SCIP_DEFAULT_CONF_SETTLELOCAL,
1341  NULL, NULL) );
1342  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1343  "conflict/repropagate",
1344  "should earlier nodes be repropagated in order to replace branching decisions by deductions?",
1345  &(*set)->conf_repropagate, TRUE, SCIP_DEFAULT_CONF_REPROPAGATE,
1346  NULL, NULL) );
1347  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1348  "conflict/keepreprop",
1349  "should constraints be kept for repropagation even if they are too long?",
1350  &(*set)->conf_keepreprop, TRUE, SCIP_DEFAULT_CONF_KEEPREPROP,
1351  NULL, NULL) );
1352  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1353  "conflict/separate",
1354  "should the conflict constraints be separated?",
1355  &(*set)->conf_separate, TRUE, SCIP_DEFAULT_CONF_SEPARATE,
1356  NULL, NULL) );
1357  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1358  "conflict/dynamic",
1359  "should the conflict constraints be subject to aging?",
1360  &(*set)->conf_dynamic, TRUE, SCIP_DEFAULT_CONF_DYNAMIC,
1361  NULL, NULL) );
1362  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1363  "conflict/removable",
1364  "should the conflict's relaxations be subject to LP aging and cleanup?",
1365  &(*set)->conf_removable, TRUE, SCIP_DEFAULT_CONF_REMOVEABLE,
1366  NULL, NULL) );
1367  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1368  "conflict/graph/depthscorefac",
1369  "score factor for depth level in bound relaxation heuristic",
1370  &(*set)->conf_depthscorefac, TRUE, SCIP_DEFAULT_CONF_DEPTHSCOREFAC, SCIP_REAL_MIN, SCIP_REAL_MAX,
1371  NULL, NULL) );
1372  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1373  "conflict/proofscorefac",
1374  "score factor for impact on acticity in bound relaxation heuristic",
1375  &(*set)->conf_proofscorefac, TRUE, SCIP_DEFAULT_CONF_PROOFSCOREFAC, SCIP_REAL_MIN, SCIP_REAL_MAX,
1376  NULL, NULL) );
1377  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1378  "conflict/uplockscorefac",
1379  "score factor for up locks in bound relaxation heuristic",
1380  &(*set)->conf_uplockscorefac, TRUE, SCIP_DEFAULT_CONF_UPLOCKSCOREFAC, SCIP_REAL_MIN, SCIP_REAL_MAX,
1381  NULL, NULL) );
1382  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1383  "conflict/downlockscorefac",
1384  "score factor for down locks in bound relaxation heuristic",
1385  &(*set)->conf_downlockscorefac, TRUE, SCIP_DEFAULT_CONF_DOWNLOCKSCOREFAC, SCIP_REAL_MIN, SCIP_REAL_MAX,
1386  NULL, NULL) );
1387  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1388  "conflict/scorefac",
1389  "factor to decrease importance of variables' earlier conflict scores",
1390  &(*set)->conf_scorefac, TRUE, SCIP_DEFAULT_CONF_SCOREFAC, 1e-6, 1.0,
1391  NULL, NULL) );
1392  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1393  "conflict/restartnum",
1394  "number of successful conflict analysis calls that trigger a restart (0: disable conflict restarts)",
1395  &(*set)->conf_restartnum, FALSE, SCIP_DEFAULT_CONF_RESTARTNUM, 0, INT_MAX,
1396  NULL, NULL) );
1397  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1398  "conflict/restartfac",
1399  "factor to increase restartnum with after each restart",
1400  &(*set)->conf_restartfac, FALSE, SCIP_DEFAULT_CONF_RESTARTFAC, 0.0, SCIP_REAL_MAX,
1401  NULL, NULL) );
1402  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1403  "conflict/ignorerelaxedbd",
1404  "should relaxed bounds be ignored?",
1405  &(*set)->conf_ignorerelaxedbd, TRUE, SCIP_DEFAULT_CONF_IGNORERELAXEDBD,
1406  NULL, NULL) );
1407  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1408  "conflict/maxvarsdetectimpliedbounds",
1409  "maximal number of variables to try to detect global bound implications and shorten the whole conflict set (0: disabled)",
1410  &(*set)->conf_maxvarsdetectimpliedbounds, TRUE, SCIP_DEFAULT_CONF_MAXVARSDETECTIMPLIEDBOUNDS, 0, INT_MAX,
1411  NULL, NULL) );
1412  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1413  "conflict/fullshortenconflict",
1414  "try to shorten the whole conflict set or terminate early (depending on the 'maxvarsdetectimpliedbounds' parameter)",
1415  &(*set)->conf_fullshortenconflict, TRUE, SCIP_DEFAULT_CONF_FULLSHORTENCONFLICT,
1416  NULL, NULL) );
1417  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1418  "conflict/conflictweight",
1419  "the weight the VSIDS score is weight by updating the VSIDS for a variable if it is part of a conflict",
1420  &(*set)->conf_conflictweight, FALSE, SCIP_DEFAULT_CONF_CONFLITWEIGHT, 0.0, 1.0,
1421  NULL, NULL) );
1422  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1423  "conflict/conflictgraphweight",
1424  "the weight the VSIDS score is weight by updating the VSIDS for a variable if it is part of a conflict graph",
1425  &(*set)->conf_conflictgraphweight, FALSE, SCIP_DEFAULT_CONF_CONFLITGRAPHWEIGHT, 0.0, 1.0,
1426  NULL, NULL) );
1427  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1428  "conflict/minimprove",
1429  "minimal improvement of primal bound to remove conflicts based on a previous incumbent",
1430  &(*set)->conf_minimprove, TRUE, SCIP_DEFAULT_CONF_MINIMPROVE, 0.0, 1.0, NULL, NULL) );
1431  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1432  "conflict/weightsize",
1433  "weight of the size of a conflict used in score calculation",
1434  &(*set)->conf_weightsize, TRUE, SCIP_DEFAULT_CONF_WEIGHTSIZE, 0.0, 1.0, NULL, NULL) );
1435  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1436  "conflict/weightrepropdepth",
1437  "weight of the repropagation depth of a conflict used in score calculation",
1438  &(*set)->conf_weightrepropdepth, TRUE, SCIP_DEFAULT_CONF_WEIGHTREPROPDEPTH, 0.0, 1.0, NULL, NULL) );
1439  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1440  "conflict/weightvaliddepth",
1441  "weight of the valid depth of a conflict used in score calculation",
1442  &(*set)->conf_weightvaliddepth, TRUE, SCIP_DEFAULT_CONF_WEIGHTVALIDDEPTH, 0.0, 1.0, NULL, NULL) );
1443  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1444  "conflict/sepaaltproofs",
1445  "apply cut generating functions to construct alternative proofs",
1446  &(*set)->conf_sepaaltproofs, FALSE, SCIP_DEFAULT_CONF_SEPAALTPROOFS,
1447  NULL, NULL) );
1448 
1449  /* constraint parameters */
1450  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1451  "constraints/agelimit",
1452  "maximum age an unnecessary constraint can reach before it is deleted (0: dynamic, -1: keep all constraints)",
1453  &(*set)->cons_agelimit, TRUE, SCIP_DEFAULT_CONS_AGELIMIT, -1, INT_MAX,
1454  NULL, NULL) );
1455  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1456  "constraints/obsoleteage",
1457  "age of a constraint after which it is marked obsolete (0: dynamic, -1 do not mark constraints obsolete)",
1458  &(*set)->cons_obsoleteage, TRUE, SCIP_DEFAULT_CONS_OBSOLETEAGE, -1, INT_MAX,
1459  NULL, NULL) );
1460  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1461  "constraints/disableenfops",
1462  "should enforcement of pseudo solution be disabled?",
1463  &(*set)->cons_disableenfops, TRUE, SCIP_DEFAULT_CONS_DISABLEENFOPS,
1464  NULL, NULL) );
1465 
1466  /* display parameters */
1467  assert(sizeof(int) == sizeof(SCIP_VERBLEVEL));
1468  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1469  "display/verblevel",
1470  "verbosity level of output",
1471  (int*)&(*set)->disp_verblevel, FALSE, (int)SCIP_DEFAULT_DISP_VERBLEVEL,
1473  NULL, NULL) );
1474  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1475  "display/width",
1476  "maximal number of characters in a node information line",
1477  &(*set)->disp_width, FALSE, SCIP_DEFAULT_DISP_WIDTH, 0, INT_MAX,
1478  SCIPparamChgdDispWidth, NULL) );
1479  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1480  "display/freq",
1481  "frequency for displaying node information lines",
1482  &(*set)->disp_freq, FALSE, SCIP_DEFAULT_DISP_FREQ, -1, INT_MAX,
1483  NULL, NULL) );
1484  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1485  "display/headerfreq",
1486  "frequency for displaying header lines (every n'th node information line)",
1487  &(*set)->disp_headerfreq, FALSE, SCIP_DEFAULT_DISP_HEADERFREQ, -1, INT_MAX,
1488  NULL, NULL) );
1489  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1490  "display/lpinfo",
1491  "should the LP solver display status messages?",
1492  &(*set)->disp_lpinfo, FALSE, SCIP_DEFAULT_DISP_LPINFO,
1493  NULL, NULL) );
1494  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1495  "display/allviols",
1496  "display all violations for a given start solution / the best solution after the solving process?",
1497  &(*set)->disp_allviols, FALSE, SCIP_DEFAULT_DISP_ALLVIOLS,
1498  NULL, NULL) );
1499  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1500  "display/relevantstats",
1501  "should the relevant statistics be displayed at the end of solving?",
1502  &(*set)->disp_relevantstats, FALSE, SCIP_DEFAULT_DISP_RELEVANTSTATS,
1503  NULL, NULL) );
1504 
1505  /* history parameters */
1506  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1507  "history/valuebased",
1508  "should statistics be collected for variable domain value pairs?",
1509  &(*set)->history_valuebased, FALSE, SCIP_DEFAULT_HISTORY_VALUEBASED,
1510  NULL, NULL) );
1511  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1512  "history/allowmerge",
1513  "should variable histories be merged from sub-SCIPs whenever possible?",
1514  &(*set)->history_allowmerge, FALSE, SCIP_DEFAULT_HISTORY_ALLOWMERGE,
1515  NULL, NULL) );
1516  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1517  "history/allowtransfer",
1518  "should variable histories be transferred to initialize SCIP copies?",
1519  &(*set)->history_allowtransfer, FALSE, SCIP_DEFAULT_HISTORY_ALLOWTRANSFER,
1520  NULL, NULL) );
1521 
1522  /* limit parameters */
1523  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1524  "limits/time",
1525  "maximal time in seconds to run",
1526  &(*set)->limit_time, FALSE, SCIP_DEFAULT_LIMIT_TIME, 0.0, SCIP_DEFAULT_LIMIT_TIME,
1527  SCIPparamChgdLimit, NULL) );
1528  SCIP_CALL( SCIPsetAddLongintParam(*set, messagehdlr, blkmem,
1529  "limits/nodes",
1530  "maximal number of nodes to process (-1: no limit)",
1531  &(*set)->limit_nodes, FALSE, SCIP_DEFAULT_LIMIT_NODES, -1LL, SCIP_LONGINT_MAX,
1532  SCIPparamChgdLimit, NULL) );
1533  SCIP_CALL( SCIPsetAddLongintParam(*set, messagehdlr, blkmem,
1534  "limits/totalnodes",
1535  "maximal number of total nodes (incl. restarts) to process (-1: no limit)",
1536  &(*set)->limit_totalnodes, FALSE, SCIP_DEFAULT_LIMIT_NODES, -1LL, SCIP_LONGINT_MAX,
1537  SCIPparamChgdLimit, NULL) );
1538  SCIP_CALL( SCIPsetAddLongintParam(*set, messagehdlr, blkmem,
1539  "limits/stallnodes",
1540  "solving stops, if the given number of nodes was processed since the last improvement of the primal solution value (-1: no limit)",
1541  &(*set)->limit_stallnodes, FALSE, SCIP_DEFAULT_LIMIT_STALLNODES, -1LL, SCIP_LONGINT_MAX,
1542  SCIPparamChgdLimit, NULL) );
1543  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1544  "limits/memory",
1545  "maximal memory usage in MB; reported memory usage is lower than real memory usage!",
1546  &(*set)->limit_memory, FALSE, SCIP_DEFAULT_LIMIT_MEMORY, 0.0, SCIP_MEM_NOLIMIT,
1547  SCIPparamChgdLimit, NULL) );
1548  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1549  "limits/gap",
1550  "solving stops, if the relative gap = |primal - dual|/MIN(|dual|,|primal|) is below the given value, the gap is 'Infinity', if primal and dual bound have opposite signs",
1551  &(*set)->limit_gap, FALSE, SCIP_DEFAULT_LIMIT_GAP, 0.0, SCIP_REAL_MAX,
1552  SCIPparamChgdLimit, NULL) );
1553  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1554  "limits/absgap",
1555  "solving stops, if the absolute gap = |primalbound - dualbound| is below the given value",
1556  &(*set)->limit_absgap, FALSE, SCIP_DEFAULT_LIMIT_ABSGAP, 0.0, SCIP_REAL_MAX,
1557  SCIPparamChgdLimit, NULL) );
1558  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1559  "limits/solutions",
1560  "solving stops, if the given number of solutions were found (-1: no limit)",
1561  &(*set)->limit_solutions, FALSE, SCIP_DEFAULT_LIMIT_SOLUTIONS, -1, INT_MAX,
1562  SCIPparamChgdLimit, NULL) );
1563  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1564  "limits/bestsol",
1565  "solving stops, if the given number of solution improvements were found (-1: no limit)",
1566  &(*set)->limit_bestsol, FALSE, SCIP_DEFAULT_LIMIT_BESTSOL, -1, INT_MAX,
1567  SCIPparamChgdLimit, NULL) );
1568  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1569  "limits/maxsol",
1570  "maximal number of solutions to store in the solution storage",
1571  &(*set)->limit_maxsol, FALSE, SCIP_DEFAULT_LIMIT_MAXSOL, 1, INT_MAX,
1572  SCIPparamChgdLimit, NULL) );
1573  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1574  "limits/maxorigsol",
1575  "maximal number of solutions candidates to store in the solution storage of the original problem",
1576  &(*set)->limit_maxorigsol, FALSE, SCIP_DEFAULT_LIMIT_MAXORIGSOL, 0, INT_MAX,
1577  SCIPparamChgdLimit, NULL) );
1578  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1579  "limits/restarts",
1580  "solving stops, if the given number of restarts was triggered (-1: no limit)",
1581  &(*set)->limit_restarts, FALSE, SCIP_DEFAULT_LIMIT_RESTARTS, -1, INT_MAX,
1582  SCIPparamChgdLimit, NULL) );
1583 
1584  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1585  "limits/autorestartnodes",
1586  "if solve exceeds this number of nodes for the first time, an automatic restart is triggered (-1: no automatic restart)",
1587  &(*set)->limit_autorestartnodes, FALSE, SCIP_DEFAULT_LIMIT_AUTORESTARTNODES, -1, INT_MAX,
1588  SCIPparamChgdLimit, NULL) );
1589 
1590  /* LP parameters */
1591  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1592  "lp/solvefreq",
1593  "frequency for solving LP at the nodes (-1: never; 0: only root LP)",
1594  &(*set)->lp_solvefreq, FALSE, SCIP_DEFAULT_LP_SOLVEFREQ, -1, SCIP_MAXTREEDEPTH,
1595  NULL, NULL) );
1596  SCIP_CALL( SCIPsetAddLongintParam(*set, messagehdlr, blkmem,
1597  "lp/iterlim",
1598  "iteration limit for each single LP solve (-1: no limit)",
1599  &(*set)->lp_iterlim, TRUE, SCIP_DEFAULT_LP_ITERLIM, -1LL, SCIP_LONGINT_MAX,
1600  NULL, NULL) );
1601  SCIP_CALL( SCIPsetAddLongintParam(*set, messagehdlr, blkmem,
1602  "lp/rootiterlim",
1603  "iteration limit for initial root LP solve (-1: no limit)",
1604  &(*set)->lp_rootiterlim, TRUE, SCIP_DEFAULT_LP_ROOTITERLIM, -1LL, SCIP_LONGINT_MAX,
1605  NULL, NULL) );
1606  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1607  "lp/solvedepth",
1608  "maximal depth for solving LP at the nodes (-1: no depth limit)",
1609  &(*set)->lp_solvedepth, FALSE, SCIP_DEFAULT_LP_SOLVEDEPTH, -1, SCIP_MAXTREEDEPTH,
1610  NULL, NULL) );
1611  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
1612  "lp/initalgorithm",
1613  "LP algorithm for solving initial LP relaxations (automatic 's'implex, 'p'rimal simplex, 'd'ual simplex, 'b'arrier, barrier with 'c'rossover)",
1614  &(*set)->lp_initalgorithm, FALSE, SCIP_DEFAULT_LP_INITALGORITHM, "spdbc",
1615  NULL, NULL) );
1616  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
1617  "lp/resolvealgorithm",
1618  "LP algorithm for resolving LP relaxations if a starting basis exists (automatic 's'implex, 'p'rimal simplex, 'd'ual simplex, 'b'arrier, barrier with 'c'rossover)",
1619  &(*set)->lp_resolvealgorithm, FALSE, SCIP_DEFAULT_LP_RESOLVEALGORITHM, "spdbc",
1620  NULL, NULL) );
1621  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
1622  "lp/pricing",
1623  "LP pricing strategy ('l'pi default, 'a'uto, 'f'ull pricing, 'p'artial, 's'teepest edge pricing, 'q'uickstart steepest edge pricing, 'd'evex pricing)",
1624  &(*set)->lp_pricing, FALSE, SCIP_DEFAULT_LP_PRICING, "lafpsqd",
1625  NULL, NULL) );
1626  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1627  "lp/clearinitialprobinglp",
1628  "should lp state be cleared at the end of probing mode when lp was initially unsolved, e.g., when called right after presolving?",
1629  &(*set)->lp_clearinitialprobinglp, TRUE, SCIP_DEFAULT_LP_CLEARINITIALPROBINGLP,
1630  NULL, NULL) );
1631  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1632  "lp/resolverestore",
1633  "should the LP be resolved to restore the state at start of diving (if FALSE we buffer the solution values)?",
1634  &(*set)->lp_resolverestore, TRUE, SCIP_DEFAULT_LP_RESOLVERESTORE,
1635  NULL, NULL) );
1636  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1637  "lp/freesolvalbuffers",
1638  "should the buffers for storing LP solution values during diving be freed at end of diving?",
1639  &(*set)->lp_freesolvalbuffers, TRUE, SCIP_DEFAULT_LP_FREESOLVALBUFFERS,
1640  NULL, NULL) );
1641  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1642  "lp/colagelimit",
1643  "maximum age a dynamic column can reach before it is deleted from the LP (-1: don't delete columns due to aging)",
1644  &(*set)->lp_colagelimit, TRUE, SCIP_DEFAULT_LP_COLAGELIMIT, -1, INT_MAX,
1645  NULL, NULL) );
1646  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1647  "lp/rowagelimit",
1648  "maximum age a dynamic row can reach before it is deleted from the LP (-1: don't delete rows due to aging)",
1649  &(*set)->lp_rowagelimit, TRUE, SCIP_DEFAULT_LP_ROWAGELIMIT, -1, INT_MAX,
1650  NULL, NULL) );
1651  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1652  "lp/cleanupcols",
1653  "should new non-basic columns be removed after LP solving?",
1654  &(*set)->lp_cleanupcols, TRUE, SCIP_DEFAULT_LP_CLEANUPCOLS,
1655  NULL, NULL) );
1656  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1657  "lp/cleanupcolsroot",
1658  "should new non-basic columns be removed after root LP solving?",
1659  &(*set)->lp_cleanupcolsroot, TRUE, SCIP_DEFAULT_LP_CLEANUPCOLSROOT,
1660  NULL, NULL) );
1661  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1662  "lp/cleanuprows",
1663  "should new basic rows be removed after LP solving?",
1664  &(*set)->lp_cleanuprows, TRUE, SCIP_DEFAULT_LP_CLEANUPROWS,
1665  NULL, NULL) );
1666  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1667  "lp/cleanuprowsroot",
1668  "should new basic rows be removed after root LP solving?",
1669  &(*set)->lp_cleanuprowsroot, TRUE, SCIP_DEFAULT_LP_CLEANUPROWSROOT,
1670  NULL, NULL) );
1671  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1672  "lp/checkstability",
1673  "should LP solver's return status be checked for stability?",
1674  &(*set)->lp_checkstability, TRUE, SCIP_DEFAULT_LP_CHECKSTABILITY,
1675  NULL, NULL) );
1676  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1677  "lp/conditionlimit",
1678  "maximum condition number of LP basis counted as stable (-1.0: no limit)",
1679  &(*set)->lp_conditionlimit, TRUE, SCIP_DEFAULT_LP_CONDITIONLIMIT, -1.0, SCIP_REAL_MAX,
1680  NULL, NULL) );
1681  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1682  "lp/checkprimfeas",
1683  "should LP solutions be checked for primal feasibility, resolving LP when numerical troubles occur?",
1684  &(*set)->lp_checkprimfeas, TRUE, SCIP_DEFAULT_LP_CHECKPRIMFEAS,
1685  NULL, NULL) );
1686  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1687  "lp/checkdualfeas",
1688  "should LP solutions be checked for dual feasibility, resolving LP when numerical troubles occur?",
1689  &(*set)->lp_checkdualfeas, TRUE, SCIP_DEFAULT_LP_CHECKDUALFEAS,
1690  NULL, NULL) );
1691  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1692  "lp/checkfarkas",
1693  "should infeasibility proofs from the LP be checked?",
1694  &(*set)->lp_checkfarkas, TRUE, SCIP_DEFAULT_LP_CHECKFARKAS,
1695  NULL, NULL) );
1696  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1697  "lp/fastmip",
1698  "which FASTMIP setting of LP solver should be used? 0: off, 1: low",
1699  &(*set)->lp_fastmip, TRUE, SCIP_DEFAULT_LP_FASTMIP, 0, 1,
1700  NULL, NULL) );
1701  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1702  "lp/scaling",
1703  "LP scaling (0: none, 1: normal, 2: aggressive)",
1704  &(*set)->lp_scaling, TRUE, SCIP_DEFAULT_LP_SCALING, 0, 2,
1705  NULL, NULL) );
1706  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1707  "lp/presolving",
1708  "should presolving of LP solver be used?",
1709  &(*set)->lp_presolving, TRUE, SCIP_DEFAULT_LP_PRESOLVING,
1710  NULL, NULL) );
1711  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1712  "lp/lexdualalgo",
1713  "should the lexicographic dual algorithm be used?",
1714  &(*set)->lp_lexdualalgo, TRUE, SCIP_DEFAULT_LP_LEXDUALALGO,
1715  NULL, NULL) );
1716  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1717  "lp/lexdualrootonly",
1718  "should the lexicographic dual algorithm be applied only at the root node",
1719  &(*set)->lp_lexdualrootonly, TRUE, SCIP_DEFAULT_LP_LEXDUALROOTONLY,
1720  NULL, NULL) );
1721  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1722  "lp/lexdualmaxrounds",
1723  "maximum number of rounds in the lexicographic dual algorithm (-1: unbounded)",
1724  &(*set)->lp_lexdualmaxrounds, TRUE, SCIP_DEFAULT_LP_LEXDUALMAXROUNDS, -1, INT_MAX,
1725  NULL, NULL) );
1726  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1727  "lp/lexdualbasic",
1728  "choose fractional basic variables in lexicographic dual algorithm?",
1729  &(*set)->lp_lexdualbasic, TRUE, SCIP_DEFAULT_LP_LEXDUALBASIC,
1730  NULL, NULL) );
1731  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1732  "lp/lexdualstalling",
1733  "turn on the lex dual algorithm only when stalling?",
1734  &(*set)->lp_lexdualstalling, TRUE, SCIP_DEFAULT_LP_LEXDUALSTALLING,
1735  NULL, NULL) );
1736  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1737  "lp/disablecutoff",
1738  "disable the cutoff bound in the LP solver? (0: enabled, 1: disabled, 2: auto)",
1739  &(*set)->lp_disablecutoff, TRUE, SCIP_DEFAULT_LP_DISABLECUTOFF,
1740  0, 2, NULL, NULL) );
1741  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1742  "lp/rowrepswitch",
1743  "simplex algorithm shall use row representation of the basis if number of rows divided by number of columns exceeds this value (-1.0 to disable row representation)",
1744  &(*set)->lp_rowrepswitch, TRUE, SCIP_DEFAULT_LP_ROWREPSWITCH, -1.0, SCIP_REAL_MAX,
1745  NULL, NULL) );
1746  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1747  "lp/threads",
1748  "number of threads used for solving the LP (0: automatic)",
1749  &(*set)->lp_threads, TRUE, SCIP_DEFAULT_LP_THREADS, 0, 64,
1750  NULL, NULL) );
1751  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1752  "lp/resolveiterfac",
1753  "factor of average LP iterations that is used as LP iteration limit for LP resolve (-1: unlimited)",
1754  &(*set)->lp_resolveiterfac, TRUE, SCIP_DEFAULT_LP_RESOLVEITERFAC, -1.0, SCIP_REAL_MAX,
1755  NULL, NULL) );
1756  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1757  "lp/resolveitermin",
1758  "minimum number of iterations that are allowed for LP resolve",
1759  &(*set)->lp_resolveitermin, TRUE, SCIP_DEFAULT_LP_RESOLVEITERMIN, 1, INT_MAX,
1760  NULL, NULL) );
1761 
1762  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1763  "lp/solutionpolishing",
1764  "LP solution polishing method (0: disabled, 1: only root, 2: always, 3: auto)",
1765  &(*set)->lp_solutionpolishing, TRUE, SCIP_DEFAULT_LP_SOLUTIONPOLISHING, 0, 3,
1766  NULL, NULL) );
1767 
1768  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1769  "lp/refactorinterval",
1770  "LP refactorization interval (0: auto)",
1771  &(*set)->lp_refactorinterval, TRUE, SCIP_DEFAULT_LP_REFACTORINTERVAL, 0, INT_MAX,
1772  NULL, NULL) );
1773  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1774  "lp/alwaysgetduals",
1775  "should the Farkas duals always be collected when an LP is found to be infeasible?",
1776  &(*set)->lp_alwaysgetduals, FALSE, SCIP_DEFAULT_LP_ALWAYSGETDUALS,
1777  NULL, NULL) );
1778 
1779  /* NLP parameters */
1780  SCIP_CALL( SCIPsetAddStringParam(*set, messagehdlr, blkmem,
1781  "nlp/solver",
1782  "solver to use for solving NLPs; leave empty to select NLPI with highest priority",
1783  &(*set)->nlp_solver, FALSE, SCIP_DEFAULT_NLP_SOLVER,
1784  NULL, NULL) );
1785  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1786  "nlp/disable",
1787  "should the NLP relaxation be always disabled (also for NLPs/MINLPs)?",
1788  &(*set)->nlp_disable, FALSE, SCIP_DEFAULT_NLP_DISABLE,
1789  NULL, NULL) );
1790 
1791  /* memory parameters */
1792  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1793  "memory/savefac",
1794  "fraction of maximal memory usage resulting in switch to memory saving mode",
1795  &(*set)->mem_savefac, FALSE, SCIP_DEFAULT_MEM_SAVEFAC, 0.0, 1.0,
1796  NULL, NULL) );
1797  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1798  "memory/arraygrowfac",
1799  "memory growing factor for dynamically allocated arrays",
1800  &(*set)->mem_arraygrowfac, TRUE, SCIP_DEFAULT_MEM_ARRAYGROWFAC, 1.0, 10.0,
1801  paramChgdArraygrowfac, NULL) );
1802  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1803  "memory/arraygrowinit",
1804  "initial size of dynamically allocated arrays",
1805  &(*set)->mem_arraygrowinit, TRUE, SCIP_DEFAULT_MEM_ARRAYGROWINIT, 0, INT_MAX,
1806  paramChgdArraygrowinit, NULL) );
1807  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1808  "memory/treegrowfac",
1809  "memory growing factor for tree array",
1810  &(*set)->mem_treegrowfac, TRUE, SCIP_DEFAULT_MEM_TREEGROWFAC, 1.0, 10.0,
1811  NULL, NULL) );
1812  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1813  "memory/treegrowinit",
1814  "initial size of tree array",
1815  &(*set)->mem_treegrowinit, TRUE, SCIP_DEFAULT_MEM_TREEGROWINIT, 0, INT_MAX,
1816  NULL, NULL) );
1817  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1818  "memory/pathgrowfac",
1819  "memory growing factor for path array",
1820  &(*set)->mem_pathgrowfac, TRUE, SCIP_DEFAULT_MEM_PATHGROWFAC, 1.0, 10.0,
1821  NULL, NULL) );
1822  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1823  "memory/pathgrowinit",
1824  "initial size of path array",
1825  &(*set)->mem_pathgrowinit, TRUE, SCIP_DEFAULT_MEM_PATHGROWINIT, 0, INT_MAX,
1826  NULL, NULL) );
1827 
1828  /* miscellaneous parameters */
1829  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1830  "misc/catchctrlc",
1831  "should the CTRL-C interrupt be caught by SCIP?",
1832  &(*set)->misc_catchctrlc, FALSE, SCIP_DEFAULT_MISC_CATCHCTRLC,
1833  NULL, NULL) );
1834  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1835  "misc/usevartable",
1836  "should a hashtable be used to map from variable names to variables?",
1837  &(*set)->misc_usevartable, FALSE, SCIP_DEFAULT_MISC_USEVARTABLE,
1838  NULL, NULL) );
1839  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1840  "misc/useconstable",
1841  "should a hashtable be used to map from constraint names to constraints?",
1842  &(*set)->misc_useconstable, FALSE, SCIP_DEFAULT_MISC_USECONSTABLE,
1843  NULL, NULL) );
1844  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1845  "misc/usesmalltables",
1846  "should smaller hashtables be used? yields better performance for small problems with about 100 variables",
1847  &(*set)->misc_usesmalltables, FALSE, SCIP_DEFAULT_MISC_USESMALLTABLES,
1848  NULL, NULL) );
1849 #if 0 /**@todo activate exactsolve parameter and finish implementation of solving MIPs exactly */
1850  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1851  "misc/exactsolve",
1852  "should the problem be solved exactly (with proven dual bounds)?",
1853  &(*set)->misc_exactsolve, FALSE, SCIP_DEFAULT_MISC_EXACTSOLVE,
1854  NULL, NULL) );
1855 #else
1856  (*set)->misc_exactsolve = SCIP_DEFAULT_MISC_EXACTSOLVE;
1857 #endif
1858 
1859  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1860  "misc/resetstat",
1861  "should the statistics be reset if the transformed problem is freed (in case of a Benders' decomposition this parameter should be set to FALSE)",
1862  &(*set)->misc_resetstat, FALSE, SCIP_DEFAULT_MISC_RESETSTAT,
1863  NULL, NULL) );
1864 
1865  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1866  "misc/improvingsols",
1867  "should only solutions be checked which improve the primal bound",
1868  &(*set)->misc_improvingsols, FALSE, SCIP_DEFAULT_MISC_IMPROVINGSOLS,
1869  NULL, NULL) );
1870  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1871  "misc/printreason",
1872  "should the reason be printed if a given start solution is infeasible",
1873  &(*set)->misc_printreason, FALSE, SCIP_DEFAULT_MISC_PRINTREASON,
1874  NULL, NULL) );
1875  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1876  "misc/estimexternmem",
1877  "should the usage of external memory be estimated?",
1878  &(*set)->misc_estimexternmem, FALSE, SCIP_DEFAULT_MISC_ESTIMEXTERNMEM,
1879  NULL, NULL) );
1880  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1881  "misc/transorigsols",
1882  "should SCIP try to transfer original solutions to the transformed space (after presolving)?",
1883  &(*set)->misc_transorigsols, FALSE, SCIP_DEFAULT_MISC_TRANSORIGSOLS,
1884  NULL, NULL) );
1885  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1886  "misc/transsolsorig",
1887  "should SCIP try to transfer transformed solutions to the original space (after solving)?",
1888  &(*set)->misc_transsolsorig, FALSE, SCIP_DEFAULT_MISC_TRANSSOLSORIG,
1889  NULL, NULL) );
1890  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1891  "misc/calcintegral",
1892  "should SCIP calculate the primal dual integral value?",
1893  &(*set)->misc_calcintegral, FALSE, SCIP_DEFAULT_MISC_CALCINTEGRAL,
1894  NULL, NULL) );
1895  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1896  "misc/finitesolutionstore",
1897  "should SCIP try to remove infinite fixings from solutions copied to the solution store?",
1898  &(*set)->misc_finitesolstore, FALSE, SCIP_DEFAULT_MISC_FINITESOLSTORE,
1899  NULL, NULL) );
1900  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1901  "misc/outputorigsol",
1902  "should the best solution be transformed to the orignal space and be output in command line run?",
1903  &(*set)->misc_outputorigsol, FALSE, SCIP_DEFAULT_MISC_OUTPUTORIGSOL,
1904  NULL, NULL) );
1905  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1906  "misc/allowdualreds",
1907  "should dual reductions in propagation methods and presolver be allowed?",
1908  &(*set)->misc_allowdualreds, FALSE, SCIP_DEFAULT_MISC_ALLOWDUALREDS,
1909  NULL, NULL) );
1910  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1911  "misc/allowobjprop",
1912  "should propagation to the current objective be allowed in propagation methods?",
1913  &(*set)->misc_allowobjprop, FALSE, SCIP_DEFAULT_MISC_ALLOWOBJPROP,
1914  NULL, NULL) );
1915  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1916  "misc/scaleobj",
1917  "should the objective function be scaled so that it is always integer?",
1918  &(*set)->misc_scaleobj, FALSE, SCIP_DEFAULT_MISC_SCALEOBJ,
1919  NULL, NULL) );
1920 
1921  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1922  "misc/referencevalue",
1923  "objective value for reference purposes",
1924  &(*set)->misc_referencevalue, FALSE, SCIP_DEFAULT_MISC_REFERENCEVALUE, SCIP_REAL_MIN, SCIP_REAL_MAX,
1925  NULL, NULL) );
1926 
1927 #ifdef WITH_DEBUG_SOLUTION
1928  SCIP_CALL( SCIPsetAddStringParam(*set, messagehdlr, blkmem,
1929  "misc/debugsol",
1930  "path to a debug solution",
1931  &(*set)->misc_debugsol, FALSE, SCIP_DEFAULT_MISC_DEBUGSOLUTION,
1932  NULL, NULL) );
1933 #endif
1934 
1935  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1936  "misc/usesymmetry",
1937  "used symmetry handling technique (0: off; 1: polyhedral; 2: orbital fixing)",
1938  &(*set)->misc_usesymmetry, FALSE, SCIP_DEFAULT_MISC_USESYMMETRY, 0, 2,
1939  paramChgdUsesymmetry, NULL) );
1940 
1941  /* randomization parameters */
1942  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1943  "randomization/randomseedshift",
1944  "global shift of all random seeds in the plugins and the LP random seed",
1945  &(*set)->random_randomseedshift, FALSE, SCIP_DEFAULT_RANDOM_RANDSEEDSHIFT, 0, INT_MAX,
1946  NULL, NULL) );
1947 
1948  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1949  "randomization/permutationseed",
1950  "seed value for permuting the problem after reading/transformation (0: no permutation)",
1951  &(*set)->random_permutationseed, FALSE, SCIP_DEFAULT_RANDOM_PERMUTATIONSEED, 0, INT_MAX,
1952  NULL, NULL) );
1953 
1954  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1955  "randomization/permuteconss",
1956  "should order of constraints be permuted (depends on permutationseed)?",
1957  &(*set)->random_permuteconss, TRUE, SCIP_DEFAULT_RANDOM_PERMUTECONSS,
1958  NULL, NULL) );
1959 
1960  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1961  "randomization/permutevars",
1962  "should order of variables be permuted (depends on permutationseed)?",
1963  &(*set)->random_permutevars, TRUE, SCIP_DEFAULT_RANDOM_PERMUTEVARS,
1964  NULL, NULL) );
1965 
1966  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1967  "randomization/lpseed",
1968  "random seed for LP solver, e.g. for perturbations in the simplex (0: LP default)",
1969  &(*set)->random_randomseed, FALSE, SCIP_DEFAULT_RANDOM_LPSEED, 0, INT_MAX,
1970  NULL, NULL) );
1971 
1972  /* node selection */
1973  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
1974  "nodeselection/childsel",
1975  "child selection rule ('d'own, 'u'p, 'p'seudo costs, 'i'nference, 'l'p value, 'r'oot LP value difference, 'h'ybrid inference/root LP value difference)",
1976  &(*set)->nodesel_childsel, FALSE, SCIP_DEFAULT_NODESEL_CHILDSEL, "dupilrh",
1977  NULL, NULL) );
1978 
1979  /* numerical parameters */
1980  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1981  "numerics/infinity",
1982  "values larger than this are considered infinity",
1983  &(*set)->num_infinity, FALSE, SCIP_DEFAULT_INFINITY, 1e+10, SCIP_INVALID/10.0,
1984  paramChgInfinity, NULL) );
1985  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1986  "numerics/epsilon",
1987  "absolute values smaller than this are considered zero",
1988  &(*set)->num_epsilon, FALSE, SCIP_DEFAULT_EPSILON, SCIP_MINEPSILON, SCIP_MAXEPSILON,
1989  NULL, NULL) );
1990  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1991  "numerics/sumepsilon",
1992  "absolute values of sums smaller than this are considered zero",
1993  &(*set)->num_sumepsilon, FALSE, SCIP_DEFAULT_SUMEPSILON, SCIP_MINEPSILON*1e+03, SCIP_MAXEPSILON,
1994  NULL, NULL) );
1995  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1996  "numerics/feastol",
1997  "feasibility tolerance for constraints",
1998  &(*set)->num_feastol, FALSE, SCIP_DEFAULT_FEASTOL, SCIP_MINEPSILON*1e+03, SCIP_MAXEPSILON,
1999  paramChgdFeastol, NULL) );
2000  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2001  "numerics/checkfeastolfac",
2002  "feasibility tolerance factor; for checking the feasibility of the best solution",
2003  &(*set)->num_checkfeastolfac, FALSE, SCIP_DEFAULT_CHECKFEASTOLFAC, 0.0, SCIP_REAL_MAX,
2004  NULL, NULL) );
2005  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2006  "numerics/lpfeastol",
2007  "primal feasibility tolerance of LP solver",
2008  &(*set)->num_lpfeastol, FALSE, SCIP_DEFAULT_LPFEASTOL, SCIP_MINEPSILON*1e+03, SCIP_MAXEPSILON,
2009  paramChgdLpfeastol, NULL) );
2010  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2011  "numerics/dualfeastol",
2012  "feasibility tolerance for reduced costs in LP solution",
2013  &(*set)->num_dualfeastol, FALSE, SCIP_DEFAULT_DUALFEASTOL, SCIP_MINEPSILON*1e+03, SCIP_MAXEPSILON,
2014  paramChgdDualfeastol, NULL) );
2015  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2016  "numerics/barrierconvtol",
2017  "LP convergence tolerance used in barrier algorithm",
2018  &(*set)->num_barrierconvtol, TRUE, SCIP_DEFAULT_BARRIERCONVTOL, SCIP_MINEPSILON*1e+03, SCIP_MAXEPSILON,
2019  paramChgdBarrierconvtol, NULL) );
2020  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2021  "numerics/boundstreps",
2022  "minimal relative improve for strengthening bounds",
2023  &(*set)->num_boundstreps, TRUE, SCIP_DEFAULT_BOUNDSTREPS, SCIP_MINEPSILON*1e+03, SCIP_INVALID/10.0,
2024  NULL, NULL) );
2025  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2026  "numerics/pseudocosteps",
2027  "minimal variable distance value to use for branching pseudo cost updates",
2028  &(*set)->num_pseudocosteps, TRUE, SCIP_DEFAULT_PSEUDOCOSTEPS, SCIP_MINEPSILON*1e+03, 1.0,
2029  NULL, NULL) );
2030  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2031  "numerics/pseudocostdelta",
2032  "minimal objective distance value to use for branching pseudo cost updates",
2033  &(*set)->num_pseudocostdelta, TRUE, SCIP_DEFAULT_PSEUDOCOSTDELTA, 0.0, SCIP_REAL_MAX,
2034  NULL, NULL) );
2035  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2036  "numerics/recomputefac",
2037  "minimal decrease factor that causes the recomputation of a value (e.g., pseudo objective) instead of an update",
2038  &(*set)->num_recompfac, TRUE, SCIP_DEFAULT_RECOMPFAC, 0.0, SCIP_REAL_MAX,
2039  NULL, NULL) );
2040  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2041  "numerics/hugeval",
2042  "values larger than this are considered huge and should be handled separately (e.g., in activity computation)",
2043  &(*set)->num_hugeval, TRUE, SCIP_DEFAULT_HUGEVAL, 0.0, SCIP_INVALID/10.0,
2044  NULL, NULL) );
2045 
2046  /* presolving parameters */
2047  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2048  "presolving/maxrounds",
2049  "maximal number of presolving rounds (-1: unlimited, 0: off)",
2050  &(*set)->presol_maxrounds, FALSE, SCIP_DEFAULT_PRESOL_MAXROUNDS, -1, INT_MAX,
2051  NULL, NULL) );
2052  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2053  "presolving/abortfac",
2054  "abort presolve, if at most this fraction of the problem was changed in last presolve round",
2055  &(*set)->presol_abortfac, TRUE, SCIP_DEFAULT_PRESOL_ABORTFAC, 0.0, 1.0,
2056  NULL, NULL) );
2057  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2058  "presolving/maxrestarts",
2059  "maximal number of restarts (-1: unlimited)",
2060  &(*set)->presol_maxrestarts, FALSE, SCIP_DEFAULT_PRESOL_MAXRESTARTS, -1, INT_MAX,
2061  NULL, NULL) );
2062  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2063  "presolving/restartfac",
2064  "fraction of integer variables that were fixed in the root node triggering a restart with preprocessing after root node evaluation",
2065  &(*set)->presol_restartfac, TRUE, SCIP_DEFAULT_PRESOL_RESTARTFAC, 0.0, 1.0,
2066  NULL, NULL) );
2067  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2068  "presolving/immrestartfac",
2069  "fraction of integer variables that were fixed in the root node triggering an immediate restart with preprocessing",
2070  &(*set)->presol_immrestartfac, TRUE, SCIP_DEFAULT_PRESOL_IMMRESTARTFAC, 0.0, 1.0,
2071  NULL, NULL) );
2072  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2073  "presolving/subrestartfac",
2074  "fraction of integer variables that were globally fixed during the solving process triggering a restart with preprocessing",
2075  &(*set)->presol_subrestartfac, TRUE, SCIP_DEFAULT_PRESOL_SUBRESTARTFAC, 0.0, 1.0,
2076  NULL, NULL) );
2077  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2078  "presolving/restartminred",
2079  "minimal fraction of integer variables removed after restart to allow for an additional restart",
2080  &(*set)->presol_restartminred, TRUE, SCIP_DEFAULT_PRESOL_RESTARTMINRED, 0.0, 1.0,
2081  NULL, NULL) );
2082  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2083  "presolving/donotmultaggr",
2084  "should multi-aggregation of variables be forbidden?",
2085  &(*set)->presol_donotmultaggr, TRUE, SCIP_DEFAULT_PRESOL_DONOTMULTAGGR,
2086  NULL, NULL) );
2087  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2088  "presolving/donotaggr",
2089  "should aggregation of variables be forbidden?",
2090  &(*set)->presol_donotaggr, TRUE, SCIP_DEFAULT_PRESOL_DONOTAGGR,
2091  NULL, NULL) );
2092 
2093  /* pricing parameters */
2094  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2095  "pricing/maxvars",
2096  "maximal number of variables priced in per pricing round",
2097  &(*set)->price_maxvars, FALSE, SCIP_DEFAULT_PRICE_MAXVARS, 1, INT_MAX,
2098  NULL, NULL) );
2099  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2100  "pricing/maxvarsroot",
2101  "maximal number of priced variables at the root node",
2102  &(*set)->price_maxvarsroot, FALSE, SCIP_DEFAULT_PRICE_MAXVARSROOT, 1, INT_MAX,
2103  NULL, NULL) );
2104  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2105  "pricing/abortfac",
2106  "pricing is aborted, if fac * pricing/maxvars pricing candidates were found",
2107  &(*set)->price_abortfac, FALSE, SCIP_DEFAULT_PRICE_ABORTFAC, 1.0, SCIP_REAL_MAX,
2108  NULL, NULL) );
2109  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2110  "pricing/delvars",
2111  "should variables created at the current node be deleted when the node is solved in case they are not present in the LP anymore?",
2112  &(*set)->price_delvars, FALSE, SCIP_DEFAULT_PRICE_DELVARS,
2113  NULL, NULL) );
2114  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2115  "pricing/delvarsroot",
2116  "should variables created at the root node be deleted when the root is solved in case they are not present in the LP anymore?",
2117  &(*set)->price_delvarsroot, FALSE, SCIP_DEFAULT_PRICE_DELVARSROOT,
2118  NULL, NULL) );
2119 
2120  /* Benders' decomposition parameters */
2121  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2122  "benders/solutiontol",
2123  "the tolerance used for checking optimality in Benders' decomposition. tol where optimality is given by LB + tol > UB.",
2124  &(*set)->benders_soltol, FALSE, SCIP_DEFAULT_BENDERS_SOLTOL, 0.0, SCIP_REAL_MAX,
2125  NULL, NULL) );
2126  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2127  "benders/cutlpsol",
2128  "should Benders' cuts be generated from the solution to the LP relaxation?",
2129  &(*set)->benders_cutlpsol, FALSE, SCIP_DEFAULT_BENDERS_CUTLPSOL,
2130  NULL, NULL) );
2131  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2132  "benders/copybenders",
2133  "should Benders' decomposition be copied for use in sub-SCIPs?",
2134  &(*set)->benders_copybenders, FALSE, SCIP_DEFAULT_BENDERS_COPYBENDERS,
2135  NULL, NULL) );
2136 
2137  /* propagation parameters */
2138  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2139  "propagating/maxrounds",
2140  "maximal number of propagation rounds per node (-1: unlimited)",
2141  &(*set)->prop_maxrounds, FALSE, SCIP_DEFAULT_PROP_MAXROUNDS, -1, INT_MAX,
2142  NULL, NULL) );
2143  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2144  "propagating/maxroundsroot",
2145  "maximal number of propagation rounds in the root node (-1: unlimited)",
2146  &(*set)->prop_maxroundsroot, FALSE, SCIP_DEFAULT_PROP_MAXROUNDSROOT, -1, INT_MAX,
2147  NULL, NULL) );
2148  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2149  "propagating/abortoncutoff",
2150  "should propagation be aborted immediately? setting this to FALSE could help conflict analysis to produce more conflict constraints",
2151  &(*set)->prop_abortoncutoff, FALSE, SCIP_DEFAULT_PROP_ABORTONCUTOFF,
2152  NULL, NULL) );
2153 
2154  /* reoptimization */
2155  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2156  "reoptimization/enable",
2157  "should reoptimization used?",
2158  &(*set)->reopt_enable, FALSE, SCIP_DEFAULT_REOPT_ENABLE,
2159  paramChgdEnableReopt, NULL) );
2160  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2161  "reoptimization/maxsavednodes",
2162  "maximal number of saved nodes",
2163  &(*set)->reopt_maxsavednodes, TRUE, SCIP_DEFAULT_REOPT_MAXSAVEDNODES, -1, INT_MAX,
2164  NULL, NULL) );
2165  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2166  "reoptimization/maxdiffofnodes",
2167  "maximal number of bound changes between two stored nodes on one path",
2168  &(*set)->reopt_maxdiffofnodes, TRUE, SCIP_DEFAULT_REOPT_MAXDIFFOFNODES, 0, INT_MAX,
2169  NULL, NULL) );
2170  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2171  "reoptimization/globalcons/sepainfsubtrees",
2172  "save global constraints to separate infeasible subtrees.",
2173  &(*set)->reopt_sepaglbinfsubtrees, FALSE, SCIP_DEFAULT_REOPT_SEPAGLBINFSUBTREES,
2174  NULL, NULL) );
2175  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2176  "reoptimization/sepabestsol",
2177  "separate the optimal solution, i.e., for constrained shortest path",
2178  &(*set)->reopt_sepabestsol, TRUE, SCIP_DEFAULT_REOPT_SEPABESTSOL,
2179  NULL, NULL) );
2180  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2181  "reoptimization/storevarhistory",
2182  "use variable history of the previous solve if the objctive function has changed only slightly",
2183  &(*set)->reopt_storevarhistory, TRUE, SCIP_DEFAULT_REOPT_STOREVARHISTOTY,
2184  NULL, NULL) );
2185  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2186  "reoptimization/usepscost",
2187  "re-use pseudo costs if the objective function changed only slightly ",
2188  &(*set)->reopt_usepscost, TRUE, SCIP_DEFAULT_REOPT_USEPSCOST,
2189  NULL, NULL) );
2190  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2191  "reoptimization/solvelp",
2192  "at which reopttype should the LP be solved? (1: transit, 3: strong branched, 4: w/ added logicor, 5: only leafs).",
2193  &(*set)->reopt_solvelp, TRUE, SCIP_DEFAULT_REOPT_SOLVELP, 1, 5,
2194  NULL, NULL) );
2195  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2196  "reoptimization/solvelpdiff",
2197  "maximal number of bound changes at node to skip solving the LP",
2198  &(*set)->reopt_solvelpdiff, TRUE, SCIP_DEFAULT_REOPT_SOLVELPDIFF, 0, INT_MAX,
2199  NULL, NULL) );
2200  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2201  "reoptimization/savesols",
2202  "number of best solutions which should be saved for the following runs. (-1: save all)",
2203  &(*set)->reopt_savesols, TRUE, SCIP_DEFAULT_REOPT_SAVESOLS, 0, INT_MAX,
2204  NULL, NULL) );
2205  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2206  "reoptimization/objsimrootLP",
2207  "similarity of two sequential objective function to disable solving the root LP.",
2208  &(*set)->reopt_objsimrootlp, TRUE, SCIP_DEFAULT_REOPT_OBJSIMROOTLP, -1.0, 1.0,
2209  NULL, NULL) );
2210  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2211  "reoptimization/objsimsol",
2212  "similarity of two objective functions to re-use stored solutions",
2213  &(*set)->reopt_objsimsol, TRUE, SCIP_DEFAULT_REOPT_OBJSIMSOL, -1.0, 1.0,
2214  NULL, NULL) );
2215  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2216  "reoptimization/delay",
2217  "minimum similarity for using reoptimization of the search tree.",
2218  &(*set)->reopt_objsimdelay, TRUE, SCIP_DEFAULT_REOPT_OBJSIMDELAY, -1.0, 1.0,
2219  NULL, NULL) );
2220  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2221  "reoptimization/commontimelimit",
2222  "time limit over all reoptimization rounds?.",
2223  &(*set)->reopt_commontimelimit, TRUE, SCIP_DEFAULT_REOPT_COMMONTIMELIMIT,
2224  NULL, NULL) );
2225  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2226  "reoptimization/shrinkinner",
2227  "replace branched inner nodes by their child nodes, if the number of bound changes is not to large",
2228  &(*set)->reopt_shrinkinner, TRUE, SCIP_DEFAULT_REOPT_SHRINKINNER,
2229  NULL, NULL) );
2230  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2231  "reoptimization/strongbranchinginit",
2232  "try to fix variables at the root node before reoptimizing by probing like strong branching",
2233  &(*set)->reopt_sbinit, TRUE, SCIP_DEFAULT_REOPT_STRONGBRANCHINIT,
2234  NULL, NULL) );
2235  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2236  "reoptimization/reducetofrontier",
2237  "delete stored nodes which were not reoptimized",
2238  &(*set)->reopt_reducetofrontier, TRUE, SCIP_DEFAULT_REOPT_REDUCETOFRONTIER,
2239  NULL, NULL) );
2240  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2241  "reoptimization/forceheurrestart",
2242  "force a restart if the last n optimal solutions were found by heuristic reoptsols",
2243  &(*set)->reopt_forceheurrestart, TRUE, SCIP_DEFAULT_REOPT_FORCEHEURRESTART, 1, INT_MAX,
2244  NULL, NULL) );
2245  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2246  "reoptimization/saveconsprop",
2247  "save constraint propagations",
2248  &(*set)->reopt_saveconsprop, TRUE, SCIP_DEFAULT_REOPT_SAVECONSPROP,
2249  NULL, NULL) );
2250  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2251  "reoptimization/usesplitcons", "use constraints to reconstruct the subtree pruned be dual reduction when reactivating the node",
2252  &(*set)->reopt_usesplitcons, TRUE, SCIP_DEFAULT_REOPT_USESPLITCONS,
2253  NULL, NULL) );
2254  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
2255  "reoptimization/varorderinterdiction", "use 'd'efault, 'r'andom or a variable ordering based on 'i'nference score for interdiction branching used during reoptimization",
2256  &(*set)->reopt_varorderinterdiction, TRUE, SCIP_DEFAULT_REOPT_VARORDERINTERDICTION, "dir",
2257  NULL, NULL) );
2258  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2259  "reoptimization/usecuts",
2260  "reoptimize cuts found at the root node",
2261  &(*set)->reopt_usecuts, TRUE, SCIP_DEFAULT_REOPT_USECUTS,
2262  NULL, NULL) );
2263  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2264  "reoptimization/maxcutage",
2265  "maximal age of a cut to be use for reoptimization",
2266  &(*set)->reopt_maxcutage, TRUE, SCIP_DEFAULT_REOPT_MAXCUTAGE, 0, INT_MAX,
2267  NULL, NULL) );
2268 
2269  /* separation parameters */
2270  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2271  "separating/maxbounddist",
2272  "maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separation (0.0: only on current best node, 1.0: on all nodes)",
2273  &(*set)->sepa_maxbounddist, FALSE, SCIP_DEFAULT_SEPA_MAXBOUNDDIST, 0.0, 1.0,
2274  NULL, NULL) );
2275  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2276  "separating/maxlocalbounddist",
2277  "maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying local separation (0.0: only on current best node, 1.0: on all nodes)",
2278  &(*set)->sepa_maxlocalbounddist, FALSE, SCIP_DEFAULT_SEPA_MAXLOCALBOUNDDIST, 0.0, 1.0,
2279  NULL, NULL) );
2280  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2281  "separating/maxcoefratio",
2282  "maximal ratio between coefficients in strongcg, cmir, and flowcover cuts",
2283  &(*set)->sepa_maxcoefratio, FALSE, SCIP_DEFAULT_SEPA_MAXCOEFRATIO, 1.0, SCIP_INVALID/10.0,
2284  NULL, NULL) );
2285  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2286  "separating/minefficacy",
2287  "minimal efficacy for a cut to enter the LP",
2288  &(*set)->sepa_minefficacy, FALSE, SCIP_DEFAULT_SEPA_MINEFFICACY, 0.0, SCIP_INVALID/10.0,
2289  NULL, NULL) );
2290  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2291  "separating/minefficacyroot",
2292  "minimal efficacy for a cut to enter the LP in the root node",
2293  &(*set)->sepa_minefficacyroot, FALSE, SCIP_DEFAULT_SEPA_MINEFFICACYROOT, 0.0, SCIP_INVALID/10.0,
2294  NULL, NULL) );
2295  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2296  "separating/minortho",
2297  "minimal orthogonality for a cut to enter the LP",
2298  &(*set)->sepa_minortho, FALSE, SCIP_DEFAULT_SEPA_MINORTHO, 0.0, 1.0,
2299  NULL, NULL) );
2300  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2301  "separating/minorthoroot",
2302  "minimal orthogonality for a cut to enter the LP in the root node",
2303  &(*set)->sepa_minorthoroot, FALSE, SCIP_DEFAULT_SEPA_MINORTHOROOT, 0.0, 1.0,
2304  NULL, NULL) );
2305  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2306  "separating/objparalfac",
2307  "factor to scale objective parallelism of cut in separation score calculation",
2308  &(*set)->sepa_objparalfac, TRUE, SCIP_DEFAULT_SEPA_OBJPARALFAC, 0.0, SCIP_INVALID/10.0,
2309  NULL, NULL) );
2310  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2311  "separating/dircutoffdistfac",
2312  "factor to scale directed cutoff distance of cut in score calculation",
2313  &(*set)->sepa_dircutoffdistfac, TRUE, SCIP_DEFAULT_SEPA_DIRCUTOFFDISTFAC, 0.0, SCIP_INVALID/10.0,
2314  NULL, NULL) );
2315  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2316  "separating/efficacyfac",
2317  "factor to scale efficacy of cut in score calculation",
2318  &(*set)->sepa_efficacyfac, TRUE, SCIP_DEFAULT_SEPA_EFFICACYFAC, 0.0, SCIP_INVALID/10.0,
2319  NULL, NULL) );
2320  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2321  "separating/intsupportfac",
2322  "factor to scale integral support of cut in separation score calculation",
2323  &(*set)->sepa_intsupportfac, TRUE, SCIP_DEFAULT_SEPA_INTSUPPORTFAC, 0.0, SCIP_INVALID/10.0,
2324  NULL, NULL) );
2325  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2326  "separating/minactivityquot",
2327  "minimum cut activity quotient to convert cuts into constraints during a restart (0.0: all cuts are converted)",
2328  &(*set)->sepa_minactivityquot, FALSE, SCIP_DEFAULT_SEPA_MINACTIVITYQUOT, 0.0, 1.0,
2329  NULL, NULL) );
2330  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
2331  "separating/orthofunc",
2332  "function used for calc. scalar prod. in orthogonality test ('e'uclidean, 'd'iscrete)",
2333  &(*set)->sepa_orthofunc, TRUE, SCIP_DEFAULT_SEPA_ORTHOFUNC, "ed",
2334  NULL, NULL) );
2335  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
2336  "separating/efficacynorm",
2337  "row norm to use for efficacy calculation ('e'uclidean, 'm'aximum, 's'um, 'd'iscrete)",
2338  &(*set)->sepa_efficacynorm, TRUE, SCIP_DEFAULT_SEPA_EFFICACYNORM, "emsd",
2339  NULL, NULL) );
2340  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
2341  "separating/cutselrestart",
2342  "cut selection during restart ('a'ge, activity 'q'uotient)",
2343  &(*set)->sepa_cutselrestart, TRUE, SCIP_DEFAULT_SEPA_CUTSELRESTART, "aq",
2344  NULL, NULL) );
2345  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
2346  "separating/cutselsubscip",
2347  "cut selection for sub SCIPs ('a'ge, activity 'q'uotient)",
2348  &(*set)->sepa_cutselsubscip, TRUE, SCIP_DEFAULT_SEPA_CUTSELSUBSCIP, "aq",
2349  NULL, NULL) );
2350  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2351  "separating/maxruns",
2352  "maximal number of runs for which separation is enabled (-1: unlimited)",
2353  &(*set)->sepa_maxruns, TRUE, SCIP_DEFAULT_SEPA_MAXRUNS, -1, INT_MAX,
2354  NULL, NULL) );
2355  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2356  "separating/maxrounds",
2357  "maximal number of separation rounds per node (-1: unlimited)",
2358  &(*set)->sepa_maxrounds, FALSE, SCIP_DEFAULT_SEPA_MAXROUNDS, -1, INT_MAX,
2359  NULL, NULL) );
2360  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2361  "separating/maxroundsroot",
2362  "maximal number of separation rounds in the root node (-1: unlimited)",
2363  &(*set)->sepa_maxroundsroot, FALSE, SCIP_DEFAULT_SEPA_MAXROUNDSROOT, -1, INT_MAX,
2364  NULL, NULL) );
2365  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2366  "separating/maxroundsrootsubrun",
2367  "maximal number of separation rounds in the root node of a subsequent run (-1: unlimited)",
2368  &(*set)->sepa_maxroundsrootsubrun, TRUE, SCIP_DEFAULT_SEPA_MAXROUNDSROOTSUBRUN, -1, INT_MAX,
2369  NULL, NULL) );
2370  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2371  "separating/maxaddrounds",
2372  "maximal additional number of separation rounds in subsequent price-and-cut loops (-1: no additional restriction)",
2373  &(*set)->sepa_maxaddrounds, TRUE, SCIP_DEFAULT_SEPA_MAXADDROUNDS, -1, INT_MAX,
2374  NULL, NULL) );
2375  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2376  "separating/maxstallrounds",
2377  "maximal number of consecutive separation rounds without objective or integrality improvement in local nodes (-1: no additional restriction)",
2378  &(*set)->sepa_maxstallrounds, FALSE, SCIP_DEFAULT_SEPA_MAXSTALLROUNDS, -1, INT_MAX,
2379  NULL, NULL) );
2380  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2381  "separating/maxstallroundsroot",
2382  "maximal number of consecutive separation rounds without objective or integrality improvement in the root node (-1: no additional restriction)",
2383  &(*set)->sepa_maxstallroundsroot, FALSE, SCIP_DEFAULT_SEPA_MAXSTALLROUNDSROOT, -1, INT_MAX,
2384  NULL, NULL) );
2385  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2386  "separating/maxcuts",
2387  "maximal number of cuts separated per separation round (0: disable local separation)",
2388  &(*set)->sepa_maxcuts, FALSE, SCIP_DEFAULT_SEPA_MAXCUTS, 0, INT_MAX,
2389  NULL, NULL) );
2390  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2391  "separating/maxcutsroot",
2392  "maximal number of separated cuts at the root node (0: disable root node separation)",
2393  &(*set)->sepa_maxcutsroot, FALSE, SCIP_DEFAULT_SEPA_MAXCUTSROOT, 0, INT_MAX,
2394  NULL, NULL) );
2395  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2396  "separating/cutagelimit",
2397  "maximum age a cut can reach before it is deleted from the global cut pool, or -1 to keep all cuts",
2398  &(*set)->sepa_cutagelimit, TRUE, SCIP_DEFAULT_SEPA_CUTAGELIMIT, -1, INT_MAX,
2399  NULL, NULL) );
2400  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2401  "separating/poolfreq",
2402  "separation frequency for the global cut pool (-1: disable global cut pool, 0: only separate pool at the root)",
2403  &(*set)->sepa_poolfreq, FALSE, SCIP_DEFAULT_SEPA_POOLFREQ, -1, SCIP_MAXTREEDEPTH,
2404  NULL, NULL) );
2405 
2406  /* parallel parameters */
2407  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2408  "parallel/mode",
2409  "parallel optimisation mode, 0: opportunistic or 1: deterministic.",
2410  &(*set)->parallel_mode, FALSE, SCIP_DEFAULT_PARALLEL_MODE, 0, 1,
2411  NULL, NULL) );
2412  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2413  "parallel/minnthreads",
2414  "the minimum number of threads used during parallel solve",
2415  &(*set)->parallel_minnthreads, FALSE, SCIP_DEFAULT_PARALLEL_MINNTHREADS, 0, 64,
2416  NULL, NULL) );
2417  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2418  "parallel/maxnthreads",
2419  "the maximum number of threads used during parallel solve",
2420  &(*set)->parallel_maxnthreads, FALSE, SCIP_DEFAULT_PARALLEL_MAXNTHREADS, 0, 64,
2421  NULL, NULL) );
2422 
2423  /* concurrent solver parameters */
2424  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2425  "concurrent/changeseeds",
2426  "set different random seeds in each concurrent solver?",
2427  &(*set)->concurrent_changeseeds, FALSE, SCIP_DEFAULT_CONCURRENT_CHANGESEEDS,
2428  NULL, NULL) );
2429  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2430  "concurrent/changechildsel",
2431  "use different child selection rules in each concurrent solver?",
2432  &(*set)->concurrent_changechildsel, FALSE, SCIP_DEFAULT_CONCURRENT_CHANGECHILDSEL,
2433  NULL, NULL) );
2434  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2435  "concurrent/commvarbnds",
2436  "should the concurrent solvers communicate global variable bound changes?",
2437  &(*set)->concurrent_commvarbnds, FALSE, SCIP_DEFAULT_CONCURRENT_COMMVARBNDS,
2438  NULL, NULL) );
2439  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2440  "concurrent/presolvebefore",
2441  "should the problem be presolved before it is copied to the concurrent solvers?",
2442  &(*set)->concurrent_presolvebefore, FALSE, SCIP_DEFAULT_CONCURRENT_PRESOLVEBEFORE,
2443  NULL, NULL) );
2444  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2445  "concurrent/initseed",
2446  "maximum number of solutions that will be shared in a one synchronization",
2447  &(*set)->concurrent_initseed, FALSE, SCIP_DEFAULT_CONCURRENT_INITSEED, 0, INT_MAX,
2448  NULL, NULL) );
2449  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2450  "concurrent/sync/freqinit",
2451  "initial frequency of synchronization with other threads",
2452  &(*set)->concurrent_freqinit, FALSE, SCIP_DEFAULT_CONCURRENT_FREQINIT, 0.0, SCIP_REAL_MAX,
2453  NULL, NULL) );
2454  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2455  "concurrent/sync/freqmax",
2456  "maximal frequency of synchronization with other threads",
2457  &(*set)->concurrent_freqmax, FALSE, SCIP_DEFAULT_CONCURRENT_FREQMAX, 0.0, SCIP_REAL_MAX,
2458  NULL, NULL) );
2459  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2460  "concurrent/sync/freqfactor",
2461  "factor by which the frequency of synchronization is changed",
2462  &(*set)->concurrent_freqfactor, FALSE, SCIP_DEFAULT_CONCURRENT_FREQFACTOR, 1.0, SCIP_REAL_MAX,
2463  NULL, NULL) );
2464  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2465  "concurrent/sync/targetprogress",
2466  "when adapting the synchronization frequency this value is the targeted relative difference by which the absolute gap decreases per synchronization",
2467  &(*set)->concurrent_targetprogress, FALSE, SCIP_DEFAULT_CONCURRENT_TARGETPROGRESS, 0.0, SCIP_REAL_MAX,
2468  NULL, NULL) );
2469  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2470  "concurrent/sync/maxnsols",
2471  "maximum number of solutions that will be shared in a single synchronization",
2472  &(*set)->concurrent_maxnsols, FALSE, SCIP_DEFAULT_CONCURRENT_MAXNSOLS, 0, 1000,
2473  NULL, NULL) );
2474  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2475  "concurrent/sync/maxnsyncdelay",
2476  "maximum number of synchronizations before reading is enforced regardless of delay",
2477  &(*set)->concurrent_maxnsyncdelay, TRUE, SCIP_DEFAULT_CONCURRENT_MAXNSYNCDELAY, 0, 100,
2478  NULL, NULL) );
2479  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2480  "concurrent/sync/minsyncdelay",
2481  "minimum delay before synchronization data is read",
2482  &(*set)->concurrent_minsyncdelay, FALSE, SCIP_DEFAULT_CONCURRENT_MINSYNCDELAY, 0.0, SCIP_REAL_MAX,
2483  NULL, NULL) );
2484  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2485  "concurrent/sync/nbestsols",
2486  "how many of the N best solutions should be considered for synchronization?",
2487  &(*set)->concurrent_nbestsols, FALSE, SCIP_DEFAULT_CONCURRENT_NBESTSOLS, 0, INT_MAX,
2488  NULL, NULL) );
2489  SCIP_CALL( SCIPsetAddStringParam(*set, messagehdlr, blkmem,
2490  "concurrent/paramsetprefix",
2491  "path prefix for parameter setting files of concurrent solvers",
2492  &(*set)->concurrent_paramsetprefix, FALSE, SCIP_DEFAULT_CONCURRENT_PARAMSETPREFIX,
2493  NULL, NULL) );
2494 
2495  /* timing parameters */
2496  assert(sizeof(int) == sizeof(SCIP_CLOCKTYPE));
2497  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2498  "timing/clocktype",
2499  "default clock type (1: CPU user seconds, 2: wall clock time)",
2500  (int*)&(*set)->time_clocktype, FALSE, (int)SCIP_DEFAULT_TIME_CLOCKTYPE, 1, 2,
2501  NULL, NULL) );
2502  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2503  "timing/enabled",
2504  "is timing enabled?",
2505  &(*set)->time_enabled, FALSE, SCIP_DEFAULT_TIME_ENABLED,
2506  NULL, NULL) );
2507  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2508  "timing/reading",
2509  "belongs reading time to solving time?",
2510  &(*set)->time_reading, FALSE, SCIP_DEFAULT_TIME_READING,
2511  NULL, NULL) );
2512  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2513  "timing/rareclockcheck",
2514  "should clock checks of solving time be performed less frequently (note: time limit could be exceeded slightly)",
2515  &(*set)->time_rareclockcheck, FALSE, SCIP_DEFAULT_TIME_RARECLOCKCHECK,
2516  NULL, NULL) );
2517  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2518  "timing/statistictiming",
2519  "should timing for statistic output be performed?",
2520  &(*set)->time_statistictiming, FALSE, SCIP_DEFAULT_TIME_STATISTICTIMING,
2521  paramChgdStatistictiming, NULL) );
2522 
2523  /* visualization parameters */
2524  SCIP_CALL( SCIPsetAddStringParam(*set, messagehdlr, blkmem,
2525  "visual/vbcfilename",
2526  "name of the VBC tool output file, or - if no VBC tool output should be created",
2527  &(*set)->visual_vbcfilename, FALSE, SCIP_DEFAULT_VISUAL_VBCFILENAME,
2528  NULL, NULL) );
2529  SCIP_CALL( SCIPsetAddStringParam(*set, messagehdlr, blkmem,
2530  "visual/bakfilename",
2531  "name of the BAK tool output file, or - if no BAK tool output should be created",
2532  &(*set)->visual_bakfilename, FALSE, SCIP_DEFAULT_VISUAL_BAKFILENAME,
2533  NULL, NULL) );
2534  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2535  "visual/realtime",
2536  "should the real solving time be used instead of a time step counter in visualization?",
2537  &(*set)->visual_realtime, FALSE, SCIP_DEFAULT_VISUAL_REALTIME,
2538  NULL, NULL) );
2539  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2540  "visual/dispsols",
2541  "should the node where solutions are found be visualized?",
2542  &(*set)->visual_dispsols, FALSE, SCIP_DEFAULT_VISUAL_DISPSOLS,
2543  NULL, NULL) );
2544  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2545  "visual/displb",
2546  "should lower bound information be visualized?",
2547  &(*set)->visual_displb, FALSE, SCIP_DEFAULT_VISUAL_DISPLB,
2548  NULL, NULL) );
2549  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2550  "visual/objextern",
2551  "should be output the external value of the objective?",
2552  &(*set)->visual_objextern, FALSE, SCIP_DEFAULT_VISUAL_OBJEXTERN,
2553  NULL, NULL) );
2554 
2555  /* Reading parameters */
2556  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2557  "reading/initialconss",
2558  "should model constraints be marked as initial?",
2559  &(*set)->read_initialconss, FALSE, SCIP_DEFAULT_READ_INITIALCONSS,
2560  NULL, NULL) );
2561  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2562  "reading/dynamicconss",
2563  "should model constraints be subject to aging?",
2564  &(*set)->read_dynamicconss, FALSE, SCIP_DEFAULT_READ_DYNAMICCONSS,
2565  NULL, NULL) );
2566  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2567  "reading/dynamiccols",
2568  "should columns be added and removed dynamically to the LP?",
2569  &(*set)->read_dynamiccols, FALSE, SCIP_DEFAULT_READ_DYNAMICCOLS,
2570  NULL, NULL) );
2571  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2572  "reading/dynamicrows",
2573  "should rows be added and removed dynamically to the LP?",
2574  &(*set)->read_dynamicrows, FALSE, SCIP_DEFAULT_READ_DYNAMICROWS,
2575  NULL, NULL) );
2576 
2577  /* Writing parameters */
2578  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2579  "write/allconss",
2580  "should all constraints be written (including the redundant constraints)?",
2581  &(*set)->write_allconss, FALSE, SCIP_DEFAULT_WRITE_ALLCONSS,
2582  NULL, NULL) );
2583  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2584  "write/printzeros",
2585  "should variables set to zero be printed?",
2586  &(*set)->write_printzeros, FALSE, SCIP_DEFAULT_PRINTZEROS,
2587  NULL, NULL) );
2588  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2589  "write/genericnamesoffset",
2590  "when writing a generic problem the index for the first variable should start with?",
2591  &(*set)->write_genoffset, FALSE, SCIP_DEFAULT_WRITE_GENNAMES_OFFSET, 0, INT_MAX/2,
2592  NULL, NULL) );
2593 
2594  return SCIP_OKAY;
2595 }
2596 
2597 /** frees global SCIP settings */
2599  SCIP_SET** set, /**< pointer to SCIP settings */
2600  BMS_BLKMEM* blkmem /**< block memory */
2601  )
2602 {
2603  int i;
2604 
2605  assert(set != NULL);
2606 
2607  if( *set == NULL )
2608  return SCIP_OKAY;
2609 
2610  /* free parameter set */
2611  SCIPparamsetFree(&(*set)->paramset, blkmem);
2612 
2613  /* free file readers */
2614  for( i = 0; i < (*set)->nreaders; ++i )
2615  {
2616  SCIP_CALL( SCIPreaderFree(&(*set)->readers[i], *set) );
2617  }
2618  BMSfreeMemoryArrayNull(&(*set)->readers);
2619 
2620  /* free variable pricers */
2621  for( i = 0; i < (*set)->npricers; ++i )
2622  {
2623  SCIP_CALL( SCIPpricerFree(&(*set)->pricers[i], *set) );
2624  }
2625  BMSfreeMemoryArrayNull(&(*set)->pricers);
2626 
2627  /* free Benders' decomposition */
2628  for( i = 0; i < (*set)->nbenders; ++i )
2629  {
2630  SCIP_CALL( SCIPbendersFree(&(*set)->benders[i], *set) );
2631  }
2632  BMSfreeMemoryArrayNull(&(*set)->benders);
2633 
2634  /* free constraint handlers */
2635  for( i = 0; i < (*set)->nconshdlrs; ++i )
2636  {
2637  SCIP_CALL( SCIPconshdlrFree(&(*set)->conshdlrs[i], *set) );
2638  }
2639  BMSfreeMemoryArrayNull(&(*set)->conshdlrs);
2640  BMSfreeMemoryArrayNull(&(*set)->conshdlrs_sepa);
2641  BMSfreeMemoryArrayNull(&(*set)->conshdlrs_enfo);
2642  BMSfreeMemoryArrayNull(&(*set)->conshdlrs_include);
2643 
2644  /* free conflict handlers */
2645  for( i = 0; i < (*set)->nconflicthdlrs; ++i )
2646  {
2647  SCIP_CALL( SCIPconflicthdlrFree(&(*set)->conflicthdlrs[i], *set) );
2648  }
2649  BMSfreeMemoryArrayNull(&(*set)->conflicthdlrs);
2650 
2651  /* free presolvers */
2652  for( i = 0; i < (*set)->npresols; ++i )
2653  {
2654  SCIP_CALL( SCIPpresolFree(&(*set)->presols[i], *set) );
2655  }
2656  BMSfreeMemoryArrayNull(&(*set)->presols);
2657 
2658  /* free relaxators */
2659  for( i = 0; i < (*set)->nrelaxs; ++i )
2660  {
2661  SCIP_CALL( SCIPrelaxFree(&(*set)->relaxs[i], *set) );
2662  }
2663  BMSfreeMemoryArrayNull(&(*set)->relaxs);
2664 
2665  /* free separators */
2666  for( i = 0; i < (*set)->nsepas; ++i )
2667  {
2668  SCIP_CALL( SCIPsepaFree(&(*set)->sepas[i], *set) );
2669  }
2670  BMSfreeMemoryArrayNull(&(*set)->sepas);
2671 
2672  /* free propagators */
2673  for( i = 0; i < (*set)->nprops; ++i )
2674  {
2675  SCIP_CALL( SCIPpropFree(&(*set)->props[i], *set) );
2676  }
2677  BMSfreeMemoryArrayNull(&(*set)->props);
2678  BMSfreeMemoryArrayNull(&(*set)->props_presol);
2679 
2680  /* free primal heuristics */
2681  for( i = 0; i < (*set)->nheurs; ++i )
2682  {
2683  SCIP_CALL( SCIPheurFree(&(*set)->heurs[i], *set, blkmem) );
2684  }
2685  BMSfreeMemoryArrayNull(&(*set)->heurs);
2686 
2687  /* free tree compressions */
2688  for( i = 0; i < (*set)->ncomprs; ++i )
2689  {
2690  SCIP_CALL( SCIPcomprFree(&(*set)->comprs[i], *set) );
2691  }
2692  BMSfreeMemoryArrayNull(&(*set)->comprs);
2693 
2694  /* free event handlers */
2695  for( i = 0; i < (*set)->neventhdlrs; ++i )
2696  {
2697  SCIP_CALL( SCIPeventhdlrFree(&(*set)->eventhdlrs[i], *set) );
2698  }
2699  BMSfreeMemoryArrayNull(&(*set)->eventhdlrs);
2700 
2701  /* free node selectors */
2702  for( i = 0; i < (*set)->nnodesels; ++i )
2703  {
2704  SCIP_CALL( SCIPnodeselFree(&(*set)->nodesels[i], *set) );
2705  }
2706  BMSfreeMemoryArrayNull(&(*set)->nodesels);
2707 
2708  /* free branching methods */
2709  for( i = 0; i < (*set)->nbranchrules; ++i )
2710  {
2711  SCIP_CALL( SCIPbranchruleFree(&(*set)->branchrules[i], *set) );
2712  }
2713  BMSfreeMemoryArrayNull(&(*set)->branchrules);
2714 
2715  /* free statistics tables */
2716  for( i = 0; i < (*set)->ntables; ++i )
2717  {
2718  SCIP_CALL( SCIPtableFree(&(*set)->tables[i], *set) );
2719  }
2720  BMSfreeMemoryArrayNull(&(*set)->tables);
2721 
2722  /* free display columns */
2723  for( i = 0; i < (*set)->ndisps; ++i )
2724  {
2725  SCIP_CALL( SCIPdispFree(&(*set)->disps[i], *set) );
2726  }
2727  BMSfreeMemoryArrayNull(&(*set)->disps);
2728 
2729  /* free dialogs */
2730  BMSfreeMemoryArrayNull(&(*set)->dialogs);
2731 
2732  /* free NLPIs */
2733  for( i = 0; i < (*set)->nnlpis; ++i )
2734  {
2735  SCIP_CALL( SCIPnlpiFree(&(*set)->nlpis[i]) );
2736  }
2737  BMSfreeMemoryArrayNull(&(*set)->nlpis);
2738 
2739  /* free concsolvers */
2741 
2742  /* free concsolvers types */
2743  for( i = 0; i < (*set)->nconcsolvertypes; ++i )
2744  {
2745  SCIPconcsolverTypeFree(&(*set)->concsolvertypes[i]);
2746  }
2747  BMSfreeMemoryArrayNull(&(*set)->concsolvertypes);
2748 
2749  /* free information on external codes */
2750  for( i = 0; i < (*set)->nextcodes; ++i )
2751  {
2752  BMSfreeMemoryArrayNull(&(*set)->extcodenames[i]);
2753  BMSfreeMemoryArrayNull(&(*set)->extcodedescs[i]);
2754  }
2755  BMSfreeMemoryArrayNull(&(*set)->extcodenames);
2756  BMSfreeMemoryArrayNull(&(*set)->extcodedescs);
2757 
2758  /* free virtual tables of bandit algorithms */
2759  for( i = 0; i < (*set)->nbanditvtables; ++i )
2760  {
2761  SCIPbanditvtableFree(&(*set)->banditvtables[i]);
2762  }
2763  BMSfreeMemoryArrayNull(&(*set)->banditvtables);
2764 
2765  BMSfreeMemory(set);
2766 
2767  return SCIP_OKAY;
2768 }
2769 
2770 /** returns current stage of SCIP */
2772  SCIP_SET* set /**< global SCIP settings */
2773  )
2774 {
2775  assert(set != NULL);
2776 
2777  return set->stage;
2778 }
2779 
2780 /** creates a SCIP_Bool parameter, sets it to its default value, and adds it to the parameter set */
2782  SCIP_SET* set, /**< global SCIP settings */
2783  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2784  BMS_BLKMEM* blkmem, /**< block memory */
2785  const char* name, /**< name of the parameter */
2786  const char* desc, /**< description of the parameter */
2787  SCIP_Bool* valueptr, /**< pointer to store the current parameter value, or NULL */
2788  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
2789  SCIP_Bool defaultvalue, /**< default value of the parameter */
2790  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
2791  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
2792  )
2793 {
2794  assert(set != NULL);
2795 
2796  SCIP_CALL( SCIPparamsetAddBool(set->paramset, messagehdlr, blkmem, name, desc, valueptr, isadvanced,
2797  defaultvalue, paramchgd, paramdata) );
2798 
2799  return SCIP_OKAY;
2800 }
2801 
2802 /** creates an int parameter, sets it to its default value, and adds it to the parameter set */
2804  SCIP_SET* set, /**< global SCIP settings */
2805  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2806  BMS_BLKMEM* blkmem, /**< block memory */
2807  const char* name, /**< name of the parameter */
2808  const char* desc, /**< description of the parameter */
2809  int* valueptr, /**< pointer to store the current parameter value, or NULL */
2810  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
2811  int defaultvalue, /**< default value of the parameter */
2812  int minvalue, /**< minimum value for parameter */
2813  int maxvalue, /**< maximum value for parameter */
2814  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
2815  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
2816  )
2817 {
2818  assert(set != NULL);
2819 
2820  SCIP_CALL( SCIPparamsetAddInt(set->paramset, messagehdlr, blkmem, name, desc, valueptr, isadvanced,
2821  defaultvalue, minvalue, maxvalue, paramchgd, paramdata) );
2822 
2823  return SCIP_OKAY;
2824 }
2825 
2826 /** creates a SCIP_Longint parameter, sets it to its default value, and adds it to the parameter set */
2828  SCIP_SET* set, /**< global SCIP settings */
2829  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2830  BMS_BLKMEM* blkmem, /**< block memory */
2831  const char* name, /**< name of the parameter */
2832  const char* desc, /**< description of the parameter */
2833  SCIP_Longint* valueptr, /**< pointer to store the current parameter value, or NULL */
2834  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
2835  SCIP_Longint defaultvalue, /**< default value of the parameter */
2836  SCIP_Longint minvalue, /**< minimum value for parameter */
2837  SCIP_Longint maxvalue, /**< maximum value for parameter */
2838  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
2839  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
2840  )
2841 {
2842  assert(set != NULL);
2843 
2844  SCIP_CALL( SCIPparamsetAddLongint(set->paramset, messagehdlr, blkmem, name, desc, valueptr, isadvanced,
2845  defaultvalue, minvalue, maxvalue, paramchgd, paramdata) );
2846 
2847  return SCIP_OKAY;
2848 }
2849 
2850 /** creates a SCIP_Real parameter, sets it to its default value, and adds it to the parameter set */
2852  SCIP_SET* set, /**< global SCIP settings */
2853  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2854  BMS_BLKMEM* blkmem, /**< block memory */
2855  const char* name, /**< name of the parameter */
2856  const char* desc, /**< description of the parameter */
2857  SCIP_Real* valueptr, /**< pointer to store the current parameter value, or NULL */
2858  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
2859  SCIP_Real defaultvalue, /**< default value of the parameter */
2860  SCIP_Real minvalue, /**< minimum value for parameter */
2861  SCIP_Real maxvalue, /**< maximum value for parameter */
2862  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
2863  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
2864  )
2865 {
2866  assert(set != NULL);
2867 
2868  SCIP_CALL( SCIPparamsetAddReal(set->paramset, messagehdlr, blkmem, name, desc, valueptr, isadvanced,
2869  defaultvalue, minvalue, maxvalue, paramchgd, paramdata) );
2870 
2871  return SCIP_OKAY;
2872 }
2873 
2874 /** creates a char parameter, sets it to its default value, and adds it to the parameter set */
2876  SCIP_SET* set, /**< global SCIP settings */
2877  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2878  BMS_BLKMEM* blkmem, /**< block memory */
2879  const char* name, /**< name of the parameter */
2880  const char* desc, /**< description of the parameter */
2881  char* valueptr, /**< pointer to store the current parameter value, or NULL */
2882  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
2883  char defaultvalue, /**< default value of the parameter */
2884  const char* allowedvalues, /**< array with possible parameter values, or NULL if not restricted */
2885  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
2886  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
2887  )
2888 {
2889  assert(set != NULL);
2890 
2891  SCIP_CALL( SCIPparamsetAddChar(set->paramset, messagehdlr, blkmem, name, desc, valueptr, isadvanced,
2892  defaultvalue, allowedvalues, paramchgd, paramdata) );
2893 
2894  return SCIP_OKAY;
2895 }
2896 
2897 /** creates a string parameter, sets it to its default value, and adds it to the parameter set */
2899  SCIP_SET* set, /**< global SCIP settings */
2900  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2901  BMS_BLKMEM* blkmem, /**< block memory */
2902  const char* name, /**< name of the parameter */
2903  const char* desc, /**< description of the parameter */
2904  char** valueptr, /**< pointer to store the current parameter value, or NULL */
2905  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
2906  const char* defaultvalue, /**< default value of the parameter */
2907  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
2908  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
2909  )
2910 {
2911  assert(set != NULL);
2912 
2913  SCIP_CALL( SCIPparamsetAddString(set->paramset, messagehdlr, blkmem, name, desc, valueptr, isadvanced,
2914  defaultvalue, paramchgd, paramdata) );
2915 
2916  return SCIP_OKAY;
2917 }
2918 
2919 /** gets the fixing status value of an existing parameter */
2921  SCIP_SET* set, /**< global SCIP settings */
2922  const char* name /**< name of the parameter */
2923  )
2924 {
2925  assert(set != NULL);
2926 
2927  return SCIPparamsetIsFixed(set->paramset, name);
2928 }
2929 
2930 /** returns the pointer to the SCIP parameter with the given name */
2932  SCIP_SET* set, /**< global SCIP settings */
2933  const char* name /**< name of the parameter */
2934  )
2935 {
2936  assert(set != NULL);
2937 
2938  return SCIPparamsetGetParam(set->paramset, name);
2939 }
2940 
2941 /** gets the value of an existing SCIP_Bool parameter */
2943  SCIP_SET* set, /**< global SCIP settings */
2944  const char* name, /**< name of the parameter */
2945  SCIP_Bool* value /**< pointer to store the parameter */
2946  )
2947 {
2948  assert(set != NULL);
2949 
2950  SCIP_CALL( SCIPparamsetGetBool(set->paramset, name, value) );
2952  return SCIP_OKAY;
2953 }
2954 
2955 /** gets the value of an existing Int parameter */
2957  SCIP_SET* set, /**< global SCIP settings */
2958  const char* name, /**< name of the parameter */
2959  int* value /**< pointer to store the value of the parameter */
2960  )
2961 {
2962  assert(set != NULL);
2963 
2964  SCIP_CALL( SCIPparamsetGetInt(set->paramset, name, value) );
2965 
2966  return SCIP_OKAY;
2967 }
2968 
2969 /** gets the value of an existing SCIP_Longint parameter */
2971  SCIP_SET* set, /**< global SCIP settings */
2972  const char* name, /**< name of the parameter */
2973  SCIP_Longint* value /**< pointer to store the value of the parameter */
2974  )
2975 {
2976  assert(set != NULL);
2977 
2978  SCIP_CALL( SCIPparamsetGetLongint(set->paramset, name, value) );
2979 
2980  return SCIP_OKAY;
2981 }
2982 
2983 /** gets the value of an existing SCIP_Real parameter */
2985  SCIP_SET* set, /**< global SCIP settings */
2986  const char* name, /**< name of the parameter */
2987  SCIP_Real* value /**< pointer to store the value of the parameter */
2988  )
2989 {
2990  assert(set != NULL);
2991 
2992  SCIP_CALL( SCIPparamsetGetReal(set->paramset, name, value) );
2993 
2994  return SCIP_OKAY;
2995 }
2997 /** gets the value of an existing Char parameter */
2999  SCIP_SET* set, /**< global SCIP settings */
3000  const char* name, /**< name of the parameter */
3001  char* value /**< pointer to store the value of the parameter */
3002  )
3003 {
3004  assert(set != NULL);
3005 
3006  SCIP_CALL( SCIPparamsetGetChar(set->paramset, name, value) );
3008  return SCIP_OKAY;
3009 }
3010 
3011 /** gets the value of an existing String parameter */
3013  SCIP_SET* set, /**< global SCIP settings */
3014  const char* name, /**< name of the parameter */
3015  char** value /**< pointer to store the value of the parameter */
3016  )
3017 {
3018  assert(set != NULL);
3019 
3020  SCIP_CALL( SCIPparamsetGetString(set->paramset, name, value) );
3021 
3022  return SCIP_OKAY;
3023 }
3024 
3025 /** changes the fixing status of an existing parameter */
3027  SCIP_SET* set, /**< global SCIP settings */
3028  const char* name, /**< name of the parameter */
3029  SCIP_Bool fixed /**< new fixing status of the parameter */
3030  )
3031 {
3032  assert(set != NULL);
3033 
3034  SCIP_CALL( SCIPparamsetFix(set->paramset, name, fixed) );
3035 
3036  return SCIP_OKAY;
3037 }
3038 
3039 /** changes the value of an existing parameter */
3041  SCIP_SET* set, /**< global SCIP settings */
3042  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3043  const char* name, /**< name of the parameter */
3044  void* value /**< new value of the parameter */
3045  )
3047  assert(set != NULL);
3048 
3049  SCIP_CALL( SCIPparamsetSet(set->paramset, set, messagehdlr, name, value) );
3050 
3051  return SCIP_OKAY;
3052 }
3053 
3054 /** changes the value of an existing SCIP_Bool parameter */
3056  SCIP_SET* set, /**< global SCIP settings */
3057  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3058  SCIP_PARAM* param, /**< parameter */
3059  SCIP_Bool value /**< new value of the parameter */
3060  )
3061 {
3062  SCIP_RETCODE retcode;
3063 
3064  assert(set != NULL);
3065 
3066  retcode = SCIPparamSetBool(param, set, messagehdlr, value, FALSE, TRUE);
3067 
3068  if( retcode != SCIP_PARAMETERWRONGVAL )
3069  {
3070  SCIP_CALL( retcode );
3071  }
3072 
3073  return retcode;
3075 
3076 /** changes the value of an existing SCIP_Bool parameter */
3078  SCIP_SET* set, /**< global SCIP settings */
3079  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3080  const char* name, /**< name of the parameter */
3081  SCIP_Bool value /**< new value of the parameter */
3082  )
3083 {
3084  assert(set != NULL);
3085 
3086  SCIP_CALL( SCIPparamsetSetBool(set->paramset, set, messagehdlr, name, value) );
3087 
3088  return SCIP_OKAY;
3089 }
3090 
3091 /** sets the default value of an existing SCIP_Bool parameter */
3093  SCIP_SET* set, /**< global SCIP settings */
3094  const char* name, /**< name of the parameter */
3095  SCIP_Bool defaultvalue /**< new default value of the parameter */
3096  )
3097 {
3098  assert(set != NULL);
3099 
3100  SCIP_CALL( SCIPparamsetSetDefaultBool(set->paramset, name, defaultvalue) );
3101 
3102  return SCIP_OKAY;
3103 }
3104 
3105 
3106 /** changes the value of an existing Int parameter */
3108  SCIP_SET* set, /**< global SCIP settings */
3109  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3110  SCIP_PARAM* param, /**< parameter */
3111  int value /**< new value of the parameter */
3112  )
3113 {
3114  SCIP_RETCODE retcode;
3115 
3116  assert(set != NULL);
3117  assert(param != NULL);
3118 
3119  retcode = SCIPparamSetInt(param, set, messagehdlr, value, FALSE, TRUE);
3120 
3121  if( retcode != SCIP_PARAMETERWRONGVAL )
3122  {
3123  SCIP_CALL( retcode );
3124  }
3125 
3126  return retcode;
3127 }
3128 
3129 /** changes the value of an existing Int parameter */
3131  SCIP_SET* set, /**< global SCIP settings */
3132  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3133  const char* name, /**< name of the parameter */
3134  int value /**< new value of the parameter */
3135  )
3136 {
3137  assert(set != NULL);
3138 
3139  SCIP_CALL( SCIPparamsetSetInt(set->paramset, set, messagehdlr, name, value) );
3140 
3141  return SCIP_OKAY;
3142 }
3143 
3144 /** changes the default value of an existing Int parameter */
3146  SCIP_SET* set, /**< global SCIP settings */
3147  const char* name, /**< name of the parameter */
3148  int defaultvalue /**< new default value of the parameter */
3149  )
3150 {
3151  assert(set != NULL);
3152 
3153  SCIP_CALL( SCIPparamsetSetDefaultInt(set->paramset, name, defaultvalue) );
3154 
3155  return SCIP_OKAY;
3156 }
3157 
3158 /** changes the value of an existing SCIP_Longint parameter */
3160  SCIP_SET* set, /**< global SCIP settings */
3161  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3162  SCIP_PARAM* param, /**< parameter */
3163  SCIP_Longint value /**< new value of the parameter */
3164  )
3165 {
3166  SCIP_RETCODE retcode;
3167 
3168  assert(set != NULL);
3169  assert(param != NULL);
3170 
3171  retcode = SCIPparamSetLongint(param, set, messagehdlr, value, FALSE, TRUE);
3172 
3173  if( retcode != SCIP_PARAMETERWRONGVAL )
3174  {
3175  SCIP_CALL( retcode );
3176  }
3177 
3178  return retcode;
3179 }
3180 
3181 /** changes the value of an existing SCIP_Longint parameter */
3183  SCIP_SET* set, /**< global SCIP settings */
3184  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3185  const char* name, /**< name of the parameter */
3186  SCIP_Longint value /**< new value of the parameter */
3187  )
3188 {
3189  assert(set != NULL);
3190 
3191  SCIP_CALL( SCIPparamsetSetLongint(set->paramset, set, messagehdlr, name, value) );
3192 
3193  return SCIP_OKAY;
3194 }
3195 
3196 /** changes the value of an existing SCIP_Real parameter */
3198  SCIP_SET* set, /**< global SCIP settings */
3199  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3200  SCIP_PARAM* param, /**< parameter */
3201  SCIP_Real value /**< new value of the parameter */
3202  )
3203 {
3204  SCIP_RETCODE retcode;
3205 
3206  assert(set != NULL);
3207  assert(param != NULL);
3208 
3209  retcode = SCIPparamSetReal(param, set, messagehdlr, value, FALSE, TRUE);
3210 
3211  if( retcode != SCIP_PARAMETERWRONGVAL )
3212  {
3213  SCIP_CALL( retcode );
3214  }
3215 
3216  return retcode;
3217 }
3218 
3219 /** changes the value of an existing SCIP_Real parameter */
3221  SCIP_SET* set, /**< global SCIP settings */
3222  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3223  const char* name, /**< name of the parameter */
3224  SCIP_Real value /**< new value of the parameter */
3225  )
3226 {
3227  assert(set != NULL);
3228 
3229  SCIP_CALL( SCIPparamsetSetReal(set->paramset, set, messagehdlr, name, value) );
3230 
3231  return SCIP_OKAY;
3232 }
3233 
3234 /** changes the value of an existing Char parameter */
3236  SCIP_SET* set, /**< global SCIP settings */
3237  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3238  SCIP_PARAM* param, /**< parameter */
3239  char value /**< new value of the parameter */
3240  )
3241 {
3242  SCIP_RETCODE retcode;
3243 
3244  assert(set != NULL);
3245  assert(param != NULL);
3246 
3247  retcode = SCIPparamSetChar(param, set, messagehdlr, value, FALSE, TRUE);
3248 
3249  if( retcode != SCIP_PARAMETERWRONGVAL )
3250  {
3251  SCIP_CALL( retcode );
3252  }
3253 
3254  return retcode;
3255 }
3256 
3257 /** changes the value of an existing Char parameter */
3259  SCIP_SET* set, /**< global SCIP settings */
3260  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3261  const char* name, /**< name of the parameter */
3262  char value /**< new value of the parameter */
3263  )
3264 {
3265  assert(set != NULL);
3266 
3267  SCIP_CALL( SCIPparamsetSetChar(set->paramset, set, messagehdlr, name, value) );
3268 
3269  return SCIP_OKAY;
3270 }
3271 
3272 /** changes the value of an existing String parameter */
3274  SCIP_SET* set, /**< global SCIP settings */
3275  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3276  SCIP_PARAM* param, /**< parameter */
3277  const char* value /**< new value of the parameter */
3278  )
3279 {
3280  SCIP_RETCODE retcode;
3281 
3282  assert(set != NULL);
3283  assert(param != NULL);
3284 
3285  retcode = SCIPparamSetString(param, set, messagehdlr, value, TRUE);
3286 
3287  if( retcode != SCIP_PARAMETERWRONGVAL )
3288  {
3289  SCIP_CALL( retcode );
3290  }
3291 
3292  return retcode;
3293 }
3294 
3295 /** changes the value of an existing String parameter */
3297  SCIP_SET* set, /**< global SCIP settings */
3298  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3299  const char* name, /**< name of the parameter */
3300  const char* value /**< new value of the parameter */
3301  )
3302 {
3303  assert(set != NULL);
3304 
3305  SCIP_CALL( SCIPparamsetSetString(set->paramset, set, messagehdlr, name, value) );
3306 
3307  return SCIP_OKAY;
3308 }
3309 
3310 /** reads parameters from a file */
3312  SCIP_SET* set, /**< global SCIP settings */
3313  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3314  const char* filename /**< file name */
3315  )
3316 {
3317  assert(set != NULL);
3318 
3319  SCIP_CALL( SCIPparamsetRead(set->paramset, set, messagehdlr, filename) );
3320 
3321  return SCIP_OKAY;
3322 }
3323 
3324 /** writes all parameters in the parameter set to a file */
3326  SCIP_SET* set, /**< global SCIP settings */
3327  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3328  const char* filename, /**< file name, or NULL for stdout */
3329  SCIP_Bool comments, /**< should parameter descriptions be written as comments? */
3330  SCIP_Bool onlychanged /**< should only the parameters been written, that are changed from default? */
3331  )
3332 {
3333  assert(set != NULL);
3335  SCIP_CALL( SCIPparamsetWrite(set->paramset, messagehdlr, filename, comments, onlychanged) );
3336 
3337  return SCIP_OKAY;
3338 }
3339 
3340 /** resets a single parameters to its default value */
3342  SCIP_SET* set, /**< global SCIP settings */
3343  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3344  const char* name /**< name of the parameter */
3345  )
3346 {
3347  SCIP_CALL( SCIPparamsetSetToDefault(set->paramset, set, messagehdlr, name) );
3348 
3349  return SCIP_OKAY;
3350 }
3351 
3352 /** resets all parameters to their default values */
3354  SCIP_SET* set, /**< global SCIP settings */
3355  SCIP_MESSAGEHDLR* messagehdlr /**< message handler */
3356  )
3357 {
3358  SCIP_CALL( SCIPparamsetSetToDefaults(set->paramset, set, messagehdlr) );
3359 
3360  return SCIP_OKAY;
3361 }
3362 
3363 /** sets parameters to
3364  *
3365  * - \ref SCIP_PARAMEMPHASIS_DEFAULT to use default values (see also SCIPsetResetParams())
3366  * - \ref SCIP_PARAMEMPHASIS_COUNTER to get feasible and "fast" counting process
3367  * - \ref SCIP_PARAMEMPHASIS_CPSOLVER to get CP like search (e.g. no LP relaxation)
3368  * - \ref SCIP_PARAMEMPHASIS_EASYCIP to solve easy problems fast
3369  * - \ref SCIP_PARAMEMPHASIS_FEASIBILITY to detect feasibility fast
3370  * - \ref SCIP_PARAMEMPHASIS_HARDLP to be capable to handle hard LPs
3371  * - \ref SCIP_PARAMEMPHASIS_OPTIMALITY to prove optimality fast
3372  * - \ref SCIP_PARAMEMPHASIS_PHASEFEAS to find feasible solutions during a 3 phase solution process
3373  * - \ref SCIP_PARAMEMPHASIS_PHASEIMPROVE to find improved solutions during a 3 phase solution process
3374  * - \ref SCIP_PARAMEMPHASIS_PHASEPROOF to proof optimality during a 3 phase solution process
3375  */
3377  SCIP_SET* set, /**< global SCIP settings */
3378  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3379  SCIP_PARAMEMPHASIS paramemphasis, /**< parameter settings */
3380  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
3381  )
3382 {
3383  SCIP_CALL( SCIPparamsetSetEmphasis(set->paramset, set, messagehdlr, paramemphasis, quiet) );
3384 
3385  return SCIP_OKAY;
3386 }
3388 /** sets parameters to deactivate separators and heuristics that use auxiliary SCIP instances; should be called for
3389  * auxiliary SCIP instances to avoid recursion
3390  */
3392  SCIP_SET* set, /**< global SCIP settings */
3393  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3394  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
3395  )
3396 {
3397  SCIP_CALL( SCIPparamsetSetToSubscipsOff(set->paramset, set, messagehdlr, quiet) );
3398 
3399  return SCIP_OKAY;
3400 }
3402 /** sets heuristic parameters values to
3403  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all heuristic parameters
3404  * - SCIP_PARAMSETTING_FAST such that the time spent on heuristics is decreased
3405  * - SCIP_PARAMSETTING_AGGRESSIVE such that the heuristics are called more aggressively
3406  * - SCIP_PARAMSETTING_OFF which turn off all heuristics
3407  */
3409  SCIP_SET* set, /**< global SCIP settings */
3410  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3411  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
3412  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
3413  )
3414 {
3415  SCIP_CALL( SCIPparamsetSetHeuristics(set->paramset, set, messagehdlr, paramsetting, quiet) );
3416 
3417  return SCIP_OKAY;
3418 }
3419 
3420 /** sets presolving parameters to
3421  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all presolving parameters
3422  * - SCIP_PARAMSETTING_FAST such that the time spent on presolving is decreased
3423  * - SCIP_PARAMSETTING_AGGRESSIVE such that the presolving is more aggressive
3424  * - SCIP_PARAMSETTING_OFF which turn off all presolving
3425  */
3427  SCIP_SET* set, /**< global SCIP settings */
3428  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3429  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
3430  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
3431  )
3432 {
3433  SCIP_CALL( SCIPparamsetSetPresolving(set->paramset, set, messagehdlr, paramsetting, quiet) );
3434 
3435  return SCIP_OKAY;
3436 }
3437 
3438 /** sets separating parameters to
3439  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all separating parameters
3440  * - SCIP_PARAMSETTING_FAST such that the time spent on separating is decreased
3441  * - SCIP_PARAMSETTING_AGGRESSIVE such that separating is more aggressive
3442  * - SCIP_PARAMSETTING_OFF which turn off all separating
3443  */
3445  SCIP_SET* set, /**< global SCIP settings */
3446  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3447  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
3448  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
3449  )
3450 {
3451  SCIP_CALL( SCIPparamsetSetSeparating(set->paramset, set, messagehdlr, paramsetting, quiet) );
3453  return SCIP_OKAY;
3454 }
3455 
3456 /** returns the array of all available SCIP parameters */
3458  SCIP_SET* set /**< global SCIP settings */
3459  )
3460 {
3461  assert(set != NULL);
3462 
3463  return SCIPparamsetGetParams(set->paramset);
3464 }
3465 
3466 /** returns the total number of all available SCIP parameters */
3468  SCIP_SET* set /**< global SCIP settings */
3469  )
3470 {
3471  assert(set != NULL);
3472 
3473  return SCIPparamsetGetNParams(set->paramset);
3474 }
3475 
3476 /** inserts file reader in file reader list */
3478  SCIP_SET* set, /**< global SCIP settings */
3479  SCIP_READER* reader /**< file reader */
3480  )
3481 {
3482  assert(set != NULL);
3483  assert(reader != NULL);
3485  if( set->nreaders >= set->readerssize )
3486  {
3487  set->readerssize = SCIPsetCalcMemGrowSize(set, set->nreaders+1);
3488  SCIP_ALLOC( BMSreallocMemoryArray(&set->readers, set->readerssize) );
3489  }
3490  assert(set->nreaders < set->readerssize);
3491 
3492  set->readers[set->nreaders] = reader;
3493  set->nreaders++;
3494 
3495  return SCIP_OKAY;
3496 }
3497 
3498 /** returns the file reader of the given name, or NULL if not existing */
3500  SCIP_SET* set, /**< global SCIP settings */
3501  const char* name /**< name of file reader */
3502  )
3503 {
3504  int i;
3505 
3506  assert(set != NULL);
3507  assert(name != NULL);
3508 
3509  for( i = 0; i < set->nreaders; ++i )
3510  {
3511  if( strcmp(SCIPreaderGetName(set->readers[i]), name) == 0 )
3512  return set->readers[i];
3513  }
3514 
3515  return NULL;
3516 }
3517 
3518 /** inserts variable pricer in variable pricer list */
3520  SCIP_SET* set, /**< global SCIP settings */
3521  SCIP_PRICER* pricer /**< variable pricer */
3522  )
3523 {
3524  assert(set != NULL);
3525  assert(pricer != NULL);
3526 
3527  if( set->npricers >= set->pricerssize )
3528  {
3529  set->pricerssize = SCIPsetCalcMemGrowSize(set, set->npricers+1);
3530  SCIP_ALLOC( BMSreallocMemoryArray(&set->pricers, set->pricerssize) );
3531  }
3532  assert(set->npricers < set->pricerssize);
3534  set->pricers[set->npricers] = pricer;
3535  set->npricers++;
3536  set->pricerssorted = FALSE;
3537 
3538  return SCIP_OKAY;
3539 }
3540 
3541 /** returns the variable pricer of the given name, or NULL if not existing */
3543  SCIP_SET* set, /**< global SCIP settings */
3544  const char* name /**< name of variable pricer */
3545  )
3546 {
3547  int i;
3548 
3549  assert(set != NULL);
3550  assert(name != NULL);
3551 
3552  for( i = 0; i < set->npricers; ++i )
3553  {
3554  if( strcmp(SCIPpricerGetName(set->pricers[i]), name) == 0 )
3555  return set->pricers[i];
3556  }
3557 
3558  return NULL;
3559 }
3560 
3561 /** sorts pricers by priorities */
3562 void SCIPsetSortPricers(
3563  SCIP_SET* set /**< global SCIP settings */
3564  )
3565 {
3566  assert(set != NULL);
3567 
3568  if( !set->pricerssorted )
3569  {
3570  SCIPsortPtr((void**)set->pricers, SCIPpricerComp, set->npricers);
3571  set->pricerssorted = TRUE;
3572  set->pricersnamesorted = FALSE;
3573  }
3574 }
3576 /** sorts pricers by name */
3578  SCIP_SET* set /**< global SCIP settings */
3579  )
3580 {
3581  assert(set != NULL);
3582 
3583  if( !set->pricersnamesorted )
3584  {
3585  SCIPsortPtr((void**)set->pricers, SCIPpricerCompName, set->npricers);
3586  set->pricerssorted = FALSE;
3587  set->pricersnamesorted = TRUE;
3588  }
3589 }
3590 
3591 /** inserts Benders' decomposition in the Benders' decomposition list */
3593  SCIP_SET* set, /**< global SCIP settings */
3594  SCIP_BENDERS* benders /**< Benders' decomposition structure */
3595  )
3596 {
3597  assert(set != NULL);
3598  assert(benders != NULL);
3599 
3600  if( set->nbenders >= set->benderssize )
3601  {
3602  set->benderssize = SCIPsetCalcMemGrowSize(set, set->nbenders+1);
3603  SCIP_ALLOC( BMSreallocMemoryArray(&set->benders, set->benderssize) );
3604  }
3605  assert(set->nbenders < set->benderssize);
3606 
3607  set->benders[set->nbenders] = benders;
3608  set->nbenders++;
3609  set->benderssorted = FALSE;
3610 
3611  return SCIP_OKAY;
3612 }
3613 
3614 /** returns the Benders' decomposition of the given name, or NULL if not existing */
3616  SCIP_SET* set, /**< global SCIP settings */
3617  const char* name /**< name of the Benders' decomposition */
3618  )
3619 {
3620  int i;
3621 
3622  assert(set != NULL);
3623  assert(name != NULL);
3624 
3625  for( i = 0; i < set->nbenders; ++i )
3626  {
3627  if( strcmp(SCIPbendersGetName(set->benders[i]), name) == 0 )
3628  return set->benders[i];
3629  }
3630 
3631  return NULL;
3632 }
3633 
3634 /** sorts Benders' decomposition by priorities */
3635 void SCIPsetSortBenders(
3636  SCIP_SET* set /**< global SCIP settings */
3637  )
3639  assert(set != NULL);
3640 
3641  if( !set->benderssorted )
3642  {
3643  SCIPsortPtr((void**)set->benders, SCIPbendersComp, set->nbenders);
3644  set->benderssorted = TRUE;
3645  set->bendersnamesorted = FALSE;
3646  }
3647 }
3648 
3649 /** sorts Benders' decomposition by name */
3651  SCIP_SET* set /**< global SCIP settings */
3652  )
3654  assert(set != NULL);
3655 
3656  if( !set->bendersnamesorted )
3657  {
3658  SCIPsortPtr((void**)set->benders, SCIPbendersCompName, set->nbenders);
3659  set->benderssorted = FALSE;
3660  set->bendersnamesorted = TRUE;
3661  }
3662 }
3663 
3664 /** inserts constraint handler in constraint handler list */
3666  SCIP_SET* set, /**< global SCIP settings */
3667  SCIP_CONSHDLR* conshdlr /**< constraint handler */
3668  )
3669 {
3670  int priority;
3671  int i;
3672 
3673  assert(set != NULL);
3674  assert(conshdlr != NULL);
3675  assert(!SCIPconshdlrIsInitialized(conshdlr));
3676 
3677  /* allocate memory */
3678  if( set->nconshdlrs >= set->conshdlrssize )
3679  {
3680  set->conshdlrssize = SCIPsetCalcMemGrowSize(set, set->nconshdlrs+1);
3681  SCIP_ALLOC( BMSreallocMemoryArray(&set->conshdlrs, set->conshdlrssize) );
3682  SCIP_ALLOC( BMSreallocMemoryArray(&set->conshdlrs_sepa, set->conshdlrssize) );
3683  SCIP_ALLOC( BMSreallocMemoryArray(&set->conshdlrs_enfo, set->conshdlrssize) );
3684  SCIP_ALLOC( BMSreallocMemoryArray(&set->conshdlrs_include, set->conshdlrssize) );
3685  }
3686  assert(set->nconshdlrs < set->conshdlrssize);
3687 
3688  /* sort constraint handler into conshdlrs array sorted by check priority */
3689  priority = SCIPconshdlrGetCheckPriority(conshdlr);
3690  for( i = set->nconshdlrs; i > 0 && SCIPconshdlrGetCheckPriority(set->conshdlrs[i-1]) < priority; --i )
3691  {
3692  set->conshdlrs[i] = set->conshdlrs[i-1];
3693  }
3694  set->conshdlrs[i] = conshdlr;
3695 
3696  /* sort constraint handler into conshdlrs_sepa array sorted by sepa priority */
3697  priority = SCIPconshdlrGetSepaPriority(conshdlr);
3698  for( i = set->nconshdlrs; i > 0 && SCIPconshdlrGetSepaPriority(set->conshdlrs_sepa[i-1]) < priority; --i )
3699  {
3700  set->conshdlrs_sepa[i] = set->conshdlrs_sepa[i-1];
3701  }
3702  set->conshdlrs_sepa[i] = conshdlr;
3703 
3704  /* sort constraint handler into conshdlrs_enfo array sorted by enfo priority */
3705  priority = SCIPconshdlrGetEnfoPriority(conshdlr);
3706  for( i = set->nconshdlrs; i > 0 && SCIPconshdlrGetEnfoPriority(set->conshdlrs_enfo[i-1]) < priority; --i )
3707  {
3708  set->conshdlrs_enfo[i] = set->conshdlrs_enfo[i-1];
3709  }
3710  set->conshdlrs_enfo[i] = conshdlr;
3712  /* add constraint handler into conshdlrs_include array sorted by inclusion order */
3713  set->conshdlrs_include[set->nconshdlrs] = conshdlr;
3714 
3715  set->nconshdlrs++;
3716 
3717  return SCIP_OKAY;
3718 }
3719 
3720 /** reinserts a constraint handler with modified sepa priority into the sepa priority sorted array */
3722  SCIP_SET* set, /**< global SCIP settings */
3723  SCIP_CONSHDLR* conshdlr, /**< constraint handler to be reinserted */
3724  int oldpriority /**< the old separation priority of constraint handler */
3725  )
3727  int newpriority;
3728  int newpos;
3729  int i;
3730  assert(set != NULL);
3731  assert(conshdlr != NULL);
3732 
3733  newpriority = SCIPconshdlrGetSepaPriority(conshdlr);
3734  newpos = -1;
3735 
3736  /* search for the old position of constraint handler; determine its new position at the same time */
3737  if( newpriority > oldpriority )
3738  {
3739  i = 0;
3740  while( i < set->nconshdlrs &&
3741  strcmp(SCIPconshdlrGetName(set->conshdlrs_sepa[i]), SCIPconshdlrGetName(conshdlr)) != 0 )
3742  {
3743  int priorityatpos;
3744 
3745  priorityatpos = SCIPconshdlrGetSepaPriority(set->conshdlrs_sepa[i]);
3746  assert(priorityatpos >= oldpriority);
3747 
3748  /* current index is the position to insert the constraint handler */
3749  if( newpriority > priorityatpos && newpos == -1 )
3750  newpos = i;
3751 
3752  ++i;
3753  }
3754  assert(i < set->nconshdlrs);
3755 
3756  /* constraint must change its position in array */
3757  if( newpos != -1 )
3758  {
3759  /* shift all constraint handlers between old and new position by one, and insert constraint handler */
3760  for( ; i > newpos; --i )
3761  {
3762  set->conshdlrs_sepa[i] = set->conshdlrs_sepa[i-1];
3763  }
3764  set->conshdlrs_sepa[newpos] = conshdlr;
3765  }
3766  }
3767  else if( newpriority < oldpriority )
3768  {
3769  i = set->nconshdlrs - 1;
3770  while( i >= 0 && strcmp(SCIPconshdlrGetName(set->conshdlrs_sepa[i]), SCIPconshdlrGetName(conshdlr)) != 0 )
3771  {
3772  int priorityatpos;
3773 
3774  priorityatpos = SCIPconshdlrGetSepaPriority(set->conshdlrs_sepa[i]);
3775  assert(priorityatpos <= oldpriority);
3776 
3777  /* current index is the position to insert the constraint handler */
3778  if( newpriority < priorityatpos && newpos == -1 )
3779  newpos = i;
3780 
3781  --i;
3782  }
3783  assert(i >= 0);
3784 
3785  /* constraint must change its position in array */
3786  if( newpos != -1 )
3787  {
3788  /* shift all constraint handlers between old and new position by one, and insert constraint handler */
3789  for(; i < newpos; ++i )
3790  {
3791  set->conshdlrs_sepa[i] = set->conshdlrs_sepa[i + 1];
3792  }
3793  set->conshdlrs_sepa[newpos] = conshdlr;
3794  }
3795 #ifndef NDEBUG
3796  for( i = 0; i < set->nconshdlrs - 1; ++i )
3797  assert(SCIPconshdlrGetSepaPriority(set->conshdlrs_sepa[i])
3798  >= SCIPconshdlrGetSepaPriority(set->conshdlrs_sepa[i + 1]));
3799 #endif
3800  }
3801 }
3802 
3803 /** returns the constraint handler of the given name, or NULL if not existing */
3805  SCIP_SET* set, /**< global SCIP settings */
3806  const char* name /**< name of constraint handler */
3807  )
3808 {
3809  int i;
3810 
3811  assert(set != NULL);
3812  assert(name != NULL);
3813 
3814  for( i = 0; i < set->nconshdlrs; ++i )
3815  {
3816  if( strcmp(SCIPconshdlrGetName(set->conshdlrs[i]), name) == 0 )
3817  return set->conshdlrs[i];
3818  }
3819 
3820  return NULL;
3821 }
3822 
3823 /** inserts conflict handler in conflict handler list */
3825  SCIP_SET* set, /**< global SCIP settings */
3826  SCIP_CONFLICTHDLR* conflicthdlr /**< conflict handler */
3827  )
3828 {
3829  assert(set != NULL);
3830  assert(conflicthdlr != NULL);
3831  assert(!SCIPconflicthdlrIsInitialized(conflicthdlr));
3832 
3833  if( set->nconflicthdlrs >= set->conflicthdlrssize )
3834  {
3835  set->conflicthdlrssize = SCIPsetCalcMemGrowSize(set, set->nconflicthdlrs+1);
3836  SCIP_ALLOC( BMSreallocMemoryArray(&set->conflicthdlrs, set->conflicthdlrssize) );
3837  }
3838  assert(set->nconflicthdlrs < set->conflicthdlrssize);
3839 
3840  set->conflicthdlrs[set->nconflicthdlrs] = conflicthdlr;
3841  set->nconflicthdlrs++;
3842  set->conflicthdlrssorted = FALSE;
3843 
3844  return SCIP_OKAY;
3845 }
3846 
3847 /** returns the conflict handler of the given name, or NULL if not existing */
3849  SCIP_SET* set, /**< global SCIP settings */
3850  const char* name /**< name of conflict handler */
3851  )
3852 {
3853  int i;
3854 
3855  assert(set != NULL);
3856  assert(name != NULL);
3857 
3858  for( i = 0; i < set->nconflicthdlrs; ++i )
3859  {
3860  if( strcmp(SCIPconflicthdlrGetName(set->conflicthdlrs[i]), name) == 0 )
3861  return set->conflicthdlrs[i];
3862  }
3863 
3864  return NULL;
3865 }
3866 
3867 /** sorts conflict handlers by priorities */
3869  SCIP_SET* set /**< global SCIP settings */
3870  )
3871 {
3872  assert(set != NULL);
3873 
3874  if( !set->conflicthdlrssorted )
3875  {
3876  SCIPsortPtr((void**)set->conflicthdlrs, SCIPconflicthdlrComp, set->nconflicthdlrs);
3877  set->conflicthdlrssorted = TRUE;
3878  set->conflicthdlrsnamesorted = FALSE;
3879  }
3881 
3882 /** sorts conflict handlers by name */
3884  SCIP_SET* set /**< global SCIP settings */
3885  )
3886 {
3887  assert(set != NULL);
3888 
3889  if( !set->conflicthdlrsnamesorted )
3890  {
3891  SCIPsortPtr((void**)set->conflicthdlrs, SCIPconflicthdlrCompName, set->nconflicthdlrs);
3892  set->conflicthdlrssorted = FALSE;
3893  set->conflicthdlrsnamesorted = TRUE;
3894  }
3895 }
3896 
3897 /** inserts presolver in presolver list */
3899  SCIP_SET* set, /**< global SCIP settings */
3900  SCIP_PRESOL* presol /**< presolver */
3901  )
3902 {
3903  assert(set != NULL);
3904  assert(presol != NULL);
3905 
3906  if( set->npresols >= set->presolssize )
3907  {
3908  set->presolssize = SCIPsetCalcMemGrowSize(set, set->npresols+1);
3909  SCIP_ALLOC( BMSreallocMemoryArray(&set->presols, set->presolssize) );
3910  }
3911  assert(set->npresols < set->presolssize);
3912 
3913  set->presols[set->npresols] = presol;
3914  set->npresols++;
3915  set->presolssorted = FALSE;
3916 
3917  return SCIP_OKAY;
3918 }
3919 
3920 /** returns the presolver of the given name, or NULL if not existing */
3922  SCIP_SET* set, /**< global SCIP settings */
3923  const char* name /**< name of presolver */
3924  )
3925 {
3926  int i;
3927 
3928  assert(set != NULL);
3929  assert(name != NULL);
3930 
3931  for( i = 0; i < set->npresols; ++i )
3932  {
3933  if( strcmp(SCIPpresolGetName(set->presols[i]), name) == 0 )
3934  return set->presols[i];
3935  }
3936 
3937  return NULL;
3938 }
3939 
3940 /** sorts presolvers by priorities */
3941 void SCIPsetSortPresols(
3942  SCIP_SET* set /**< global SCIP settings */
3943  )
3945  assert(set != NULL);
3946 
3947  if( !set->presolssorted )
3948  {
3949  SCIPsortPtr((void**)set->presols, SCIPpresolComp, set->npresols);
3950  set->presolssorted = TRUE;
3951  set->presolsnamesorted = FALSE;
3952  }
3953 }
3954 
3955 /** sorts presolvers by name */
3957  SCIP_SET* set /**< global SCIP settings */
3958  )
3960  assert(set != NULL);
3961 
3962  if( !set->presolsnamesorted )
3963  {
3964  SCIPsortPtr((void**)set->presols, SCIPpresolCompName, set->npresols);
3965  set->presolssorted = FALSE;
3966  set->presolsnamesorted = TRUE;
3967  }
3968 }
3969 
3970 /** inserts relaxator in relaxator list */
3972  SCIP_SET* set, /**< global SCIP settings */
3973  SCIP_RELAX* relax /**< relaxator */
3974  )
3975 {
3976  assert(set != NULL);
3977  assert(relax != NULL);
3978  assert(!SCIPrelaxIsInitialized(relax));
3979 
3980  if( set->nrelaxs >= set->relaxssize )
3981  {
3982  set->relaxssize = SCIPsetCalcMemGrowSize(set, set->nrelaxs+1);
3983  SCIP_ALLOC( BMSreallocMemoryArray(&set->relaxs, set->relaxssize) );
3984  }
3985  assert(set->nrelaxs < set->relaxssize);
3986 
3987  set->relaxs[set->nrelaxs] = relax;
3988  set->nrelaxs++;
3989  set->relaxssorted = FALSE;
3990 
3991  return SCIP_OKAY;
3992 }
3993 
3994 /** returns the relaxator of the given name, or NULL if not existing */
3996  SCIP_SET* set, /**< global SCIP settings */
3997  const char* name /**< name of relaxator */
3998  )
3999 {
4000  int i;
4001 
4002  assert(set != NULL);
4003  assert(name != NULL);
4004 
4005  for( i = 0; i < set->nrelaxs; ++i )
4006  {
4007  if( strcmp(SCIPrelaxGetName(set->relaxs[i]), name) == 0 )
4008  return set->relaxs[i];
4009  }
4010 
4011  return NULL;
4012 }
4013 
4014 /** sorts relaxators by priorities */
4015 void SCIPsetSortRelaxs(
4016  SCIP_SET* set /**< global SCIP settings */
4017  )
4018 {
4019  assert(set != NULL);
4020 
4021  if( !set->relaxssorted )
4022  {
4023  SCIPsortPtr((void**)set->relaxs, SCIPrelaxComp, set->nrelaxs);
4024  set->relaxssorted = TRUE;
4025  set->relaxsnamesorted = FALSE;
4026  }
4027 }
4028 
4029 /** sorts relaxators by priorities */
4031  SCIP_SET* set /**< global SCIP settings */
4032  )
4033 {
4034  assert(set != NULL);
4035 
4036  if( !set->relaxsnamesorted )
4037  {
4038  SCIPsortPtr((void**)set->relaxs, SCIPrelaxCompName, set->nrelaxs);
4039  set->relaxssorted = FALSE;
4040  set->relaxsnamesorted = TRUE;
4041  }
4042 }
4043 
4044 /** inserts separator in separator list */
4046  SCIP_SET* set, /**< global SCIP settings */
4047  SCIP_SEPA* sepa /**< separator */
4048  )
4049 {
4050  assert(set != NULL);
4051  assert(sepa != NULL);
4052  assert(!SCIPsepaIsInitialized(sepa));
4053 
4054  if( set->nsepas >= set->sepassize )
4055  {
4056  set->sepassize = SCIPsetCalcMemGrowSize(set, set->nsepas+1);
4057  SCIP_ALLOC( BMSreallocMemoryArray(&set->sepas, set->sepassize) );
4058  }
4059  assert(set->nsepas < set->sepassize);
4060 
4061  set->sepas[set->nsepas] = sepa;
4062  set->nsepas++;
4063  set->sepassorted = FALSE;
4064 
4065  return SCIP_OKAY;
4066 }
4067 
4068 /** returns the separator of the given name, or NULL if not existing */
4070  SCIP_SET* set, /**< global SCIP settings */
4071  const char* name /**< name of separator */
4072  )
4073 {
4074  int i;
4075 
4076  assert(set != NULL);
4077  assert(name != NULL);
4078 
4079  for( i = 0; i < set->nsepas; ++i )
4080  {
4081  if( strcmp(SCIPsepaGetName(set->sepas[i]), name) == 0 )
4082  return set->sepas[i];
4083  }
4084 
4085  return NULL;
4086 }
4087 
4088 /** sorts separators by priorities */
4089 void SCIPsetSortSepas(
4090  SCIP_SET* set /**< global SCIP settings */
4091  )
4092 {
4093  assert(set != NULL);
4094 
4095  if( !set->sepassorted )
4096  {
4097  SCIPsortPtr((void**)set->sepas, SCIPsepaComp, set->nsepas);
4098  set->sepassorted = TRUE;
4099  set->sepasnamesorted = FALSE;
4100  }
4101 }
4102 
4103 /** sorts separators by name */
4105  SCIP_SET* set /**< global SCIP settings */
4106  )
4107 {
4108  assert(set != NULL);
4109 
4110  if( !set->sepasnamesorted )
4111  {
4112  SCIPsortPtr((void**)set->sepas, SCIPsepaCompName, set->nsepas);
4113  set->sepassorted = FALSE;
4114  set->sepasnamesorted = TRUE;
4115  }
4116 }
4117 
4118 /** inserts propagator in propagator list */
4120  SCIP_SET* set, /**< global SCIP settings */
4121  SCIP_PROP* prop /**< propagator */
4122  )
4123 {
4124  assert(set != NULL);
4125  assert(prop != NULL);
4126  assert(!SCIPpropIsInitialized(prop));
4127 
4128  if( set->nprops >= set->propssize )
4129  {
4130  set->propssize = SCIPsetCalcMemGrowSize(set, set->nprops+1);
4131  SCIP_ALLOC( BMSreallocMemoryArray(&set->props, set->propssize) );
4132  SCIP_ALLOC( BMSreallocMemoryArray(&set->props_presol, set->propssize) );
4133  }
4134  assert(set->nprops < set->propssize);
4135 
4136  set->props[set->nprops] = prop;
4137  set->props_presol[set->nprops] = prop;
4138  set->nprops++;
4139  set->propssorted = FALSE;
4140  set->propspresolsorted = FALSE;
4141 
4142  return SCIP_OKAY;
4143 }
4144 
4145 /** returns the propagator of the given name, or NULL if not existing */
4147  SCIP_SET* set, /**< global SCIP settings */
4148  const char* name /**< name of propagator */
4149  )
4150 {
4151  int i;
4152 
4153  assert(set != NULL);
4154  assert(name != NULL);
4155 
4156  for( i = 0; i < set->nprops; ++i )
4157  {
4158  if( strcmp(SCIPpropGetName(set->props[i]), name) == 0 )
4159  return set->props[i];
4160  }
4161 
4162  return NULL;
4163 }
4164 
4165 /** sorts propagators by priorities */
4166 void SCIPsetSortProps(
4167  SCIP_SET* set /**< global SCIP settings */
4168  )
4169 {
4170  assert(set != NULL);
4171 
4172  if( !set->propssorted )
4173  {
4174  SCIPsortPtr((void**)set->props, SCIPpropComp, set->nprops);
4175  set->propssorted = TRUE;
4176  set->propsnamesorted = FALSE;
4177  }
4178 }
4179 
4180 /** sorts propagators by priorities for presolving */
4182  SCIP_SET* set /**< global SCIP settings */
4183  )
4184 {
4185  assert(set != NULL);
4186 
4187  if( !set->propspresolsorted )
4188  {
4189  SCIPsortPtr((void**)set->props_presol, SCIPpropCompPresol, set->nprops);
4190  set->propspresolsorted = TRUE;
4191  set->propsnamesorted = FALSE;
4192  }
4193 }
4194 
4195 /** sorts propagators w.r.t. names */
4197  SCIP_SET* set /**< global SCIP settings */
4198  )
4199 {
4200  assert(set != NULL);
4201 
4202  if( !set->propsnamesorted )
4203  {
4204  SCIPsortPtr((void**)set->props, SCIPpropCompName, set->nprops);
4205  set->propssorted = FALSE;
4206  set->propsnamesorted = TRUE;
4207  }
4208 }
4209 
4210 /** inserts bandit virtual function table into set */
4212  SCIP_SET* set, /**< global SCIP settings */
4213  SCIP_BANDITVTABLE* banditvtable /**< bandit algorithm virtual function table */
4214  )
4215 {
4216  assert(set != NULL);
4217  assert(banditvtable != NULL);
4218 
4219  if( set->nbanditvtables >= set->banditvtablessize )
4220  {
4221  int newsize = SCIPsetCalcMemGrowSize(set, set->nbanditvtables + 1);
4222  SCIP_ALLOC( BMSreallocMemoryArray(&set->banditvtables, newsize) );
4223  set->banditvtablessize = newsize;
4224  }
4225 
4226  assert(set->nbanditvtables < set->banditvtablessize);
4227  set->banditvtables[set->nbanditvtables++] = banditvtable;
4228 
4229  return SCIP_OKAY;
4230 }
4231 
4232 /** returns the bandit virtual function table of the given name, or NULL if not existing */
4234  SCIP_SET* set, /**< global SCIP settings */
4235  const char* name /**< name of bandit algorithm virtual function table */
4236  )
4237 {
4238  int b;
4239 
4240  assert(set != NULL);
4241  assert(name != NULL);
4243  /* search for a bandit v table of the given name */
4244  for( b = 0; b < set->nbanditvtables; ++b )
4245  {
4246  if( strcmp(name, SCIPbanditvtableGetName(set->banditvtables[b])) == 0 )
4247  return set->banditvtables[b];
4248  }
4249 
4250  return NULL;
4251 }
4252 
4253 /** inserts concurrent solver type into the concurrent solver type list */
4255  SCIP_SET* set, /**< global SCIP settings */
4256  SCIP_CONCSOLVERTYPE* concsolvertype /**< concurrent solver type */
4257  )
4258 {
4259  assert(set != NULL);
4260  assert(concsolvertype != NULL);
4261 
4262  if( set->nconcsolvertypes >= set->concsolvertypessize )
4263  {
4264  set->concsolvertypessize = SCIPsetCalcMemGrowSize(set, set->nconcsolvertypes + 1);
4265  SCIP_ALLOC( BMSreallocMemoryArray(&set->concsolvertypes, set->concsolvertypessize) );
4266  }
4267  assert(set->nconcsolvertypes < set->concsolvertypessize);
4268 
4269  set->concsolvertypes[set->nconcsolvertypes] = concsolvertype;
4270  set->nconcsolvertypes++;
4271 
4272  return SCIP_OKAY;
4273 }
4274 
4275 /** returns the concurrent solver type with the given name, or NULL if not existing */
4277  SCIP_SET* set, /**< global SCIP settings */
4278  const char* name /**< name of concurrent solver type */
4279  )
4280 {
4281  int i;
4282 
4283  assert(set != NULL);
4284  assert(name != NULL);
4285 
4286  for( i = 0; i < set->nconcsolvertypes; ++i )
4287  {
4288  if( strcmp(SCIPconcsolverTypeGetName(set->concsolvertypes[i]), name) == 0 )
4289  return set->concsolvertypes[i];
4290  }
4291 
4292  return NULL;
4293 }
4294 
4295 /** inserts concurrent solver into the concurrent solver list */
4297  SCIP_SET* set, /**< global SCIP settings */
4298  SCIP_CONCSOLVER* concsolver /**< concurrent solver */
4299  )
4300 {
4301  assert(set != NULL);
4302  assert(concsolver != NULL);
4303 
4304  if( set->nconcsolvers >= set->concsolverssize )
4305  {
4306  set->concsolverssize = SCIPsetCalcMemGrowSize(set, set->nconcsolvers + 1);
4307  SCIP_ALLOC( BMSreallocMemoryArray(&set->concsolvers, set->concsolverssize) );
4308  }
4309  assert(set->nconcsolvers < set->concsolverssize);
4310 
4311  set->concsolvers[set->nconcsolvers] = concsolver;
4312  assert(set->nconcsolvers == SCIPconcsolverGetIdx(concsolver));
4313 
4314  set->nconcsolvers++;
4315 
4316  return SCIP_OKAY;
4317 }
4318 
4319 /** frees all concurrent solvers in the concurrent solver list */
4321  SCIP_SET* set /**< global SCIP settings */
4322  )
4323 {
4324  int i;
4325  assert(set != NULL);
4326 
4327  /* call user callback for each concurrent solver */
4328  for( i = 0; i < set->nconcsolvers; ++i )
4329  {
4330  SCIP_CALL( SCIPconcsolverDestroyInstance(set, &set->concsolvers[i]) );
4331  }
4332 
4333  /* set size and number to zero and free the concurent solver array */
4334  set->nconcsolvers = 0;
4335  set->concsolverssize = 0;
4336  BMSfreeMemoryArrayNull(&set->concsolvers);
4337 
4338  return SCIP_OKAY;
4339 }
4340 
4341 /** inserts primal heuristic in primal heuristic list */
4343  SCIP_SET* set, /**< global SCIP settings */
4344  SCIP_HEUR* heur /**< primal heuristic */
4345  )
4346 {
4347  assert(set != NULL);
4348  assert(heur != NULL);
4349  assert(!SCIPheurIsInitialized(heur));
4350 
4351  if( set->nheurs >= set->heurssize )
4352  {
4353  set->heurssize = SCIPsetCalcMemGrowSize(set, set->nheurs+1);
4354  SCIP_ALLOC( BMSreallocMemoryArray(&set->heurs, set->heurssize) );
4355  }
4356  assert(set->nheurs < set->heurssize);
4357 
4358  set->heurs[set->nheurs] = heur;
4359  set->nheurs++;
4360  set->heurssorted = FALSE;
4361 
4362  return SCIP_OKAY;
4363 }
4364 
4365 /** returns the primal heuristic of the given name, or NULL if not existing */
4367  SCIP_SET* set, /**< global SCIP settings */
4368  const char* name /**< name of primal heuristic */
4369  )
4370 {
4371  int i;
4373  assert(set != NULL);
4374  assert(name != NULL);
4375 
4376  for( i = 0; i < set->nheurs; ++i )
4377  {
4378  if( strcmp(SCIPheurGetName(set->heurs[i]), name) == 0 )
4379  return set->heurs[i];
4380  }
4381 
4382  return NULL;
4383 }
4384 
4385 /** sorts heuristics by priorities */
4386 void SCIPsetSortHeurs(
4387  SCIP_SET* set /**< global SCIP settings */
4388  )
4389 {
4390  assert(set != NULL);
4391 
4392  if( !set->heurssorted )
4393  {
4394  SCIPsortPtr((void**)set->heurs, SCIPheurComp, set->nheurs);
4395  set->heurssorted = TRUE;
4396  set->heursnamesorted = FALSE;
4397  }
4398 }
4399 
4400 /** sorts heuristics by names */
4402  SCIP_SET* set /**< global SCIP settings */
4403  )
4404 {
4405  assert(set != NULL);
4406 
4407  if( !set->heursnamesorted )
4408  {
4409  SCIPsortPtr((void**)set->heurs, SCIPheurCompName, set->nheurs);
4410  set->heurssorted = FALSE;
4411  set->heursnamesorted = TRUE;
4412  }
4413 }
4414 
4415 /** inserts tree compression in tree compression list */
4417  SCIP_SET* set, /**< global SCIP settings */
4418  SCIP_COMPR* compr /**< tree compression */
4419  )
4420 {
4421  assert(set != NULL);
4422  assert(compr != NULL);
4423  assert(!SCIPcomprIsInitialized(compr));
4424 
4425  if( set->ncomprs >= set->comprssize )
4426  {
4427  set->comprssize = SCIPsetCalcMemGrowSize(set, set->ncomprs+1);
4428  SCIP_ALLOC( BMSreallocMemoryArray(&set->comprs, set->comprssize) );
4429  }
4430  assert(set->ncomprs < set->comprssize);
4431 
4432  set->comprs[set->ncomprs] = compr;
4433  set->ncomprs++;
4434  set->comprssorted = FALSE;
4435 
4436  return SCIP_OKAY;
4437 }
4438 
4439 /** returns the tree compression of the given name, or NULL if not existing */
4441  SCIP_SET* set, /**< global SCIP settings */
4442  const char* name /**< name of tree compression */
4443  )
4444 {
4445  int i;
4446 
4447  assert(set != NULL);
4448  assert(name != NULL);
4449 
4450  for( i = 0; i < set->ncomprs; ++i )
4451  {
4452  if( strcmp(SCIPcomprGetName(set->comprs[i]), name) == 0 )
4453  return set->comprs[i];
4454  }
4455 
4456  return NULL;
4457 }
4458 
4459 /** sorts compressions by priorities */
4460 void SCIPsetSortComprs(
4461  SCIP_SET* set /**< global SCIP settings */
4462  )
4463 {
4464  assert(set != NULL);
4465 
4466  if( !set->comprssorted )
4467  {
4468  SCIPsortPtr((void**)set->comprs, SCIPcomprComp, set->ncomprs);
4469  set->comprssorted = TRUE;
4470  set->comprsnamesorted = FALSE;
4471  }
4472 }
4473 
4474 /** sorts heuristics by names */
4476  SCIP_SET* set /**< global SCIP settings */
4477  )
4478 {
4479  assert(set != NULL);
4480 
4481  if( !set->comprsnamesorted )
4482  {
4483  SCIPsortPtr((void**)set->comprs, SCIPcomprCompName, set->ncomprs);
4484  set->comprssorted = FALSE;
4485  set->comprsnamesorted = TRUE;
4486  }
4487 }
4488 
4489 /** inserts event handler in event handler list */
4491  SCIP_SET* set, /**< global SCIP settings */
4492  SCIP_EVENTHDLR* eventhdlr /**< event handler */
4493  )
4494 {
4495  assert(set != NULL);
4496  assert(eventhdlr != NULL);
4497  assert(!SCIPeventhdlrIsInitialized(eventhdlr));
4498 
4499  if( set->neventhdlrs >= set->eventhdlrssize )
4500  {
4501  set->eventhdlrssize = SCIPsetCalcMemGrowSize(set, set->neventhdlrs+1);
4502  SCIP_ALLOC( BMSreallocMemoryArray(&set->eventhdlrs, set->eventhdlrssize) );
4503  }
4504  assert(set->neventhdlrs < set->eventhdlrssize);
4505 
4506  set->eventhdlrs[set->neventhdlrs] = eventhdlr;
4507  set->neventhdlrs++;
4508 
4509  return SCIP_OKAY;
4510 }
4511 
4512 /** returns the event handler of the given name, or NULL if not existing */
4514  SCIP_SET* set, /**< global SCIP settings */
4515  const char* name /**< name of event handler */
4516  )
4517 {
4518  int i;
4519 
4520  assert(set != NULL);
4521  assert(name != NULL);
4522 
4523  for( i = 0; i < set->neventhdlrs; ++i )
4524  {
4525  if( strcmp(SCIPeventhdlrGetName(set->eventhdlrs[i]), name) == 0 )
4526  return set->eventhdlrs[i];
4527  }
4528 
4529  return NULL;
4530 }
4531 
4532 /** inserts node selector in node selector list */
4534  SCIP_SET* set, /**< global SCIP settings */
4535  SCIP_NODESEL* nodesel /**< node selector */
4536  )
4537 {
4538  int i;
4539  int nodeselstdprio;
4540 
4541  assert(set != NULL);
4542  assert(nodesel != NULL);
4543  assert(!SCIPnodeselIsInitialized(nodesel));
4544 
4545  if( set->nnodesels >= set->nodeselssize )
4546  {
4547  set->nodeselssize = SCIPsetCalcMemGrowSize(set, set->nnodesels+1);
4548  SCIP_ALLOC( BMSreallocMemoryArray(&set->nodesels, set->nodeselssize) );
4549  }
4550  assert(set->nnodesels < set->nodeselssize);
4552  nodeselstdprio = SCIPnodeselGetStdPriority(nodesel);
4553 
4554  for( i = set->nnodesels; i > 0 && nodeselstdprio > SCIPnodeselGetStdPriority(set->nodesels[i-1]); --i )
4555  set->nodesels[i] = set->nodesels[i-1];
4556 
4557  set->nodesels[i] = nodesel;
4558  set->nnodesels++;
4559 
4560  return SCIP_OKAY;
4561 }
4562 
4563 /** returns the node selector of the given name, or NULL if not existing */
4565  SCIP_SET* set, /**< global SCIP settings */
4566  const char* name /**< name of event handler */
4567  )
4568 {
4569  int i;
4570 
4571  assert(set != NULL);
4572  assert(name != NULL);
4573 
4574  for( i = 0; i < set->nnodesels; ++i )
4575  {
4576  if( strcmp(SCIPnodeselGetName(set->nodesels[i]), name) == 0 )
4577  return set->nodesels[i];
4578  }
4579 
4580  return NULL;
4581 }
4582 
4583 /** returns node selector with highest priority in the current mode */
4585  SCIP_SET* set, /**< global SCIP settings */
4586  SCIP_STAT* stat /**< dynamic problem statistics */
4587  )
4588 {
4589  assert(set != NULL);
4590  assert(stat != NULL);
4591 
4592  /* check, if old node selector is still valid */
4593  if( set->nodesel == NULL && set->nnodesels > 0 )
4594  {
4595  int i;
4596 
4597  set->nodesel = set->nodesels[0];
4598 
4599  /* search highest priority node selector */
4600  if( stat->memsavemode )
4601  {
4602  for( i = 1; i < set->nnodesels; ++i )
4603  {
4604  if( SCIPnodeselGetMemsavePriority(set->nodesels[i]) > SCIPnodeselGetMemsavePriority(set->nodesel) )
4605  set->nodesel = set->nodesels[i];
4606  }
4607  }
4608  else
4609  {
4610  for( i = 1; i < set->nnodesels; ++i )
4611  {
4612  if( SCIPnodeselGetStdPriority(set->nodesels[i]) > SCIPnodeselGetStdPriority(set->nodesel) )
4613  set->nodesel = set->nodesels[i];
4614  }
4615  }
4616  }
4617 
4618  return set->nodesel;
4619 }
4620 
4621 /** inserts branching rule in branching rule list */
4623  SCIP_SET* set, /**< global SCIP settings */
4624  SCIP_BRANCHRULE* branchrule /**< branching rule */
4625  )
4626 {
4627  assert(set != NULL);
4628  assert(branchrule != NULL);
4629  assert(!SCIPbranchruleIsInitialized(branchrule));
4630 
4631  if( set->nbranchrules >= set->branchrulessize )
4632  {
4633  set->branchrulessize = SCIPsetCalcMemGrowSize(set, set->nbranchrules+1);
4634  SCIP_ALLOC( BMSreallocMemoryArray(&set->branchrules, set->branchrulessize) );
4635  }
4636  assert(set->nbranchrules < set->branchrulessize);
4637 
4638  set->branchrules[set->nbranchrules] = branchrule;
4639  set->nbranchrules++;
4640  set->branchrulessorted = FALSE;
4641 
4642  return SCIP_OKAY;
4643 }
4644 
4645 /** returns the branching rule of the given name, or NULL if not existing */
4647  SCIP_SET* set, /**< global SCIP settings */
4648  const char* name /**< name of event handler */
4649  )
4650 {
4651  int i;
4652 
4653  assert(set != NULL);
4654  assert(name != NULL);
4655 
4656  for( i = 0; i < set->nbranchrules; ++i )
4657  {
4658  if( strcmp(SCIPbranchruleGetName(set->branchrules[i]), name) == 0 )
4659  return set->branchrules[i];
4660  }
4661 
4662  return NULL;
4663 }
4664 
4665 /** sorts branching rules by priorities */
4667  SCIP_SET* set /**< global SCIP settings */
4668  )
4669 {
4670  assert(set != NULL);
4671 
4672  if( !set->branchrulessorted )
4673  {
4674  SCIPsortPtr((void**)set->branchrules, SCIPbranchruleComp, set->nbranchrules);
4675  set->branchrulessorted = TRUE;
4676  set->branchrulesnamesorted = FALSE;
4677  }
4678 }
4679 
4680 /** sorts branching rules by priorities */
4682  SCIP_SET* set /**< global SCIP settings */
4683  )
4684 {
4685  assert(set != NULL);
4686 
4687  if( !set->branchrulesnamesorted )
4688  {
4689  SCIPsortPtr((void**)set->branchrules, SCIPbranchruleCompName, set->nbranchrules);
4690  set->branchrulessorted = FALSE;
4691  set->branchrulesnamesorted = TRUE;
4692  }
4693 }
4694 
4695 /** inserts display column in display column list */
4697  SCIP_SET* set, /**< global SCIP settings */
4698  SCIP_DISP* disp /**< display column */
4699  )
4700 {
4701  int i;
4702  int disppos;
4703 
4704  assert(set != NULL);
4705  assert(disp != NULL);
4706  assert(!SCIPdispIsInitialized(disp));
4707 
4708  if( set->ndisps >= set->dispssize )
4709  {
4710  set->dispssize = SCIPsetCalcMemGrowSize(set, set->ndisps+1);
4711  SCIP_ALLOC( BMSreallocMemoryArray(&set->disps, set->dispssize) );
4712  }
4713  assert(set->ndisps < set->dispssize);
4714 
4715  disppos = SCIPdispGetPosition(disp);
4716 
4717  for( i = set->ndisps; i > 0 && disppos < SCIPdispGetPosition(set->disps[i-1]); --i )
4718  {
4719  set->disps[i] = set->disps[i-1];
4720  }
4721  set->disps[i] = disp;
4722  set->ndisps++;
4723 
4724  return SCIP_OKAY;
4725 }
4726 
4727 /** returns the display column of the given name, or NULL if not existing */
4729  SCIP_SET* set, /**< global SCIP settings */
4730  const char* name /**< name of display */
4731  )
4732 {
4733  int i;
4734 
4735  assert(set != NULL);
4736  assert(name != NULL);
4737 
4738  for( i = 0; i < set->ndisps; ++i )
4739  {
4740  if( strcmp(SCIPdispGetName(set->disps[i]), name) == 0 )
4741  return set->disps[i];
4742  }
4743 
4744  return NULL;
4745 }
4746 
4747 /** inserts statistics table in statistics table list */
4749  SCIP_SET* set, /**< global SCIP settings */
4750  SCIP_TABLE* table /**< statistics table */
4751  )
4752 {
4753  assert(set != NULL);
4754  assert(table != NULL);
4755  assert(!SCIPtableIsInitialized(table));
4756 
4757  if( set->ntables >= set->tablessize )
4758  {
4759  set->tablessize = SCIPsetCalcMemGrowSize(set, set->ntables+1);
4760  SCIP_ALLOC( BMSreallocMemoryArray(&set->tables, set->tablessize) );
4761  }
4762  assert(set->ntables < set->tablessize);
4763 
4764  /* we insert in arbitrary order and sort once before printing statistics */
4765  set->tables[set->ntables] = table;
4766  set->ntables++;
4767  set->tablessorted = FALSE;
4768 
4769  return SCIP_OKAY;
4770 }
4771 
4772 /** returns the statistics table of the given name, or NULL if not existing */
4774  SCIP_SET* set, /**< global SCIP settings */
4775  const char* name /**< name of statistics table */
4776  )
4777 {
4778  int i;
4779 
4780  assert(set != NULL);
4781  assert(name != NULL);
4782 
4783  for( i = 0; i < set->ntables; ++i )
4784  {
4785  if( strcmp(SCIPtableGetName(set->tables[i]), name) == 0 )
4786  return set->tables[i];
4787  }
4788 
4789  return NULL;
4790 }
4791 
4792 /** inserts dialog in dialog list */
4794  SCIP_SET* set, /**< global SCIP settings */
4795  SCIP_DIALOG* dialog /**< dialog */
4796  )
4797 {
4798  assert(set != NULL);
4799  assert(dialog != NULL);
4800 
4801  if( set->ndialogs >= set->dialogssize )
4802  {
4803  set->dialogssize = SCIPsetCalcMemGrowSize(set, set->ndialogs+1);
4804  SCIP_ALLOC( BMSreallocMemoryArray(&set->dialogs, set->dialogssize) );
4805  }
4806  assert(set->ndialogs < set->dialogssize);
4807 
4808  set->dialogs[set->ndialogs] = dialog;
4809  set->ndialogs++;
4810 
4811  return SCIP_OKAY;
4812 }
4813 
4814 /** returns if the dialog already exists */
4816  SCIP_SET* set, /**< global SCIP settings */
4817  SCIP_DIALOG* dialog /**< dialog */
4818  )
4819 {
4820  int i;
4821 
4822  assert(set != NULL);
4823 
4824  if( dialog == NULL )
4825  return FALSE;
4826 
4827  for( i = 0; i < set->ndialogs; ++i )
4828  {
4829  if( set->dialogs[i] == dialog )
4830  return TRUE;
4831  }
4832 
4833  return FALSE;
4834 }
4835 
4836 /** inserts NLPI in NLPI list */
4838  SCIP_SET* set, /**< global SCIP settings */
4839  SCIP_NLPI* nlpi /**< NLPI */
4840  )
4841 {
4842  assert(set != NULL);
4843  assert(nlpi != NULL);
4844 
4845  if( set->nnlpis >= set->nlpissize )
4846  {
4847  set->nlpissize = SCIPsetCalcMemGrowSize(set, set->nnlpis+1);
4848  SCIP_ALLOC( BMSreallocMemoryArray(&set->nlpis, set->nlpissize) );
4849  }
4850  assert(set->nnlpis < set->nlpissize);
4851 
4852  set->nlpis[set->nnlpis] = nlpi;
4853  set->nnlpis++;
4854  set->nlpissorted = FALSE;
4855 
4856  return SCIP_OKAY;
4857 }
4858 
4859 /** returns the NLPI of the given name, or NULL if not existing */
4861  SCIP_SET* set, /**< global SCIP settings */
4862  const char* name /**< name of NLPI */
4863  )
4864 {
4865  int i;
4866 
4867  assert(set != NULL);
4868  assert(name != NULL);
4870  for( i = 0; i < set->nnlpis; ++i )
4871  {
4872  if( strcmp(SCIPnlpiGetName(set->nlpis[i]), name) == 0 )
4873  return set->nlpis[i];
4874  }
4875 
4876  return NULL;
4877 }
4878 
4879 /** sorts NLPIs by priorities */
4880 void SCIPsetSortNlpis(
4881  SCIP_SET* set /**< global SCIP settings */
4882  )
4883 {
4884  assert(set != NULL);
4885 
4886  if( !set->nlpissorted )
4887  {
4888  SCIPsortPtr((void**)set->nlpis, SCIPnlpiComp, set->nnlpis);
4889  set->nlpissorted = TRUE;
4890  }
4892 
4893 /** set priority of an NLPI */
4895  SCIP_SET* set, /**< global SCIP settings */
4896  SCIP_NLPI* nlpi, /**< NLPI */
4897  int priority /**< new priority of NLPI */
4898  )
4899 {
4900  assert(set != NULL);
4901  assert(nlpi != NULL);
4902 
4903  SCIPnlpiSetPriority(nlpi, priority);
4904  set->nlpissorted = FALSE;
4905 }
4906 
4907 /** inserts information about an external code in external codes list */
4909  SCIP_SET* set, /**< global SCIP settings */
4910  const char* name, /**< name of external code */
4911  const char* description /**< description of external code, can be NULL */
4912  )
4914  assert(set != NULL);
4915  assert(name != NULL);
4916 
4917  if( set->nextcodes >= set->extcodessize )
4918  {
4919  set->extcodessize = SCIPsetCalcMemGrowSize(set, set->nextcodes+1);
4920  SCIP_ALLOC( BMSreallocMemoryArray(&set->extcodenames, set->extcodessize) );
4921  SCIP_ALLOC( BMSreallocMemoryArray(&set->extcodedescs, set->extcodessize) );
4922  }
4923  assert(set->nextcodes < set->extcodessize);
4924 
4925  BMSduplicateMemoryArray(&(set->extcodenames[set->nextcodes]), name, (int) (strlen(name)+1)); /*lint !e866*/
4926  if( description != NULL )
4927  {
4928  BMSduplicateMemoryArray(&(set->extcodedescs[set->nextcodes]), description, (int) (strlen(description)+1)); /*lint !e866*/
4929  }
4930  else
4931  {
4932  set->extcodedescs[set->nextcodes] = NULL;
4933  }
4934  set->nextcodes++;
4935 
4936  return SCIP_OKAY;
4937 }
4938 
4939 /** calls init methods of all plugins */
4941  SCIP_SET* set, /**< global SCIP settings */
4942  BMS_BLKMEM* blkmem, /**< block memory */
4943  SCIP_STAT* stat /**< dynamic problem statistics */
4944  )
4945 {
4946  int i;
4947 
4948  assert(set != NULL);
4949 
4950  /* active variable pricers */
4951  SCIPsetSortPricers(set);
4952  for( i = 0; i < set->nactivepricers; ++i )
4953  {
4954  SCIP_CALL( SCIPpricerInit(set->pricers[i], set) );
4955  }
4957  /* Benders' decomposition algorithm */
4958  SCIPsetSortBenders(set);
4959  for( i = 0; i < set->nactivebenders; ++i )
4960  {
4961  SCIP_CALL( SCIPbendersInit(set->benders[i], set) );
4962  }
4963 
4964  /* constraint handlers */
4965  for( i = 0; i < set->nconshdlrs; ++i )
4966  {
4967  SCIP_CALL( SCIPconshdlrInit(set->conshdlrs[i], blkmem, set, stat) );
4968  }
4969 
4970  /* conflict handlers */
4971  for( i = 0; i < set->nconflicthdlrs; ++i )
4972  {
4973  SCIP_CALL( SCIPconflicthdlrInit(set->conflicthdlrs[i], set) );
4974  }
4975 
4976  /* presolvers */
4977  for( i = 0; i < set->npresols; ++i )
4978  {
4979  SCIP_CALL( SCIPpresolInit(set->presols[i], set) );
4980  }
4981 
4982  /* relaxators */
4983  for( i = 0; i < set->nrelaxs; ++i )
4984  {
4985  SCIP_CALL( SCIPrelaxInit(set->relaxs[i], set) );
4986  }
4987 
4988  /* separators */
4989  for( i = 0; i < set->nsepas; ++i )
4990  {
4991  SCIP_CALL( SCIPsepaInit(set->sepas[i], set) );
4992  }
4993 
4994  /* propagators */
4995  for( i = 0; i < set->nprops; ++i )
4996  {
4997  SCIP_CALL( SCIPpropInit(set->props[i], set) );
4998  }
4999 
5000  /* primal heuristics */
5001  for( i = 0; i < set->nheurs; ++i )
5002  {
5003  SCIP_CALL( SCIPheurInit(set->heurs[i], set) );
5004  }
5005 
5006  /* tree compression */
5007  for( i = 0; i < set->ncomprs; ++i )
5008  {
5009  SCIP_CALL( SCIPcomprInit(set->comprs[i], set) );
5010  }
5011 
5012  /* event handlers */
5013  for( i = 0; i < set->neventhdlrs; ++i )
5014  {
5015  SCIP_CALL( SCIPeventhdlrInit(set->eventhdlrs[i], set) );
5016  }
5017 
5018  /* node selectors */
5019  for( i = 0; i < set->nnodesels; ++i )
5020  {
5021  SCIP_CALL( SCIPnodeselInit(set->nodesels[i], set) );
5022  }
5023 
5024  /* branching rules */
5025  for( i = 0; i < set->nbranchrules; ++i )
5026  {
5027  SCIP_CALL( SCIPbranchruleInit(set->branchrules[i], set) );
5028  }
5029 
5030  /* display columns */
5031  for( i = 0; i < set->ndisps; ++i )
5032  {
5033  SCIP_CALL( SCIPdispInit(set->disps[i], set) );
5034  }
5036 
5037  /* statistics tables */
5038  for( i = 0; i < set->ntables; ++i )
5039  {
5040  SCIP_CALL( SCIPtableInit(set->tables[i], set) );
5041  }
5042 
5043  return SCIP_OKAY;
5044 }
5045 
5046 /** calls exit methods of all plugins */
5048  SCIP_SET* set, /**< global SCIP settings */
5049  BMS_BLKMEM* blkmem, /**< block memory */
5050  SCIP_STAT* stat /**< dynamic problem statistics */
5051  )
5052 {
5053  int i;
5054 
5055  assert(set != NULL);
5056 
5057  /* active variable pricers */
5058  SCIPsetSortPricers(set);
5059  for( i = 0; i < set->nactivepricers; ++i )
5060  {
5061  SCIP_CALL( SCIPpricerExit(set->pricers[i], set) );
5062  }
5063 
5064  /* Benders' decomposition */
5065  SCIPsetSortBenders(set);
5066  for( i = 0; i < set->nactivebenders; ++i )
5067  {
5068  SCIP_CALL( SCIPbendersExit(set->benders[i], set) );
5069  }
5070 
5071  /* constraint handlers */
5072  for( i = 0; i < set->nconshdlrs; ++i )
5073  {
5074  SCIP_CALL( SCIPconshdlrExit(set->conshdlrs[i], blkmem, set, stat) );
5075  }
5076 
5077  /* conflict handlers */
5078  for( i = 0; i < set->nconflicthdlrs; ++i )
5079  {
5080  SCIP_CALL( SCIPconflicthdlrExit(set->conflicthdlrs[i], set) );
5081  }
5082 
5083  /* presolvers */
5084  for( i = 0; i < set->npresols; ++i )
5085  {
5086  SCIP_CALL( SCIPpresolExit(set->presols[i], set) );
5087  }
5088 
5089  /* relaxators */
5090  for( i = 0; i < set->nrelaxs; ++i )
5091  {
5092  SCIP_CALL( SCIPrelaxExit(set->relaxs[i], set) );
5093  }
5094 
5095  /* separators */
5096  for( i = 0; i < set->nsepas; ++i )
5097  {
5098  SCIP_CALL( SCIPsepaExit(set->sepas[i], set) );
5099  }
5100 
5101  /* propagators */
5102  for( i = 0; i < set->nprops; ++i )
5103  {
5104  SCIP_CALL( SCIPpropExit(set->props[i], set) );
5105  }
5106 
5107  /* primal heuristics */
5108  for( i = 0; i < set->nheurs; ++i )
5109  {
5110  SCIP_CALL( SCIPheurExit(set->heurs[i], set) );
5111  }
5112 
5113  /* tree compression */
5114  for( i = 0; i < set->ncomprs; ++i )
5115  {
5116  SCIP_CALL( SCIPcomprExit(set->comprs[i], set) );
5117  }
5118 
5119  /* event handlers */
5120  for( i = 0; i < set->neventhdlrs; ++i )
5121  {
5122  SCIP_CALL( SCIPeventhdlrExit(set->eventhdlrs[i], set) );
5123  }
5124 
5125  /* node selectors */
5126  for( i = 0; i < set->nnodesels; ++i )
5127  {
5128  SCIP_CALL( SCIPnodeselExit(set->nodesels[i], set) );
5129  }
5130 
5131  /* branching rules */
5132  for( i = 0; i < set->nbranchrules; ++i )
5133  {
5134  SCIP_CALL( SCIPbranchruleExit(set->branchrules[i], set) );
5135  }
5136 
5137</