Scippy

SCIP

Solving Constraint Integer Programs

set.c
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright (C) 2002-2020 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not visit scipopt.org. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file set.c
17  * @ingroup OTHER_CFILES
18  * @brief methods for global SCIP settings
19  * @author Tobias Achterberg
20  * @author Timo Berthold
21  *
22  * @todo Functions like SCIPsetFeastol() are misleading (it seems that the feasibility tolerance can be set).
23  * Rename all functions starting with SCIPsetXXX, e.g., SCIPsetGetFeastol() and SCIPsetSetFeastol().
24  */
25 
26 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
27 
28 #include <assert.h>
29 #include <string.h>
30 #include <math.h>
31 
32 #include "scip/def.h"
33 #include "scip/set.h"
34 #include "scip/stat.h"
35 #include "scip/clock.h"
36 #include "scip/event.h"
37 #include "scip/lp.h"
38 #include "scip/paramset.h"
39 #include "scip/scip.h"
40 #include "scip/bandit.h"
41 #include "scip/branch.h"
42 #include "scip/conflict.h"
43 #include "scip/cons.h"
44 #include "scip/disp.h"
45 #include "scip/dialog.h"
46 #include "scip/heur.h"
47 #include "scip/concsolver.h"
48 #include "scip/compr.h"
49 #include "scip/nodesel.h"
50 #include "scip/presol.h"
51 #include "scip/pricer.h"
52 #include "scip/reader.h"
53 #include "scip/relax.h"
54 #include "scip/sepa.h"
55 #include "scip/table.h"
56 #include "scip/prop.h"
57 #include "scip/benders.h"
58 #include "nlpi/nlpi.h"
59 #include "scip/struct_scip.h" /* for SCIPsetPrintDebugMessage() */
60 
61 /*
62  * Default settings
63  */
64 
65 
66 /* Branching */
67 
68 #define SCIP_DEFAULT_BRANCH_SCOREFUNC 'p' /**< branching score function ('s'um, 'p'roduct) */
69 #define SCIP_DEFAULT_BRANCH_SCOREFAC 0.167 /**< branching score factor to weigh downward and upward gain prediction
70  * in sum score function */
71 #define SCIP_DEFAULT_BRANCH_PREFERBINARY FALSE /**< should branching on binary variables be preferred? */
72 #define SCIP_DEFAULT_BRANCH_CLAMP 0.2 /**< minimal fractional distance of branching point to a continuous variable'
73  * bounds; a value of 0.5 leads to branching always in the middle of a bounded domain */
74 #define SCIP_DEFAULT_BRANCH_MIDPULL 0.75 /**< fraction by which to move branching point of a continuous variable towards the middle of the domain */
75 #define SCIP_DEFAULT_BRANCH_MIDPULLRELDOMTRIG 0.5 /**< multiply midpull by relative domain width if the latter is below this value */
76 #define SCIP_DEFAULT_BRANCH_LPGAINNORMALIZE 's' /**< strategy for normalizing LP gain when updating pseudo costs of continuous variables */
77 #define SCIP_DEFAULT_BRANCH_DELAYPSCOST TRUE /**< should updating pseudo costs of continuous variables be delayed to after separation */
78 #define SCIP_DEFAULT_BRANCH_DIVINGPSCOST TRUE /**< should pseudo costs be updated also in diving and probing mode? */
79 #define SCIP_DEFAULT_BRANCH_FORCEALL FALSE /**< should all strong branching children be regarded even if
80  * one is detected to be infeasible? (only with propagation) */
81 #define SCIP_DEFAULT_BRANCH_FIRSTSBCHILD 'a' /**< child node to be regarded first during strong branching (only with propagation): 'u'p child, 'd'own child, 'h'istory-based, or 'a'utomatic */
82 #define SCIP_DEFAULT_BRANCH_CHECKSBSOL TRUE /**< should LP solutions during strong branching with propagation be checked for feasibility? */
83 #define SCIP_DEFAULT_BRANCH_ROUNDSBSOL TRUE /**< should LP solutions during strong branching with propagation be rounded? (only when checksbsol=TRUE) */
84 #define SCIP_DEFAULT_BRANCH_SUMADJUSTSCORE FALSE /**< score adjustment near zero by adding epsilon (TRUE) or using maximum (FALSE) */
85 
86 /* Tree Compression */
87 
88 #define SCIP_DEFAULT_COMPR_ENABLE FALSE /**< should automatic tree compression in reoptimization after presolving be enabled? */
89 
90 
91 /* Conflict Analysis (general) */
92 
93 #define SCIP_DEFAULT_CONF_ENABLE TRUE /**< conflict analysis be enabled? */
94 #define SCIP_DEFAULT_CONF_MAXVARSFAC 0.15 /**< maximal fraction of variables involved in a conflict constraint */
95 #define SCIP_DEFAULT_CONF_MINMAXVARS 0 /**< minimal absolute maximum of variables involved in a conflict constraint */
96 #define SCIP_DEFAULT_CONF_MAXLPLOOPS 2 /**< maximal number of LP resolving loops during conflict analysis
97  * (-1: no limit) */
98 #define SCIP_DEFAULT_CONF_LPITERATIONS 10 /**< maximal number of LP iterations in each LP resolving loop
99  * (-1: no limit) */
100 #define SCIP_DEFAULT_CONF_USEPROP TRUE /**< should propagation conflict analysis be used? */
101 #define SCIP_DEFAULT_CONF_USEINFLP 'b' /**< should infeasible LP conflict analysis be used?
102  * ('o'ff, 'c'onflict graph, 'd'ual ray, 'b'oth conflict graph and dual ray)
103  */
104 #define SCIP_DEFAULT_CONF_USEBOUNDLP 'b' /**< should bound exceeding LP conflict analysis be used?
105  * ('o'ff, 'c'onflict graph, 'd'ual ray, 'b'oth conflict graph and dual solution)
106  */
107 #define SCIP_DEFAULT_CONF_USESB TRUE /**< should infeasible/bound exceeding strong branching conflict analysis
108  * be used? */
109 #define SCIP_DEFAULT_CONF_USEPSEUDO TRUE /**< should pseudo solution conflict analysis be used? */
110 #define SCIP_DEFAULT_CONF_PREFINFPROOF TRUE /**< prefer infeasibility proof to boundexceeding proof */
111 #define SCIP_DEFAULT_CONF_SEPARATE TRUE /**< should the conflict constraints be separated? */
112 #define SCIP_DEFAULT_CONF_DYNAMIC TRUE /**< should the conflict constraints be subject to aging? */
113 
114 
115 /* Conflict Analysis (conflict graph) */
117 #define SCIP_DEFAULT_CONF_MAXSTORESIZE 10000 /**< maximal size of the conflict pool */
118 #define SCIP_DEFAULT_CONF_RECONVLEVELS -1 /**< number of depth levels up to which UIP reconvergence constraints are
119  * generated (-1: generate reconvergence constraints in all depth levels) */
120 #define SCIP_DEFAULT_CONF_CLEANBNDDEPEND TRUE /**< should conflicts based on an old cutoff bound removed? */
121 #define SCIP_DEFAULT_CONF_FUIPLEVELS -1 /**< number of depth levels up to which first UIP's are used in conflict
122  * analysis (-1: use All-FirstUIP rule) */
123 #define SCIP_DEFAULT_CONF_INTERCONSS -1 /**< maximal number of intermediate conflict constraints generated in
124  * conflict graph (-1: use every intermediate constraint) */
125 #define SCIP_DEFAULT_CONF_MAXCONSS 10 /**< maximal number of conflict constraints accepted at an infeasible node
126  * (-1: use all generated conflict constraints) */
127 #define SCIP_DEFAULT_CONF_PREFERBINARY FALSE /**< should binary conflicts be preferred? */
128 #define SCIP_DEFAULT_CONF_ALLOWLOCAL TRUE /**< should conflict constraints be generated that are only valid locally? */
129 #define SCIP_DEFAULT_CONF_SETTLELOCAL FALSE /**< should conflict constraints be attached only to the local subtree
130  * where they can be useful? */
131 #define SCIP_DEFAULT_CONF_REPROPAGATE TRUE /**< should earlier nodes be repropagated in order to replace branching
132  * decisions by deductions? */
133 #define SCIP_DEFAULT_CONF_KEEPREPROP TRUE /**< should constraints be kept for repropagation even if they are too long? */
134 #define SCIP_DEFAULT_CONF_REMOVEABLE TRUE /**< should the conflict's relaxations be subject to LP aging and cleanup? */
135 #define SCIP_DEFAULT_CONF_DEPTHSCOREFAC 1.0 /**< score factor for depth level in bound relaxation heuristic of LP analysis */
136 #define SCIP_DEFAULT_CONF_PROOFSCOREFAC 1.0 /**< score factor for impact on acticity in bound relaxation heuristic of LP analysis */
137 #define SCIP_DEFAULT_CONF_UPLOCKSCOREFAC 0.0 /**< score factor for up locks in bound relaxation heuristic of LP analysis */
138 #define SCIP_DEFAULT_CONF_DOWNLOCKSCOREFAC 0.0 /**< score factor for down locks in bound relaxation heuristic of LP analysis */
139 #define SCIP_DEFAULT_CONF_SCOREFAC 0.98 /**< factor to decrease importance of variables' earlier conflict scores */
140 #define SCIP_DEFAULT_CONF_RESTARTNUM 0 /**< number of successful conflict analysis calls that trigger a restart
141  * (0: disable conflict restarts) */
142 #define SCIP_DEFAULT_CONF_RESTARTFAC 1.5 /**< factor to increase restartnum with after each restart */
143 #define SCIP_DEFAULT_CONF_IGNORERELAXEDBD FALSE /**< should relaxed bounds be ignored? */
144 #define SCIP_DEFAULT_CONF_MAXVARSDETECTIMPLIEDBOUNDS 250 /**< maximal number of variables to try to detect global bound implications and shorten the whole conflict set (0: disabled) */
145 #define SCIP_DEFAULT_CONF_FULLSHORTENCONFLICT TRUE /**< try to shorten the whole conflict set or terminate early (depending on the 'maxvarsdetectimpliedbounds' parameter) */
146 #define SCIP_DEFAULT_CONF_CONFLITWEIGHT 0.0 /**< the weight the VSIDS score is weight by updating the VSIDS for a variable if it is part of a conflict */
147 #define SCIP_DEFAULT_CONF_CONFLITGRAPHWEIGHT 1.0/**< the weight the VSIDS score is weight by updating the VSIDS for a variable if it is part of a conflict graph */
148 #define SCIP_DEFAULT_CONF_WEIGHTSIZE 0.001 /**< weight of the size of a conflict used in score calculation */
149 #define SCIP_DEFAULT_CONF_WEIGHTREPROPDEPTH 0.1 /**< weight of the repropagation depth of a conflict used in score calculation */
150 #define SCIP_DEFAULT_CONF_WEIGHTVALIDDEPTH 1.0 /**< weight of the valid depth of a conflict used in score calculation */
151 #define SCIP_DEFAULT_CONF_MINIMPROVE 0.05 /**< minimal improvement of primal bound to remove conflicts based on a previous incumbent */
153 /* Conflict Analysis (dual ray) */
155 #define SCIP_DEFAULT_CONF_SEPAALTPROOFS FALSE /**< apply cut generating functions to construct alternative proofs */
156 #define SCIP_DEFAULT_CONF_USELOCALROWS TRUE /**< use local rows to construct infeasibility proofs */
157 
158 /* Constraints */
160 #define SCIP_DEFAULT_CONS_AGELIMIT 0 /**< maximum age an unnecessary constraint can reach before it is deleted
161  * (0: dynamic adjustment, -1: constraints are never deleted) */
162 #define SCIP_DEFAULT_CONS_OBSOLETEAGE -1 /**< age of a constraint after which it is marked obsolete
163  * (0: dynamic adjustment, -1: constraints are never marked obsolete) */
164 #define SCIP_DEFAULT_CONS_DISABLEENFOPS FALSE /**< should enforcement of pseudo solution be disabled? */
167 /* Display */
169 #define SCIP_DEFAULT_DISP_VERBLEVEL SCIP_VERBLEVEL_HIGH /**< verbosity level of output */
170 #define SCIP_DEFAULT_DISP_WIDTH 143 /**< maximal number of characters in a node information line */
171 #define SCIP_DEFAULT_DISP_FREQ 100 /**< frequency for displaying node information lines */
172 #define SCIP_DEFAULT_DISP_HEADERFREQ 15 /**< frequency for displaying header lines (every n'th node info line) */
173 #define SCIP_DEFAULT_DISP_LPINFO FALSE /**< should the LP solver display status messages? */
174 #define SCIP_DEFAULT_DISP_ALLVIOLS FALSE /**< display all violations of the best solution after the solving process finished? */
175 #define SCIP_DEFAULT_DISP_RELEVANTSTATS TRUE /**< should the relevant statistics be displayed at the end of solving? */
176 
177 /* Heuristics */
178 
179 #define SCIP_DEFAULT_HEUR_USEUCTSUBSCIP FALSE /**< should setting of common subscip parameters include the activation of the UCT node selector? */
181 /* History */
182 
183 #define SCIP_DEFAULT_HISTORY_VALUEBASED FALSE /**< should statistics be collected for variable domain value pairs */
184 #define SCIP_DEFAULT_HISTORY_ALLOWMERGE FALSE /**< should variable histories be merged from sub-SCIPs whenever possible? */
185 #define SCIP_DEFAULT_HISTORY_ALLOWTRANSFER FALSE /**< should variable histories be transferred to initialize SCIP copies? */
186 
187 /* Limits */
189 #define SCIP_DEFAULT_LIMIT_TIME 1e+20 /**< maximal time in seconds to run */
190 #define SCIP_DEFAULT_LIMIT_MEMORY SCIP_MEM_NOLIMIT/**< maximal memory usage in MB */
191 #define SCIP_DEFAULT_LIMIT_GAP 0.0 /**< solving stops, if the gap is below the given value */
192 #define SCIP_DEFAULT_LIMIT_ABSGAP 0.0 /**< solving stops, if the absolute difference between primal and dual
193  * bound reaches this value */
194 #define SCIP_DEFAULT_LIMIT_NODES -1LL /**< maximal number of nodes to process (-1: no limit) */
195 #define SCIP_DEFAULT_LIMIT_STALLNODES -1LL /**< solving stops, if the given number of nodes was processed since the
196  * last improvement of the primal solution value (-1: no limit) */
197 #define SCIP_DEFAULT_LIMIT_SOLUTIONS -1 /**< solving stops, if given number of sols were found (-1: no limit) */
198 #define SCIP_DEFAULT_LIMIT_BESTSOL -1 /**< solving stops, if given number of solution improvements were found
199  * (-1: no limit) */
200 #define SCIP_DEFAULT_LIMIT_MAXSOL 100 /**< maximal number of solutions to store in the solution storage */
201 #define SCIP_DEFAULT_LIMIT_MAXORIGSOL 10 /**< maximal number of solutions candidates to store in the solution storage of the original problem */
202 #define SCIP_DEFAULT_LIMIT_RESTARTS -1 /**< solving stops, if the given number of restarts was triggered (-1: no limit) */
203 #define SCIP_DEFAULT_LIMIT_AUTORESTARTNODES -1 /**< if solve exceeds this number of nodes, an automatic restart is triggered (-1: no automatic restart)*/
205 
206 /* LP */
207 
208 #define SCIP_DEFAULT_LP_SOLVEFREQ 1 /**< frequency for solving LP at the nodes; -1: never; 0: only root LP */
209 #define SCIP_DEFAULT_LP_ITERLIM -1LL /**< iteration limit for each single LP solve; -1: no limit */
210 #define SCIP_DEFAULT_LP_ROOTITERLIM -1LL /**< iteration limit for initial root LP solve; -1: no limit */
211 #define SCIP_DEFAULT_LP_SOLVEDEPTH -1 /**< maximal depth for solving LPs (-1: no depth limit) */
212 #define SCIP_DEFAULT_LP_INITALGORITHM 's' /**< LP algorithm for solving initial LP relaxations ('s'implex, 'b'arrier,
213  * barrier with 'c'rossover) */
214 #define SCIP_DEFAULT_LP_RESOLVEALGORITHM 's' /**< LP algorithm for resolving LP relaxations if a starting basis exists
215  * ('s'implex, 'b'arrier, barrier with 'c'rossover) */
216 #define SCIP_DEFAULT_LP_PRICING 'l' /**< LP pricing strategy ('l'pi default, 'a'uto, 'f'ull pricing, 'p'artial,
217  * 's'teepest edge pricing, 'q'uickstart steepest edge pricing,
218  * 'd'evex pricing) */
219 #define SCIP_DEFAULT_LP_CLEARINITIALPROBINGLP TRUE/**< should lp state be cleared at the end of probing mode when lp
220  * was initially unsolved, e.g., when called right after presolving? */
221 #define SCIP_DEFAULT_LP_RESOLVERESTORE FALSE /**< should the LP be resolved to restore the state at start of diving (if FALSE we buffer the solution values)? */
222 #define SCIP_DEFAULT_LP_FREESOLVALBUFFERS FALSE /**< should the buffers for storing LP solution values during diving be freed at end of diving? */
223 #define SCIP_DEFAULT_LP_COLAGELIMIT 10 /**< maximum age a dynamic column can reach before it is deleted from SCIP_LP
224  * (-1: don't delete columns due to aging) */
225 #define SCIP_DEFAULT_LP_ROWAGELIMIT 10 /**< maximum age a dynamic row can reach before it is deleted from SCIP_LP
226  * (-1: don't delete rows due to aging) */
227 #define SCIP_DEFAULT_LP_CLEANUPCOLS FALSE /**< should new non-basic columns be removed after LP solving? */
228 #define SCIP_DEFAULT_LP_CLEANUPCOLSROOT FALSE /**< should new non-basic columns be removed after root LP solving? */
229 #define SCIP_DEFAULT_LP_CLEANUPROWS TRUE /**< should new basic rows be removed after LP solving? */
230 #define SCIP_DEFAULT_LP_CLEANUPROWSROOT TRUE /**< should new basic rows be removed after root LP solving? */
231 #define SCIP_DEFAULT_LP_CHECKSTABILITY TRUE /**< should LP solver's return status be checked for stability? */
232 #define SCIP_DEFAULT_LP_CONDITIONLIMIT -1.0 /**< maximum condition number of LP basis counted as stable (-1.0: no limit) */
233 #define SCIP_DEFAULT_LP_MARKOWITZ 0.01 /**< minimal Markowitz threshold to control sparsity/stability in LU factorization */
234 #define SCIP_DEFAULT_LP_CHECKPRIMFEAS TRUE /**< should LP solutions be checked for primal feasibility to resolve LP at numerical troubles? */
235 #define SCIP_DEFAULT_LP_CHECKDUALFEAS TRUE /**< should LP solutions be checked for dual feasibility to resolve LP at numerical troubles? */
236 #define SCIP_DEFAULT_LP_CHECKFARKAS TRUE /**< should infeasibility proofs from the LP be checked? */
237 #define SCIP_DEFAULT_LP_FASTMIP 1 /**< should FASTMIP setting of LP solver be used? */
238 #define SCIP_DEFAULT_LP_SCALING 1 /**< LP scaling (0: none, 1: normal, 2: aggressive) */
239 #define SCIP_DEFAULT_LP_PRESOLVING TRUE /**< should presolving of LP solver be used? */
240 #define SCIP_DEFAULT_LP_LEXDUALALGO FALSE /**< should the dual lexicographic algorithm be used? */
241 #define SCIP_DEFAULT_LP_LEXDUALROOTONLY TRUE /**< should the lexicographic dual algorithm be applied only at the root node */
242 #define SCIP_DEFAULT_LP_LEXDUALMAXROUNDS 2 /**< maximum number of rounds in the dual lexicographic algorithm */
243 #define SCIP_DEFAULT_LP_LEXDUALBASIC FALSE /**< choose fractional basic variables in lexicographic dual algorithm */
244 #define SCIP_DEFAULT_LP_LEXDUALSTALLING TRUE /**< turn on the lex dual algorithm only when stalling? */
245 #define SCIP_DEFAULT_LP_DISABLECUTOFF 2 /**< disable the cutoff bound in the LP solver? (0: enabled, 1: disabled, 2: auto) */
246 #define SCIP_DEFAULT_LP_ROWREPSWITCH 1.2 /**< simplex algorithm shall use row representation of the basis
247  * if number of rows divided by number of columns exceeds this value */
248 #define SCIP_DEFAULT_LP_THREADS 0 /**< number of threads used for solving the LP (0: automatic) */
249 #define SCIP_DEFAULT_LP_RESOLVEITERFAC -1.0 /**< factor of average LP iterations that is used as LP iteration limit
250  * for LP resolve (-1.0: unlimited) */
251 #define SCIP_DEFAULT_LP_RESOLVEITERMIN 1000 /**< minimum number of iterations that are allowed for LP resolve */
252 #define SCIP_DEFAULT_LP_SOLUTIONPOLISHING 3 /**< LP solution polishing method (0: disabled, 1: only root, 2: always, 3: auto) */
253 #define SCIP_DEFAULT_LP_REFACTORINTERVAL 0 /**< LP refactorization interval (0: automatic) */
254 #define SCIP_DEFAULT_LP_ALWAYSGETDUALS FALSE /**< should the dual solution always be collected */
255 
256 /* NLP */
258 #define SCIP_DEFAULT_NLP_SOLVER "" /**< name of NLP solver to use, or "" if solver should be chosen by priority */
259 #define SCIP_DEFAULT_NLP_DISABLE FALSE /**< should the NLP be always disabled? */
262 /* Memory */
264 #define SCIP_DEFAULT_MEM_SAVEFAC 0.8 /**< fraction of maximal mem usage when switching to memory saving mode */
265 #define SCIP_DEFAULT_MEM_TREEGROWFAC 2.0 /**< memory growing factor for tree array */
266 #define SCIP_DEFAULT_MEM_PATHGROWFAC 2.0 /**< memory growing factor for path array */
267 #define SCIP_DEFAULT_MEM_TREEGROWINIT 65536 /**< initial size of tree array */
268 #define SCIP_DEFAULT_MEM_PATHGROWINIT 256 /**< initial size of path array */
271 /* Miscellaneous */
273 #define SCIP_DEFAULT_MISC_CATCHCTRLC TRUE /**< should the CTRL-C interrupt be caught by SCIP? */
274 #define SCIP_DEFAULT_MISC_USEVARTABLE TRUE /**< should a hashtable be used to map from variable names to variables? */
275 #define SCIP_DEFAULT_MISC_USECONSTABLE TRUE /**< should a hashtable be used to map from constraint names to constraints? */
276 #define SCIP_DEFAULT_MISC_USESMALLTABLES FALSE /**< should smaller hashtables be used? yields better performance for small problems with about 100 variables */
277 #define SCIP_DEFAULT_MISC_EXACTSOLVE FALSE /**< should the problem be solved exactly (with proven dual bounds)? */
278 #define SCIP_DEFAULT_MISC_RESETSTAT TRUE /**< should the statistics be reset if the transformed problem is
279  * freed otherwise the statistics get reset after original problem is
280  * freed (in case of Benders' decomposition this parameter should be set
281  * to FALSE and therefore can be used to collect statistics over all
282  * runs) */
283 #define SCIP_DEFAULT_MISC_IMPROVINGSOLS FALSE /**< should only solutions be checked which improve the primal bound */
284 #define SCIP_DEFAULT_MISC_PRINTREASON TRUE /**< should the reason be printed if a given start solution is infeasible? */
285 #define SCIP_DEFAULT_MISC_ESTIMEXTERNMEM TRUE /**< should the usage of external memory be estimated? */
286 #define SCIP_DEFAULT_MISC_TRANSORIGSOLS TRUE /**< should SCIP try to transfer original solutions to the transformed space (after presolving)? */
287 #define SCIP_DEFAULT_MISC_TRANSSOLSORIG TRUE /**< should SCIP try to transfer transformed solutions to the original space (after solving)? */
288 #define SCIP_DEFAULT_MISC_CALCINTEGRAL TRUE /**< should SCIP calculate the primal dual integral? */
289 #define SCIP_DEFAULT_MISC_FINITESOLSTORE FALSE /**< should SCIP try to remove infinite fixings from solutions copied to the solution store? */
290 #define SCIP_DEFAULT_MISC_OUTPUTORIGSOL TRUE /**< should the best solution be transformed to the orignal space and be output in command line run? */
291 #define SCIP_DEFAULT_MISC_ALLOWSTRONGDUALREDS TRUE /**< should strong dual reductions be allowed in propagation and presolving? */
292 #define SCIP_DEFAULT_MISC_ALLOWWEAKDUALREDS TRUE /**< should weak dual reductions be allowed in propagation and presolving? */
293 #define SCIP_DEFAULT_MISC_REFERENCEVALUE 1e99 /**< objective value for reference purposes */
294 #define SCIP_DEFAULT_MISC_USESYMMETRY 3 /**< bitset describing used symmetry handling technique (0: off; 1: polyhedral (orbitopes and/or symresacks);
295  * 2: orbital fixing; 3: orbitopes and orbital fixing) */
296 #define SCIP_DEFAULT_MISC_SCALEOBJ TRUE /**< should the objective function be scaled? */
298 #ifdef WITH_DEBUG_SOLUTION
299 #define SCIP_DEFAULT_MISC_DEBUGSOLUTION "-" /**< path to a debug solution */
300 #endif
301 
302 /* Randomization */
303 #define SCIP_DEFAULT_RANDOM_RANDSEEDSHIFT 0 /**< global shift of all random seeds in the plugins, this will have no impact on the permutation and LP seeds */
304 #define SCIP_DEFAULT_RANDOM_PERMUTATIONSEED 0 /**< seed value for permuting the problem after reading/transformation (0: no permutation) */
305 #define SCIP_DEFAULT_RANDOM_LPSEED 0 /**< random seed for LP solver, e.g. for perturbations in the simplex (0: LP default) */
306 #define SCIP_DEFAULT_RANDOM_PERMUTECONSS TRUE /**< should order of constraints be permuted (depends on permutationseed)? */
307 #define SCIP_DEFAULT_RANDOM_PERMUTEVARS FALSE /**< should order of variables be permuted (depends on permutationseed)? */
310 /* Node Selection */
311 
312 #define SCIP_DEFAULT_NODESEL_CHILDSEL 'h' /**< child selection rule ('d'own, 'u'p, 'p'seudo costs, 'i'nference, 'l'p value,
313  * 'r'oot LP value difference, 'h'brid inference/root LP value difference) */
314 
315 
316 /* Presolving */
317 
318 #define SCIP_DEFAULT_PRESOL_ABORTFAC 8e-04 /**< abort presolve, if at most this fraction of the problem was changed
319  * in last presolve round */
320 #define SCIP_DEFAULT_PRESOL_MAXROUNDS -1 /**< maximal number of presolving rounds (-1: unlimited, 0: off) */
321 #define SCIP_DEFAULT_PRESOL_MAXRESTARTS -1 /**< maximal number of restarts (-1: unlimited) */
322 #define SCIP_DEFAULT_PRESOL_CLQTABLEFAC 2.0 /**< limit on number of entries in clique table relative to number of problem nonzeros */
323 #define SCIP_DEFAULT_PRESOL_RESTARTFAC 0.025 /**< fraction of integer variables that were fixed in the root node
324  * triggering a restart with preprocessing after root node evaluation */
325 #define SCIP_DEFAULT_PRESOL_IMMRESTARTFAC 0.10 /**< fraction of integer variables that were fixed in the root node triggering an
326  * immediate restart with preprocessing */
327 #define SCIP_DEFAULT_PRESOL_SUBRESTARTFAC 1.00 /**< fraction of integer variables that were globally fixed during the
328  * solving process triggering a restart with preprocessing */
329 #define SCIP_DEFAULT_PRESOL_RESTARTMINRED 0.10 /**< minimal fraction of integer variables removed after restart to allow
330  * for an additional restart */
331 #define SCIP_DEFAULT_PRESOL_DONOTMULTAGGR FALSE /**< should multi-aggregation of variables be forbidden? */
332 #define SCIP_DEFAULT_PRESOL_DONOTAGGR FALSE /**< should aggregation of variables be forbidden? */
333 
334 
335 /* Pricing */
336 
337 #define SCIP_DEFAULT_PRICE_ABORTFAC 2.0 /**< pricing is aborted, if fac * price_maxvars pricing candidates were
338  * found */
339 #define SCIP_DEFAULT_PRICE_MAXVARS 100 /**< maximal number of variables priced in per pricing round */
340 #define SCIP_DEFAULT_PRICE_MAXVARSROOT 2000 /**< maximal number of priced variables at the root node */
341 #define SCIP_DEFAULT_PRICE_DELVARS FALSE /**< should variables created at the current node be deleted when the node is solved
342  * in case they are not present in the LP anymore? */
343 #define SCIP_DEFAULT_PRICE_DELVARSROOT FALSE /**< should variables created at the root node be deleted when the root is solved
344  * in case they are not present in the LP anymore? */
345 
346 /* Decomposition */
347 #define SCIP_DEFAULT_DECOMP_BENDERSLABELS FALSE /**< should the variables be labelled for the application of Benders' decomposition */
348 #define SCIP_DEFAULT_DECOMP_APPLYBENDERS FALSE /**< if a decomposition exists, should Benders' decomposition be applied? */
349 #define SCIP_DEFAULT_DECOMP_MAXGRAPHEDGE 10000 /**< maximum number of edges in block graph computation, or -1 for no limit */
350 
351 /* Benders' decomposition */
352 #define SCIP_DEFAULT_BENDERS_SOLTOL 1e-6 /**< the tolerance used to determine optimality in Benders' decomposition */
353 #define SCIP_DEFAULT_BENDERS_CUTLPSOL TRUE /**< should Benders' cuts be generated from the LP solution? */
354 #define SCIP_DEFAULT_BENDERS_COPYBENDERS TRUE /**< should Benders' decomposition be copied for sub-SCIPs? */
356 /* Reoptimization */
357 
358 #define SCIP_DEFAULT_REOPT_OBJSIMSOL -1.0 /**< re-use stored solutions only if the similarity of the new and the old objective
359  function is greater or equal than this value */
360 #define SCIP_DEFAULT_REOPT_OBJSIMROOTLP 0.8 /**< similarity of two sequential objective function to disable solving the root LP. */
361 #define SCIP_DEFAULT_REOPT_OBJSIMDELAY -1.0 /**< start reoptimizing the search if the new objective function has similarity of
362  * at least SCIP_DEFAULT_REOPT_DELAY w.r.t. the previous objective function. */
363 #define SCIP_DEFAULT_REOPT_VARORDERINTERDICTION 'd' /** use 'd'efault, 'r'andom or 'i'nference score for variable
364  * ordering when performing interdiction branching during
365  * reoptimization of nodes
366  */
367 #define SCIP_DEFAULT_REOPT_MAXSAVEDNODES INT_MAX/**< maximum number of saved nodes */
368 #define SCIP_DEFAULT_REOPT_MAXDIFFOFNODES INT_MAX/**< maximum number of bound changes of two ancestor nodes
369  * such that the path get not shrunk */
370 #define SCIP_DEFAULT_REOPT_FORCEHEURRESTART 3 /**< force a restart if the last n optimal solutions are found by
371  * reoptsols heuristic
372  */
373 #define SCIP_DEFAULT_REOPT_SAVESOLS INT_MAX/**< save n best solutions found so far. */
374 #define SCIP_DEFAULT_REOPT_SOLVELP 1 /**< strategy for solving the LP at nodes from reoptimization */
375 #define SCIP_DEFAULT_REOPT_SOLVELPDIFF 1 /**< difference of path length between two ancestor nodes to solve the LP */
376 #define SCIP_DEFAULT_REOPT_ENABLE FALSE /**< enable reoptimization */
377 #define SCIP_DEFAULT_REOPT_SEPAGLBINFSUBTREES TRUE/**< save global constraints to separate infeasible subtrees */
378 #define SCIP_DEFAULT_REOPT_SEPABESTSOL FALSE /**< separate the optimal solution, e.g., for solving constraint shortest
379  * path problems
380  */
381 #define SCIP_DEFAULT_REOPT_STOREVARHISTOTY FALSE/**< use the variable history of the previous solve if the objective
382  * function has changed only slightly
383  */
384 #define SCIP_DEFAULT_REOPT_USEPSCOST FALSE /**< re-use pseudo costs of the objective function changed only slightly */
385 #define SCIP_DEFAULT_REOPT_COMMONTIMELIMIT FALSE/**< is the given time limit for all reoptimization round? */
386 #define SCIP_DEFAULT_REOPT_SHRINKINNER TRUE /**< replace branched transit nodes by their child nodes, if the number
387  * of bound changes is not to large
388  */
389 #define SCIP_DEFAULT_REOPT_STRONGBRANCHINIT TRUE/**< try to fix variables before reoptimizing by probing like strong
390  * branching
391  */
392 #define SCIP_DEFAULT_REOPT_REDUCETOFRONTIER TRUE/**< delete stored nodes which were not reoptimized */
393 #define SCIP_DEFAULT_REOPT_SAVECONSPROP FALSE/**< save constraint propagation */
394 #define SCIP_DEFAULT_REOPT_USESPLITCONS TRUE /**< use constraints to reconstruct the subtree pruned be dual reduction
395  * when reactivating the node
396  */
397 #define SCIP_DEFAULT_REOPT_USECUTS FALSE /**< reoptimize cuts found at the root node */
398 #define SCIP_DEFAULT_REOPT_MAXCUTAGE 0 /**< maximal age of a cut to be use for reoptimization */
400 /* Propagating */
401 
402 #define SCIP_DEFAULT_PROP_MAXROUNDS 100 /**< maximal number of propagation rounds per node (-1: unlimited) */
403 #define SCIP_DEFAULT_PROP_MAXROUNDSROOT 1000 /**< maximal number of propagation rounds in root node (-1: unlimited) */
404 #define SCIP_DEFAULT_PROP_ABORTONCUTOFF TRUE /**< should propagation be aborted immediately? setting this to FALSE could
405  * help conflict analysis to produce more conflict constraints */
408 /* Separation */
409 
410 #define SCIP_DEFAULT_SEPA_MAXBOUNDDIST 1.0 /**< maximal relative distance from current node's dual bound to primal
411  * bound compared to best node's dual bound for applying separation
412  * (0.0: only on current best node, 1.0: on all nodes) */
413 #define SCIP_DEFAULT_SEPA_MAXLOCALBOUNDDIST 0.0 /**< maximal relative distance from current node's dual bound to primal
414  * bound compared to best node's dual bound for applying local separation
415  * (0.0: only on current best node, 1.0: on all nodes) */
416 #define SCIP_DEFAULT_SEPA_MAXCOEFRATIO 1e+4 /**< maximal ratio between coefficients in strongcg, cmir, and flowcover cuts */
417 #define SCIP_DEFAULT_SEPA_MINEFFICACY 1e-4 /**< minimal efficacy for a cut to enter the LP */
418 #define SCIP_DEFAULT_SEPA_MINEFFICACYROOT 1e-4 /**< minimal efficacy for a cut to enter the LP in the root node */
419 #define SCIP_DEFAULT_SEPA_MINORTHO 0.90 /**< minimal orthogonality for a cut to enter the LP */
420 #define SCIP_DEFAULT_SEPA_MINORTHOROOT 0.90 /**< minimal orthogonality for a cut to enter the LP in the root node */
421 #define SCIP_DEFAULT_SEPA_OBJPARALFAC 0.1 /**< factor to scale objective parallelism of cut in score calculation */
422 #define SCIP_DEFAULT_SEPA_DIRCUTOFFDISTFAC 0.5 /**< factor to scale directed cutoff distance of cut in score calculation */
423 #define SCIP_DEFAULT_SEPA_EFFICACYFAC 0.6 /**< factor to scale efficacy of cut in score calculation */
424 #define SCIP_DEFAULT_SEPA_INTSUPPORTFAC 0.1 /**< factor to scale integral support of cut in score calculation */
425 #define SCIP_DEFAULT_SEPA_ORTHOFUNC 'e' /**< function used for calc. scalar prod. in orthogonality test ('e'uclidean, 'd'iscrete) */
426 #define SCIP_DEFAULT_SEPA_EFFICACYNORM 'e' /**< row norm to use for efficacy calculation ('e'uclidean, 'm'aximum,
427  * 's'um, 'd'iscrete) */
428 #define SCIP_DEFAULT_SEPA_CUTSELRESTART 'a' /**< cut selection during restart ('a'ge, activity 'q'uotient) */
429 #define SCIP_DEFAULT_SEPA_CUTSELSUBSCIP 'a' /**< cut selection for sub SCIPs ('a'ge, activity 'q'uotient) */
430 #define SCIP_DEFAULT_SEPA_MAXRUNS -1 /**< maximal number of runs for which separation is enabled (-1: unlimited) */
431 #define SCIP_DEFAULT_SEPA_MAXROUNDS -1 /**< maximal number of separation rounds per node (-1: unlimited) */
432 #define SCIP_DEFAULT_SEPA_MAXROUNDSROOT -1 /**< maximal number of separation rounds in the root node (-1: unlimited) */
433 #define SCIP_DEFAULT_SEPA_MAXROUNDSROOTSUBRUN -1 /**< maximal number of separation rounds in the root node of a subsequent run (-1: unlimited) */
434 #define SCIP_DEFAULT_SEPA_MAXADDROUNDS 1 /**< maximal additional number of separation rounds in subsequent
435  * price-and-cut loops (-1: no additional restriction) */
436 #define SCIP_DEFAULT_SEPA_MAXSTALLROUNDSROOT 10 /**< maximal number of consecutive separation rounds without objective
437  * or integrality improvement in the root node (-1: no additional restriction) */
438 #define SCIP_DEFAULT_SEPA_MAXSTALLROUNDS 1 /**< maximal number of consecutive separation rounds without objective
439  * or integrality improvement in local nodes (-1: no additional restriction) */
440 #define SCIP_DEFAULT_SEPA_MAXCUTS 100 /**< maximal number of cuts separated per separation round */
441 #define SCIP_DEFAULT_SEPA_MAXCUTSROOT 2000 /**< maximal separated cuts at the root node */
442 #define SCIP_DEFAULT_SEPA_CUTAGELIMIT 80 /**< maximum age a cut can reach before it is deleted from global cut pool
443  * (-1: cuts are never deleted from the global cut pool) */
444 #define SCIP_DEFAULT_SEPA_POOLFREQ 10 /**< separation frequency for the global cut pool */
445 #define SCIP_DEFAULT_SEPA_MINACTIVITYQUOT 0.8 /**< minimum cut activity quotient to convert cuts into constraints
446  * during a restart (0.0: all cuts are converted) */
447 
448 /* Parallel */
449 #define SCIP_DEFAULT_PARALLEL_MODE 1 /**< the mode for the parallel implementation. Either 0: opportunistic or
450  * 1: deterministic */
451 #define SCIP_DEFAULT_PARALLEL_MINNTHREADS 1 /**< the minimum number of threads used in parallel code */
452 #define SCIP_DEFAULT_PARALLEL_MAXNTHREADS 8 /**< the maximum number of threads used in parallel code */
453 
454 /* Concurrent solvers */
455 #define SCIP_DEFAULT_CONCURRENT_CHANGESEEDS TRUE /**< should the concurrent solvers use different random seeds? */
456 #define SCIP_DEFAULT_CONCURRENT_CHANGECHILDSEL TRUE /**< should the concurrent solvers use different child selection rules? */
457 #define SCIP_DEFAULT_CONCURRENT_COMMVARBNDS TRUE /**< should the concurrent solvers communicate variable bounds? */
458 #define SCIP_DEFAULT_CONCURRENT_PRESOLVEBEFORE TRUE /**< should the problem be presolved before it is copied to the concurrent solvers? */
459 #define SCIP_DEFAULT_CONCURRENT_INITSEED 5131912 /**< the seed used to initialize the random seeds for the concurrent solvers */
460 #define SCIP_DEFAULT_CONCURRENT_FREQINIT 10.0 /**< initial frequency of synchronization with other threads
461  * (fraction of time required for solving the root LP) */
462 #define SCIP_DEFAULT_CONCURRENT_FREQMAX 10.0 /**< maximal frequency of synchronization with other threads
463  * (fraction of time required for solving the root LP) */
464 #define SCIP_DEFAULT_CONCURRENT_FREQFACTOR 1.5 /**< factor by which the frequency of synchronization is changed */
465 #define SCIP_DEFAULT_CONCURRENT_TARGETPROGRESS 0.001 /**< when adapting the synchronization frequency this value is the targeted
466  * relative difference by which the absolute gap decreases per synchronization */
467 #define SCIP_DEFAULT_CONCURRENT_MAXNSOLS 3 /**< maximum number of solutions that will be shared in a single synchronization */
468 #define SCIP_DEFAULT_CONCURRENT_MAXNSYNCDELAY 7 /**< maximum number of synchronizations before reading is enforced regardless of delay */
469 #define SCIP_DEFAULT_CONCURRENT_MINSYNCDELAY 10.0 /**< minimum delay before synchronization data is read */
470 #define SCIP_DEFAULT_CONCURRENT_NBESTSOLS 10 /**< how many of the N best solutions should be considered for synchronization */
471 #define SCIP_DEFAULT_CONCURRENT_PARAMSETPREFIX "" /**< path prefix for parameter setting files of concurrent solvers */
472 
473 
474 /* Timing */
475 
476 #define SCIP_DEFAULT_TIME_CLOCKTYPE SCIP_CLOCKTYPE_WALL /**< default clock type for timing */
477 #define SCIP_DEFAULT_TIME_ENABLED TRUE /**< is timing enabled? */
478 #define SCIP_DEFAULT_TIME_READING FALSE /**< belongs reading time to solving time? */
479 #define SCIP_DEFAULT_TIME_RARECLOCKCHECK FALSE /**< should clock checks of solving time be performed less frequently (might exceed time limit slightly) */
480 #define SCIP_DEFAULT_TIME_STATISTICTIMING TRUE /**< should timing for statistic output be enabled? */
483 /* visualization output */
485 #define SCIP_DEFAULT_VISUAL_VBCFILENAME "-" /**< name of the VBC tool output file, or "-" if no VBC tool output should be created */
486 #define SCIP_DEFAULT_VISUAL_BAKFILENAME "-" /**< name of the BAK tool output file, or "-" if no BAK tool output should be created */
487 #define SCIP_DEFAULT_VISUAL_REALTIME TRUE /**< should the real solving time be used instead of a time step counter in visualization? */
488 #define SCIP_DEFAULT_VISUAL_DISPSOLS FALSE /**< should the node where solutions are found be visualized? */
489 #define SCIP_DEFAULT_VISUAL_DISPLB FALSE /**< should lower bound information be visualized? */
490 #define SCIP_DEFAULT_VISUAL_OBJEXTERN TRUE /**< should be output the external value of the objective? */
492 
493 /* Reading */
495 #define SCIP_DEFAULT_READ_INITIALCONSS TRUE /**< should model constraints be marked as initial? */
496 #define SCIP_DEFAULT_READ_DYNAMICCONSS TRUE /**< should model constraints be subject to aging? */
497 #define SCIP_DEFAULT_READ_DYNAMICCOLS FALSE /**< should columns be added and removed dynamically to the LP? */
498 #define SCIP_DEFAULT_READ_DYNAMICROWS FALSE /**< should rows be added and removed dynamically to the LP? */
499 #define SCIP_DEFAULT_WRITE_GENNAMES_OFFSET 0 /**< when writing the problem with generic names, we start with index
500  * 0; using this parameter we can change the starting index to be
501  * different */
502 
504 /* Writing */
505 
506 #define SCIP_DEFAULT_WRITE_ALLCONSS FALSE /**< should all constraints be written (including the redundant constraints)? */
507 #define SCIP_DEFAULT_PRINTZEROS FALSE /**< should variables set to zero be printed? */
508 
511 /** calculate memory size for dynamically allocated arrays */
512 static
513 int calcGrowSize(
514  int initsize, /**< initial size of array */
515  SCIP_Real growfac, /**< growing factor of array */
516  int num /**< minimum number of entries to store */
517  )
518 {
519  int size;
521  assert(initsize >= 0);
522  assert(growfac >= 1.0);
523  assert(num >= 0);
525  if( growfac == 1.0 )
526  size = MAX(initsize, num);
527  else
528  {
529  int oldsize;
531  /* calculate the size with this loop, such that the resulting numbers are always the same (-> block memory) */
532  initsize = MAX(initsize, 4);
533  size = initsize;
534  oldsize = size - 1;
536  /* second condition checks against overflow */
537  while( size < num && size > oldsize )
538  {
539  oldsize = size;
540  size = (int)(growfac * size + initsize);
541  }
543  /* if an overflow happened, set the correct value */
544  if( size <= oldsize )
545  size = num;
546  }
547 
548  assert(size >= initsize);
549  assert(size >= num);
550 
551  return size;
552 }
555 /** information method for a parameter change of feastol */
556 static
557 SCIP_DECL_PARAMCHGD(paramChgdFeastol)
558 { /*lint --e{715}*/
559  SCIP_Real newfeastol;
561  newfeastol = SCIPparamGetReal(param);
563  /* change the feastol through the SCIP call in order to adjust LP's feastol if necessary */
564  SCIP_CALL( SCIPchgFeastol(scip, newfeastol) );
566  return SCIP_OKAY;
567 }
568 
569 /** information method for a parameter change of lpfeastolfactor */
570 static
571 SCIP_DECL_PARAMCHGD(paramChgdLPFeastolFactor)
572 { /*lint --e{715}*/
573  SCIP_Real newlpfeastolfactor;
575  newlpfeastolfactor = SCIPparamGetReal(param);
576 
577  if( SCIPgetStage(scip) == SCIP_STAGE_SOLVING && SCIPgetLPFeastol(scip) > newlpfeastolfactor * SCIPfeastol(scip) )
578  {
579  /* reset the LP feastol to ensure that it does not exceed newlpfeastolfactor * SCIP's feastol
580  * this also marks the LP unsolved
581  */
583  }
585  return SCIP_OKAY;
586 }
587 
588 /** information method for a parameter change of dualfeastol */
589 static
590 SCIP_DECL_PARAMCHGD(paramChgdDualfeastol)
591 { /*lint --e{715}*/
592  SCIP_Real newdualfeastol;
593 
594  newdualfeastol = SCIPparamGetReal(param);
595 
596  /* change the dualfeastol through the SCIP call in order to mark the LP unsolved */
597  SCIP_CALL( SCIPchgDualfeastol(scip, newdualfeastol) );
598 
599  return SCIP_OKAY;
600 }
601 
602 /** information method for a parameter change of barrierconvtol */
603 static
604 SCIP_DECL_PARAMCHGD(paramChgdBarrierconvtol)
605 { /*lint --e{715}*/
606  SCIP_Real newbarrierconvtol;
607 
608  newbarrierconvtol = SCIPparamGetReal(param);
609 
610  /* change the barrierconvtol through the SCIP call in order to mark the LP unsolved */
611  SCIP_CALL( SCIPchgBarrierconvtol(scip, newbarrierconvtol) );
612 
613  return SCIP_OKAY;
614 }
615 
616 /** information method for a parameter change of infinity value */
617 static
618 SCIP_DECL_PARAMCHGD(paramChgdInfinity)
619 { /*lint --e{715}*/
621 
622  infinity = SCIPparamGetReal(param);
623 
624  /* Check that infinity value of LP-solver is at least as large as the one used in SCIP. This is necessary, because we
625  * transfer SCIP infinity values to the ones by the LPI, but not the converse. */
626  if ( scip->lp != NULL && scip->lp->lpi != NULL && infinity > SCIPlpiInfinity(scip->lp->lpi) )
627  {
628  SCIPerrorMessage("The infinity value of the LP solver has to be at least as large as the one of SCIP.\n");
629  return SCIP_PARAMETERWRONGVAL;
630  }
631 
632  return SCIP_OKAY;
633 }
635 /** parameter change information method to autoselect display columns again */
636 static
637 SCIP_DECL_PARAMCHGD(SCIPparamChgdDispWidth)
638 { /*lint --e{715}*/
639  /* automatically select the new active display columns */
641 
642  return SCIP_OKAY;
643 }
644 
645 /** parameter change information method that some limit was changed */
646 static
647 SCIP_DECL_PARAMCHGD(SCIPparamChgdLimit)
648 { /*lint --e{715}*/
650  return SCIP_OKAY;
651 }
652 
653 /** information method for a parameter change of mem_arraygrowfac */
654 static
655 SCIP_DECL_PARAMCHGD(paramChgdArraygrowfac)
656 { /*lint --e{715}*/
657  SCIP_Real newarraygrowfac;
658 
659  newarraygrowfac = SCIPparamGetReal(param);
660 
661  /* change arraygrowfac */
664 
665  return SCIP_OKAY;
666 }
668 /** information method for a parameter change of mem_arraygrowinit */
669 static
670 SCIP_DECL_PARAMCHGD(paramChgdArraygrowinit)
671 { /*lint --e{715}*/
672  int newarraygrowinit;
673 
674  newarraygrowinit = SCIPparamGetInt(param);
675 
676  /* change arraygrowinit */
677  BMSsetBufferMemoryArraygrowinit(SCIPbuffer(scip), newarraygrowinit);
679 
680  return SCIP_OKAY;
681 }
682 
683 /** information method for a parameter change of reopt_enable */
684 static
685 SCIP_DECL_PARAMCHGD(paramChgdEnableReopt)
686 { /*lint --e{715}*/
687  SCIP_RETCODE retcode;
688 
689  assert( scip != NULL );
690  assert( param != NULL );
691 
692  /* create or deconstruct the reoptimization data structures */
694 
695  /* an appropriate error message is already printed in the above method */
696  if( retcode == SCIP_INVALIDCALL )
697  return SCIP_PARAMETERWRONGVAL;
698 
699  return SCIP_OKAY;
700 }
701 
702 /** information method for a parameter change of usesymmetry */
703 static
704 SCIP_DECL_PARAMCHGD(paramChgdUsesymmetry)
705 { /*lint --e{715}*/
706  assert( scip != NULL );
707  assert( param != NULL );
708 
710  {
711  if ( SCIPparamGetInt(param) > 0 )
712  {
713  SCIPerrorMessage("Cannot turn on symmetry handling during (pre)solving or change method.\n");
715  }
716  }
717 
718  return SCIP_OKAY;
719 }
720 
721 /** set parameters for reoptimization */
723  SCIP_SET* set, /**< SCIP data structure */
724  SCIP_MESSAGEHDLR* messagehdlr /**< message handler */
725  )
726 {
727  assert(set != NULL);
728  assert(messagehdlr != NULL);
729 
730  if( set->reopt_enable )
731  {
732  /* disable some parts of conflict analysis */
733  SCIP_CALL( SCIPsetSetCharParam(set, messagehdlr, "conflict/useboundlp", 'o') );
734  SCIP_CALL( SCIPsetSetBoolParam(set, messagehdlr, "conflict/usepseudo", FALSE) );
735 
736  /* TODO check wheather multi aggregation can be enabled in reoptimization */
737  if( SCIPsetIsParamFixed(set, "presolving/donotmultaggr") )
738  {
739  SCIP_CALL( SCIPsetChgParamFixed(set, "presolving/donotmultaggr", FALSE) );
740  }
741  SCIP_CALL( SCIPsetSetBoolParam(set, messagehdlr, "presolving/donotmultaggr", TRUE) );
742 
743  if( SCIPsetIsParamFixed(set, "branching/nodereopt/priority") )
744  {
745  SCIP_CALL( SCIPsetChgParamFixed(set, "branching/nodereopt/priority", FALSE) );
746  }
747  SCIP_CALL( SCIPsetSetIntParam(set, messagehdlr, "branching/nodereopt/priority", INT_MAX/4) );
748  }
749  else
750  {
751  /* disable conflict analysis */
752  if( SCIPsetIsParamFixed(set, "conflict/enable") )
753  {
754  SCIP_CALL( SCIPsetChgParamFixed(set, "conflict/enable", FALSE) );
755  }
756  SCIP_CALL( SCIPsetResetParam(set, messagehdlr, "conflict/enable") );
757 
758  /* TODO check wheather multi aggregation can be enabled in reoptimization */
759  if( SCIPsetIsParamFixed(set, "presolving/donotmultaggr") )
760  {
761  SCIP_CALL( SCIPsetChgParamFixed(set, "presolving/donotmultaggr", FALSE) );
762  }
763  SCIP_CALL( SCIPsetResetParam(set, messagehdlr, "presolving/donotmultaggr") );
764 
765  /* set priority to defeault */
766  if( SCIPsetFindBranchrule(set, "nodereopt") != NULL )
767  {
768  if( SCIPsetIsParamFixed(set, "branching/nodereopt/priority") )
769  {
770  SCIP_CALL( SCIPsetChgParamFixed(set, "branching/nodereopt/priority", FALSE) );
771  }
772  SCIP_CALL( SCIPsetResetParam(set, messagehdlr, "branching/nodereopt/priority") );
773  }
774  }
775 
776  return SCIP_OKAY;
777 }
778 
779 /** enable or disable all plugin timers depending on the value of the flag \p enabled */
781  SCIP_SET* set, /**< SCIP settings */
782  SCIP_Bool enabled /**< should plugin clocks be enabled? */
783  )
784 {
785  int i;
786 
787  assert(set != NULL);
788 
789  /* go through all plugin types and enable or disable their respective clocks */
790  for( i = set->nreaders - 1; i >= 0; --i )
791  SCIPreaderEnableOrDisableClocks(set->readers[i], enabled);
792 
793  for( i = set->npricers - 1; i >= 0; --i )
794  SCIPpricerEnableOrDisableClocks(set->pricers[i], enabled);
795 
796  for( i = set->nconshdlrs - 1; i >= 0; --i )
797  SCIPconshdlrEnableOrDisableClocks(set->conshdlrs[i], enabled);
798 
799  for( i = set->nconflicthdlrs - 1; i >= 0; --i )
800  SCIPconflicthdlrEnableOrDisableClocks(set->conflicthdlrs[i], enabled);
801 
802  for( i = set->npresols - 1; i >= 0; --i )
803  SCIPpresolEnableOrDisableClocks(set->presols[i], enabled);
804 
805  for( i = set->nrelaxs - 1; i >= 0; --i )
806  SCIPrelaxEnableOrDisableClocks(set->relaxs[i], enabled);
807 
808  for( i = set->nsepas - 1; i >= 0; --i )
809  SCIPsepaEnableOrDisableClocks(set->sepas[i], enabled);
810 
811  for( i = set->nprops - 1; i >= 0; --i )
812  SCIPpropEnableOrDisableClocks(set->props[i], enabled);
813 
814  for( i = set->nheurs - 1; i >= 0; --i )
815  SCIPheurEnableOrDisableClocks(set->heurs[i], enabled);
816 
817  for( i = set->neventhdlrs - 1; i >= 0; --i )
818  SCIPeventhdlrEnableOrDisableClocks(set->eventhdlrs[i], enabled);
819 
820  for( i = set->nnodesels - 1; i >= 0; --i )
821  SCIPnodeselEnableOrDisableClocks(set->nodesels[i], enabled);
822 
823  for( i = set->nbranchrules - 1; i >= 0; --i )
824  SCIPbranchruleEnableOrDisableClocks(set->branchrules[i], enabled);
825 }
826 
827 /* method to be invoked when the parameter timing/statistictiming is changed */
828 static
829 SCIP_DECL_PARAMCHGD(paramChgdStatistictiming)
830 { /*lint --e{715}*/
832 
833  return SCIP_OKAY;
834 }
835 
836 /** copies plugins from sourcescip to targetscip; in case that a constraint handler which does not need constraints
837  * cannot be copied, valid will return FALSE. All plugins can declare that, if their copy process failed, the
838  * copied SCIP instance might not represent the same problem semantics as the original.
839  * Note that in this case dual reductions might be invalid. */
841  SCIP_SET* sourceset, /**< source SCIP_SET data structure */
842  SCIP_SET* targetset, /**< target SCIP_SET data structure */
843  SCIP_Bool copyreaders, /**< should the file readers be copied */
844  SCIP_Bool copypricers, /**< should the variable pricers be copied */
845  SCIP_Bool copyconshdlrs, /**< should the constraint handlers be copied */
846  SCIP_Bool copyconflicthdlrs, /**< should the conflict handlers be copied */
847  SCIP_Bool copypresolvers, /**< should the presolvers be copied */
848  SCIP_Bool copyrelaxators, /**< should the relaxators be copied */
849  SCIP_Bool copyseparators, /**< should the separators be copied */
850  SCIP_Bool copypropagators, /**< should the propagators be copied */
851  SCIP_Bool copyheuristics, /**< should the heuristics be copied */
852  SCIP_Bool copyeventhdlrs, /**< should the event handlers be copied */
853  SCIP_Bool copynodeselectors, /**< should the node selectors be copied */
854  SCIP_Bool copybranchrules, /**< should the branchrules be copied */
855  SCIP_Bool copydisplays, /**< should the display columns be copied */
856  SCIP_Bool copydialogs, /**< should the dialogs be copied */
857  SCIP_Bool copytables, /**< should the statistics tables be copied */
858  SCIP_Bool copynlpis, /**< should the NLP interfaces be copied */
859  SCIP_Bool* allvalid /**< pointer to store whether all plugins were validly copied */
860  )
861 {
862  int p;
863  SCIP_Bool valid;
864 
865  assert(sourceset != NULL);
866  assert(targetset != NULL);
867  assert(sourceset != targetset);
868  assert(allvalid != NULL);
869 
870  *allvalid = TRUE;
871 
872  /* copy all reader plugins */
873  if( copyreaders && sourceset->readers != NULL )
874  {
875  for( p = sourceset->nreaders - 1; p >= 0; --p )
876  {
877  SCIP_CALL( SCIPreaderCopyInclude(sourceset->readers[p], targetset) );
878  }
879  }
880 
881  /* copy all variable pricer plugins */
882  if( copypricers && sourceset->pricers != NULL )
883  {
884  for( p = sourceset->npricers - 1; p >= 0; --p )
885  {
886  valid = FALSE;
887  SCIP_CALL( SCIPpricerCopyInclude(sourceset->pricers[p], targetset, &valid) );
888  *allvalid = *allvalid && valid;
889  if( SCIPpricerIsActive(sourceset->pricers[p]) )
890  {
891  SCIP_CALL( SCIPactivatePricer(targetset->scip, targetset->pricers[p]) );
892  }
893  }
894  }
895 
896  /* copy all constraint handler plugins */
897  if( copyconshdlrs && sourceset->conshdlrs_include != NULL )
898  {
899  /* copy them in order they were added to the sourcescip
900  *
901  * @note we only have to set the valid pointer to FALSE in case that a constraint handler, which does not need
902  * constraints, does not copy; in the case that a constraint handler does not copy and it needs constraint
903  * we will detect later that the problem is not valid if a constraint of that type exits
904  */
905  for( p = 0; p < sourceset->nconshdlrs; ++p )
906  {
907  if( SCIPconshdlrIsClonable(sourceset->conshdlrs_include[p]) )
908  {
909  valid = FALSE;
910  SCIP_CALL( SCIPconshdlrCopyInclude(sourceset->conshdlrs_include[p], targetset, &valid) );
911  *allvalid = *allvalid && valid;
912  SCIPsetDebugMsg(sourceset, "Copying conshdlr <%s> was%s valid.\n", SCIPconshdlrGetName(sourceset->conshdlrs_include[p]), valid ? "" : " not");
913  }
914  else if( !SCIPconshdlrNeedsCons(sourceset->conshdlrs_include[p]) )
915  {
916  SCIPsetDebugMsg(sourceset, "Copying Conshdlr <%s> without constraints not valid.\n", SCIPconshdlrGetName(sourceset->conshdlrs_include[p]));
917  *allvalid = FALSE;
918  }
919  }
920  }
921 
922  /* copy all conflict handler plugins */
923  if( copyconflicthdlrs && sourceset->conflicthdlrs != NULL )
924  {
925  for( p = sourceset->nconflicthdlrs - 1; p >= 0; --p )
926  {
927  SCIP_CALL( SCIPconflicthdlrCopyInclude(sourceset->conflicthdlrs[p], targetset) );
928  }
929  }
930 
931  /* copy all presolver plugins */
932  if( copypresolvers && sourceset->presols != NULL )
933  {
934  for( p = sourceset->npresols - 1; p >= 0; --p )
935  {
936  SCIP_CALL( SCIPpresolCopyInclude(sourceset->presols[p], targetset) );
937  }
938  }
939 
940  /* copy all relaxator plugins */
941  if( copyrelaxators && sourceset->relaxs != NULL )
942  {
943  for( p = sourceset->nrelaxs - 1; p >= 0; --p )
944  {
945  SCIP_CALL( SCIPrelaxCopyInclude(sourceset->relaxs[p], targetset) );
946  }
947  }
948 
949  /* copy all separator plugins */
950  if( copyseparators && sourceset->sepas != NULL )
951  {
952  for( p = sourceset->nsepas - 1; p >= 0; --p )
953  {
954  SCIP_CALL( SCIPsepaCopyInclude(sourceset->sepas[p], targetset) );
955  }
956  }
957 
958  /* copy all propagators plugins */
959  if( copypropagators && sourceset->props != NULL )
960  {
961  for( p = sourceset->nprops - 1; p >= 0; --p )
962  {
963  SCIP_CALL( SCIPpropCopyInclude(sourceset->props[p], targetset) );
964  }
965  }
966 
967  /* copy all primal heuristics plugins */
968  if( copyheuristics && sourceset->heurs != NULL )
969  {
970  for( p = sourceset->nheurs - 1; p >= 0; --p )
971  {
972  SCIP_CALL( SCIPheurCopyInclude(sourceset->heurs[p], targetset) );
973  }
974  }
975 
976  /* copy all event handler plugins */
977  if( copyeventhdlrs && sourceset->eventhdlrs != NULL )
978  {
979  for( p = sourceset->neventhdlrs - 1; p >= 0; --p )
980  {
981  /* @todo: the copying process of event handlers is currently not checked for consistency */
982  SCIP_CALL( SCIPeventhdlrCopyInclude(sourceset->eventhdlrs[p], targetset) );
983  }
984  }
985 
986  /* copy all node selector plugins */
987  if( copynodeselectors && sourceset->nodesels != NULL )
988  {
989  for( p = sourceset->nnodesels - 1; p >= 0; --p )
990  {
991  SCIP_CALL( SCIPnodeselCopyInclude(sourceset->nodesels[p], targetset) );
992  }
993  }
994 
995  /* copy all branchrule plugins */
996  if( copybranchrules && sourceset->branchrules != NULL )
997  {
998  for( p = sourceset->nbranchrules - 1; p >= 0; --p )
999  {
1000  SCIP_CALL( SCIPbranchruleCopyInclude(sourceset->branchrules[p], targetset) );
1001  }
1002  }
1003 
1004  /* copy all display plugins */
1005  if( copydisplays && sourceset->disps != NULL )
1006  {
1007  for( p = sourceset->ndisps - 1; p >= 0; --p )
1008  {
1009  SCIP_CALL( SCIPdispCopyInclude(sourceset->disps[p], targetset) );
1010  }
1011  }
1012 
1013  /* copy all dialog plugins */
1014  if( copydialogs && sourceset->dialogs != NULL )
1015  {
1016  for( p = sourceset->ndialogs - 1; p >= 0; --p )
1017  {
1018  /* @todo: the copying process of dialog handlers is currently not checked for consistency */
1019  SCIP_CALL( SCIPdialogCopyInclude(sourceset->dialogs[p], targetset) );
1020  }
1021  }
1022 
1023  /* copy all table plugins */
1024  if( copytables && sourceset->tables != NULL )
1025  {
1026  for( p = sourceset->ntables - 1; p >= 0; --p )
1027  {
1028  SCIP_CALL( SCIPtableCopyInclude(sourceset->tables[p], targetset) );
1029  }
1030  }
1031 
1032  /* copy all NLP interfaces */
1033  if( copynlpis && sourceset->nlpis != NULL )
1034  {
1035  for( p = sourceset->nnlpis - 1; p >= 0; --p )
1036  {
1037  SCIP_NLPI* nlpicopy;
1038 
1039  SCIP_CALL_FINALLY( SCIPnlpiCopy(SCIPblkmem(targetset->scip), sourceset->nlpis[p], &nlpicopy), (void)SCIPnlpiFree(&nlpicopy) );
1040  SCIP_CALL( SCIPincludeNlpi(targetset->scip, nlpicopy) );
1041  }
1042  }
1043 
1044  return SCIP_OKAY;
1045 }
1046 
1047 
1048 /** copies parameters from sourcescip to targetscip */
1050  SCIP_SET* sourceset, /**< source SCIP_SET data structure */
1051  SCIP_SET* targetset, /**< target SCIP_SET data structure */
1052  SCIP_MESSAGEHDLR* messagehdlr /**< message handler of target SCIP */
1053  )
1054 {
1055  assert(sourceset != NULL);
1056  assert(targetset != NULL);
1057  assert(sourceset != targetset);
1058  assert(targetset->scip != NULL);
1059 
1060  SCIP_CALL( SCIPparamsetCopyParams(sourceset->paramset, targetset->paramset, targetset, messagehdlr) );
1061 
1062  return SCIP_OKAY;
1063 }
1064 
1065 /** creates global SCIP settings */
1067  SCIP_SET** set, /**< pointer to SCIP settings */
1068  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1069  BMS_BLKMEM* blkmem, /**< block memory */
1070  SCIP* scip /**< SCIP data structure */
1071  )
1072 {
1073  assert(set != NULL);
1074  assert(scip != NULL);
1075 
1076  SCIP_ALLOC( BMSallocMemory(set) );
1077 
1078  (*set)->stage = SCIP_STAGE_INIT;
1079  (*set)->scip = scip;
1080  (*set)->buffer = SCIPbuffer(scip);
1081  (*set)->cleanbuffer = SCIPcleanbuffer(scip);
1082 
1083  SCIP_CALL( SCIPparamsetCreate(&(*set)->paramset, blkmem) );
1084 
1085  (*set)->readers = NULL;
1086  (*set)->nreaders = 0;
1087  (*set)->readerssize = 0;
1088  (*set)->pricers = NULL;
1089  (*set)->npricers = 0;
1090  (*set)->nactivepricers = 0;
1091  (*set)->pricerssize = 0;
1092  (*set)->pricerssorted = FALSE;
1093  (*set)->pricersnamesorted = FALSE;
1094  (*set)->conshdlrs = NULL;
1095  (*set)->conshdlrs_sepa = NULL;
1096  (*set)->conshdlrs_enfo = NULL;
1097  (*set)->conshdlrs_include = NULL;
1098  (*set)->nconshdlrs = 0;
1099  (*set)->conshdlrssize = 0;
1100  (*set)->conflicthdlrs = NULL;
1101  (*set)->nconflicthdlrs = 0;
1102  (*set)->conflicthdlrssize = 0;
1103  (*set)->conflicthdlrssorted = FALSE;
1104  (*set)->conflicthdlrsnamesorted = FALSE;
1105  (*set)->benders = NULL;
1106  (*set)->nbenders = 0;
1107  (*set)->nactivebenders = 0;
1108  (*set)->benderssize = 0;
1109  (*set)->benderssorted = FALSE;
1110  (*set)->bendersnamesorted = FALSE;
1111 
1112  (*set)->debugsoldata = NULL;
1113  SCIP_CALL( SCIPdebugSolDataCreate(&(*set)->debugsoldata) ); /*lint !e506 !e774*/
1114 
1115  (*set)->presols = NULL;
1116  (*set)->npresols = 0;
1117  (*set)->presolssize = 0;
1118  (*set)->presolssorted = FALSE;
1119  (*set)->presolsnamesorted = FALSE;
1120  (*set)->relaxs = NULL;
1121  (*set)->nrelaxs = 0;
1122  (*set)->relaxssize = 0;
1123  (*set)->relaxssorted = FALSE;
1124  (*set)->relaxsnamesorted = FALSE;
1125  (*set)->sepas = NULL;
1126  (*set)->nsepas = 0;
1127  (*set)->sepassize = 0;
1128  (*set)->sepassorted = FALSE;
1129  (*set)->sepasnamesorted = FALSE;
1130  (*set)->props = NULL;
1131  (*set)->props_presol = NULL;
1132  (*set)->nprops = 0;
1133  (*set)->propssize = 0;
1134  (*set)->propssorted = FALSE;
1135  (*set)->propspresolsorted = FALSE;
1136  (*set)->propsnamesorted = FALSE;
1137  (*set)->concsolvertypes = NULL;
1138  (*set)->nconcsolvertypes = 0;
1139  (*set)->concsolvertypessize = 0;
1140  (*set)->concsolvers = NULL;
1141  (*set)->nconcsolvers = 0;
1142  (*set)->concsolverssize = 0;
1143  (*set)->concurrent_paramsetprefix = NULL;
1144  (*set)->heurs = NULL;
1145  (*set)->nheurs = 0;
1146  (*set)->heurssize = 0;
1147  (*set)->heurssorted = FALSE;
1148  (*set)->heursnamesorted = FALSE;
1149  (*set)->comprs = NULL;
1150  (*set)->ncomprs = 0;
1151  (*set)->comprssize = 0;
1152  (*set)->comprssorted = FALSE;
1153  (*set)->comprsnamesorted = FALSE;
1154  (*set)->eventhdlrs = NULL;
1155  (*set)->neventhdlrs = 0;
1156  (*set)->eventhdlrssize = 0;
1157  (*set)->nodesels = NULL;
1158  (*set)->nnodesels = 0;
1159  (*set)->nodeselssize = 0;
1160  (*set)->nodesel = NULL;
1161  (*set)->branchrules = NULL;
1162  (*set)->nbranchrules = 0;
1163  (*set)->branchrulessize = 0;
1164  (*set)->branchrulessorted = FALSE;
1165  (*set)->branchrulesnamesorted = FALSE;
1166  (*set)->banditvtables = NULL;
1167  (*set)->banditvtablessize = 0;
1168  (*set)->nbanditvtables = 0;
1169  (*set)->disps = NULL;
1170  (*set)->ndisps = 0;
1171  (*set)->dispssize = 0;
1172  (*set)->tables = NULL;
1173  (*set)->ntables = 0;
1174  (*set)->tablessize = 0;
1175  (*set)->tablessorted = FALSE;
1176  (*set)->dialogs = NULL;
1177  (*set)->ndialogs = 0;
1178  (*set)->dialogssize = 0;
1179  (*set)->nlpis = NULL;
1180  (*set)->nnlpis = 0;
1181  (*set)->nlpissize = 0;
1182  (*set)->nlpissorted = FALSE;
1183  (*set)->limitchanged = FALSE;
1184  (*set)->subscipsoff = FALSE;
1185  (*set)->extcodenames = NULL;
1186  (*set)->extcodedescs = NULL;
1187  (*set)->nextcodes = 0;
1188  (*set)->extcodessize = 0;
1189  (*set)->visual_vbcfilename = NULL;
1190  (*set)->visual_bakfilename = NULL;
1191  (*set)->nlp_solver = NULL;
1192  (*set)->nlp_disable = FALSE;
1193  (*set)->num_relaxfeastol = SCIP_INVALID;
1194  (*set)->misc_debugsol = NULL;
1195 
1196  /* the default time limit is infinite */
1197  (*set)->istimelimitfinite = FALSE;
1198 
1199  /* branching parameters */
1200  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
1201  "branching/scorefunc",
1202  "branching score function ('s'um, 'p'roduct, 'q'uotient)",
1203  &(*set)->branch_scorefunc, TRUE, SCIP_DEFAULT_BRANCH_SCOREFUNC, "spq",
1204  NULL, NULL) );
1205  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1206  "branching/scorefac",
1207  "branching score factor to weigh downward and upward gain prediction in sum score function",
1208  &(*set)->branch_scorefac, TRUE, SCIP_DEFAULT_BRANCH_SCOREFAC, 0.0, 1.0,
1209  NULL, NULL) );
1210  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1211  "branching/preferbinary",
1212  "should branching on binary variables be preferred?",
1213  &(*set)->branch_preferbinary, FALSE, SCIP_DEFAULT_BRANCH_PREFERBINARY,
1214  NULL, NULL) );
1215  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1216  "branching/clamp",
1217  "minimal relative distance of branching point to bounds when branching on a continuous variable",
1218  &(*set)->branch_clamp, FALSE, SCIP_DEFAULT_BRANCH_CLAMP, 0.0, 0.5,
1219  NULL, NULL) );
1220  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1221  "branching/midpull",
1222  "fraction by which to move branching point of a continuous variable towards the middle of the domain; a value of 1.0 leads to branching always in the middle of the domain",
1223  &(*set)->branch_midpull, FALSE, SCIP_DEFAULT_BRANCH_MIDPULL, 0.0, 1.0,
1224  NULL, NULL) );
1225  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1226  "branching/midpullreldomtrig",
1227  "multiply midpull by relative domain width if the latter is below this value",
1228  &(*set)->branch_midpullreldomtrig, FALSE, SCIP_DEFAULT_BRANCH_MIDPULLRELDOMTRIG, 0.0, 1.0,
1229  NULL, NULL) );
1230  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
1231  "branching/lpgainnormalize",
1232  "strategy for normalization of LP gain when updating pseudocosts of continuous variables (divide by movement of 'l'p value, reduction in 'd'omain width, or reduction in domain width of 's'ibling)",
1233  &(*set)->branch_lpgainnorm, FALSE, SCIP_DEFAULT_BRANCH_LPGAINNORMALIZE, "dls",
1234  NULL, NULL) );
1235  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1236  "branching/delaypscostupdate",
1237  "should updating pseudo costs for continuous variables be delayed to the time after separation?",
1238  &(*set)->branch_delaypscost, FALSE, SCIP_DEFAULT_BRANCH_DELAYPSCOST,
1239  NULL, NULL) );
1240  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1241  "branching/divingpscost",
1242  "should pseudo costs be updated also in diving and probing mode?",
1243  &(*set)->branch_divingpscost, FALSE, SCIP_DEFAULT_BRANCH_DIVINGPSCOST,
1244  NULL, NULL) );
1245  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1246  "branching/forceallchildren",
1247  "should all strong branching children be regarded even if one is detected to be infeasible? (only with propagation)",
1248  &(*set)->branch_forceall, TRUE, SCIP_DEFAULT_BRANCH_FORCEALL,
1249  NULL, NULL) );
1250  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
1251  "branching/firstsbchild",
1252  "child node to be regarded first during strong branching (only with propagation): 'u'p child, 'd'own child, 'h'istory-based, or 'a'utomatic",
1253  &(*set)->branch_firstsbchild, TRUE, SCIP_DEFAULT_BRANCH_FIRSTSBCHILD, "aduh",
1254  NULL, NULL) );
1255  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1256  "branching/checksol",
1257  "should LP solutions during strong branching with propagation be checked for feasibility?",
1258  &(*set)->branch_checksbsol, TRUE, SCIP_DEFAULT_BRANCH_CHECKSBSOL,
1259  NULL, NULL) );
1260  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1261  "branching/roundsbsol",
1262  "should LP solutions during strong branching with propagation be rounded? (only when checksbsol=TRUE)",
1263  &(*set)->branch_roundsbsol, TRUE, SCIP_DEFAULT_BRANCH_ROUNDSBSOL,
1264  NULL, NULL) );
1265  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1266  "branching/sumadjustscore",
1267  "score adjustment near zero by adding epsilon (TRUE) or using maximum (FALSE)",
1268  &(*set)->branch_sumadjustscore, TRUE, SCIP_DEFAULT_BRANCH_SUMADJUSTSCORE,
1269  NULL, NULL) );
1270 
1271  /* tree compression parameters */
1272  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1273  "compression/enable",
1274  "should automatic tree compression after the presolving be enabled?",
1275  &(*set)->compr_enable, TRUE, SCIP_DEFAULT_COMPR_ENABLE,
1276  NULL, NULL) );
1277 
1278  /* conflict analysis parameters */
1279  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1280  "conflict/enable",
1281  "should conflict analysis be enabled?",
1282  &(*set)->conf_enable, FALSE, SCIP_DEFAULT_CONF_ENABLE,
1283  NULL, NULL) );
1284  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1285  "conflict/cleanboundexceedings",
1286  "should conflicts based on an old cutoff bound be removed from the conflict pool after improving the primal bound?",
1287  &(*set)->conf_cleanbnddepend, TRUE, SCIP_DEFAULT_CONF_CLEANBNDDEPEND,
1288  NULL, NULL) );
1289  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1290  "conflict/uselocalrows",
1291  "use local rows to construct infeasibility proofs",
1292  &(*set)->conf_uselocalrows, TRUE, SCIP_DEFAULT_CONF_USELOCALROWS,
1293  NULL, NULL) );
1294  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1295  "conflict/useprop",
1296  "should propagation conflict analysis be used?",
1297  &(*set)->conf_useprop, FALSE, SCIP_DEFAULT_CONF_USEPROP,
1298  NULL, NULL) );
1299  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
1300  "conflict/useinflp",
1301  "should infeasible LP conflict analysis be used? ('o'ff, 'c'onflict graph, 'd'ual ray, 'b'oth conflict graph and dual ray)",
1302  &(*set)->conf_useinflp, FALSE, SCIP_DEFAULT_CONF_USEINFLP, "ocdb",
1303  NULL, NULL) );
1304  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
1305  "conflict/useboundlp",
1306  "should bound exceeding LP conflict analysis be used? ('o'ff, 'c'onflict graph, 'd'ual ray, 'b'oth conflict graph and dual ray)",
1307  &(*set)->conf_useboundlp, FALSE, SCIP_DEFAULT_CONF_USEBOUNDLP, "ocdb",
1308  NULL, NULL) );
1309  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1310  "conflict/usesb",
1311  "should infeasible/bound exceeding strong branching conflict analysis be used?",
1312  &(*set)->conf_usesb, FALSE, SCIP_DEFAULT_CONF_USESB,
1313  NULL, NULL) );
1314  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1315  "conflict/usepseudo",
1316  "should pseudo solution conflict analysis be used?",
1317  &(*set)->conf_usepseudo, FALSE, SCIP_DEFAULT_CONF_USEPSEUDO,
1318  NULL, NULL) );
1319  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1320  "conflict/maxvarsfac",
1321  "maximal fraction of variables involved in a conflict constraint",
1322  &(*set)->conf_maxvarsfac, TRUE, SCIP_DEFAULT_CONF_MAXVARSFAC, 0.0, SCIP_REAL_MAX,
1323  NULL, NULL) );
1324  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1325  "conflict/minmaxvars",
1326  "minimal absolute maximum of variables involved in a conflict constraint",
1327  &(*set)->conf_minmaxvars, TRUE, SCIP_DEFAULT_CONF_MINMAXVARS, 0, INT_MAX,
1328  NULL, NULL) );
1329  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1330  "conflict/maxlploops",
1331  "maximal number of LP resolving loops during conflict analysis (-1: no limit)",
1332  &(*set)->conf_maxlploops, TRUE, SCIP_DEFAULT_CONF_MAXLPLOOPS, -1, INT_MAX,
1333  NULL, NULL) );
1334  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1335  "conflict/lpiterations",
1336  "maximal number of LP iterations in each LP resolving loop (-1: no limit)",
1337  &(*set)->conf_lpiterations, TRUE, SCIP_DEFAULT_CONF_LPITERATIONS, -1, INT_MAX,
1338  NULL, NULL) );
1339  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1340  "conflict/fuiplevels",
1341  "number of depth levels up to which first UIP's are used in conflict analysis (-1: use All-FirstUIP rule)",
1342  &(*set)->conf_fuiplevels, TRUE, SCIP_DEFAULT_CONF_FUIPLEVELS, -1, INT_MAX,
1343  NULL, NULL) );
1344  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1345  "conflict/interconss",
1346  "maximal number of intermediate conflict constraints generated in conflict graph (-1: use every intermediate constraint)",
1347  &(*set)->conf_interconss, TRUE, SCIP_DEFAULT_CONF_INTERCONSS, -1, INT_MAX,
1348  NULL, NULL) );
1349  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1350  "conflict/reconvlevels",
1351  "number of depth levels up to which UIP reconvergence constraints are generated (-1: generate reconvergence constraints in all depth levels)",
1352  &(*set)->conf_reconvlevels, TRUE, SCIP_DEFAULT_CONF_RECONVLEVELS, -1, INT_MAX,
1353  NULL, NULL) );
1354  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1355  "conflict/maxconss",
1356  "maximal number of conflict constraints accepted at an infeasible node (-1: use all generated conflict constraints)",
1357  &(*set)->conf_maxconss, TRUE, SCIP_DEFAULT_CONF_MAXCONSS, -1, INT_MAX,
1358  NULL, NULL) );
1359  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1360  "conflict/maxstoresize",
1361  "maximal size of conflict store (-1: auto, 0: disable storage)",
1362  &(*set)->conf_maxstoresize, TRUE, SCIP_DEFAULT_CONF_MAXSTORESIZE, -1, INT_MAX,
1363  NULL, NULL) );
1364  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1365  "conflict/preferbinary",
1366  "should binary conflicts be preferred?",
1367  &(*set)->conf_preferbinary, FALSE, SCIP_DEFAULT_CONF_PREFERBINARY,
1368  NULL, NULL) );
1369  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1370  "conflict/prefinfproof",
1371  "prefer infeasibility proof to boundexceeding proof",
1372  &(*set)->conf_prefinfproof, TRUE, SCIP_DEFAULT_CONF_PREFINFPROOF,
1373  NULL, NULL) );
1374  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1375  "conflict/allowlocal",
1376  "should conflict constraints be generated that are only valid locally?",
1377  &(*set)->conf_allowlocal, TRUE, SCIP_DEFAULT_CONF_ALLOWLOCAL,
1378  NULL, NULL) );
1379  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1380  "conflict/settlelocal",
1381  "should conflict constraints be attached only to the local subtree where they can be useful?",
1382  &(*set)->conf_settlelocal, TRUE, SCIP_DEFAULT_CONF_SETTLELOCAL,
1383  NULL, NULL) );
1384  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1385  "conflict/repropagate",
1386  "should earlier nodes be repropagated in order to replace branching decisions by deductions?",
1387  &(*set)->conf_repropagate, TRUE, SCIP_DEFAULT_CONF_REPROPAGATE,
1388  NULL, NULL) );
1389  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1390  "conflict/keepreprop",
1391  "should constraints be kept for repropagation even if they are too long?",
1392  &(*set)->conf_keepreprop, TRUE, SCIP_DEFAULT_CONF_KEEPREPROP,
1393  NULL, NULL) );
1394  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1395  "conflict/separate",
1396  "should the conflict constraints be separated?",
1397  &(*set)->conf_separate, TRUE, SCIP_DEFAULT_CONF_SEPARATE,
1398  NULL, NULL) );
1399  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1400  "conflict/dynamic",
1401  "should the conflict constraints be subject to aging?",
1402  &(*set)->conf_dynamic, TRUE, SCIP_DEFAULT_CONF_DYNAMIC,
1403  NULL, NULL) );
1404  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1405  "conflict/removable",
1406  "should the conflict's relaxations be subject to LP aging and cleanup?",
1407  &(*set)->conf_removable, TRUE, SCIP_DEFAULT_CONF_REMOVEABLE,
1408  NULL, NULL) );
1409  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1410  "conflict/graph/depthscorefac",
1411  "score factor for depth level in bound relaxation heuristic",
1412  &(*set)->conf_depthscorefac, TRUE, SCIP_DEFAULT_CONF_DEPTHSCOREFAC, SCIP_REAL_MIN, SCIP_REAL_MAX,
1413  NULL, NULL) );
1414  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1415  "conflict/proofscorefac",
1416  "score factor for impact on acticity in bound relaxation heuristic",
1417  &(*set)->conf_proofscorefac, TRUE, SCIP_DEFAULT_CONF_PROOFSCOREFAC, SCIP_REAL_MIN, SCIP_REAL_MAX,
1418  NULL, NULL) );
1419  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1420  "conflict/uplockscorefac",
1421  "score factor for up locks in bound relaxation heuristic",
1422  &(*set)->conf_uplockscorefac, TRUE, SCIP_DEFAULT_CONF_UPLOCKSCOREFAC, SCIP_REAL_MIN, SCIP_REAL_MAX,
1423  NULL, NULL) );
1424  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1425  "conflict/downlockscorefac",
1426  "score factor for down locks in bound relaxation heuristic",
1427  &(*set)->conf_downlockscorefac, TRUE, SCIP_DEFAULT_CONF_DOWNLOCKSCOREFAC, SCIP_REAL_MIN, SCIP_REAL_MAX,
1428  NULL, NULL) );
1429  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1430  "conflict/scorefac",
1431  "factor to decrease importance of variables' earlier conflict scores",
1432  &(*set)->conf_scorefac, TRUE, SCIP_DEFAULT_CONF_SCOREFAC, 1e-6, 1.0,
1433  NULL, NULL) );
1434  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1435  "conflict/restartnum",
1436  "number of successful conflict analysis calls that trigger a restart (0: disable conflict restarts)",
1437  &(*set)->conf_restartnum, FALSE, SCIP_DEFAULT_CONF_RESTARTNUM, 0, INT_MAX,
1438  NULL, NULL) );
1439  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1440  "conflict/restartfac",
1441  "factor to increase restartnum with after each restart",
1442  &(*set)->conf_restartfac, FALSE, SCIP_DEFAULT_CONF_RESTARTFAC, 0.0, SCIP_REAL_MAX,
1443  NULL, NULL) );
1444  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1445  "conflict/ignorerelaxedbd",
1446  "should relaxed bounds be ignored?",
1447  &(*set)->conf_ignorerelaxedbd, TRUE, SCIP_DEFAULT_CONF_IGNORERELAXEDBD,
1448  NULL, NULL) );
1449  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1450  "conflict/maxvarsdetectimpliedbounds",
1451  "maximal number of variables to try to detect global bound implications and shorten the whole conflict set (0: disabled)",
1452  &(*set)->conf_maxvarsdetectimpliedbounds, TRUE, SCIP_DEFAULT_CONF_MAXVARSDETECTIMPLIEDBOUNDS, 0, INT_MAX,
1453  NULL, NULL) );
1454  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1455  "conflict/fullshortenconflict",
1456  "try to shorten the whole conflict set or terminate early (depending on the 'maxvarsdetectimpliedbounds' parameter)",
1457  &(*set)->conf_fullshortenconflict, TRUE, SCIP_DEFAULT_CONF_FULLSHORTENCONFLICT,
1458  NULL, NULL) );
1459  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1460  "conflict/conflictweight",
1461  "the weight the VSIDS score is weight by updating the VSIDS for a variable if it is part of a conflict",
1462  &(*set)->conf_conflictweight, FALSE, SCIP_DEFAULT_CONF_CONFLITWEIGHT, 0.0, 1.0,
1463  NULL, NULL) );
1464  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1465  "conflict/conflictgraphweight",
1466  "the weight the VSIDS score is weight by updating the VSIDS for a variable if it is part of a conflict graph",
1467  &(*set)->conf_conflictgraphweight, FALSE, SCIP_DEFAULT_CONF_CONFLITGRAPHWEIGHT, 0.0, 1.0,
1468  NULL, NULL) );
1469  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1470  "conflict/minimprove",
1471  "minimal improvement of primal bound to remove conflicts based on a previous incumbent",
1472  &(*set)->conf_minimprove, TRUE, SCIP_DEFAULT_CONF_MINIMPROVE, 0.0, 1.0, NULL, NULL) );
1473  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1474  "conflict/weightsize",
1475  "weight of the size of a conflict used in score calculation",
1476  &(*set)->conf_weightsize, TRUE, SCIP_DEFAULT_CONF_WEIGHTSIZE, 0.0, 1.0, NULL, NULL) );
1477  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1478  "conflict/weightrepropdepth",
1479  "weight of the repropagation depth of a conflict used in score calculation",
1480  &(*set)->conf_weightrepropdepth, TRUE, SCIP_DEFAULT_CONF_WEIGHTREPROPDEPTH, 0.0, 1.0, NULL, NULL) );
1481  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1482  "conflict/weightvaliddepth",
1483  "weight of the valid depth of a conflict used in score calculation",
1484  &(*set)->conf_weightvaliddepth, TRUE, SCIP_DEFAULT_CONF_WEIGHTVALIDDEPTH, 0.0, 1.0, NULL, NULL) );
1485  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1486  "conflict/sepaaltproofs",
1487  "apply cut generating functions to construct alternative proofs",
1488  &(*set)->conf_sepaaltproofs, FALSE, SCIP_DEFAULT_CONF_SEPAALTPROOFS,
1489  NULL, NULL) );
1490 
1491  /* constraint parameters */
1492  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1493  "constraints/agelimit",
1494  "maximum age an unnecessary constraint can reach before it is deleted (0: dynamic, -1: keep all constraints)",
1495  &(*set)->cons_agelimit, TRUE, SCIP_DEFAULT_CONS_AGELIMIT, -1, INT_MAX,
1496  NULL, NULL) );
1497  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1498  "constraints/obsoleteage",
1499  "age of a constraint after which it is marked obsolete (0: dynamic, -1 do not mark constraints obsolete)",
1500  &(*set)->cons_obsoleteage, TRUE, SCIP_DEFAULT_CONS_OBSOLETEAGE, -1, INT_MAX,
1501  NULL, NULL) );
1502  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1503  "constraints/disableenfops",
1504  "should enforcement of pseudo solution be disabled?",
1505  &(*set)->cons_disableenfops, TRUE, SCIP_DEFAULT_CONS_DISABLEENFOPS,
1506  NULL, NULL) );
1507 
1508  /* display parameters */
1509  assert(sizeof(int) == sizeof(SCIP_VERBLEVEL)); /*lint !e506*/
1510  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1511  "display/verblevel",
1512  "verbosity level of output",
1513  (int*)&(*set)->disp_verblevel, FALSE, (int)SCIP_DEFAULT_DISP_VERBLEVEL,
1515  NULL, NULL) );
1516  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1517  "display/width",
1518  "maximal number of characters in a node information line",
1519  &(*set)->disp_width, FALSE, SCIP_DEFAULT_DISP_WIDTH, 0, INT_MAX,
1520  SCIPparamChgdDispWidth, NULL) );
1521  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1522  "display/freq",
1523  "frequency for displaying node information lines",
1524  &(*set)->disp_freq, FALSE, SCIP_DEFAULT_DISP_FREQ, -1, INT_MAX,
1525  NULL, NULL) );
1526  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1527  "display/headerfreq",
1528  "frequency for displaying header lines (every n'th node information line)",
1529  &(*set)->disp_headerfreq, FALSE, SCIP_DEFAULT_DISP_HEADERFREQ, -1, INT_MAX,
1530  NULL, NULL) );
1531  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1532  "display/lpinfo",
1533  "should the LP solver display status messages?",
1534  &(*set)->disp_lpinfo, FALSE, SCIP_DEFAULT_DISP_LPINFO,
1535  NULL, NULL) );
1536  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1537  "display/allviols",
1538  "display all violations for a given start solution / the best solution after the solving process?",
1539  &(*set)->disp_allviols, FALSE, SCIP_DEFAULT_DISP_ALLVIOLS,
1540  NULL, NULL) );
1541  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1542  "display/relevantstats",
1543  "should the relevant statistics be displayed at the end of solving?",
1544  &(*set)->disp_relevantstats, FALSE, SCIP_DEFAULT_DISP_RELEVANTSTATS,
1545  NULL, NULL) );
1546 
1547  /* heuristic parameters */
1548  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1549  "heuristics/useuctsubscip",
1550  "should setting of common subscip parameters include the activation of the UCT node selector?",
1551  &(*set)->heur_useuctsubscip, TRUE, SCIP_DEFAULT_HEUR_USEUCTSUBSCIP, NULL, NULL) );
1552 
1553  /* history parameters */
1554  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1555  "history/valuebased",
1556  "should statistics be collected for variable domain value pairs?",
1557  &(*set)->history_valuebased, FALSE, SCIP_DEFAULT_HISTORY_VALUEBASED,
1558  NULL, NULL) );
1559  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1560  "history/allowmerge",
1561  "should variable histories be merged from sub-SCIPs whenever possible?",
1562  &(*set)->history_allowmerge, FALSE, SCIP_DEFAULT_HISTORY_ALLOWMERGE,
1563  NULL, NULL) );
1564  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1565  "history/allowtransfer",
1566  "should variable histories be transferred to initialize SCIP copies?",
1567  &(*set)->history_allowtransfer, FALSE, SCIP_DEFAULT_HISTORY_ALLOWTRANSFER,
1568  NULL, NULL) );
1569 
1570  /* limit parameters */
1571  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1572  "limits/time",
1573  "maximal time in seconds to run",
1574  &(*set)->limit_time, FALSE, SCIP_DEFAULT_LIMIT_TIME, 0.0, SCIP_DEFAULT_LIMIT_TIME,
1575  SCIPparamChgdLimit, NULL) );
1576  SCIP_CALL( SCIPsetAddLongintParam(*set, messagehdlr, blkmem,
1577  "limits/nodes",
1578  "maximal number of nodes to process (-1: no limit)",
1579  &(*set)->limit_nodes, FALSE, SCIP_DEFAULT_LIMIT_NODES, -1LL, SCIP_LONGINT_MAX,
1580  SCIPparamChgdLimit, NULL) );
1581  SCIP_CALL( SCIPsetAddLongintParam(*set, messagehdlr, blkmem,
1582  "limits/totalnodes",
1583  "maximal number of total nodes (incl. restarts) to process (-1: no limit)",
1584  &(*set)->limit_totalnodes, FALSE, SCIP_DEFAULT_LIMIT_NODES, -1LL, SCIP_LONGINT_MAX,
1585  SCIPparamChgdLimit, NULL) );
1586  SCIP_CALL( SCIPsetAddLongintParam(*set, messagehdlr, blkmem,
1587  "limits/stallnodes",
1588  "solving stops, if the given number of nodes was processed since the last improvement of the primal solution value (-1: no limit)",
1589  &(*set)->limit_stallnodes, FALSE, SCIP_DEFAULT_LIMIT_STALLNODES, -1LL, SCIP_LONGINT_MAX,
1590  SCIPparamChgdLimit, NULL) );
1591  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1592  "limits/memory",
1593  "maximal memory usage in MB; reported memory usage is lower than real memory usage!",
1594  &(*set)->limit_memory, FALSE, (SCIP_Real)SCIP_DEFAULT_LIMIT_MEMORY, 0.0, (SCIP_Real)SCIP_MEM_NOLIMIT,
1595  SCIPparamChgdLimit, NULL) );
1596  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1597  "limits/gap",
1598  "solving stops, if the relative gap = |primal - dual|/MIN(|dual|,|primal|) is below the given value, the gap is 'Infinity', if primal and dual bound have opposite signs",
1599  &(*set)->limit_gap, FALSE, SCIP_DEFAULT_LIMIT_GAP, 0.0, SCIP_REAL_MAX,
1600  SCIPparamChgdLimit, NULL) );
1601  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1602  "limits/absgap",
1603  "solving stops, if the absolute gap = |primalbound - dualbound| is below the given value",
1604  &(*set)->limit_absgap, FALSE, SCIP_DEFAULT_LIMIT_ABSGAP, 0.0, SCIP_REAL_MAX,
1605  SCIPparamChgdLimit, NULL) );
1606  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1607  "limits/solutions",
1608  "solving stops, if the given number of solutions were found (-1: no limit)",
1609  &(*set)->limit_solutions, FALSE, SCIP_DEFAULT_LIMIT_SOLUTIONS, -1, INT_MAX,
1610  SCIPparamChgdLimit, NULL) );
1611  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1612  "limits/bestsol",
1613  "solving stops, if the given number of solution improvements were found (-1: no limit)",
1614  &(*set)->limit_bestsol, FALSE, SCIP_DEFAULT_LIMIT_BESTSOL, -1, INT_MAX,
1615  SCIPparamChgdLimit, NULL) );
1616  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1617  "limits/maxsol",
1618  "maximal number of solutions to store in the solution storage",
1619  &(*set)->limit_maxsol, FALSE, SCIP_DEFAULT_LIMIT_MAXSOL, 1, INT_MAX,
1620  SCIPparamChgdLimit, NULL) );
1621  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1622  "limits/maxorigsol",
1623  "maximal number of solutions candidates to store in the solution storage of the original problem",
1624  &(*set)->limit_maxorigsol, FALSE, SCIP_DEFAULT_LIMIT_MAXORIGSOL, 0, INT_MAX,
1625  SCIPparamChgdLimit, NULL) );
1626  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1627  "limits/restarts",
1628  "solving stops, if the given number of restarts was triggered (-1: no limit)",
1629  &(*set)->limit_restarts, FALSE, SCIP_DEFAULT_LIMIT_RESTARTS, -1, INT_MAX,
1630  SCIPparamChgdLimit, NULL) );
1631 
1632  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1633  "limits/autorestartnodes",
1634  "if solve exceeds this number of nodes for the first time, an automatic restart is triggered (-1: no automatic restart)",
1635  &(*set)->limit_autorestartnodes, FALSE, SCIP_DEFAULT_LIMIT_AUTORESTARTNODES, -1, INT_MAX,
1636  SCIPparamChgdLimit, NULL) );
1637 
1638  /* LP parameters */
1639  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1640  "lp/solvefreq",
1641  "frequency for solving LP at the nodes (-1: never; 0: only root LP)",
1642  &(*set)->lp_solvefreq, FALSE, SCIP_DEFAULT_LP_SOLVEFREQ, -1, SCIP_MAXTREEDEPTH,
1643  NULL, NULL) );
1644  SCIP_CALL( SCIPsetAddLongintParam(*set, messagehdlr, blkmem,
1645  "lp/iterlim",
1646  "iteration limit for each single LP solve (-1: no limit)",
1647  &(*set)->lp_iterlim, TRUE, SCIP_DEFAULT_LP_ITERLIM, -1LL, SCIP_LONGINT_MAX,
1648  NULL, NULL) );
1649  SCIP_CALL( SCIPsetAddLongintParam(*set, messagehdlr, blkmem,
1650  "lp/rootiterlim",
1651  "iteration limit for initial root LP solve (-1: no limit)",
1652  &(*set)->lp_rootiterlim, TRUE, SCIP_DEFAULT_LP_ROOTITERLIM, -1LL, SCIP_LONGINT_MAX,
1653  NULL, NULL) );
1654  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1655  "lp/solvedepth",
1656  "maximal depth for solving LP at the nodes (-1: no depth limit)",
1657  &(*set)->lp_solvedepth, FALSE, SCIP_DEFAULT_LP_SOLVEDEPTH, -1, SCIP_MAXTREEDEPTH,
1658  NULL, NULL) );
1659  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
1660  "lp/initalgorithm",
1661  "LP algorithm for solving initial LP relaxations (automatic 's'implex, 'p'rimal simplex, 'd'ual simplex, 'b'arrier, barrier with 'c'rossover)",
1662  &(*set)->lp_initalgorithm, FALSE, SCIP_DEFAULT_LP_INITALGORITHM, "spdbc",
1663  NULL, NULL) );
1664  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
1665  "lp/resolvealgorithm",
1666  "LP algorithm for resolving LP relaxations if a starting basis exists (automatic 's'implex, 'p'rimal simplex, 'd'ual simplex, 'b'arrier, barrier with 'c'rossover)",
1667  &(*set)->lp_resolvealgorithm, FALSE, SCIP_DEFAULT_LP_RESOLVEALGORITHM, "spdbc",
1668  NULL, NULL) );
1669  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
1670  "lp/pricing",
1671  "LP pricing strategy ('l'pi default, 'a'uto, 'f'ull pricing, 'p'artial, 's'teepest edge pricing, 'q'uickstart steepest edge pricing, 'd'evex pricing)",
1672  &(*set)->lp_pricing, FALSE, SCIP_DEFAULT_LP_PRICING, "lafpsqd",
1673  NULL, NULL) );
1674  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1675  "lp/clearinitialprobinglp",
1676  "should lp state be cleared at the end of probing mode when lp was initially unsolved, e.g., when called right after presolving?",
1677  &(*set)->lp_clearinitialprobinglp, TRUE, SCIP_DEFAULT_LP_CLEARINITIALPROBINGLP,
1678  NULL, NULL) );
1679  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1680  "lp/resolverestore",
1681  "should the LP be resolved to restore the state at start of diving (if FALSE we buffer the solution values)?",
1682  &(*set)->lp_resolverestore, TRUE, SCIP_DEFAULT_LP_RESOLVERESTORE,
1683  NULL, NULL) );
1684  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1685  "lp/freesolvalbuffers",
1686  "should the buffers for storing LP solution values during diving be freed at end of diving?",
1687  &(*set)->lp_freesolvalbuffers, TRUE, SCIP_DEFAULT_LP_FREESOLVALBUFFERS,
1688  NULL, NULL) );
1689  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1690  "lp/colagelimit",
1691  "maximum age a dynamic column can reach before it is deleted from the LP (-1: don't delete columns due to aging)",
1692  &(*set)->lp_colagelimit, TRUE, SCIP_DEFAULT_LP_COLAGELIMIT, -1, INT_MAX,
1693  NULL, NULL) );
1694  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1695  "lp/rowagelimit",
1696  "maximum age a dynamic row can reach before it is deleted from the LP (-1: don't delete rows due to aging)",
1697  &(*set)->lp_rowagelimit, TRUE, SCIP_DEFAULT_LP_ROWAGELIMIT, -1, INT_MAX,
1698  NULL, NULL) );
1699  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1700  "lp/cleanupcols",
1701  "should new non-basic columns be removed after LP solving?",
1702  &(*set)->lp_cleanupcols, TRUE, SCIP_DEFAULT_LP_CLEANUPCOLS,
1703  NULL, NULL) );
1704  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1705  "lp/cleanupcolsroot",
1706  "should new non-basic columns be removed after root LP solving?",
1707  &(*set)->lp_cleanupcolsroot, TRUE, SCIP_DEFAULT_LP_CLEANUPCOLSROOT,
1708  NULL, NULL) );
1709  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1710  "lp/cleanuprows",
1711  "should new basic rows be removed after LP solving?",
1712  &(*set)->lp_cleanuprows, TRUE, SCIP_DEFAULT_LP_CLEANUPROWS,
1713  NULL, NULL) );
1714  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1715  "lp/cleanuprowsroot",
1716  "should new basic rows be removed after root LP solving?",
1717  &(*set)->lp_cleanuprowsroot, TRUE, SCIP_DEFAULT_LP_CLEANUPROWSROOT,
1718  NULL, NULL) );
1719  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1720  "lp/checkstability",
1721  "should LP solver's return status be checked for stability?",
1722  &(*set)->lp_checkstability, TRUE, SCIP_DEFAULT_LP_CHECKSTABILITY,
1723  NULL, NULL) );
1724  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1725  "lp/conditionlimit",
1726  "maximum condition number of LP basis counted as stable (-1.0: no limit)",
1727  &(*set)->lp_conditionlimit, TRUE, SCIP_DEFAULT_LP_CONDITIONLIMIT, -1.0, SCIP_REAL_MAX,
1728  NULL, NULL) );
1729  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1730  "lp/minmarkowitz",
1731  "minimal Markowitz threshold to control sparsity/stability in LU factorization",
1732  &(*set)->lp_markowitz, TRUE, SCIP_DEFAULT_LP_MARKOWITZ, 1e-4, 0.9999,
1733  NULL, NULL) );
1734  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1735  "lp/checkprimfeas",
1736  "should LP solutions be checked for primal feasibility, resolving LP when numerical troubles occur?",
1737  &(*set)->lp_checkprimfeas, TRUE, SCIP_DEFAULT_LP_CHECKPRIMFEAS,
1738  NULL, NULL) );
1739  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1740  "lp/checkdualfeas",
1741  "should LP solutions be checked for dual feasibility, resolving LP when numerical troubles occur?",
1742  &(*set)->lp_checkdualfeas, TRUE, SCIP_DEFAULT_LP_CHECKDUALFEAS,
1743  NULL, NULL) );
1744  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1745  "lp/checkfarkas",
1746  "should infeasibility proofs from the LP be checked?",
1747  &(*set)->lp_checkfarkas, TRUE, SCIP_DEFAULT_LP_CHECKFARKAS,
1748  NULL, NULL) );
1749  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1750  "lp/fastmip",
1751  "which FASTMIP setting of LP solver should be used? 0: off, 1: low",
1752  &(*set)->lp_fastmip, TRUE, SCIP_DEFAULT_LP_FASTMIP, 0, 1,
1753  NULL, NULL) );
1754  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1755  "lp/scaling",
1756  "LP scaling (0: none, 1: normal, 2: aggressive)",
1757  &(*set)->lp_scaling, TRUE, SCIP_DEFAULT_LP_SCALING, 0, 2,
1758  NULL, NULL) );
1759  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1760  "lp/presolving",
1761  "should presolving of LP solver be used?",
1762  &(*set)->lp_presolving, TRUE, SCIP_DEFAULT_LP_PRESOLVING,
1763  NULL, NULL) );
1764  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1765  "lp/lexdualalgo",
1766  "should the lexicographic dual algorithm be used?",
1767  &(*set)->lp_lexdualalgo, TRUE, SCIP_DEFAULT_LP_LEXDUALALGO,
1768  NULL, NULL) );
1769  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1770  "lp/lexdualrootonly",
1771  "should the lexicographic dual algorithm be applied only at the root node",
1772  &(*set)->lp_lexdualrootonly, TRUE, SCIP_DEFAULT_LP_LEXDUALROOTONLY,
1773  NULL, NULL) );
1774  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1775  "lp/lexdualmaxrounds",
1776  "maximum number of rounds in the lexicographic dual algorithm (-1: unbounded)",
1777  &(*set)->lp_lexdualmaxrounds, TRUE, SCIP_DEFAULT_LP_LEXDUALMAXROUNDS, -1, INT_MAX,
1778  NULL, NULL) );
1779  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1780  "lp/lexdualbasic",
1781  "choose fractional basic variables in lexicographic dual algorithm?",
1782  &(*set)->lp_lexdualbasic, TRUE, SCIP_DEFAULT_LP_LEXDUALBASIC,
1783  NULL, NULL) );
1784  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1785  "lp/lexdualstalling",
1786  "turn on the lex dual algorithm only when stalling?",
1787  &(*set)->lp_lexdualstalling, TRUE, SCIP_DEFAULT_LP_LEXDUALSTALLING,
1788  NULL, NULL) );
1789  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1790  "lp/disablecutoff",
1791  "disable the cutoff bound in the LP solver? (0: enabled, 1: disabled, 2: auto)",
1792  &(*set)->lp_disablecutoff, TRUE, SCIP_DEFAULT_LP_DISABLECUTOFF,
1793  0, 2, NULL, NULL) );
1794  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1795  "lp/rowrepswitch",
1796  "simplex algorithm shall use row representation of the basis if number of rows divided by number of columns exceeds this value (-1.0 to disable row representation)",
1797  &(*set)->lp_rowrepswitch, TRUE, SCIP_DEFAULT_LP_ROWREPSWITCH, -1.0, SCIP_REAL_MAX,
1798  NULL, NULL) );
1799  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1800  "lp/threads",
1801  "number of threads used for solving the LP (0: automatic)",
1802  &(*set)->lp_threads, TRUE, SCIP_DEFAULT_LP_THREADS, 0, 64,
1803  NULL, NULL) );
1804  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1805  "lp/resolveiterfac",
1806  "factor of average LP iterations that is used as LP iteration limit for LP resolve (-1: unlimited)",
1807  &(*set)->lp_resolveiterfac, TRUE, SCIP_DEFAULT_LP_RESOLVEITERFAC, -1.0, SCIP_REAL_MAX,
1808  NULL, NULL) );
1809  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1810  "lp/resolveitermin",
1811  "minimum number of iterations that are allowed for LP resolve",
1812  &(*set)->lp_resolveitermin, TRUE, SCIP_DEFAULT_LP_RESOLVEITERMIN, 1, INT_MAX,
1813  NULL, NULL) );
1814 
1815  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1816  "lp/solutionpolishing",
1817  "LP solution polishing method (0: disabled, 1: only root, 2: always, 3: auto)",
1818  &(*set)->lp_solutionpolishing, TRUE, SCIP_DEFAULT_LP_SOLUTIONPOLISHING, 0, 3,
1819  NULL, NULL) );
1820 
1821  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1822  "lp/refactorinterval",
1823  "LP refactorization interval (0: auto)",
1824  &(*set)->lp_refactorinterval, TRUE, SCIP_DEFAULT_LP_REFACTORINTERVAL, 0, INT_MAX,
1825  NULL, NULL) );
1826  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1827  "lp/alwaysgetduals",
1828  "should the Farkas duals always be collected when an LP is found to be infeasible?",
1829  &(*set)->lp_alwaysgetduals, FALSE, SCIP_DEFAULT_LP_ALWAYSGETDUALS,
1830  NULL, NULL) );
1831 
1832  /* NLP parameters */
1833  SCIP_CALL( SCIPsetAddStringParam(*set, messagehdlr, blkmem,
1834  "nlp/solver",
1835  "solver to use for solving NLPs; leave empty to select NLPI with highest priority",
1836  &(*set)->nlp_solver, FALSE, SCIP_DEFAULT_NLP_SOLVER,
1837  NULL, NULL) );
1838  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1839  "nlp/disable",
1840  "should the NLP relaxation be always disabled (also for NLPs/MINLPs)?",
1841  &(*set)->nlp_disable, FALSE, SCIP_DEFAULT_NLP_DISABLE,
1842  NULL, NULL) );
1843 
1844  /* memory parameters */
1845  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1846  "memory/savefac",
1847  "fraction of maximal memory usage resulting in switch to memory saving mode",
1848  &(*set)->mem_savefac, FALSE, SCIP_DEFAULT_MEM_SAVEFAC, 0.0, 1.0,
1849  NULL, NULL) );
1850  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1851  "memory/arraygrowfac",
1852  "memory growing factor for dynamically allocated arrays",
1853  &(*set)->mem_arraygrowfac, TRUE, SCIP_DEFAULT_MEM_ARRAYGROWFAC, 1.0, 10.0,
1854  paramChgdArraygrowfac, NULL) );
1855  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1856  "memory/arraygrowinit",
1857  "initial size of dynamically allocated arrays",
1858  &(*set)->mem_arraygrowinit, TRUE, SCIP_DEFAULT_MEM_ARRAYGROWINIT, 0, INT_MAX,
1859  paramChgdArraygrowinit, NULL) );
1860  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1861  "memory/treegrowfac",
1862  "memory growing factor for tree array",
1863  &(*set)->mem_treegrowfac, TRUE, SCIP_DEFAULT_MEM_TREEGROWFAC, 1.0, 10.0,
1864  NULL, NULL) );
1865  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1866  "memory/treegrowinit",
1867  "initial size of tree array",
1868  &(*set)->mem_treegrowinit, TRUE, SCIP_DEFAULT_MEM_TREEGROWINIT, 0, INT_MAX,
1869  NULL, NULL) );
1870  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1871  "memory/pathgrowfac",
1872  "memory growing factor for path array",
1873  &(*set)->mem_pathgrowfac, TRUE, SCIP_DEFAULT_MEM_PATHGROWFAC, 1.0, 10.0,
1874  NULL, NULL) );
1875  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1876  "memory/pathgrowinit",
1877  "initial size of path array",
1878  &(*set)->mem_pathgrowinit, TRUE, SCIP_DEFAULT_MEM_PATHGROWINIT, 0, INT_MAX,
1879  NULL, NULL) );
1880 
1881  /* miscellaneous parameters */
1882  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1883  "misc/catchctrlc",
1884  "should the CTRL-C interrupt be caught by SCIP?",
1885  &(*set)->misc_catchctrlc, FALSE, SCIP_DEFAULT_MISC_CATCHCTRLC,
1886  NULL, NULL) );
1887  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1888  "misc/usevartable",
1889  "should a hashtable be used to map from variable names to variables?",
1890  &(*set)->misc_usevartable, FALSE, SCIP_DEFAULT_MISC_USEVARTABLE,
1891  NULL, NULL) );
1892  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1893  "misc/useconstable",
1894  "should a hashtable be used to map from constraint names to constraints?",
1895  &(*set)->misc_useconstable, FALSE, SCIP_DEFAULT_MISC_USECONSTABLE,
1896  NULL, NULL) );
1897  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1898  "misc/usesmalltables",
1899  "should smaller hashtables be used? yields better performance for small problems with about 100 variables",
1900  &(*set)->misc_usesmalltables, FALSE, SCIP_DEFAULT_MISC_USESMALLTABLES,
1901  NULL, NULL) );
1902 #if 0 /**@todo activate exactsolve parameter and finish implementation of solving MIPs exactly */
1903  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1904  "misc/exactsolve",
1905  "should the problem be solved exactly (with proven dual bounds)?",
1906  &(*set)->misc_exactsolve, FALSE, SCIP_DEFAULT_MISC_EXACTSOLVE,
1907  NULL, NULL) );
1908 #else
1909  (*set)->misc_exactsolve = SCIP_DEFAULT_MISC_EXACTSOLVE;
1910 #endif
1911 
1912  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1913  "misc/resetstat",
1914  "should the statistics be reset if the transformed problem is freed (in case of a Benders' decomposition this parameter should be set to FALSE)",
1915  &(*set)->misc_resetstat, FALSE, SCIP_DEFAULT_MISC_RESETSTAT,
1916  NULL, NULL) );
1917 
1918  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1919  "misc/improvingsols",
1920  "should only solutions be checked which improve the primal bound",
1921  &(*set)->misc_improvingsols, FALSE, SCIP_DEFAULT_MISC_IMPROVINGSOLS,
1922  NULL, NULL) );
1923  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1924  "misc/printreason",
1925  "should the reason be printed if a given start solution is infeasible",
1926  &(*set)->misc_printreason, FALSE, SCIP_DEFAULT_MISC_PRINTREASON,
1927  NULL, NULL) );
1928  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1929  "misc/estimexternmem",
1930  "should the usage of external memory be estimated?",
1931  &(*set)->misc_estimexternmem, FALSE, SCIP_DEFAULT_MISC_ESTIMEXTERNMEM,
1932  NULL, NULL) );
1933  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1934  "misc/transorigsols",
1935  "should SCIP try to transfer original solutions to the transformed space (after presolving)?",
1936  &(*set)->misc_transorigsols, FALSE, SCIP_DEFAULT_MISC_TRANSORIGSOLS,
1937  NULL, NULL) );
1938  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1939  "misc/transsolsorig",
1940  "should SCIP try to transfer transformed solutions to the original space (after solving)?",
1941  &(*set)->misc_transsolsorig, FALSE, SCIP_DEFAULT_MISC_TRANSSOLSORIG,
1942  NULL, NULL) );
1943  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1944  "misc/calcintegral",
1945  "should SCIP calculate the primal dual integral value?",
1946  &(*set)->misc_calcintegral, FALSE, SCIP_DEFAULT_MISC_CALCINTEGRAL,
1947  NULL, NULL) );
1948  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1949  "misc/finitesolutionstore",
1950  "should SCIP try to remove infinite fixings from solutions copied to the solution store?",
1951  &(*set)->misc_finitesolstore, FALSE, SCIP_DEFAULT_MISC_FINITESOLSTORE,
1952  NULL, NULL) );
1953  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1954  "misc/outputorigsol",
1955  "should the best solution be transformed to the orignal space and be output in command line run?",
1956  &(*set)->misc_outputorigsol, FALSE, SCIP_DEFAULT_MISC_OUTPUTORIGSOL,
1957  NULL, NULL) );
1958  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1959  "misc/allowstrongdualreds",
1960  "should strong dual reductions be allowed in propagation and presolving?",
1961  &(*set)->misc_allowstrongdualreds, FALSE, SCIP_DEFAULT_MISC_ALLOWSTRONGDUALREDS,
1962  NULL, NULL) );
1963  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1964  "misc/allowweakdualreds",
1965  "should weak dual reductions be allowed in propagation and presolving?",
1966  &(*set)->misc_allowweakdualreds, FALSE, SCIP_DEFAULT_MISC_ALLOWWEAKDUALREDS,
1967  NULL, NULL) );
1968  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1969  "misc/scaleobj",
1970  "should the objective function be scaled so that it is always integer?",
1971  &(*set)->misc_scaleobj, FALSE, SCIP_DEFAULT_MISC_SCALEOBJ,
1972  NULL, NULL) );
1973 
1974  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1975  "misc/referencevalue",
1976  "objective value for reference purposes",
1977  &(*set)->misc_referencevalue, FALSE, SCIP_DEFAULT_MISC_REFERENCEVALUE, SCIP_REAL_MIN, SCIP_REAL_MAX,
1978  NULL, NULL) );
1979 
1980 #ifdef WITH_DEBUG_SOLUTION
1981  SCIP_CALL( SCIPsetAddStringParam(*set, messagehdlr, blkmem,
1982  "misc/debugsol",
1983  "path to a debug solution",
1984  &(*set)->misc_debugsol, FALSE, SCIP_DEFAULT_MISC_DEBUGSOLUTION,
1985  NULL, NULL) );
1986 #endif
1987 
1988  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1989  "misc/usesymmetry",
1990  "bitset describing used symmetry handling technique (0: off; 1: polyhedral (orbitopes and/or symresacks);" \
1991  " 2: orbital fixing; 3: orbitopes and orbital fixing), see type_symmetry.h.",
1992  &(*set)->misc_usesymmetry, FALSE, SCIP_DEFAULT_MISC_USESYMMETRY, 0, 3,
1993  paramChgdUsesymmetry, NULL) );
1994 
1995  /* randomization parameters */
1996  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1997  "randomization/randomseedshift",
1998  "global shift of all random seeds in the plugins and the LP random seed",
1999  &(*set)->random_randomseedshift, FALSE, SCIP_DEFAULT_RANDOM_RANDSEEDSHIFT, 0, INT_MAX,
2000  NULL, NULL) );
2001 
2002  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2003  "randomization/permutationseed",
2004  "seed value for permuting the problem after reading/transformation (0: no permutation)",
2005  &(*set)->random_permutationseed, FALSE, SCIP_DEFAULT_RANDOM_PERMUTATIONSEED, 0, INT_MAX,
2006  NULL, NULL) );
2007 
2008  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2009  "randomization/permuteconss",
2010  "should order of constraints be permuted (depends on permutationseed)?",
2011  &(*set)->random_permuteconss, TRUE, SCIP_DEFAULT_RANDOM_PERMUTECONSS,
2012  NULL, NULL) );
2013 
2014  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2015  "randomization/permutevars",
2016  "should order of variables be permuted (depends on permutationseed)?",
2017  &(*set)->random_permutevars, TRUE, SCIP_DEFAULT_RANDOM_PERMUTEVARS,
2018  NULL, NULL) );
2019 
2020  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2021  "randomization/lpseed",
2022  "random seed for LP solver, e.g. for perturbations in the simplex (0: LP default)",
2023  &(*set)->random_randomseed, FALSE, SCIP_DEFAULT_RANDOM_LPSEED, 0, INT_MAX,
2024  NULL, NULL) );
2025 
2026  /* node selection */
2027  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
2028  "nodeselection/childsel",
2029  "child selection rule ('d'own, 'u'p, 'p'seudo costs, 'i'nference, 'l'p value, 'r'oot LP value difference, 'h'ybrid inference/root LP value difference)",
2030  &(*set)->nodesel_childsel, FALSE, SCIP_DEFAULT_NODESEL_CHILDSEL, "dupilrh",
2031  NULL, NULL) );
2032 
2033  /* numerical parameters */
2034  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2035  "numerics/infinity",
2036  "values larger than this are considered infinity",
2037  &(*set)->num_infinity, FALSE, SCIP_DEFAULT_INFINITY, 1e+10, SCIP_INVALID/10.0,
2038  paramChgdInfinity, NULL) );
2039  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2040  "numerics/epsilon",
2041  "absolute values smaller than this are considered zero",
2042  &(*set)->num_epsilon, FALSE, SCIP_DEFAULT_EPSILON, SCIP_MINEPSILON, SCIP_MAXEPSILON,
2043  NULL, NULL) );
2044  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2045  "numerics/sumepsilon",
2046  "absolute values of sums smaller than this are considered zero",
2047  &(*set)->num_sumepsilon, FALSE, SCIP_DEFAULT_SUMEPSILON, SCIP_MINEPSILON*1e+03, SCIP_MAXEPSILON,
2048  NULL, NULL) );
2049  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2050  "numerics/feastol",
2051  "feasibility tolerance for constraints",
2052  &(*set)->num_feastol, FALSE, SCIP_DEFAULT_FEASTOL, SCIP_MINEPSILON*1e+03, SCIP_MAXEPSILON,
2053  paramChgdFeastol, NULL) );
2054  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2055  "numerics/checkfeastolfac",
2056  "feasibility tolerance factor; for checking the feasibility of the best solution",
2057  &(*set)->num_checkfeastolfac, FALSE, SCIP_DEFAULT_CHECKFEASTOLFAC, 0.0, SCIP_REAL_MAX,
2058  NULL, NULL) );
2059  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2060  "numerics/lpfeastolfactor",
2061  "factor w.r.t. primal feasibility tolerance that determines default (and maximal) primal feasibility tolerance of LP solver",
2062  &(*set)->num_lpfeastolfactor, FALSE, SCIP_DEFAULT_LPFEASTOLFACTOR, 1e-6, 1.0,
2063  paramChgdLPFeastolFactor, NULL) );
2064  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2065  "numerics/dualfeastol",
2066  "feasibility tolerance for reduced costs in LP solution",
2067  &(*set)->num_dualfeastol, FALSE, SCIP_DEFAULT_DUALFEASTOL, SCIP_MINEPSILON*1e+03, SCIP_MAXEPSILON,
2068  paramChgdDualfeastol, NULL) );
2069  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2070  "numerics/barrierconvtol",
2071  "LP convergence tolerance used in barrier algorithm",
2072  &(*set)->num_barrierconvtol, TRUE, SCIP_DEFAULT_BARRIERCONVTOL, SCIP_MINEPSILON*1e+03, SCIP_MAXEPSILON,
2073  paramChgdBarrierconvtol, NULL) );
2074  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2075  "numerics/boundstreps",
2076  "minimal relative improve for strengthening bounds",
2077  &(*set)->num_boundstreps, TRUE, SCIP_DEFAULT_BOUNDSTREPS, SCIP_MINEPSILON*1e+03, SCIP_INVALID/10.0,
2078  NULL, NULL) );
2079  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2080  "numerics/pseudocosteps",
2081  "minimal variable distance value to use for branching pseudo cost updates",
2082  &(*set)->num_pseudocosteps, TRUE, SCIP_DEFAULT_PSEUDOCOSTEPS, SCIP_MINEPSILON*1e+03, 1.0,
2083  NULL, NULL) );
2084  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2085  "numerics/pseudocostdelta",
2086  "minimal objective distance value to use for branching pseudo cost updates",
2087  &(*set)->num_pseudocostdelta, TRUE, SCIP_DEFAULT_PSEUDOCOSTDELTA, 0.0, SCIP_REAL_MAX,
2088  NULL, NULL) );
2089  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2090  "numerics/recomputefac",
2091  "minimal decrease factor that causes the recomputation of a value (e.g., pseudo objective) instead of an update",
2092  &(*set)->num_recompfac, TRUE, SCIP_DEFAULT_RECOMPFAC, 0.0, SCIP_REAL_MAX,
2093  NULL, NULL) );
2094  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2095  "numerics/hugeval",
2096  "values larger than this are considered huge and should be handled separately (e.g., in activity computation)",
2097  &(*set)->num_hugeval, TRUE, SCIP_DEFAULT_HUGEVAL, 0.0, SCIP_INVALID/10.0,
2098  NULL, NULL) );
2099 
2100  /* presolving parameters */
2101  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2102  "presolving/maxrounds",
2103  "maximal number of presolving rounds (-1: unlimited, 0: off)",
2104  &(*set)->presol_maxrounds, FALSE, SCIP_DEFAULT_PRESOL_MAXROUNDS, -1, INT_MAX,
2105  NULL, NULL) );
2106  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2107  "presolving/abortfac",
2108  "abort presolve, if at most this fraction of the problem was changed in last presolve round",
2109  &(*set)->presol_abortfac, TRUE, SCIP_DEFAULT_PRESOL_ABORTFAC, 0.0, 1.0,
2110  NULL, NULL) );
2111  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2112  "presolving/maxrestarts",
2113  "maximal number of restarts (-1: unlimited)",
2114  &(*set)->presol_maxrestarts, FALSE, SCIP_DEFAULT_PRESOL_MAXRESTARTS, -1, INT_MAX,
2115  NULL, NULL) );
2116  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2117  "presolving/restartfac",
2118  "fraction of integer variables that were fixed in the root node triggering a restart with preprocessing after root node evaluation",
2119  &(*set)->presol_restartfac, TRUE, SCIP_DEFAULT_PRESOL_RESTARTFAC, 0.0, 1.0,
2120  NULL, NULL) );
2121  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2122  "presolving/clqtablefac",
2123  "limit on number of entries in clique table relative to number of problem nonzeros",
2124  &(*set)->presol_clqtablefac, TRUE, SCIP_DEFAULT_PRESOL_CLQTABLEFAC, 0.0, SCIP_REAL_MAX,
2125  NULL, NULL) );
2126  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2127  "presolving/immrestartfac",
2128  "fraction of integer variables that were fixed in the root node triggering an immediate restart with preprocessing",
2129  &(*set)->presol_immrestartfac, TRUE, SCIP_DEFAULT_PRESOL_IMMRESTARTFAC, 0.0, 1.0,
2130  NULL, NULL) );
2131  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2132  "presolving/subrestartfac",
2133  "fraction of integer variables that were globally fixed during the solving process triggering a restart with preprocessing",
2134  &(*set)->presol_subrestartfac, TRUE, SCIP_DEFAULT_PRESOL_SUBRESTARTFAC, 0.0, 1.0,
2135  NULL, NULL) );
2136  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2137  "presolving/restartminred",
2138  "minimal fraction of integer variables removed after restart to allow for an additional restart",
2139  &(*set)->presol_restartminred, TRUE, SCIP_DEFAULT_PRESOL_RESTARTMINRED, 0.0, 1.0,
2140  NULL, NULL) );
2141  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2142  "presolving/donotmultaggr",
2143  "should multi-aggregation of variables be forbidden?",
2144  &(*set)->presol_donotmultaggr, TRUE, SCIP_DEFAULT_PRESOL_DONOTMULTAGGR,
2145  NULL, NULL) );
2146  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2147  "presolving/donotaggr",
2148  "should aggregation of variables be forbidden?",
2149  &(*set)->presol_donotaggr, TRUE, SCIP_DEFAULT_PRESOL_DONOTAGGR,
2150  NULL, NULL) );
2151 
2152  /* pricing parameters */
2153  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2154  "pricing/maxvars",
2155  "maximal number of variables priced in per pricing round",
2156  &(*set)->price_maxvars, FALSE, SCIP_DEFAULT_PRICE_MAXVARS, 1, INT_MAX,
2157  NULL, NULL) );
2158  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2159  "pricing/maxvarsroot",
2160  "maximal number of priced variables at the root node",
2161  &(*set)->price_maxvarsroot, FALSE, SCIP_DEFAULT_PRICE_MAXVARSROOT, 1, INT_MAX,
2162  NULL, NULL) );
2163  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2164  "pricing/abortfac",
2165  "pricing is aborted, if fac * pricing/maxvars pricing candidates were found",
2166  &(*set)->price_abortfac, FALSE, SCIP_DEFAULT_PRICE_ABORTFAC, 1.0, SCIP_REAL_MAX,
2167  NULL, NULL) );
2168  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2169  "pricing/delvars",
2170  "should variables created at the current node be deleted when the node is solved in case they are not present in the LP anymore?",
2171  &(*set)->price_delvars, FALSE, SCIP_DEFAULT_PRICE_DELVARS,
2172  NULL, NULL) );
2173  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2174  "pricing/delvarsroot",
2175  "should variables created at the root node be deleted when the root is solved in case they are not present in the LP anymore?",
2176  &(*set)->price_delvarsroot, FALSE, SCIP_DEFAULT_PRICE_DELVARSROOT,
2177  NULL, NULL) );
2178 
2179  /* Decomposition parameters */
2180  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2181  "decomposition/benderslabels",
2182  "should the variables be labelled for the application of Benders' decomposition?",
2183  &(*set)->decomp_benderslabels, FALSE, SCIP_DEFAULT_DECOMP_BENDERSLABELS,
2184  NULL, NULL) );
2185  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2186  "decomposition/applybenders",
2187  "if a decomposition exists, should Benders' decomposition be applied?",
2188  &(*set)->decomp_applybenders, FALSE, SCIP_DEFAULT_DECOMP_APPLYBENDERS,
2189  NULL, NULL) );
2190  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2191  "decomposition/maxgraphedge",
2192  "maximum number of edges in block graph computation, or -1 for no limit",
2193  &(*set)->decomp_maxgraphedge, FALSE, SCIP_DEFAULT_DECOMP_MAXGRAPHEDGE, -1, INT_MAX,
2194  NULL, NULL) );
2195 
2196  /* Benders' decomposition parameters */
2197  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2198  "benders/solutiontol",
2199  "the tolerance used for checking optimality in Benders' decomposition. tol where optimality is given by LB + tol > UB.",
2200  &(*set)->benders_soltol, FALSE, SCIP_DEFAULT_BENDERS_SOLTOL, 0.0, SCIP_REAL_MAX,
2201  NULL, NULL) );
2202  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2203  "benders/cutlpsol",
2204  "should Benders' cuts be generated from the solution to the LP relaxation?",
2205  &(*set)->benders_cutlpsol, FALSE, SCIP_DEFAULT_BENDERS_CUTLPSOL,
2206  NULL, NULL) );
2207  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2208  "benders/copybenders",
2209  "should Benders' decomposition be copied for use in sub-SCIPs?",
2210  &(*set)->benders_copybenders, FALSE, SCIP_DEFAULT_BENDERS_COPYBENDERS,
2211  NULL, NULL) );
2212 
2213  /* propagation parameters */
2214  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2215  "propagating/maxrounds",
2216  "maximal number of propagation rounds per node (-1: unlimited)",
2217  &(*set)->prop_maxrounds, FALSE, SCIP_DEFAULT_PROP_MAXROUNDS, -1, INT_MAX,
2218  NULL, NULL) );
2219  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2220  "propagating/maxroundsroot",
2221  "maximal number of propagation rounds in the root node (-1: unlimited)",
2222  &(*set)->prop_maxroundsroot, FALSE, SCIP_DEFAULT_PROP_MAXROUNDSROOT, -1, INT_MAX,
2223  NULL, NULL) );
2224  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2225  "propagating/abortoncutoff",
2226  "should propagation be aborted immediately? setting this to FALSE could help conflict analysis to produce more conflict constraints",
2227  &(*set)->prop_abortoncutoff, FALSE, SCIP_DEFAULT_PROP_ABORTONCUTOFF,
2228  NULL, NULL) );
2229 
2230  /* reoptimization */
2231  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2232  "reoptimization/enable",
2233  "should reoptimization used?",
2234  &(*set)->reopt_enable, FALSE, SCIP_DEFAULT_REOPT_ENABLE,
2235  paramChgdEnableReopt, NULL) );
2236  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2237  "reoptimization/maxsavednodes",
2238  "maximal number of saved nodes",
2239  &(*set)->reopt_maxsavednodes, TRUE, SCIP_DEFAULT_REOPT_MAXSAVEDNODES, -1, INT_MAX,
2240  NULL, NULL) );
2241  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2242  "reoptimization/maxdiffofnodes",
2243  "maximal number of bound changes between two stored nodes on one path",
2244  &(*set)->reopt_maxdiffofnodes, TRUE, SCIP_DEFAULT_REOPT_MAXDIFFOFNODES, 0, INT_MAX,
2245  NULL, NULL) );
2246  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2247  "reoptimization/globalcons/sepainfsubtrees",
2248  "save global constraints to separate infeasible subtrees.",
2249  &(*set)->reopt_sepaglbinfsubtrees, FALSE, SCIP_DEFAULT_REOPT_SEPAGLBINFSUBTREES,
2250  NULL, NULL) );
2251  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2252  "reoptimization/sepabestsol",
2253  "separate the optimal solution, i.e., for constrained shortest path",
2254  &(*set)->reopt_sepabestsol, TRUE, SCIP_DEFAULT_REOPT_SEPABESTSOL,
2255  NULL, NULL) );
2256  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2257  "reoptimization/storevarhistory",
2258  "use variable history of the previous solve if the objctive function has changed only slightly",
2259  &(*set)->reopt_storevarhistory, TRUE, SCIP_DEFAULT_REOPT_STOREVARHISTOTY,
2260  NULL, NULL) );
2261  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2262  "reoptimization/usepscost",
2263  "re-use pseudo costs if the objective function changed only slightly ",
2264  &(*set)->reopt_usepscost, TRUE, SCIP_DEFAULT_REOPT_USEPSCOST,
2265  NULL, NULL) );
2266  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2267  "reoptimization/solvelp",
2268  "at which reopttype should the LP be solved? (1: transit, 3: strong branched, 4: w/ added logicor, 5: only leafs).",
2269  &(*set)->reopt_solvelp, TRUE, SCIP_DEFAULT_REOPT_SOLVELP, 1, 5,
2270  NULL, NULL) );
2271  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2272  "reoptimization/solvelpdiff",
2273  "maximal number of bound changes at node to skip solving the LP",
2274  &(*set)->reopt_solvelpdiff, TRUE, SCIP_DEFAULT_REOPT_SOLVELPDIFF, 0, INT_MAX,
2275  NULL, NULL) );
2276  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2277  "reoptimization/savesols",
2278  "number of best solutions which should be saved for the following runs. (-1: save all)",
2279  &(*set)->reopt_savesols, TRUE, SCIP_DEFAULT_REOPT_SAVESOLS, 0, INT_MAX,
2280  NULL, NULL) );
2281  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2282  "reoptimization/objsimrootLP",
2283  "similarity of two sequential objective function to disable solving the root LP.",
2284  &(*set)->reopt_objsimrootlp, TRUE, SCIP_DEFAULT_REOPT_OBJSIMROOTLP, -1.0, 1.0,
2285  NULL, NULL) );
2286  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2287  "reoptimization/objsimsol",
2288  "similarity of two objective functions to re-use stored solutions",
2289  &(*set)->reopt_objsimsol, TRUE, SCIP_DEFAULT_REOPT_OBJSIMSOL, -1.0, 1.0,
2290  NULL, NULL) );
2291  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2292  "reoptimization/delay",
2293  "minimum similarity for using reoptimization of the search tree.",
2294  &(*set)->reopt_objsimdelay, TRUE, SCIP_DEFAULT_REOPT_OBJSIMDELAY, -1.0, 1.0,
2295  NULL, NULL) );
2296  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2297  "reoptimization/commontimelimit",
2298  "time limit over all reoptimization rounds?.",
2299  &(*set)->reopt_commontimelimit, TRUE, SCIP_DEFAULT_REOPT_COMMONTIMELIMIT,
2300  NULL, NULL) );
2301  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2302  "reoptimization/shrinkinner",
2303  "replace branched inner nodes by their child nodes, if the number of bound changes is not to large",
2304  &(*set)->reopt_shrinkinner, TRUE, SCIP_DEFAULT_REOPT_SHRINKINNER,
2305  NULL, NULL) );
2306  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2307  "reoptimization/strongbranchinginit",
2308  "try to fix variables at the root node before reoptimizing by probing like strong branching",
2309  &(*set)->reopt_sbinit, TRUE, SCIP_DEFAULT_REOPT_STRONGBRANCHINIT,
2310  NULL, NULL) );
2311  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2312  "reoptimization/reducetofrontier",
2313  "delete stored nodes which were not reoptimized",
2314  &(*set)->reopt_reducetofrontier, TRUE, SCIP_DEFAULT_REOPT_REDUCETOFRONTIER,
2315  NULL, NULL) );
2316  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2317  "reoptimization/forceheurrestart",
2318  "force a restart if the last n optimal solutions were found by heuristic reoptsols",
2319  &(*set)->reopt_forceheurrestart, TRUE, SCIP_DEFAULT_REOPT_FORCEHEURRESTART, 1, INT_MAX,
2320  NULL, NULL) );
2321  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2322  "reoptimization/saveconsprop",
2323  "save constraint propagations",
2324  &(*set)->reopt_saveconsprop, TRUE, SCIP_DEFAULT_REOPT_SAVECONSPROP,
2325  NULL, NULL) );
2326  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2327  "reoptimization/usesplitcons", "use constraints to reconstruct the subtree pruned be dual reduction when reactivating the node",
2328  &(*set)->reopt_usesplitcons, TRUE, SCIP_DEFAULT_REOPT_USESPLITCONS,
2329  NULL, NULL) );
2330  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
2331  "reoptimization/varorderinterdiction", "use 'd'efault, 'r'andom or a variable ordering based on 'i'nference score for interdiction branching used during reoptimization",
2332  &(*set)->reopt_varorderinterdiction, TRUE, SCIP_DEFAULT_REOPT_VARORDERINTERDICTION, "dir",
2333  NULL, NULL) );
2334  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2335  "reoptimization/usecuts",
2336  "reoptimize cuts found at the root node",
2337  &(*set)->reopt_usecuts, TRUE, SCIP_DEFAULT_REOPT_USECUTS,
2338  NULL, NULL) );
2339  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2340  "reoptimization/maxcutage",
2341  "maximal age of a cut to be use for reoptimization",
2342  &(*set)->reopt_maxcutage, TRUE, SCIP_DEFAULT_REOPT_MAXCUTAGE, 0, INT_MAX,
2343  NULL, NULL) );
2344 
2345  /* separation parameters */
2346  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2347  "separating/maxbounddist",
2348  "maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separation (0.0: only on current best node, 1.0: on all nodes)",
2349  &(*set)->sepa_maxbounddist, FALSE, SCIP_DEFAULT_SEPA_MAXBOUNDDIST, 0.0, 1.0,
2350  NULL, NULL) );
2351  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2352  "separating/maxlocalbounddist",
2353  "maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying local separation (0.0: only on current best node, 1.0: on all nodes)",
2354  &(*set)->sepa_maxlocalbounddist, FALSE, SCIP_DEFAULT_SEPA_MAXLOCALBOUNDDIST, 0.0, 1.0,
2355  NULL, NULL) );
2356  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2357  "separating/maxcoefratio",
2358  "maximal ratio between coefficients in strongcg, cmir, and flowcover cuts",
2359  &(*set)->sepa_maxcoefratio, FALSE, SCIP_DEFAULT_SEPA_MAXCOEFRATIO, 1.0, SCIP_INVALID/10.0,
2360  NULL, NULL) );
2361  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2362  "separating/minefficacy",
2363  "minimal efficacy for a cut to enter the LP",
2364  &(*set)->sepa_minefficacy, FALSE, SCIP_DEFAULT_SEPA_MINEFFICACY, 0.0, SCIP_INVALID/10.0,
2365  NULL, NULL) );
2366  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2367  "separating/minefficacyroot",
2368  "minimal efficacy for a cut to enter the LP in the root node",
2369  &(*set)->sepa_minefficacyroot, FALSE, SCIP_DEFAULT_SEPA_MINEFFICACYROOT, 0.0, SCIP_INVALID/10.0,
2370  NULL, NULL) );
2371  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2372  "separating/minortho",
2373  "minimal orthogonality for a cut to enter the LP",
2374  &(*set)->sepa_minortho, FALSE, SCIP_DEFAULT_SEPA_MINORTHO, 0.0, 1.0,
2375  NULL, NULL) );
2376  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2377  "separating/minorthoroot",
2378  "minimal orthogonality for a cut to enter the LP in the root node",
2379  &(*set)->sepa_minorthoroot, FALSE, SCIP_DEFAULT_SEPA_MINORTHOROOT, 0.0, 1.0,
2380  NULL, NULL) );
2381  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2382  "separating/objparalfac",
2383  "factor to scale objective parallelism of cut in separation score calculation",
2384  &(*set)->sepa_objparalfac, TRUE, SCIP_DEFAULT_SEPA_OBJPARALFAC, 0.0, SCIP_INVALID/10.0,
2385  NULL, NULL) );
2386  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2387  "separating/dircutoffdistfac",
2388  "factor to scale directed cutoff distance of cut in score calculation",
2389  &(*set)->sepa_dircutoffdistfac, TRUE, SCIP_DEFAULT_SEPA_DIRCUTOFFDISTFAC, 0.0, SCIP_INVALID/10.0,
2390  NULL, NULL) );
2391  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2392  "separating/efficacyfac",
2393  "factor to scale efficacy of cut in score calculation",
2394  &(*set)->sepa_efficacyfac, TRUE, SCIP_DEFAULT_SEPA_EFFICACYFAC, 0.0, SCIP_INVALID/10.0,
2395  NULL, NULL) );
2396  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2397  "separating/intsupportfac",
2398  "factor to scale integral support of cut in separation score calculation",
2399  &(*set)->sepa_intsupportfac, TRUE, SCIP_DEFAULT_SEPA_INTSUPPORTFAC, 0.0, SCIP_INVALID/10.0,
2400  NULL, NULL) );
2401  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2402  "separating/minactivityquot",
2403  "minimum cut activity quotient to convert cuts into constraints during a restart (0.0: all cuts are converted)",
2404  &(*set)->sepa_minactivityquot, FALSE, SCIP_DEFAULT_SEPA_MINACTIVITYQUOT, 0.0, 1.0,
2405  NULL, NULL) );
2406  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
2407  "separating/orthofunc",
2408  "function used for calc. scalar prod. in orthogonality test ('e'uclidean, 'd'iscrete)",
2409  &(*set)->sepa_orthofunc, TRUE, SCIP_DEFAULT_SEPA_ORTHOFUNC, "ed",
2410  NULL, NULL) );
2411  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
2412  "separating/efficacynorm",
2413  "row norm to use for efficacy calculation ('e'uclidean, 'm'aximum, 's'um, 'd'iscrete)",
2414  &(*set)->sepa_efficacynorm, TRUE, SCIP_DEFAULT_SEPA_EFFICACYNORM, "emsd",
2415  NULL, NULL) );
2416  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
2417  "separating/cutselrestart",
2418  "cut selection during restart ('a'ge, activity 'q'uotient)",
2419  &(*set)->sepa_cutselrestart, TRUE, SCIP_DEFAULT_SEPA_CUTSELRESTART, "aq",
2420  NULL, NULL) );
2421  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
2422  "separating/cutselsubscip",
2423  "cut selection for sub SCIPs ('a'ge, activity 'q'uotient)",
2424  &(*set)->sepa_cutselsubscip, TRUE, SCIP_DEFAULT_SEPA_CUTSELSUBSCIP, "aq",
2425  NULL, NULL) );
2426  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2427  "separating/maxruns",
2428  "maximal number of runs for which separation is enabled (-1: unlimited)",
2429  &(*set)->sepa_maxruns, TRUE, SCIP_DEFAULT_SEPA_MAXRUNS, -1, INT_MAX,
2430  NULL, NULL) );
2431  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2432  "separating/maxrounds",
2433  "maximal number of separation rounds per node (-1: unlimited)",
2434  &(*set)->sepa_maxrounds, FALSE, SCIP_DEFAULT_SEPA_MAXROUNDS, -1, INT_MAX,
2435  NULL, NULL) );
2436  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2437  "separating/maxroundsroot",
2438  "maximal number of separation rounds in the root node (-1: unlimited)",
2439  &(*set)->sepa_maxroundsroot, FALSE, SCIP_DEFAULT_SEPA_MAXROUNDSROOT, -1, INT_MAX,
2440  NULL, NULL) );
2441  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2442  "separating/maxroundsrootsubrun",
2443  "maximal number of separation rounds in the root node of a subsequent run (-1: unlimited)",
2444  &(*set)->sepa_maxroundsrootsubrun, TRUE, SCIP_DEFAULT_SEPA_MAXROUNDSROOTSUBRUN, -1, INT_MAX,
2445  NULL, NULL) );
2446  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2447  "separating/maxaddrounds",
2448  "maximal additional number of separation rounds in subsequent price-and-cut loops (-1: no additional restriction)",
2449  &(*set)->sepa_maxaddrounds, TRUE, SCIP_DEFAULT_SEPA_MAXADDROUNDS, -1, INT_MAX,
2450  NULL, NULL) );
2451  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2452  "separating/maxstallrounds",
2453  "maximal number of consecutive separation rounds without objective or integrality improvement in local nodes (-1: no additional restriction)",
2454  &(*set)->sepa_maxstallrounds, FALSE, SCIP_DEFAULT_SEPA_MAXSTALLROUNDS, -1, INT_MAX,
2455  NULL, NULL) );
2456  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2457  "separating/maxstallroundsroot",
2458  "maximal number of consecutive separation rounds without objective or integrality improvement in the root node (-1: no additional restriction)",
2459  &(*set)->sepa_maxstallroundsroot, FALSE, SCIP_DEFAULT_SEPA_MAXSTALLROUNDSROOT, -1, INT_MAX,
2460  NULL, NULL) );
2461  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2462  "separating/maxcuts",
2463  "maximal number of cuts separated per separation round (0: disable local separation)",
2464  &(*set)->sepa_maxcuts, FALSE, SCIP_DEFAULT_SEPA_MAXCUTS, 0, INT_MAX,
2465  NULL, NULL) );
2466  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2467  "separating/maxcutsroot",
2468  "maximal number of separated cuts at the root node (0: disable root node separation)",
2469  &(*set)->sepa_maxcutsroot, FALSE, SCIP_DEFAULT_SEPA_MAXCUTSROOT, 0, INT_MAX,
2470  NULL, NULL) );
2471  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2472  "separating/cutagelimit",
2473  "maximum age a cut can reach before it is deleted from the global cut pool, or -1 to keep all cuts",
2474  &(*set)->sepa_cutagelimit, TRUE, SCIP_DEFAULT_SEPA_CUTAGELIMIT, -1, INT_MAX,
2475  NULL, NULL) );
2476  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2477  "separating/poolfreq",
2478  "separation frequency for the global cut pool (-1: disable global cut pool, 0: only separate pool at the root)",
2479  &(*set)->sepa_poolfreq, FALSE, SCIP_DEFAULT_SEPA_POOLFREQ, -1, SCIP_MAXTREEDEPTH,
2480  NULL, NULL) );
2481 
2482  /* parallel parameters */
2483  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2484  "parallel/mode",
2485  "parallel optimisation mode, 0: opportunistic or 1: deterministic.",
2486  &(*set)->parallel_mode, FALSE, SCIP_DEFAULT_PARALLEL_MODE, 0, 1,
2487  NULL, NULL) );
2488  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2489  "parallel/minnthreads",
2490  "the minimum number of threads used during parallel solve",
2491  &(*set)->parallel_minnthreads, FALSE, SCIP_DEFAULT_PARALLEL_MINNTHREADS, 0, 64,
2492  NULL, NULL) );
2493  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2494  "parallel/maxnthreads",
2495  "the maximum number of threads used during parallel solve",
2496  &(*set)->parallel_maxnthreads, FALSE, SCIP_DEFAULT_PARALLEL_MAXNTHREADS, 0, 64,
2497  NULL, NULL) );
2498 
2499  /* concurrent solver parameters */
2500  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2501  "concurrent/changeseeds",
2502  "set different random seeds in each concurrent solver?",
2503  &(*set)->concurrent_changeseeds, FALSE, SCIP_DEFAULT_CONCURRENT_CHANGESEEDS,
2504  NULL, NULL) );
2505  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2506  "concurrent/changechildsel",
2507  "use different child selection rules in each concurrent solver?",
2508  &(*set)->concurrent_changechildsel, FALSE, SCIP_DEFAULT_CONCURRENT_CHANGECHILDSEL,
2509  NULL, NULL) );
2510  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2511  "concurrent/commvarbnds",
2512  "should the concurrent solvers communicate global variable bound changes?",
2513  &(*set)->concurrent_commvarbnds, FALSE, SCIP_DEFAULT_CONCURRENT_COMMVARBNDS,
2514  NULL, NULL) );
2515  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2516  "concurrent/presolvebefore",
2517  "should the problem be presolved before it is copied to the concurrent solvers?",
2518  &(*set)->concurrent_presolvebefore, FALSE, SCIP_DEFAULT_CONCURRENT_PRESOLVEBEFORE,
2519  NULL, NULL) );
2520  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2521  "concurrent/initseed",
2522  "maximum number of solutions that will be shared in a one synchronization",
2523  &(*set)->concurrent_initseed, FALSE, SCIP_DEFAULT_CONCURRENT_INITSEED, 0, INT_MAX,
2524  NULL, NULL) );
2525  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2526  "concurrent/sync/freqinit",
2527  "initial frequency of synchronization with other threads",
2528  &(*set)->concurrent_freqinit, FALSE, SCIP_DEFAULT_CONCURRENT_FREQINIT, 0.0, SCIP_REAL_MAX,
2529  NULL, NULL) );
2530  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2531  "concurrent/sync/freqmax",
2532  "maximal frequency of synchronization with other threads",
2533  &(*set)->concurrent_freqmax, FALSE, SCIP_DEFAULT_CONCURRENT_FREQMAX, 0.0, SCIP_REAL_MAX,
2534  NULL, NULL) );
2535  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2536  "concurrent/sync/freqfactor",
2537  "factor by which the frequency of synchronization is changed",
2538  &(*set)->concurrent_freqfactor, FALSE, SCIP_DEFAULT_CONCURRENT_FREQFACTOR, 1.0, SCIP_REAL_MAX,
2539  NULL, NULL) );
2540  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2541  "concurrent/sync/targetprogress",
2542  "when adapting the synchronization frequency this value is the targeted relative difference by which the absolute gap decreases per synchronization",
2543  &(*set)->concurrent_targetprogress, FALSE, SCIP_DEFAULT_CONCURRENT_TARGETPROGRESS, 0.0, SCIP_REAL_MAX,
2544  NULL, NULL) );
2545  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2546  "concurrent/sync/maxnsols",
2547  "maximum number of solutions that will be shared in a single synchronization",
2548  &(*set)->concurrent_maxnsols, FALSE, SCIP_DEFAULT_CONCURRENT_MAXNSOLS, 0, 1000,
2549  NULL, NULL) );
2550  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2551  "concurrent/sync/maxnsyncdelay",
2552  "maximum number of synchronizations before reading is enforced regardless of delay",
2553  &(*set)->concurrent_maxnsyncdelay, TRUE, SCIP_DEFAULT_CONCURRENT_MAXNSYNCDELAY, 0, 100,
2554  NULL, NULL) );
2555  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
2556  "concurrent/sync/minsyncdelay",
2557  "minimum delay before synchronization data is read",
2558  &(*set)->concurrent_minsyncdelay, FALSE, SCIP_DEFAULT_CONCURRENT_MINSYNCDELAY, 0.0, SCIP_REAL_MAX,
2559  NULL, NULL) );
2560  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2561  "concurrent/sync/nbestsols",
2562  "how many of the N best solutions should be considered for synchronization?",
2563  &(*set)->concurrent_nbestsols, FALSE, SCIP_DEFAULT_CONCURRENT_NBESTSOLS, 0, INT_MAX,
2564  NULL, NULL) );
2565  SCIP_CALL( SCIPsetAddStringParam(*set, messagehdlr, blkmem,
2566  "concurrent/paramsetprefix",
2567  "path prefix for parameter setting files of concurrent solvers",
2568  &(*set)->concurrent_paramsetprefix, FALSE, SCIP_DEFAULT_CONCURRENT_PARAMSETPREFIX,
2569  NULL, NULL) );
2570 
2571  /* timing parameters */
2572  assert(sizeof(int) == sizeof(SCIP_CLOCKTYPE)); /*lint !e506*/
2573  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2574  "timing/clocktype",
2575  "default clock type (1: CPU user seconds, 2: wall clock time)",
2576  (int*)&(*set)->time_clocktype, FALSE, (int)SCIP_DEFAULT_TIME_CLOCKTYPE, 1, 2,
2577  NULL, NULL) );
2578  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2579  "timing/enabled",
2580  "is timing enabled?",
2581  &(*set)->time_enabled, FALSE, SCIP_DEFAULT_TIME_ENABLED,
2582  NULL, NULL) );
2583  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2584  "timing/reading",
2585  "belongs reading time to solving time?",
2586  &(*set)->time_reading, FALSE, SCIP_DEFAULT_TIME_READING,
2587  NULL, NULL) );
2588  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2589  "timing/rareclockcheck",
2590  "should clock checks of solving time be performed less frequently (note: time limit could be exceeded slightly)",
2591  &(*set)->time_rareclockcheck, FALSE, SCIP_DEFAULT_TIME_RARECLOCKCHECK,
2592  NULL, NULL) );
2593  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2594  "timing/statistictiming",
2595  "should timing for statistic output be performed?",
2596  &(*set)->time_statistictiming, FALSE, SCIP_DEFAULT_TIME_STATISTICTIMING,
2597  paramChgdStatistictiming, NULL) );
2598 
2599  /* visualization parameters */
2600  SCIP_CALL( SCIPsetAddStringParam(*set, messagehdlr, blkmem,
2601  "visual/vbcfilename",
2602  "name of the VBC tool output file, or - if no VBC tool output should be created",
2603  &(*set)->visual_vbcfilename, FALSE, SCIP_DEFAULT_VISUAL_VBCFILENAME,
2604  NULL, NULL) );
2605  SCIP_CALL( SCIPsetAddStringParam(*set, messagehdlr, blkmem,
2606  "visual/bakfilename",
2607  "name of the BAK tool output file, or - if no BAK tool output should be created",
2608  &(*set)->visual_bakfilename, FALSE, SCIP_DEFAULT_VISUAL_BAKFILENAME,
2609  NULL, NULL) );
2610  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2611  "visual/realtime",
2612  "should the real solving time be used instead of a time step counter in visualization?",
2613  &(*set)->visual_realtime, FALSE, SCIP_DEFAULT_VISUAL_REALTIME,
2614  NULL, NULL) );
2615  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2616  "visual/dispsols",
2617  "should the node where solutions are found be visualized?",
2618  &(*set)->visual_dispsols, FALSE, SCIP_DEFAULT_VISUAL_DISPSOLS,
2619  NULL, NULL) );
2620  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2621  "visual/displb",
2622  "should lower bound information be visualized?",
2623  &(*set)->visual_displb, FALSE, SCIP_DEFAULT_VISUAL_DISPLB,
2624  NULL, NULL) );
2625  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2626  "visual/objextern",
2627  "should be output the external value of the objective?",
2628  &(*set)->visual_objextern, FALSE, SCIP_DEFAULT_VISUAL_OBJEXTERN,
2629  NULL, NULL) );
2630 
2631  /* Reading parameters */
2632  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2633  "reading/initialconss",
2634  "should model constraints be marked as initial?",
2635  &(*set)->read_initialconss, FALSE, SCIP_DEFAULT_READ_INITIALCONSS,
2636  NULL, NULL) );
2637  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2638  "reading/dynamicconss",
2639  "should model constraints be subject to aging?",
2640  &(*set)->read_dynamicconss, FALSE, SCIP_DEFAULT_READ_DYNAMICCONSS,
2641  NULL, NULL) );
2642  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2643  "reading/dynamiccols",
2644  "should columns be added and removed dynamically to the LP?",
2645  &(*set)->read_dynamiccols, FALSE, SCIP_DEFAULT_READ_DYNAMICCOLS,
2646  NULL, NULL) );
2647  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2648  "reading/dynamicrows",
2649  "should rows be added and removed dynamically to the LP?",
2650  &(*set)->read_dynamicrows, FALSE, SCIP_DEFAULT_READ_DYNAMICROWS,
2651  NULL, NULL) );
2652 
2653  /* Writing parameters */
2654  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2655  "write/allconss",
2656  "should all constraints be written (including the redundant constraints)?",
2657  &(*set)->write_allconss, FALSE, SCIP_DEFAULT_WRITE_ALLCONSS,
2658  NULL, NULL) );
2659  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
2660  "write/printzeros",
2661  "should variables set to zero be printed?",
2662  &(*set)->write_printzeros, FALSE, SCIP_DEFAULT_PRINTZEROS,
2663  NULL, NULL) );
2664  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
2665  "write/genericnamesoffset",
2666  "when writing a generic problem the index for the first variable should start with?",
2667  &(*set)->write_genoffset, FALSE, SCIP_DEFAULT_WRITE_GENNAMES_OFFSET, 0, INT_MAX/2,
2668  NULL, NULL) );
2669 
2670  return SCIP_OKAY;
2671 }
2672 
2673 /** frees global SCIP settings */
2675  SCIP_SET** set, /**< pointer to SCIP settings */
2676  BMS_BLKMEM* blkmem /**< block memory */
2677  )
2678 {
2679  int i;
2680 
2681  assert(set != NULL);
2682 
2683  if( *set == NULL )
2684  return SCIP_OKAY;
2685 
2686  /* free parameter set */
2687  SCIPparamsetFree(&(*set)->paramset, blkmem);
2688 
2689  /* free file readers */
2690  for( i = 0; i < (*set)->nreaders; ++i )
2691  {
2692  SCIP_CALL( SCIPreaderFree(&(*set)->readers[i], *set) );
2693  }
2694  BMSfreeMemoryArrayNull(&(*set)->readers);
2695 
2696  /* free variable pricers */
2697  for( i = 0; i < (*set)->npricers; ++i )
2698  {
2699  SCIP_CALL( SCIPpricerFree(&(*set)->pricers[i], *set) );
2700  }
2701  BMSfreeMemoryArrayNull(&(*set)->pricers);
2702 
2703  /* free Benders' decomposition */
2704  for( i = 0; i < (*set)->nbenders; ++i )
2705  {
2706  SCIP_CALL( SCIPbendersFree(&(*set)->benders[i], *set) );
2707  }
2708  BMSfreeMemoryArrayNull(&(*set)->benders);
2709 
2710  /* free constraint handlers */
2711  for( i = 0; i < (*set)->nconshdlrs; ++i )
2712  {
2713  SCIP_CALL( SCIPconshdlrFree(&(*set)->conshdlrs[i], *set) );
2714  }
2715  BMSfreeMemoryArrayNull(&(*set)->conshdlrs);
2716  BMSfreeMemoryArrayNull(&(*set)->conshdlrs_sepa);
2717  BMSfreeMemoryArrayNull(&(*set)->conshdlrs_enfo);
2718  BMSfreeMemoryArrayNull(&(*set)->conshdlrs_include);
2719 
2720  /* free conflict handlers */
2721  for( i = 0; i < (*set)->nconflicthdlrs; ++i )
2722  {
2723  SCIP_CALL( SCIPconflicthdlrFree(&(*set)->conflicthdlrs[i], *set) );
2724  }
2725  BMSfreeMemoryArrayNull(&(*set)->conflicthdlrs);
2726 
2727  /* free presolvers */
2728  for( i = 0; i < (*set)->npresols; ++i )
2729  {
2730  SCIP_CALL( SCIPpresolFree(&(*set)->presols[i], *set) );
2731  }
2732  BMSfreeMemoryArrayNull(&(*set)->presols);
2733 
2734  /* free relaxators */
2735  for( i = 0; i < (*set)->nrelaxs; ++i )
2736  {
2737  SCIP_CALL( SCIPrelaxFree(&(*set)->relaxs[i], *set) );
2738  }
2739  BMSfreeMemoryArrayNull(&(*set)->relaxs);
2740 
2741  /* free separators */
2742  for( i = 0; i < (*set)->nsepas; ++i )
2743  {
2744  SCIP_CALL( SCIPsepaFree(&(*set)->sepas[i], *set) );
2745  }
2746  BMSfreeMemoryArrayNull(&(*set)->sepas);
2747 
2748  /* free propagators */
2749  for( i = 0; i < (*set)->nprops; ++i )
2750  {
2751  SCIP_CALL( SCIPpropFree(&(*set)->props[i], *set) );
2752  }
2753  BMSfreeMemoryArrayNull(&(*set)->props);
2754  BMSfreeMemoryArrayNull(&(*set)->props_presol);
2755 
2756  /* free primal heuristics */
2757  for( i = 0; i < (*set)->nheurs; ++i )
2758  {
2759  SCIP_CALL( SCIPheurFree(&(*set)->heurs[i], *set, blkmem) );
2760  }
2761  BMSfreeMemoryArrayNull(&(*set)->heurs);
2762 
2763  /* free tree compressions */
2764  for( i = 0; i < (*set)->ncomprs; ++i )
2765  {
2766  SCIP_CALL( SCIPcomprFree(&(*set)->comprs[i], *set) );
2767  }
2768  BMSfreeMemoryArrayNull(&(*set)->comprs);
2769 
2770  /* free event handlers */
2771  for( i = 0; i < (*set)->neventhdlrs; ++i )
2772  {
2773  SCIP_CALL( SCIPeventhdlrFree(&(*set)->eventhdlrs[i], *set) );
2774  }
2775  BMSfreeMemoryArrayNull(&(*set)->eventhdlrs);
2776 
2777  /* free node selectors */
2778  for( i = 0; i < (*set)->nnodesels; ++i )
2779  {
2780  SCIP_CALL( SCIPnodeselFree(&(*set)->nodesels[i], *set) );
2781  }
2782  BMSfreeMemoryArrayNull(&(*set)->nodesels);
2783 
2784  /* free branching methods */
2785  for( i = 0; i < (*set)->nbranchrules; ++i )
2786  {
2787  SCIP_CALL( SCIPbranchruleFree(&(*set)->branchrules[i], *set) );
2788  }
2789  BMSfreeMemoryArrayNull(&(*set)->branchrules);
2790 
2791  /* free statistics tables */
2792  for( i = 0; i < (*set)->ntables; ++i )
2793  {
2794  SCIP_CALL( SCIPtableFree(&(*set)->tables[i], *set) );
2795  }
2796  BMSfreeMemoryArrayNull(&(*set)->tables);
2797 
2798  /* free display columns */
2799  for( i = 0; i < (*set)->ndisps; ++i )
2800  {
2801  SCIP_CALL( SCIPdispFree(&(*set)->disps[i], *set) );
2802  }
2803  BMSfreeMemoryArrayNull(&(*set)->disps);
2804 
2805  /* free dialogs */
2806  BMSfreeMemoryArrayNull(&(*set)->dialogs);
2807 
2808  /* free NLPIs */
2809  for( i = 0; i < (*set)->nnlpis; ++i )
2810  {
2811  SCIP_CALL( SCIPnlpiFree(&(*set)->nlpis[i]) );
2812  }
2813  BMSfreeMemoryArrayNull(&(*set)->nlpis);
2814 
2815  /* free concsolvers */
2817 
2818  /* free concsolvers types */
2819  for( i = 0; i < (*set)->nconcsolvertypes; ++i )
2820  {
2821  SCIPconcsolverTypeFree(&(*set)->concsolvertypes[i]);
2822  }
2823  BMSfreeMemoryArrayNull(&(*set)->concsolvertypes);
2824 
2825  /* free information on external codes */
2826  for( i = 0; i < (*set)->nextcodes; ++i )
2827  {
2828  BMSfreeMemoryArrayNull(&(*set)->extcodenames[i]);
2829  BMSfreeMemoryArrayNull(&(*set)->extcodedescs[i]);
2830  }
2831  BMSfreeMemoryArrayNull(&(*set)->extcodenames);
2832  BMSfreeMemoryArrayNull(&(*set)->extcodedescs);
2833 
2834  /* free virtual tables of bandit algorithms */
2835  for( i = 0; i < (*set)->nbanditvtables; ++i )
2836  {
2837  SCIPbanditvtableFree(&(*set)->banditvtables[i]);
2838  }
2839  BMSfreeMemoryArrayNull(&(*set)->banditvtables);
2840 
2841  BMSfreeMemory(set);
2842 
2843  return SCIP_OKAY;
2844 }
2845 
2846 /** returns current stage of SCIP */
2848  SCIP_SET* set /**< global SCIP settings */
2849  )
2850 {
2851  assert(set != NULL);
2852 
2853  return set->stage;
2854 }
2855 
2856 /** creates a SCIP_Bool parameter, sets it to its default value, and adds it to the parameter set */
2858  SCIP_SET* set, /**< global SCIP settings */
2859  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2860  BMS_BLKMEM* blkmem, /**< block memory */
2861  const char* name, /**< name of the parameter */
2862  const char* desc, /**< description of the parameter */
2863  SCIP_Bool* valueptr, /**< pointer to store the current parameter value, or NULL */
2864  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
2865  SCIP_Bool defaultvalue, /**< default value of the parameter */
2866  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
2867  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
2868  )
2869 {
2870  assert(set != NULL);
2871 
2872  SCIP_CALL( SCIPparamsetAddBool(set->paramset, messagehdlr, blkmem, name, desc, valueptr, isadvanced,
2873  defaultvalue, paramchgd, paramdata) );
2874 
2875  return SCIP_OKAY;
2876 }
2877 
2878 /** creates an int parameter, sets it to its default value, and adds it to the parameter set */
2880  SCIP_SET* set, /**< global SCIP settings */
2881  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2882  BMS_BLKMEM* blkmem, /**< block memory */
2883  const char* name, /**< name of the parameter */
2884  const char* desc, /**< description of the parameter */
2885  int* valueptr, /**< pointer to store the current parameter value, or NULL */
2886  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
2887  int defaultvalue, /**< default value of the parameter */
2888  int minvalue, /**< minimum value for parameter */
2889  int maxvalue, /**< maximum value for parameter */
2890  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
2891  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
2892  )
2893 {
2894  assert(set != NULL);
2895 
2896  SCIP_CALL( SCIPparamsetAddInt(set->paramset, messagehdlr, blkmem, name, desc, valueptr, isadvanced,
2897  defaultvalue, minvalue, maxvalue, paramchgd, paramdata) );
2898 
2899  return SCIP_OKAY;
2900 }
2901 
2902 /** creates a SCIP_Longint parameter, sets it to its default value, and adds it to the parameter set */
2904  SCIP_SET* set, /**< global SCIP settings */
2905  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2906  BMS_BLKMEM* blkmem, /**< block memory */
2907  const char* name, /**< name of the parameter */
2908  const char* desc, /**< description of the parameter */
2909  SCIP_Longint* valueptr, /**< pointer to store the current parameter value, or NULL */
2910  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
2911  SCIP_Longint defaultvalue, /**< default value of the parameter */
2912  SCIP_Longint minvalue, /**< minimum value for parameter */
2913  SCIP_Longint maxvalue, /**< maximum value for parameter */
2914  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
2915  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
2916  )
2917 {
2918  assert(set != NULL);
2919 
2920  SCIP_CALL( SCIPparamsetAddLongint(set->paramset, messagehdlr, blkmem, name, desc, valueptr, isadvanced,
2921  defaultvalue, minvalue, maxvalue, paramchgd, paramdata) );
2922 
2923  return SCIP_OKAY;
2925 
2926 /** creates a SCIP_Real parameter, sets it to its default value, and adds it to the parameter set */
2928  SCIP_SET* set, /**< global SCIP settings */
2929  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2930  BMS_BLKMEM* blkmem, /**< block memory */
2931  const char* name, /**< name of the parameter */
2932  const char* desc, /**< description of the parameter */
2933  SCIP_Real* valueptr, /**< pointer to store the current parameter value, or NULL */
2934  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
2935  SCIP_Real defaultvalue, /**< default value of the parameter */
2936  SCIP_Real minvalue, /**< minimum value for parameter */
2937  SCIP_Real maxvalue, /**< maximum value for parameter */
2938  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
2939  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
2940  )
2941 {
2942  assert(set != NULL);
2943 
2944  SCIP_CALL( SCIPparamsetAddReal(set->paramset, messagehdlr, blkmem, name, desc, valueptr, isadvanced,
2945  defaultvalue, minvalue, maxvalue, paramchgd, paramdata) );
2946 
2947  return SCIP_OKAY;
2948 }
2949 
2950 /** creates a char parameter, sets it to its default value, and adds it to the parameter set */
2952  SCIP_SET* set, /**< global SCIP settings */
2953  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2954  BMS_BLKMEM* blkmem, /**< block memory */
2955  const char* name, /**< name of the parameter */
2956  const char* desc, /**< description of the parameter */
2957  char* valueptr, /**< pointer to store the current parameter value, or NULL */
2958  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
2959  char defaultvalue, /**< default value of the parameter */
2960  const char* allowedvalues, /**< array with possible parameter values, or NULL if not restricted */
2961  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
2962  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
2963  )
2964 {
2965  assert(set != NULL);
2966 
2967  SCIP_CALL( SCIPparamsetAddChar(set->paramset, messagehdlr, blkmem, name, desc, valueptr, isadvanced,
2968  defaultvalue, allowedvalues, paramchgd, paramdata) );
2969 
2970  return SCIP_OKAY;
2971 }
2972 
2973 /** creates a string parameter, sets it to its default value, and adds it to the parameter set */
2975  SCIP_SET* set, /**< global SCIP settings */
2976  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2977  BMS_BLKMEM* blkmem, /**< block memory */
2978  const char* name, /**< name of the parameter */
2979  const char* desc, /**< description of the parameter */
2980  char** valueptr, /**< pointer to store the current parameter value, or NULL */
2981  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
2982  const char* defaultvalue, /**< default value of the parameter */
2983  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
2984  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
2985  )
2986 {
2987  assert(set != NULL);
2988 
2989  SCIP_CALL( SCIPparamsetAddString(set->paramset, messagehdlr, blkmem, name, desc, valueptr, isadvanced,
2990  defaultvalue, paramchgd, paramdata) );
2991 
2992  return SCIP_OKAY;
2993 }
2994 
2995 /** gets the fixing status value of an existing parameter */
2997  SCIP_SET* set, /**< global SCIP settings */
2998  const char* name /**< name of the parameter */
2999  )
3000 {
3001  assert(set != NULL);
3002 
3003  return SCIPparamsetIsFixed(set->paramset, name);
3005 
3006 /** returns the pointer to the SCIP parameter with the given name */
3008  SCIP_SET* set, /**< global SCIP settings */
3009  const char* name /**< name of the parameter */
3010  )
3011 {
3012  assert(set != NULL);
3013 
3014  return SCIPparamsetGetParam(set->paramset, name);
3015 }
3016 
3017 /** gets the value of an existing SCIP_Bool parameter */
3019  SCIP_SET* set, /**< global SCIP settings */
3020  const char* name, /**< name of the parameter */
3021  SCIP_Bool* value /**< pointer to store the parameter */
3022  )
3023 {
3024  assert(set != NULL);
3025 
3026  SCIP_CALL( SCIPparamsetGetBool(set->paramset, name, value) );
3027 
3028  return SCIP_OKAY;
3029 }
3030 
3031 /** gets the value of an existing Int parameter */
3033  SCIP_SET* set, /**< global SCIP settings */
3034  const char* name, /**< name of the parameter */
3035  int* value /**< pointer to store the value of the parameter */
3036  )
3037 {
3038  assert(set != NULL);
3039 
3040  SCIP_CALL( SCIPparamsetGetInt(set->paramset, name, value) );
3041 
3042  return SCIP_OKAY;
3043 }
3044 
3045 /** gets the value of an existing SCIP_Longint parameter */
3047  SCIP_SET* set, /**< global SCIP settings */
3048  const char* name, /**< name of the parameter */
3049  SCIP_Longint* value /**< pointer to store the value of the parameter */
3050  )
3052  assert(set != NULL);
3053 
3054  SCIP_CALL( SCIPparamsetGetLongint(set->paramset, name, value) );
3055 
3056  return SCIP_OKAY;
3057 }
3058 
3059 /** gets the value of an existing SCIP_Real parameter */
3061  SCIP_SET* set, /**< global SCIP settings */
3062  const char* name, /**< name of the parameter */
3063  SCIP_Real* value /**< pointer to store the value of the parameter */
3064  )
3065 {
3066  assert(set != NULL);
3067 
3068  SCIP_CALL( SCIPparamsetGetReal(set->paramset, name, value) );
3069 
3070  return SCIP_OKAY;
3071 }
3072 
3073 /** gets the value of an existing Char parameter */
3075  SCIP_SET* set, /**< global SCIP settings */
3076  const char* name, /**< name of the parameter */
3077  char* value /**< pointer to store the value of the parameter */
3078  )
3079 {
3080  assert(set != NULL);
3081 
3082  SCIP_CALL( SCIPparamsetGetChar(set->paramset, name, value) );
3083 
3084  return SCIP_OKAY;
3085 }
3086 
3087 /** gets the value of an existing String parameter */
3089  SCIP_SET* set, /**< global SCIP settings */
3090  const char* name, /**< name of the parameter */
3091  char** value /**< pointer to store the value of the parameter */
3092  )
3093 {
3094  assert(set != NULL);
3096  SCIP_CALL( SCIPparamsetGetString(set->paramset, name, value) );
3097 
3098  return SCIP_OKAY;
3099 }
3100 
3101 /** changes the fixing status of an existing parameter */
3103  SCIP_SET* set, /**< global SCIP settings */
3104  const char* name, /**< name of the parameter */
3105  SCIP_Bool fixed /**< new fixing status of the parameter */
3106  )
3107 {
3108  assert(set != NULL);
3110  SCIP_CALL( SCIPparamsetFix(set->paramset, name, fixed) );
3111 
3112  return SCIP_OKAY;
3113 }
3114 
3115 /** changes the value of an existing parameter */
3117  SCIP_SET* set, /**< global SCIP settings */
3118  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3119  const char* name, /**< name of the parameter */
3120  void* value /**< new value of the parameter */
3121  )
3122 {
3123  assert(set != NULL);
3124 
3125  SCIP_CALL( SCIPparamsetSet(set->paramset, set, messagehdlr, name, value) );
3126 
3127  return SCIP_OKAY;
3128 }
3129 
3130 /** changes the value of an existing SCIP_Bool parameter */
3132  SCIP_SET* set, /**< global SCIP settings */
3133  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3134  SCIP_PARAM* param, /**< parameter */
3135  SCIP_Bool value /**< new value of the parameter */
3136  )
3138  SCIP_RETCODE retcode;
3139 
3140  assert(set != NULL);
3141 
3142  retcode = SCIPparamSetBool(param, set, messagehdlr, value, FALSE, TRUE);
3143 
3144  if( retcode != SCIP_PARAMETERWRONGVAL )
3145  {
3146  SCIP_CALL( retcode );
3147  }
3148 
3149  return retcode;
3150 }
3152 /** changes the value of an existing SCIP_Bool parameter */
3154  SCIP_SET* set, /**< global SCIP settings */
3155  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3156  const char* name, /**< name of the parameter */
3157  SCIP_Bool value /**< new value of the parameter */
3158  )
3159 {
3160  assert(set != NULL);
3161 
3162  SCIP_CALL( SCIPparamsetSetBool(set->paramset, set, messagehdlr, name, value) );
3163 
3164  return SCIP_OKAY;
3166 
3167 /** sets the default value of an existing SCIP_Bool parameter */
3169  SCIP_SET* set, /**< global SCIP settings */
3170  const char* name, /**< name of the parameter */
3171  SCIP_Bool defaultvalue /**< new default value of the parameter */
3172  )
3173 {
3174  assert(set != NULL);
3175 
3176  SCIP_CALL( SCIPparamsetSetDefaultBool(set->paramset, name, defaultvalue) );
3177 
3178  return SCIP_OKAY;
3180 
3181 
3182 /** changes the value of an existing Int parameter */
3184  SCIP_SET* set, /**< global SCIP settings */
3185  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3186  SCIP_PARAM* param, /**< parameter */
3187  int value /**< new value of the parameter */
3188  )
3189 {
3190  SCIP_RETCODE retcode;
3191 
3192  assert(set != NULL);
3193  assert(param != NULL);
3194 
3195  retcode = SCIPparamSetInt(param, set, messagehdlr, value, FALSE, TRUE);
3196 
3197  if( retcode != SCIP_PARAMETERWRONGVAL )
3198  {
3199  SCIP_CALL( retcode );
3200  }
3201 
3202  return retcode;
3203 }
3204 
3205 /** changes the value of an existing Int parameter */
3207  SCIP_SET* set, /**< global SCIP settings */
3208  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3209  const char* name, /**< name of the parameter */
3210  int value /**< new value of the parameter */
3211  )
3212 {
3213  assert(set != NULL);
3214 
3215  SCIP_CALL( SCIPparamsetSetInt(set->paramset, set, messagehdlr, name, value) );
3216 
3217  return SCIP_OKAY;
3218 }
3219 
3220 /** changes the default value of an existing Int parameter */
3222  SCIP_SET* set, /**< global SCIP settings */
3223  const char* name, /**< name of the parameter */
3224  int defaultvalue /**< new default value of the parameter */
3225  )
3226 {
3227  assert(set != NULL);
3228 
3229  SCIP_CALL( SCIPparamsetSetDefaultInt(set->paramset, name, defaultvalue) );
3231  return SCIP_OKAY;
3232 }
3233 
3234 /** changes the value of an existing SCIP_Longint parameter */
3236  SCIP_SET* set, /**< global SCIP settings */
3237  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3238  SCIP_PARAM* param, /**< parameter */
3239  SCIP_Longint value /**< new value of the parameter */
3240  )
3241 {
3242  SCIP_RETCODE retcode;
3243 
3244  assert(set != NULL);
3245  assert(param != NULL);
3246 
3247  retcode = SCIPparamSetLongint(param, set, messagehdlr, value, FALSE, TRUE);
3248 
3249  if( retcode != SCIP_PARAMETERWRONGVAL )
3250  {
3251  SCIP_CALL( retcode );
3252  }
3253 
3254  return retcode;
3255 }
3256 
3257 /** changes the value of an existing SCIP_Longint parameter */
3259  SCIP_SET* set, /**< global SCIP settings */
3260  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3261  const char* name, /**< name of the parameter */
3262  SCIP_Longint value /**< new value of the parameter */
3263  )
3264 {
3265  assert(set != NULL);
3266 
3267  SCIP_CALL( SCIPparamsetSetLongint(set->paramset, set, messagehdlr, name, value) );
3268 
3269  return SCIP_OKAY;
3270 }
3271 
3272 /** changes the value of an existing SCIP_Real parameter */
3274  SCIP_SET* set, /**< global SCIP settings */
3275  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3276  SCIP_PARAM* param, /**< parameter */
3277  SCIP_Real value /**< new value of the parameter */
3278  )
3279 {
3280  SCIP_RETCODE retcode;
3281 
3282  assert(set != NULL);
3283  assert(param != NULL);
3284 
3285  retcode = SCIPparamSetReal(param, set, messagehdlr, value, FALSE, TRUE);
3286 
3287  if( retcode != SCIP_PARAMETERWRONGVAL )
3288  {
3289  SCIP_CALL( retcode );
3290  }
3291 
3292  return retcode;
3293 }
3294 
3295 /** changes the value of an existing SCIP_Real parameter */
3297  SCIP_SET* set, /**< global SCIP settings */
3298  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3299  const char* name, /**< name of the parameter */
3300  SCIP_Real value /**< new value of the parameter */
3301  )
3302 {
3303  assert(set != NULL);
3304 
3305  SCIP_CALL( SCIPparamsetSetReal(set->paramset, set, messagehdlr, name, value) );
3306 
3307  return SCIP_OKAY;
3308 }
3309 
3310 /** changes the value of an existing Char parameter */
3312  SCIP_SET* set, /**< global SCIP settings */
3313  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3314  SCIP_PARAM* param, /**< parameter */
3315  char value /**< new value of the parameter */
3316  )
3317 {
3318  SCIP_RETCODE retcode;
3319 
3320  assert(set != NULL);
3321  assert(param != NULL);
3322 
3323  retcode = SCIPparamSetChar(param, set, messagehdlr, value, FALSE, TRUE);
3324 
3325  if( retcode != SCIP_PARAMETERWRONGVAL )
3326  {
3327  SCIP_CALL( retcode );
3328  }
3329 
3330  return retcode;
3331 }
3332 
3333 /** changes the value of an existing Char parameter */
3335  SCIP_SET* set, /**< global SCIP settings */
3336  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3337  const char* name, /**< name of the parameter */
3338  char value /**< new value of the parameter */
3339  )
3340 {
3341  assert(set != NULL);
3342 
3343  SCIP_CALL( SCIPparamsetSetChar(set->paramset, set, messagehdlr, name, value) );
3344 
3345  return SCIP_OKAY;
3346 }
3347 
3348 /** changes the value of an existing String parameter */
3350  SCIP_SET* set, /**< global SCIP settings */
3351  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3352  SCIP_PARAM* param, /**< parameter */
3353  const char* value /**< new value of the parameter */
3354  )
3355 {
3356  SCIP_RETCODE retcode;
3357 
3358  assert(set != NULL);
3359  assert(param != NULL);
3360 
3361  retcode = SCIPparamSetString(param, set, messagehdlr, value, TRUE);
3362 
3363  if( retcode != SCIP_PARAMETERWRONGVAL )
3364  {
3365  SCIP_CALL( retcode );
3366  }
3367 
3368  return retcode;
3369 }
3370 
3371 /** changes the value of an existing String parameter */
3373  SCIP_SET* set, /**< global SCIP settings */
3374  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3375  const char* name, /**< name of the parameter */
3376  const char* value /**< new value of the parameter */
3377  )
3378 {
3379  assert(set != NULL);
3380 
3381  SCIP_CALL( SCIPparamsetSetString(set->paramset, set, messagehdlr, name, value) );
3382 
3383  return SCIP_OKAY;
3384 }
3385 
3386 /** reads parameters from a file */
3388  SCIP_SET* set, /**< global SCIP settings */
3389  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3390  const char* filename /**< file name */
3391  )
3392 {
3393  assert(set != NULL);
3394 
3395  SCIP_CALL( SCIPparamsetRead(set->paramset, set, messagehdlr, filename) );
3396 
3397  return SCIP_OKAY;
3398 }
3399 
3400 /** writes all parameters in the parameter set to a file */
3402  SCIP_SET* set, /**< global SCIP settings */
3403  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3404  const char* filename, /**< file name, or NULL for stdout */
3405  SCIP_Bool comments, /**< should parameter descriptions be written as comments? */
3406  SCIP_Bool onlychanged /**< should only the parameters been written, that are changed from default? */
3407  )
3408 {
3409  assert(set != NULL);
3410 
3411  SCIP_CALL( SCIPparamsetWrite(set->paramset, messagehdlr, filename, comments, onlychanged) );
3412 
3413  return SCIP_OKAY;
3414 }
3415 
3416 /** resets a single parameters to its default value */
3418  SCIP_SET* set, /**< global SCIP settings */
3419  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3420  const char* name /**< name of the parameter */
3421  )
3422 {
3423  SCIP_CALL( SCIPparamsetSetToDefault(set->paramset, set, messagehdlr, name) );
3424 
3425  return SCIP_OKAY;
3427 
3428 /** resets all parameters to their default values */
3430  SCIP_SET* set, /**< global SCIP settings */
3431  SCIP_MESSAGEHDLR* messagehdlr /**< message handler */
3432  )
3433 {
3434  SCIP_CALL( SCIPparamsetSetToDefaults(set->paramset, set, messagehdlr) );
3435 
3436  return SCIP_OKAY;
3437 }
3438 
3439 /** sets parameters to
3440  *
3441  * - \ref SCIP_PARAMEMPHASIS_DEFAULT to use default values (see also SCIPsetResetParams())
3442  * - \ref SCIP_PARAMEMPHASIS_COUNTER to get feasible and "fast" counting process
3443  * - \ref SCIP_PARAMEMPHASIS_CPSOLVER to get CP like search (e.g. no LP relaxation)
3444  * - \ref SCIP_PARAMEMPHASIS_EASYCIP to solve easy problems fast
3445  * - \ref SCIP_PARAMEMPHASIS_FEASIBILITY to detect feasibility fast
3446  * - \ref SCIP_PARAMEMPHASIS_HARDLP to be capable to handle hard LPs
3447  * - \ref SCIP_PARAMEMPHASIS_OPTIMALITY to prove optimality fast
3448  * - \ref SCIP_PARAMEMPHASIS_PHASEFEAS to find feasible solutions during a 3 phase solution process
3449  * - \ref SCIP_PARAMEMPHASIS_PHASEIMPROVE to find improved solutions during a 3 phase solution process
3450  * - \ref SCIP_PARAMEMPHASIS_PHASEPROOF to proof optimality during a 3 phase solution process
3451  */
3453  SCIP_SET* set, /**< global SCIP settings */
3454  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3455  SCIP_PARAMEMPHASIS paramemphasis, /**< parameter settings */
3456  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
3457  )
3458 {
3459  SCIP_CALL( SCIPparamsetSetEmphasis(set->paramset, set, messagehdlr, paramemphasis, quiet) );
3460 
3461  return SCIP_OKAY;
3462 }
3463 
3464 /** sets parameters to deactivate separators and heuristics that use auxiliary SCIP instances; should be called for
3465  * auxiliary SCIP instances to avoid recursion
3466  */
3468  SCIP_SET* set, /**< global SCIP settings */
3469  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3470  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
3471  )
3472 {
3473  SCIP_CALL( SCIPparamsetSetToSubscipsOff(set->paramset, set, messagehdlr, quiet) );
3474 
3475  return SCIP_OKAY;
3476 }
3477 
3478 /** sets heuristic parameters values to
3479  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all heuristic parameters
3480  * - SCIP_PARAMSETTING_FAST such that the time spent on heuristics is decreased
3481  * - SCIP_PARAMSETTING_AGGRESSIVE such that the heuristics are called more aggressively
3482  * - SCIP_PARAMSETTING_OFF which turn off all heuristics
3483  */
3485  SCIP_SET* set, /**< global SCIP settings */
3486  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3487  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
3488  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
3489  )
3490 {
3491  SCIP_CALL( SCIPparamsetSetHeuristics(set->paramset, set, messagehdlr, paramsetting, quiet) );
3492 
3493  return SCIP_OKAY;
3495 
3496 /** sets presolving parameters to
3497  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all presolving parameters
3498  * - SCIP_PARAMSETTING_FAST such that the time spent on presolving is decreased
3499  * - SCIP_PARAMSETTING_AGGRESSIVE such that the presolving is more aggressive
3500  * - SCIP_PARAMSETTING_OFF which turn off all presolving
3501  */
3503  SCIP_SET* set, /**< global SCIP settings */
3504  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3505  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
3506  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
3507  )
3508 {
3509  SCIP_CALL( SCIPparamsetSetPresolving(set->paramset, set, messagehdlr, paramsetting, quiet) );
3510 
3511  return SCIP_OKAY;
3512 }
3513 
3514 /** sets separating parameters to
3515  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all separating parameters
3516  * - SCIP_PARAMSETTING_FAST such that the time spent on separating is decreased
3517  * - SCIP_PARAMSETTING_AGGRESSIVE such that separating is more aggressive
3518  * - SCIP_PARAMSETTING_OFF which turn off all separating
3519  */
3521  SCIP_SET* set, /**< global SCIP settings */
3522  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3523  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
3524  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
3525  )
3526 {
3527  SCIP_CALL( SCIPparamsetSetSeparating(set->paramset, set, messagehdlr, paramsetting, quiet) );
3528 
3529  return SCIP_OKAY;
3530 }
3531 
3532 /** returns the array of all available SCIP parameters */
3534  SCIP_SET* set /**< global SCIP settings */
3535  )
3536 {
3537  assert(set != NULL);
3538 
3539  return SCIPparamsetGetParams(set->paramset);
3540 }
3541 
3542 /** returns the total number of all available SCIP parameters */
3543 int SCIPsetGetNParams(
3544  SCIP_SET* set /**< global SCIP settings */
3545  )
3546 {
3547  assert(set != NULL);
3548 
3549  return SCIPparamsetGetNParams(set->paramset);
3550 }
3551 
3552 /** inserts file reader in file reader list */
3554  SCIP_SET* set, /**< global SCIP settings */
3555  SCIP_READER* reader /**< file reader */
3556  )
3557 {
3558  assert(set != NULL);
3559  assert(reader != NULL);
3560 
3561  if( set->nreaders >= set->readerssize )
3562  {
3563  set->readerssize = SCIPsetCalcMemGrowSize(set, set->nreaders+1);
3564  SCIP_ALLOC( BMSreallocMemoryArray(&set->readers, set->readerssize) );
3565  }
3566  assert(set->nreaders < set->readerssize);
3567 
3568  set->readers[set->nreaders] = reader;
3569  set->nreaders++;
3570 
3571  return SCIP_OKAY;
3572 }
3573 
3574 /** returns the file reader of the given name, or NULL if not existing */
3576  SCIP_SET* set, /**< global SCIP settings */
3577  const char* name /**< name of file reader */
3578  )
3580  int i;
3581 
3582  assert(set != NULL);
3583  assert(name != NULL);
3584 
3585  for( i = 0; i < set->nreaders; ++i )
3586  {
3587  if( strcmp(SCIPreaderGetName(set->readers[i]), name) == 0 )
3588  return set->readers[i];
3589  }
3590 
3591  return NULL;
3592 }
3593 
3594 /** inserts variable pricer in variable pricer list */
3596  SCIP_SET* set, /**< global SCIP settings */
3597  SCIP_PRICER* pricer /**< variable pricer */
3598  )
3599 {
3600  assert(set != NULL);
3601  assert(pricer != NULL);
3602 
3603  if( set->npricers >= set->pricerssize )
3604  {
3605  set->pricerssize = SCIPsetCalcMemGrowSize(set, set->npricers+1);
3606  SCIP_ALLOC( BMSreallocMemoryArray(&set->pricers, set->pricerssize) );
3607  }
3608  assert(set->npricers < set->pricerssize);
3609 
3610  set->pricers[set->npricers] = pricer;
3611  set->npricers++;
3612  set->pricerssorted = FALSE;
3613 
3614  return SCIP_OKAY;
3615 }
3616 
3617 /** returns the variable pricer of the given name, or NULL if not existing */
3619  SCIP_SET* set, /**< global SCIP settings */
3620  const char* name /**< name of variable pricer */
3621  )
3622 {
3623  int i;
3624 
3625  assert(set != NULL);
3626  assert(name != NULL);
3627 
3628  for( i = 0; i < set->npricers; ++i )
3629  {
3630  if( strcmp(SCIPpricerGetName(set->pricers[i]), name) == 0 )
3631  return set->pricers[i];
3632  }
3633 
3634  return NULL;
3635 }
3636 
3637 /** sorts pricers by priorities */
3638 void SCIPsetSortPricers(
3639  SCIP_SET* set /**< global SCIP settings */
3640  )
3641 {
3642  assert(set != NULL);
3643 
3644  if( !set->pricerssorted )
3645  {
3646  SCIPsortPtr((void**)set->pricers, SCIPpricerComp, set->npricers);
3647  set->pricerssorted = TRUE;
3648  set->pricersnamesorted = FALSE;
3649  }
3650 }
3651 
3652 /** sorts pricers by name */
3654  SCIP_SET* set /**< global SCIP settings */
3655  )
3656 {
3657  assert(set != NULL);
3658 
3659  if( !set->pricersnamesorted )
3660  {
3661  SCIPsortPtr((void**)set->pricers, SCIPpricerCompName, set->npricers);
3662  set->pricerssorted = FALSE;
3663  set->pricersnamesorted = TRUE;
3664  }
3665 }
3666 
3667 /** inserts Benders' decomposition in the Benders' decomposition list */
3669  SCIP_SET* set, /**< global SCIP settings */
3670  SCIP_BENDERS* benders /**< Benders' decomposition structure */
3671  )
3673  assert(set != NULL);
3674  assert(benders != NULL);
3675 
3676  if( set->nbenders >= set->benderssize )
3677  {
3678  set->benderssize = SCIPsetCalcMemGrowSize(set, set->nbenders+1);
3679  SCIP_ALLOC( BMSreallocMemoryArray(&set->benders, set->benderssize) );
3680  }
3681  assert(set->nbenders < set->benderssize);
3682 
3683  set->benders[set->nbenders] = benders;
3684  set->nbenders++;
3685  set->benderssorted = FALSE;
3686 
3687  return SCIP_OKAY;
3688 }
3689 
3690 /** returns the Benders' decomposition of the given name, or NULL if not existing */
3692  SCIP_SET* set, /**< global SCIP settings */
3693  const char* name /**< name of the Benders' decomposition */
3694  )
3696  int i;
3697 
3698  assert(set != NULL);
3699  assert(name != NULL);
3700 
3701  for( i = 0; i < set->nbenders; ++i )
3702  {
3703  if( strcmp(SCIPbendersGetName(set->benders[i]), name) == 0 )
3704  return set->benders[i];
3705  }
3706 
3707  return NULL;
3708 }
3709 
3710 /** sorts Benders' decomposition by priorities */
3711 void SCIPsetSortBenders(
3712  SCIP_SET* set /**< global SCIP settings */
3713  )
3714 {
3715  assert(set != NULL);
3716 
3717  if( !set->benderssorted )
3718  {
3719  SCIPsortPtr((void**)set->benders, SCIPbendersComp, set->nbenders);
3720  set->benderssorted = TRUE;
3721  set->bendersnamesorted = FALSE;
3722  }
3723 }
3724 
3725 /** sorts Benders' decomposition by name */
3727  SCIP_SET* set /**< global SCIP settings */
3728  )
3729 {
3730  assert(set != NULL);
3731 
3732  if( !set->bendersnamesorted )
3733  {
3734  SCIPsortPtr((void**)set->benders, SCIPbendersCompName, set->nbenders);
3735  set->benderssorted = FALSE;
3736  set->bendersnamesorted = TRUE;
3737  }
3738 }
3739 
3740 /** inserts constraint handler in constraint handler list */
3742  SCIP_SET* set, /**< global SCIP settings */
3743  SCIP_CONSHDLR* conshdlr /**< constraint handler */
3744  )
3746  int priority;
3747  int i;
3748 
3749  assert(set != NULL);
3750  assert(conshdlr != NULL);
3751  assert(!SCIPconshdlrIsInitialized(conshdlr));
3752 
3753  /* allocate memory */
3754  if( set->nconshdlrs >= set->conshdlrssize )
3755  {
3756  set->conshdlrssize = SCIPsetCalcMemGrowSize(set, set->nconshdlrs+1);
3757  SCIP_ALLOC( BMSreallocMemoryArray(&set->conshdlrs, set->conshdlrssize) );
3758  SCIP_ALLOC( BMSreallocMemoryArray(&set->conshdlrs_sepa, set->conshdlrssize) );
3759  SCIP_ALLOC( BMSreallocMemoryArray(&set->conshdlrs_enfo, set->conshdlrssize) );
3760  SCIP_ALLOC( BMSreallocMemoryArray(&set->conshdlrs_include, set->conshdlrssize) );
3761  }
3762  assert(set->nconshdlrs < set->conshdlrssize);
3763 
3764  /* sort constraint handler into conshdlrs array sorted by check priority */
3765  priority = SCIPconshdlrGetCheckPriority(conshdlr);
3766  for( i = set->nconshdlrs; i > 0 && SCIPconshdlrGetCheckPriority(set->conshdlrs[i-1]) < priority; --i )
3767  {
3768  set->conshdlrs[i] = set->conshdlrs[i-1];
3769  }
3770  set->conshdlrs[i] = conshdlr;
3771 
3772  /* sort constraint handler into conshdlrs_sepa array sorted by sepa priority */
3773  priority = SCIPconshdlrGetSepaPriority(conshdlr);
3774  for( i = set->nconshdlrs; i > 0 && SCIPconshdlrGetSepaPriority(set->conshdlrs_sepa[i-1]) < priority; --i )
3775  {
3776  set->conshdlrs_sepa[i] = set->conshdlrs_sepa[i-1];
3777  }
3778  set->conshdlrs_sepa[i] = conshdlr;
3779 
3780  /* sort constraint handler into conshdlrs_enfo array sorted by enfo priority */
3781  priority = SCIPconshdlrGetEnfoPriority(conshdlr);
3782  for( i = set->nconshdlrs; i > 0 && SCIPconshdlrGetEnfoPriority(set->conshdlrs_enfo[i-1]) < priority; --i )
3783  {
3784  set->conshdlrs_enfo[i] = set->conshdlrs_enfo[i-1];
3785  }
3786  set->conshdlrs_enfo[i] = conshdlr;
3787 
3788  /* add constraint handler into conshdlrs_include array sorted by inclusion order */
3789  set->conshdlrs_include[set->nconshdlrs] = conshdlr;
3790 
3791  set->nconshdlrs++;
3792 
3793  return SCIP_OKAY;
3794 }
3795 
3796 /** reinserts a constraint handler with modified sepa priority into the sepa priority sorted array */
3798  SCIP_SET* set, /**< global SCIP settings */
3799  SCIP_CONSHDLR* conshdlr, /**< constraint handler to be reinserted */
3800  int oldpriority /**< the old separation priority of constraint handler */
3801  )
3802 {
3803  int newpriority;
3804  int newpos;
3805  int i;
3806  assert(set != NULL);
3807  assert(conshdlr != NULL);
3808 
3809  newpriority = SCIPconshdlrGetSepaPriority(conshdlr);
3810  newpos = -1;
3811 
3812  /* search for the old position of constraint handler; determine its new position at the same time */
3813  if( newpriority > oldpriority )
3814  {
3815  i = 0;
3816  while( i < set->nconshdlrs &&
3817  strcmp(SCIPconshdlrGetName(set->conshdlrs_sepa[i]), SCIPconshdlrGetName(conshdlr)) != 0 )
3818  {
3819  int priorityatpos;
3820 
3821  priorityatpos = SCIPconshdlrGetSepaPriority(set->conshdlrs_sepa[i]);
3822  assert(priorityatpos >= oldpriority);
3823 
3824  /* current index is the position to insert the constraint handler */
3825  if( newpriority > priorityatpos && newpos == -1 )
3826  newpos = i;
3827 
3828  ++i;
3829  }
3830  assert(i < set->nconshdlrs);
3831 
3832  /* constraint must change its position in array */
3833  if( newpos != -1 )
3834  {
3835  /* shift all constraint handlers between old and new position by one, and insert constraint handler */
3836  for( ; i > newpos; --i )
3837  {
3838  set->conshdlrs_sepa[i] = set->conshdlrs_sepa[i-1];
3839  }
3840  set->conshdlrs_sepa[newpos] = conshdlr;
3841  }
3842  }
3843  else if( newpriority < oldpriority )
3844  {
3845  i = set->nconshdlrs - 1;
3846  while( i >= 0 && strcmp(SCIPconshdlrGetName(set->conshdlrs_sepa[i]), SCIPconshdlrGetName(conshdlr)) != 0 )
3847  {
3848  int priorityatpos;
3849 
3850  priorityatpos = SCIPconshdlrGetSepaPriority(set->conshdlrs_sepa[i]);
3851  assert(priorityatpos <= oldpriority);
3852 
3853  /* current index is the position to insert the constraint handler */
3854  if( newpriority < priorityatpos && newpos == -1 )
3855  newpos = i;
3856 
3857  --i;
3858  }
3859  assert(i >= 0);
3860 
3861  /* constraint must change its position in array */
3862  if( newpos != -1 )
3863  {
3864  /* shift all constraint handlers between old and new position by one, and insert constraint handler */
3865  for(; i < newpos; ++i )
3866  {
3867  set->conshdlrs_sepa[i] = set->conshdlrs_sepa[i + 1];
3868  }
3869  set->conshdlrs_sepa[newpos] = conshdlr;
3870  }
3871 #ifndef NDEBUG
3872  for( i = 0; i < set->nconshdlrs - 1; ++i )
3873  assert(SCIPconshdlrGetSepaPriority(set->conshdlrs_sepa[i])
3874  >= SCIPconshdlrGetSepaPriority(set->conshdlrs_sepa[i + 1]));
3875 #endif
3876  }
3877 }
3878 
3879 /** returns the constraint handler of the given name, or NULL if not existing */
3881  SCIP_SET* set, /**< global SCIP settings */
3882  const char* name /**< name of constraint handler */
3883  )
3884 {
3885  int i;
3886 
3887  assert(set != NULL);
3888  assert(name != NULL);
3889 
3890  for( i = 0; i < set->nconshdlrs; ++i )
3891  {
3892  if( strcmp(SCIPconshdlrGetName(set->conshdlrs[i]), name) == 0 )
3893  return set->conshdlrs[i];
3894  }
3895 
3896  return NULL;
3897 }
3898 
3899 /** inserts conflict handler in conflict handler list */
3901  SCIP_SET* set, /**< global SCIP settings */
3902  SCIP_CONFLICTHDLR* conflicthdlr /**< conflict handler */
3903  )
3904 {
3905  assert(set != NULL);
3906  assert(conflicthdlr != NULL);
3907  assert(!SCIPconflicthdlrIsInitialized(conflicthdlr));
3908 
3909  if( set->nconflicthdlrs >= set->conflicthdlrssize )
3910  {
3911  set->conflicthdlrssize = SCIPsetCalcMemGrowSize(set, set->nconflicthdlrs+1);
3912  SCIP_ALLOC( BMSreallocMemoryArray(&set->conflicthdlrs, set->conflicthdlrssize) );
3913  }
3914  assert(set->nconflicthdlrs < set->conflicthdlrssize);
3915 
3916  set->conflicthdlrs[set->nconflicthdlrs] = conflicthdlr;
3917  set->nconflicthdlrs++;
3918  set->conflicthdlrssorted = FALSE;
3919 
3920  return SCIP_OKAY;
3921 }
3922 
3923 /** returns the conflict handler of the given name, or NULL if not existing */
3925  SCIP_SET* set, /**< global SCIP settings */
3926  const char* name /**< name of conflict handler */
3927  )
3928 {
3929  int i;
3930 
3931  assert(set != NULL);
3932  assert(name != NULL);
3933 
3934  for( i = 0; i < set->nconflicthdlrs; ++i )
3935  {
3936  if( strcmp(SCIPconflicthdlrGetName(set->conflicthdlrs[i]), name) == 0 )
3937  return set->conflicthdlrs[i];
3938  }
3939 
3940  return NULL;
3941 }
3942 
3943 /** sorts conflict handlers by priorities */
3945  SCIP_SET* set /**< global SCIP settings */
3946  )
3947 {
3948  assert(set != NULL);
3949 
3950  if( !set->conflicthdlrssorted )
3951  {
3952  SCIPsortPtr((void**)set->conflicthdlrs, SCIPconflicthdlrComp, set->nconflicthdlrs);
3953  set->conflicthdlrssorted = TRUE;
3954  set->conflicthdlrsnamesorted = FALSE;
3955  }
3956 }
3958 /** sorts conflict handlers by name */
3960  SCIP_SET* set /**< global SCIP settings */
3961  )
3962 {
3963  assert(set != NULL);
3964 
3965  if( !set->conflicthdlrsnamesorted )
3966  {
3967  SCIPsortPtr((void**)set->conflicthdlrs, SCIPconflicthdlrCompName, set->nconflicthdlrs);
3968  set->conflicthdlrssorted = FALSE;
3969  set->conflicthdlrsnamesorted = TRUE;
3970  }
3971 }
3972 
3973 /** inserts presolver in presolver list */
3975  SCIP_SET* set, /**< global SCIP settings */
3976  SCIP_PRESOL* presol /**< presolver */
3977  )
3978 {
3979  assert(set != NULL);
3980  assert(presol != NULL);
3981 
3982  if( set->npresols >= set->presolssize )
3983  {
3984  set->presolssize = SCIPsetCalcMemGrowSize(set, set->npresols+1);
3985  SCIP_ALLOC( BMSreallocMemoryArray(&set->presols, set->presolssize) );
3986  }
3987  assert(set->npresols < set->presolssize);
3988 
3989  set->presols[set->npresols] = presol;
3990  set->npresols++;
3991  set->presolssorted = FALSE;
3992 
3993  return SCIP_OKAY;
3994 }
3995 
3996 /** returns the presolver of the given name, or NULL if not existing */
3998  SCIP_SET* set, /**< global SCIP settings */
3999  const char* name /**< name of presolver */
4000  )
4002  int i;
4003 
4004  assert(set != NULL);
4005  assert(name != NULL);
4006 
4007  for( i = 0; i < set->npresols; ++i )
4008  {
4009  if( strcmp(SCIPpresolGetName(set->presols[i]), name) == 0 )
4010  return set->presols[i];
4011  }
4012 
4013  return NULL;
4014 }
4015 
4016 /** sorts presolvers by priorities */
4017 void SCIPsetSortPresols(
4018  SCIP_SET* set /**< global SCIP settings */
4019  )
4020 {
4021  assert(set != NULL);
4022 
4023  if( !set->presolssorted )
4024  {
4025  SCIPsortPtr((void**)set->presols, SCIPpresolComp, set->npresols);
4026  set->presolssorted = TRUE;
4027  set->presolsnamesorted = FALSE;
4028  }
4029 }
4030 
4031 /** sorts presolvers by name */
4033  SCIP_SET* set /**< global SCIP settings */
4034  )
4035 {
4036  assert(set != NULL);
4037 
4038  if( !set->presolsnamesorted )
4039  {
4040  SCIPsortPtr((void**)set->presols, SCIPpresolCompName, set->npresols);
4041  set->presolssorted = FALSE;
4042  set->presolsnamesorted = TRUE;
4043  }
4044 }
4045 
4046 /** inserts relaxator in relaxator list */
4048  SCIP_SET* set, /**< global SCIP settings */
4049  SCIP_RELAX* relax /**< relaxator */
4050  )
4052  assert(set != NULL);
4053  assert(relax != NULL);
4054  assert(!SCIPrelaxIsInitialized(relax));
4055 
4056  if( set->nrelaxs >= set->relaxssize )
4057  {
4058  set->relaxssize = SCIPsetCalcMemGrowSize(set, set->nrelaxs+1);
4059  SCIP_ALLOC( BMSreallocMemoryArray(&set->relaxs, set->relaxssize) );
4060  }
4061  assert(set->nrelaxs < set->relaxssize);
4062 
4063  set->relaxs[set->nrelaxs] = relax;
4064  set->nrelaxs++;
4065  set->relaxssorted = FALSE;
4066 
4067  return SCIP_OKAY;
4068 }
4069 
4070 /** returns the relaxator of the given name, or NULL if not existing */
4072  SCIP_SET* set, /**< global SCIP settings */
4073  const char* name /**< name of relaxator */
4074  )
4075 {
4076  int i;
4077 
4078  assert(set != NULL);
4079  assert(name != NULL);
4080 
4081  for( i = 0; i < set->nrelaxs; ++i )
4082  {
4083  if( strcmp(SCIPrelaxGetName(set->relaxs[i]), name) == 0 )
4084  return set->relaxs[i];
4085  }
4086 
4087  return NULL;
4088 }
4089 
4090 /** sorts relaxators by priorities */
4091 void SCIPsetSortRelaxs(
4092  SCIP_SET* set /**< global SCIP settings */
4093  )
4095  assert(set != NULL);
4096 
4097  if( !set->relaxssorted )
4098  {
4099  SCIPsortPtr((void**)set->relaxs, SCIPrelaxComp, set->nrelaxs);
4100  set->relaxssorted = TRUE;
4101  set->relaxsnamesorted = FALSE;
4102  }
4103 }
4104 
4105 /** sorts relaxators by priorities */
4107  SCIP_SET* set /**< global SCIP settings */
4108  )
4110  assert(set != NULL);
4111 
4112  if( !set->relaxsnamesorted )
4113  {
4114  SCIPsortPtr((void**)set->relaxs, SCIPrelaxCompName, set->nrelaxs);
4115  set->relaxssorted = FALSE;
4116  set->relaxsnamesorted = TRUE;
4117  }
4118 }
4119 
4120 /** inserts separator in separator list */
4122  SCIP_SET* set, /**< global SCIP settings */
4123  SCIP_SEPA* sepa /**< separator */
4124  )
4125 {
4126  assert(set != NULL);
4127  assert(sepa != NULL);
4128  assert(!SCIPsepaIsInitialized(sepa));
4129 
4130  if( set->nsepas >= set->sepassize )
4131  {
4132  set->sepassize = SCIPsetCalcMemGrowSize(set, set->nsepas+1);
4133  SCIP_ALLOC( BMSreallocMemoryArray(&set->sepas, set->sepassize) );
4134  }
4135  assert(set->nsepas < set->sepassize);
4136 
4137  set->sepas[set->nsepas] = sepa;
4138  set->nsepas++;
4139  set->sepassorted = FALSE;
4140 
4141  return SCIP_OKAY;
4142 }
4143 
4144 /** returns the separator of the given name, or NULL if not existing */
4146  SCIP_SET* set, /**< global SCIP settings */
4147  const char* name /**< name of separator */
4148  )
4149 {
4150  int i;
4151 
4152  assert(set != NULL);
4153  assert(name != NULL);
4154 
4155  for( i = 0; i < set->nsepas; ++i )
4156  {
4157  if( strcmp(SCIPsepaGetName(set->sepas[i]), name) == 0 )
4158  return set->sepas[i];
4159  }
4160 
4161  return NULL;
4162 }
4163 
4164 /** sorts separators by priorities */
4165 void SCIPsetSortSepas(
4166  SCIP_SET* set /**< global SCIP settings */
4167  )
4169  assert(set != NULL);
4170 
4171  if( !set->sepassorted )
4172  {
4173  SCIPsortPtr((void**)set->sepas, SCIPsepaComp, set->nsepas);
4174  set->sepassorted = TRUE;
4175  set->sepasnamesorted = FALSE;
4176  }
4177 }
4178 
4179 /** sorts separators by name */
4181  SCIP_SET* set /**< global SCIP settings */
4182  )
4184  assert(set != NULL);
4185 
4186  if( !set->sepasnamesorted )
4187  {
4188  SCIPsortPtr((void**)set->sepas, SCIPsepaCompName, set->nsepas);
4189  set->sepassorted = FALSE;
4190  set->sepasnamesorted = TRUE;
4191  }
4192 }
4193 
4194 /** inserts propagator in propagator list */
4196  SCIP_SET* set, /**< global SCIP settings */
4197  SCIP_PROP* prop /**< propagator */
4198  )
4199 {
4200  assert(set != NULL);
4201  assert(prop != NULL);
4202  assert(!SCIPpropIsInitialized(prop));
4203 
4204  if( set->nprops >= set->propssize )
4205  {
4206  set->propssize = SCIPsetCalcMemGrowSize(set, set->nprops+1);
4207  SCIP_ALLOC( BMSreallocMemoryArray(&set->props, set->propssize) );
4208  SCIP_ALLOC( BMSreallocMemoryArray(&set->props_presol, set->propssize) );
4209  }
4210  assert(set->nprops < set->propssize);
4211 
4212  set->props[set->nprops] = prop;
4213  set->props_presol[set->nprops] = prop;
4214  set->nprops++;
4215  set->propssorted = FALSE;
4216  set->propspresolsorted = FALSE;
4217 
4218  return SCIP_OKAY;
4219 }
4220 
4221 /** returns the propagator of the given name, or NULL if not existing */
4223  SCIP_SET* set, /**< global SCIP settings */
4224  const char* name /**< name of propagator */
4225  )
4226 {
4227  int i;
4228 
4229  assert(set != NULL);
4230  assert(name != NULL);
4231 
4232  for( i = 0; i < set->nprops; ++i )
4233  {
4234  if( strcmp(SCIPpropGetName(set->props[i]), name) == 0 )
4235  return set->props[i];
4236  }
4237 
4238  return NULL;
4239 }
4240 
4241 /** sorts propagators by priorities */
4243  SCIP_SET* set /**< global SCIP settings */
4244  )
4245 {
4246  assert(set != NULL);
4247 
4248  if( !set->propssorted )
4249  {
4250  SCIPsortPtr((void**)set->props, SCIPpropComp, set->nprops);
4251  set->propssorted = TRUE;
4252  set->propsnamesorted = FALSE;
4253  }
4254 }
4255 
4256 /** sorts propagators by priorities for presolving */
4258  SCIP_SET* set /**< global SCIP settings */
4259  )
4260 {
4261  assert(set != NULL);
4262 
4263  if( !set->propspresolsorted )
4264  {
4265  SCIPsortPtr((void**)set->props_presol, SCIPpropCompPresol, set->nprops);
4266  set->propspresolsorted = TRUE;
4267  set->propsnamesorted = FALSE;
4268  }
4269 }
4270 
4271 /** sorts propagators w.r.t. names */
4273  SCIP_SET* set /**< global SCIP settings */
4274  )
4275 {
4276  assert(set != NULL);
4277 
4278  if( !set->propsnamesorted )
4279  {
4280  SCIPsortPtr((void**)set->props, SCIPpropCompName, set->nprops);
4281  set->propssorted = FALSE;
4282  set->propsnamesorted = TRUE;
4283  }
4284 }
4285 
4286 /** inserts bandit virtual function table into set */
4288  SCIP_SET* set, /**< global SCIP settings */
4289  SCIP_BANDITVTABLE* banditvtable /**< bandit algorithm virtual function table */
4290  )
4291 {
4292  assert(set != NULL);
4293  assert(banditvtable != NULL);
4294 
4295  if( set->nbanditvtables >= set->banditvtablessize )
4296  {
4297  int newsize = SCIPsetCalcMemGrowSize(set, set->nbanditvtables + 1);
4298  SCIP_ALLOC( BMSreallocMemoryArray(&set->banditvtables, newsize) );
4299  set->banditvtablessize = newsize;
4300  }
4301 
4302  assert(set->nbanditvtables < set->banditvtablessize);
4303  set->banditvtables[set->nbanditvtables++] = banditvtable;
4304 
4305  return SCIP_OKAY;
4306 }
4307 
4308 /** returns the bandit virtual function table of the given name, or NULL if not existing */
4310  SCIP_SET* set, /**< global SCIP settings */
4311  const char* name /**< name of bandit algorithm virtual function table */
4312  )
4313 {
4314  int b;
4315 
4316  assert(set != NULL);
4317  assert(name != NULL);
4318 
4319  /* search for a bandit v table of the given name */
4320  for( b = 0; b < set->nbanditvtables; ++b )
4321  {
4322  if( strcmp(name, SCIPbanditvtableGetName(set->banditvtables[b])) == 0 )
4323  return set->banditvtables[b];
4324  }
4325 
4326  return NULL;
4327 }
4328 
4329 /** inserts concurrent solver type into the concurrent solver type list */
4331  SCIP_SET* set, /**< global SCIP settings */
4332  SCIP_CONCSOLVERTYPE* concsolvertype /**< concurrent solver type */
4333  )
4335  assert(set != NULL);
4336  assert(concsolvertype != NULL);
4337 
4338  if( set->nconcsolvertypes >= set->concsolvertypessize )
4339  {
4340  set->concsolvertypessize = SCIPsetCalcMemGrowSize(set, set->nconcsolvertypes + 1);
4341  SCIP_ALLOC( BMSreallocMemoryArray(&set->concsolvertypes, set->concsolvertypessize) );
4342  }
4343  assert(set->nconcsolvertypes < set->concsolvertypessize);
4344 
4345  set->concsolvertypes[set->nconcsolvertypes] = concsolvertype;
4346  set->nconcsolvertypes++;
4347 
4348  return SCIP_OKAY;
4350 
4351 /** returns the concurrent solver type with the given name, or NULL if not existing */
4353  SCIP_SET* set, /**< global SCIP settings */
4354  const char* name /**< name of concurrent solver type */
4355  )
4356 {
4357  int i;
4358 
4359  assert(set != NULL);
4360  assert(name != NULL);
4361 
4362  for( i = 0; i < set->nconcsolvertypes; ++i )
4363  {
4364  if( strcmp(SCIPconcsolverTypeGetName(set->concsolvertypes[i]), name) == 0 )
4365  return set->concsolvertypes[i];
4366  }
4367 
4368  return NULL;
4369 }
4370 
4371 /** inserts concurrent solver into the concurrent solver list */
4373  SCIP_SET* set, /**< global SCIP settings */
4374  SCIP_CONCSOLVER* concsolver /**< concurrent solver */
4375  )
4376 {
4377  assert(set != NULL);
4378  assert(concsolver != NULL);
4379 
4380  if( set->nconcsolvers >= set->concsolverssize )
4381  {
4382  set->concsolverssize = SCIPsetCalcMemGrowSize(set, set->nconcsolvers + 1);
4383  SCIP_ALLOC( BMSreallocMemoryArray(&set->concsolvers, set->concsolverssize) );
4384  }
4385  assert(set->nconcsolvers < set->concsolverssize);
4387  set->concsolvers[set->nconcsolvers] = concsolver;
4388  assert(set->nconcsolvers == SCIPconcsolverGetIdx(concsolver));
4389 
4390  set->nconcsolvers++;
4391 
4392  return SCIP_OKAY;
4393 }
4394 
4395 /** frees all concurrent solvers in the concurrent solver list */
4397  SCIP_SET* set /**< global SCIP settings */
4398  )
4399 {
4400  int i;
4401  assert(set != NULL);
4402 
4403  /* call user callback for each concurrent solver */
4404  for( i = 0; i < set->nconcsolvers; ++i )
4405  {
4406  SCIP_CALL( SCIPconcsolverDestroyInstance(set, &set->concsolvers[i]) );
4407  }
4408 
4409  /* set size and number to zero and free the concurent solver array */
4410  set->nconcsolvers = 0;
4411  set->concsolverssize = 0;
4412  BMSfreeMemoryArrayNull(&set->concsolvers);
4413 
4414  return SCIP_OKAY;
4415 }
4416 
4417 /** inserts primal heuristic in primal heuristic list */
4419  SCIP_SET* set, /**< global SCIP settings */
4420  SCIP_HEUR* heur /**< primal heuristic */
4421  )
4422 {
4423  assert(set != NULL);
4424  assert(heur != NULL);
4425  assert(!SCIPheurIsInitialized(heur));
4426 
4427  if( set->nheurs >= set->heurssize )
4428  {
4429  set->heurssize = SCIPsetCalcMemGrowSize(set, set->nheurs+1);
4430  SCIP_ALLOC( BMSreallocMemoryArray(&set->heurs, set->heurssize) );
4431  }
4432  assert(set->nheurs < set->heurssize);
4433 
4434  set->heurs[set->nheurs] = heur;
4435  set->nheurs++;
4436  set->heurssorted = FALSE;
4437 
4438  return SCIP_OKAY;
4439 }
4440 
4441 /** returns the primal heuristic of the given name, or NULL if not existing */
4443  SCIP_SET* set, /**< global SCIP settings */
4444  const char* name /**< name of primal heuristic */
4445  )
4446 {
4447  int i;
4448 
4449  assert(set != NULL);
4450  assert(name != NULL);
4451 
4452  for( i = 0; i < set->nheurs; ++i )
4453  {
4454  if( strcmp(SCIPheurGetName(set->heurs[i]), name) == 0 )
4455  return set->heurs[i];
4456  }
4457 
4458  return NULL;
4459 }
4460 
4461 /** sorts heuristics by priorities */
4462 void SCIPsetSortHeurs(
4463  SCIP_SET* set /**< global SCIP settings */
4464  )
4465 {
4466  assert(set != NULL);
4467 
4468  if( !set->heurssorted )
4469  {
4470  SCIPsortPtr((void**)set->heurs, SCIPheurComp, set->nheurs);
4471  set->heurssorted = TRUE;
4472  set->heursnamesorted = FALSE;
4473  }
4474 }
4475 
4476 /** sorts heuristics by names */
4478  SCIP_SET* set /**< global SCIP settings */
4479  )
4480 {
4481  assert(set != NULL);
4482 
4483  if( !set->heursnamesorted )
4484  {
4485  SCIPsortPtr((void**)set->heurs, SCIPheurCompName, set->nheurs);
4486  set->heurssorted = FALSE;
4487  set->heursnamesorted = TRUE;
4488  }
4489 }
4490 
4491 /** inserts tree compression in tree compression list */
4493  SCIP_SET* set, /**< global SCIP settings */
4494  SCIP_COMPR* compr /**< tree compression */
4495  )
4496 {
4497  assert(set != NULL);
4498  assert(compr != NULL);
4499  assert(!SCIPcomprIsInitialized(compr));
4500 
4501  if( set->ncomprs >= set->comprssize )
4502  {
4503  set->comprssize = SCIPsetCalcMemGrowSize(set, set->ncomprs+1);
4504  SCIP_ALLOC( BMSreallocMemoryArray(&set->comprs, set->comprssize) );
4505  }
4506  assert(set->ncomprs < set->comprssize);
4507 
4508  set->comprs[set->ncomprs] = compr;
4509  set->ncomprs++;
4510  set->comprssorted = FALSE;
4511 
4512  return SCIP_OKAY;
4513 }
4514 
4515 /** returns the tree compression of the given name, or NULL if not existing */
4517  SCIP_SET* set, /**< global SCIP settings */
4518  const char* name /**< name of tree compression */
4519  )
4520 {
4521  int i;
4522 
4523  assert(set != NULL);
4524  assert(name != NULL);
4525 
4526  for( i = 0; i < set->ncomprs; ++i )
4527  {
4528  if( strcmp(SCIPcomprGetName(set->comprs[i]), name) == 0 )
4529  return set->comprs[i];
4530  }
4531 
4532  return NULL;
4533 }
4534 
4535 /** sorts compressions by priorities */
4536 void SCIPsetSortComprs(
4537  SCIP_SET* set /**< global SCIP settings */
4538  )
4540  assert(set != NULL);
4541 
4542  if( !set->comprssorted )
4543  {
4544  SCIPsortPtr((void**)set->comprs, SCIPcomprComp, set->ncomprs);
4545  set->comprssorted = TRUE;
4546  set->comprsnamesorted = FALSE;
4547  }
4548 }
4549 
4550 /** sorts heuristics by names */
4552  SCIP_SET* set /**< global SCIP settings */
4553  )
4555  assert(set != NULL);
4556 
4557  if( !set->comprsnamesorted )
4558  {
4559  SCIPsortPtr((void**)set->comprs, SCIPcomprCompName, set->ncomprs);
4560  set->comprssorted = FALSE;
4561  set->comprsnamesorted = TRUE;
4562  }
4563 }
4564 
4565 /** inserts event handler in event handler list */
4567  SCIP_SET* set, /**< global SCIP settings */
4568  SCIP_EVENTHDLR* eventhdlr /**< event handler */
4569  )
4570 {
4571  assert(set != NULL);
4572  assert(eventhdlr != NULL);
4573  assert(!SCIPeventhdlrIsInitialized(eventhdlr));
4574 
4575  if( set->neventhdlrs >= set->eventhdlrssize )
4576  {
4577  set->eventhdlrssize = SCIPsetCalcMemGrowSize(set, set->neventhdlrs+1);
4578  SCIP_ALLOC( BMSreallocMemoryArray(&set->eventhdlrs, set->eventhdlrssize) );
4579  }
4580  assert(set->neventhdlrs < set->eventhdlrssize);
4581 
4582  set->eventhdlrs[set->neventhdlrs] = eventhdlr;
4583  set->neventhdlrs++;
4584 
4585  return SCIP_OKAY;
4586 }
4587 
4588 /** returns the event handler of the given name, or NULL if not existing */
4590  SCIP_SET* set, /**< global SCIP settings */
4591  const char* name /**< name of event handler */
4592  )
4594  int i;
4595 
4596  assert(set != NULL);
4597  assert(name != NULL);
4598 
4599  for( i = 0; i < set->neventhdlrs; ++i )
4600  {
4601  if( strcmp(SCIPeventhdlrGetName(set->eventhdlrs[i]), name) == 0 )
4602  return set->eventhdlrs[i];
4603  }
4604 
4605  return NULL;
4606 }
4607 
4608 /** inserts node selector in node selector list */
4610  SCIP_SET* set, /**< global SCIP settings */
4611  SCIP_NODESEL* nodesel /**< node selector */
4612  )
4614  int i;
4615  int nodeselstdprio;
4616 
4617  assert(set != NULL);
4618  assert(nodesel != NULL);
4619  assert(!SCIPnodeselIsInitialized(nodesel));
4620 
4621  if( set->nnodesels >= set->nodeselssize )
4622  {
4623  set->nodeselssize = SCIPsetCalcMemGrowSize(set, set->nnodesels+1);
4624  SCIP_ALLOC( BMSreallocMemoryArray(&set->nodesels, set->nodeselssize) );
4625  }
4626  assert(set->nnodesels < set->nodeselssize);
4627 
4628  nodeselstdprio = SCIPnodeselGetStdPriority(nodesel);
4629 
4630  for( i = set->nnodesels; i > 0 && nodeselstdprio > SCIPnodeselGetStdPriority(set->nodesels[i-1]); --i )
4631  set->nodesels[i] = set->nodesels[i-1];
4632 
4633  set->nodesels[i] = nodesel;
4634  set->nnodesels++;
4635 
4636  return SCIP_OKAY;
4637 }
4638 
4639 /** returns the node selector of the given name, or NULL if not existing */
4641  SCIP_SET* set, /**< global SCIP settings */
4642  const char* name /**< name of event handler */
4643  )
4644 {
4645  int i;
4646 
4647  assert(set != NULL);
4648  assert(name != NULL);
4649 
4650  for( i = 0; i < set->nnodesels; ++i )
4651  {
4652  if( strcmp(SCIPnodeselGetName(set->nodesels[i]), name) == 0 )
4653  return set->nodesels[i];
4654  }
4655 
4656  return NULL;
4657 }
4658 
4659 /** returns node selector with highest priority in the current mode */
4661  SCIP_SET* set, /**< global SCIP settings */
4662  SCIP_STAT* stat /**< dynamic problem statistics */
4663  )
4664 {
4665  assert(set != NULL);
4666  assert(stat != NULL);
4667 
4668  /* check, if old node selector is still valid */
4669  if( set->nodesel == NULL && set->nnodesels > 0 )
4670  {
4671  int i;
4672 
4673  set->nodesel = set->nodesels[0];
4674 
4675  /* search highest priority node selector */
4676  if( stat->memsavemode )
4677  {
4678  for( i = 1; i < set->nnodesels; ++i )
4679  {
4680  if( SCIPnodeselGetMemsavePriority(set->nodesels[i]) > SCIPnodeselGetMemsavePriority(set->nodesel) )
4681  set->nodesel = set->nodesels[i];
4682  }
4683  }
4684  else
4685  {
4686  for( i = 1; i < set->nnodesels; ++i )
4687  {
4688  if( SCIPnodeselGetStdPriority(set->nodesels[i]) > SCIPnodeselGetStdPriority(set->nodesel) )
4689  set->nodesel = set->nodesels[i];
4690  }
4691  }
4692  }
4693 
4694  return set->nodesel;
4695 }
4696 
4697 /** inserts branching rule in branching rule list */
4699  SCIP_SET* set, /**< global SCIP settings */
4700  SCIP_BRANCHRULE* branchrule /**< branching rule */
4701  )
4702 {
4703  assert(set != NULL);
4704  assert(branchrule != NULL);
4705  assert(!SCIPbranchruleIsInitialized(branchrule));
4706 
4707  if( set->nbranchrules >= set->branchrulessize )
4708  {
4709  set->branchrulessize = SCIPsetCalcMemGrowSize(set, set->nbranchrules+1);
4710  SCIP_ALLOC( BMSreallocMemoryArray(&set->branchrules, set->branchrulessize) );
4711  }
4712  assert(set->nbranchrules < set->branchrulessize);
4713 
4714  set->branchrules[set->nbranchrules] = branchrule;
4715  set->nbranchrules++;
4716  set->branchrulessorted = FALSE;
4718  return SCIP_OKAY;
4719 }
4720 
4721 /** returns the branching rule of the given name, or NULL if not existing */
4723  SCIP_SET* set, /**< global SCIP settings */
4724  const char* name /**< name of event handler */
4725  )
4726 {
4727  int i;
4728 
4729  assert(set != NULL);
4730  assert(name != NULL);
4731 
4732  for( i = 0; i < set->nbranchrules; ++i )
4733  {
4734  if( strcmp(SCIPbranchruleGetName(set->branchrules[i]), name) == 0 )
4735  return set->branchrules[i];
4736  }
4738  return NULL;
4739 }
4740 
4741 /** sorts branching rules by priorities */
4743  SCIP_SET* set /**< global SCIP settings */
4744  )
4745 {
4746  assert(set != NULL);
4747 
4748  if( !set->branchrulessorted )
4749  {
4750  SCIPsortPtr((void**)set->branchrules, SCIPbranchruleComp, set->nbranchrules);
4751  set->branchrulessorted = TRUE;
4752  set->branchrulesnamesorted = FALSE;
4753  }
4754 }
4755 
4756 /** sorts branching rules by priorities */
4758  SCIP_SET* set /**< global SCIP settings */
4759  )
4760 {
4761  assert(set != NULL);
4762 
4763  if( !set->branchrulesnamesorted )
4764  {
4765  SCIPsortPtr((void**)set->branchrules, SCIPbranchruleCompName, set->nbranchrules);
4766  set->branchrulessorted = FALSE;
4767  set->branchrulesnamesorted = TRUE;
4768  }
4769 }
4770 
4771 /** inserts display column in display column list */
4773  SCIP_SET* set, /**< global SCIP settings */
4774  SCIP_DISP* disp /**< display column */
4775  )
4776 {
4777  int i;
4778  int disppos;
4779 
4780  assert(set != NULL);
4781  assert(disp != NULL);
4782  assert(!SCIPdispIsInitialized(disp));
4783 
4784  if( set->ndisps >= set->dispssize )
4785  {
4786  set->dispssize = SCIPsetCalcMemGrowSize(set, set->ndisps+1);
4787  SCIP_ALLOC( BMSreallocMemoryArray(&set->disps, set->dispssize) );
4788  }
4789  assert(set->ndisps < set->dispssize);
4790 
4791  disppos = SCIPdispGetPosition(disp);
4792 
4793  for( i = set->ndisps; i > 0 && disppos < SCIPdispGetPosition(set->disps[i-1]); --i )
4794  {
4795  set->disps[i] = set->disps[i-1];
4796  }
4797  set->disps[i] = disp;
4798  set->ndisps++;
4800  return SCIP_OKAY;
4801 }
4802 
4803 /** returns the display column of the given name, or NULL if not existing */
4805  SCIP_SET* set, /**< global SCIP settings */
4806  const char* name /**< name of display */
4807  )
4808 {
4809  int i;
4810 
4811  assert(set != NULL);
4812  assert(name != NULL);
4813 
4814  for( i = 0; i < set->ndisps; ++i )
4815  {
4816  if( strcmp(SCIPdispGetName(set->disps[i]), name) == 0 )
4817  return set->disps[i];
4818  }
4820  return NULL;
4821 }
4822 
4823 /** inserts statistics table in statistics table list */
4825  SCIP_SET* set, /**< global SCIP settings */
4826  SCIP_TABLE* table /**< statistics table */
4827  )
4828 {
4829  assert(set != NULL);
4830  assert(table != NULL);
4831  assert(!SCIPtableIsInitialized(table));
4832 
4833  if( set->ntables >= set->tablessize )
4834  {
4835  set->tablessize = SCIPsetCalcMemGrowSize(set, set->ntables+1);
4836  SCIP_ALLOC( BMSreallocMemoryArray(&set->tables, set->tablessize) );
4837  }
4838  assert(set->ntables < set->tablessize);
4839 
4840  /* we insert in arbitrary order and sort once before printing statistics */
4841  set->tables[set->ntables] = table;
4842  set->ntables++;
4843  set->tablessorted = FALSE;
4844 
4845  return SCIP_OKAY;
4846 }
4847 
4848 /** returns the statistics table of the given name, or NULL if not existing */
4850  SCIP_SET* set, /**< global SCIP settings */
4851  const char* name /**< name of statistics table */
4852  )
4853 {
4854  int i;
4855 
4856  assert(set != NULL);
4857  assert(name != NULL);
4858 
4859  for( i = 0; i < set->ntables; ++i )
4860  {
4861  if( strcmp(SCIPtableGetName(set->tables[i]), name) == 0 )
4862  return set->tables[i];
4863  }
4864 
4865  return NULL;
4866 }
4867 
4868 /** inserts dialog in dialog list */
4870  SCIP_SET* set, /**< global SCIP settings */
4871  SCIP_DIALOG* dialog /**< dialog */
4872  )
4873 {
4874  assert(set != NULL);
4875  assert(dialog != NULL);
4876 
4877  if( set->ndialogs >= set->dialogssize )
4878  {
4879  set->dialogssize = SCIPsetCalcMemGrowSize(set, set->ndialogs+1);
4880  SCIP_ALLOC( BMSreallocMemoryArray(&set->dialogs, set->dialogssize) );
4881  }
4882  assert(set->ndialogs < set->dialogssize);
4883 
4884  set->dialogs[set->ndialogs] = dialog;
4885  set->ndialogs++;
4886 
4887  return SCIP_OKAY;
4888 }
4889 
4890 /** returns if the dialog already exists */
4892  SCIP_SET* set, /**< global SCIP settings */
4893  SCIP_DIALOG* dialog /**< dialog */
4894  )
4895 {
4896  int i;
4897 
4898  assert(set != NULL);
4899 
4900  if( dialog == NULL )
4901  return FALSE;
4902 
4903  for( i = 0; i < set->ndialogs; ++i )
4904  {
4905  if( set->dialogs[i] == dialog )
4906  return TRUE;
4907  }
4908 
4909  return FALSE;
4910 }
4911 
4912 /** inserts NLPI in NLPI list */
4914  SCIP_SET* set, /**< global SCIP settings */
4915  SCIP_NLPI* nlpi /**< NLPI */
4916  )
4917 {
4918  assert(set != NULL);
4919  assert(nlpi != NULL);
4920 
4921  if( set->nnlpis >= set->nlpissize )
4922  {
4923  set->nlpissize = SCIPsetCalcMemGrowSize(set, set->nnlpis+1);
4924  SCIP_ALLOC( BMSreallocMemoryArray(&set->nlpis, set->nlpissize) );
4925  }
4926  assert(set->nnlpis < set->nlpissize);
4927 
4928  set->nlpis[set->nnlpis] = nlpi;
4929  set->nnlpis++;
4930  set->nlpissorted = FALSE;
4931 
4932  return SCIP_OKAY;
4933 }
4934 
4935 /** returns the NLPI of the given name, or NULL if not existing */
4937  SCIP_SET* set, /**< global SCIP settings */
4938  const char* name /**< name of NLPI */
4939  )
4940 {
4941  int i;
4942 
4943  assert(set != NULL);
4944  assert(name != NULL);
4945 
4946  for( i = 0; i < set->nnlpis; ++i )
4947  {
4948  if( strcmp(SCIPnlpiGetName(set->nlpis[i]), name) == 0 )
4949  return set->nlpis[i];
4950  }
4951 
4952  return NULL;
4953 }
4954 
4955 /** sorts NLPIs by priorities */
4956 void SCIPsetSortNlpis(
4957  SCIP_SET* set /**< global SCIP settings */
4958  )
4959 {
4960  assert(set != NULL);
4961 
4962  if( !set->nlpissorted )
4963  {
4964  SCIPsortPtr((void**)set->nlpis, SCIPnlpiComp, set->nnlpis);
4965  set->nlpissorted = TRUE;
4966  }
4967 }
4969 /** set priority of an NLPI */
4971  SCIP_SET* set, /**< global SCIP settings */
4972  SCIP_NLPI* nlpi, /**< NLPI */
4973  int priority /**< new priority of NLPI */
4974  )
4975 {
4976  assert(set != NULL);
4977  assert(nlpi != NULL);
4978 
4979  SCIPnlpiSetPriority(nlpi, priority);
4980  set->nlpissorted = FALSE;
4981 }
4982 
4983 /** inserts information about an external code in external codes list */
4985  SCIP_SET* set, /**< global SCIP settings */
4986  const char* name, /**< name of external code */
4987  const char* description /**< description of external code, can be NULL */
4988  )
4989 {
4990  assert(set != NULL);
4991  assert(name != NULL);
4992 
4993  if( set->nextcodes >= set->extcodessize )
4994  {
4995  set->extcodessize = SCIPsetCalcMemGrowSize(set, set->nextcodes+1);
4996  SCIP_ALLOC( BMSreallocMemoryArray(&set->extcodenames, set->extcodessize) );
4997  SCIP_ALLOC( BMSreallocMemoryArray(&set->extcodedescs, set->extcodessize) );
4998  }
4999  assert(set->nextcodes < set->extcodessize);
5000 
5001  BMSduplicateMemoryArray(&(set->extcodenames[set->nextcodes]), name, (int) (strlen(name)+1)); /*lint !e866*/
5002  if( description != NULL )
5003  {
5004  BMSduplicateMemoryArray(&(set->extcodedescs[set->nextcodes]), description, (int) (strlen(description)+1)); /*lint !e866*/
5005  }
5006  else
5007  {
5008  set->extcodedescs[set->nextcodes] = NULL;
5009  }
5010  set->nextcodes++;
5011 
5012  return SCIP_OKAY;
5014 
5015 /** calls init methods of all plugins */
5017  SCIP_SET* set, /**< global SCIP settings */
5018  BMS_BLKMEM* blkmem, /**< block memory */
5019  SCIP_STAT* stat /**< dynamic problem statistics */
5020  )
5021 {
5022  int i;
5023 
5024  assert(set != NULL);
5025 
5026  /* active variable pricers */
5027  SCIPsetSortPricers(set);
5028  for( i = 0; i < set->nactivepricers; ++i )
5029  {
5030  SCIP_CALL( SCIPpricerInit(set->pricers[i], set) );
5031  }
5032 
5033  /* Benders' decomposition algorithm */
5034  SCIPsetSortBenders(set);
5035  for( i = 0; i < set->nactivebenders; ++i )
5036  {
5037  SCIP_CALL( SCIPbendersInit(set->benders[i], set) );
5038  }
5039 
5040  /* constraint handlers */
5041  for( i = 0; i < set->nconshdlrs; ++i )
5042  {
5043  SCIP_CALL( SCIPconshdlrInit(set->conshdlrs[i], blkmem, set, stat) );
5044  }
5045 
5046  /* conflict handlers */
5047  for( i = 0; i < set->nconflicthdlrs; ++i )
5048  {
5049  SCIP_CALL( SCIPconflicthdlrInit(set->conflicthdlrs[i], set) );
5050  }
5051 
5052  /* presolvers */
5053  for( i = 0; i < set->npresols; ++i )
5054  {
5055  SCIP_CALL( SCIPpresolInit(set->presols[i], set) );
5056  }
5057 
5058  /* relaxators */
5059  for( i = 0; i < set->nrelaxs; ++i )
5060  {
5061  SCIP_CALL( SCIPrelaxInit(set->relaxs[i], set) );
5062  }
5063 
5064  /* separators */
5065  for( i = 0; i < set->nsepas; ++i )
5066  {
5067  SCIP_CALL( SCIPsepaInit(set->sepas[i], set) );
5068  }
5069 
5070  /* propagators */
5071  for( i = 0; i < set->nprops; ++i )
5072  {
5073  SCIP_CALL( SCIPpropInit(set->props[i], set) );
5074  }
5075 
5076  /* primal heuristics */
5077  for( i = 0; i < set->nheurs; ++i )
5078  {
5079  SCIP_CALL( SCIPheurInit(set->heurs[i], set) );
5080  }
5081 
5082  /* tree compression */
5083  for( i = 0; i < set->ncomprs; ++i )
5084  {
5085  SCIP_CALL( SCIPcomprInit(set->comprs[i], set) );
5086  }
5087 
5088  /* event handlers */
5089  for( i = 0; i < set->neventhdlrs; ++i )
5090  {
5091  SCIP_CALL( SCIPeventhdlrInit(set->eventhdlrs[i], set) );
5092  }
5094  /* node selectors */
5095  for( i = 0; i < set->nnodesels; ++i )
5096  {
5097  SCIP_CALL( SCIPnodeselInit(set->nodesels[i], set) );
5098  }
5099 
5100  /* branching rules */
5101  for( i = 0; i < set->nbranchrules; ++i )
5102  {
5103  SCIP_CALL( SCIPbranchruleInit(set->branchrules[i], set) );
5104  }
5105 
5106  /* display columns */
5107  for( i = 0; i < set->ndisps; ++i )
5108  {
5109  SCIP_CALL( SCIPdispInit(set->disps[i], set) );
5110  }
5112 
5113  /* statistics tables */
5114  for( i = 0; i < set->ntables; ++i )
5115  {
5116  SCIP_CALL( SCIPtableInit(set->tables[i], set) );
5117  }
5118 
5119  return SCIP_OKAY;
5120 }
5121 
5122 /** calls exit methods of all plugins */
5124  SCIP_SET* set, /**< global SCIP settings */
5125  BMS_BLKMEM* blkmem, /**< block memory */
5126  SCIP_STAT* stat /**< dynamic problem statistics */
5127  )
5128 {
5129  int i;
5130 
5131  assert(set != NULL);
5132 
5133  /* active variable pricers */
5134  SCIPsetSortPricers(set);
5135  for( i = 0; i < set->nactivepricers; ++i )
5136  {
5137  SCIP_CALL( SCIPpricerExit(set->pricers[i], set) );
5138  }
5139 
5140  /* Benders' decomposition */
5141  SCIPsetSortBenders(set);
5142  for( i = 0; i < set->nactivebenders; ++i )
5143  {
5144  SCIP_CALL( SCIPbendersExit(set->benders[i], set) );
5145  }
5146 
5147  /* constraint handlers */
5148  for( i = 0; i < set->nconshdlrs; ++i )
5149  {
5150  SCIP_CALL( SCIPconshdlrExit(set->conshdlrs[i], blkmem, set, stat) );
5151  }
5152 
5153  /* conflict handlers */
5154  for( i = 0; i < set->nconflicthdlrs; ++i )
5155  {
5156  SCIP_CALL( SCIPconflicthdlrExit(set->conflicthdlrs[i], set) );
5157  }
5158 
5159  /* presolvers */
5160  for( i = 0; i < set->npresols; ++i )
5161  {
5162  SCIP_CALL( SCIPpresolExit(set->presols[i], set) );
5163  }
5164 
5165  /* relaxators */
5166  for( i = 0; i < set->nrelaxs; ++i )
5167  {
5168  SCIP_CALL( SCIPrelaxExit(set->relaxs[i], set) );
5169  }
5170 
5171  /* separators */
5172  for( i = 0; i < set->nsepas; ++i )
5173  {
5174  SCIP_CALL( SCIPsepaExit(set->sepas[i], set) );
5175  }
5176 
5177  /* propagators */
5178  for( i = 0; i < set->nprops; ++i )
5179  {
5180  SCIP_CALL( SCIPpropExit(set->props[i], set) );
5181  }
5182 
5183  /* primal heuristics */
5184  for( i = 0; i < set->nheurs; ++i )
5185  {
5186  SCIP_CALL( SCIPheurExit(set->heurs[i], set) );
5187  }
5188 
5189  /* tree compression */
5190  for( i = 0; i < set->ncomprs; ++i )
5191  {
5192  SCIP_CALL( SCIPcomprExit(set->comprs[i], set) );
5193  }
5194 
5195  /* event handlers */
5196  for( i = 0; i < set->neventhdlrs; ++i )
5197  {
5198  SCIP_CALL( SCIPeventhdlrExit(set->eventhdlrs[i], set) );
5199  }
5201  /* node selectors */
5202  for( i = 0; i < set->nnodesels; ++i )
5203  {
5204  SCIP_CALL( SCIPnodeselExit(set->nodesels[i], set) );
5205  }
5206 
5207  /* branching rules */
5208  for( i = 0; i < set->nbranchrules; ++i )
5209  {
5210  SCIP_CALL( SCIPbranchruleExit(set->branchrules[i], set) );
5211  }
5212 
5213  /* display columns */
5214  for( i = 0; i < set->ndisps; ++i )
5215  {
5216  SCIP_CALL( SCIPdispExit(set->disps[i], set) );
5217  }
5218 
5219  /* statistics tables */
5220  for( i = 0; i < set->ntables; ++i )
5221  {
5222  SCIP_CALL( SCIPtableExit(set->tables[i], set) );
5223  }
5224 
5225  return SCIP_OKAY;
5226 }
5227 
5228 /** calls initpre methods of all plugins */
5230  SCIP_SET* set, /**< global SCIP settings */
5231  BMS_BLKMEM* blkmem, /**< block memory */
5232  SCIP_STAT* stat /**< dynamic problem statistics */
5233  )
5234 {
5235  int i;
5236 
5237  assert(set != NULL);
5238 
5239  /* inform presolvers that the presolving is about to begin */
5240  for( i = 0; i < set->npresols; ++i )
5241  {
5242  SCIP_CALL( SCIPpresolInitpre(set->presols[i], set) );
5243  }
5244 
5245  /* inform propagators that the presolving is about to begin */
5246  for( i = 0; i < set->nprops; ++i )
5247  {
5248  SCIP_CALL( SCIPpropInitpre(set->props[i], set) );
5249  }
5250 
5251  /* inform constraint handlers that the presolving is about to begin */
5252  for( i = 0; i < set->nconshdlrs; ++i )
5253  {
5254  SCIP_CALL( SCIPconshdlrInitpre(set->conshdlrs[i], blkmem, set, stat) );
5255  }
5256 
5257  /* inform Benders' decomposition that the presolving is about to begin */
5258  for( i = 0; i < set->nactivebenders; ++i )
5259  {
5260  SCIP_CALL( SCIPbendersInitpre(set->benders[i], set, stat) );
5261  }
5262 
5263  return SCIP_OKAY;
5264 }
5265 
5266 /** calls exitpre methods of all plugins */
5268  SCIP_SET* set, /**< global SCIP settings */
5269  BMS_BLKMEM* blkmem, /**< block memory */
5270  SCIP_STAT* stat /**< dynamic problem statistics */
5271  )
5272 {
5273  int i;
5274 
5275  assert(set != NULL);
5276 
5277  /* inform presolvers that the presolving is about to end */
5278  for( i = 0; i < set->npresols; ++i )
5279  {
5280  SCIP_CALL( SCIPpresolExitpre(set->presols[i], set) );
5281  }
5282 
5283  /* inform propagators that the presolving is about to end */
5284  for( i = 0; i < set->nprops; ++i )
5285  {
5286  SCIP_CALL( SCIPpropExitpre(set->props[i], set) );
5287  }
5288 
5289  /* inform constraint handlers that the presolving is about to end */
5290  for( i = 0; i < set->nconshdlrs; ++i )
5291  {
5292  SCIP_CALL( SCIPconshdlrExitpre(set->conshdlrs[i], blkmem, set, stat) );
5293  }
5294 
5295  /* inform Benders' decomposition that the presolving is about to end */
5296  for( i = 0; i < set->nactivebenders; ++i )
5297  {
5298  SCIP_CALL( SCIPbendersExitpre(set->benders[i], set, stat) );
5299  }
5300 
5301  return SCIP_OKAY;
5302 }
5303 
5304 /** calls initsol methods of all plugins */
5306  SCIP_SET* set, /**< global SCIP settings */
5307  BMS_BLKMEM* blkmem, /**< block memory */
5308  SCIP_STAT* stat /**< dynamic problem statistics */
5309  )
5310 {
5311  int i;
5312 
5313  assert(set != NULL);
5314 
5315  /* reset SCIP-defined feasibility tolerance for relaxations
5316  * if this is invalid, then only the relaxation specific feasibility tolerance,
5317  * e.g., numerics/lpfeastol is applied
5318  * SCIP plugins or core may set num_relaxfeastol to request a
5319  * tighter feasibility tolerance, though
5320  * see also documentation of SCIPchgRelaxfeastol
5321  */
5322  set->num_relaxfeastol = SCIP_INVALID;
5323 
5324  /* active variable pricers */
5325  SCIPsetSortPricers(set);
5326  for( i = 0; i < set->nactivepricers; ++i )
5327  {
5328  SCIP_CALL( SCIPpricerInitsol(set->pricers[i], set) );
5329  }
5330 
5331  /* Benders' decomposition */
5332  SCIPsetSortBenders(set);
5333  for( i = 0; i < set->nactivebenders; ++i )
5334  {
5335  SCIP_CALL( SCIPbendersInitsol(set->benders[i], set) );
5336  }
5337 
5338  /* constraint handlers */
5339  for( i = 0; i < set->nconshdlrs; ++i )
5340  {
5341  SCIP_CALL( SCIPconshdlrInitsol(set->conshdlrs[i], blkmem, set, stat) );
5342  }
5343 
5344  /* conflict handlers */
5345  for( i = 0; i < set->nconflicthdlrs; ++i )
5346  {
5347  SCIP_CALL( SCIPconflicthdlrInitsol(set->conflicthdlrs[i], set) );
5348  }
5349 
5350  /* relaxators */
5351  for( i = 0; i < set->nrelaxs; ++i )
5352  {
5353  SCIP_CALL( SCIPrelaxInitsol(set->relaxs[i], set) );
5354  }
5355 
5356  /* separators */
5357  for( i = 0; i < set->nsepas; ++i )
5358  {
5359  SCIP_CALL( SCIPsepaInitsol(set->sepas[i], set) );
5360  }
5361 
5362  /* propagators */
5363  for( i = 0; i < set->nprops; ++i )
5364  {
5365  SCIP_CALL( SCIPpropInitsol(set->props[i], set) );
5366  }
5367 
5368  /* primal heuristics */
5369  for( i = 0; i < set->nheurs; ++i )
5370  {
5371  SCIP_CALL( SCIPheurInitsol(set->heurs[i], set) );
5372  }
5373 
5374  /* event handlers */
5375  for( i = 0; i < set->neventhdlrs; ++i )
5376  {
5377  SCIP_CALL( SCIPeventhdlrInitsol(set->eventhdlrs[i], set) );
5378  }
5379 
5380  /* node selectors */
5381  for( i = 0; i < set->nnodesels; ++i )
5382  {
5383  SCIP_CALL( SCIPnodeselInitsol(set->nodesels[i], set) );
5384  }
5385 
5386  /* branching rules */
5387  for( i = 0; i < set->nbranchrules; ++i )
5388  {
5389  SCIP_CALL( SCIPbranchruleInitsol(set->branchrules[i], set) );
5390  }
5391 
5392  /* display columns */
5393  for( i = 0; i < set->ndisps; ++i )
5394  {
5395  SCIP_CALL( SCIPdispInitsol(set->disps[i], set) );
5396  }
5397 
5398  /* statistics tables */
5399  for( i = 0; i < set->ntables; ++i )
5400  {
5401  SCIP_CALL( SCIPtableInitsol(set->tables[i], set) );
5402  }
5403 
5404  return SCIP_OKAY;
5405 }
5406 
5407 /** calls exitsol methods of all plugins */
5409  SCIP_SET* set, /**< global SCIP settings */
5410  BMS_BLKMEM* blkmem, /**< block memory */
5411  SCIP_STAT* stat, /**< dynamic problem statistics */
5412  SCIP_Bool restart /**< was this exit solve call triggered by a restart? */
5413  )
5414 {
5415  int i;
5416 
5417  assert(set != NULL);
5418 
5419  /* active variable pricers */
5420  SCIPsetSortPricers(set);
5421  for( i = 0; i < set->nactivepricers; ++i )
5422  {
5423  SCIP_CALL( SCIPpricerExitsol(set->pricers[i], set) );
5424  }
5425 
5426  /* Benders' decomposition */
5427  SCIPsetSortBenders(set);
5428  for( i = 0; i < set->nactivebenders; ++i )
5429  {
5430  SCIP_CALL( SCIPbendersExitsol(set->benders[i], set) );
5431  }
5432 
5433  /* constraint handlers */
5434  for( i = 0; i < set->nconshdlrs; ++i )
5435  {
5436  SCIP_CALL( SCIPconshdlrExitsol(set->conshdlrs[i], blkmem, set, stat, restart) );
5437  }
5438 
5439  /* conflict handlers */
5440  for( i = 0; i < set->nconflicthdlrs; ++i )
5441  {
5442  SCIP_CALL( SCIPconflicthdlrExitsol(set->conflicthdlrs[i], set) );
5443  }
5444 
5445  /* relaxators */
5446  for( i = 0; i < set->nrelaxs; ++i )
5447  {
5448  SCIP_CALL( SCIPrelaxExitsol(set->relaxs[i], set) );
5449  }
5450 
5451  /* separators */
5452  for( i = 0; i < set->nsepas; ++i )
5453  {
5454  SCIP_CALL( SCIPsepaExitsol(set->sepas[i], set) );
5455  }
5456 
5457  /* propagators */
5458  for( i = 0; i < set->nprops; ++i )
5459  {
5460  SCIP_CALL( SCIPpropExitsol(set->props[i], set, restart) );
5461  }
5462 
5463  /* primal heuristics */
5464  for( i = 0; i < set->nheurs; ++i )
5465  {
5466  SCIP_CALL( SCIPheurExitsol(set->heurs[i], set) );
5467  }
5468 
5469  /* event handlers */
5470  for( i = 0; i < set->neventhdlrs; ++i )
5471  {
5472  SCIP_CALL( SCIPeventhdlrExitsol(set->eventhdlrs[i], set) );
5473  }
5474 
5475  /* node selectors */
5476  for( i = 0; i < set->nnodesels; ++i )
5477  {
5478  SCIP_CALL( SCIPnodeselExitsol(set->nodesels[i], set) );
5479  }
5480 
5481  /* branching rules */
5482  for( i = 0; i < set->nbranchrules; ++i )
5483  {
5484  SCIP_CALL( SCIPbranchruleExitsol(set->branchrules[i], set) );
5485  }
5486 
5487  /* display columns */
5488  for( i = 0; i < set->ndisps; ++i )
5489  {
5490  SCIP_CALL( SCIPdispExitsol(set->disps[i], set) );
5491  }
5492 
5493  /* statistics tables */
5494  for( i = 0; i < set->ntables; ++i )
5495  {
5496  SCIP_CALL( SCIPtableExitsol(set->tables[i], set) );
5497  }
5498 
5499  return SCIP_OKAY;
5500 }
5501 
5502 /** calculate memory size for dynamically allocated arrays */
5504  SCIP_SET* set, /**< global SCIP settings */
5505  int num /**< minimum number of entries to store */
5506  )
5507 {
5508  return calcGrowSize(set->mem_arraygrowinit, set->mem_arraygrowfac, num);
5509 }
5510 
5511 /** calculate memory size for tree array */
5513  SCIP_SET* set, /**< global SCIP settings */
5514  int num /**< minimum number of entries to store */
5515  )
5516 {
5517  return calcGrowSize(set->mem_treegrowinit, set->mem_treegrowfac, num);
5518 }
5519 
5520 /** calculate memory size for path array */
5522  SCIP_SET* set, /**< global SCIP settings */
5523  int num /**< minimum number of entries to store */
5524  )
5525 {
5526  return calcGrowSize(set->mem_pathgrowinit, set->mem_pathgrowfac, num);
5527 }
5528 
5529 /** sets verbosity level for message output */
5531  SCIP_SET* set, /**< global SCIP settings */
5532  SCIP_VERBLEVEL verblevel /**< verbosity level for message output */
5533  )
5534 {
5535  assert(set != NULL);
5536 
5537  if( verblevel > SCIP_VERBLEVEL_FULL )
5538  {
5539  SCIPerrorMessage("invalid verbosity level <%d>, maximum is <%d>\n", verblevel, SCIP_VERBLEVEL_FULL);
5540  return SCIP_INVALIDCALL;
5541  }
5542 
5543  set->disp_verblevel = verblevel;
5544 
5545  return SCIP_OKAY;
5546 }
5547 
5548 /** sets feasibility tolerance */
5550  SCIP_SET* set, /**< global SCIP settings */
5551  SCIP_LP* lp, /**< LP data, or NULL */
5552  SCIP_Real feastol /**< new feasibility tolerance */
5553  )
5554 {
5555  assert(set != NULL);
5556 
5557  set->num_feastol = feastol;
5558 
5559  /* the feasibility tolerance of the LP solver should never be larger than
5560  * numerics/lpfeastolfactor times SCIP's feasibility tolerance
5561  * if necessary, reset LP feastol
5562  */
5563  if( lp != NULL && SCIPlpGetFeastol(lp) > set->num_lpfeastolfactor * SCIPsetFeastol(set) )
5564  SCIPlpResetFeastol(lp, set);
5565 
5566  return SCIP_OKAY;
5567 }
5568 
5569 /** sets feasibility tolerance for reduced costs in LP solution */
5571  SCIP_SET* set, /**< global SCIP settings */
5572  SCIP_Real dualfeastol /**< new reduced costs feasibility tolerance */
5573  )
5574 {
5575  assert(set != NULL);
5576 
5577  set->num_dualfeastol = dualfeastol;
5578 
5579  return SCIP_OKAY;
5581 
5582 /** sets LP convergence tolerance used in barrier algorithm */
5584  SCIP_SET* set, /**< global SCIP settings */
5585  SCIP_Real barrierconvtol /**< new convergence tolerance used in barrier algorithm */
5586  )
5587 {
5588  assert(set != NULL);
5590  set->num_barrierconvtol = barrierconvtol;
5591 
5592  return SCIP_OKAY;
5593 }
5594 
5595 /** sets primal feasibility tolerance for relaxations (relaxfeastol)
5596  *
5597  * @note Set to SCIP_INVALID to apply relaxation-specific feasibility tolerance only.
5598  *
5599  * @return Previous value of relaxfeastol.
5600  */
5602  SCIP_SET* set, /**< global SCIP settings */
5603  SCIP_Real relaxfeastol /**< new primal feasibility tolerance for relaxations, or SCIP_INVALID */
5604  )
5605 {
5606  SCIP_Real oldval;
5608  assert(set != NULL);
5609  assert(relaxfeastol >= 0.0);
5610 
5611  oldval = set->num_relaxfeastol;
5612  set->num_relaxfeastol = relaxfeastol;
5613 
5614  return oldval;
5615 }
5616 
5617 /** marks that some limit parameter was changed */
5619  SCIP_SET* set /**< global SCIP settings */
5620  )
5621 {
5622  set->limitchanged = TRUE;
5623 
5624  set->istimelimitfinite = (set->limit_time < SCIP_DEFAULT_LIMIT_TIME);
5625 }
5627 /** returns the maximal number of variables priced into the LP per round */
5629  SCIP_SET* set, /**< global SCIP settings */
5630  SCIP_Bool root /**< are we at the root node? */
5631  )
5632 {
5633  assert(set != NULL);
5634 
5635  if( root )
5636  return set->price_maxvarsroot;
5637  else
5638  return set->price_maxvars;
5639 }
5640 
5641 /** returns the maximal number of cuts separated per round */
5643  SCIP_SET* set, /**< global SCIP settings */
5644  SCIP_Bool root /**< are we at the root node? */
5645  )
5646 {
5647  assert(set != NULL);
5648 
5649  if( root )
5650  return set->sepa_maxcutsroot;
5651  else
5652  return set->sepa_maxcuts;
5653 }
5654 
5655 /** returns user defined objective value (in original space) for reference purposes */
5657  SCIP_SET* set /**< global SCIP settings */
5658  )
5659 {
5660  assert(NULL != set);
5661 
5662  return set->misc_referencevalue;
5663 }
5664 
5665 
5666 /** returns debug solution data */
5668  SCIP_SET* set /**< global SCIP settings */
5669  )
5670 {
5671  assert(set != NULL);
5672 
5673  return set->debugsoldata;
5674 }
5675 
5676 
5677 /*
5678  * simple functions implemented as defines
5679  */
5680 
5681 /* In debug mode, the following methods are implemented as function calls to ensure
5682  * type validity.
5683  * In optimized mode, the methods are implemented as defines to improve performance.
5684  * However, we want to have them in the library anyways, so we have to undef the defines.
5685  */
5686 
5687 #undef SCIPsetInfinity
5688 #undef SCIPsetEpsilon
5689 #undef SCIPsetSumepsilon
5690 #undef SCIPsetFeastol
5691 #undef SCIPsetDualfeastol
5692 #undef SCIPsetBarrierconvtol
5693 #undef SCIPsetPseudocosteps
5694 #undef SCIPsetPseudocostdelta
5695 #undef SCIPsetCutoffbounddelta
5696 #undef SCIPsetLPFeastolFactor
5697 #undef SCIPsetRelaxfeastol
5698 #undef SCIPsetRecompfac
5699 #undef SCIPsetIsEQ
5700 #undef SCIPsetIsLT
5701 #undef SCIPsetIsLE
5702 #undef SCIPsetIsGT
5703 #undef SCIPsetIsGE
5704 #undef SCIPsetIsInfinity
5705 #undef SCIPsetIsZero
5706 #undef SCIPsetIsPositive
5707 #undef SCIPsetIsNegative
5708 #undef SCIPsetIsIntegral
5709 #undef SCIPsetIsScalingIntegral
5710 #undef SCIPsetIsFracIntegral
5711 #undef SCIPsetFloor
5712 #undef SCIPsetCeil
5713 #undef SCIPsetRound
5714 #undef SCIPsetFrac
5715 #undef SCIPsetIsSumEQ
5716 #undef SCIPsetIsSumLT
5717 #undef SCIPsetIsSumLE
5718 #undef SCIPsetIsSumGT
5719 #undef SCIPsetIsSumGE
5720 #undef SCIPsetIsSumZero
5721 #undef SCIPsetIsSumPositive
5722 #undef SCIPsetIsSumNegative
5723 #undef SCIPsetSumFloor
5724 #undef SCIPsetSumCeil
5725 #undef SCIPsetSumRound
5726 #undef SCIPsetSumFrac
5727 #undef SCIPsetIsFeasEQ
5728 #undef SCIPsetIsFeasLT
5729 #undef SCIPsetIsFeasLE
5730 #undef SCIPsetIsFeasGT
5731 #undef SCIPsetIsFeasGE
5732 #undef SCIPsetIsFeasZero
5733 #undef SCIPsetIsFeasPositive
5734 #undef SCIPsetIsFeasNegative
5735 #undef SCIPsetIsFeasIntegral
5736 #undef SCIPsetIsFeasFracIntegral
5737 #undef SCIPsetFeasFloor
5738 #undef SCIPsetFeasCeil
5739 #undef SCIPsetFeasRound
5740 #undef SCIPsetFeasFrac
5741 #undef SCIPsetIsDualfeasEQ
5742 #undef SCIPsetIsDualfeasLT
5743 #undef SCIPsetIsDualfeasLE
5744 #undef SCIPsetIsDualfeasGT
5745 #undef SCIPsetIsDualfeasGE
5746 #undef SCIPsetIsDualfeasZero
5747 #undef SCIPsetIsDualfeasPositive
5748 #undef SCIPsetIsDualfeasNegative
5749 #undef SCIPsetIsDualfeasIntegral
5750 #undef SCIPsetIsDualfeasFracIntegral
5751 #undef SCIPsetDualfeasFloor
5752 #undef SCIPsetDualfeasCeil
5753 #undef SCIPsetDualfeasRound
5754 #undef SCIPsetDualfeasFrac
5755 #undef SCIPsetIsLbBetter
5756 #undef SCIPsetIsUbBetter
5757 #undef SCIPsetIsEfficacious
5758 #undef SCIPsetIsRelEQ
5759 #undef SCIPsetIsRelLT
5760 #undef SCIPsetIsRelLE
5761 #undef SCIPsetIsRelGT
5762 #undef SCIPsetIsRelGE
5763 #undef SCIPsetIsSumRelEQ
5764 #undef SCIPsetIsSumRelLT
5765 #undef SCIPsetIsSumRelLE
5766 #undef SCIPsetIsSumRelGT
5767 #undef SCIPsetIsSumRelGE
5768 #undef SCIPsetIsUpdateUnreliable
5769 #undef SCIPsetInitializeRandomSeed
5770 #undef SCIPsetIsHugeValue
5771 #undef SCIPsetGetHugeValue
5772 #undef SCIPsetGetSubscipsOff
5773 
5774 /** returns value treated as infinity */
5776  SCIP_SET* set /**< global SCIP settings */
5777  )
5778 {
5779  assert(set != NULL);
5780 
5781  return set->num_infinity;
5782 }
5783 
5784 /** returns the minimum value that is regarded as huge and should be handled separately (e.g., in activity
5785  * computation)
5786  */
5788  SCIP_SET* set /**< global SCIP settings */
5789  )
5790 {
5791  assert(set != NULL);
5792 
5793  return set->num_hugeval;
5794 }
5795 
5796 /** returns value treated as zero */
5798  SCIP_SET* set /**< global SCIP settings */
5799  )
5800 {
5801  assert(set != NULL);
5802 
5803  return set->num_epsilon;
5804 }
5805 
5806 /** returns value treated as zero for sums of floating point values */
5808  SCIP_SET* set /**< global SCIP settings */
5809  )
5810 {
5811  assert(set != NULL);
5812 
5813  return set->num_sumepsilon;
5814 }
5815 
5816 /** returns feasibility tolerance for constraints */
5818  SCIP_SET* set /**< global SCIP settings */
5819  )
5820 {
5821  assert(set != NULL);
5822 
5823  return set->num_feastol;
5824 }
5825 
5826 /** returns feasibility tolerance for reduced costs */
5828  SCIP_SET* set /**< global SCIP settings */
5829  )
5830 {
5831  assert(set != NULL);
5832 
5833  return set->num_dualfeastol;
5834 }
5835 
5836 /** returns factor w.r.t. primal feasibility tolerance that determines default (and maximal) feasibility tolerance */
5838  SCIP_SET* set /**< global SCIP settings */
5839  )
5840 {
5841  return set->num_lpfeastolfactor;
5842 }
5843 
5844 /** returns convergence tolerance used in barrier algorithm */
5846  SCIP_SET* set /**< global SCIP settings */
5847  )
5848 {
5849  assert(set != NULL);
5850 
5851  return set->num_barrierconvtol;
5853 
5854 /** returns minimal variable distance value to use for pseudo cost updates */
5856  SCIP_SET* set /**< global SCIP settings */
5857  )
5858 {
5859  assert(set != NULL);
5860 
5861  return set->num_pseudocosteps;
5862 }
5863 
5864 /** returns minimal minimal objective distance value to use for pseudo cost updates */
5866  SCIP_SET* set /**< global SCIP settings */
5867  )
5868 {
5869  assert(set != NULL);
5870 
5871  return set->num_pseudocostdelta;
5872 }
5873 
5874 /** return the delta to use for computing the cutoff bound for integral objectives */
5876  SCIP_SET* set /**< global SCIP settings */
5877  )
5878 {
5879  SCIP_Real feastol;
5880 
5881  assert(set != NULL);
5882 
5883  feastol = SCIPsetFeastol(set);
5885  return MIN(100.0 * feastol, 0.0001);
5886 }
5887 
5888 /** return the primal feasibility tolerance for relaxations */
5890  SCIP_SET* set /**< global SCIP settings */
5891  )
5892 {
5893  assert(set != NULL);
5895  return set->num_relaxfeastol;
5896 }
5897 
5898 /** returns minimal decrease factor that causes the recomputation of a value
5899  * (e.g., pseudo objective) instead of an update */
5901  SCIP_SET* set /**< global SCIP settings */
5902  )
5903 {
5904  assert(set != NULL);
5905 
5906  return set->num_recompfac;
5907 }
5908 
5909 /** checks, if value is (positive) infinite */
5911  SCIP_SET* set, /**< global SCIP settings */
5912  SCIP_Real val /**< value to be compared against infinity */
5913  )
5915  assert(set != NULL);
5916 
5917  return (val >= set->num_infinity);
5918 }
5919 
5920 /** checks, if value is huge and should be handled separately (e.g., in activity computation) */
5922  SCIP_SET* set, /**< global SCIP settings */
5923  SCIP_Real val /**< value to be checked whether it is huge */
5924  )
5925 {
5926  assert(set != NULL);
5927 
5928  return (val >= set->num_hugeval);
5929 }
5930 
5931 /** checks, if values are in range of epsilon */
5933  SCIP_SET* set, /**< global SCIP settings */
5934  SCIP_Real val1, /**< first value to be compared */
5935  SCIP_Real val2 /**< second value to be compared */
5936  )
5937 {
5938  assert(set != NULL);
5939 
5940  /* avoid to compare two different infinities; the reason for that is
5941  * that such a comparison can lead to unexpected results */
5942  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
5943  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
5944  || val1 == val2 ); /*lint !e777*/
5945 
5946  return EPSEQ(val1, val2, set->num_epsilon);
5947 }
5948 
5949 /** checks, if val1 is (more than epsilon) lower than val2 */
5951  SCIP_SET* set, /**< global SCIP settings */
5952  SCIP_Real val1, /**< first value to be compared */
5953  SCIP_Real val2 /**< second value to be compared */
5954  )
5955 {
5956  assert(set != NULL);
5957 
5958  /* avoid to compare two different infinities; the reason for that is
5959  * that such a comparison can lead to unexpected results */
5960  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
5961  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
5962  || val1 == val2 ); /*lint !e777*/
5963 
5964  return EPSLT(val1, val2, set->num_epsilon);
5965 }
5967 /** checks, if val1 is not (more than epsilon) greater than val2 */
5969  SCIP_SET* set, /**< global SCIP settings */
5970  SCIP_Real val1, /**< first value to be compared */
5971  SCIP_Real val2 /**< second value to be compared */
5972  )
5973 {
5974  assert(set != NULL);
5975 
5976  /* avoid to compare two different infinities; the reason for that is
5977  * that such a comparison can lead to unexpected results */
5978  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
5979  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
5980  || val1 == val2 ); /*lint !e777*/
5981 
5982  return EPSLE(val1, val2, set->num_epsilon);
5983 }
5984 
5985 /** checks, if val1 is (more than epsilon) greater than val2 */
5987  SCIP_SET* set, /**< global SCIP settings */
5988  SCIP_Real val1, /**< first value to be compared */
5989  SCIP_Real val2 /**< second value to be compared */
5990  )
5991 {
5992  assert(set != NULL);
5993 
5994  /* avoid to compare two different infinities; the reason for that is
5995  * that such a comparison can lead to unexpected results */
5996  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
5997  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
5998  || val1 == val2 ); /*lint !e777*/
5999 
6000  return EPSGT(val1, val2, set->num_epsilon);
6001 }
6002 
6003 /** checks, if val1 is not (more than epsilon) lower than val2 */
6005  SCIP_SET* set, /**< global SCIP settings */
6006  SCIP_Real val1, /**< first value to be compared */
6007  SCIP_Real val2 /**< second value to be compared */
6008  )
6010  assert(set != NULL);
6011 
6012  /* avoid to compare two different infinities; the reason for that is
6013  * that such a comparison can lead to unexpected results */
6014  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6015  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6016  || val1 == val2 ); /*lint !e777*/
6017 
6018  return EPSGE(val1, val2, set->num_epsilon);
6019 }
6020 
6021 /** checks, if value is in range epsilon of 0.0 */
6023  SCIP_SET* set, /**< global SCIP settings */
6024  SCIP_Real val /**< value to process */
6025  )
6026 {
6027  assert(set != NULL);
6028 
6029  return EPSZ(val, set->num_epsilon);
6030 }
6031 
6032 /** checks, if value is greater than epsilon */
6034  SCIP_SET* set, /**< global SCIP settings */
6035  SCIP_Real val /**< value to process */
6036  )
6037 {
6038  assert(set != NULL);
6039 
6040  return EPSP(val, set->num_epsilon);
6041 }
6042 
6043 /** checks, if value is lower than -epsilon */
6045  SCIP_SET* set, /**< global SCIP settings */
6046  SCIP_Real val /**< value to process */
6047  )
6048 {
6049  assert(set != NULL);
6050 
6051  return EPSN(val, set->num_epsilon);
6052 }
6053 
6054 /** checks, if value is integral within epsilon */
6056  SCIP_SET* set, /**< global SCIP settings */
6057  SCIP_Real val /**< value to process */
6058  )
6059 {
6060  assert(set != NULL);
6061 
6062  return EPSISINT(val, set->num_epsilon);
6064 
6065 /** checks whether the product val * scalar is integral in epsilon scaled by scalar */
6067  SCIP_SET* set, /**< global SCIP settings */
6068  SCIP_Real val, /**< unscaled value to check for scaled integrality */
6069  SCIP_Real scalar /**< value to scale val with for checking for integrality */
6070  )
6071 {
6072  SCIP_Real scaledeps;
6073 
6074  assert(set != NULL);
6075 
6076  scaledeps = REALABS(scalar);
6077  scaledeps = MAX(scaledeps, 1.0);
6078  scaledeps *= set->num_epsilon;
6079 
6080  return EPSISINT(scalar*val, scaledeps);
6082 
6083 /** checks, if given fractional part is smaller than epsilon */
6085  SCIP_SET* set, /**< global SCIP settings */
6086  SCIP_Real val /**< value to process */
6087  )
6088 {
6089  assert(set != NULL);
6090  assert(SCIPsetIsGE(set, val, -set->num_epsilon));
6091  assert(SCIPsetIsLE(set, val, 1.0+set->num_epsilon));
6092 
6093  return (val <= set->num_epsilon);
6094 }
6095 
6096 /** rounds value + feasibility tolerance down to the next integer in epsilon tolerance */
6098  SCIP_SET* set, /**< global SCIP settings */
6099  SCIP_Real val /**< value to process */
6100  )
6101 {
6102  assert(set != NULL);
6103 
6104  return EPSFLOOR(val, set->num_epsilon);
6105 }
6106 
6107 /** rounds value - feasibility tolerance up to the next integer in epsilon tolerance */
6109  SCIP_SET* set, /**< global SCIP settings */
6110  SCIP_Real val /**< value to process */
6111  )
6112 {
6113  assert(set != NULL);
6114 
6115  return EPSCEIL(val, set->num_epsilon);
6116 }
6117 
6118 /** rounds value to the nearest integer in epsilon tolerance */
6120  SCIP_SET* set, /**< global SCIP settings */
6121  SCIP_Real val /**< value to process */
6122  )
6123 {
6124  assert(set != NULL);
6125 
6126  return EPSROUND(val, set->num_epsilon);
6127 }
6128 
6129 /** returns fractional part of value, i.e. x - floor(x) in epsilon tolerance */
6131  SCIP_SET* set, /**< global SCIP settings */
6132  SCIP_Real val /**< value to return fractional part for */
6133  )
6134 {
6135  assert(set != NULL);
6136 
6137  return EPSFRAC(val, set->num_epsilon);
6138 }
6139 
6140 /** checks, if values are in range of sumepsilon */
6142  SCIP_SET* set, /**< global SCIP settings */
6143  SCIP_Real val1, /**< first value to be compared */
6144  SCIP_Real val2 /**< second value to be compared */
6145  )
6146 {
6147  assert(set != NULL);
6148 
6149  /* avoid to compare two different infinities; the reason for that is
6150  * that such a comparison can lead to unexpected results */
6151  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6152  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6153  || val1 == val2 ); /*lint !e777*/
6154 
6155  return EPSEQ(val1, val2, set->num_sumepsilon);
6156 }
6157 
6158 /** checks, if val1 is (more than sumepsilon) lower than val2 */
6160  SCIP_SET* set, /**< global SCIP settings */
6161  SCIP_Real val1, /**< first value to be compared */
6162  SCIP_Real val2 /**< second value to be compared */
6163  )
6164 {
6165  assert(set != NULL);
6166 
6167  /* avoid to compare two different infinities; the reason for that is
6168  * that such a comparison can lead to unexpected results */
6169  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6170  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6171  || val1 == val2 ); /*lint !e777*/
6172 
6173  return EPSLT(val1, val2, set->num_sumepsilon);
6175 
6176 /** checks, if val1 is not (more than sumepsilon) greater than val2 */
6178  SCIP_SET* set, /**< global SCIP settings */
6179  SCIP_Real val1, /**< first value to be compared */
6180  SCIP_Real val2 /**< second value to be compared */
6181  )
6182 {
6183  assert(set != NULL);
6184 
6185  /* avoid to compare two different infinities; the reason for that is
6186  * that such a comparison can lead to unexpected results */
6187  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6188  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6189  || val1 == val2 ); /*lint !e777*/
6190 
6191  return EPSLE(val1, val2, set->num_sumepsilon);
6192 }
6193 
6194 /** checks, if val1 is (more than sumepsilon) greater than val2 */
6196  SCIP_SET* set, /**< global SCIP settings */
6197  SCIP_Real val1, /**< first value to be compared */
6198  SCIP_Real val2 /**< second value to be compared */
6199  )
6200 {
6201  assert(set != NULL);
6202 
6203  /* avoid to compare two different infinities; the reason for that is
6204  * that such a comparison can lead to unexpected results */
6205  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6206  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6207  || val1 == val2 ); /*lint !e777*/
6208 
6209  return EPSGT(val1, val2, set->num_sumepsilon);
6210 }
6211 
6212 /** checks, if val1 is not (more than sumepsilon) lower than val2 */
6214  SCIP_SET* set, /**< global SCIP settings */
6215  SCIP_Real val1, /**< first value to be compared */
6216  SCIP_Real val2 /**< second value to be compared */
6217  )
6219  assert(set != NULL);
6220 
6221  /* avoid to compare two different infinities; the reason for that is
6222  * that such a comparison can lead to unexpected results */
6223  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6224  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6225  || val1 == val2 ); /*lint !e777*/
6226 
6227  return EPSGE(val1, val2, set->num_sumepsilon);
6228 }
6229 
6230 /** checks, if value is in range sumepsilon of 0.0 */
6232  SCIP_SET* set, /**< global SCIP settings */
6233  SCIP_Real val /**< value to process */
6234  )
6235 {
6236  assert(set != NULL);
6237 
6238  return EPSZ(val, set->num_sumepsilon);
6239 }
6240 
6241 /** checks, if value is greater than sumepsilon */
6243  SCIP_SET* set, /**< global SCIP settings */
6244  SCIP_Real val /**< value to process */
6245  )
6246 {
6247  assert(set != NULL);
6248 
6249  return EPSP(val, set->num_sumepsilon);
6250 }
6251 
6252 /** checks, if value is lower than -sumepsilon */
6254  SCIP_SET* set, /**< global SCIP settings */
6255  SCIP_Real val /**< value to process */
6256  )
6257 {
6258  assert(set != NULL);
6259 
6260  return EPSN(val, set->num_sumepsilon);
6261 }
6262 
6263 /** rounds value + sumepsilon tolerance down to the next integer */
6265  SCIP_SET* set, /**< global SCIP settings */
6266  SCIP_Real val /**< value to process */
6267  )
6268 {
6269  assert(set != NULL);
6270 
6271  return EPSFLOOR(val, set->num_sumepsilon);
6273 
6274 /** rounds value - sumepsilon tolerance up to the next integer */
6276  SCIP_SET* set, /**< global SCIP settings */
6277  SCIP_Real val /**< value to process */
6278  )
6279 {
6280  assert(set != NULL);
6281 
6282  return EPSCEIL(val, set->num_sumepsilon);
6283 }
6284 
6285 /** rounds value to the nearest integer in sumepsilon tolerance */
6287  SCIP_SET* set, /**< global SCIP settings */
6288  SCIP_Real val /**< value to process */
6289  )
6291  assert(set != NULL);
6292 
6293  return EPSROUND(val, set->num_sumepsilon);
6294 }
6295 
6296 /** returns fractional part of value, i.e. x - floor(x) in sumepsilon tolerance */
6298  SCIP_SET* set, /**< global SCIP settings */
6299  SCIP_Real val /**< value to process */
6300  )
6301 {
6302  assert(set != NULL);
6303 
6304  return EPSFRAC(val, set->num_sumepsilon);
6305 }
6306 
6307 /** checks, if relative difference of values is in range of feastol */
6309  SCIP_SET* set, /**< global SCIP settings */
6310  SCIP_Real val1, /**< first value to be compared */
6311  SCIP_Real val2 /**< second value to be compared */
6312  )
6313 {
6314  SCIP_Real diff;
6315 
6316  assert(set != NULL);
6317 
6318  /* avoid to compare two different infinities; the reason for that is
6319  * that such a comparison can lead to unexpected results */
6320  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6321  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6322  || val1 == val2 ); /*lint !e777*/
6323 
6324  diff = SCIPrelDiff(val1, val2);
6325 
6326  return EPSZ(diff, set->num_feastol);
6327 }
6328 
6329 /** checks, if relative difference of val1 and val2 is lower than feastol */
6331  SCIP_SET* set, /**< global SCIP settings */
6332  SCIP_Real val1, /**< first value to be compared */
6333  SCIP_Real val2 /**< second value to be compared */
6334  )
6335 {
6336  SCIP_Real diff;
6337 
6338  assert(set != NULL);
6339 
6340  /* avoid to compare two different infinities; the reason for that is
6341  * that such a comparison can lead to unexpected results */
6342  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6343  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6344  || val1 == val2 ); /*lint !e777*/
6345 
6346  diff = SCIPrelDiff(val1, val2);
6347 
6348  return EPSN(diff, set->num_feastol);
6349 }
6350 
6351 /** checks, if relative difference of val1 and val2 is not greater than feastol */
6353  SCIP_SET* set, /**< global SCIP settings */
6354  SCIP_Real val1, /**< first value to be compared */
6355  SCIP_Real val2 /**< second value to be compared */
6356  )
6357 {
6358  SCIP_Real diff;
6359 
6360  assert(set != NULL);
6361 
6362  /* avoid to compare two different infinities; the reason for that is
6363  * that such a comparison can lead to unexpected results */
6364  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6365  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6366  || val1 == val2 ); /*lint !e777*/
6367 
6368  diff = SCIPrelDiff(val1, val2);
6369 
6370  return !EPSP(diff, set->num_feastol);
6371 }
6372 
6373 /** checks, if relative difference of val1 and val2 is greater than feastol */
6375  SCIP_SET* set, /**< global SCIP settings */
6376  SCIP_Real val1, /**< first value to be compared */
6377  SCIP_Real val2 /**< second value to be compared */
6378  )
6379 {
6380  SCIP_Real diff;
6381 
6382  assert(set != NULL);
6383 
6384  /* avoid to compare two different infinities; the reason for that is
6385  * that such a comparison can lead to unexpected results */
6386  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6387  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6388  || val1 == val2 ); /*lint !e777*/
6389 
6390  diff = SCIPrelDiff(val1, val2);
6391 
6392  return EPSP(diff, set->num_feastol);
6393 }
6394 
6395 /** checks, if relative difference of val1 and val2 is not lower than -feastol */
6397  SCIP_SET* set, /**< global SCIP settings */
6398  SCIP_Real val1, /**< first value to be compared */
6399  SCIP_Real val2 /**< second value to be compared */
6400  )
6401 {
6402  SCIP_Real diff;
6403 
6404  assert(set != NULL);
6405 
6406  /* avoid to compare two different infinities; the reason for that is
6407  * that such a comparison can lead to unexpected results */
6408  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6409  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6410  || val1 == val2 ); /*lint !e777*/
6411 
6412  diff = SCIPrelDiff(val1, val2);
6413 
6414  return !EPSN(diff, set->num_feastol);
6415 }
6416 
6417 /** checks, if value is in range feasibility tolerance of 0.0 */
6419  SCIP_SET* set, /**< global SCIP settings */
6420  SCIP_Real val /**< value to process */
6421  )
6422 {
6423  assert(set != NULL);
6424 
6425  return EPSZ(val, set->num_feastol);
6426 }
6427 
6428 /** checks, if value is greater than feasibility tolerance */
6430  SCIP_SET* set, /**< global SCIP settings */
6431  SCIP_Real val /**< value to process */
6432  )
6433 {
6434  assert(set != NULL);
6435 
6436  return EPSP(val, set->num_feastol);
6437 }
6438 
6439 /** checks, if value is lower than -feasibility tolerance */
6441  SCIP_SET* set, /**< global SCIP settings */
6442  SCIP_Real val /**< value to process */
6443  )
6444 {
6445  assert(set != NULL);
6446 
6447  return EPSN(val, set->num_feastol);
6448 }
6449 
6450 /** checks, if value is integral within the feasibility bounds */
6452  SCIP_SET* set, /**< global SCIP settings */
6453  SCIP_Real val /**< value to process */
6454  )
6455 {
6456  assert(set != NULL);
6457 
6458  return EPSISINT(val, set->num_feastol);
6459 }
6460 
6461 /** checks, if given fractional part is smaller than feastol */
6463  SCIP_SET* set, /**< global SCIP settings */
6464  SCIP_Real val /**< value to process */
6465  )
6466 {
6467  assert(set != NULL);
6468  assert(SCIPsetIsGE(set, val, -2*set->num_feastol));
6469  assert(SCIPsetIsLE(set, val, 1.0+set->num_feastol));
6470 
6471  return (val <= set->num_feastol);
6472 }
6474 /** rounds value + feasibility tolerance down to the next integer in feasibility tolerance */
6476  SCIP_SET* set, /**< global SCIP settings */
6477  SCIP_Real val /**< value to process */
6478  )
6479 {
6480  assert(set != NULL);
6481 
6482  return EPSFLOOR(val, set->num_feastol);
6483 }
6484 
6485 /** rounds value - feasibility tolerance up to the next integer in feasibility tolerance */
6487  SCIP_SET* set, /**< global SCIP settings */
6488  SCIP_Real val /**< value to process */
6489  )
6490 {
6491  assert(set != NULL);
6492 
6493  return EPSCEIL(val, set->num_feastol);
6494 }
6496 /** rounds value to the nearest integer in feasibility tolerance */
6498  SCIP_SET* set, /**< global SCIP settings */
6499  SCIP_Real val /**< value to process */
6500  )
6501 {
6502  assert(set != NULL);
6503 
6504  return EPSROUND(val, set->num_feastol);
6505 }
6507 /** returns fractional part of value, i.e. x - floor(x) in feasibility tolerance */
6509  SCIP_SET* set, /**< global SCIP settings */
6510  SCIP_Real val /**< value to process */
6511  )
6512 {
6513  assert(set != NULL);
6514 
6515  return EPSFRAC(val, set->num_feastol);
6516 }
6518 /** checks, if relative difference of values is in range of dual feasibility tolerance */
6520  SCIP_SET* set, /**< global SCIP settings */
6521  SCIP_Real val1, /**< first value to be compared */
6522  SCIP_Real val2 /**< second value to be compared */
6523  )
6524 {
6525  SCIP_Real diff;
6526 
6527  assert(set != NULL);
6529  /* avoid to compare two different infinities; the reason for that is
6530  * that such a comparison can lead to unexpected results */
6531  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6532  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6533  || val1 == val2 ); /*lint !e777*/
6534 
6535  diff = SCIPrelDiff(val1, val2);
6536 
6537  return EPSZ(diff, set->num_dualfeastol);
6538 }
6540 /** checks, if relative difference of val1 and val2 is lower than dual feasibility tolerance */
6542  SCIP_SET* set, /**< global SCIP settings */
6543  SCIP_Real val1, /**< first value to be compared */
6544  SCIP_Real val2 /**< second value to be compared */
6545  )
6546 {
6547  SCIP_Real diff;
6548 
6549  assert(set != NULL);
6550 
6551  /* avoid to compare two different infinities; the reason for that is
6552  * that such a comparison can lead to unexpected results */
6553  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6554  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6555  || val1 == val2 ); /*lint !e777*/
6556 
6557  diff = SCIPrelDiff(val1, val2);
6558 
6559  return EPSN(diff, set->num_dualfeastol);
6560 }
6561 
6562 /** checks, if relative difference of val1 and val2 is not greater than dual feasibility tolerance */
6564  SCIP_SET* set, /**< global SCIP settings */
6565  SCIP_Real val1, /**< first value to be compared */
6566  SCIP_Real val2 /**< second value to be compared */
6567  )
6568 {
6569  SCIP_Real diff;
6570 
6571  assert(set != NULL);
6572 
6573  /* avoid to compare two different infinities; the reason for that is
6574  * that such a comparison can lead to unexpected results */
6575  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6576  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6577  || val1 == val2 ); /*lint !e777*/
6578 
6579  diff = SCIPrelDiff(val1, val2);
6580 
6581  return !EPSP(diff, set->num_dualfeastol);
6582 }
6583 
6584 /** checks, if relative difference of val1 and val2 is greater than dual feasibility tolerance */
6586  SCIP_SET* set, /**< global SCIP settings */
6587  SCIP_Real val1, /**< first value to be compared */
6588  SCIP_Real val2 /**< second value to be compared */
6589  )
6590 {
6591  SCIP_Real diff;
6592 
6593  assert(set != NULL);
6594 
6595  /* avoid to compare two different infinities; the reason for that is
6596  * that such a comparison can lead to unexpected results */
6597  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6598  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6599  || val1 == val2 ); /*lint !e777*/
6600 
6601  diff = SCIPrelDiff(val1, val2);
6602 
6603  return EPSP(diff, set->num_dualfeastol);
6604 }
6605 
6606 /** checks, if relative difference of val1 and val2 is not lower than -dual feasibility tolerance */
6608  SCIP_SET* set, /**< global SCIP settings */
6609  SCIP_Real val1, /**< first value to be compared */
6610  SCIP_Real val2 /**< second value to be compared */
6611  )
6612 {
6613  SCIP_Real diff;
6614 
6615  assert(set != NULL);
6616 
6617  /* avoid to compare two different infinities; the reason for that is
6618  * that such a comparison can lead to unexpected results */
6619  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6620  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6621  || val1 == val2 ); /*lint !e777*/
6622 
6623  diff = SCIPrelDiff(val1, val2);
6624 
6625  return !EPSN(diff, set->num_dualfeastol);
6626 }
6627 
6628 /** checks, if value is in range feasibility tolerance of 0.0 */
6630  SCIP_SET* set, /**< global SCIP settings */
6631  SCIP_Real val /**< value to process */
6632  )
6633 {
6634  assert(set != NULL);
6635 
6636  return EPSZ(val, set->num_dualfeastol);
6637 }
6638 
6639 /** checks, if value is greater than dual feasibility tolerance */
6641  SCIP_SET* set, /**< global SCIP settings */
6642  SCIP_Real val /**< value to process */
6643  )
6644 {
6645  assert(set != NULL);
6646 
6647  return EPSP(val, set->num_dualfeastol);
6648 }
6649 
6650 /** checks, if value is lower than -dual feasibility tolerance */
6652  SCIP_SET* set, /**< global SCIP settings */
6653  SCIP_Real val /**< value to process */
6654  )
6655 {
6656  assert(set != NULL);
6657 
6658  return EPSN(val, set->num_dualfeastol);
6659 }
6660 
6661 /** checks, if value is integral within the dual feasibility bounds */
6663  SCIP_SET* set, /**< global SCIP settings */
6664  SCIP_Real val /**< value to process */
6665  )
6666 {
6667  assert(set != NULL);
6668 
6669  return EPSISINT(val, set->num_dualfeastol);
6670 }
6671 
6672 /** checks, if given fractional part is smaller than dual feasibility tolerance */
6674  SCIP_SET* set, /**< global SCIP settings */
6675  SCIP_Real val /**< value to process */
6676  )
6677 {
6678  assert(set != NULL);
6679  assert(SCIPsetIsGE(set, val, -set->num_dualfeastol));
6680  assert(SCIPsetIsLE(set, val, 1.0+set->num_dualfeastol));
6681 
6682  return (val <= set->num_dualfeastol);
6683 }
6685 /** rounds value + dual feasibility tolerance down to the next integer */
6687  SCIP_SET* set, /**< global SCIP settings */
6688  SCIP_Real val /**< value to process */
6689  )
6690 {
6691  assert(set != NULL);
6692 
6693  return EPSFLOOR(val, set->num_dualfeastol);
6694 }
6695 
6696 /** rounds value - dual feasibility tolerance up to the next integer */
6698  SCIP_SET* set, /**< global SCIP settings */
6699  SCIP_Real val /**< value to process */
6700  )
6701 {
6702  assert(set != NULL);
6703 
6704  return EPSCEIL(val, set->num_dualfeastol);
6705 }
6707 /** rounds value to the nearest integer in dual feasibility tolerance */
6709  SCIP_SET* set, /**< global SCIP settings */
6710  SCIP_Real val /**< value to process */
6711  )
6712 {
6713  assert(set != NULL);
6714 
6715  return EPSROUND(val, set->num_dualfeastol);
6716 }
6718 /** returns fractional part of value, i.e. x - floor(x) in dual feasibility tolerance */
6720  SCIP_SET* set, /**< global SCIP settings */
6721  SCIP_Real val /**< value to process */
6722  )
6723 {
6724  assert(set != NULL);
6725 
6726  return EPSFRAC(val, set->num_dualfeastol);
6727 }
6729 /** checks, if the given new lower bound is at least min(oldub - oldlb, |oldlb|) times the bound
6730  * strengthening epsilon better than the old one or the change in the lower bound would fix the
6731  * sign of the variable
6732  */
6734  SCIP_SET* set, /**< global SCIP settings */
6735  SCIP_Real newlb, /**< new lower bound */
6736  SCIP_Real oldlb, /**< old lower bound */
6737  SCIP_Real oldub /**< old upper bound */
6738  )
6740  assert(set != NULL);
6741  assert(SCIPsetIsLE(set, oldlb, oldub));
6742 
6743  /* if lower bound is moved to 0 or higher, always accept bound change */
6744  if( oldlb < 0.0 && newlb >= 0.0 )
6745  return TRUE;
6746 
6747  return EPSGT(newlb, oldlb, set->num_boundstreps * MAX(MIN(oldub - oldlb, REALABS(oldlb)), 1e-3)); /*lint !e666*/
6748 }
6749 
6750 /** checks, if the given new upper bound is at least min(oldub - oldlb, |oldub|) times the bound
6751  * strengthening epsilon better than the old one or the change in the upper bound would fix the
6752  * sign of the variable
6753  */
6755  SCIP_SET* set, /**< global SCIP settings */
6756  SCIP_Real newub, /**< new upper bound */
6757  SCIP_Real oldlb, /**< old lower bound */
6758  SCIP_Real oldub /**< old upper bound */
6759  )
6760 {
6761  assert(set != NULL);
6762  assert(SCIPsetIsLE(set, oldlb, oldub));
6764  /* if upper bound is moved to 0 or lower, always accept bound change */
6765  if( oldub > 0.0 && newub <= 0.0 )
6766  return TRUE;
6767 
6768  return EPSLT(newub, oldub, set->num_boundstreps * MAX(MIN(oldub - oldlb, REALABS(oldub)), 1e-3)); /*lint !e666*/
6769 }
6770 
6771 /** checks, if the given cut's efficacy is larger than the minimal cut efficacy */
6773  SCIP_SET* set, /**< global SCIP settings */
6774  SCIP_Bool root, /**< should the root's minimal cut efficacy be used? */
6775  SCIP_Real efficacy /**< efficacy of the cut */
6776  )
6777 {
6778  assert(set != NULL);
6779 
6780  if( root )
6781  return EPSP(efficacy, set->sepa_minefficacyroot);
6782  else
6783  return EPSP(efficacy, set->sepa_minefficacy);
6784 }
6786 /** checks, if relative difference of values is in range of epsilon */
6788  SCIP_SET* set, /**< global SCIP settings */
6789  SCIP_Real val1, /**< first value to be compared */
6790  SCIP_Real val2 /**< second value to be compared */
6791  )
6792 {
6793  SCIP_Real diff;
6794 
6795  assert(set != NULL);
6797  /* avoid to compare two different infinities; the reason for that is
6798  * that such a comparison can lead to unexpected results */
6799  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6800  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6801  || val1 == val2 ); /*lint !e777*/
6802 
6803  diff = SCIPrelDiff(val1, val2);
6804 
6805  return EPSZ(diff, set->num_epsilon);
6806 }
6807 
6808 /** checks, if relative difference of val1 and val2 is lower than epsilon */
6810  SCIP_SET* set, /**< global SCIP settings */
6811  SCIP_Real val1, /**< first value to be compared */
6812  SCIP_Real val2 /**< second value to be compared */
6813  )
6814 {
6815  SCIP_Real diff;
6816 
6817  assert(set != NULL);
6818 
6819  /* avoid to compare two different infinities; the reason for that is
6820  * that such a comparison can lead to unexpected results */
6821  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6822  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6823  || val1 == val2 ); /*lint !e777*/
6824 
6825  diff = SCIPrelDiff(val1, val2);
6826 
6827  return EPSN(diff, set->num_epsilon);
6828 }
6829 
6830 /** checks, if relative difference of val1 and val2 is not greater than epsilon */
6832  SCIP_SET* set, /**< global SCIP settings */
6833  SCIP_Real val1, /**< first value to be compared */
6834  SCIP_Real val2 /**< second value to be compared */
6835  )
6836 {
6837  SCIP_Real diff;
6838 
6839  assert(set != NULL);
6840 
6841  /* avoid to compare two different infinities; the reason for that is
6842  * that such a comparison can lead to unexpected results */
6843  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6844  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6845  || val1 == val2 ); /*lint !e777*/
6846 
6847  diff = SCIPrelDiff(val1, val2);
6848 
6849  return !EPSP(diff, set->num_epsilon);
6850 }
6851 
6852 /** checks, if relative difference of val1 and val2 is greater than epsilon */
6854  SCIP_SET* set, /**< global SCIP settings */
6855  SCIP_Real val1, /**< first value to be compared */
6856  SCIP_Real val2 /**< second value to be compared */
6857  )
6858 {
6859  SCIP_Real diff;
6860 
6861  assert(set != NULL);
6862 
6863  /* avoid to compare two different infinities; the reason for that is
6864  * that such a comparison can lead to unexpected results */
6865  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6866  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6867  || val1 == val2 ); /*lint !e777*/
6868 
6869  diff = SCIPrelDiff(val1, val2);
6870 
6871  return EPSP(diff, set->num_epsilon);
6872 }
6873 
6874 /** checks, if relative difference of val1 and val2 is not lower than -epsilon */
6876  SCIP_SET* set, /**< global SCIP settings */
6877  SCIP_Real val1, /**< first value to be compared */
6878  SCIP_Real val2 /**< second value to be compared */
6879  )
6880 {
6881  SCIP_Real diff;
6882 
6883  assert(set != NULL);
6884 
6885  /* avoid to compare two different infinities; the reason for that is
6886  * that such a comparison can lead to unexpected results */
6887  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6888  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6889  || val1 == val2 ); /*lint !e777*/
6890 
6891  diff = SCIPrelDiff(val1, val2);
6892 
6893  return !EPSN(diff, set->num_epsilon);
6894 }
6895 
6896 /** checks, if relative difference of values is in range of sumepsilon */
6898  SCIP_SET* set, /**< global SCIP settings */
6899  SCIP_Real val1, /**< first value to be compared */
6900  SCIP_Real val2 /**< second value to be compared */
6901  )
6902 {
6903  SCIP_Real diff;
6904 
6905  assert(set != NULL);
6906 
6907  /* avoid to compare two different infinities; the reason for that is
6908  * that such a comparison can lead to unexpected results */
6909  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6910  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6911  || val1 == val2 ); /*lint !e777*/
6912 
6913  diff = SCIPrelDiff(val1, val2);
6914 
6915  return EPSZ(diff, set->num_sumepsilon);
6916 }
6917 
6918 /** checks, if relative difference of val1 and val2 is lower than sumepsilon */
6920  SCIP_SET* set, /**< global SCIP settings */
6921  SCIP_Real val1, /**< first value to be compared */
6922  SCIP_Real val2 /**< second value to be compared */
6923  )
6924 {
6925  SCIP_Real diff;
6926 
6927  assert(set != NULL);
6928 
6929  /* avoid to compare two different infinities; the reason for that is
6930  * that such a comparison can lead to unexpected results */
6931  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6932  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6933  || val1 == val2 ); /*lint !e777*/
6934 
6935  diff = SCIPrelDiff(val1, val2);
6936 
6937  return EPSN(diff, set->num_sumepsilon);
6938 }
6939 
6940 /** checks, if relative difference of val1 and val2 is not greater than sumepsilon */
6942  SCIP_SET* set, /**< global SCIP settings */
6943  SCIP_Real val1, /**< first value to be compared */
6944  SCIP_Real val2 /**< second value to be compared */
6945  )
6946 {
6947  SCIP_Real diff;
6948 
6949  assert(set != NULL);
6950 
6951  /* avoid to compare two different infinities; the reason for that is
6952  * that such a comparison can lead to unexpected results */
6953  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6954  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6955  || val1 == val2 ); /*lint !e777*/
6956 
6957  diff = SCIPrelDiff(val1, val2);
6958 
6959  return !EPSP(diff, set->num_sumepsilon);
6960 }
6961 
6962 /** checks, if relative difference of val1 and val2 is greater than sumepsilon */
6964  SCIP_SET* set, /**< global SCIP settings */
6965  SCIP_Real val1, /**< first value to be compared */
6966  SCIP_Real val2 /**< second value to be compared */
6967  )
6968 {
6969  SCIP_Real diff;
6970 
6971  assert(set != NULL);
6972 
6973  /* avoid to compare two different infinities; the reason for that is
6974  * that such a comparison can lead to unexpected results */
6975  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6976  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6977  || val1 == val2 ); /*lint !e777*/
6978 
6979  diff = SCIPrelDiff(val1, val2);
6980 
6981  return EPSP(diff, set->num_sumepsilon);
6982 }
6983 
6984 /** checks, if relative difference of val1 and val2 is not lower than -sumepsilon */
6986  SCIP_SET* set, /**< global SCIP settings */
6987  SCIP_Real val1, /**< first value to be compared */
6988  SCIP_Real val2 /**< second value to be compared */
6989  )
6990 {
6991  SCIP_Real diff;
6992 
6993  assert(set != NULL);
6994 
6995  /* avoid to compare two different infinities; the reason for that is
6996  * that such a comparison can lead to unexpected results */
6997  assert( ((!SCIPsetIsInfinity(set, val1) || !SCIPsetIsInfinity(set, val2))
6998  && (!SCIPsetIsInfinity(set, -val1) || !SCIPsetIsInfinity(set, -val2)))
6999  || val1 == val2 ); /*lint !e777*/
7000 
7001  diff = SCIPrelDiff(val1, val2);
7002 
7003  return !EPSN(diff, set->num_sumepsilon);
7004 }
7005 
7006 /** returns the flag indicating whether sub-SCIPs that could cause recursion have been deactivated */
7008  SCIP_SET* set /**< global SCIP settings */
7009  )
7010 {
7011  assert(set != NULL);
7012 
7013  return set->subscipsoff;
7014 }
7015 
7016 /** Checks, if an iteratively updated value is reliable or should be recomputed from scratch.
7017  * This is useful, if the value, e.g., the activity of a linear constraint or the pseudo objective value, gets a high
7018  * absolute value during the optimization process which is later reduced significantly. In this case, the last digits
7019  * were canceled out when increasing the value and are random after decreasing it.
7020  * We dot not consider the cancellations which can occur during increasing the absolute value because they just cannot
7021  * be expressed using fixed precision floating point arithmetic, anymore.
7022  * The idea to get more reliable values is to always store the last reliable value, where increasing the absolute of
7023  * the value is viewed as preserving reliability. Then, after each update, the new absolute value can be compared
7024  * against the last reliable one with this method, checking whether it was decreased by a factor of at least
7025  * "lp/recompfac" and should be recomputed.
7026  */
7028  SCIP_SET* set, /**< global SCIP settings */
7029  SCIP_Real newvalue, /**< new value after update */
7030  SCIP_Real oldvalue /**< old value, i.e., last reliable value */
7031  )
7032 {
7033  SCIP_Real quotient;
7034 
7035  assert(set != NULL);
7036 
7037  quotient = ABS(oldvalue) / MAX(ABS(newvalue), set->num_epsilon);
7038 
7039  return quotient >= set->num_recompfac;
7041 
7042 /** prints a debug message */
7044  SCIP_SET* set, /**< global SCIP settings */
7045  const char* sourcefile, /**< name of the source file that called the function */
7046  int sourceline, /**< line in the source file where the function was called */
7047  const char* formatstr, /**< format string like in printf() function */
7048  ... /**< format arguments line in printf() function */
7049  )
7050 {
7051  int subscipdepth = 0;
7052  SCIP* scip;
7053  va_list ap;
7054 
7055  assert( sourcefile != NULL );
7056  assert( set != NULL );
7057 
7058  scip = set->scip;
7059  assert( scip != NULL );
7060 
7061  if ( scip->stat != NULL )
7062  subscipdepth = scip->stat->subscipdepth;
7063 
7064  if ( subscipdepth > 0 )
7065  SCIPmessageFPrintInfo(scip->messagehdlr, NULL, "%d: [%s:%d] debug: ", subscipdepth, sourcefile, sourceline);
7066  else
7067  SCIPmessageFPrintInfo(scip->messagehdlr, NULL, "[%s:%d] debug: ", sourcefile, sourceline);
7068 
7069  va_start(ap, formatstr); /*lint !e838*/
7070  SCIPmessageVFPrintInfo(scip->messagehdlr, NULL, formatstr, ap);
7071  va_end(ap);
7072 }
7073 
7074 /** prints a debug message without precode */
7076  SCIP_SET* set, /**< global SCIP settings */
7077  const char* formatstr, /**< format string like in printf() function */
7078  ... /**< format arguments line in printf() function */
7079  )
7080 {
7081  va_list ap;
7082 
7083  assert( set != NULL );
7084  assert( set->scip != NULL );
7085 
7086  va_start(ap, formatstr); /*lint !e838*/
7087  SCIPmessageVFPrintInfo(set->scip->messagehdlr, NULL, formatstr, ap);
7088  va_end(ap);
7089 }
7090 
7091 /** modifies an initial seed value with the global shift of random seeds */
7092 unsigned int SCIPsetInitializeRandomSeed(
7093  SCIP_SET* set, /**< global SCIP settings */
7094  unsigned int initialseedvalue /**< initial seed value to be modified */
7095  )
7096 {
7097  assert(set != NULL);
7098 
7099  return (unsigned int)(initialseedvalue + (unsigned) set->random_randomseedshift);
7100 }
SCIP_RETCODE SCIPsetInitprePlugins(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_STAT *stat)
Definition: set.c:5306
SCIP_RETCODE SCIPsetIncludePresol(SCIP_SET *set, SCIP_PRESOL *presol)
Definition: set.c:4051
void SCIPpricerEnableOrDisableClocks(SCIP_PRICER *pricer, SCIP_Bool enable)
Definition: pricer.c:672
SCIP_Real SCIPsetFeasRound(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6574
internal methods for separators
SCIP_Bool SCIPsetIsUpdateUnreliable(SCIP_SET *set, SCIP_Real newvalue, SCIP_Real oldvalue)
Definition: set.c:7104
SCIP_RETCODE SCIPsetExitsolPlugins(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_STAT *stat, SCIP_Bool restart)
Definition: set.c:5485
#define SCIP_DEFAULT_SEPA_MINORTHO
Definition: set.c:484
SCIP_STAT * stat
Definition: struct_scip.h:70
void SCIPsetSortPropsName(SCIP_SET *set)
Definition: set.c:4349
#define SCIP_DEFAULT_DISP_LPINFO
Definition: set.c:192
int ndisps
Definition: struct_set.h:124
SCIP_RETCODE SCIPsetSetEmphasis(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMEMPHASIS paramemphasis, SCIP_Bool quiet)
Definition: set.c:3529
SCIP_RETCODE SCIPparamsetFix(SCIP_PARAMSET *paramset, const char *name, SCIP_Bool fixed)
Definition: paramset.c:1907
SCIP_RETCODE SCIPpricerInit(SCIP_PRICER *pricer, SCIP_SET *set)
Definition: pricer.c:225
#define SCIP_DEFAULT_BRANCH_FIRSTSBCHILD
Definition: set.c:84
SCIP_Real SCIPfeastol(SCIP *scip)
#define SCIP_DEFAULT_PRESOL_MAXROUNDS
Definition: set.c:358
SCIP_RETCODE SCIPreaderCopyInclude(SCIP_READER *reader, SCIP_SET *set)
Definition: reader.c:49
SCIP_EXPORT const char * SCIPreaderGetName(SCIP_READER *reader)
Definition: reader.c:548
#define SCIP_DEFAULT_BRANCH_ROUNDSBSOL
Definition: set.c:86
SCIP_RETCODE SCIPpropExitpre(SCIP_PROP *prop, SCIP_SET *set)
Definition: prop.c:437
SCIP_RETCODE SCIPsetIncludeEventhdlr(SCIP_SET *set, SCIP_EVENTHDLR *eventhdlr)
Definition: set.c:4643
void SCIPlpResetFeastol(SCIP_LP *lp, SCIP_SET *set)
Definition: lp.c:10250
SCIP_RETCODE SCIPparamsetAddChar(SCIP_PARAMSET *paramset, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, char *valueptr, SCIP_Bool isadvanced, char defaultvalue, const char *allowedvalues, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: paramset.c:1607
SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)
Definition: set.c:5987
SCIP_Bool SCIPsetIsSumGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6290
SCIP_RETCODE SCIPpropInitsol(SCIP_PROP *prop, SCIP_SET *set)
Definition: prop.c:461
SCIP_RETCODE SCIPdispInit(SCIP_DISP *disp, SCIP_SET *set)
Definition: disp.c:205
#define SCIP_DEFAULT_VISUAL_BAKFILENAME
Definition: set.c:561
SCIP_EXPORT SCIP_Real SCIPlpiInfinity(SCIP_LPI *lpi)
Definition: lpi_clp.cpp:3893
#define SCIP_DEFAULT_LP_CLEANUPCOLS
Definition: set.c:256
internal methods for managing events
SCIP_Bool SCIPconshdlrNeedsCons(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5106
SCIP_RETCODE SCIPparamsetWrite(SCIP_PARAMSET *paramset, SCIP_MESSAGEHDLR *messagehdlr, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
Definition: paramset.c:2613
SCIP_READER ** readers
Definition: struct_set.h:68
#define SCIP_DEFAULT_BRANCH_DELAYPSCOST
Definition: set.c:79
SCIP_Bool SCIPsetIsLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6045
SCIP_Bool SCIPsetIsFeasZero(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6495
void SCIPsepaEnableOrDisableClocks(SCIP_SEPA *sepa, SCIP_Bool enable)
Definition: sepa.c:782
#define SCIP_DEFAULT_LP_LEXDUALMAXROUNDS
Definition: set.c:271
int nnodesels
Definition: struct_set.h:120
#define SCIP_DEFAULT_PRESOL_DONOTAGGR
Definition: set.c:374
static int calcGrowSize(int initsize, SCIP_Real growfac, int num)
Definition: set.c:590
const char * SCIPheurGetName(SCIP_HEUR *heur)
Definition: heur.c:1429
#define SCIP_DEFAULT_BRANCH_MIDPULLRELDOMTRIG
Definition: set.c:77
#define SCIP_DEFAULT_SEPA_MAXROUNDSROOTSUBRUN
Definition: set.c:499
void SCIPnodeselEnableOrDisableClocks(SCIP_NODESEL *nodesel, SCIP_Bool enable)
Definition: nodesel.c:1210
#define SCIP_DEFAULT_CONF_CLEANBNDDEPEND
Definition: set.c:131
#define SCIP_DEFAULT_REOPT_ENABLE
Definition: set.c:426
SCIP_RETCODE SCIPsetIncludeConcsolver(SCIP_SET *set, SCIP_CONCSOLVER *concsolver)
Definition: set.c:4449
#define BMSfreeMemoryArrayNull(ptr)
Definition: memory.h:140
SCIP_RETCODE SCIPdispInitsol(SCIP_DISP *disp, SCIP_SET *set)
Definition: disp.c:253
SCIP_RETCODE SCIPpresolInit(SCIP_PRESOL *presol, SCIP_SET *set)
Definition: presol.c:230
#define SCIP_DEFAULT_MISC_USESMALLTABLES
Definition: set.c:307
#define SCIP_DEFAULT_CONF_USEINFLP
Definition: set.c:106
SCIP_RETCODE SCIPtableInitsol(SCIP_TABLE *table, SCIP_SET *set)
Definition: table.c:227
#define SCIP_DEFAULT_CONF_MAXLPLOOPS
Definition: set.c:99
SCIP_CONFLICTHDLR ** conflicthdlrs
Definition: struct_set.h:74
#define SCIP_DEFAULT_VISUAL_OBJEXTERN
Definition: set.c:565
#define SCIP_DEFAULT_MISC_REFERENCEVALUE
Definition: set.c:328
void SCIPsetPrintDebugMessage(SCIP_SET *set, const char *sourcefile, int sourceline, const char *formatstr,...)
Definition: set.c:7120
#define SCIP_DEFAULT_MISC_FINITESOLSTORE
Definition: set.c:324
SCIP_Bool SCIPsetIsSumZero(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6308
SCIP_RETCODE SCIPconshdlrExit(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2502
SCIP_NLPI * SCIPsetFindNlpi(SCIP_SET *set, const char *name)
Definition: set.c:5013
#define SCIP_DEFAULT_LIMIT_SOLUTIONS
Definition: set.c:218
SCIP_Real SCIPsetFeastol(SCIP_SET *set)
Definition: set.c:5894
#define SCIP_DEFAULT_CONCURRENT_MAXNSYNCDELAY
Definition: set.c:543
#define SCIP_DEFAULT_READ_DYNAMICCOLS
Definition: set.c:572
#define SCIP_DEFAULT_REOPT_SAVECONSPROP
Definition: set.c:451
SCIP_Bool SCIPsetIsDualfeasEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6596
#define SCIP_DEFAULT_MEM_TREEGROWINIT
Definition: set.c:298
SCIP_PRICER * SCIPsetFindPricer(SCIP_SET *set, const char *name)
Definition: set.c:3695
SCIP_TABLE * SCIPsetFindTable(SCIP_SET *set, const char *name)
Definition: set.c:4926
unsigned int SCIPsetInitializeRandomSeed(SCIP_SET *set, unsigned int initialseedvalue)
Definition: set.c:7169
SCIP_RETCODE SCIPdispAutoActivate(SCIP_SET *set)
Definition: disp.c:492
#define SCIP_DEFAULT_CONF_RESTARTNUM
Definition: set.c:156
#define SCIP_DEFAULT_LP_PRICING
Definition: set.c:240
SCIP_RETCODE SCIPpropCopyInclude(SCIP_PROP *prop, SCIP_SET *set)
Definition: prop.c:91
SCIP_RETCODE SCIPsepaCopyInclude(SCIP_SEPA *sepa, SCIP_SET *set)
Definition: sepa.c:70
#define SCIP_DEFAULT_CONF_REPROPAGATE
Definition: set.c:146
#define SCIP_DEFAULT_MISC_OUTPUTORIGSOL
Definition: set.c:325
SCIP_Real SCIPsetFloor(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6174
#define SCIP_DEFAULT_CONCURRENT_FREQFACTOR
Definition: set.c:538
SCIP_Real SCIPsetPseudocosteps(SCIP_SET *set)
Definition: set.c:5932
SCIP_Bool SCIPsetIsFeasEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6385
SCIP_RETCODE SCIPsetSetRealParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_Real value)
Definition: set.c:3373
SCIP_RETCODE SCIPrelaxInit(SCIP_RELAX *relax, SCIP_SET *set)
Definition: relax.c:221
SCIP_Bool SCIPpricerIsActive(SCIP_PRICER *pricer)
Definition: pricer.c:684
#define SCIP_DEFAULT_CONCURRENT_NBESTSOLS
Definition: set.c:545
SCIP_RETCODE SCIPbranchruleExitsol(SCIP_BRANCHRULE *branchrule, SCIP_SET *set)
Definition: branch.c:1510
SCIP_RETCODE SCIPnodeselExitsol(SCIP_NODESEL *nodesel, SCIP_SET *set)
Definition: nodesel.c:979
#define SCIP_DEFAULT_PRESOL_CLQTABLEFAC
Definition: set.c:360
#define SCIP_DEFAULT_MISC_RESETSTAT
Definition: set.c:309
SCIP_NODESEL ** nodesels
Definition: struct_set.h:83
#define infinity
Definition: gastrans.c:71
#define SCIP_DEFAULT_SEPA_MAXRUNS
Definition: set.c:496
#define SCIP_DEFAULT_LIMIT_TIME
Definition: set.c:208
#define SCIP_DEFAULT_HEUR_USEUCTSUBSCIP
Definition: set.c:198
#define SCIP_DEFAULT_LP_LEXDUALROOTONLY
Definition: set.c:270
SCIP_RETCODE SCIPpresolFree(SCIP_PRESOL **presol, SCIP_SET *set)
Definition: presol.c:203
const char * SCIPbranchruleGetName(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:1971
#define SCIP_DEFAULT_LP_MARKOWITZ
Definition: set.c:262
#define SCIP_DEFAULT_WRITE_GENNAMES_OFFSET
Definition: set.c:574
SCIP_Bool SCIPsetIsDualfeasGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6684
SCIP_RETCODE SCIPdispFree(SCIP_DISP **disp, SCIP_SET *set)
Definition: disp.c:179
SCIP_RETCODE SCIPeventhdlrExit(SCIP_EVENTHDLR *eventhdlr, SCIP_SET *set)
Definition: event.c:207
SCIP_RETCODE SCIPcomprInit(SCIP_COMPR *compr, SCIP_SET *set)
Definition: compr.c:221
#define SCIP_DEFAULT_PROP_MAXROUNDSROOT
Definition: set.c:463
#define SCIP_DEFAULT_LP_PRESOLVING
Definition: set.c:268
internal methods for clocks and timing issues
#define SCIP_DEFAULT_REOPT_SEPABESTSOL
Definition: set.c:428
SCIP_RETCODE SCIPparamsetSetToDefault(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *paramname)
Definition: paramset.c:2714
SCIP_Bool SCIPsetIsSumGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6272
#define SCIP_DEFAULT_REOPT_MAXDIFFOFNODES
Definition: set.c:415
SCIP_RETCODE SCIPsetCreate(SCIP_SET **set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, SCIP *scip)
Definition: set.c:1143
SCIP_RETCODE SCIPsetIncludeRelax(SCIP_SET *set, SCIP_RELAX *relax)
Definition: set.c:4124
SCIP_EXPORT SCIP_Bool SCIPtableIsInitialized(SCIP_TABLE *table)
Definition: table.c:350
SCIP_Bool SCIPsetIsPositive(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6110
SCIP_EVENTHDLR * SCIPsetFindEventhdlr(SCIP_SET *set, const char *name)
Definition: set.c:4666
#define SCIP_DEFAULT_MEM_SAVEFAC
Definition: set.c:295
int SCIPconshdlrGetSepaPriority(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5046
int nprops
Definition: struct_set.h:112
#define SCIP_DEFAULT_SEPA_CUTSELSUBSCIP
Definition: set.c:495
#define SCIP_DEFAULT_CONF_FULLSHORTENCONFLICT
Definition: set.c:162
struct SCIP_ParamData SCIP_PARAMDATA
Definition: type_paramset.h:77
#define SCIP_DEFAULT_CONCURRENT_COMMVARBNDS
Definition: set.c:529
#define SCIP_DEFAULT_LP_INITALGORITHM
Definition: set.c:234
#define SCIP_DEFAULT_CONS_AGELIMIT
Definition: set.c:177
#define SCIP_CALL_FINALLY(x, y)
Definition: def.h:406
#define SCIP_DEFAULT_PRESOL_ABORTFAC
Definition: set.c:355
void SCIPsetSortComprsName(SCIP_SET *set)
Definition: set.c:4628
SCIP_Bool SCIPsetIsSumRelGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:7040
internal methods for NLPI solver interfaces
#define SCIP_DEFAULT_SEPA_CUTAGELIMIT
Definition: set.c:511
#define SCIP_DEFAULT_DISP_RELEVANTSTATS
Definition: set.c:194
SCIP_RETCODE SCIPsetIncludeConshdlr(SCIP_SET *set, SCIP_CONSHDLR *conshdlr)
Definition: set.c:3818
#define SCIP_DEFAULT_LP_CHECKFARKAS
Definition: set.c:265
SCIP_RETCODE SCIPsetGetStringParam(SCIP_SET *set, const char *name, char **value)
Definition: set.c:3165
SCIP_Bool SCIPcomprIsInitialized(SCIP_COMPR *compr)
Definition: compr.c:521
#define SCIPdebugSolDataCreate(debugsoldata)
Definition: debug.h:239
void SCIPconcsolverTypeFree(SCIP_CONCSOLVERTYPE **concsolvertype)
Definition: concsolver.c:144
SCIP_RETCODE SCIPparamsetSetSeparating(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: paramset.c:4181
SCIP_RETCODE SCIPeventhdlrCopyInclude(SCIP_EVENTHDLR *eventhdlr, SCIP_SET *set)
Definition: event.c:51
SCIP_RETCODE SCIPnlpiFree(SCIP_NLPI **nlpi)
Definition: nlpi.c:182
SCIP_RETCODE SCIPsetIncludeBanditvtable(SCIP_SET *set, SCIP_BANDITVTABLE *banditvtable)
Definition: set.c:4364
SCIP_RETCODE SCIPsetResetParams(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
Definition: set.c:3506
SCIP_RETCODE SCIPdispExit(SCIP_DISP *disp, SCIP_SET *set)
Definition: disp.c:229
#define SCIP_DEFAULT_CONF_MAXSTORESIZE
Definition: set.c:127
#define SCIP_DEFAULT_REOPT_REDUCETOFRONTIER
Definition: set.c:450
#define SCIP_DEFAULT_REOPT_MAXSAVEDNODES
Definition: set.c:414
SCIP_Bool SCIPsetIsScalingIntegral(SCIP_SET *set, SCIP_Real val, SCIP_Real scalar)
Definition: set.c:6143
#define SCIP_DEFAULT_LP_THREADS
Definition: set.c:278
SCIP_Real SCIPsetInfinity(SCIP_SET *set)
Definition: set.c:5852
internal methods for displaying statistics tables
#define SCIP_DEFAULT_LIMIT_ABSGAP
Definition: set.c:211
#define SCIP_DEFAULT_BRANCH_FORCEALL
Definition: set.c:81
SCIP_RETCODE SCIPtableFree(SCIP_TABLE **table, SCIP_SET *set)
Definition: table.c:154
void SCIPsetSortConflicthdlrsName(SCIP_SET *set)
Definition: set.c:4036
SCIP_RETCODE SCIPsetIncludeDialog(SCIP_SET *set, SCIP_DIALOG *dialog)
Definition: set.c:4946
#define SCIP_DEFAULT_CONF_MAXCONSS
Definition: set.c:138
SCIP_RETCODE SCIPheurFree(SCIP_HEUR **heur, SCIP_SET *set, BMS_BLKMEM *blkmem)
Definition: heur.c:1007
#define SCIP_DEFAULT_REOPT_USECUTS
Definition: set.c:457
const char * SCIPeventhdlrGetName(SCIP_EVENTHDLR *eventhdlr)
Definition: event.c:315
SCIP_RETCODE SCIPpresolExit(SCIP_PRESOL *presol, SCIP_SET *set)
Definition: presol.c:289
enum SCIP_ClockType SCIP_CLOCKTYPE
Definition: type_clock.h:38
#define SCIP_DEFAULT_MISC_CATCHCTRLC
Definition: set.c:304
void SCIPsetSortHeurs(SCIP_SET *set)
Definition: set.c:4539
#define FALSE
Definition: def.h:73
SCIP_SEPA ** sepas
Definition: struct_set.h:77
SCIP_RETCODE SCIPbendersExit(SCIP_BENDERS *benders, SCIP_SET *set)
Definition: benders.c:2233
#define EPSEQ(x, y, eps)
Definition: def.h:188
#define EPSISINT(x, eps)
Definition: def.h:200
#define SCIP_DEFAULT_MISC_CALCINTEGRAL
Definition: set.c:323
SCIP_RETCODE SCIPpricerInitsol(SCIP_PRICER *pricer, SCIP_SET *set)
Definition: pricer.c:296
SCIP_RETCODE SCIPbendersExitpre(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_STAT *stat)
Definition: benders.c:2419
#define SCIP_DEFAULT_RECOMPFAC
Definition: def.h:179
#define SCIP_DEFAULT_CONF_MAXVARSFAC
Definition: set.c:97
#define SCIP_DEFAULT_CONF_PROOFSCOREFAC
Definition: set.c:152
SCIP_Real SCIPsetSetRelaxfeastol(SCIP_SET *set, SCIP_Real relaxfeastol)
Definition: set.c:5678
SCIP_Bool SCIPsetIsFeasIntegral(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6528
internal methods for bandit algorithms
#define SCIP_MAXEPSILON
Definition: def.h:181
SCIP_NODESEL * SCIPsetGetNodesel(SCIP_SET *set, SCIP_STAT *stat)
Definition: set.c:4737
internal methods for Benders&#39; decomposition
SCIP_PROP * SCIPsetFindProp(SCIP_SET *set, const char *name)
Definition: set.c:4299
SCIP_RETCODE SCIPconshdlrInitsol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2671
#define SCIP_DEFAULT_MISC_USEVARTABLE
Definition: set.c:305
#define SCIP_DEFAULT_VISUAL_DISPLB
Definition: set.c:564
SCIP_RETCODE SCIPcomprFree(SCIP_COMPR **compr, SCIP_SET *set)
Definition: compr.c:194
SCIP_Bool SCIPsetIsZero(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6099
void SCIPbanditvtableFree(SCIP_BANDITVTABLE **banditvtable)
Definition: bandit.c:260
#define TRUE
Definition: def.h:72
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:54
SCIP_PRESOL * SCIPsetFindPresol(SCIP_SET *set, const char *name)
Definition: set.c:4074
SCIP_RETCODE SCIPheurInitsol(SCIP_HEUR *heur, SCIP_SET *set)
Definition: heur.c:1123
#define SCIP_DEFAULT_SEPA_EFFICACYFAC
Definition: set.c:488
SCIP_PARAM * SCIPparamsetGetParam(SCIP_PARAMSET *paramset, const char *name)
Definition: paramset.c:1703
#define SCIP_MEM_NOLIMIT
Definition: def.h:294
#define EPSP(x, eps)
Definition: def.h:194
#define SCIP_DEFAULT_REOPT_COMMONTIMELIMIT
Definition: set.c:439
SCIP_RETCODE SCIPsetSetParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, void *value)
Definition: set.c:3193
enum SCIP_VerbLevel SCIP_VERBLEVEL
Definition: type_message.h:48
internal methods for branching rules and branching candidate storage
SCIP_RETCODE SCIPnodeselInitsol(SCIP_NODESEL *nodesel, SCIP_SET *set)
Definition: nodesel.c:955
SCIP_RETCODE SCIPconflicthdlrExitsol(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)
Definition: conflict.c:605
SCIP_Real SCIPsetCutoffbounddelta(SCIP_SET *set)
Definition: set.c:5952
int SCIPsetCalcMemGrowSize(SCIP_SET *set, int num)
Definition: set.c:5580
#define SCIP_DEFAULT_PRESOL_MAXRESTARTS
Definition: set.c:359
SCIP_Bool SCIPsetIsSumLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6236
datastructures for concurrent solvers
SCIP_PARAM ** SCIPsetGetParams(SCIP_SET *set)
Definition: set.c:3610
SCIP_Real SCIPsetRound(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6196
#define SCIP_DEFAULT_CONF_IGNORERELAXEDBD
Definition: set.c:160
#define SCIP_DEFAULT_LIMIT_STALLNODES
Definition: set.c:215
#define SCIP_DEFAULT_SEPA_MAXSTALLROUNDSROOT
Definition: set.c:503
#define SCIP_DEFAULT_LP_SCALING
Definition: set.c:267
SCIP_Bool SCIPsetIsDualfeasLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6640
SCIP_RETCODE SCIPparamsetSetToDefaults(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
Definition: paramset.c:2696
int nheurs
Definition: struct_set.h:114
#define SCIP_DEFAULT_SEPA_MINACTIVITYQUOT
Definition: set.c:515
#define EPSGE(x, y, eps)
Definition: def.h:192
SCIP_RETCODE SCIPsetIncludeNlpi(SCIP_SET *set, SCIP_NLPI *nlpi)
Definition: set.c:4990
#define SCIP_DEFAULT_CONCURRENT_PRESOLVEBEFORE
Definition: set.c:530
#define SCIP_DEFAULT_NLP_SOLVER
Definition: set.c:289
SCIP_RETCODE SCIPbranchruleInitsol(SCIP_BRANCHRULE *branchrule, SCIP_SET *set)
Definition: branch.c:1486
SCIP_RETCODE SCIPconshdlrInit(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2389
SCIP_Real SCIPsetRelaxfeastol(SCIP_SET *set)
Definition: set.c:5966
SCIP_RETCODE SCIPsepaFree(SCIP_SEPA **sepa, SCIP_SET *set)
Definition: sepa.c:227
#define SCIP_DEFAULT_PROP_ABORTONCUTOFF
Definition: set.c:464
SCIP_RETCODE SCIPrelaxFree(SCIP_RELAX **relax, SCIP_SET *set)
Definition: relax.c:194
#define SCIP_DEFAULT_LP_CLEARINITIALPROBINGLP
Definition: set.c:245
#define SCIP_DEFAULT_CONF_MINIMPROVE
Definition: set.c:168
#define SCIP_DEFAULT_CONCURRENT_MINSYNCDELAY
Definition: set.c:544
#define EPSFRAC(x, eps)
Definition: def.h:199
#define SCIP_DEFAULT_REOPT_VARORDERINTERDICTION
Definition: set.c:410
internal methods for handling parameter settings
#define SCIP_DEFAULT_LP_SOLUTIONPOLISHING
Definition: set.c:283
SCIP_RETCODE SCIPsetIncludeConcsolverType(SCIP_SET *set, SCIP_CONCSOLVERTYPE *concsolvertype)
Definition: set.c:4407
SCIP_Bool SCIPdispIsInitialized(SCIP_DISP *disp)
Definition: disp.c:396
#define SCIP_DEFAULT_SEPA_MAXLOCALBOUNDDIST
Definition: set.c:476
SCIP_EXPORT SCIP_Bool SCIPsepaIsInitialized(SCIP_SEPA *sepa)
Definition: sepa.c:954
SCIP_RETCODE SCIPheurCopyInclude(SCIP_HEUR *heur, SCIP_SET *set)
Definition: heur.c:861
SCIP_Bool SCIPsetIsNegative(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6121
SCIP_PRESOL ** presols
Definition: struct_set.h:75
const char * SCIPcomprGetName(SCIP_COMPR *compr)
Definition: compr.c:447
int ndialogs
Definition: struct_set.h:128
#define SCIP_LONGINT_MAX
Definition: def.h:149
#define SCIP_DEFAULT_DISP_FREQ
Definition: set.c:190
SCIP_RELAX ** relaxs
Definition: struct_set.h:76
#define SCIP_DEFAULT_CONF_DOWNLOCKSCOREFAC
Definition: set.c:154
#define BMSfreeMemory(ptr)
Definition: memory.h:137
SCIP_RETCODE SCIPpropInit(SCIP_PROP *prop, SCIP_SET *set)
Definition: prop.c:305
#define SCIP_DEFAULT_BENDERS_COPYBENDERS
Definition: set.c:399
#define SCIP_DEFAULT_MISC_IMPROVINGSOLS
Definition: set.c:318
SCIP_Real SCIPsetSumFloor(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6341
#define SCIP_DEFAULT_CONF_UPLOCKSCOREFAC
Definition: set.c:153
SCIP_CONSHDLR ** conshdlrs_include
Definition: struct_set.h:73
#define SCIP_DEFAULT_VISUAL_REALTIME
Definition: set.c:562
SCIP_RETCODE SCIPpricerCopyInclude(SCIP_PRICER *pricer, SCIP_SET *set, SCIP_Bool *valid)
Definition: pricer.c:78
#define SCIP_DEFAULT_LP_SOLVEDEPTH
Definition: set.c:233
#define SCIP_DEFAULT_SEPA_ORTHOFUNC
Definition: set.c:490
SCIP_Real SCIPparamGetReal(SCIP_PARAM *param)
Definition: paramset.c:819
SCIP_Real SCIPsetCeil(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6185
SCIP_Real SCIPsetGetHugeValue(SCIP_SET *set)
Definition: set.c:5864
internal methods for LP management
SCIP_Bool SCIPsetIsFeasFracIntegral(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6539
const char * SCIPbanditvtableGetName(SCIP_BANDITVTABLE *banditvtable)
Definition: bandit.c:273
void SCIPsetSortHeursName(SCIP_SET *set)
Definition: set.c:4554
int nbranchrules
Definition: struct_set.h:122
Definition: heur_padm.c:125
#define SCIP_DEFAULT_CONCURRENT_TARGETPROGRESS
Definition: set.c:539
SCIP_RETCODE SCIPnodeselExit(SCIP_NODESEL *nodesel, SCIP_SET *set)
Definition: nodesel.c:925
#define SCIP_DEFAULT_LP_ROWREPSWITCH
Definition: set.c:275
#define SCIP_DEFAULT_LP_RESOLVEITERMIN
Definition: set.c:282
#define SCIP_DEFAULT_SEPA_MAXCOEFRATIO
Definition: set.c:481
#define SCIP_DEFAULT_MISC_SCALEOBJ
Definition: set.c:332
SCIP_RETCODE SCIPsetIncludeSepa(SCIP_SET *set, SCIP_SEPA *sepa)
Definition: set.c:4198
void SCIPsetSortBendersName(SCIP_SET *set)
Definition: set.c:3803
#define SCIP_DEFAULT_REOPT_STRONGBRANCHINIT
Definition: set.c:445
#define SCIP_DEFAULT_REOPT_STOREVARHISTOTY
Definition: set.c:433
SCIP_RETCODE SCIPsetIncludeCompr(SCIP_SET *set, SCIP_COMPR *compr)
Definition: set.c:4569
SCIP_RETCODE SCIPsetSetStringParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, const char *value)
Definition: set.c:3449
SCIP_RETCODE SCIPsetIncludeBenders(SCIP_SET *set, SCIP_BENDERS *benders)
Definition: set.c:3745
#define SCIP_DEFAULT_COMPR_ENABLE
Definition: set.c:91
SCIP * scip
Definition: struct_set.h:64
enum SCIP_ParamSetting SCIP_PARAMSETTING
Definition: type_paramset.h:56
SCIP_RETCODE SCIPenableReoptimization(SCIP *scip, SCIP_Bool enable)
Definition: scip_solve.c:3028
int SCIPsetGetSepaMaxcuts(SCIP_SET *set, SCIP_Bool root)
Definition: set.c:5719
#define SCIP_DEFAULT_LP_ALWAYSGETDUALS
Definition: set.c:285
#define SCIP_DEFAULT_MISC_ALLOWSTRONGDUALREDS
Definition: set.c:326
#define SCIP_DEFAULT_DISP_WIDTH
Definition: set.c:189
SCIP_Real SCIPsetPseudocostdelta(SCIP_SET *set)
Definition: set.c:5942
SCIP_RETCODE SCIPreaderFree(SCIP_READER **reader, SCIP_SET *set)
Definition: reader.c:130
#define SCIP_DEFAULT_LP_ROOTITERLIM
Definition: set.c:232
SCIP_RETCODE SCIPpricerExit(SCIP_PRICER *pricer, SCIP_SET *set)
Definition: pricer.c:265
SCIP_RETCODE SCIPsepaInit(SCIP_SEPA *sepa, SCIP_SET *set)
Definition: sepa.c:254
#define SCIP_DEFAULT_EPSILON
Definition: def.h:169
SCIP_RETCODE SCIPsetAddCharParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, char *valueptr, SCIP_Bool isadvanced, char defaultvalue, const char *allowedvalues, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: set.c:3028
int neventhdlrs
Definition: struct_set.h:118
SCIP_Bool SCIPsetIsGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6081
#define SCIP_DEFAULT_CONF_SETTLELOCAL
Definition: set.c:143
internal methods for propagators
SCIP_RETCODE SCIPdispCopyInclude(SCIP_DISP *disp, SCIP_SET *set)
Definition: disp.c:56
SCIP_RETCODE SCIPparamSetInt(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, int value, SCIP_Bool initialize, SCIP_Bool quiet)
Definition: paramset.c:4488
#define SCIP_DEFAULT_CHECKFEASTOLFAC
Definition: def.h:172
SCIP_RETCODE SCIPnodeselCopyInclude(SCIP_NODESEL *nodesel, SCIP_SET *set)
Definition: nodesel.c:740
#define SCIP_DEFAULT_TIME_ENABLED
Definition: set.c:552
SCIP_NLPI ** nlpis
Definition: struct_set.h:89
SCIP_Bool SCIPsetIsEfficacious(SCIP_SET *set, SCIP_Bool root, SCIP_Real efficacy)
Definition: set.c:6849
#define SCIP_DEFAULT_PRESOL_RESTARTMINRED
Definition: set.c:370
#define SCIP_DEFAULT_CONF_KEEPREPROP
Definition: set.c:149
#define SCIP_DEFAULT_LIMIT_NODES
Definition: set.c:214
SCIP_Real SCIPsetDualfeasFloor(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6763
SCIP_RETCODE SCIPsetInitPlugins(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_STAT *stat)
Definition: set.c:5093
SCIP_RETCODE SCIPsetFree(SCIP_SET **set, BMS_BLKMEM *blkmem)
Definition: set.c:2751
void SCIPreaderEnableOrDisableClocks(SCIP_READER *reader, SCIP_Bool enable)
Definition: reader.c:608
#define SCIP_DEFAULT_LIMIT_AUTORESTARTNODES
Definition: set.c:225
SCIP_RETCODE SCIPeventhdlrFree(SCIP_EVENTHDLR **eventhdlr, SCIP_SET *set)
Definition: event.c:140
struct SCIP_DebugSolData SCIP_DEBUGSOLDATA
Definition: debug.h:50
SCIP_RETCODE SCIPparamSetChar(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, char value, SCIP_Bool initialize, SCIP_Bool quiet)
Definition: paramset.c:4670
SCIP_Bool SCIPsetIsLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6027
SCIP_RETCODE SCIPsetReadParams(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *filename)
Definition: set.c:3464
#define SCIP_DEFAULT_PRICE_MAXVARS
Definition: set.c:382
#define SCIP_DEFAULT_MISC_ALLOWWEAKDUALREDS
Definition: set.c:327
#define SCIP_DEFAULT_PRICE_ABORTFAC
Definition: set.c:379
#define SCIP_DEFAULT_TIME_READING
Definition: set.c:553
SCIP_RETCODE SCIPparamsetSetToSubscipsOff(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Bool quiet)
Definition: paramset.c:4004
#define SCIP_DEFAULT_CONF_LPITERATIONS
Definition: set.c:102
SCIP_RETCODE SCIPconflicthdlrExit(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)
Definition: conflict.c:550
#define SCIP_DEFAULT_CONF_USEBOUNDLP
Definition: set.c:111
SCIP_RETCODE SCIPconshdlrCopyInclude(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_Bool *valid)
Definition: cons.c:1969
#define SCIP_DEFAULT_PRESOL_RESTARTFAC
Definition: set.c:361
SCIP_RETCODE SCIPconflicthdlrInitsol(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)
Definition: conflict.c:581
SCIP_Bool SCIPsetIsSumLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6254
SCIP_RETCODE SCIPsetCopyPlugins(SCIP_SET *sourceset, SCIP_SET *targetset, SCIP_Bool copyreaders, SCIP_Bool copypricers, SCIP_Bool copyconshdlrs, SCIP_Bool copyconflicthdlrs, SCIP_Bool copypresolvers, SCIP_Bool copyrelaxators, SCIP_Bool copyseparators, SCIP_Bool copypropagators, SCIP_Bool copyheuristics, SCIP_Bool copyeventhdlrs, SCIP_Bool copynodeselectors, SCIP_Bool copybranchrules, SCIP_Bool copydisplays, SCIP_Bool copydialogs, SCIP_Bool copytables, SCIP_Bool copynlpis, SCIP_Bool *allvalid)
Definition: set.c:917
SCIP_CONSHDLR * SCIPsetFindConshdlr(SCIP_SET *set, const char *name)
Definition: set.c:3957
SCIP_RETCODE SCIPsepaInitsol(SCIP_SEPA *sepa, SCIP_SET *set)
Definition: sepa.c:332
SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)
Definition: misc.c:10912
SCIP_RETCODE SCIPsetIncludeHeur(SCIP_SET *set, SCIP_HEUR *heur)
Definition: set.c:4495
#define SCIP_DEFAULT_LP_LEXDUALALGO
Definition: set.c:269
#define SCIP_DEFAULT_RANDOM_LPSEED
Definition: set.c:341
SCIP_RETCODE SCIPsetChgIntParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAM *param, int value)
Definition: set.c:3260
#define SCIP_DEFAULT_REOPT_OBJSIMROOTLP
Definition: set.c:406
SCIP_Bool SCIPsetIsParamFixed(SCIP_SET *set, const char *name)
Definition: set.c:3073
#define SCIP_DEFAULT_MISC_ESTIMEXTERNMEM
Definition: set.c:320
void SCIPresetLPFeastol(SCIP *scip)
Definition: scip_lp.c:443
void BMSsetBufferMemoryArraygrowinit(BMS_BUFMEM *buffer, int arraygrowinit)
Definition: memory.c:2566
#define EPSN(x, eps)
Definition: def.h:195
SCIP_Bool SCIPsetIsSumRelGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:7062
#define SCIP_DEFAULT_SEPA_MAXROUNDS
Definition: set.c:497
SCIP_RETCODE SCIPsetSetSubscipsOff(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Bool quiet)
Definition: set.c:3544
void SCIPsetSetPriorityNlpi(SCIP_SET *set, SCIP_NLPI *nlpi, int priority)
Definition: set.c:5047
#define SCIP_DEFAULT_CONCURRENT_CHANGESEEDS
Definition: set.c:527
SCIP_RETCODE SCIPbendersInitsol(SCIP_BENDERS *benders, SCIP_SET *set)
Definition: benders.c:2445
void SCIPsetReinsertConshdlrSepaPrio(SCIP_SET *set, SCIP_CONSHDLR *conshdlr, int oldpriority)
Definition: set.c:3874
SCIP_RETCODE SCIPparamsetGetInt(SCIP_PARAMSET *paramset, const char *name, int *value)
Definition: paramset.c:1747
void SCIPconshdlrEnableOrDisableClocks(SCIP_CONSHDLR *conshdlr, SCIP_Bool enable)
Definition: cons.c:4646
#define SCIP_DEFAULT_CONF_CONFLITGRAPHWEIGHT
Definition: set.c:164
#define SCIP_DEFAULT_CONF_WEIGHTVALIDDEPTH
Definition: set.c:167
SCIP_RETCODE SCIPsetChgBoolParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAM *param, SCIP_Bool value)
Definition: set.c:3208
#define SCIP_DEFAULT_MEM_TREEGROWFAC
Definition: set.c:296
#define SCIP_DEFAULT_PRESOL_DONOTMULTAGGR
Definition: set.c:373
#define SCIP_DEFAULT_CONF_INTERCONSS
Definition: set.c:135
#define SCIP_DEFAULT_REOPT_USESPLITCONS
Definition: set.c:452
#define SCIPerrorMessage
Definition: pub_message.h:55
SCIP_Bool SCIPpropIsInitialized(SCIP_PROP *prop)
Definition: prop.c:1147
#define SCIP_DEFAULT_RANDOM_PERMUTECONSS
Definition: set.c:342
SCIP_BANDITVTABLE * SCIPsetFindBanditvtable(SCIP_SET *set, const char *name)
Definition: set.c:4386
SCIP_RETCODE SCIPparamsetSetReal(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_Real value)
Definition: paramset.c:2157
#define SCIP_DEFAULT_CONF_SEPARATE
Definition: set.c:121
SCIP_RETCODE SCIPdispExitsol(SCIP_DISP *disp, SCIP_SET *set)
Definition: disp.c:271
SCIP_RETCODE SCIPrelaxExit(SCIP_RELAX *relax, SCIP_SET *set)
Definition: relax.c:265
SCIP_RETCODE SCIPparamSetBool(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Bool value, SCIP_Bool initialize, SCIP_Bool quiet)
Definition: paramset.c:4428
#define SCIP_DEFAULT_TIME_RARECLOCKCHECK
Definition: set.c:554
#define SCIP_DEFAULT_BRANCH_SCOREFUNC
Definition: set.c:68
SCIP_RETCODE SCIPsetWriteParams(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
Definition: set.c:3478
SCIP_Bool SCIPconflicthdlrIsInitialized(SCIP_CONFLICTHDLR *conflicthdlr)
Definition: conflict.c:807
SCIP_RETCODE SCIPparamsetSetDefaultInt(SCIP_PARAMSET *paramset, const char *name, int defaultvalue)
Definition: paramset.c:2092
SCIP_RETCODE SCIPparamsetGetBool(SCIP_PARAMSET *paramset, const char *name, SCIP_Bool *value)
Definition: paramset.c:1715
static SCIP_DECL_PARAMCHGD(paramChgdFeastol)
Definition: set.c:634
SCIP_Bool SCIPsetIsSumRelEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6974
SCIP_RETCODE SCIPtableInit(SCIP_TABLE *table, SCIP_SET *set)
Definition: table.c:179
SCIP_RETCODE SCIPenableOrDisableStatisticTiming(SCIP *scip)
Definition: scip_timing.c:209
SCIP_Bool SCIPsetIsRelEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6864
#define SCIP_DEFAULT_SEPA_MINEFFICACY
Definition: set.c:482
SCIP_RETCODE SCIPsetSetSeparating(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: set.c:3597
SCIP_Bool SCIPsetIsDualfeasIntegral(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6739
#define SCIP_DEFAULT_MISC_EXACTSOLVE
Definition: set.c:308
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
Definition: scip_mem.c:48
SCIP_RETCODE SCIPpricerFree(SCIP_PRICER **pricer, SCIP_SET *set)
Definition: pricer.c:198
void SCIPpresolEnableOrDisableClocks(SCIP_PRESOL *presol, SCIP_Bool enable)
Definition: presol.c:676
#define SCIP_DEFAULT_HISTORY_ALLOWTRANSFER
Definition: set.c:204
#define SCIP_DEFAULT_LIMIT_BESTSOL
Definition: set.c:219
internal methods for presolvers
SCIP_RETCODE SCIPbranchruleExit(SCIP_BRANCHRULE *branchrule, SCIP_SET *set)
Definition: branch.c:1456
const char * SCIPpropGetName(SCIP_PROP *prop)
Definition: prop.c:932
void SCIPsetSortComprs(SCIP_SET *set)
Definition: set.c:4613
SCIP_RETCODE SCIPsetInitsolPlugins(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_STAT *stat)
Definition: set.c:5382
#define SCIP_DEFAULT_BRANCH_CLAMP
Definition: set.c:73
SCIP_RETCODE SCIPsetSetIntParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, int value)
Definition: set.c:3283
SCIP_RELAX * SCIPsetFindRelax(SCIP_SET *set, const char *name)
Definition: set.c:4148
SCIP_Bool SCIPbranchruleIsInitialized(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:2173
SCIP_RETCODE SCIPbendersExitsol(SCIP_BENDERS *benders, SCIP_SET *set)
Definition: benders.c:2478
void SCIPeventhdlrEnableOrDisableClocks(SCIP_EVENTHDLR *eventhdlr, SCIP_Bool enable)
Definition: event.c:433
SCIP_RETCODE SCIPparamSetString(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *value, SCIP_Bool quiet)
Definition: paramset.c:4729
SCIP_RETCODE SCIPconshdlrInitpre(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2545
#define SCIP_DEFAULT_CONF_USELOCALROWS
Definition: set.c:173
SCIP_Real SCIPsetBarrierconvtol(SCIP_SET *set)
Definition: set.c:5922
int SCIPsetGetNParams(SCIP_SET *set)
Definition: set.c:3620
SCIP_CONFLICTHDLR * SCIPsetFindConflicthdlr(SCIP_SET *set, const char *name)
Definition: set.c:4001
SCIP_RETCODE SCIPsetChgRealParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAM *param, SCIP_Real value)
Definition: set.c:3350
#define SCIP_DEFAULT_MISC_TRANSSOLSORIG
Definition: set.c:322
SCIP_Bool SCIPsetExistsDialog(SCIP_SET *set, SCIP_DIALOG *dialog)
Definition: set.c:4968
SCIP_RETCODE SCIPparamsetGetLongint(SCIP_PARAMSET *paramset, const char *name, SCIP_Longint *value)
Definition: paramset.c:1779
SCIP_Bool SCIPsetGetSubscipsOff(SCIP_SET *set)
Definition: set.c:7084
SCIP_RETCODE SCIPparamsetCreate(SCIP_PARAMSET **paramset, BMS_BLKMEM *blkmem)
Definition: paramset.c:1417
SCIP_Bool SCIPsetIsSumRelLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6996
SCIP_Real SCIPsetFeasCeil(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6563
void SCIPsetSetLimitChanged(SCIP_SET *set)
Definition: set.c:5695
#define SCIP_DEFAULT_LP_ROWAGELIMIT
Definition: set.c:253
#define SCIP_DEFAULT_LP_RESOLVEALGORITHM
Definition: set.c:237
#define SCIP_DEFAULT_RANDOM_PERMUTEVARS
Definition: set.c:343
#define SCIP_DEFAULT_LP_COLAGELIMIT
Definition: set.c:250
SCIP_Bool SCIPsetIsRelLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6908
SCIP_RETCODE SCIPsetChgLongintParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAM *param, SCIP_Longint value)
Definition: set.c:3312
#define NULL
Definition: lpi_spx1.cpp:155
SCIP_RETCODE SCIPparamsetSetEmphasis(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMEMPHASIS paramemphasis, SCIP_Bool quiet)
Definition: paramset.c:3747
SCIP_RETCODE SCIPparamsetAddLongint(SCIP_PARAMSET *paramset, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Longint *valueptr, SCIP_Bool isadvanced, SCIP_Longint defaultvalue, SCIP_Longint minvalue, SCIP_Longint maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: paramset.c:1547
#define SCIP_DEFAULT_REOPT_OBJSIMSOL
Definition: set.c:403
SCIP_Real SCIPsetDualfeasCeil(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6774
SCIP_RETCODE SCIPnodeselFree(SCIP_NODESEL **nodesel, SCIP_SET *set)
Definition: nodesel.c:860
SCIP_Bool SCIPsetIsDualfeasFracIntegral(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6750
SCIP_RETCODE SCIPparamsetAddString(SCIP_PARAMSET *paramset, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, char **valueptr, SCIP_Bool isadvanced, const char *defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: paramset.c:1636
int nrelaxs
Definition: struct_set.h:108
SCIP_Bool SCIPsetIsDualfeasGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6662
void SCIPpropEnableOrDisableClocks(SCIP_PROP *prop, SCIP_Bool enable)
Definition: prop.c:1010
SCIP_Real SCIPsetFrac(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6207
SCIP_RETCODE SCIPsetIncludePricer(SCIP_SET *set, SCIP_PRICER *pricer)
Definition: set.c:3672
#define REALABS(x)
Definition: def.h:187
SCIP_SEPA * SCIPsetFindSepa(SCIP_SET *set, const char *name)
Definition: set.c:4222
#define SCIP_DEFAULT_REOPT_MAXCUTAGE
Definition: set.c:458
#define SCIP_DEFAULT_BENDERS_CUTLPSOL
Definition: set.c:398
SCIP_Bool SCIPsetIsRelGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6930
#define SCIP_DEFAULT_PRINTZEROS
Definition: set.c:584
internal methods for node selectors and node priority queues
#define SCIP_DEFAULT_BRANCH_SCOREFAC
Definition: set.c:69
internal methods for variable pricers
SCIP_Bool SCIPnodeselIsInitialized(SCIP_NODESEL *nodesel)
Definition: nodesel.c:1200
SCIP_RETCODE SCIPconflicthdlrFree(SCIP_CONFLICTHDLR **conflicthdlr, SCIP_SET *set)
Definition: conflict.c:485
#define SCIP_DEFAULT_REOPT_SAVESOLS
Definition: set.c:423
void SCIPsetSortProps(SCIP_SET *set)
Definition: set.c:4319
internal methods for global SCIP settings
#define SCIP_DEFAULT_TIME_CLOCKTYPE
Definition: set.c:551
#define SCIP_CALL(x)
Definition: def.h:364
SCIP_RETCODE SCIPsetSetReoptimizationParams(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
Definition: set.c:799
SCIP_RETCODE SCIPrelaxCopyInclude(SCIP_RELAX *relax, SCIP_SET *set)
Definition: relax.c:73
SCIP main data structure.
#define SCIP_DEFAULT_READ_DYNAMICCONSS
Definition: set.c:571
SCIP_Bool SCIPsetIsFeasGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6473
#define SCIP_DEFAULT_FEASTOL
Definition: def.h:171
#define SCIP_DEFAULT_REOPT_SOLVELP
Definition: set.c:424
SCIP_RETCODE SCIPparamsetSetHeuristics(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: paramset.c:4109
#define SCIP_DEFAULT_LP_FREESOLVALBUFFERS
Definition: set.c:249
SCIP_RETCODE SCIPconcsolverDestroyInstance(SCIP_SET *set, SCIP_CONCSOLVER **concsolver)
Definition: concsolver.c:248
SCIP_RETCODE SCIPeventhdlrInitsol(SCIP_EVENTHDLR *eventhdlr, SCIP_SET *set)
Definition: event.c:237
SCIP_RETCODE SCIPsetSetPresolving(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: set.c:3579
SCIP_Bool SCIPsetIsLbBetter(SCIP_SET *set, SCIP_Real newlb, SCIP_Real oldlb, SCIP_Real oldub)
Definition: set.c:6810
#define SCIP_DEFAULT_PSEUDOCOSTEPS
Definition: def.h:177
SCIP_EXPORT const char * SCIPsepaGetName(SCIP_SEPA *sepa)
Definition: sepa.c:697
int SCIPsetCalcTreeGrowSize(SCIP_SET *set, int num)
Definition: set.c:5589
#define SCIP_DEFAULT_CONF_USESB
Definition: set.c:116
internal methods for relaxators
SCIP_RETCODE SCIPsetAddIntParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: set.c:2956
SCIP_RETCODE SCIPparamSetLongint(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Longint value, SCIP_Bool initialize, SCIP_Bool quiet)
Definition: paramset.c:4548
SCIP_Bool SCIPsetIsEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6009
SCIP_RETCODE SCIPnodeselInit(SCIP_NODESEL *nodesel, SCIP_SET *set)
Definition: nodesel.c:889
int SCIPparamsetGetNParams(SCIP_PARAMSET *paramset)
Definition: paramset.c:4222
int nsepas
Definition: struct_set.h:110
SCIP_Bool SCIPsetIsHugeValue(SCIP_SET *set, SCIP_Real val)
Definition: set.c:5998
SCIP_Bool SCIPheurIsInitialized(SCIP_HEUR *heur)
Definition: heur.c:1585
#define SCIP_DEFAULT_DECOMP_MAXGRAPHEDGE
Definition: set.c:394
SCIP_RETCODE SCIPcomprExit(SCIP_COMPR *compr, SCIP_SET *set)
Definition: compr.c:260
#define SCIP_DEFAULT_LP_CLEANUPCOLSROOT
Definition: set.c:257
SCIP_EXPORT void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
#define SCIP_DEFAULT_LP_CLEANUPROWSROOT
Definition: set.c:259
#define SCIP_DEFAULT_SEPA_MINEFFICACYROOT
Definition: set.c:483
SCIP_RETCODE SCIPincludeNlpi(SCIP *scip, SCIP_NLPI *nlpi)
Definition: scip_nlp.c:70
void SCIPsetSortPropsPresol(SCIP_SET *set)
Definition: set.c:4334
#define SCIP_DEFAULT_REOPT_USEPSCOST
Definition: set.c:438
SCIP_Bool SCIPsetIsFeasLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6429
SCIP_RETCODE SCIPsetSetFeastol(SCIP_SET *set, SCIP_LP *lp, SCIP_Real feastol)
Definition: set.c:5626
void SCIPsetSortPresolsName(SCIP_SET *set)
Definition: set.c:4109
#define EPSCEIL(x, eps)
Definition: def.h:197
#define BMSduplicateMemoryArray(ptr, source, num)
Definition: memory.h:135
#define SCIP_DEFAULT_MISC_PRINTREASON
Definition: set.c:319
SCIP_READER * SCIPsetFindReader(SCIP_SET *set, const char *name)
Definition: set.c:3652
void SCIPsetSortRelaxs(SCIP_SET *set)
Definition: set.c:4168
#define SCIP_DEFAULT_TIME_STATISTICTIMING
Definition: set.c:555
SCIP_BRANCHRULE ** branchrules
Definition: struct_set.h:85
#define SCIP_DEFAULT_LP_CLEANUPROWS
Definition: set.c:258
SCIP_RETCODE SCIPconflicthdlrInit(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)
Definition: conflict.c:513
#define SCIP_DEFAULT_CONF_ENABLE
Definition: set.c:96
#define SCIP_DEFAULT_LIMIT_MAXORIGSOL
Definition: set.c:223
SCIP_RETCODE SCIPsetSetLongintParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_Longint value)
Definition: set.c:3335
SCIP_Real SCIPlpGetFeastol(SCIP_LP *lp)
Definition: lp.c:10215
#define SCIP_DEFAULT_SEPA_MAXBOUNDDIST
Definition: set.c:471
SCIP_COMPR * SCIPsetFindCompr(SCIP_SET *set, const char *name)
Definition: set.c:4593
SCIP_RETCODE SCIPsetIncludeProp(SCIP_SET *set, SCIP_PROP *prop)
Definition: set.c:4272
SCIP_RETCODE SCIPbendersInitpre(SCIP_BENDERS *benders, SCIP_SET *set, SCIP_STAT *stat)
Definition: benders.c:2376
void SCIPsetSortBenders(SCIP_SET *set)
Definition: set.c:3788
#define SCIP_DEFAULT_LIMIT_RESTARTS
Definition: set.c:224
#define SCIP_DEFAULT_DISP_ALLVIOLS
Definition: set.c:193
SCIP_Bool SCIPsetIsIntegral(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6132
#define SCIP_DEFAULT_HUGEVAL
Definition: def.h:180
#define SCIP_DEFAULT_PRICE_DELVARS
Definition: set.c:384
SCIP_RETCODE SCIPsetSetHeuristics(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: set.c:3561
internal methods for user interface dialog
SCIP_Real SCIPgetLPFeastol(SCIP *scip)
Definition: scip_lp.c:419
#define SCIP_Bool
Definition: def.h:70
#define SCIP_DEFAULT_CONCURRENT_FREQMAX
Definition: set.c:535
#define SCIP_DEFAULT_MEM_PATHGROWFAC
Definition: set.c:297
SCIP_Real SCIPsetSumepsilon(SCIP_SET *set)
Definition: set.c:5884
void SCIPsetSortSepasName(SCIP_SET *set)
Definition: set.c:4257
#define SCIP_DEFAULT_LIMIT_MAXSOL
Definition: set.c:222
SCIP_RETCODE SCIPsetIncludeTable(SCIP_SET *set, SCIP_TABLE *table)
Definition: set.c:4901
#define SCIP_DEFAULT_LPFEASTOLFACTOR
Definition: def.h:173
SCIP_PARAMSET * paramset
Definition: struct_set.h:65
SCIP_RETCODE SCIPsetSetBarrierconvtol(SCIP_SET *set, SCIP_Real barrierconvtol)
Definition: set.c:5660
SCIP_NODESEL * SCIPsetFindNodesel(SCIP_SET *set, const char *name)
Definition: set.c:4717
SCIP_RETCODE SCIPparamsetSetInt(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, int value)
Definition: paramset.c:2058
SCIP_RETCODE SCIPtableExitsol(SCIP_TABLE *table, SCIP_SET *set)
Definition: table.c:245
int SCIPsetCalcPathGrowSize(SCIP_SET *set, int num)
Definition: set.c:5598
#define SCIP_DEFAULT_PRICE_DELVARSROOT
Definition: set.c:387
#define SCIP_DEFAULT_REOPT_OBJSIMDELAY
Definition: set.c:407
SCIP_RETCODE SCIPrelaxInitsol(SCIP_RELAX *relax, SCIP_SET *set)
Definition: relax.c:295
SCIP_EXPORT const char * SCIPtableGetName(SCIP_TABLE *table)
Definition: table.c:300
SCIP_Bool memsavemode
Definition: struct_stat.h:264
#define SCIP_DEFAULT_DECOMP_APPLYBENDERS
Definition: set.c:393
#define SCIP_DEFAULT_CONF_REMOVEABLE
Definition: set.c:150
#define SCIP_DEFAULT_PRESOL_IMMRESTARTFAC
Definition: set.c:364
#define SCIP_DEFAULT_CONF_DEPTHSCOREFAC
Definition: set.c:151
#define SCIP_DEFAULT_BENDERS_SOLTOL
Definition: set.c:397
SCIP_RETCODE SCIPparamsetGetReal(SCIP_PARAMSET *paramset, const char *name, SCIP_Real *value)
Definition: paramset.c:1811
void BMSsetBufferMemoryArraygrowfac(BMS_BUFMEM *buffer, double arraygrowfac)
Definition: memory.c:2554
#define SCIP_DEFAULT_MISC_TRANSORIGSOLS
Definition: set.c:321
internal methods for input file readers
#define SCIP_DEFAULT_BOUNDSTREPS
Definition: def.h:176
const char * SCIPpresolGetName(SCIP_PRESOL *presol)
Definition: presol.c:590
SCIP_RETCODE SCIPsetGetIntParam(SCIP_SET *set, const char *name, int *value)
Definition: set.c:3109
SCIP_HEUR ** heurs
Definition: struct_set.h:80
SCIP_RETCODE SCIPheurInit(SCIP_HEUR *heur, SCIP_SET *set)
Definition: heur.c:1043
SCIP_RETCODE SCIPsetIncludeExternalCode(SCIP_SET *set, const char *name, const char *description)
Definition: set.c:5061
#define MAX(x, y)
Definition: tclique_def.h:83
SCIP_RETCODE SCIPpricerExitsol(SCIP_PRICER *pricer, SCIP_SET *set)
Definition: pricer.c:320
void SCIPsetSortNlpis(SCIP_SET *set)
Definition: set.c:5033
int nreaders
Definition: struct_set.h:97
#define SCIP_DEFAULT_LP_SOLVEFREQ
Definition: set.c:230
SCIP_RETCODE SCIPparamsetSetDefaultBool(SCIP_PARAMSET *paramset, const char *name, SCIP_Bool defaultvalue)
Definition: paramset.c:2027
SCIP_RETCODE SCIPsetCopyParams(SCIP_SET *sourceset, SCIP_SET *targetset, SCIP_MESSAGEHDLR *messagehdlr)
Definition: set.c:1126
SCIP_RETCODE SCIPparamsetGetString(SCIP_PARAMSET *paramset, const char *name, char **value)
Definition: paramset.c:1875
SCIP_Real SCIPsetDualfeasFrac(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6796
void SCIPbranchruleEnableOrDisableClocks(SCIP_BRANCHRULE *branchrule, SCIP_Bool enable)
Definition: branch.c:2059
SCIP_RETCODE SCIPparamsetSetBool(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_Bool value)
Definition: paramset.c:1993
int SCIPdispGetPosition(SCIP_DISP *disp)
Definition: disp.c:376
#define SCIP_DEFAULT_DISP_VERBLEVEL
Definition: set.c:188
#define SCIPsetDebugMsg
Definition: set.h:1721
SCIP_RETCODE SCIPbendersFree(SCIP_BENDERS **benders, SCIP_SET *set)
Definition: benders.c:1269
SCIP_Bool SCIPsetIsRelLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6886
#define SCIP_DEFAULT_LP_LEXDUALSTALLING
Definition: set.c:273
SCIP_RETCODE SCIPparamsetCopyParams(SCIP_PARAMSET *sourceparamset, SCIP_PARAMSET *targetparamset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
Definition: paramset.c:4236
SCIP_Real SCIPsetDualfeasRound(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6785
void SCIPsetDebugMessagePrint(SCIP_SET *set, const char *formatstr,...)
Definition: set.c:7152
#define SCIP_DEFAULT_BRANCH_LPGAINNORMALIZE
Definition: set.c:78
const char * SCIPpricerGetName(SCIP_PRICER *pricer)
Definition: pricer.c:588
#define SCIP_DEFAULT_CONCURRENT_MAXNSOLS
Definition: set.c:542
#define SCIP_DEFAULT_SEPA_MINORTHOROOT
Definition: set.c:485
#define SCIP_DEFAULT_MEM_ARRAYGROWFAC
Definition: def.h:291
SCIP_RETCODE SCIPparamsetSetPresolving(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: paramset.c:4145
SCIP_RETCODE SCIPtableCopyInclude(SCIP_TABLE *table, SCIP_SET *set)
Definition: table.c:46
#define SCIP_DEFAULT_CONF_USEPSEUDO
Definition: set.c:119
#define SCIP_DEFAULT_CONF_WEIGHTREPROPDEPTH
Definition: set.c:166
void SCIPheurEnableOrDisableClocks(SCIP_HEUR *heur, SCIP_Bool enable)
Definition: heur.c:1595
#define EPSLE(x, y, eps)
Definition: def.h:190
void SCIPrelaxEnableOrDisableClocks(SCIP_RELAX *relax, SCIP_Bool enable)
Definition: relax.c:591
#define SCIP_DEFAULT_PRESOL_SUBRESTARTFAC
Definition: set.c:367
SCIP_RETCODE SCIPsetSetDefaultBoolParam(SCIP_SET *set, const char *name, SCIP_Bool defaultvalue)
Definition: set.c:3245
#define SCIP_DEFAULT_CONF_MINMAXVARS
Definition: set.c:98
BMS_BUFMEM * SCIPbuffer(SCIP *scip)
Definition: scip_mem.c:63
SCIP_RETCODE SCIPsetAddStringParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, char **valueptr, SCIP_Bool isadvanced, const char *defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: set.c:3051
SCIP_RETCODE SCIPautoselectDisps(SCIP *scip)
Definition: scip_disp.c:123
SCIP_RETCODE SCIPsetSetCharParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, char value)
Definition: set.c:3411
const char * SCIPconflicthdlrGetName(SCIP_CONFLICTHDLR *conflicthdlr)
Definition: conflict.c:763
SCIP_Bool SCIPsetIsSumNegative(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6330
int ntables
Definition: struct_set.h:126
SCIP_HEUR * SCIPsetFindHeur(SCIP_SET *set, const char *name)
Definition: set.c:4519
SCIP_DIALOG ** dialogs
Definition: struct_set.h:88
#define SCIP_DEFAULT_CONF_WEIGHTSIZE
Definition: set.c:165
#define SCIP_DEFAULT_LIMIT_MEMORY
Definition: set.c:209
#define SCIP_DEFAULT_LP_RESOLVERESTORE
Definition: set.c:248
SCIP_DISP * SCIPsetFindDisp(SCIP_SET *set, const char *name)
Definition: set.c:4881
SCIP_Bool SCIPparamGetBool(SCIP_PARAM *param)
Definition: paramset.c:700
int nconflicthdlrs
Definition: struct_set.h:104
#define SCIP_DEFAULT_LP_LEXDUALBASIC
Definition: set.c:272
#define SCIP_DEFAULT_HISTORY_VALUEBASED
Definition: set.c:202
SCIP_RETCODE SCIPsetIncludeNodesel(SCIP_SET *set, SCIP_NODESEL *nodesel)
Definition: set.c:4686
SCIP_RETCODE SCIPpropInitpre(SCIP_PROP *prop, SCIP_SET *set)
Definition: prop.c:401
SCIP_Bool SCIPsetIsFeasLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6407
#define SCIP_DEFAULT_REOPT_SOLVELPDIFF
Definition: set.c:425
SCIP_Bool SCIPsetIsSumEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6218
SCIP_RETCODE SCIPparamsetAddInt(SCIP_PARAMSET *paramset, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: paramset.c:1517
#define SCIP_DEFAULT_LP_ITERLIM
Definition: set.c:231
#define SCIP_DEFAULT_CONCURRENT_INITSEED
Definition: set.c:531
SCIP_RETCODE SCIPsetGetCharParam(SCIP_SET *set, const char *name, char *value)
Definition: set.c:3151
#define SCIP_MAXTREEDEPTH
Definition: def.h:300
void SCIPmarkLimitChanged(SCIP *scip)
SCIP_Real SCIPsetGetReferencevalue(SCIP_SET *set)
Definition: set.c:5733
SCIP_EXPORT SCIP_Bool SCIPrelaxIsInitialized(SCIP_RELAX *relax)
Definition: relax.c:683
#define SCIP_DEFAULT_REOPT_SHRINKINNER
Definition: set.c:440
void SCIPsetEnableOrDisablePluginClocks(SCIP_SET *set, SCIP_Bool enabled)
Definition: set.c:857
SCIP_TABLE ** tables
Definition: struct_set.h:87
SCIP_PARAM * SCIPsetGetParam(SCIP_SET *set, const char *name)
Definition: set.c:3084
SCIP_Real SCIPsetFeasFrac(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6585
enum SCIP_ParamEmphasis SCIP_PARAMEMPHASIS
Definition: type_paramset.h:74
#define SCIP_REAL_MAX
Definition: def.h:164
SCIP_Bool SCIPsetIsDualfeasPositive(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6717
#define SCIP_DEFAULT_SEPA_CUTSELRESTART
Definition: set.c:494
int SCIPparamGetInt(SCIP_PARAM *param)
Definition: paramset.c:725
SCIP_RETCODE SCIPsetGetRealParam(SCIP_SET *set, const char *name, SCIP_Real *value)
Definition: set.c:3137
SCIP_RETCODE SCIPconshdlrExitpre(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2631
void SCIPnlpiSetPriority(SCIP_NLPI *nlpi, int priority)
Definition: nlpi.c:775
SCIP_RETCODE SCIPparamsetSetString(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, const char *value)
Definition: paramset.c:2225
#define EPSLT(x, y, eps)
Definition: def.h:189
#define SCIP_DEFAULT_SEPA_MAXSTALLROUNDS
Definition: set.c:506
#define SCIP_REAL_MIN
Definition: def.h:165
#define SCIP_DEFAULT_CONS_OBSOLETEAGE
Definition: set.c:180
#define SCIP_DEFAULT_LP_FASTMIP
Definition: set.c:266
SCIP_Bool SCIPsetIsSumPositive(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6319
SCIP_Real SCIPsetFeasFloor(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6552
#define SCIP_DEFAULT_CONF_USEPROP
Definition: set.c:105
#define SCIP_DEFAULT_CONF_PREFINFPROOF
Definition: set.c:120
#define EPSGT(x, y, eps)
Definition: def.h:191
SCIP_VAR ** b
Definition: circlepacking.c:56
int SCIPconcsolverGetIdx(SCIP_CONCSOLVER *concsolver)
Definition: concsolver.c:614
#define SCIP_DEFAULT_BRANCH_CHECKSBSOL
Definition: set.c:85
const char * SCIPnodeselGetName(SCIP_NODESEL *nodesel)
Definition: nodesel.c:1043
void SCIPsetSortBranchrules(SCIP_SET *set)
Definition: set.c:4819
int npricers
Definition: struct_set.h:99
#define SCIP_DEFAULT_CONF_FUIPLEVELS
Definition: set.c:132
#define SCIP_DEFAULT_INFINITY
Definition: def.h:168
#define SCIP_DEFAULT_SEPA_EFFICACYNORM
Definition: set.c:491
#define SCIP_DEFAULT_RANDOM_RANDSEEDSHIFT
Definition: set.c:339
int SCIPnodeselGetStdPriority(SCIP_NODESEL *nodesel)
Definition: nodesel.c:1063
#define SCIP_DEFAULT_MEM_PATHGROWINIT
Definition: set.c:299
#define SCIP_DEFAULT_LP_RESOLVEITERFAC
Definition: set.c:279
SCIP_RETCODE SCIPdialogCopyInclude(SCIP_DIALOG *dialog, SCIP_SET *set)
Definition: dialog.c:309
#define SCIP_DEFAULT_DUALFEASTOL
Definition: def.h:174
#define SCIP_DEFAULT_PARALLEL_MINNTHREADS
Definition: set.c:523
internal methods for conflict analysis
SCIP_BENDERS * SCIPsetFindBenders(SCIP_SET *set, const char *name)
Definition: set.c:3768
void SCIPsetSortPresols(SCIP_SET *set)
Definition: set.c:4094
SCIP_RETCODE SCIPsepaExit(SCIP_SEPA *sepa, SCIP_SET *set)
Definition: sepa.c:302
internal methods for tree compressions
void SCIPsetSortRelaxsName(SCIP_SET *set)
Definition: set.c:4183
SCIP_RETCODE SCIPsetResetParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name)
Definition: set.c:3494
void SCIPmessageVFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr, va_list ap)
Definition: message.c:624
#define SCIP_DEFAULT_DISP_HEADERFREQ
Definition: set.c:191
SCIP_RETCODE SCIPsetChgParamFixed(SCIP_SET *set, const char *name, SCIP_Bool fixed)
Definition: set.c:3179
void SCIPsetSortConflicthdlrs(SCIP_SET *set)
Definition: set.c:4021
#define SCIP_DEFAULT_PARALLEL_MODE
Definition: set.c:520
#define SCIP_DEFAULT_LP_CONDITIONLIMIT
Definition: set.c:261
#define SCIP_DEFAULT_CONS_DISABLEENFOPS
Definition: set.c:183
#define SCIP_DEFAULT_MISC_USECONSTABLE
Definition: set.c:306
#define SCIP_DEFAULT_SEPA_MAXCUTS
Definition: set.c:509
SCIP_RETCODE SCIPsetIncludeBranchrule(SCIP_SET *set, SCIP_BRANCHRULE *branchrule)
Definition: set.c:4775
#define SCIP_DEFAULT_WRITE_ALLCONSS
Definition: set.c:583
#define SCIP_DEFAULT_RANDOM_PERMUTATIONSEED
Definition: set.c:340
#define SCIP_DEFAULT_READ_DYNAMICROWS
Definition: set.c:573
SCIP_RETCODE SCIPbranchruleInit(SCIP_BRANCHRULE *branchrule, SCIP_SET *set)
Definition: branch.c:1412
SCIP_RETCODE SCIPbranchruleCopyInclude(SCIP_BRANCHRULE *branchrule, SCIP_SET *set)
Definition: branch.c:1247
#define SCIP_DEFAULT_CONF_RESTARTFAC
Definition: set.c:159
SCIP_Real SCIPsetSumCeil(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6352
#define SCIP_DEFAULT_CONCURRENT_PARAMSETPREFIX
Definition: set.c:546
SCIP_RETCODE SCIPtableExit(SCIP_TABLE *table, SCIP_SET *set)
Definition: table.c:203
SCIP_Bool SCIPconshdlrIsInitialized(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5176
SCIP_RETCODE SCIPpresolCopyInclude(SCIP_PRESOL *presol, SCIP_SET *set)
Definition: presol.c:75
SCIP_RETCODE SCIPparamsetAddReal(SCIP_PARAMSET *paramset, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: paramset.c:1577
SCIP_Real SCIPsetSumRound(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6363
#define SCIP_DEFAULT_SUMEPSILON
Definition: def.h:170
SCIP_PROP ** props
Definition: struct_set.h:78
SCIP_RETCODE SCIPheurExit(SCIP_HEUR *heur, SCIP_SET *set)
Definition: heur.c:1093
#define SCIP_DEFAULT_LP_DISABLECUTOFF
Definition: set.c:274
#define SCIP_DEFAULT_BARRIERCONVTOL
Definition: def.h:175
#define SCIP_DEFAULT_LIMIT_GAP
Definition: set.c:210
#define SCIP_DEFAULT_SEPA_POOLFREQ
Definition: set.c:514
SCIP_Bool SCIPsetIsSumRelLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:7018
int SCIPconshdlrGetCheckPriority(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5066
SCIP_RETCODE SCIPeventhdlrExitsol(SCIP_EVENTHDLR *eventhdlr, SCIP_SET *set)
Definition: event.c:261
#define SCIP_DEFAULT_REOPT_SEPAGLBINFSUBTREES
Definition: set.c:427
void SCIPmessageFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr,...)
Definition: message.c:609
#define SCIP_DEFAULT_SEPA_MAXCUTSROOT
Definition: set.c:510
#define SCIP_DEFAULT_READ_INITIALCONSS
Definition: set.c:570
SCIP_Bool SCIPsetIsGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6063
SCIP_RETCODE SCIPsetAddLongintParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Longint *valueptr, SCIP_Bool isadvanced, SCIP_Longint defaultvalue, SCIP_Longint minvalue, SCIP_Longint maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: set.c:2980
SCIP_MESSAGEHDLR * messagehdlr
Definition: struct_scip.h:66
#define SCIP_DEFAULT_CONF_DYNAMIC
Definition: set.c:122
SCIP_EXPORT const char * SCIPrelaxGetName(SCIP_RELAX *relax)
Definition: relax.c:527
#define SCIP_DEFAULT_NODESEL_CHILDSEL
Definition: set.c:348
#define SCIP_Real
Definition: def.h:163
internal methods for problem statistics
SCIP_RETCODE SCIPbranchruleFree(SCIP_BRANCHRULE **branchrule, SCIP_SET *set)
Definition: branch.c:1385
SCIP_RETCODE SCIPsetIncludeReader(SCIP_SET *set, SCIP_READER *reader)
Definition: set.c:3630
SCIP_PRICER ** pricers
Definition: struct_set.h:69
#define EPSROUND(x, eps)
Definition: def.h:198
SCIP_RETCODE SCIPconshdlrExitsol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool restart)
Definition: cons.c:2711
enum SCIP_Stage SCIP_STAGE
Definition: type_set.h:50
BMS_BUFMEM * SCIPcleanbuffer(SCIP *scip)
Definition: scip_mem.c:77
SCIP_BRANCHRULE * SCIPsetFindBranchrule(SCIP_SET *set, const char *name)
Definition: set.c:4799
#define SCIP_DEFAULT_REOPT_FORCEHEURRESTART
Definition: set.c:418
SCIP_Bool SCIPsetIsFeasPositive(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6506
#define SCIP_DEFAULT_CONF_MAXVARSDETECTIMPLIEDBOUNDS
Definition: set.c:161
SCIP_DEBUGSOLDATA * SCIPsetGetDebugSolData(SCIP_SET *set)
Definition: set.c:5744
SCIP_Real SCIPsetDualfeastol(SCIP_SET *set)
Definition: set.c:5904
#define SCIP_DEFAULT_BRANCH_MIDPULL
Definition: set.c:76
void SCIPsetSortPricers(SCIP_SET *set)
Definition: set.c:3715
#define SCIP_DEFAULT_SEPA_DIRCUTOFFDISTFAC
Definition: set.c:487
void SCIPparamsetFree(SCIP_PARAMSET **paramset, BMS_BLKMEM *blkmem)
Definition: paramset.c:1437
#define SCIP_DEFAULT_SEPA_OBJPARALFAC
Definition: set.c:486
SCIP_RETCODE SCIPsetFreeConcsolvers(SCIP_SET *set)
Definition: set.c:4473
#define SCIP_DEFAULT_CONF_CONFLITWEIGHT
Definition: set.c:163
SCIP_RETCODE SCIPbendersInit(SCIP_BENDERS *benders, SCIP_SET *set)
Definition: benders.c:1989
SCIP_RETCODE SCIPparamsetRead(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *filename)
Definition: paramset.c:2563
#define BMSallocMemory(ptr)
Definition: memory.h:111
#define SCIP_INVALID
Definition: def.h:183
#define BMSreallocMemoryArray(ptr, num)
Definition: memory.h:119
int nnlpis
Definition: struct_set.h:130
#define SCIP_DEFAULT_CONF_PREFERBINARY
Definition: set.c:141
SCIP_RETCODE SCIPparamsetSetLongint(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_Longint value)
Definition: paramset.c:2123
internal methods for constraints and constraint handlers
SCIP_RETCODE SCIPparamsetSetChar(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, char value)
Definition: paramset.c:2191
SCIP_RETCODE SCIPpresolExitpre(SCIP_PRESOL *presol, SCIP_SET *set)
Definition: presol.c:355
#define SCIP_Longint
Definition: def.h:148
#define SCIP_DEFAULT_DECOMP_BENDERSLABELS
Definition: set.c:392
SCIP_RETCODE SCIPsetSetDefaultIntParam(SCIP_SET *set, const char *name, int defaultvalue)
Definition: set.c:3298
SCIP_RETCODE SCIPsetSetDualfeastol(SCIP_SET *set, SCIP_Real dualfeastol)
Definition: set.c:5647
SCIP_Bool SCIPsetIsDualfeasZero(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6706
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4167
void SCIPconflicthdlrEnableOrDisableClocks(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_Bool enable)
Definition: conflict.c:817
SCIP_Bool SCIPsetIsFeasGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6451
#define SCIP_DEFAULT_SEPA_INTSUPPORTFAC
Definition: set.c:489
SCIP_Bool SCIPparamsetIsFixed(SCIP_PARAMSET *paramset, const char *name)
Definition: paramset.c:1681
SCIP_RETCODE SCIPsetChgStringParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAM *param, const char *value)
Definition: set.c:3426
SCIP_RETCODE SCIPsetGetLongintParam(SCIP_SET *set, const char *name, SCIP_Longint *value)
Definition: set.c:3123
SCIP_Real SCIPsetRecompfac(SCIP_SET *set)
Definition: set.c:5977
SCIP_RETCODE SCIPsetSetVerbLevel(SCIP_SET *set, SCIP_VERBLEVEL verblevel)
Definition: set.c:5607
int SCIPconshdlrGetEnfoPriority(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5056
#define SCIP_DEFAULT_PRICE_MAXVARSROOT
Definition: set.c:383
SCIP_RETCODE SCIPparamsetGetChar(SCIP_PARAMSET *paramset, const char *name, char *value)
Definition: paramset.c:1843
SCIP_RETCODE SCIPsetChgCharParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAM *param, char value)
Definition: set.c:3388
SCIP_Real SCIPsetEpsilon(SCIP_SET *set)
Definition: set.c:5874
SCIP_STAGE SCIPsetGetStage(SCIP_SET *set)
Definition: set.c:2924
#define SCIP_DEFAULT_MISC_USESYMMETRY
Definition: set.c:329
SCIP_RETCODE SCIPactivatePricer(SCIP *scip, SCIP_PRICER *pricer)
Definition: scip_pricer.c:375
SCIP_PARAM ** SCIPparamsetGetParams(SCIP_PARAMSET *paramset)
Definition: paramset.c:4212
#define SCIP_DEFAULT_CONF_SCOREFAC
Definition: set.c:155
#define SCIP_DEFAULT_BRANCH_PREFERBINARY
Definition: set.c:72
SCIP_Bool SCIPsetIsUbBetter(SCIP_SET *set, SCIP_Real newub, SCIP_Real oldlb, SCIP_Real oldub)
Definition: set.c:6831
int nconshdlrs
Definition: struct_set.h:102
const char * SCIPdispGetName(SCIP_DISP *disp)
Definition: disp.c:326
SCIP_RETCODE SCIPchgDualfeastol(SCIP *scip, SCIP_Real dualfeastol)
SCIP_Bool SCIPsetIsDualfeasNegative(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6728
#define EPSFLOOR(x, eps)
Definition: def.h:196
#define SCIP_DEFAULT_LP_CHECKSTABILITY
Definition: set.c:260
SCIP_Real SCIPsetSumFrac(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6374
#define SCIP_MINEPSILON
Definition: def.h:182
const char * SCIPbendersGetName(SCIP_BENDERS *benders)
Definition: benders.c:5905
SCIP_RETCODE SCIPparamsetAddBool(SCIP_PARAMSET *paramset, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: paramset.c:1490
SCIP_RETCODE SCIPparamSetReal(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Real value, SCIP_Bool initialize, SCIP_Bool quiet)
Definition: paramset.c:4608
common defines and data types used in all packages of SCIP
#define SCIP_DEFAULT_VISUAL_VBCFILENAME
Definition: set.c:560
SCIP_RETCODE SCIPchgBarrierconvtol(SCIP *scip, SCIP_Real barrierconvtol)
struct BMS_BlkMem BMS_BLKMEM
Definition: memory.h:429
SCIP_RETCODE SCIPconshdlrFree(SCIP_CONSHDLR **conshdlr, SCIP_SET *set)
Definition: cons.c:2344
SCIP_RETCODE SCIPsetAddRealParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: set.c:3004
SCIP_RETCODE SCIPsetExitPlugins(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_STAT *stat)
Definition: set.c:5200
#define SCIP_DEFAULT_VISUAL_DISPSOLS
Definition: set.c:563
internal methods for primal heuristics
#define SCIP_DEFAULT_LP_CHECKDUALFEAS
Definition: set.c:264
SCIP_STAGE SCIPgetStage(SCIP *scip)
Definition: scip_general.c:356
SCIP_RETCODE SCIPsetGetBoolParam(SCIP_SET *set, const char *name, SCIP_Bool *value)
Definition: set.c:3095
SCIP_RETCODE SCIPconflicthdlrCopyInclude(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)
Definition: conflict.c:380
SCIP_RETCODE SCIPheurExitsol(SCIP_HEUR *heur, SCIP_SET *set)
Definition: heur.c:1153
SCIP_DISP ** disps
Definition: struct_set.h:86
#define SCIP_DEFAULT_SEPA_MAXROUNDSROOT
Definition: set.c:498
SCIP_RETCODE SCIPsetExitprePlugins(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_STAT *stat)
Definition: set.c:5344
SCIP_RETCODE SCIPchgFeastol(SCIP *scip, SCIP_Real feastol)
#define SCIP_DEFAULT_CONF_RECONVLEVELS
Definition: set.c:128
int npresols
Definition: struct_set.h:106
#define SCIP_DEFAULT_CONF_ALLOWLOCAL
Definition: set.c:142
#define SCIP_ALLOC(x)
Definition: def.h:375
#define SCIP_DEFAULT_LP_CHECKPRIMFEAS
Definition: set.c:263
SCIP_RETCODE SCIPsepaExitsol(SCIP_SEPA *sepa, SCIP_SET *set)
Definition: sepa.c:359
#define SCIP_DEFAULT_CONF_SEPAALTPROOFS
Definition: set.c:172
SCIP_Bool SCIPsetIsRelGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6952
SCIP_RETCODE SCIPsetAddBoolParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: set.c:2934
SCIP_Bool SCIPsetIsDualfeasLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6618
SCIP_RETCODE SCIPsetIncludeConflicthdlr(SCIP_SET *set, SCIP_CONFLICTHDLR *conflicthdlr)
Definition: set.c:3977
void SCIPsetSortSepas(SCIP_SET *set)
Definition: set.c:4242
SCIP_RETCODE SCIPsetSetBoolParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_Bool value)
Definition: set.c:3230
SCIP_Bool SCIPsetIsFracIntegral(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6161
#define SCIP_DEFAULT_NLP_DISABLE
Definition: set.c:290
#define SCIP_DEFAULT_CONCURRENT_CHANGECHILDSEL
Definition: set.c:528
#define SCIP_DEFAULT_MEM_ARRAYGROWINIT
Definition: def.h:292
#define SCIP_DEFAULT_PARALLEL_MAXNTHREADS
Definition: set.c:524
#define SCIP_DEFAULT_CONCURRENT_FREQINIT
Definition: set.c:532
#define SCIP_DEFAULT_LP_REFACTORINTERVAL
Definition: set.c:284
SCIP_RETCODE SCIPpresolInitpre(SCIP_PRESOL *presol, SCIP_SET *set)
Definition: presol.c:320
SCIP_RETCODE SCIPsetIncludeDisp(SCIP_SET *set, SCIP_DISP *disp)
Definition: set.c:4849
#define SCIP_DEFAULT_SEPA_MAXADDROUNDS
Definition: set.c:500
SCIP_Real SCIPsetLPFeastolFactor(SCIP_SET *set)
Definition: set.c:5914
#define SCIP_DEFAULT_HISTORY_ALLOWMERGE
Definition: set.c:203
SCIP_CONCSOLVERTYPE * SCIPsetFindConcsolverType(SCIP_SET *set, const char *name)
Definition: set.c:4429
int subscipdepth
Definition: struct_stat.h:205
#define EPSZ(x, eps)
Definition: def.h:193
SCIP_RETCODE SCIPpropExit(SCIP_PROP *prop, SCIP_SET *set)
Definition: prop.c:371
SCIP_RETCODE SCIPpropFree(SCIP_PROP **prop, SCIP_SET *set)
Definition: prop.c:275
SCIP_EVENTHDLR ** eventhdlrs
Definition: struct_set.h:82
#define SCIP_DEFAULT_BRANCH_SUMADJUSTSCORE
Definition: set.c:87
SCIP callable library.
int SCIPnodeselGetMemsavePriority(SCIP_NODESEL *nodesel)
Definition: nodesel.c:1087
SCIP_Bool SCIPsetIsFeasNegative(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6517
SCIP_RETCODE SCIPnlpiCopy(BMS_BLKMEM *blkmem, SCIP_NLPI *sourcenlpi, SCIP_NLPI **targetnlpi)
Definition: nlpi.c:166
SCIP_RETCODE SCIPpropExitsol(SCIP_PROP *prop, SCIP_SET *set, SCIP_Bool restart)
Definition: prop.c:485
SCIP_RETCODE SCIPeventhdlrInit(SCIP_EVENTHDLR *eventhdlr, SCIP_SET *set)
Definition: event.c:171
#define SCIP_DEFAULT_PSEUDOCOSTDELTA
Definition: def.h:178
SCIP_Bool SCIPconshdlrIsClonable(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5186
void SCIPsetSortBranchrulesName(SCIP_SET *set)
Definition: set.c:4834
#define SCIP_DEFAULT_BRANCH_DIVINGPSCOST
Definition: set.c:80
#define SCIP_DEFAULT_PROP_MAXROUNDS
Definition: set.c:462
SCIP_Bool SCIPeventhdlrIsInitialized(SCIP_EVENTHDLR *eventhdlr)
Definition: event.c:423
char * SCIPconcsolverTypeGetName(SCIP_CONCSOLVERTYPE *concsolvertype)
Definition: concsolver.c:181
SCIP_RETCODE SCIPrelaxExitsol(SCIP_RELAX *relax, SCIP_SET *set)
Definition: relax.c:319
int SCIPsetGetPriceMaxvars(SCIP_SET *set, SCIP_Bool root)
Definition: set.c:5705
SCIP_RETCODE SCIPparamsetSet(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, void *value)
Definition: paramset.c:1931
const char * SCIPnlpiGetName(SCIP_NLPI *nlpi)
Definition: nlpi.c:745
internal methods for displaying runtime statistics
void SCIPsetSortPricersName(SCIP_SET *set)
Definition: set.c:3730