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