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