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