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