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