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