Scippy

SCIP

Solving Constraint Integer Programs

set.c
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright (C) 2002-2014 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not email to scip@zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file set.c
17  * @brief methods for global SCIP settings
18  * @author Tobias Achterberg
19  * @author Timo Berthold
20  *
21  * @todo Functions like SCIPsetFeastol() are misleading (it seems that the feasibility tolerance can be set).
22  * Rename all functions starting with SCIPsetXXX, e.g., SCIPsetGetFeastol() and SCIPsetSetFeastol().
23  */
24 
25 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
26 
27 #include <assert.h>
28 #include <string.h>
29 #include <math.h>
30 
31 #include "scip/def.h"
32 #include "scip/set.h"
33 #include "scip/stat.h"
34 #include "scip/clock.h"
35 #include "scip/event.h"
36 #include "scip/lp.h"
37 #include "scip/paramset.h"
38 #include "scip/scip.h"
39 #include "scip/branch.h"
40 #include "scip/conflict.h"
41 #include "scip/cons.h"
42 #include "scip/disp.h"
43 #include "scip/dialog.h"
44 #include "scip/heur.h"
45 #include "scip/nodesel.h"
46 #include "scip/presol.h"
47 #include "scip/pricer.h"
48 #include "scip/reader.h"
49 #include "scip/relax.h"
50 #include "scip/sepa.h"
51 #include "scip/prop.h"
52 #include "nlpi/nlpi.h"
53 
54 /*
55  * Default settings
56  */
57 
58 
59 /* Branching */
60 
61 #define SCIP_DEFAULT_BRANCH_SCOREFUNC 'p' /**< branching score function ('s'um, 'p'roduct) */
62 #define SCIP_DEFAULT_BRANCH_SCOREFAC 0.167 /**< branching score factor to weigh downward and upward gain prediction
63  * in sum score function */
64 #define SCIP_DEFAULT_BRANCH_PREFERBINARY FALSE /**< should branching on binary variables be preferred? */
65 #define SCIP_DEFAULT_BRANCH_CLAMP 0.2 /**< minimal fractional distance of branching point to a continuous variable'
66  * bounds; a value of 0.5 leads to branching always in the middle of a bounded domain */
67 #define SCIP_DEFAULT_BRANCH_LPGAINNORMALIZE 's' /**< strategy for normalizing LP gain when updating pseudo costs of continuous variables */
68 #define SCIP_DEFAULT_BRANCH_DELAYPSCOST TRUE /**< should updating pseudo costs of continuous variables be delayed to after separation */
69 #define SCIP_DEFAULT_BRANCH_FORCEALL FALSE /**< should all strong branching children be regarded even if
70  * one is detected to be infeasible? (only with propagation) */
71 #define SCIP_DEFAULT_BRANCH_FIRSTSBCHILD 'a' /**< child node to be regarded first during strong branching (only with propagation): 'u'p child, 'd'own child, or 'a'utomatic */
72 #define SCIP_DEFAULT_BRANCH_CHECKSBSOL TRUE /**< should LP solutions during strong branching with propagation be checked for feasibility? */
73 #define SCIP_DEFAULT_BRANCH_ROUNDSBSOL TRUE /**< should LP solutions during strong branching with propagation be rounded? (only when checksbsol=TRUE) */
74 
75 /* Conflict Analysis */
76 
77 #define SCIP_DEFAULT_CONF_MAXVARSFAC 0.10 /**< maximal fraction of variables involved in a conflict constraint */
78 #define SCIP_DEFAULT_CONF_MINMAXVARS 30 /**< minimal absolute maximum of variables involved in a conflict constraint */
79 #define SCIP_DEFAULT_CONF_MAXLPLOOPS 2 /**< maximal number of LP resolving loops during conflict analysis
80  * (-1: no limit) */
81 #define SCIP_DEFAULT_CONF_LPITERATIONS 10 /**< maximal number of LP iterations in each LP resolving loop
82  * (-1: no limit) */
83 #define SCIP_DEFAULT_CONF_FUIPLEVELS -1 /**< number of depth levels up to which first UIP's are used in conflict
84  * analysis (-1: use All-FirstUIP rule) */
85 #define SCIP_DEFAULT_CONF_INTERCONSS -1 /**< maximal number of intermediate conflict constraints generated in
86  * conflict graph (-1: use every intermediate constraint) */
87 #define SCIP_DEFAULT_CONF_MAXCONSS 10 /**< maximal number of conflict constraints accepted at an infeasible node
88  * (-1: use all generated conflict constraints) */
89 #define SCIP_DEFAULT_CONF_RECONVLEVELS -1 /**< number of depth levels up to which UIP reconvergence constraints are
90  * generated (-1: generate reconvergence constraints in all depth levels) */
91 #define SCIP_DEFAULT_CONF_ENABLE TRUE /**< conflict analysis be enabled? */
92 #define SCIP_DEFAULT_CONF_USEPROP TRUE /**< should propagation conflict analysis be used? */
93 #define SCIP_DEFAULT_CONF_USEINFLP TRUE /**< should infeasible LP conflict analysis be used? */
94 #define SCIP_DEFAULT_CONF_USEBOUNDLP FALSE /**< should bound exceeding LP conflict analysis be used? */
95 #define SCIP_DEFAULT_CONF_USESB FALSE /**< should infeasible/bound exceeding strong branching conflict analysis
96  * be used? */
97 #define SCIP_DEFAULT_CONF_USEPSEUDO TRUE /**< should pseudo solution conflict analysis be used? */
98 #define SCIP_DEFAULT_CONF_PREFERBINARY FALSE /**< should binary conflicts be preferred? */
99 #define SCIP_DEFAULT_CONF_ALLOWLOCAL TRUE /**< should conflict constraints be generated that are only valid locally? */
100 #define SCIP_DEFAULT_CONF_SETTLELOCAL FALSE /**< should conflict constraints be attached only to the local subtree
101  * where they can be useful? */
102 #define SCIP_DEFAULT_CONF_REPROPAGATE TRUE /**< should earlier nodes be repropagated in order to replace branching
103  * decisions by deductions? */
104 #define SCIP_DEFAULT_CONF_KEEPREPROP TRUE /**< should constraints be kept for repropagation even if they are too long? */
105 #define SCIP_DEFAULT_CONF_SEPARATE TRUE /**< should the conflict constraints be separated? */
106 #define SCIP_DEFAULT_CONF_DYNAMIC TRUE /**< should the conflict constraints be subject to aging? */
107 #define SCIP_DEFAULT_CONF_REMOVEABLE TRUE /**< should the conflict's relaxations be subject to LP aging and cleanup? */
108 #define SCIP_DEFAULT_CONF_DEPTHSCOREFAC 1.0 /**< score factor for depth level in bound relaxation heuristic of LP analysis */
109 #define SCIP_DEFAULT_CONF_SCOREFAC 0.98 /**< factor to decrease importance of variables' earlier conflict scores */
110 #define SCIP_DEFAULT_CONF_RESTARTNUM 0 /**< number of successful conflict analysis calls that trigger a restart
111  * (0: disable conflict restarts) */
112 #define SCIP_DEFAULT_CONF_RESTARTFAC 1.5 /**< factor to increase restartnum with after each restart */
113 #define SCIP_DEFAULT_CONF_IGNORERELAXEDBD FALSE /**< should relaxed bounds be ignored? */
114 #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) */
115 #define SCIP_DEFAULT_CONF_FULLSHORTENCONFLICT TRUE /**< try to shorten the whole conflict set or terminate early (depending on the 'maxvarsdetectimpliedbounds' parameter) */
116 #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 */
117 #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 */
118 
119 
120 /* Constraints */
121 
122 #define SCIP_DEFAULT_CONS_AGELIMIT 0 /**< maximum age an unnecessary constraint can reach before it is deleted
123  * (0: dynamic adjustment, -1: constraints are never deleted) */
124 #define SCIP_DEFAULT_CONS_OBSOLETEAGE -1 /**< age of a constraint after which it is marked obsolete
125  * (0: dynamic adjustment, -1: constraints are never marked obsolete) */
126 #define SCIP_DEFAULT_CONS_DISABLEENFOPS FALSE /**< should enforcement of pseudo solution be disabled? */
127 
128 
129 /* Display */
130 
131 #define SCIP_DEFAULT_DISP_VERBLEVEL SCIP_VERBLEVEL_HIGH /**< verbosity level of output */
132 #define SCIP_DEFAULT_DISP_WIDTH 139 /**< maximal number of characters in a node information line */
133 #define SCIP_DEFAULT_DISP_FREQ 100 /**< frequency for displaying node information lines */
134 #define SCIP_DEFAULT_DISP_HEADERFREQ 15 /**< frequency for displaying header lines (every n'th node info line) */
135 #define SCIP_DEFAULT_DISP_LPINFO FALSE /**< should the LP solver display status messages? */
136 
137 
138 /* History */
139 
140 #define SCIP_DEFAULT_HISTORY_VALUEBASED FALSE /**< should statistics be collected for variable domain value pairs */
141 
142 /* Limits */
143 
144 #define SCIP_DEFAULT_LIMIT_TIME 1e+20 /**< maximal time in seconds to run */
145 #define SCIP_DEFAULT_LIMIT_MEMORY 1e+20 /**< maximal memory usage in MB */
146 #define SCIP_DEFAULT_LIMIT_GAP 0.0 /**< solving stops, if the gap is below the given value */
147 #define SCIP_DEFAULT_LIMIT_ABSGAP 0.0 /**< solving stops, if the absolute difference between primal and dual
148  * bound reaches this value */
149 #define SCIP_DEFAULT_LIMIT_NODES -1LL /**< maximal number of nodes to process (-1: no limit) */
150 #define SCIP_DEFAULT_LIMIT_STALLNODES -1LL /**< solving stops, if the given number of nodes was processed since the
151  * last improvement of the primal solution value (-1: no limit) */
152 #define SCIP_DEFAULT_LIMIT_SOLUTIONS -1 /**< solving stops, if given number of sols were found (-1: no limit) */
153 #define SCIP_DEFAULT_LIMIT_BESTSOL -1 /**< solving stops, if given number of solution improvements were found
154  * (-1: no limit) */
155 #define SCIP_DEFAULT_LIMIT_MAXSOL 100 /**< maximal number of solutions to store in the solution storage */
156 #define SCIP_DEFAULT_LIMIT_MAXORIGSOL 10 /**< maximal number of solutions candidates to store in the solution storage of the original problem */
157 #define SCIP_DEFAULT_LIMIT_RESTARTS -1 /**< solving stops, if the given number of restarts was triggered (-1: no limit) */
158 
159 
160 /* LP */
161 
162 #define SCIP_DEFAULT_LP_SOLVEFREQ 1 /**< frequency for solving LP at the nodes; -1: never; 0: only root LP */
163 #define SCIP_DEFAULT_LP_ITERLIM -1LL /**< iteration limit for each single LP solve; -1: no limit */
164 #define SCIP_DEFAULT_LP_ROOTITERLIM -1LL /**< iteration limit for initial root LP solve; -1: no limit */
165 #define SCIP_DEFAULT_LP_SOLVEDEPTH -1 /**< maximal depth for solving LPs (-1: no depth limit) */
166 #define SCIP_DEFAULT_LP_INITALGORITHM 's' /**< LP algorithm for solving initial LP relaxations ('s'implex, 'b'arrier,
167  * barrier with 'c'rossover) */
168 #define SCIP_DEFAULT_LP_RESOLVEALGORITHM 's' /**< LP algorithm for resolving LP relaxations if a starting basis exists
169  * ('s'implex, 'b'arrier, barrier with 'c'rossover) */
170 #define SCIP_DEFAULT_LP_PRICING 'l' /**< LP pricing strategy ('l'pi default, 'a'uto, 'f'ull pricing, 'p'artial,
171  * 's'teepest edge pricing, 'q'uickstart steepest edge pricing,
172  * 'd'evex pricing) */
173 #define SCIP_DEFAULT_LP_CLEARINITIALPROBINGLP TRUE/**< should lp state be cleared at the end of probing mode when lp
174  * was initially unsolved, e.g., when called right after presolving? */
175 #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)? */
176 #define SCIP_DEFAULT_LP_FREESOLVALBUFFERS FALSE /**< should the buffers for storing LP solution values during diving be freed at end of diving? */
177 #define SCIP_DEFAULT_LP_COLAGELIMIT 10 /**< maximum age a dynamic column can reach before it is deleted from SCIP_LP
178  * (-1: don't delete columns due to aging) */
179 #define SCIP_DEFAULT_LP_ROWAGELIMIT 10 /**< maximum age a dynamic row can reach before it is deleted from SCIP_LP
180  * (-1: don't delete rows due to aging) */
181 #define SCIP_DEFAULT_LP_CLEANUPCOLS FALSE /**< should new non-basic columns be removed after LP solving? */
182 #define SCIP_DEFAULT_LP_CLEANUPCOLSROOT FALSE /**< should new non-basic columns be removed after root LP solving? */
183 #define SCIP_DEFAULT_LP_CLEANUPROWS TRUE /**< should new basic rows be removed after LP solving? */
184 #define SCIP_DEFAULT_LP_CLEANUPROWSROOT TRUE /**< should new basic rows be removed after root LP solving? */
185 #define SCIP_DEFAULT_LP_CHECKSTABILITY TRUE /**< should LP solver's return status be checked for stability? */
186 #define SCIP_DEFAULT_LP_CONDITIONLIMIT -1.0 /**< maximum condition number of LP basis counted as stable (-1.0: no limit) */
187 #define SCIP_DEFAULT_LP_CHECKPRIMFEAS TRUE /**< should LP solutions be checked for primal feasibility to resolve LP at numerical troubles? */
188 #define SCIP_DEFAULT_LP_CHECKDUALFEAS TRUE /**< should LP solutions be checked for dual feasibility to resolve LP at numerical troubles? */
189 #define SCIP_DEFAULT_LP_FASTMIP 1 /**< should FASTMIP setting of LP solver be used? */
190 #define SCIP_DEFAULT_LP_SCALING TRUE /**< should scaling of LP solver be used? */
191 #define SCIP_DEFAULT_LP_PRESOLVING TRUE /**< should presolving of LP solver be used? */
192 #define SCIP_DEFAULT_LP_LEXDUALALGO FALSE /**< should the dual lexicographic algorithm be used? */
193 #define SCIP_DEFAULT_LP_LEXDUALROOTONLY TRUE /**< should the lexicographic dual algorithm be applied only at the root node */
194 #define SCIP_DEFAULT_LP_LEXDUALMAXROUNDS 2 /**< maximum number of rounds in the dual lexicographic algorithm */
195 #define SCIP_DEFAULT_LP_LEXDUALBASIC FALSE /**< choose fractional basic variables in lexicographic dual algorithm */
196 #define SCIP_DEFAULT_LP_LEXDUALSTALLING TRUE /**< turn on the lex dual algorithm only when stalling? */
197 #define SCIP_DEFAULT_LP_DISABLECUTOFF 2 /**< disable the cutoff bound in the LP solver? (0: enabled, 1: disabled, 2: auto) */
198 #define SCIP_DEFAULT_LP_ROWREPSWITCH -1.0 /**< simplex algorithm shall use row representation of the basis
199  * if number of rows divided by number of columns exceeds this value */
200 #define SCIP_DEFAULT_LP_THREADS 0 /**< number of threads used for solving the LP (0: automatic) */
201 #define SCIP_DEFAULT_LP_RESOLVEITERFAC -1.0 /**< factor of average LP iterations that is used as LP iteration limit
202  * for LP resolve (-1.0: unlimited) */
203 #define SCIP_DEFAULT_LP_RESOLVEITERMIN 1000 /**< minimum number of iterations that are allowed for LP resolve */
204 
205 /* NLP */
206 
207 #define SCIP_DEFAULT_NLP_SOLVER "" /**< name of NLP solver to use, or "" if solver should be chosen by priority */
208 #define SCIP_DEFAULT_NLP_DISABLE FALSE /**< should the NLP be always disabled? */
209 
210 /* Memory */
211 
212 #define SCIP_DEFAULT_MEM_SAVEFAC 0.8 /**< fraction of maximal mem usage when switching to memory saving mode */
213 #define SCIP_DEFAULT_MEM_ARRAYGROWFAC 1.2 /**< memory growing factor for dynamically allocated arrays */
214 #define SCIP_DEFAULT_MEM_TREEGROWFAC 2.0 /**< memory growing factor for tree array */
215 #define SCIP_DEFAULT_MEM_PATHGROWFAC 2.0 /**< memory growing factor for path array */
216 #define SCIP_DEFAULT_MEM_ARRAYGROWINIT 4 /**< initial size of dynamically allocated arrays */
217 #define SCIP_DEFAULT_MEM_TREEGROWINIT 65536 /**< initial size of tree array */
218 #define SCIP_DEFAULT_MEM_PATHGROWINIT 256 /**< initial size of path array */
219 
220 
221 /* Miscellaneous */
222 
223 #define SCIP_DEFAULT_MISC_CATCHCTRLC TRUE /**< should the CTRL-C interrupt be caught by SCIP? */
224 #define SCIP_DEFAULT_MISC_USEVARTABLE TRUE /**< should a hashtable be used to map from variable names to variables? */
225 #define SCIP_DEFAULT_MISC_USECONSTABLE TRUE /**< should a hashtable be used to map from constraint names to constraints? */
226 #define SCIP_DEFAULT_MISC_USESMALLTABLES FALSE /**< should smaller hashtables be used? yields better performance for small problems with about 100 variables */
227 #define SCIP_DEFAULT_MISC_PERMUTATIONSEED -1 /**< seed value for permuting the problem after the problem was transformed (-1: no permutation) */
228 #define SCIP_DEFAULT_MISC_PERMUTECONSS TRUE /**< should order of constraints be permuted (depends on permutationseed)? */
229 #define SCIP_DEFAULT_MISC_PERMUTEVARS FALSE /**< should order of variables be permuted (depends on permutationseed)? */
230 #define SCIP_DEFAULT_MISC_EXACTSOLVE FALSE /**< should the problem be solved exactly (with proven dual bounds)? */
231 #define SCIP_DEFAULT_MISC_RESETSTAT TRUE /**< should the statistics be reset if the transformed problem is
232  * freed otherwise the statistics get reset after original problem is
233  * freed (in case of Benders decomposition this parameter should be set
234  * to FALSE and therefore can be used to collect statistics over all
235  * runs) */
236 #define SCIP_DEFAULT_MISC_IMPROVINGSOLS FALSE /**< should only solutions be checked which improve the primal bound */
237 #define SCIP_DEFAULT_MISC_PRINTREASON TRUE /**< should the reason be printed if a given start solution is infeasible? */
238 #define SCIP_DEFAULT_MISC_ESTIMEXTERNMEM TRUE /**< should the usage of external memory be estimated? */
239 #define SCIP_DEFAULT_MISC_TRANSORIGSOLS TRUE /**< should SCIP try to transfer original solutions to the extended space (after presolving)? */
240 #define SCIP_DEFAULT_MISC_CALCINTEGRAL TRUE /**< should SCIP calculate the primal dual integral? */
241 #define SCIP_DEFAULT_MISC_FINITESOLSTORE FALSE /**< should SCIP try to remove infinite fixings from solutions copied to the solution store? */
242 
243 
244 /* Node Selection */
245 #define SCIP_DEFAULT_NODESEL_CHILDSEL 'h' /**< child selection rule ('d'own, 'u'p, 'p'seudo costs, 'i'nference, 'l'p value,
246  * 'r'oot LP value difference, 'h'brid inference/root LP value difference) */
247 
248 /* Presolving */
249 
250 #define SCIP_DEFAULT_PRESOL_ABORTFAC 1e-04 /**< abort presolve, if at most this fraction of the problem was changed
251  * in last presolve round */
252 #define SCIP_DEFAULT_PRESOL_MAXROUNDS -1 /**< maximal number of presolving rounds (-1: unlimited, 0: off) */
253 #define SCIP_DEFAULT_PRESOL_MAXRESTARTS -1 /**< maximal number of restarts (-1: unlimited) */
254 #define SCIP_DEFAULT_PRESOL_RESTARTFAC 0.05 /**< fraction of integer variables that were fixed in the root node
255  * triggering a restart with preprocessing after root node evaluation */
256 #define SCIP_DEFAULT_PRESOL_IMMRESTARTFAC 0.20 /**< fraction of integer variables that were fixed in the root node triggering an
257  * immediate restart with preprocessing */
258 #define SCIP_DEFAULT_PRESOL_SUBRESTARTFAC 1.00 /**< fraction of integer variables that were globally fixed during the
259  * solving process triggering a restart with preprocessing */
260 #define SCIP_DEFAULT_PRESOL_RESTARTMINRED 0.10 /**< minimal fraction of integer variables removed after restart to allow
261  * for an additional restart */
262 #define SCIP_DEFAULT_PRESOL_DONOTMULTAGGR FALSE /**< should multi-aggregation of variables be forbidden? */
263 #define SCIP_DEFAULT_PRESOL_DONOTAGGR FALSE /**< should aggregation of variables be forbidden? */
264 
265 /* Pricing */
266 
267 #define SCIP_DEFAULT_PRICE_ABORTFAC 2.0 /**< pricing is aborted, if fac * price_maxvars pricing candidates were
268  * found */
269 #define SCIP_DEFAULT_PRICE_MAXVARS 100 /**< maximal number of variables priced in per pricing round */
270 #define SCIP_DEFAULT_PRICE_MAXVARSROOT 2000 /**< maximal number of priced variables at the root node */
271 #define SCIP_DEFAULT_PRICE_DELVARS FALSE /**< should variables created at the current node be deleted when the node is solved
272  * in case they are not present in the LP anymore? */
273 #define SCIP_DEFAULT_PRICE_DELVARSROOT FALSE /**< should variables created at the root node be deleted when the root is solved
274  * in case they are not present in the LP anymore? */
275 
276 
277 /* Propagating */
278 
279 #define SCIP_DEFAULT_PROP_MAXROUNDS 100 /**< maximal number of propagation rounds per node (-1: unlimited) */
280 #define SCIP_DEFAULT_PROP_MAXROUNDSROOT 1000 /**< maximal number of propagation rounds in root node (-1: unlimited) */
281 #define SCIP_DEFAULT_PROP_ABORTONCUTOFF TRUE /**< should propagation be aborted immediately? setting this to FALSE could
282  * help conflict analysis to produce more conflict constraints */
283 
284 
285 /* Separation */
286 
287 #define SCIP_DEFAULT_SEPA_MAXBOUNDDIST 1.0 /**< maximal relative distance from current node's dual bound to primal
288  * bound compared to best node's dual bound for applying separation
289  * (0.0: only on current best node, 1.0: on all nodes) */
290 #define SCIP_DEFAULT_SEPA_MINEFFICACY 0.05 /**< minimal efficacy for a cut to enter the LP */
291 #define SCIP_DEFAULT_SEPA_MINEFFICACYROOT 0.001 /**< minimal efficacy for a cut to enter the LP in the root node */
292 #define SCIP_DEFAULT_SEPA_MINORTHO 0.50 /**< minimal orthogonality for a cut to enter the LP */
293 #define SCIP_DEFAULT_SEPA_MINORTHOROOT 0.50 /**< minimal orthogonality for a cut to enter the LP in the root node */
294 #define SCIP_DEFAULT_SEPA_OBJPARALFAC 0.0001 /**< factor to scale objective parallelism of cut in score calculation */
295 #define SCIP_DEFAULT_SEPA_ORTHOFAC 1.00 /**< factor to scale orthogonality of cut in score calculation */
296 #define SCIP_DEFAULT_SEPA_ORTHOFUNC 'e' /**< function used for calc. scalar prod. in orthogonality test ('e'uclidean, 'd'iscrete) */
297 #define SCIP_DEFAULT_SEPA_EFFICACYNORM 'e' /**< row norm to use for efficacy calculation ('e'uclidean, 'm'aximum,
298  * 's'um, 'd'iscrete) */
299 #define SCIP_DEFAULT_SEPA_MAXRUNS -1 /**< maximal number of runs for which separation is enabled (-1: unlimited) */
300 #define SCIP_DEFAULT_SEPA_MAXROUNDS 5 /**< maximal number of separation rounds per node (-1: unlimited) */
301 #define SCIP_DEFAULT_SEPA_MAXROUNDSROOT -1 /**< maximal number of separation rounds in the root node (-1: unlimited) */
302 #define SCIP_DEFAULT_SEPA_MAXROUNDSROOTSUBRUN 1 /**< maximal number of separation rounds in the root node of a subsequent run (-1: unlimited) */
303 #define SCIP_DEFAULT_SEPA_MAXADDROUNDS 1 /**< maximal additional number of separation rounds in subsequent
304  * price-and-cut loops (-1: no additional restriction) */
305 #define SCIP_DEFAULT_SEPA_MAXSTALLROUNDS 5 /**< maximal number of consecutive separation rounds without objective
306  * or integrality improvement (-1: no additional restriction) */
307 #define SCIP_DEFAULT_SEPA_MAXCUTS 100 /**< maximal number of cuts separated per separation round */
308 #define SCIP_DEFAULT_SEPA_MAXCUTSROOT 2000 /**< maximal separated cuts at the root node */
309 #define SCIP_DEFAULT_SEPA_CUTAGELIMIT 100 /**< maximum age a cut can reach before it is deleted from global cut pool
310  * (-1: cuts are never deleted from the global cut pool) */
311 #define SCIP_DEFAULT_SEPA_POOLFREQ 0 /**< separation frequency for the global cut pool */
312 #define SCIP_DEFAULT_SEPA_FEASTOLFAC -1.00 /**< factor on cut infeasibility to limit feasibility tolerance for relaxation solver (-1: off) */
313 
314 
315 /* Timing */
316 
317 #define SCIP_DEFAULT_TIME_CLOCKTYPE SCIP_CLOCKTYPE_CPU /**< default clock type for timing */
318 #define SCIP_DEFAULT_TIME_ENABLED TRUE /**< is timing enabled? */
319 #define SCIP_DEFAULT_TIME_READING FALSE /**< belongs reading time to solving time? */
320 #define SCIP_DEFAULT_TIME_RARECLOCKCHECK FALSE /**< should clock checks of solving time be performed less frequently (might exceed time limit slightly) */
321 #define SCIP_DEFAULT_TIME_STATISTICTIMING TRUE /**< should timing for statistic output be enabled? */
322 
323 /* VBC Tool output */
324 #define SCIP_DEFAULT_VBC_FILENAME "-" /**< name of the VBC Tool output file, or "-" if no output should be
325  * created */
326 #define SCIP_DEFAULT_VBC_REALTIME TRUE /**< should the real solving time be used instead of a time step counter
327  * in VBC output? */
328 #define SCIP_DEFAULT_VBC_DISPSOLS FALSE /**< should the node where solutions are found be visualized? */
329 
330 /* Reading */
331 #define SCIP_DEFAULT_READ_INITIALCONSS TRUE /**< should model constraints be marked as initial? */
332 #define SCIP_DEFAULT_READ_DYNAMICCONSS TRUE /**< should model constraints be subject to aging? */
333 #define SCIP_DEFAULT_READ_DYNAMICCOLS FALSE /**< should columns be added and removed dynamically to the LP? */
334 #define SCIP_DEFAULT_READ_DYNAMICROWS FALSE /**< should rows be added and removed dynamically to the LP? */
335 #define SCIP_DEFAULT_WRITE_GENNAMES_OFFSET 0 /**< when writing the problem with generic names, we start with index
336  * 0; using this parameter we can change the starting index to be
337  * different */
338 
339 /* Writing */
340 #define SCIP_DEFAULT_WRITE_ALLCONSS FALSE /**< should all constraints be written (including the redundant constraints)? */
341 
342 
343 
344 
345 /** calculate memory size for dynamically allocated arrays */
346 static
347 int calcGrowSize(
348  int initsize, /**< initial size of array */
349  SCIP_Real growfac, /**< growing factor of array */
350  int num /**< minimum number of entries to store */
351  )
352 {
353  int size;
354 
355  assert(initsize >= 0);
356  assert(growfac >= 1.0);
357  assert(num >= 0);
358 
359  if( growfac == 1.0 )
360  size = MAX(initsize, num);
361  else
362  {
363  int oldsize;
364 
365  /* calculate the size with this loop, such that the resulting numbers are always the same (-> block memory) */
366  initsize = MAX(initsize, 4);
367  size = initsize;
368  oldsize = size - 1;
369 
370  /* second condition checks against overflow */
371  while( size < num && size > oldsize )
372  {
373  oldsize = size;
374  size = (int)(growfac * size + initsize);
375  }
376 
377  /* if an overflow happened, set the correct value */
378  if( size <= oldsize )
379  size = num;
380  }
381 
382  assert(size >= initsize);
383  assert(size >= num);
384 
385  return size;
386 }
387 
388 
389 /** information method for a parameter change of feastol */
390 static
391 SCIP_DECL_PARAMCHGD(paramChgdFeastol)
392 { /*lint --e{715}*/
393  SCIP_Real newfeastol;
394 
395  newfeastol = SCIPparamGetReal(param);
396 
397  /* change the feastol through the SCIP call in order to adjust lpfeastol if necessary */
398  SCIP_CALL( SCIPchgFeastol(scip, newfeastol) );
399 
400  return SCIP_OKAY;
401 }
402 
403 /** information method for a parameter change of lpfeastol */
404 static
405 SCIP_DECL_PARAMCHGD(paramChgdLpfeastol)
406 { /*lint --e{715}*/
407  SCIP_Real newlpfeastol;
408 
409  newlpfeastol = SCIPparamGetReal(param);
410 
411  /* change the lpfeastol through the SCIP call in order to mark the LP unsolved and control that it does not exceed
412  * SCIP's feastol
413  */
414  SCIP_CALL( SCIPchgLpfeastol(scip, newlpfeastol, FALSE) );
415 
416  return SCIP_OKAY;
417 }
418 
419 /** information method for a parameter change of dualfeastol */
420 static
421 SCIP_DECL_PARAMCHGD(paramChgdDualfeastol)
422 { /*lint --e{715}*/
423  SCIP_Real newdualfeastol;
424 
425  newdualfeastol = SCIPparamGetReal(param);
426 
427  /* change the dualfeastol through the SCIP call in order to mark the LP unsolved */
428  SCIP_CALL( SCIPchgDualfeastol(scip, newdualfeastol) );
429 
430  return SCIP_OKAY;
431 }
432 
433 /** information method for a parameter change of barrierconvtol */
434 static
435 SCIP_DECL_PARAMCHGD(paramChgdBarrierconvtol)
436 { /*lint --e{715}*/
437  SCIP_Real newbarrierconvtol;
438 
439  newbarrierconvtol = SCIPparamGetReal(param);
440 
441  /* change the barrierconvtol through the SCIP call in order to mark the LP unsolved */
442  SCIP_CALL( SCIPchgBarrierconvtol(scip, newbarrierconvtol) );
443 
444  return SCIP_OKAY;
445 }
446 
447 /** parameter change information method to autoselect display columns again */
448 static
449 SCIP_DECL_PARAMCHGD(SCIPparamChgdDispWidth)
450 { /*lint --e{715}*/
451  /* automatically select the new active display columns */
452  SCIP_CALL( SCIPautoselectDisps(scip) );
453 
454  return SCIP_OKAY;
455 }
456 
457 /** parameter change information method that some limit was changed */
458 static
459 SCIP_DECL_PARAMCHGD(SCIPparamChgdLimit)
460 { /*lint --e{715}*/
461 
462  SCIPmarkLimitChanged(scip);
463  return SCIP_OKAY;
464 }
465 
466 /** enable or disable all plugin timers depending on the value of the flag \p enabled */
467 void SCIPsetEnableOrDisablePluginClocks(
468  SCIP_SET* set, /**< SCIP settings */
469  SCIP_Bool enabled /**< should plugin clocks be enabled? */
470  )
471 {
472  int i;
473 
474  assert(set != NULL);
475 
476  /* go through all plugin types and enable or disable their respective clocks */
477  for( i = set->nreaders - 1; i >= 0; --i )
478  SCIPreaderEnableOrDisableClocks(set->readers[i], enabled);
479 
480  for( i = set->npricers - 1; i >= 0; --i )
481  SCIPpricerEnableOrDisableClocks(set->pricers[i], enabled);
482 
483  for( i = set->nconshdlrs - 1; i >= 0; --i )
484  SCIPconshdlrEnableOrDisableClocks(set->conshdlrs[i], enabled);
485 
486  for( i = set->nconflicthdlrs - 1; i >= 0; --i )
487  SCIPconflicthdlrEnableOrDisableClocks(set->conflicthdlrs[i], enabled);
488 
489  for( i = set->npresols - 1; i >= 0; --i )
490  SCIPpresolEnableOrDisableClocks(set->presols[i], enabled);
491 
492  for( i = set->nrelaxs - 1; i >= 0; --i )
493  SCIPrelaxEnableOrDisableClocks(set->relaxs[i], enabled);
494 
495  for( i = set->nsepas - 1; i >= 0; --i )
496  SCIPsepaEnableOrDisableClocks(set->sepas[i], enabled);
497 
498  for( i = set->nprops - 1; i >= 0; --i )
499  SCIPpropEnableOrDisableClocks(set->props[i], enabled);
500 
501  for( i = set->nheurs - 1; i >= 0; --i )
502  SCIPheurEnableOrDisableClocks(set->heurs[i], enabled);
503 
504  for( i = set->neventhdlrs - 1; i >= 0; --i )
505  SCIPeventhdlrEnableOrDisableClocks(set->eventhdlrs[i], enabled);
506 
507  for( i = set->nnodesels - 1; i >= 0; --i )
508  SCIPnodeselEnableOrDisableClocks(set->nodesels[i], enabled);
509 
510  for( i = set->nbranchrules - 1; i >= 0; --i )
511  SCIPbranchruleEnableOrDisableClocks(set->branchrules[i], enabled);
512 }
513 
514 /* method to be invoked when the parameter timing/statistictiming is changed */
515 static
516 SCIP_DECL_PARAMCHGD(paramChgdStatistictiming)
517 { /*lint --e{715}*/
518  SCIP_CALL( SCIPenableOrDisableStatisticTiming(scip) );
519 
520  return SCIP_OKAY;
521 }
522 
523 
524 /** copies plugins from sourcescip to targetscip; in case that a constraint handler which does not need constraints
525  * cannot be copied, valid will return FALSE. All plugins can declare that, if their copy process failed, the
526  * copied SCIP instance might not represent the same problem semantics as the original.
527  * Note that in this case dual reductions might be invalid. */
528 SCIP_RETCODE SCIPsetCopyPlugins(
529  SCIP_SET* sourceset, /**< source SCIP_SET data structure */
530  SCIP_SET* targetset, /**< target SCIP_SET data structure */
531  SCIP_Bool copyreaders, /**< should the file readers be copied */
532  SCIP_Bool copypricers, /**< should the variable pricers be copied */
533  SCIP_Bool copyconshdlrs, /**< should the constraint handlers be copied */
534  SCIP_Bool copyconflicthdlrs, /**< should the conflict handlers be copied */
535  SCIP_Bool copypresolvers, /**< should the presolvers be copied */
536  SCIP_Bool copyrelaxators, /**< should the relaxators be copied */
537  SCIP_Bool copyseparators, /**< should the separators be copied */
538  SCIP_Bool copypropagators, /**< should the propagators be copied */
539  SCIP_Bool copyheuristics, /**< should the heuristics be copied */
540  SCIP_Bool copyeventhdlrs, /**< should the event handlers be copied */
541  SCIP_Bool copynodeselectors, /**< should the node selectors be copied */
542  SCIP_Bool copybranchrules, /**< should the branchrules be copied */
543  SCIP_Bool copydisplays, /**< should the display columns be copied */
544  SCIP_Bool copydialogs, /**< should the dialogs be copied */
545  SCIP_Bool copynlpis, /**< should the NLP interfaces be copied */
546  SCIP_Bool* allvalid /**< pointer to store whether all plugins were validly copied */
547  )
548 {
549  int p;
550  SCIP_Bool valid;
551 
552  assert(sourceset != NULL);
553  assert(targetset != NULL);
554  assert(sourceset != targetset);
555  assert(allvalid != NULL);
556 
557  *allvalid = TRUE;
558 
559  /* copy all reader plugins */
560  if( copyreaders && sourceset->readers != NULL )
561  {
562  for( p = sourceset->nreaders - 1; p >= 0; --p )
563  {
564  SCIP_CALL( SCIPreaderCopyInclude(sourceset->readers[p], targetset) );
565  }
566  }
567 
568  /* copy all variable pricer plugins */
569  if( copypricers && sourceset->pricers != NULL )
570  {
571  for( p = sourceset->npricers - 1; p >= 0; --p )
572  {
573  valid = FALSE;
574  SCIP_CALL( SCIPpricerCopyInclude(sourceset->pricers[p], targetset, &valid) );
575  *allvalid = *allvalid && valid;
576  if( SCIPpricerIsActive(sourceset->pricers[p]) )
577  {
578  SCIP_CALL( SCIPactivatePricer(targetset->scip, targetset->pricers[p]) );
579  }
580  }
581  }
582 
583  /* copy all constraint handler plugins */
584  if( copyconshdlrs && sourceset->conshdlrs_include != NULL )
585  {
586  /* copy them in order they were added to the sourcescip
587  *
588  * @note we only have to set the valid pointer to FALSE in case that a constraint handler, which does not need
589  * constraints, does not copy; in the case that a constraint handler does not copy and it needs constraint
590  * we will detect later that the problem is not valid if a constraint of that type exits
591  */
592  for( p = 0; p < sourceset->nconshdlrs; ++p )
593  {
594  if( SCIPconshdlrIsClonable(sourceset->conshdlrs_include[p]) )
595  {
596  valid = FALSE;
597  SCIP_CALL( SCIPconshdlrCopyInclude(sourceset->conshdlrs_include[p], targetset, &valid) );
598  *allvalid = *allvalid && valid;
599  SCIPdebugMessage("Copying conshdlr <%s> was%s valid.\n", SCIPconshdlrGetName(sourceset->conshdlrs_include[p]), valid ? "" : " not");
600  }
601  else if( !SCIPconshdlrNeedsCons(sourceset->conshdlrs_include[p]) )
602  {
603  SCIPdebugMessage("Copying Conshdlr <%s> without constraints not valid.\n", SCIPconshdlrGetName(sourceset->conshdlrs_include[p]));
604  *allvalid = FALSE;
605  }
606  }
607  }
608 
609  /* copy all conflict handler plugins */
610  if( copyconflicthdlrs && sourceset->conflicthdlrs != NULL )
611  {
612  for( p = sourceset->nconflicthdlrs - 1; p >= 0; --p )
613  {
614  SCIP_CALL( SCIPconflicthdlrCopyInclude(sourceset->conflicthdlrs[p], targetset) );
615  }
616  }
617 
618  /* copy all presolver plugins */
619  if( copypresolvers && sourceset->presols != NULL )
620  {
621  for( p = sourceset->npresols - 1; p >= 0; --p )
622  {
623  SCIP_CALL( SCIPpresolCopyInclude(sourceset->presols[p], targetset) );
624  }
625  }
626 
627 
628  /* copy all relaxator plugins */
629  if( copyrelaxators && sourceset->relaxs != NULL )
630  {
631  for( p = sourceset->nrelaxs - 1; p >= 0; --p )
632  {
633  SCIP_CALL( SCIPrelaxCopyInclude(sourceset->relaxs[p], targetset) );
634  }
635  }
636 
637 
638  /* copy all separator plugins */
639  if( copyseparators && sourceset->sepas != NULL )
640  {
641  for( p = sourceset->nsepas - 1; p >= 0; --p )
642  {
643  SCIP_CALL( SCIPsepaCopyInclude(sourceset->sepas[p], targetset) );
644  }
645  }
646 
647  /* copy all propagators plugins */
648  if( copypropagators && sourceset->props != NULL )
649  {
650  for( p = sourceset->nprops - 1; p >= 0; --p )
651  {
652  SCIP_CALL( SCIPpropCopyInclude(sourceset->props[p], targetset) );
653  }
654  }
655 
656  /* copy all primal heuristics plugins */
657  if( copyheuristics && sourceset->heurs != NULL )
658  {
659  for( p = sourceset->nheurs - 1; p >= 0; --p )
660  {
661  SCIP_CALL( SCIPheurCopyInclude(sourceset->heurs[p], targetset) );
662  }
663  }
664 
665 
666  /* copy all event handler plugins */
667  if( copyeventhdlrs && sourceset->eventhdlrs != NULL )
668  {
669  for( p = sourceset->neventhdlrs - 1; p >= 0; --p )
670  {
671  /* @todo: the copying process of event handlers is currently not checked for consistency */
672  SCIP_CALL( SCIPeventhdlrCopyInclude(sourceset->eventhdlrs[p], targetset) );
673  }
674  }
675 
676 
677  /* copy all node selector plugins */
678  if( copynodeselectors && sourceset->nodesels != NULL )
679  {
680  for( p = sourceset->nnodesels - 1; p >= 0; --p )
681  {
682  SCIP_CALL( SCIPnodeselCopyInclude(sourceset->nodesels[p], targetset) );
683  }
684  }
685 
686  /* copy all branchrule plugins */
687  if( copybranchrules && sourceset->branchrules != NULL )
688  {
689  for( p = sourceset->nbranchrules - 1; p >= 0; --p )
690  {
691  SCIP_CALL( SCIPbranchruleCopyInclude(sourceset->branchrules[p], targetset) );
692  }
693  }
694 
695 
696  /* copy all display plugins */
697  if( copydisplays && sourceset->disps != NULL )
698  {
699  for( p = sourceset->ndisps - 1; p >= 0; --p )
700  {
701  SCIP_CALL( SCIPdispCopyInclude(sourceset->disps[p], targetset) );
702  }
703  }
704 
705 
706  /* copy all dialog plugins */
707  if( copydialogs && sourceset->dialogs != NULL )
708  {
709  for( p = sourceset->ndialogs - 1; p >= 0; --p )
710  {
711  /* @todo: the copying process of dialog handlers is currently not checked for consistency */
712  SCIP_CALL( SCIPdialogCopyInclude(sourceset->dialogs[p], targetset) );
713  }
714  }
715 
716  /* copy all NLP interfaces */
717  if( copynlpis && sourceset->nlpis != NULL )
718  {
719  for( p = sourceset->nnlpis - 1; p >= 0; --p )
720  {
721  SCIP_NLPI* nlpicopy;
722 
723  SCIP_CALL( SCIPnlpiCopy(SCIPblkmem(targetset->scip), sourceset->nlpis[p], &nlpicopy) );
724  SCIP_CALL( SCIPincludeNlpi(targetset->scip, nlpicopy) );
725  }
726  }
727 
728  return SCIP_OKAY;
729 }
730 
731 /** copies parameters from sourcescip to targetscip */
732 SCIP_RETCODE SCIPsetCopyParams(
733  SCIP_SET* sourceset, /**< source SCIP_SET data structure */
734  SCIP_SET* targetset, /**< target SCIP_SET data structure */
735  SCIP_MESSAGEHDLR* messagehdlr /**< message handler of target SCIP */
736  )
737 {
738  assert(sourceset != NULL);
739  assert(targetset != NULL);
740  assert(sourceset != targetset);
741  assert(targetset->scip != NULL);
742 
743  SCIP_CALL( SCIPparamsetCopyParams(sourceset->paramset, targetset->paramset, targetset, messagehdlr) );
744 
745  return SCIP_OKAY;
746 }
747 
748 /** creates global SCIP settings */
749 SCIP_RETCODE SCIPsetCreate(
750  SCIP_SET** set, /**< pointer to SCIP settings */
751  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
752  BMS_BLKMEM* blkmem, /**< block memory */
753  SCIP* scip /**< SCIP data structure */
754  )
755 {
756  assert(set != NULL);
757  assert(scip != NULL);
758 
759  SCIP_ALLOC( BMSallocMemory(set) );
760 
761  (*set)->stage = SCIP_STAGE_INIT;
762  (*set)->scip = scip;
763 
764  SCIP_CALL( SCIPparamsetCreate(&(*set)->paramset, blkmem) );
765  SCIP_CALL( SCIPbufferCreate(&(*set)->buffer) );
766 
767  (*set)->readers = NULL;
768  (*set)->nreaders = 0;
769  (*set)->readerssize = 0;
770  (*set)->pricers = NULL;
771  (*set)->npricers = 0;
772  (*set)->nactivepricers = 0;
773  (*set)->pricerssize = 0;
774  (*set)->pricerssorted = FALSE;
775  (*set)->pricersnamesorted = FALSE;
776  (*set)->conshdlrs = NULL;
777  (*set)->conshdlrs_sepa = NULL;
778  (*set)->conshdlrs_enfo = NULL;
779  (*set)->conshdlrs_include = NULL;
780  (*set)->nconshdlrs = 0;
781  (*set)->conshdlrssize = 0;
782  (*set)->conflicthdlrs = NULL;
783  (*set)->nconflicthdlrs = 0;
784  (*set)->conflicthdlrssize = 0;
785  (*set)->conflicthdlrssorted = FALSE;
786  (*set)->conflicthdlrsnamesorted = FALSE;
787  (*set)->presols = NULL;
788  (*set)->npresols = 0;
789  (*set)->presolssize = 0;
790  (*set)->presolssorted = FALSE;
791  (*set)->presolsnamesorted = FALSE;
792  (*set)->relaxs = NULL;
793  (*set)->nrelaxs = 0;
794  (*set)->relaxssize = 0;
795  (*set)->relaxssorted = FALSE;
796  (*set)->relaxsnamesorted = FALSE;
797  (*set)->sepas = NULL;
798  (*set)->nsepas = 0;
799  (*set)->sepassize = 0;
800  (*set)->sepassorted = FALSE;
801  (*set)->sepasnamesorted = FALSE;
802  (*set)->props = NULL;
803  (*set)->nprops = 0;
804  (*set)->propssize = 0;
805  (*set)->propssorted = FALSE;
806  (*set)->propspresolsorted = FALSE;
807  (*set)->propsnamesorted = FALSE;
808  (*set)->heurs = NULL;
809  (*set)->nheurs = 0;
810  (*set)->heurssize = 0;
811  (*set)->heurssorted = FALSE;
812  (*set)->heursnamesorted = FALSE;
813  (*set)->eventhdlrs = NULL;
814  (*set)->neventhdlrs = 0;
815  (*set)->eventhdlrssize = 0;
816  (*set)->nodesels = NULL;
817  (*set)->nnodesels = 0;
818  (*set)->nodeselssize = 0;
819  (*set)->nodesel = NULL;
820  (*set)->branchrules = NULL;
821  (*set)->nbranchrules = 0;
822  (*set)->branchrulessize = 0;
823  (*set)->branchrulessorted = FALSE;
824  (*set)->branchrulesnamesorted = FALSE;
825  (*set)->disps = NULL;
826  (*set)->ndisps = 0;
827  (*set)->dispssize = 0;
828  (*set)->dialogs = NULL;
829  (*set)->ndialogs = 0;
830  (*set)->dialogssize = 0;
831  (*set)->nlpis = NULL;
832  (*set)->nnlpis = 0;
833  (*set)->nlpissize = 0;
834  (*set)->nlpissorted = FALSE;
835  (*set)->limitchanged = FALSE;
836  (*set)->nlpenabled = FALSE;
837  (*set)->extcodenames = NULL;
838  (*set)->extcodedescs = NULL;
839  (*set)->nextcodes = 0;
840  (*set)->extcodessize = 0;
841  (*set)->vbc_filename = NULL;
842  (*set)->nlp_solver = NULL;
843  (*set)->nlp_disable = FALSE;
844  (*set)->mem_externestim = 0;
845  (*set)->sepa_primfeastol = SCIP_INVALID;
846 
847  /* branching parameters */
848  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
849  "branching/scorefunc",
850  "branching score function ('s'um, 'p'roduct, 'q'uotient)",
851  &(*set)->branch_scorefunc, TRUE, SCIP_DEFAULT_BRANCH_SCOREFUNC, "spq",
852  NULL, NULL) );
853  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
854  "branching/scorefac",
855  "branching score factor to weigh downward and upward gain prediction in sum score function",
856  &(*set)->branch_scorefac, TRUE, SCIP_DEFAULT_BRANCH_SCOREFAC, 0.0, 1.0,
857  NULL, NULL) );
858  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
859  "branching/preferbinary",
860  "should branching on binary variables be preferred?",
861  &(*set)->branch_preferbinary, FALSE, SCIP_DEFAULT_BRANCH_PREFERBINARY,
862  NULL, NULL) );
863  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
864  "branching/clamp",
865  "minimal relative distance of branching point to bounds when branching on a continuous variable",
866  &(*set)->branch_clamp, FALSE, SCIP_DEFAULT_BRANCH_CLAMP, 0.0, 0.5,
867  NULL, NULL) );
868  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
869  "branching/lpgainnormalize",
870  "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)",
871  &(*set)->branch_lpgainnorm, FALSE, SCIP_DEFAULT_BRANCH_LPGAINNORMALIZE, "dls",
872  NULL, NULL) );
873  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
874  "branching/delaypscostupdate",
875  "should updating pseudo costs for continuous variables be delayed to the time after separation?",
876  &(*set)->branch_delaypscost, FALSE, SCIP_DEFAULT_BRANCH_DELAYPSCOST,
877  NULL, NULL) );
878  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
879  "branching/forceallchildren",
880  "should all strong branching children be regarded even if one is detected to be infeasible? (only with propagation)",
881  &(*set)->branch_forceall, TRUE, SCIP_DEFAULT_BRANCH_FORCEALL,
882  NULL, NULL) );
883  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
884  "branching/firstsbchild",
885  "child node to be regarded first during strong branching (only with propagation): 'u'p child, 'd'own child, or 'a'utomatic",
886  &(*set)->branch_firstsbchild, TRUE, SCIP_DEFAULT_BRANCH_FIRSTSBCHILD, "adu",
887  NULL, NULL) );
888  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
889  "branching/checksol",
890  "should LP solutions during strong branching with propagation be checked for feasibility?",
891  &(*set)->branch_checksbsol, TRUE, SCIP_DEFAULT_BRANCH_CHECKSBSOL,
892  NULL, NULL) );
893  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
894  "branching/roundsbsol",
895  "should LP solutions during strong branching with propagation be rounded? (only when checksbsol=TRUE)",
896  &(*set)->branch_roundsbsol, TRUE, SCIP_DEFAULT_BRANCH_ROUNDSBSOL,
897  NULL, NULL) );
898 
899  /* conflict analysis parameters */
900  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
901  "conflict/enable",
902  "should conflict analysis be enabled?",
903  &(*set)->conf_enable, FALSE, SCIP_DEFAULT_CONF_ENABLE,
904  NULL, NULL) );
905  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
906  "conflict/useprop",
907  "should propagation conflict analysis be used?",
908  &(*set)->conf_useprop, FALSE, SCIP_DEFAULT_CONF_USEPROP,
909  NULL, NULL) );
910  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
911  "conflict/useinflp",
912  "should infeasible LP conflict analysis be used?",
913  &(*set)->conf_useinflp, FALSE, SCIP_DEFAULT_CONF_USEINFLP,
914  NULL, NULL) );
915  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
916  "conflict/useboundlp",
917  "should bound exceeding LP conflict analysis be used?",
918  &(*set)->conf_useboundlp, FALSE, SCIP_DEFAULT_CONF_USEBOUNDLP,
919  NULL, NULL) );
920  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
921  "conflict/usesb",
922  "should infeasible/bound exceeding strong branching conflict analysis be used?",
923  &(*set)->conf_usesb, FALSE, SCIP_DEFAULT_CONF_USESB,
924  NULL, NULL) );
925  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
926  "conflict/usepseudo",
927  "should pseudo solution conflict analysis be used?",
928  &(*set)->conf_usepseudo, FALSE, SCIP_DEFAULT_CONF_USEPSEUDO,
929  NULL, NULL) );
930  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
931  "conflict/maxvarsfac",
932  "maximal fraction of variables involved in a conflict constraint",
933  &(*set)->conf_maxvarsfac, TRUE, SCIP_DEFAULT_CONF_MAXVARSFAC, 0.0, SCIP_REAL_MAX,
934  NULL, NULL) );
935  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
936  "conflict/minmaxvars",
937  "minimal absolute maximum of variables involved in a conflict constraint",
938  &(*set)->conf_minmaxvars, TRUE, SCIP_DEFAULT_CONF_MINMAXVARS, 0, INT_MAX,
939  NULL, NULL) );
940  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
941  "conflict/maxlploops",
942  "maximal number of LP resolving loops during conflict analysis (-1: no limit)",
943  &(*set)->conf_maxlploops, TRUE, SCIP_DEFAULT_CONF_MAXLPLOOPS, -1, INT_MAX,
944  NULL, NULL) );
945  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
946  "conflict/lpiterations",
947  "maximal number of LP iterations in each LP resolving loop (-1: no limit)",
948  &(*set)->conf_lpiterations, TRUE, SCIP_DEFAULT_CONF_LPITERATIONS, -1, INT_MAX,
949  NULL, NULL) );
950  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
951  "conflict/fuiplevels",
952  "number of depth levels up to which first UIP's are used in conflict analysis (-1: use All-FirstUIP rule)",
953  &(*set)->conf_fuiplevels, TRUE, SCIP_DEFAULT_CONF_FUIPLEVELS, -1, INT_MAX,
954  NULL, NULL) );
955  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
956  "conflict/interconss",
957  "maximal number of intermediate conflict constraints generated in conflict graph (-1: use every intermediate constraint)",
958  &(*set)->conf_interconss, TRUE, SCIP_DEFAULT_CONF_INTERCONSS, -1, INT_MAX,
959  NULL, NULL) );
960  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
961  "conflict/reconvlevels",
962  "number of depth levels up to which UIP reconvergence constraints are generated (-1: generate reconvergence constraints in all depth levels)",
963  &(*set)->conf_reconvlevels, TRUE, SCIP_DEFAULT_CONF_RECONVLEVELS, -1, INT_MAX,
964  NULL, NULL) );
965  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
966  "conflict/maxconss",
967  "maximal number of conflict constraints accepted at an infeasible node (-1: use all generated conflict constraints)",
968  &(*set)->conf_maxconss, TRUE, SCIP_DEFAULT_CONF_MAXCONSS, -1, INT_MAX,
969  NULL, NULL) );
970  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
971  "conflict/preferbinary",
972  "should binary conflicts be preferred?",
973  &(*set)->conf_preferbinary, FALSE, SCIP_DEFAULT_CONF_PREFERBINARY,
974  NULL, NULL) );
975  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
976  "conflict/allowlocal",
977  "should conflict constraints be generated that are only valid locally?",
978  &(*set)->conf_allowlocal, TRUE, SCIP_DEFAULT_CONF_ALLOWLOCAL,
979  NULL, NULL) );
980  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
981  "conflict/settlelocal",
982  "should conflict constraints be attached only to the local subtree where they can be useful?",
983  &(*set)->conf_settlelocal, TRUE, SCIP_DEFAULT_CONF_SETTLELOCAL,
984  NULL, NULL) );
985  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
986  "conflict/repropagate",
987  "should earlier nodes be repropagated in order to replace branching decisions by deductions?",
988  &(*set)->conf_repropagate, TRUE, SCIP_DEFAULT_CONF_REPROPAGATE,
989  NULL, NULL) );
990  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
991  "conflict/keepreprop",
992  "should constraints be kept for repropagation even if they are too long?",
993  &(*set)->conf_keepreprop, TRUE, SCIP_DEFAULT_CONF_KEEPREPROP,
994  NULL, NULL) );
995  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
996  "conflict/separate",
997  "should the conflict constraints be separated?",
998  &(*set)->conf_seperate, TRUE, SCIP_DEFAULT_CONF_SEPARATE,
999  NULL, NULL) );
1000  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1001  "conflict/dynamic",
1002  "should the conflict constraints be subject to aging?",
1003  &(*set)->conf_dynamic, TRUE, SCIP_DEFAULT_CONF_DYNAMIC,
1004  NULL, NULL) );
1005  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1006  "conflict/removable",
1007  "should the conflict's relaxations be subject to LP aging and cleanup?",
1008  &(*set)->conf_removable, TRUE, SCIP_DEFAULT_CONF_REMOVEABLE,
1009  NULL, NULL) );
1010  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1011  "conflict/depthscorefac",
1012  "score factor for depth level in bound relaxation heuristic of LP analysis",
1013  &(*set)->conf_depthscorefac, TRUE, SCIP_DEFAULT_CONF_DEPTHSCOREFAC, SCIP_REAL_MIN, SCIP_REAL_MAX,
1014  NULL, NULL) );
1015  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1016  "conflict/scorefac",
1017  "factor to decrease importance of variables' earlier conflict scores",
1018  &(*set)->conf_scorefac, TRUE, SCIP_DEFAULT_CONF_SCOREFAC, 1e-6, 1.0,
1019  NULL, NULL) );
1020  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1021  "conflict/restartnum",
1022  "number of successful conflict analysis calls that trigger a restart (0: disable conflict restarts)",
1023  &(*set)->conf_restartnum, FALSE, SCIP_DEFAULT_CONF_RESTARTNUM, 0, INT_MAX,
1024  NULL, NULL) );
1025  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1026  "conflict/restartfac",
1027  "factor to increase restartnum with after each restart",
1028  &(*set)->conf_restartfac, FALSE, SCIP_DEFAULT_CONF_RESTARTFAC, 0.0, SCIP_REAL_MAX,
1029  NULL, NULL) );
1030  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1031  "conflict/ignorerelaxedbd",
1032  "should relaxed bounds be ignored?",
1033  &(*set)->conf_ignorerelaxedbd, TRUE, SCIP_DEFAULT_CONF_IGNORERELAXEDBD,
1034  NULL, NULL) );
1035  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1036  "conflict/maxvarsdetectimpliedbounds",
1037  "maximal number of variables to try to detect global bound implications and shorten the whole conflict set (0: disabled)",
1038  &(*set)->conf_maxvarsdetectimpliedbounds, TRUE, SCIP_DEFAULT_CONF_MAXVARSDETECTIMPLIEDBOUNDS, 0, INT_MAX,
1039  NULL, NULL) );
1040  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1041  "conflict/fullshortenconflict",
1042  "try to shorten the whole conflict set or terminate early (depending on the 'maxvarsdetectimpliedbounds' parameter)",
1043  &(*set)->conf_fullshortenconflict, TRUE, SCIP_DEFAULT_CONF_FULLSHORTENCONFLICT,
1044  NULL, NULL) );
1045  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1046  "conflict/conflictweight",
1047  "the weight the VSIDS score is weight by updating the VSIDS for a variable if it is part of a conflict",
1048  &(*set)->conf_conflictweight, FALSE, SCIP_DEFAULT_CONF_CONFLITWEIGHT, 0.0, 1.0,
1049  NULL, NULL) );
1050  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1051  "conflict/conflictgraphweight",
1052  "the weight the VSIDS score is weight by updating the VSIDS for a variable if it is part of a conflict graph",
1053  &(*set)->conf_conflictgraphweight, FALSE, SCIP_DEFAULT_CONF_CONFLITGRAPHWEIGHT, 0.0, 1.0,
1054  NULL, NULL) );
1055 
1056  /* constraint parameters */
1057  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1058  "constraints/agelimit",
1059  "maximum age an unnecessary constraint can reach before it is deleted (0: dynamic, -1: keep all constraints)",
1060  &(*set)->cons_agelimit, TRUE, SCIP_DEFAULT_CONS_AGELIMIT, -1, INT_MAX,
1061  NULL, NULL) );
1062  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1063  "constraints/obsoleteage",
1064  "age of a constraint after which it is marked obsolete (0: dynamic, -1 do not mark constraints obsolete)",
1065  &(*set)->cons_obsoleteage, TRUE, SCIP_DEFAULT_CONS_OBSOLETEAGE, -1, INT_MAX,
1066  NULL, NULL) );
1067  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1068  "constraints/disableenfops",
1069  "should enforcement of pseudo solution be disabled?",
1070  &(*set)->cons_disableenfops, TRUE, SCIP_DEFAULT_CONS_DISABLEENFOPS,
1071  NULL, NULL) );
1072 
1073  /* display parameters */
1074  assert(sizeof(int) == sizeof(SCIP_VERBLEVEL));
1075  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1076  "display/verblevel",
1077  "verbosity level of output",
1078  (int*)&(*set)->disp_verblevel, FALSE, (int)SCIP_DEFAULT_DISP_VERBLEVEL,
1079  (int)SCIP_VERBLEVEL_NONE, (int)SCIP_VERBLEVEL_FULL,
1080  NULL, NULL) );
1081  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1082  "display/width",
1083  "maximal number of characters in a node information line",
1084  &(*set)->disp_width, FALSE, SCIP_DEFAULT_DISP_WIDTH, 0, INT_MAX,
1085  SCIPparamChgdDispWidth, NULL) );
1086  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1087  "display/freq",
1088  "frequency for displaying node information lines",
1089  &(*set)->disp_freq, FALSE, SCIP_DEFAULT_DISP_FREQ, -1, INT_MAX,
1090  NULL, NULL) );
1091  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1092  "display/headerfreq",
1093  "frequency for displaying header lines (every n'th node information line)",
1094  &(*set)->disp_headerfreq, FALSE, SCIP_DEFAULT_DISP_HEADERFREQ, -1, INT_MAX,
1095  NULL, NULL) );
1096  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1097  "display/lpinfo",
1098  "should the LP solver display status messages?",
1099  &(*set)->disp_lpinfo, FALSE, SCIP_DEFAULT_DISP_LPINFO,
1100  NULL, NULL) );
1101 
1102  /* history parameters */
1103  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1104  "history/valuebased",
1105  "should statistics be collected for variable domain value pairs?",
1106  &(*set)->history_valuebased, FALSE, SCIP_DEFAULT_HISTORY_VALUEBASED,
1107  NULL, NULL) );
1108 
1109  /* limit parameters */
1110  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1111  "limits/time",
1112  "maximal time in seconds to run",
1113  &(*set)->limit_time, FALSE, SCIP_DEFAULT_LIMIT_TIME, 0.0, SCIP_REAL_MAX,
1114  SCIPparamChgdLimit, NULL) );
1115 
1116  SCIP_CALL( SCIPsetAddLongintParam(*set, messagehdlr, blkmem,
1117  "limits/nodes",
1118  "maximal number of nodes to process (-1: no limit)",
1119  &(*set)->limit_nodes, FALSE, SCIP_DEFAULT_LIMIT_NODES, -1LL, SCIP_LONGINT_MAX,
1120  SCIPparamChgdLimit, NULL) );
1121  SCIP_CALL( SCIPsetAddLongintParam(*set, messagehdlr, blkmem,
1122  "limits/totalnodes",
1123  "maximal number of total nodes (incl. restarts) to process (-1: no limit)",
1124  &(*set)->limit_totalnodes, FALSE, SCIP_DEFAULT_LIMIT_NODES, -1LL, SCIP_LONGINT_MAX,
1125  SCIPparamChgdLimit, NULL) );
1126  SCIP_CALL( SCIPsetAddLongintParam(*set, messagehdlr, blkmem,
1127  "limits/stallnodes",
1128  "solving stops, if the given number of nodes was processed since the last improvement of the primal solution value (-1: no limit)",
1129  &(*set)->limit_stallnodes, FALSE, SCIP_DEFAULT_LIMIT_STALLNODES, -1LL, SCIP_LONGINT_MAX,
1130  SCIPparamChgdLimit, NULL) );
1131  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1132  "limits/memory",
1133  "maximal memory usage in MB; reported memory usage is lower than real memory usage!",
1134  &(*set)->limit_memory, FALSE, SCIP_DEFAULT_LIMIT_MEMORY, 0.0, SCIP_REAL_MAX,
1135  SCIPparamChgdLimit, NULL) );
1136  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1137  "limits/gap",
1138  "solving stops, if the relative gap = |primal - dual|/MIN(|dual|,|primal|) is below the given value",
1139  &(*set)->limit_gap, FALSE, SCIP_DEFAULT_LIMIT_GAP, 0.0, SCIP_REAL_MAX,
1140  SCIPparamChgdLimit, NULL) );
1141  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1142  "limits/absgap",
1143  "solving stops, if the absolute gap = |primalbound - dualbound| is below the given value",
1144  &(*set)->limit_absgap, FALSE, SCIP_DEFAULT_LIMIT_ABSGAP, 0.0, SCIP_REAL_MAX,
1145  SCIPparamChgdLimit, NULL) );
1146  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1147  "limits/solutions",
1148  "solving stops, if the given number of solutions were found (-1: no limit)",
1149  &(*set)->limit_solutions, FALSE, SCIP_DEFAULT_LIMIT_SOLUTIONS, -1, INT_MAX,
1150  SCIPparamChgdLimit, NULL) );
1151  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1152  "limits/bestsol",
1153  "solving stops, if the given number of solution improvements were found (-1: no limit)",
1154  &(*set)->limit_bestsol, FALSE, SCIP_DEFAULT_LIMIT_BESTSOL, -1, INT_MAX,
1155  SCIPparamChgdLimit, NULL) );
1156  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1157  "limits/maxsol",
1158  "maximal number of solutions to store in the solution storage",
1159  &(*set)->limit_maxsol, FALSE, SCIP_DEFAULT_LIMIT_MAXSOL, 1, INT_MAX,
1160  SCIPparamChgdLimit, NULL) );
1161  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1162  "limits/maxorigsol",
1163  "maximal number of solutions candidates to store in the solution storage of the original problem",
1164  &(*set)->limit_maxorigsol, FALSE, SCIP_DEFAULT_LIMIT_MAXORIGSOL, 0, INT_MAX,
1165  SCIPparamChgdLimit, NULL) );
1166  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1167  "limits/restarts",
1168  "solving stops, if the given number of restarts was triggered (-1: no limit)",
1169  &(*set)->limit_restarts, FALSE, SCIP_DEFAULT_LIMIT_RESTARTS, -1, INT_MAX,
1170  SCIPparamChgdLimit, NULL) );
1171 
1172  /* LP parameters */
1173  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1174  "lp/solvefreq",
1175  "frequency for solving LP at the nodes (-1: never; 0: only root LP)",
1176  &(*set)->lp_solvefreq, FALSE, SCIP_DEFAULT_LP_SOLVEFREQ, -1, INT_MAX,
1177  NULL, NULL) );
1178  SCIP_CALL( SCIPsetAddLongintParam(*set, messagehdlr, blkmem,
1179  "lp/iterlim",
1180  "iteration limit for each single LP solve (-1: no limit)",
1181  &(*set)->lp_iterlim, TRUE, SCIP_DEFAULT_LP_ITERLIM, -1LL, SCIP_LONGINT_MAX,
1182  NULL, NULL) );
1183  SCIP_CALL( SCIPsetAddLongintParam(*set, messagehdlr, blkmem,
1184  "lp/rootiterlim",
1185  "iteration limit for initial root LP solve (-1: no limit)",
1186  &(*set)->lp_rootiterlim, TRUE, SCIP_DEFAULT_LP_ROOTITERLIM, -1LL, SCIP_LONGINT_MAX,
1187  NULL, NULL) );
1188  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1189  "lp/solvedepth",
1190  "maximal depth for solving LP at the nodes (-1: no depth limit)",
1191  &(*set)->lp_solvedepth, FALSE, SCIP_DEFAULT_LP_SOLVEDEPTH, -1, INT_MAX,
1192  NULL, NULL) );
1193  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
1194  "lp/initalgorithm",
1195  "LP algorithm for solving initial LP relaxations (automatic 's'implex, 'p'rimal simplex, 'd'ual simplex, 'b'arrier, barrier with 'c'rossover)",
1196  &(*set)->lp_initalgorithm, FALSE, SCIP_DEFAULT_LP_INITALGORITHM, "spdbc",
1197  NULL, NULL) );
1198  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
1199  "lp/resolvealgorithm",
1200  "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)",
1201  &(*set)->lp_resolvealgorithm, FALSE, SCIP_DEFAULT_LP_RESOLVEALGORITHM, "spdbc",
1202  NULL, NULL) );
1203  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
1204  "lp/pricing",
1205  "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)",
1206  &(*set)->lp_pricing, FALSE, SCIP_DEFAULT_LP_PRICING, "lafpsqd",
1207  NULL, NULL) );
1208  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1209  "lp/clearinitialprobinglp",
1210  "should lp state be cleared at the end of probing mode when lp was initially unsolved, e.g., when called right after presolving?",
1211  &(*set)->lp_clearinitialprobinglp, TRUE, SCIP_DEFAULT_LP_CLEARINITIALPROBINGLP,
1212  NULL, NULL) );
1213  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1214  "lp/resolverestore",
1215  "should the LP be resolved to restore the state at start of diving (if FALSE we buffer the solution values)?",
1216  &(*set)->lp_resolverestore, TRUE, SCIP_DEFAULT_LP_RESOLVERESTORE,
1217  NULL, NULL) );
1218  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1219  "lp/freesolvalbuffers",
1220  "should the buffers for storing LP solution values during diving be freed at end of diving?",
1221  &(*set)->lp_freesolvalbuffers, TRUE, SCIP_DEFAULT_LP_FREESOLVALBUFFERS,
1222  NULL, NULL) );
1223  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1224  "lp/colagelimit",
1225  "maximum age a dynamic column can reach before it is deleted from the LP (-1: don't delete columns due to aging)",
1226  &(*set)->lp_colagelimit, TRUE, SCIP_DEFAULT_LP_COLAGELIMIT, -1, INT_MAX,
1227  NULL, NULL) );
1228  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1229  "lp/rowagelimit",
1230  "maximum age a dynamic row can reach before it is deleted from the LP (-1: don't delete rows due to aging)",
1231  &(*set)->lp_rowagelimit, TRUE, SCIP_DEFAULT_LP_ROWAGELIMIT, -1, INT_MAX,
1232  NULL, NULL) );
1233  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1234  "lp/cleanupcols",
1235  "should new non-basic columns be removed after LP solving?",
1236  &(*set)->lp_cleanupcols, TRUE, SCIP_DEFAULT_LP_CLEANUPCOLS,
1237  NULL, NULL) );
1238  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1239  "lp/cleanupcolsroot",
1240  "should new non-basic columns be removed after root LP solving?",
1241  &(*set)->lp_cleanupcolsroot, TRUE, SCIP_DEFAULT_LP_CLEANUPCOLSROOT,
1242  NULL, NULL) );
1243  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1244  "lp/cleanuprows",
1245  "should new basic rows be removed after LP solving?",
1246  &(*set)->lp_cleanuprows, TRUE, SCIP_DEFAULT_LP_CLEANUPROWS,
1247  NULL, NULL) );
1248  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1249  "lp/cleanuprowsroot",
1250  "should new basic rows be removed after root LP solving?",
1251  &(*set)->lp_cleanuprowsroot, TRUE, SCIP_DEFAULT_LP_CLEANUPROWSROOT,
1252  NULL, NULL) );
1253  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1254  "lp/checkstability",
1255  "should LP solver's return status be checked for stability?",
1256  &(*set)->lp_checkstability, TRUE, SCIP_DEFAULT_LP_CHECKSTABILITY,
1257  NULL, NULL) );
1258  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1259  "lp/conditionlimit",
1260  "maximum condition number of LP basis counted as stable (-1.0: no limit)",
1261  &(*set)->lp_conditionlimit, TRUE, SCIP_DEFAULT_LP_CONDITIONLIMIT, -1.0, SCIP_REAL_MAX,
1262  NULL, NULL) );
1263  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1264  "lp/checkprimfeas",
1265  "should LP solutions be checked for primal feasibility, resolving LP when numerical troubles occur?",
1266  &(*set)->lp_checkprimfeas, TRUE, SCIP_DEFAULT_LP_CHECKPRIMFEAS,
1267  NULL, NULL) );
1268  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1269  "lp/checkdualfeas",
1270  "should LP solutions be checked for dual feasibility, resolving LP when numerical troubles occur?",
1271  &(*set)->lp_checkdualfeas, TRUE, SCIP_DEFAULT_LP_CHECKDUALFEAS,
1272  NULL, NULL) );
1273  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1274  "lp/fastmip",
1275  "which FASTMIP setting of LP solver should be used? 0: off, 1: low",
1276  &(*set)->lp_fastmip, TRUE, SCIP_DEFAULT_LP_FASTMIP, 0, 1,
1277  NULL, NULL) );
1278  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1279  "lp/scaling",
1280  "should scaling of LP solver be used?",
1281  &(*set)->lp_scaling, TRUE, SCIP_DEFAULT_LP_SCALING,
1282  NULL, NULL) );
1283  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1284  "lp/presolving",
1285  "should presolving of LP solver be used?",
1286  &(*set)->lp_presolving, TRUE, SCIP_DEFAULT_LP_PRESOLVING,
1287  NULL, NULL) );
1288  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1289  "lp/lexdualalgo",
1290  "should the lexicographic dual alogrithm be used?",
1291  &(*set)->lp_lexdualalgo, TRUE, SCIP_DEFAULT_LP_LEXDUALALGO,
1292  NULL, NULL) );
1293  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1294  "lp/lexdualrootonly",
1295  "should the lexicographic dual algorithm be applied only at the root node",
1296  &(*set)->lp_lexdualrootonly, TRUE, SCIP_DEFAULT_LP_LEXDUALROOTONLY,
1297  NULL, NULL) );
1298  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1299  "lp/lexdualmaxrounds",
1300  "maximum number of rounds in the lexicographic dual algorithm (-1: unbounded)",
1301  &(*set)->lp_lexdualmaxrounds, TRUE, SCIP_DEFAULT_LP_LEXDUALMAXROUNDS, -1, INT_MAX,
1302  NULL, NULL) );
1303  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1304  "lp/lexdualbasic",
1305  "choose fractional basic variables in lexicographic dual algorithm?",
1306  &(*set)->lp_lexdualbasic, TRUE, SCIP_DEFAULT_LP_LEXDUALBASIC,
1307  NULL, NULL) );
1308  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1309  "lp/lexdualstalling",
1310  "turn on the lex dual algorithm only when stalling?",
1311  &(*set)->lp_lexdualstalling, TRUE, SCIP_DEFAULT_LP_LEXDUALSTALLING,
1312  NULL, NULL) );
1313  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1314  "lp/disablecutoff",
1315  "disable the cutoff bound in the LP solver? (0: enabled, 1: disabled, 2: auto)",
1316  &(*set)->lp_disablecutoff, TRUE, SCIP_DEFAULT_LP_DISABLECUTOFF,
1317  0, 2, NULL, NULL) );
1318  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1319  "lp/rowrepswitch",
1320  "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)",
1321  &(*set)->lp_rowrepswitch, TRUE, SCIP_DEFAULT_LP_ROWREPSWITCH, -1.0, SCIP_REAL_MAX,
1322  NULL, NULL) );
1323  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1324  "lp/threads",
1325  "number of threads used for solving the LP (0: automatic)",
1326  &(*set)->lp_threads, TRUE, SCIP_DEFAULT_LP_THREADS, 0, 64,
1327  NULL, NULL) );
1328  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1329  "lp/resolveiterfac",
1330  "factor of average LP iterations that is used as LP iteration limit for LP resolve (-1: unlimited)",
1331  &(*set)->lp_resolveiterfac, TRUE, SCIP_DEFAULT_LP_RESOLVEITERFAC, -1.0, SCIP_REAL_MAX,
1332  NULL, NULL) );
1333  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1334  "lp/resolveitermin",
1335  "minimum number of iterations that are allowed for LP resolve",
1336  &(*set)->lp_resolveitermin, TRUE, SCIP_DEFAULT_LP_RESOLVEITERMIN, 1, INT_MAX,
1337  NULL, NULL) );
1338 
1339  /* NLP parameters */
1340  SCIP_CALL( SCIPsetAddStringParam(*set, messagehdlr, blkmem,
1341  "nlp/solver",
1342  "solver to use for solving NLPs; leave empty to select NLPI with highest priority",
1343  &(*set)->nlp_solver, FALSE, SCIP_DEFAULT_NLP_SOLVER,
1344  NULL, NULL) );
1345  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1346  "nlp/disable",
1347  "should the NLP relaxation be always disabled (also for NLPs/MINLPs)?",
1348  &(*set)->nlp_disable, FALSE, SCIP_DEFAULT_NLP_DISABLE,
1349  NULL, NULL) );
1350 
1351  /* memory parameters */
1352  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1353  "memory/savefac",
1354  "fraction of maximal memory usage resulting in switch to memory saving mode",
1355  &(*set)->mem_savefac, FALSE, SCIP_DEFAULT_MEM_SAVEFAC, 0.0, 1.0,
1356  NULL, NULL) );
1357  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1358  "memory/arraygrowfac",
1359  "memory growing factor for dynamically allocated arrays",
1360  &(*set)->mem_arraygrowfac, TRUE, SCIP_DEFAULT_MEM_ARRAYGROWFAC, 1.0, 10.0,
1361  NULL, NULL) );
1362  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1363  "memory/arraygrowinit",
1364  "initial size of dynamically allocated arrays",
1365  &(*set)->mem_arraygrowinit, TRUE, SCIP_DEFAULT_MEM_ARRAYGROWINIT, 0, INT_MAX,
1366  NULL, NULL) );
1367  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1368  "memory/treegrowfac",
1369  "memory growing factor for tree array",
1370  &(*set)->mem_treegrowfac, TRUE, SCIP_DEFAULT_MEM_TREEGROWFAC, 1.0, 10.0,
1371  NULL, NULL) );
1372  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1373  "memory/treegrowinit",
1374  "initial size of tree array",
1375  &(*set)->mem_treegrowinit, TRUE, SCIP_DEFAULT_MEM_TREEGROWINIT, 0, INT_MAX,
1376  NULL, NULL) );
1377  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1378  "memory/pathgrowfac",
1379  "memory growing factor for path array",
1380  &(*set)->mem_pathgrowfac, TRUE, SCIP_DEFAULT_MEM_PATHGROWFAC, 1.0, 10.0,
1381  NULL, NULL) );
1382  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1383  "memory/pathgrowinit",
1384  "initial size of path array",
1385  &(*set)->mem_pathgrowinit, TRUE, SCIP_DEFAULT_MEM_PATHGROWINIT, 0, INT_MAX,
1386  NULL, NULL) );
1387 
1388  /* miscellaneous parameters */
1389  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1390  "misc/catchctrlc",
1391  "should the CTRL-C interrupt be caught by SCIP?",
1392  &(*set)->misc_catchctrlc, FALSE, SCIP_DEFAULT_MISC_CATCHCTRLC,
1393  NULL, NULL) );
1394  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1395  "misc/usevartable",
1396  "should a hashtable be used to map from variable names to variables?",
1397  &(*set)->misc_usevartable, FALSE, SCIP_DEFAULT_MISC_USEVARTABLE,
1398  NULL, NULL) );
1399  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1400  "misc/useconstable",
1401  "should a hashtable be used to map from constraint names to constraints?",
1402  &(*set)->misc_useconstable, FALSE, SCIP_DEFAULT_MISC_USECONSTABLE,
1403  NULL, NULL) );
1404  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1405  "misc/usesmalltables",
1406  "should smaller hashtables be used? yields better performance for small problems with about 100 variables",
1407  &(*set)->misc_usesmalltables, FALSE, SCIP_DEFAULT_MISC_USESMALLTABLES,
1408  NULL, NULL) );
1409 #if 0 /**@todo activate exactsolve parameter and finish implementation of solving MIPs exactly */
1410  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1411  "misc/exactsolve",
1412  "should the problem be solved exactly (with proven dual bounds)?",
1413  &(*set)->misc_exactsolve, FALSE, SCIP_DEFAULT_MISC_EXACTSOLVE,
1414  NULL, NULL) );
1415 #else
1416  (*set)->misc_exactsolve = SCIP_DEFAULT_MISC_EXACTSOLVE;
1417 #endif
1418  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1419  "misc/permutationseed",
1420  "seed value for permuting the problem after the problem was transformed (-1: no permutation)",
1421  &(*set)->misc_permutationseed, FALSE, SCIP_DEFAULT_MISC_PERMUTATIONSEED, -1, INT_MAX,
1422  NULL, NULL) );
1423 
1424  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1425  "misc/permuteconss",
1426  "should order of constraints be permuted (depends on permutationseed)?",
1427  &(*set)->misc_permuteconss, TRUE, SCIP_DEFAULT_MISC_PERMUTECONSS,
1428  NULL, NULL) );
1429 
1430  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1431  "misc/permutevars",
1432  "should order of variables be permuted (depends on permutationseed)?",
1433  &(*set)->misc_permutevars, TRUE, SCIP_DEFAULT_MISC_PERMUTEVARS,
1434  NULL, NULL) );
1435 
1436  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1437  "misc/resetstat",
1438  "should the statistics be reset if the transformed problem is freed (in case of a Benders decomposition this parameter should be set to FALSE)",
1439  &(*set)->misc_resetstat, FALSE, SCIP_DEFAULT_MISC_RESETSTAT,
1440  NULL, NULL) );
1441 
1442  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1443  "misc/improvingsols",
1444  "should only solutions be checked which improve the primal bound",
1445  &(*set)->misc_improvingsols, FALSE, SCIP_DEFAULT_MISC_IMPROVINGSOLS,
1446  NULL, NULL) );
1447  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1448  "misc/printreason",
1449  "should the reason be printed if a given start solution is infeasible",
1450  &(*set)->misc_printreason, FALSE, SCIP_DEFAULT_MISC_PRINTREASON,
1451  NULL, NULL) );
1452  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1453  "misc/estimexternmem",
1454  "should the usage of external memory be estimated?",
1455  &(*set)->misc_estimexternmem, FALSE, SCIP_DEFAULT_MISC_ESTIMEXTERNMEM,
1456  NULL, NULL) );
1457  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1458  "misc/transorigsols",
1459  "should SCIP try to transfer original solutions to the extended space (after presolving)?",
1460  &(*set)->misc_transorigsols, FALSE, SCIP_DEFAULT_MISC_TRANSORIGSOLS,
1461  NULL, NULL) );
1462  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1463  "misc/calcintegral",
1464  "should SCIP calculate the primal dual integral value?",
1465  &(*set)->misc_calcintegral, FALSE, SCIP_DEFAULT_MISC_CALCINTEGRAL,
1466  NULL, NULL) );
1467  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1468  "misc/finitesolutionstore",
1469  "should SCIP try to remove infinite fixings from solutions copied to the solution store?",
1470  &(*set)->misc_finitesolstore, FALSE, SCIP_DEFAULT_MISC_FINITESOLSTORE,
1471  NULL, NULL) );
1472 
1473  /* node selection */
1474  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
1475  "nodeselection/childsel",
1476  "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)",
1477  &(*set)->nodesel_childsel, FALSE, SCIP_DEFAULT_NODESEL_CHILDSEL, "dupilrh",
1478  NULL, NULL) );
1479 
1480  /* numerical parameters */
1481  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1482  "numerics/infinity",
1483  "values larger than this are considered infinity",
1484  &(*set)->num_infinity, FALSE, SCIP_DEFAULT_INFINITY, 1e+10, SCIP_INVALID/10.0,
1485  NULL, NULL) );
1486  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1487  "numerics/epsilon",
1488  "absolute values smaller than this are considered zero",
1489  &(*set)->num_epsilon, FALSE, SCIP_DEFAULT_EPSILON, SCIP_MINEPSILON, SCIP_MAXEPSILON,
1490  NULL, NULL) );
1491  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1492  "numerics/sumepsilon",
1493  "absolute values of sums smaller than this are considered zero",
1494  &(*set)->num_sumepsilon, FALSE, SCIP_DEFAULT_SUMEPSILON, SCIP_MINEPSILON*1e+03, SCIP_MAXEPSILON,
1495  NULL, NULL) );
1496  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1497  "numerics/feastol",
1498  "feasibility tolerance for constraints",
1499  &(*set)->num_feastol, FALSE, SCIP_DEFAULT_FEASTOL, SCIP_MINEPSILON*1e+03, SCIP_MAXEPSILON,
1500  paramChgdFeastol, NULL) );
1501  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1502  "numerics/lpfeastol",
1503  "primal feasibility tolerance of LP solver",
1504  &(*set)->num_lpfeastol, FALSE, SCIP_DEFAULT_LPFEASTOL, SCIP_MINEPSILON*1e+03, SCIP_MAXEPSILON,
1505  paramChgdLpfeastol, NULL) );
1506  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1507  "numerics/dualfeastol",
1508  "feasibility tolerance for reduced costs in LP solution",
1509  &(*set)->num_dualfeastol, FALSE, SCIP_DEFAULT_DUALFEASTOL, SCIP_MINEPSILON*1e+03, SCIP_MAXEPSILON,
1510  paramChgdDualfeastol, NULL) );
1511  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1512  "numerics/barrierconvtol",
1513  "LP convergence tolerance used in barrier algorithm",
1514  &(*set)->num_barrierconvtol, TRUE, SCIP_DEFAULT_BARRIERCONVTOL, SCIP_MINEPSILON*1e+03, SCIP_MAXEPSILON,
1515  paramChgdBarrierconvtol, NULL) );
1516  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1517  "numerics/boundstreps",
1518  "minimal relative improve for strengthening bounds",
1519  &(*set)->num_boundstreps, TRUE, SCIP_DEFAULT_BOUNDSTREPS, SCIP_MINEPSILON*1e+03, SCIP_INVALID/10.0,
1520  NULL, NULL) );
1521  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1522  "numerics/pseudocosteps",
1523  "minimal variable distance value to use for branching pseudo cost updates",
1524  &(*set)->num_pseudocosteps, TRUE, SCIP_DEFAULT_PSEUDOCOSTEPS, SCIP_MINEPSILON*1e+03, 1.0,
1525  NULL, NULL) );
1526  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1527  "numerics/pseudocostdelta",
1528  "minimal objective distance value to use for branching pseudo cost updates",
1529  &(*set)->num_pseudocostdelta, TRUE, SCIP_DEFAULT_PSEUDOCOSTDELTA, 0.0, SCIP_REAL_MAX,
1530  NULL, NULL) );
1531  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1532  "numerics/recomputefac",
1533  "minimal decrease factor that causes the recomputation of a value (e.g., pseudo objective) instead of an update",
1534  &(*set)->num_recompfac, TRUE, SCIP_DEFAULT_RECOMPFAC, 0.0, SCIP_REAL_MAX,
1535  NULL, NULL) );
1536  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1537  "numerics/hugeval",
1538  "values larger than this are considered huge and should be handled separately (e.g., in activity computation)",
1539  &(*set)->num_hugeval, TRUE, SCIP_DEFAULT_HUGEVAL, 0.0, SCIP_INVALID/10.0,
1540  NULL, NULL) );
1541 
1542  /* presolving parameters */
1543  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1544  "presolving/maxrounds",
1545  "maximal number of presolving rounds (-1: unlimited, 0: off)",
1546  &(*set)->presol_maxrounds, FALSE, SCIP_DEFAULT_PRESOL_MAXROUNDS, -1, INT_MAX,
1547  NULL, NULL) );
1548  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1549  "presolving/abortfac",
1550  "abort presolve, if at most this fraction of the problem was changed in last presolve round",
1551  &(*set)->presol_abortfac, TRUE, SCIP_DEFAULT_PRESOL_ABORTFAC, 0.0, 1.0,
1552  NULL, NULL) );
1553  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1554  "presolving/maxrestarts",
1555  "maximal number of restarts (-1: unlimited)",
1556  &(*set)->presol_maxrestarts, FALSE, SCIP_DEFAULT_PRESOL_MAXRESTARTS, -1, INT_MAX,
1557  NULL, NULL) );
1558  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1559  "presolving/restartfac",
1560  "fraction of integer variables that were fixed in the root node triggering a restart with preprocessing after root node evaluation",
1561  &(*set)->presol_restartfac, TRUE, SCIP_DEFAULT_PRESOL_RESTARTFAC, 0.0, 1.0,
1562  NULL, NULL) );
1563  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1564  "presolving/immrestartfac",
1565  "fraction of integer variables that were fixed in the root node triggering an immediate restart with preprocessing",
1566  &(*set)->presol_immrestartfac, TRUE, SCIP_DEFAULT_PRESOL_IMMRESTARTFAC, 0.0, 1.0,
1567  NULL, NULL) );
1568  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1569  "presolving/subrestartfac",
1570  "fraction of integer variables that were globally fixed during the solving process triggering a restart with preprocessing",
1571  &(*set)->presol_subrestartfac, TRUE, SCIP_DEFAULT_PRESOL_SUBRESTARTFAC, 0.0, 1.0,
1572  NULL, NULL) );
1573  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1574  "presolving/restartminred",
1575  "minimal fraction of integer variables removed after restart to allow for an additional restart",
1576  &(*set)->presol_restartminred, TRUE, SCIP_DEFAULT_PRESOL_RESTARTMINRED, 0.0, 1.0,
1577  NULL, NULL) );
1578  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1579  "presolving/donotmultaggr",
1580  "should multi-aggregation of variables be forbidden?",
1581  &(*set)->presol_donotmultaggr, TRUE, SCIP_DEFAULT_PRESOL_DONOTMULTAGGR,
1582  NULL, NULL) );
1583  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1584  "presolving/donotaggr",
1585  "should aggregation of variables be forbidden?",
1586  &(*set)->presol_donotaggr, TRUE, SCIP_DEFAULT_PRESOL_DONOTAGGR,
1587  NULL, NULL) );
1588 
1589 
1590  /* pricing parameters */
1591  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1592  "pricing/maxvars",
1593  "maximal number of variables priced in per pricing round",
1594  &(*set)->price_maxvars, FALSE, SCIP_DEFAULT_PRICE_MAXVARS, 1, INT_MAX,
1595  NULL, NULL) );
1596  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1597  "pricing/maxvarsroot",
1598  "maximal number of priced variables at the root node",
1599  &(*set)->price_maxvarsroot, FALSE, SCIP_DEFAULT_PRICE_MAXVARSROOT, 1, INT_MAX,
1600  NULL, NULL) );
1601  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1602  "pricing/abortfac",
1603  "pricing is aborted, if fac * pricing/maxvars pricing candidates were found",
1604  &(*set)->price_abortfac, FALSE, SCIP_DEFAULT_PRICE_ABORTFAC, 1.0, SCIP_REAL_MAX,
1605  NULL, NULL) );
1606  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1607  "pricing/delvars",
1608  "should variables created at the current node be deleted when the node is solved in case they are not present in the LP anymore?",
1609  &(*set)->price_delvars, FALSE, SCIP_DEFAULT_PRICE_DELVARS,
1610  NULL, NULL) );
1611  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1612  "pricing/delvarsroot",
1613  "should variables created at the root node be deleted when the root is solved in case they are not present in the LP anymore?",
1614  &(*set)->price_delvarsroot, FALSE, SCIP_DEFAULT_PRICE_DELVARSROOT,
1615  NULL, NULL) );
1616 
1617  /* propagation parameters */
1618  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1619  "propagating/maxrounds",
1620  "maximal number of propagation rounds per node (-1: unlimited)",
1621  &(*set)->prop_maxrounds, FALSE, SCIP_DEFAULT_PROP_MAXROUNDS, -1, INT_MAX,
1622  NULL, NULL) );
1623  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1624  "propagating/maxroundsroot",
1625  "maximal number of propagation rounds in the root node (-1: unlimited)",
1626  &(*set)->prop_maxroundsroot, FALSE, SCIP_DEFAULT_PROP_MAXROUNDSROOT, -1, INT_MAX,
1627  NULL, NULL) );
1628  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1629  "propagating/abortoncutoff",
1630  "should propagation be aborted immediately? setting this to FALSE could help conflict analysis to produce more conflict constraints",
1631  &(*set)->prop_abortoncutoff, FALSE, SCIP_DEFAULT_PROP_ABORTONCUTOFF,
1632  NULL, NULL) );
1633 
1634  /* separation parameters */
1635  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1636  "separating/maxbounddist",
1637  "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)",
1638  &(*set)->sepa_maxbounddist, FALSE, SCIP_DEFAULT_SEPA_MAXBOUNDDIST, 0.0, 1.0,
1639  NULL, NULL) );
1640  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1641  "separating/minefficacy",
1642  "minimal efficacy for a cut to enter the LP",
1643  &(*set)->sepa_minefficacy, FALSE, SCIP_DEFAULT_SEPA_MINEFFICACY, 0.0, SCIP_INVALID/10.0,
1644  NULL, NULL) );
1645  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1646  "separating/minefficacyroot",
1647  "minimal efficacy for a cut to enter the LP in the root node",
1648  &(*set)->sepa_minefficacyroot, FALSE, SCIP_DEFAULT_SEPA_MINEFFICACYROOT, 0.0, SCIP_INVALID/10.0,
1649  NULL, NULL) );
1650  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1651  "separating/minortho",
1652  "minimal orthogonality for a cut to enter the LP",
1653  &(*set)->sepa_minortho, FALSE, SCIP_DEFAULT_SEPA_MINORTHO, 0.0, 1.0,
1654  NULL, NULL) );
1655  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1656  "separating/minorthoroot",
1657  "minimal orthogonality for a cut to enter the LP in the root node",
1658  &(*set)->sepa_minorthoroot, FALSE, SCIP_DEFAULT_SEPA_MINORTHOROOT, 0.0, 1.0,
1659  NULL, NULL) );
1660  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1661  "separating/objparalfac",
1662  "factor to scale objective parallelism of cut in separation score calculation",
1663  &(*set)->sepa_objparalfac, TRUE, SCIP_DEFAULT_SEPA_OBJPARALFAC, 0.0, SCIP_INVALID/10.0,
1664  NULL, NULL) );
1665  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1666  "separating/orthofac",
1667  "factor to scale orthogonality of cut in separation score calculation (0.0 to disable orthogonality calculation)",
1668  &(*set)->sepa_orthofac, TRUE, SCIP_DEFAULT_SEPA_ORTHOFAC, 0.0, SCIP_INVALID/10.0,
1669  NULL, NULL) );
1670  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
1671  "separating/orthofunc",
1672  "function used for calc. scalar prod. in orthogonality test ('e'uclidean, 'd'iscrete)",
1673  &(*set)->sepa_orthofunc, TRUE, SCIP_DEFAULT_SEPA_ORTHOFUNC, "ed",
1674  NULL, NULL) );
1675  SCIP_CALL( SCIPsetAddCharParam(*set, messagehdlr, blkmem,
1676  "separating/efficacynorm",
1677  "row norm to use for efficacy calculation ('e'uclidean, 'm'aximum, 's'um, 'd'iscrete)",
1678  &(*set)->sepa_efficacynorm, TRUE, SCIP_DEFAULT_SEPA_EFFICACYNORM, "emsd",
1679  NULL, NULL) );
1680  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1681  "separating/maxruns",
1682  "maximal number of runs for which separation is enabled (-1: unlimited)",
1683  &(*set)->sepa_maxruns, TRUE, SCIP_DEFAULT_SEPA_MAXRUNS, -1, INT_MAX,
1684  NULL, NULL) );
1685  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1686  "separating/maxrounds",
1687  "maximal number of separation rounds per node (-1: unlimited)",
1688  &(*set)->sepa_maxrounds, FALSE, SCIP_DEFAULT_SEPA_MAXROUNDS, -1, INT_MAX,
1689  NULL, NULL) );
1690  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1691  "separating/maxroundsroot",
1692  "maximal number of separation rounds in the root node (-1: unlimited)",
1693  &(*set)->sepa_maxroundsroot, FALSE, SCIP_DEFAULT_SEPA_MAXROUNDSROOT, -1, INT_MAX,
1694  NULL, NULL) );
1695  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1696  "separating/maxroundsrootsubrun",
1697  "maximal number of separation rounds in the root node of a subsequent run (-1: unlimited)",
1698  &(*set)->sepa_maxroundsrootsubrun, TRUE, SCIP_DEFAULT_SEPA_MAXROUNDSROOTSUBRUN, -1, INT_MAX,
1699  NULL, NULL) );
1700  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1701  "separating/maxaddrounds",
1702  "maximal additional number of separation rounds in subsequent price-and-cut loops (-1: no additional restriction)",
1703  &(*set)->sepa_maxaddrounds, TRUE, SCIP_DEFAULT_SEPA_MAXADDROUNDS, -1, INT_MAX,
1704  NULL, NULL) );
1705  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1706  "separating/maxstallrounds",
1707  "maximal number of consecutive separation rounds without objective or integrality improvement (-1: no additional restriction)",
1708  &(*set)->sepa_maxstallrounds, FALSE, SCIP_DEFAULT_SEPA_MAXSTALLROUNDS, -1, INT_MAX,
1709  NULL, NULL) );
1710  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1711  "separating/maxcuts",
1712  "maximal number of cuts separated per separation round (0: disable local separation)",
1713  &(*set)->sepa_maxcuts, FALSE, SCIP_DEFAULT_SEPA_MAXCUTS, 0, INT_MAX,
1714  NULL, NULL) );
1715  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1716  "separating/maxcutsroot",
1717  "maximal number of separated cuts at the root node (0: disable root node separation)",
1718  &(*set)->sepa_maxcutsroot, FALSE, SCIP_DEFAULT_SEPA_MAXCUTSROOT, 0, INT_MAX,
1719  NULL, NULL) );
1720  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1721  "separating/cutagelimit",
1722  "maximum age a cut can reach before it is deleted from the global cut pool, or -1 to keep all cuts",
1723  &(*set)->sepa_cutagelimit, TRUE, SCIP_DEFAULT_SEPA_CUTAGELIMIT, -1, INT_MAX,
1724  NULL, NULL) );
1725  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1726  "separating/poolfreq",
1727  "separation frequency for the global cut pool (-1: disable global cut pool, 0: only separate pool at the root)",
1728  &(*set)->sepa_poolfreq, FALSE, SCIP_DEFAULT_SEPA_POOLFREQ, -1, INT_MAX,
1729  NULL, NULL) );
1730  SCIP_CALL( SCIPsetAddRealParam(*set, messagehdlr, blkmem,
1731  "separating/feastolfac",
1732  "factor on cut infeasibility to limit feasibility tolerance for relaxation solver (-1: off)",
1733  &(*set)->sepa_feastolfac, TRUE, SCIP_DEFAULT_SEPA_FEASTOLFAC, -1.0, 1.0,
1734  NULL, NULL) );
1735 
1736  /* timing parameters */
1737  assert(sizeof(int) == sizeof(SCIP_CLOCKTYPE));
1738  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1739  "timing/clocktype",
1740  "default clock type (1: CPU user seconds, 2: wall clock time)",
1741  (int*)&(*set)->time_clocktype, FALSE, (int)SCIP_DEFAULT_TIME_CLOCKTYPE, 1, 2,
1742  NULL, NULL) );
1743  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1744  "timing/enabled",
1745  "is timing enabled?",
1746  &(*set)->time_enabled, FALSE, SCIP_DEFAULT_TIME_ENABLED,
1747  NULL, NULL) );
1748  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1749  "timing/reading",
1750  "belongs reading time to solving time?",
1751  &(*set)->time_reading, FALSE, SCIP_DEFAULT_TIME_READING,
1752  NULL, NULL) );
1753  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1754  "timing/rareclockcheck",
1755  "should clock checks of solving time be performed less frequently (note: time limit could be exceeded slightly)",
1756  &(*set)->time_rareclockcheck, FALSE, SCIP_DEFAULT_TIME_RARECLOCKCHECK,
1757  NULL, NULL) );
1758  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1759  "timing/statistictiming",
1760  "should timing for statistic output be performed?",
1761  &(*set)->time_statistictiming, FALSE, SCIP_DEFAULT_TIME_STATISTICTIMING,
1762  paramChgdStatistictiming, NULL) );
1763 
1764  /* VBC tool parameters */
1765  SCIP_CALL( SCIPsetAddStringParam(*set, messagehdlr, blkmem,
1766  "vbc/filename",
1767  "name of the VBC Tool output file, or - if no VBC Tool output should be created",
1768  &(*set)->vbc_filename, FALSE, SCIP_DEFAULT_VBC_FILENAME,
1769  NULL, NULL) );
1770  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1771  "vbc/realtime",
1772  "should the real solving time be used instead of a time step counter in VBC output?",
1773  &(*set)->vbc_realtime, FALSE, SCIP_DEFAULT_VBC_REALTIME,
1774  NULL, NULL) );
1775  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1776  "vbc/dispsols",
1777  "should the node where solutions are found be visualized?",
1778  &(*set)->vbc_dispsols, FALSE, SCIP_DEFAULT_VBC_DISPSOLS,
1779  NULL, NULL) );
1780 
1781  /* Reading parameters */
1782  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1783  "reading/initialconss",
1784  "should model constraints be marked as initial?",
1785  &(*set)->read_initialconss, FALSE, SCIP_DEFAULT_READ_INITIALCONSS,
1786  NULL, NULL) );
1787  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1788  "reading/dynamicconss",
1789  "should model constraints be subject to aging?",
1790  &(*set)->read_dynamicconss, FALSE, SCIP_DEFAULT_READ_DYNAMICCONSS,
1791  NULL, NULL) );
1792  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1793  "reading/dynamiccols",
1794  "should columns be added and removed dynamically to the LP?",
1795  &(*set)->read_dynamiccols, FALSE, SCIP_DEFAULT_READ_DYNAMICCOLS,
1796  NULL, NULL) );
1797  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1798  "reading/dynamicrows",
1799  "should rows be added and removed dynamically to the LP?",
1800  &(*set)->read_dynamicrows, FALSE, SCIP_DEFAULT_READ_DYNAMICROWS,
1801  NULL, NULL) );
1802 
1803  /* Writing parameters */
1804  SCIP_CALL( SCIPsetAddBoolParam(*set, messagehdlr, blkmem,
1805  "write/allconss",
1806  "should all constraints be written (including the redundant constraints)?",
1807  &(*set)->write_allconss, FALSE, SCIP_DEFAULT_WRITE_ALLCONSS,
1808  NULL, NULL) );
1809  SCIP_CALL( SCIPsetAddIntParam(*set, messagehdlr, blkmem,
1810  "write/genericnamesoffset",
1811  "when writing a generic problem the index for the first variable should start with?",
1812  &(*set)->write_genoffset, FALSE, SCIP_DEFAULT_WRITE_GENNAMES_OFFSET, 0, INT_MAX/2,
1813  NULL, NULL) );
1814 
1815  /* check if default time limit is finite; if the time limit is changed later, this flag is set accordingly */
1816  (*set)->istimelimitfinite = !SCIPsetIsInfinity(*set, SCIP_DEFAULT_LIMIT_TIME);
1817 
1818  return SCIP_OKAY;
1819 }
1820 
1821 /** frees global SCIP settings */
1822 SCIP_RETCODE SCIPsetFree(
1823  SCIP_SET** set, /**< pointer to SCIP settings */
1824  BMS_BLKMEM* blkmem /**< block memory */
1825  )
1826 {
1827  int i;
1828 
1829  assert(set != NULL);
1830 
1831  /* free parameter set */
1832  SCIPparamsetFree(&(*set)->paramset, blkmem);
1833 
1834  /* free memory buffers */
1835  SCIPbufferFree(&(*set)->buffer);
1836 
1837  /* free file readers */
1838  for( i = 0; i < (*set)->nreaders; ++i )
1839  {
1840  SCIP_CALL( SCIPreaderFree(&(*set)->readers[i], *set) );
1841  }
1842  BMSfreeMemoryArrayNull(&(*set)->readers);
1843 
1844  /* free variable pricers */
1845  for( i = 0; i < (*set)->npricers; ++i )
1846  {
1847  SCIP_CALL( SCIPpricerFree(&(*set)->pricers[i], *set) );
1848  }
1849  BMSfreeMemoryArrayNull(&(*set)->pricers);
1850 
1851  /* free constraint handlers */
1852  for( i = 0; i < (*set)->nconshdlrs; ++i )
1853  {
1854  SCIP_CALL( SCIPconshdlrFree(&(*set)->conshdlrs[i], *set) );
1855  }
1856  BMSfreeMemoryArrayNull(&(*set)->conshdlrs);
1857  BMSfreeMemoryArrayNull(&(*set)->conshdlrs_sepa);
1858  BMSfreeMemoryArrayNull(&(*set)->conshdlrs_enfo);
1859  BMSfreeMemoryArrayNull(&(*set)->conshdlrs_include);
1860 
1861  /* free conflict handlers */
1862  for( i = 0; i < (*set)->nconflicthdlrs; ++i )
1863  {
1864  SCIP_CALL( SCIPconflicthdlrFree(&(*set)->conflicthdlrs[i], *set) );
1865  }
1866  BMSfreeMemoryArrayNull(&(*set)->conflicthdlrs);
1867 
1868  /* free presolvers */
1869  for( i = 0; i < (*set)->npresols; ++i )
1870  {
1871  SCIP_CALL( SCIPpresolFree(&(*set)->presols[i], *set) );
1872  }
1873  BMSfreeMemoryArrayNull(&(*set)->presols);
1874 
1875  /* free relaxators */
1876  for( i = 0; i < (*set)->nrelaxs; ++i )
1877  {
1878  SCIP_CALL( SCIPrelaxFree(&(*set)->relaxs[i], *set) );
1879  }
1880  BMSfreeMemoryArrayNull(&(*set)->relaxs);
1881 
1882  /* free separators */
1883  for( i = 0; i < (*set)->nsepas; ++i )
1884  {
1885  SCIP_CALL( SCIPsepaFree(&(*set)->sepas[i], *set) );
1886  }
1887  BMSfreeMemoryArrayNull(&(*set)->sepas);
1888 
1889  /* free propagators */
1890  for( i = 0; i < (*set)->nprops; ++i )
1891  {
1892  SCIP_CALL( SCIPpropFree(&(*set)->props[i], *set) );
1893  }
1894  BMSfreeMemoryArrayNull(&(*set)->props);
1895 
1896  /* free primal heuristics */
1897  for( i = 0; i < (*set)->nheurs; ++i )
1898  {
1899  SCIP_CALL( SCIPheurFree(&(*set)->heurs[i], *set) );
1900  }
1901  BMSfreeMemoryArrayNull(&(*set)->heurs);
1902 
1903  /* free event handlers */
1904  for( i = 0; i < (*set)->neventhdlrs; ++i )
1905  {
1906  SCIP_CALL( SCIPeventhdlrFree(&(*set)->eventhdlrs[i], *set) );
1907  }
1908  BMSfreeMemoryArrayNull(&(*set)->eventhdlrs);
1909 
1910  /* free node selectors */
1911  for( i = 0; i < (*set)->nnodesels; ++i )
1912  {
1913  SCIP_CALL( SCIPnodeselFree(&(*set)->nodesels[i], *set) );
1914  }
1915  BMSfreeMemoryArrayNull(&(*set)->nodesels);
1916 
1917  /* free branching methods */
1918  for( i = 0; i < (*set)->nbranchrules; ++i )
1919  {
1920  SCIP_CALL( SCIPbranchruleFree(&(*set)->branchrules[i], *set) );
1921  }
1922  BMSfreeMemoryArrayNull(&(*set)->branchrules);
1923 
1924  /* free display columns */
1925  for( i = 0; i < (*set)->ndisps; ++i )
1926  {
1927  SCIP_CALL( SCIPdispFree(&(*set)->disps[i], *set) );
1928  }
1929  BMSfreeMemoryArrayNull(&(*set)->disps);
1930 
1931  /* free dialogs */
1932  BMSfreeMemoryArrayNull(&(*set)->dialogs);
1933 
1934  /* free NLPIs */
1935  for( i = 0; i < (*set)->nnlpis; ++i )
1936  {
1937  SCIP_CALL( SCIPnlpiFree(&(*set)->nlpis[i]) );
1938  }
1939  BMSfreeMemoryArrayNull(&(*set)->nlpis);
1940 
1941  /* free information on external codes */
1942  for( i = 0; i < (*set)->nextcodes; ++i )
1943  {
1944  BMSfreeMemoryArrayNull(&(*set)->extcodenames[i]);
1945  BMSfreeMemoryArrayNull(&(*set)->extcodedescs[i]);
1946  }
1947  BMSfreeMemoryArrayNull(&(*set)->extcodenames);
1948  BMSfreeMemoryArrayNull(&(*set)->extcodedescs);
1949 
1950  BMSfreeMemory(set);
1951 
1952  return SCIP_OKAY;
1953 }
1954 
1955 /** returns current stage of SCIP */
1956 SCIP_STAGE SCIPsetGetStage(
1957  SCIP_SET* set /**< global SCIP settings */
1958  )
1959 {
1960  assert(set != NULL);
1961 
1962  return set->stage;
1963 }
1964 
1965 /** creates a SCIP_Bool parameter, sets it to its default value, and adds it to the parameter set */
1966 SCIP_RETCODE SCIPsetAddBoolParam(
1967  SCIP_SET* set, /**< global SCIP settings */
1968  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1969  BMS_BLKMEM* blkmem, /**< block memory */
1970  const char* name, /**< name of the parameter */
1971  const char* desc, /**< description of the parameter */
1972  SCIP_Bool* valueptr, /**< pointer to store the current parameter value, or NULL */
1973  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1974  SCIP_Bool defaultvalue, /**< default value of the parameter */
1975  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1976  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1977  )
1978 {
1979  assert(set != NULL);
1980 
1981  SCIP_CALL( SCIPparamsetAddBool(set->paramset, messagehdlr, blkmem, name, desc, valueptr, isadvanced,
1982  defaultvalue, paramchgd, paramdata) );
1983 
1984  return SCIP_OKAY;
1985 }
1986 
1987 /** creates an int parameter, sets it to its default value, and adds it to the parameter set */
1988 SCIP_RETCODE SCIPsetAddIntParam(
1989  SCIP_SET* set, /**< global SCIP settings */
1990  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1991  BMS_BLKMEM* blkmem, /**< block memory */
1992  const char* name, /**< name of the parameter */
1993  const char* desc, /**< description of the parameter */
1994  int* valueptr, /**< pointer to store the current parameter value, or NULL */
1995  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1996  int defaultvalue, /**< default value of the parameter */
1997  int minvalue, /**< minimum value for parameter */
1998  int maxvalue, /**< maximum value for parameter */
1999  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
2000  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
2001  )
2002 {
2003  assert(set != NULL);
2004 
2005  SCIP_CALL( SCIPparamsetAddInt(set->paramset, messagehdlr, blkmem, name, desc, valueptr, isadvanced,
2006  defaultvalue, minvalue, maxvalue, paramchgd, paramdata) );
2007 
2008  return SCIP_OKAY;
2009 }
2010 
2011 /** creates a SCIP_Longint parameter, sets it to its default value, and adds it to the parameter set */
2012 SCIP_RETCODE SCIPsetAddLongintParam(
2013  SCIP_SET* set, /**< global SCIP settings */
2014  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2015  BMS_BLKMEM* blkmem, /**< block memory */
2016  const char* name, /**< name of the parameter */
2017  const char* desc, /**< description of the parameter */
2018  SCIP_Longint* valueptr, /**< pointer to store the current parameter value, or NULL */
2019  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
2020  SCIP_Longint defaultvalue, /**< default value of the parameter */
2021  SCIP_Longint minvalue, /**< minimum value for parameter */
2022  SCIP_Longint maxvalue, /**< maximum value for parameter */
2023  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
2024  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
2025  )
2026 {
2027  assert(set != NULL);
2028 
2029  SCIP_CALL( SCIPparamsetAddLongint(set->paramset, messagehdlr, blkmem, name, desc, valueptr, isadvanced,
2030  defaultvalue, minvalue, maxvalue, paramchgd, paramdata) );
2031 
2032  return SCIP_OKAY;
2033 }
2034 
2035 /** creates a SCIP_Real parameter, sets it to its default value, and adds it to the parameter set */
2036 SCIP_RETCODE SCIPsetAddRealParam(
2037  SCIP_SET* set, /**< global SCIP settings */
2038  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2039  BMS_BLKMEM* blkmem, /**< block memory */
2040  const char* name, /**< name of the parameter */
2041  const char* desc, /**< description of the parameter */
2042  SCIP_Real* valueptr, /**< pointer to store the current parameter value, or NULL */
2043  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
2044  SCIP_Real defaultvalue, /**< default value of the parameter */
2045  SCIP_Real minvalue, /**< minimum value for parameter */
2046  SCIP_Real maxvalue, /**< maximum value for parameter */
2047  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
2048  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
2049  )
2050 {
2051  assert(set != NULL);
2052 
2053  SCIP_CALL( SCIPparamsetAddReal(set->paramset, messagehdlr, blkmem, name, desc, valueptr, isadvanced,
2054  defaultvalue, minvalue, maxvalue, paramchgd, paramdata) );
2055 
2056  return SCIP_OKAY;
2057 }
2058 
2059 /** creates a char parameter, sets it to its default value, and adds it to the parameter set */
2060 SCIP_RETCODE SCIPsetAddCharParam(
2061  SCIP_SET* set, /**< global SCIP settings */
2062  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2063  BMS_BLKMEM* blkmem, /**< block memory */
2064  const char* name, /**< name of the parameter */
2065  const char* desc, /**< description of the parameter */
2066  char* valueptr, /**< pointer to store the current parameter value, or NULL */
2067  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
2068  char defaultvalue, /**< default value of the parameter */
2069  const char* allowedvalues, /**< array with possible parameter values, or NULL if not restricted */
2070  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
2071  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
2072  )
2073 {
2074  assert(set != NULL);
2075 
2076  SCIP_CALL( SCIPparamsetAddChar(set->paramset, messagehdlr, blkmem, name, desc, valueptr, isadvanced,
2077  defaultvalue, allowedvalues, paramchgd, paramdata) );
2078 
2079  return SCIP_OKAY;
2080 }
2081 
2082 /** creates a string parameter, sets it to its default value, and adds it to the parameter set */
2083 SCIP_RETCODE SCIPsetAddStringParam(
2084  SCIP_SET* set, /**< global SCIP settings */
2085  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2086  BMS_BLKMEM* blkmem, /**< block memory */
2087  const char* name, /**< name of the parameter */
2088  const char* desc, /**< description of the parameter */
2089  char** valueptr, /**< pointer to store the current parameter value, or NULL */
2090  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
2091  const char* defaultvalue, /**< default value of the parameter */
2092  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
2093  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
2094  )
2095 {
2096  assert(set != NULL);
2097 
2098  SCIP_CALL( SCIPparamsetAddString(set->paramset, messagehdlr, blkmem, name, desc, valueptr, isadvanced,
2099  defaultvalue, paramchgd, paramdata) );
2100 
2101  return SCIP_OKAY;
2102 }
2103 
2104 /** gets the fixing status value of an existing parameter */
2105 SCIP_Bool SCIPsetIsParamFixed(
2106  SCIP_SET* set, /**< global SCIP settings */
2107  const char* name /**< name of the parameter */
2108  )
2109 {
2110  assert(set != NULL);
2111 
2112  return SCIPparamsetIsFixed(set->paramset, name);
2113 }
2114 
2115 /** returns the pointer to the SCIP parameter with the given name */
2116 SCIP_PARAM* SCIPsetGetParam(
2117  SCIP_SET* set, /**< global SCIP settings */
2118  const char* name /**< name of the parameter */
2119  )
2120 {
2121  assert(set != NULL);
2122 
2123  return SCIPparamsetGetParam(set->paramset, name);
2124 }
2125 
2126 /** gets the value of an existing SCIP_Bool parameter */
2127 SCIP_RETCODE SCIPsetGetBoolParam(
2128  SCIP_SET* set, /**< global SCIP settings */
2129  const char* name, /**< name of the parameter */
2130  SCIP_Bool* value /**< pointer to store the parameter */
2131  )
2132 {
2133  assert(set != NULL);
2134 
2135  SCIP_CALL( SCIPparamsetGetBool(set->paramset, name, value) );
2136 
2137  return SCIP_OKAY;
2138 }
2139 
2140 /** gets the value of an existing Int parameter */
2141 SCIP_RETCODE SCIPsetGetIntParam(
2142  SCIP_SET* set, /**< global SCIP settings */
2143  const char* name, /**< name of the parameter */
2144  int* value /**< pointer to store the value of the parameter */
2145  )
2146 {
2147  assert(set != NULL);
2148 
2149  SCIP_CALL( SCIPparamsetGetInt(set->paramset, name, value) );
2150 
2151  return SCIP_OKAY;
2152 }
2153 
2154 /** gets the value of an existing SCIP_Longint parameter */
2155 SCIP_RETCODE SCIPsetGetLongintParam(
2156  SCIP_SET* set, /**< global SCIP settings */
2157  const char* name, /**< name of the parameter */
2158  SCIP_Longint* value /**< pointer to store the value of the parameter */
2159  )
2160 {
2161  assert(set != NULL);
2162 
2163  SCIP_CALL( SCIPparamsetGetLongint(set->paramset, name, value) );
2164 
2165  return SCIP_OKAY;
2166 }
2167 
2168 /** gets the value of an existing SCIP_Real parameter */
2169 SCIP_RETCODE SCIPsetGetRealParam(
2170  SCIP_SET* set, /**< global SCIP settings */
2171  const char* name, /**< name of the parameter */
2172  SCIP_Real* value /**< pointer to store the value of the parameter */
2173  )
2174 {
2175  assert(set != NULL);
2176 
2177  SCIP_CALL( SCIPparamsetGetReal(set->paramset, name, value) );
2178 
2179  return SCIP_OKAY;
2180 }
2181 
2182 /** gets the value of an existing Char parameter */
2183 SCIP_RETCODE SCIPsetGetCharParam(
2184  SCIP_SET* set, /**< global SCIP settings */
2185  const char* name, /**< name of the parameter */
2186  char* value /**< pointer to store the value of the parameter */
2187  )
2188 {
2189  assert(set != NULL);
2190 
2191  SCIP_CALL( SCIPparamsetGetChar(set->paramset, name, value) );
2192 
2193  return SCIP_OKAY;
2194 }
2195 
2196 /** gets the value of an existing String parameter */
2197 SCIP_RETCODE SCIPsetGetStringParam(
2198  SCIP_SET* set, /**< global SCIP settings */
2199  const char* name, /**< name of the parameter */
2200  char** value /**< pointer to store the value of the parameter */
2201  )
2202 {
2203  assert(set != NULL);
2204 
2205  SCIP_CALL( SCIPparamsetGetString(set->paramset, name, value) );
2206 
2207  return SCIP_OKAY;
2208 }
2209 
2210 /** changes the fixing status of an existing parameter */
2211 SCIP_RETCODE SCIPsetChgParamFixed(
2212  SCIP_SET* set, /**< global SCIP settings */
2213  const char* name, /**< name of the parameter */
2214  SCIP_Bool fixed /**< new fixing status of the parameter */
2215  )
2216 {
2217  assert(set != NULL);
2218 
2219  SCIP_CALL( SCIPparamsetFix(set->paramset, name, fixed) );
2220 
2221  return SCIP_OKAY;
2222 }
2223 
2224 /** changes the value of an existing parameter */
2225 SCIP_RETCODE SCIPsetSetParam(
2226  SCIP_SET* set, /**< global SCIP settings */
2227  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2228  const char* name, /**< name of the parameter */
2229  void* value /**< new value of the parameter */
2230  )
2231 {
2232  assert(set != NULL);
2233 
2234  SCIP_CALL( SCIPparamsetSet(set->paramset, set, messagehdlr, name, value) );
2235 
2236  return SCIP_OKAY;
2237 }
2238 
2239 /** changes the value of an existing SCIP_Bool parameter */
2240 SCIP_RETCODE SCIPsetChgBoolParam(
2241  SCIP_SET* set, /**< global SCIP settings */
2242  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2243  SCIP_PARAM* param, /**< parameter */
2244  SCIP_Bool value /**< new value of the parameter */
2245  )
2246 {
2247  SCIP_RETCODE retcode;
2248 
2249  assert(set != NULL);
2250 
2251  retcode = SCIPparamSetBool(param, set, messagehdlr, value, TRUE);
2252 
2253  if( retcode != SCIP_PARAMETERWRONGVAL )
2254  {
2255  SCIP_CALL( retcode );
2256  }
2257 
2258  return retcode;
2259 }
2260 
2261 /** changes the value of an existing SCIP_Bool parameter */
2262 SCIP_RETCODE SCIPsetSetBoolParam(
2263  SCIP_SET* set, /**< global SCIP settings */
2264  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2265  const char* name, /**< name of the parameter */
2266  SCIP_Bool value /**< new value of the parameter */
2267  )
2268 {
2269  assert(set != NULL);
2270 
2271  SCIP_CALL( SCIPparamsetSetBool(set->paramset, set, messagehdlr, name, value) );
2272 
2273  return SCIP_OKAY;
2274 }
2275 
2276 /** sets the default value of an existing SCIP_Bool parameter */
2277 SCIP_RETCODE SCIPsetSetDefaultBoolParam(
2278  SCIP_SET* set, /**< global SCIP settings */
2279  const char* name, /**< name of the parameter */
2280  SCIP_Bool defaultvalue /**< new default value of the parameter */
2281  )
2282 {
2283  assert(set != NULL);
2284 
2285  SCIP_CALL( SCIPparamsetSetDefaultBool(set->paramset, name, defaultvalue) );
2286 
2287  return SCIP_OKAY;
2288 }
2289 
2290 
2291 /** changes the value of an existing Int parameter */
2292 SCIP_RETCODE SCIPsetChgIntParam(
2293  SCIP_SET* set, /**< global SCIP settings */
2294  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2295  SCIP_PARAM* param, /**< parameter */
2296  int value /**< new value of the parameter */
2297  )
2298 {
2299  SCIP_RETCODE retcode;
2300 
2301  assert(set != NULL);
2302  assert(param != NULL);
2303 
2304  retcode = SCIPparamSetInt(param, set, messagehdlr, value, TRUE);
2305 
2306  if( retcode != SCIP_PARAMETERWRONGVAL )
2307  {
2308  SCIP_CALL( retcode );
2309  }
2310 
2311  return retcode;
2312 }
2313 
2314 /** changes the value of an existing Int parameter */
2315 SCIP_RETCODE SCIPsetSetIntParam(
2316  SCIP_SET* set, /**< global SCIP settings */
2317  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2318  const char* name, /**< name of the parameter */
2319  int value /**< new value of the parameter */
2320  )
2321 {
2322  assert(set != NULL);
2323 
2324  SCIP_CALL( SCIPparamsetSetInt(set->paramset, set, messagehdlr, name, value) );
2325 
2326  return SCIP_OKAY;
2327 }
2328 
2329 /** changes the default value of an existing Int parameter */
2330 SCIP_RETCODE SCIPsetSetDefaultIntParam(
2331  SCIP_SET* set, /**< global SCIP settings */
2332  const char* name, /**< name of the parameter */
2333  int defaultvalue /**< new default value of the parameter */
2334  )
2335 {
2336  assert(set != NULL);
2337 
2338  SCIP_CALL( SCIPparamsetSetDefaultInt(set->paramset, name, defaultvalue) );
2339 
2340  return SCIP_OKAY;
2341 }
2342 
2343 /** changes the value of an existing SCIP_Longint parameter */
2344 SCIP_RETCODE SCIPsetChgLongintParam(
2345  SCIP_SET* set, /**< global SCIP settings */
2346  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2347  SCIP_PARAM* param, /**< parameter */
2348  SCIP_Longint value /**< new value of the parameter */
2349  )
2350 {
2351  SCIP_RETCODE retcode;
2352 
2353  assert(set != NULL);
2354  assert(param != NULL);
2355 
2356  retcode = SCIPparamSetLongint(param, set, messagehdlr, value, TRUE);
2357 
2358  if( retcode != SCIP_PARAMETERWRONGVAL )
2359  {
2360  SCIP_CALL( retcode );
2361  }
2362 
2363  return retcode;
2364 }
2365 
2366 /** changes the value of an existing SCIP_Longint parameter */
2367 SCIP_RETCODE SCIPsetSetLongintParam(
2368  SCIP_SET* set, /**< global SCIP settings */
2369  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2370  const char* name, /**< name of the parameter */
2371  SCIP_Longint value /**< new value of the parameter */
2372  )
2373 {
2374  assert(set != NULL);
2375 
2376  SCIP_CALL( SCIPparamsetSetLongint(set->paramset, set, messagehdlr, name, value) );
2377 
2378  return SCIP_OKAY;
2379 }
2380 
2381 /** changes the value of an existing SCIP_Real parameter */
2382 SCIP_RETCODE SCIPsetChgRealParam(
2383  SCIP_SET* set, /**< global SCIP settings */
2384  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2385  SCIP_PARAM* param, /**< parameter */
2386  SCIP_Real value /**< new value of the parameter */
2387  )
2388 {
2389  SCIP_RETCODE retcode;
2390 
2391  assert(set != NULL);
2392  assert(param != NULL);
2393 
2394  retcode = SCIPparamSetReal(param, set, messagehdlr, value, TRUE);
2395 
2396  if( retcode != SCIP_PARAMETERWRONGVAL )
2397  {
2398  SCIP_CALL( retcode );
2399  }
2400 
2401  return retcode;
2402 }
2403 
2404 /** changes the value of an existing SCIP_Real parameter */
2405 SCIP_RETCODE SCIPsetSetRealParam(
2406  SCIP_SET* set, /**< global SCIP settings */
2407  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2408  const char* name, /**< name of the parameter */
2409  SCIP_Real value /**< new value of the parameter */
2410  )
2411 {
2412  assert(set != NULL);
2413 
2414  SCIP_CALL( SCIPparamsetSetReal(set->paramset, set, messagehdlr, name, value) );
2415 
2416  return SCIP_OKAY;
2417 }
2418 
2419 /** changes the value of an existing Char parameter */
2420 SCIP_RETCODE SCIPsetChgCharParam(
2421  SCIP_SET* set, /**< global SCIP settings */
2422  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2423  SCIP_PARAM* param, /**< parameter */
2424  char value /**< new value of the parameter */
2425  )
2426 {
2427  SCIP_RETCODE retcode;
2428 
2429  assert(set != NULL);
2430  assert(param != NULL);
2431 
2432  retcode = SCIPparamSetChar(param, set, messagehdlr, value, TRUE);
2433 
2434  if( retcode != SCIP_PARAMETERWRONGVAL )
2435  {
2436  SCIP_CALL( retcode );
2437  }
2438 
2439  return retcode;
2440 }
2441 
2442 /** changes the value of an existing Char parameter */
2443 SCIP_RETCODE SCIPsetSetCharParam(
2444  SCIP_SET* set, /**< global SCIP settings */
2445  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2446  const char* name, /**< name of the parameter */
2447  char value /**< new value of the parameter */
2448  )
2449 {
2450  assert(set != NULL);
2451 
2452  SCIP_CALL( SCIPparamsetSetChar(set->paramset, set, messagehdlr, name, value) );
2453 
2454  return SCIP_OKAY;
2455 }
2456 
2457 /** changes the value of an existing String parameter */
2458 SCIP_RETCODE SCIPsetChgStringParam(
2459  SCIP_SET* set, /**< global SCIP settings */
2460  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2461  SCIP_PARAM* param, /**< parameter */
2462  const char* value /**< new value of the parameter */
2463  )
2464 {
2465  SCIP_RETCODE retcode;
2466 
2467  assert(set != NULL);
2468  assert(param != NULL);
2469 
2470  retcode = SCIPparamSetString(param, set, messagehdlr, value, TRUE);
2471 
2472  if( retcode != SCIP_PARAMETERWRONGVAL )
2473  {
2474  SCIP_CALL( retcode );
2475  }
2476 
2477  return retcode;
2478 }
2479 
2480 /** changes the value of an existing String parameter */
2481 SCIP_RETCODE SCIPsetSetStringParam(
2482  SCIP_SET* set, /**< global SCIP settings */
2483  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2484  const char* name, /**< name of the parameter */
2485  const char* value /**< new value of the parameter */
2486  )
2487 {
2488  assert(set != NULL);
2489 
2490  SCIP_CALL( SCIPparamsetSetString(set->paramset, set, messagehdlr, name, value) );
2491 
2492  return SCIP_OKAY;
2493 }
2494 
2495 /** reads parameters from a file */
2496 SCIP_RETCODE SCIPsetReadParams(
2497  SCIP_SET* set, /**< global SCIP settings */
2498  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2499  const char* filename /**< file name */
2500  )
2501 {
2502  assert(set != NULL);
2503 
2504  SCIP_CALL( SCIPparamsetRead(set->paramset, set, messagehdlr, filename) );
2505 
2506  return SCIP_OKAY;
2507 }
2508 
2509 /** writes all parameters in the parameter set to a file */
2510 SCIP_RETCODE SCIPsetWriteParams(
2511  SCIP_SET* set, /**< global SCIP settings */
2512  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2513  const char* filename, /**< file name, or NULL for stdout */
2514  SCIP_Bool comments, /**< should parameter descriptions be written as comments? */
2515  SCIP_Bool onlychanged /**< should only the parameters been written, that are changed from default? */
2516  )
2517 {
2518  assert(set != NULL);
2519 
2520  SCIP_CALL( SCIPparamsetWrite(set->paramset, messagehdlr, filename, comments, onlychanged) );
2521 
2522  return SCIP_OKAY;
2523 }
2524 
2525 /** resets a single parameters to its default value */
2526 SCIP_RETCODE SCIPsetResetParam(
2527  SCIP_SET* set, /**< global SCIP settings */
2528  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2529  const char* name /**< name of the parameter */
2530  )
2531 {
2532  SCIP_CALL( SCIPparamsetSetToDefault(set->paramset, set, messagehdlr, name) );
2533 
2534  return SCIP_OKAY;
2535 }
2536 
2537 /** resets all parameters to their default values */
2538 SCIP_RETCODE SCIPsetResetParams(
2539  SCIP_SET* set, /**< global SCIP settings */
2540  SCIP_MESSAGEHDLR* messagehdlr /**< message handler */
2541  )
2542 {
2543  SCIP_CALL( SCIPparamsetSetToDefaults(set->paramset, set, messagehdlr) );
2544 
2545  return SCIP_OKAY;
2546 }
2547 
2548 /** sets parameters to
2549  * - SCIP_PARAMSETTING_DEFAULT to use default values (see also SCIPsetResetParams())
2550  * - SCIP_PARAMSETTING_COUNTER to get feasible and "fast" counting process
2551  * - SCIP_PARAMSETTING_CPSOLVER to get CP like search (e.g. no LP relaxation)
2552  * - SCIP_PARAMSETTING_EASYCIP to solve easy problems fast
2553  * - SCIP_PARAMSETTING_FEASIBILITY to detect feasibility fast
2554  * - SCIP_PARAMSETTING_HARDLP to be capable to handle hard LPs
2555  * - SCIP_PARAMSETTING_OPTIMALITY to prove optimality fast
2556  */
2557 SCIP_RETCODE SCIPsetSetEmphasis(
2558  SCIP_SET* set, /**< global SCIP settings */
2559  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2560  SCIP_PARAMEMPHASIS paramemphasis, /**< parameter settings */
2561  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
2562  )
2563 {
2564  SCIP_CALL( SCIPparamsetSetEmphasis(set->paramset, set, messagehdlr, paramemphasis, quiet) );
2565 
2566  return SCIP_OKAY;
2567 }
2568 
2569 /** sets parameters to deactivate separators and heuristics that use auxiliary SCIP instances; should be called for
2570  * auxiliary SCIP instances to avoid recursion
2571  */
2572 SCIP_RETCODE SCIPsetSetSubscipsOff(
2573  SCIP_SET* set, /**< global SCIP settings */
2574  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2575  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
2576  )
2577 {
2578  SCIP_CALL( SCIPparamsetSetToSubscipsOff(set->paramset, set, messagehdlr, quiet) );
2579 
2580  return SCIP_OKAY;
2581 }
2582 
2583 /** sets heuristic parameters values to
2584  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all heuristic parameters
2585  * - SCIP_PARAMSETTING_FAST such that the time spend for heuristic is decreased
2586  * - SCIP_PARAMSETTING_AGGRESSIVE such that the heuristic are called more aggregative
2587  * - SCIP_PARAMSETTING_OFF which turn off all heuristics
2588  */
2589 SCIP_RETCODE SCIPsetSetHeuristics(
2590  SCIP_SET* set, /**< global SCIP settings */
2591  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2592  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
2593  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
2594  )
2595 {
2596  SCIP_CALL( SCIPparamsetSetHeuristics(set->paramset, set, messagehdlr, paramsetting, quiet) );
2597 
2598  return SCIP_OKAY;
2599 }
2600 
2601 /** sets presolving parameters to
2602  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all presolving parameters
2603  * - SCIP_PARAMSETTING_FAST such that the time spend for presolving is decreased
2604  * - SCIP_PARAMSETTING_AGGRESSIVE such that the presolving is more aggregative
2605  * - SCIP_PARAMSETTING_OFF which turn off all presolving
2606  */
2607 SCIP_RETCODE SCIPsetSetPresolving(
2608  SCIP_SET* set, /**< global SCIP settings */
2609  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2610  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
2611  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
2612  )
2613 {
2614  SCIP_CALL( SCIPparamsetSetPresolving(set->paramset, set, messagehdlr, paramsetting, quiet) );
2615 
2616  return SCIP_OKAY;
2617 }
2618 
2619 /** sets separating parameters to
2620  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all separating parameters
2621  * - SCIP_PARAMSETTING_FAST such that the time spend for separating is decreased
2622  * - SCIP_PARAMSETTING_AGGRESSIVE such that the separating is done more aggregative
2623  * - SCIP_PARAMSETTING_OFF which turn off all separating
2624  */
2625 SCIP_RETCODE SCIPsetSetSeparating(
2626  SCIP_SET* set, /**< global SCIP settings */
2627  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2628  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
2629  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
2630  )
2631 {
2632  SCIP_CALL( SCIPparamsetSetSeparating(set->paramset, set, messagehdlr, paramsetting, quiet) );
2633 
2634  return SCIP_OKAY;
2635 }
2636 
2637 /** returns the array of all available SCIP parameters */
2638 SCIP_PARAM** SCIPsetGetParams(
2639  SCIP_SET* set /**< global SCIP settings */
2640  )
2641 {
2642  assert(set != NULL);
2643 
2644  return SCIPparamsetGetParams(set->paramset);
2645 }
2646 
2647 /** returns the total number of all available SCIP parameters */
2648 int SCIPsetGetNParams(
2649  SCIP_SET* set /**< global SCIP settings */
2650  )
2651 {
2652  assert(set != NULL);
2653 
2654  return SCIPparamsetGetNParams(set->paramset);
2655 }
2656 
2657 /** inserts file reader in file reader list */
2658 SCIP_RETCODE SCIPsetIncludeReader(
2659  SCIP_SET* set, /**< global SCIP settings */
2660  SCIP_READER* reader /**< file reader */
2661  )
2662 {
2663  assert(set != NULL);
2664  assert(reader != NULL);
2665 
2666  if( set->nreaders >= set->readerssize )
2667  {
2668  set->readerssize = SCIPsetCalcMemGrowSize(set, set->nreaders+1);
2669  SCIP_ALLOC( BMSreallocMemoryArray(&set->readers, set->readerssize) );
2670  }
2671  assert(set->nreaders < set->readerssize);
2672 
2673  set->readers[set->nreaders] = reader;
2674  set->nreaders++;
2675 
2676  return SCIP_OKAY;
2677 }
2678 
2679 /** returns the file reader of the given name, or NULL if not existing */
2680 SCIP_READER* SCIPsetFindReader(
2681  SCIP_SET* set, /**< global SCIP settings */
2682  const char* name /**< name of file reader */
2683  )
2684 {
2685  int i;
2686 
2687  assert(set != NULL);
2688  assert(name != NULL);
2689 
2690  for( i = 0; i < set->nreaders; ++i )
2691  {
2692  if( strcmp(SCIPreaderGetName(set->readers[i]), name) == 0 )
2693  return set->readers[i];
2694  }
2695 
2696  return NULL;
2697 }
2698 
2699 /** inserts variable pricer in variable pricer list */
2700 SCIP_RETCODE SCIPsetIncludePricer(
2701  SCIP_SET* set, /**< global SCIP settings */
2702  SCIP_PRICER* pricer /**< variable pricer */
2703  )
2704 {
2705  assert(set != NULL);
2706  assert(pricer != NULL);
2707 
2708  if( set->npricers >= set->pricerssize )
2709  {
2710  set->pricerssize = SCIPsetCalcMemGrowSize(set, set->npricers+1);
2711  SCIP_ALLOC( BMSreallocMemoryArray(&set->pricers, set->pricerssize) );
2712  }
2713  assert(set->npricers < set->pricerssize);
2714 
2715  set->pricers[set->npricers] = pricer;
2716  set->npricers++;
2717  set->pricerssorted = FALSE;
2718 
2719  return SCIP_OKAY;
2720 }
2721 
2722 /** returns the variable pricer of the given name, or NULL if not existing */
2723 SCIP_PRICER* SCIPsetFindPricer(
2724  SCIP_SET* set, /**< global SCIP settings */
2725  const char* name /**< name of variable pricer */
2726  )
2727 {
2728  int i;
2729 
2730  assert(set != NULL);
2731  assert(name != NULL);
2732 
2733  for( i = 0; i < set->npricers; ++i )
2734  {
2735  if( strcmp(SCIPpricerGetName(set->pricers[i]), name) == 0 )
2736  return set->pricers[i];
2737  }
2738 
2739  return NULL;
2740 }
2741 
2742 /** sorts pricers by priorities */
2743 void SCIPsetSortPricers(
2744  SCIP_SET* set /**< global SCIP settings */
2745  )
2746 {
2747  assert(set != NULL);
2748 
2749  if( !set->pricerssorted )
2750  {
2751  SCIPsortPtr((void**)set->pricers, SCIPpricerComp, set->npricers);
2752  set->pricerssorted = TRUE;
2753  set->pricersnamesorted = FALSE;
2754  }
2755 }
2756 
2757 /** sorts pricers by name */
2758 void SCIPsetSortPricersName(
2759  SCIP_SET* set /**< global SCIP settings */
2760  )
2761 {
2762  assert(set != NULL);
2763 
2764  if( !set->pricersnamesorted )
2765  {
2766  SCIPsortPtr((void**)set->pricers, SCIPpricerCompName, set->npricers);
2767  set->pricerssorted = FALSE;
2768  set->pricersnamesorted = TRUE;
2769  }
2770 }
2771 
2772 /** inserts constraint handler in constraint handler list */
2773 SCIP_RETCODE SCIPsetIncludeConshdlr(
2774  SCIP_SET* set, /**< global SCIP settings */
2775  SCIP_CONSHDLR* conshdlr /**< constraint handler */
2776  )
2777 {
2778  int priority;
2779  int i;
2780 
2781  assert(set != NULL);
2782  assert(conshdlr != NULL);
2783  assert(!SCIPconshdlrIsInitialized(conshdlr));
2784 
2785  /* allocate memory */
2786  if( set->nconshdlrs >= set->conshdlrssize )
2787  {
2788  set->conshdlrssize = SCIPsetCalcMemGrowSize(set, set->nconshdlrs+1);
2789  SCIP_ALLOC( BMSreallocMemoryArray(&set->conshdlrs, set->conshdlrssize) );
2790  SCIP_ALLOC( BMSreallocMemoryArray(&set->conshdlrs_sepa, set->conshdlrssize) );
2791  SCIP_ALLOC( BMSreallocMemoryArray(&set->conshdlrs_enfo, set->conshdlrssize) );
2792  SCIP_ALLOC( BMSreallocMemoryArray(&set->conshdlrs_include, set->conshdlrssize) );
2793  }
2794  assert(set->nconshdlrs < set->conshdlrssize);
2795 
2796  /* sort constraint handler into conshdlrs array sorted by check priority */
2797  priority = SCIPconshdlrGetCheckPriority(conshdlr);
2798  for( i = set->nconshdlrs; i > 0 && SCIPconshdlrGetCheckPriority(set->conshdlrs[i-1]) < priority; --i )
2799  {
2800  set->conshdlrs[i] = set->conshdlrs[i-1];
2801  }
2802  set->conshdlrs[i] = conshdlr;
2803 
2804  /* sort constraint handler into conshdlrs_sepa array sorted by sepa priority */
2805  priority = SCIPconshdlrGetSepaPriority(conshdlr);
2806  for( i = set->nconshdlrs; i > 0 && SCIPconshdlrGetSepaPriority(set->conshdlrs_sepa[i-1]) < priority; --i )
2807  {
2808  set->conshdlrs_sepa[i] = set->conshdlrs_sepa[i-1];
2809  }
2810  set->conshdlrs_sepa[i] = conshdlr;
2811 
2812  /* sort constraint handler into conshdlrs_enfo array sorted by enfo priority */
2813  priority = SCIPconshdlrGetEnfoPriority(conshdlr);
2814  for( i = set->nconshdlrs; i > 0 && SCIPconshdlrGetEnfoPriority(set->conshdlrs_enfo[i-1]) < priority; --i )
2815  {
2816  set->conshdlrs_enfo[i] = set->conshdlrs_enfo[i-1];
2817  }
2818  set->conshdlrs_enfo[i] = conshdlr;
2819 
2820  /* add constraint handler into conshdlrs_include array sorted by inclusion order */
2821  set->conshdlrs_include[set->nconshdlrs] = conshdlr;
2822 
2823  set->nconshdlrs++;
2824 
2825  return SCIP_OKAY;
2826 }
2827 
2828 /** reinserts a constraint handler with modified sepa priority into the sepa priority sorted array */
2829 void SCIPsetReinsertConshdlrSepaPrio(
2830  SCIP_SET* set, /**< global SCIP settings */
2831  SCIP_CONSHDLR* conshdlr, /**< constraint handler to be reinserted */
2832  int oldpriority /**< the old separation priority of constraint handler */
2833  )
2834 {
2835  int newpriority;
2836  int newpos;
2837  int i;
2838  assert(set != NULL);
2839  assert(conshdlr != NULL);
2840 
2841  newpriority = SCIPconshdlrGetSepaPriority(conshdlr);
2842  newpos = -1;
2843 
2844  /* search for the old position of constraint handler; determine its new position at the same time */
2845  if( newpriority > oldpriority )
2846  {
2847  i = 0;
2848  while( i < set->nconshdlrs &&
2849  strcmp(SCIPconshdlrGetName(set->conshdlrs_sepa[i]), SCIPconshdlrGetName(conshdlr)) != 0 )
2850  {
2851  int priorityatpos;
2852 
2853  priorityatpos = SCIPconshdlrGetSepaPriority(set->conshdlrs_sepa[i]);
2854  assert(priorityatpos >= oldpriority);
2855 
2856  /* current index is the position to insert the constraint handler */
2857  if( newpriority > priorityatpos && newpos == -1 )
2858  newpos = i;
2859 
2860  ++i;
2861  }
2862  assert(i < set->nconshdlrs);
2863 
2864  /* constraint must change its position in array */
2865  if( newpos != -1 )
2866  {
2867  /* shift all constraint handlers between old and new position by one, and insert constraint handler */
2868  for( ; i > newpos; --i )
2869  {
2870  set->conshdlrs_sepa[i] = set->conshdlrs_sepa[i-1];
2871  }
2872  set->conshdlrs_sepa[newpos] = conshdlr;
2873  }
2874 
2875  }
2876  else if( newpriority < oldpriority )
2877  {
2878  i = set->nconshdlrs - 1;
2879  while( i >= 0 &&
2880  strcmp(SCIPconshdlrGetName(set->conshdlrs_sepa[i]), SCIPconshdlrGetName(conshdlr)) != 0 )
2881  {
2882  int priorityatpos;
2883 
2884  priorityatpos = SCIPconshdlrGetSepaPriority(set->conshdlrs_sepa[i]);
2885  assert(priorityatpos <= oldpriority);
2886 
2887  /* current index is the position to insert the constraint handler */
2888  if( newpriority < priorityatpos && newpos == -1 )
2889  newpos = i;
2890 
2891  --i;
2892  }
2893  assert(i >= 0);
2894 
2895  /* constraint must change its position in array */
2896  if( newpos != -1 )
2897  {
2898  /* shift all constraint handlers between old and new position by one, and insert constraint handler */
2899  for(; i < newpos; ++i )
2900  {
2901  set->conshdlrs_sepa[i] = set->conshdlrs_sepa[i + 1];
2902  }
2903  set->conshdlrs_sepa[newpos] = conshdlr;
2904  }
2905 #ifndef NDEBUG
2906  for( i = 0; i < set->nconshdlrs - 1; ++i )
2907  assert(SCIPconshdlrGetSepaPriority(set->conshdlrs_sepa[i])
2908  >= SCIPconshdlrGetSepaPriority(set->conshdlrs_sepa[i + 1]));
2909 #endif
2910  }
2911 }
2912 
2913 /** returns the constraint handler of the given name, or NULL if not existing */
2914 SCIP_CONSHDLR* SCIPsetFindConshdlr(
2915  SCIP_SET* set, /**< global SCIP settings */
2916  const char* name /**< name of constraint handler */
2917  )
2918 {
2919  int i;
2920 
2921  assert(set != NULL);
2922  assert(name != NULL);
2923 
2924  for( i = 0; i < set->nconshdlrs; ++i )
2925  {
2926  if( strcmp(SCIPconshdlrGetName(set->conshdlrs[i]), name) == 0 )
2927  return set->conshdlrs[i];
2928  }
2929 
2930  return NULL;
2931 }
2932 
2933 /** inserts conflict handler in conflict handler list */
2934 SCIP_RETCODE SCIPsetIncludeConflicthdlr(
2935  SCIP_SET* set, /**< global SCIP settings */
2936  SCIP_CONFLICTHDLR* conflicthdlr /**< conflict handler */
2937  )
2938 {
2939  assert(set != NULL);
2940  assert(conflicthdlr != NULL);
2941  assert(!SCIPconflicthdlrIsInitialized(conflicthdlr));
2942 
2943  if( set->nconflicthdlrs >= set->conflicthdlrssize )
2944  {
2945  set->conflicthdlrssize = SCIPsetCalcMemGrowSize(set, set->nconflicthdlrs+1);
2946  SCIP_ALLOC( BMSreallocMemoryArray(&set->conflicthdlrs, set->conflicthdlrssize) );
2947  }
2948  assert(set->nconflicthdlrs < set->conflicthdlrssize);
2949 
2950  set->conflicthdlrs[set->nconflicthdlrs] = conflicthdlr;
2951  set->nconflicthdlrs++;
2952  set->conflicthdlrssorted = FALSE;
2953 
2954  return SCIP_OKAY;
2955 }
2956 
2957 /** returns the conflict handler of the given name, or NULL if not existing */
2958 SCIP_CONFLICTHDLR* SCIPsetFindConflicthdlr(
2959  SCIP_SET* set, /**< global SCIP settings */
2960  const char* name /**< name of conflict handler */
2961  )
2962 {
2963  int i;
2964 
2965  assert(set != NULL);
2966  assert(name != NULL);
2967 
2968  for( i = 0; i < set->nconflicthdlrs; ++i )
2969  {
2970  if( strcmp(SCIPconflicthdlrGetName(set->conflicthdlrs[i]), name) == 0 )
2971  return set->conflicthdlrs[i];
2972  }
2973 
2974  return NULL;
2975 }
2976 
2977 /** sorts conflict handlers by priorities */
2978 void SCIPsetSortConflicthdlrs(
2979  SCIP_SET* set /**< global SCIP settings */
2980  )
2981 {
2982  assert(set != NULL);
2983 
2984  if( !set->conflicthdlrssorted )
2985  {
2986  SCIPsortPtr((void**)set->conflicthdlrs, SCIPconflicthdlrComp, set->nconflicthdlrs);
2987  set->conflicthdlrssorted = TRUE;
2988  set->conflicthdlrsnamesorted = FALSE;
2989  }
2990 }
2991 
2992 /** sorts conflict handlers by name */
2993 void SCIPsetSortConflicthdlrsName(
2994  SCIP_SET* set /**< global SCIP settings */
2995  )
2996 {
2997  assert(set != NULL);
2998 
2999  if( !set->conflicthdlrsnamesorted )
3000  {
3001  SCIPsortPtr((void**)set->conflicthdlrs, SCIPconflicthdlrCompName, set->nconflicthdlrs);
3002  set->conflicthdlrssorted = FALSE;
3003  set->conflicthdlrsnamesorted = TRUE;
3004  }
3005 }
3006 
3007 /** inserts presolver in presolver list */
3008 SCIP_RETCODE SCIPsetIncludePresol(
3009  SCIP_SET* set, /**< global SCIP settings */
3010  SCIP_PRESOL* presol /**< presolver */
3011  )
3012 {
3013  assert(set != NULL);
3014  assert(presol != NULL);
3015 
3016  if( set->npresols >= set->presolssize )
3017  {
3018  set->presolssize = SCIPsetCalcMemGrowSize(set, set->npresols+1);
3019  SCIP_ALLOC( BMSreallocMemoryArray(&set->presols, set->presolssize) );
3020  }
3021  assert(set->npresols < set->presolssize);
3022 
3023  set->presols[set->npresols] = presol;
3024  set->npresols++;
3025  set->presolssorted = FALSE;
3026 
3027  return SCIP_OKAY;
3028 }
3029 
3030 /** returns the presolver of the given name, or NULL if not existing */
3031 SCIP_PRESOL* SCIPsetFindPresol(
3032  SCIP_SET* set, /**< global SCIP settings */
3033  const char* name /**< name of presolver */
3034  )
3035 {
3036  int i;
3037 
3038  assert(set != NULL);
3039  assert(name != NULL);
3040 
3041  for( i = 0; i < set->npresols; ++i )
3042  {
3043  if( strcmp(SCIPpresolGetName(set->presols[i]), name) == 0 )
3044  return set->presols[i];
3045  }
3046 
3047  return NULL;
3048 }
3049 
3050 /** sorts presolvers by priorities */
3051 void SCIPsetSortPresols(
3052  SCIP_SET* set /**< global SCIP settings */
3053  )
3054 {
3055  assert(set != NULL);
3056 
3057  if( !set->presolssorted )
3058  {
3059  SCIPsortPtr((void**)set->presols, SCIPpresolComp, set->npresols);
3060  set->presolssorted = TRUE;
3061  set->presolsnamesorted = FALSE;
3062  }
3063 }
3064 
3065 /** sorts presolvers by name */
3066 void SCIPsetSortPresolsName(
3067  SCIP_SET* set /**< global SCIP settings */
3068  )
3069 {
3070  assert(set != NULL);
3071 
3072  if( !set->presolsnamesorted )
3073  {
3074  SCIPsortPtr((void**)set->presols, SCIPpresolCompName, set->npresols);
3075  set->presolssorted = FALSE;
3076  set->presolsnamesorted = TRUE;
3077  }
3078 }
3079 
3080 /** inserts relaxator in relaxator list */
3081 SCIP_RETCODE SCIPsetIncludeRelax(
3082  SCIP_SET* set, /**< global SCIP settings */
3083  SCIP_RELAX* relax /**< relaxator */
3084  )
3085 {
3086  assert(set != NULL);
3087  assert(relax != NULL);
3088  assert(!SCIPrelaxIsInitialized(relax));
3089 
3090  if( set->nrelaxs >= set->relaxssize )
3091  {
3092  set->relaxssize = SCIPsetCalcMemGrowSize(set, set->nrelaxs+1);
3093  SCIP_ALLOC( BMSreallocMemoryArray(&set->relaxs, set->relaxssize) );
3094  }
3095  assert(set->nrelaxs < set->relaxssize);
3096 
3097  set->relaxs[set->nrelaxs] = relax;
3098  set->nrelaxs++;
3099  set->relaxssorted = FALSE;
3100 
3101  return SCIP_OKAY;
3102 }
3103 
3104 /** returns the relaxator of the given name, or NULL if not existing */
3105 SCIP_RELAX* SCIPsetFindRelax(
3106  SCIP_SET* set, /**< global SCIP settings */
3107  const char* name /**< name of relaxator */
3108  )
3109 {
3110  int i;
3111 
3112  assert(set != NULL);
3113  assert(name != NULL);
3114 
3115  for( i = 0; i < set->nrelaxs; ++i )
3116  {
3117  if( strcmp(SCIPrelaxGetName(set->relaxs[i]), name) == 0 )
3118  return set->relaxs[i];
3119  }
3120 
3121  return NULL;
3122 }
3123 
3124 /** sorts relaxators by priorities */
3125 void SCIPsetSortRelaxs(
3126  SCIP_SET* set /**< global SCIP settings */
3127  )
3128 {
3129  assert(set != NULL);
3130 
3131  if( !set->relaxssorted )
3132  {
3133  SCIPsortPtr((void**)set->relaxs, SCIPrelaxComp, set->nrelaxs);
3134  set->relaxssorted = TRUE;
3135  set->relaxsnamesorted = FALSE;
3136  }
3137 }
3138 
3139 /** sorts relaxators by priorities */
3140 void SCIPsetSortRelaxsName(
3141  SCIP_SET* set /**< global SCIP settings */
3142  )
3143 {
3144  assert(set != NULL);
3145 
3146  if( !set->relaxsnamesorted )
3147  {
3148  SCIPsortPtr((void**)set->relaxs, SCIPrelaxCompName, set->nrelaxs);
3149  set->relaxssorted = FALSE;
3150  set->relaxsnamesorted = TRUE;
3151  }
3152 }
3153 
3154 /** inserts separator in separator list */
3155 SCIP_RETCODE SCIPsetIncludeSepa(
3156  SCIP_SET* set, /**< global SCIP settings */
3157  SCIP_SEPA* sepa /**< separator */
3158  )
3159 {
3160  assert(set != NULL);
3161  assert(sepa != NULL);
3162  assert(!SCIPsepaIsInitialized(sepa));
3163 
3164  if( set->nsepas >= set->sepassize )
3165  {
3166  set->sepassize = SCIPsetCalcMemGrowSize(set, set->nsepas+1);
3167  SCIP_ALLOC( BMSreallocMemoryArray(&set->sepas, set->sepassize) );
3168  }
3169  assert(set->nsepas < set->sepassize);
3170 
3171  set->sepas[set->nsepas] = sepa;
3172  set->nsepas++;
3173  set->sepassorted = FALSE;
3174 
3175  return SCIP_OKAY;
3176 }
3177 
3178 /** returns the separator of the given name, or NULL if not existing */
3179 SCIP_SEPA* SCIPsetFindSepa(
3180  SCIP_SET* set, /**< global SCIP settings */
3181  const char* name /**< name of separator */
3182  )
3183 {
3184  int i;
3185 
3186  assert(set != NULL);
3187  assert(name != NULL);
3188 
3189  for( i = 0; i < set->nsepas; ++i )
3190  {
3191  if( strcmp(SCIPsepaGetName(set->sepas[i]), name) == 0 )
3192  return set->sepas[i];
3193  }
3194 
3195  return NULL;
3196 }
3197 
3198 /** sorts separators by priorities */
3199 void SCIPsetSortSepas(
3200  SCIP_SET* set /**< global SCIP settings */
3201  )
3202 {
3203  assert(set != NULL);
3204 
3205  if( !set->sepassorted )
3206  {
3207  SCIPsortPtr((void**)set->sepas, SCIPsepaComp, set->nsepas);
3208  set->sepassorted = TRUE;
3209  set->sepasnamesorted = FALSE;
3210  }
3211 }
3212 
3213 /** sorts separators by name */
3214 void SCIPsetSortSepasName(
3215  SCIP_SET* set /**< global SCIP settings */
3216  )
3217 {
3218  assert(set != NULL);
3219 
3220  if( !set->sepasnamesorted )
3221  {
3222  SCIPsortPtr((void**)set->sepas, SCIPsepaCompName, set->nsepas);
3223  set->sepassorted = FALSE;
3224  set->sepasnamesorted = TRUE;
3225  }
3226 }
3227 
3228 /** inserts propagator in propagator list */
3229 SCIP_RETCODE SCIPsetIncludeProp(
3230  SCIP_SET* set, /**< global SCIP settings */
3231  SCIP_PROP* prop /**< propagator */
3232  )
3233 {
3234  assert(set != NULL);
3235  assert(prop != NULL);
3236  assert(!SCIPpropIsInitialized(prop));
3237 
3238  if( set->nprops >= set->propssize )
3239  {
3240  set->propssize = SCIPsetCalcMemGrowSize(set, set->nprops+1);
3241  SCIP_ALLOC( BMSreallocMemoryArray(&set->props, set->propssize) );
3242  }
3243  assert(set->nprops < set->propssize);
3244 
3245  set->props[set->nprops] = prop;
3246  set->nprops++;
3247  set->propssorted = FALSE;
3248 
3249  return SCIP_OKAY;
3250 }
3251 
3252 /** returns the propagator of the given name, or NULL if not existing */
3253 SCIP_PROP* SCIPsetFindProp(
3254  SCIP_SET* set, /**< global SCIP settings */
3255  const char* name /**< name of propagator */
3256  )
3257 {
3258  int i;
3259 
3260  assert(set != NULL);
3261  assert(name != NULL);
3262 
3263  for( i = 0; i < set->nprops; ++i )
3264  {
3265  if( strcmp(SCIPpropGetName(set->props[i]), name) == 0 )
3266  return set->props[i];
3267  }
3268 
3269  return NULL;
3270 }
3271 
3272 /** sorts propagators by priorities */
3273 void SCIPsetSortProps(
3274  SCIP_SET* set /**< global SCIP settings */
3275  )
3276 {
3277  assert(set != NULL);
3278 
3279  if( !set->propssorted )
3280  {
3281  SCIPsortPtr((void**)set->props, SCIPpropComp, set->nprops);
3282  set->propssorted = TRUE;
3283  set->propspresolsorted = FALSE;
3284  set->propsnamesorted = FALSE;
3285  }
3286 }
3287 
3288 /** sorts propagators by priorities for presolving */
3289 void SCIPsetSortPropsPresol(
3290  SCIP_SET* set /**< global SCIP settings */
3291  )
3292 {
3293  assert(set != NULL);
3294 
3295  if( !set->propspresolsorted )
3296  {
3297  SCIPsortPtr((void**)set->props, SCIPpropCompPresol, set->nprops);
3298  set->propspresolsorted = TRUE;
3299  set->propssorted = FALSE;
3300  set->propsnamesorted = FALSE;
3301  }
3302 }
3303 
3304 /** sorts propagators w.r.t. names */
3305 void SCIPsetSortPropsName(
3306  SCIP_SET* set /**< global SCIP settings */
3307  )
3308 {
3309  assert(set != NULL);
3310 
3311  if( !set->propsnamesorted )
3312  {
3313  SCIPsortPtr((void**)set->props, SCIPpropCompName, set->nprops);
3314  set->propssorted = FALSE;
3315  set->propspresolsorted = FALSE;
3316  set->propsnamesorted = TRUE;
3317  }
3318 }
3319 
3320 /** inserts primal heuristic in primal heuristic list */
3321 SCIP_RETCODE SCIPsetIncludeHeur(
3322  SCIP_SET* set, /**< global SCIP settings */
3323  SCIP_HEUR* heur /**< primal heuristic */
3324  )
3325 {
3326  assert(set != NULL);
3327  assert(heur != NULL);
3328  assert(!SCIPheurIsInitialized(heur));
3329 
3330  if( set->nheurs >= set->heurssize )
3331  {
3332  set->heurssize = SCIPsetCalcMemGrowSize(set, set->nheurs+1);
3333  SCIP_ALLOC( BMSreallocMemoryArray(&set->heurs, set->heurssize) );
3334  }
3335  assert(set->nheurs < set->heurssize);
3336 
3337  set->heurs[set->nheurs] = heur;
3338  set->nheurs++;
3339  set->heurssorted = FALSE;
3340 
3341  return SCIP_OKAY;
3342 }
3343 
3344 /** returns the primal heuristic of the given name, or NULL if not existing */
3345 SCIP_HEUR* SCIPsetFindHeur(
3346  SCIP_SET* set, /**< global SCIP settings */
3347  const char* name /**< name of primal heuristic */
3348  )
3349 {
3350  int i;
3351 
3352  assert(set != NULL);
3353  assert(name != NULL);
3354 
3355  for( i = 0; i < set->nheurs; ++i )
3356  {
3357  if( strcmp(SCIPheurGetName(set->heurs[i]), name) == 0 )
3358  return set->heurs[i];
3359  }
3360 
3361  return NULL;
3362 }
3363 
3364 /** sorts heuristics by priorities */
3365 void SCIPsetSortHeurs(
3366  SCIP_SET* set /**< global SCIP settings */
3367  )
3368 {
3369  assert(set != NULL);
3370 
3371  if( !set->heurssorted )
3372  {
3373  SCIPsortPtr((void**)set->heurs, SCIPheurComp, set->nheurs);
3374  set->heurssorted = TRUE;
3375  set->heursnamesorted = FALSE;
3376  }
3377 }
3378 
3379 /** sorts heuristics by names */
3380 void SCIPsetSortHeursName(
3381  SCIP_SET* set /**< global SCIP settings */
3382  )
3383 {
3384  assert(set != NULL);
3385 
3386  if( !set->heursnamesorted )
3387  {
3388  SCIPsortPtr((void**)set->heurs, SCIPheurCompName, set->nheurs);
3389  set->heurssorted = FALSE;
3390  set->heursnamesorted = TRUE;
3391  }
3392 }
3393 
3394 /** inserts event handler in event handler list */
3395 SCIP_RETCODE SCIPsetIncludeEventhdlr(
3396  SCIP_SET* set, /**< global SCIP settings */
3397  SCIP_EVENTHDLR* eventhdlr /**< event handler */
3398  )
3399 {
3400  assert(set != NULL);
3401  assert(eventhdlr != NULL);
3402  assert(!SCIPeventhdlrIsInitialized(eventhdlr));
3403 
3404  if( set->neventhdlrs >= set->eventhdlrssize )
3405  {
3406  set->eventhdlrssize = SCIPsetCalcMemGrowSize(set, set->neventhdlrs+1);
3407  SCIP_ALLOC( BMSreallocMemoryArray(&set->eventhdlrs, set->eventhdlrssize) );
3408  }
3409  assert(set->neventhdlrs < set->eventhdlrssize);
3410 
3411  set->eventhdlrs[set->neventhdlrs] = eventhdlr;
3412  set->neventhdlrs++;
3413 
3414  return SCIP_OKAY;
3415 }
3416 
3417 /** returns the event handler of the given name, or NULL if not existing */
3418 SCIP_EVENTHDLR* SCIPsetFindEventhdlr(
3419  SCIP_SET* set, /**< global SCIP settings */
3420  const char* name /**< name of event handler */
3421  )
3422 {
3423  int i;
3424 
3425  assert(set != NULL);
3426  assert(name != NULL);
3427 
3428  for( i = 0; i < set->neventhdlrs; ++i )
3429  {
3430  if( strcmp(SCIPeventhdlrGetName(set->eventhdlrs[i]), name) == 0 )
3431  return set->eventhdlrs[i];
3432  }
3433 
3434  return NULL;
3435 }
3436 
3437 /** inserts node selector in node selector list */
3438 SCIP_RETCODE SCIPsetIncludeNodesel(
3439  SCIP_SET* set, /**< global SCIP settings */
3440  SCIP_NODESEL* nodesel /**< node selector */
3441  )
3442 {
3443  int i;
3444  int nodeselstdprio;
3445 
3446  assert(set != NULL);
3447  assert(nodesel != NULL);
3448  assert(!SCIPnodeselIsInitialized(nodesel));
3449 
3450  if( set->nnodesels >= set->nodeselssize )
3451  {
3452  set->nodeselssize = SCIPsetCalcMemGrowSize(set, set->nnodesels+1);
3453  SCIP_ALLOC( BMSreallocMemoryArray(&set->nodesels, set->nodeselssize) );
3454  }
3455  assert(set->nnodesels < set->nodeselssize);
3456 
3457  nodeselstdprio = SCIPnodeselGetStdPriority(nodesel);
3458 
3459  for( i = set->nnodesels; i > 0 && nodeselstdprio > SCIPnodeselGetStdPriority(set->nodesels[i-1]); --i )
3460  set->nodesels[i] = set->nodesels[i-1];
3461 
3462  set->nodesels[i] = nodesel;
3463  set->nnodesels++;
3464 
3465  return SCIP_OKAY;
3466 }
3467 
3468 /** returns the node selector of the given name, or NULL if not existing */
3469 SCIP_NODESEL* SCIPsetFindNodesel(
3470  SCIP_SET* set, /**< global SCIP settings */
3471  const char* name /**< name of event handler */
3472  )
3473 {
3474  int i;
3475 
3476  assert(set != NULL);
3477  assert(name != NULL);
3478 
3479  for( i = 0; i < set->nnodesels; ++i )
3480  {
3481  if( strcmp(SCIPnodeselGetName(set->nodesels[i]), name) == 0 )
3482  return set->nodesels[i];
3483  }
3484 
3485  return NULL;
3486 }
3487 
3488 /** returns node selector with highest priority in the current mode */
3489 SCIP_NODESEL* SCIPsetGetNodesel(
3490  SCIP_SET* set, /**< global SCIP settings */
3491  SCIP_STAT* stat /**< dynamic problem statistics */
3492  )
3493 {
3494  assert(set != NULL);
3495  assert(stat != NULL);
3496 
3497  /* check, if old node selector is still valid */
3498  if( set->nodesel == NULL && set->nnodesels > 0 )
3499  {
3500  int i;
3501 
3502  set->nodesel = set->nodesels[0];
3503 
3504  /* search highest priority node selector */
3505  if( stat->memsavemode )
3506  {
3507  for( i = 1; i < set->nnodesels; ++i )
3508  {
3509  if( SCIPnodeselGetMemsavePriority(set->nodesels[i]) > SCIPnodeselGetMemsavePriority(set->nodesel) )
3510  set->nodesel = set->nodesels[i];
3511  }
3512  }
3513  else
3514  {
3515  for( i = 1; i < set->nnodesels; ++i )
3516  {
3517  if( SCIPnodeselGetStdPriority(set->nodesels[i]) > SCIPnodeselGetStdPriority(set->nodesel) )
3518  set->nodesel = set->nodesels[i];
3519  }
3520  }
3521  }
3522 
3523  return set->nodesel;
3524 }
3525 
3526 /** inserts branching rule in branching rule list */
3527 SCIP_RETCODE SCIPsetIncludeBranchrule(
3528  SCIP_SET* set, /**< global SCIP settings */
3529  SCIP_BRANCHRULE* branchrule /**< branching rule */
3530  )
3531 {
3532  assert(set != NULL);
3533  assert(branchrule != NULL);
3534  assert(!SCIPbranchruleIsInitialized(branchrule));
3535 
3536  if( set->nbranchrules >= set->branchrulessize )
3537  {
3538  set->branchrulessize = SCIPsetCalcMemGrowSize(set, set->nbranchrules+1);
3539  SCIP_ALLOC( BMSreallocMemoryArray(&set->branchrules, set->branchrulessize) );
3540  }
3541  assert(set->nbranchrules < set->branchrulessize);
3542 
3543  set->branchrules[set->nbranchrules] = branchrule;
3544  set->nbranchrules++;
3545  set->branchrulessorted = FALSE;
3546 
3547  return SCIP_OKAY;
3548 }
3549 
3550 /** returns the branching rule of the given name, or NULL if not existing */
3551 SCIP_BRANCHRULE* SCIPsetFindBranchrule(
3552  SCIP_SET* set, /**< global SCIP settings */
3553  const char* name /**< name of event handler */
3554  )
3555 {
3556  int i;
3557 
3558  assert(set != NULL);
3559  assert(name != NULL);
3560 
3561  for( i = 0; i < set->nbranchrules; ++i )
3562  {
3563  if( strcmp(SCIPbranchruleGetName(set->branchrules[i]), name) == 0 )
3564  return set->branchrules[i];
3565  }
3566 
3567  return NULL;
3568 }
3569 
3570 /** sorts branching rules by priorities */
3571 void SCIPsetSortBranchrules(
3572  SCIP_SET* set /**< global SCIP settings */
3573  )
3574 {
3575  assert(set != NULL);
3576 
3577  if( !set->branchrulessorted )
3578  {
3579  SCIPsortPtr((void**)set->branchrules, SCIPbranchruleComp, set->nbranchrules);
3580  set->branchrulessorted = TRUE;
3581  set->branchrulesnamesorted = FALSE;
3582  }
3583 }
3584 
3585 /** sorts branching rules by priorities */
3586 void SCIPsetSortBranchrulesName(
3587  SCIP_SET* set /**< global SCIP settings */
3588  )
3589 {
3590  assert(set != NULL);
3591 
3592  if( !set->branchrulesnamesorted )
3593  {
3594  SCIPsortPtr((void**)set->branchrules, SCIPbranchruleCompName, set->nbranchrules);
3595  set->branchrulessorted = FALSE;
3596  set->branchrulesnamesorted = TRUE;
3597  }
3598 }
3599 
3600 /** inserts display column in display column list */
3601 SCIP_RETCODE SCIPsetIncludeDisp(
3602  SCIP_SET* set, /**< global SCIP settings */
3603  SCIP_DISP* disp /**< display column */
3604  )
3605 {
3606  int i;
3607  int disppos;
3608 
3609  assert(set != NULL);
3610  assert(disp != NULL);
3611  assert(!SCIPdispIsInitialized(disp));
3612 
3613  if( set->ndisps >= set->dispssize )
3614  {
3615  set->dispssize = SCIPsetCalcMemGrowSize(set, set->ndisps+1);
3616  SCIP_ALLOC( BMSreallocMemoryArray(&set->disps, set->dispssize) );
3617  }
3618  assert(set->ndisps < set->dispssize);
3619 
3620  disppos = SCIPdispGetPosition(disp);
3621 
3622  for( i = set->ndisps; i > 0 && disppos < SCIPdispGetPosition(set->disps[i-1]); --i )
3623  {
3624  set->disps[i] = set->disps[i-1];
3625  }
3626  set->disps[i] = disp;
3627  set->ndisps++;
3628 
3629  return SCIP_OKAY;
3630 }
3631 
3632 /** returns the display column of the given name, or NULL if not existing */
3633 SCIP_DISP* SCIPsetFindDisp(
3634  SCIP_SET* set, /**< global SCIP settings */
3635  const char* name /**< name of display */
3636  )
3637 {
3638  int i;
3639 
3640  assert(set != NULL);
3641  assert(name != NULL);
3642 
3643  for( i = 0; i < set->ndisps; ++i )
3644  {
3645  if( strcmp(SCIPdispGetName(set->disps[i]), name) == 0 )
3646  return set->disps[i];
3647  }
3648 
3649  return NULL;
3650 }
3651 
3652 /** inserts dialog in dialog list */
3653 SCIP_RETCODE SCIPsetIncludeDialog(
3654  SCIP_SET* set, /**< global SCIP settings */
3655  SCIP_DIALOG* dialog /**< dialog */
3656  )
3657 {
3658  assert(set != NULL);
3659  assert(dialog != NULL);
3660 
3661  if( set->ndialogs >= set->dialogssize )
3662  {
3663  set->dialogssize = SCIPsetCalcMemGrowSize(set, set->ndialogs+1);
3664  SCIP_ALLOC( BMSreallocMemoryArray(&set->dialogs, set->dialogssize) );
3665  }
3666  assert(set->ndialogs < set->dialogssize);
3667 
3668  set->dialogs[set->ndialogs] = dialog;
3669  set->ndialogs++;
3670 
3671  return SCIP_OKAY;
3672 }
3673 
3674 /** returns if the dialog already exists */
3675 SCIP_Bool SCIPsetExistsDialog(
3676  SCIP_SET* set, /**< global SCIP settings */
3677  SCIP_DIALOG* dialog /**< dialog */
3678  )
3679 {
3680  int i;
3681 
3682  assert(set != NULL);
3683 
3684  if( dialog == NULL )
3685  return FALSE;
3686 
3687  for( i = 0; i < set->ndialogs; ++i )
3688  {
3689  if( set->dialogs[i] == dialog )
3690  return TRUE;
3691  }
3692 
3693  return FALSE;
3694 }
3695 
3696 /** inserts NLPI in NLPI list */
3697 SCIP_RETCODE SCIPsetIncludeNlpi(
3698  SCIP_SET* set, /**< global SCIP settings */
3699  SCIP_NLPI* nlpi /**< NLPI */
3700  )
3701 {
3702  assert(set != NULL);
3703  assert(nlpi != NULL);
3704 
3705  if( set->nnlpis >= set->nlpissize )
3706  {
3707  set->nlpissize = SCIPsetCalcMemGrowSize(set, set->nnlpis+1);
3708  SCIP_ALLOC( BMSreallocMemoryArray(&set->nlpis, set->nlpissize) );
3709  }
3710  assert(set->nnlpis < set->nlpissize);
3711 
3712  set->nlpis[set->nnlpis] = nlpi;
3713  set->nnlpis++;
3714  set->nlpissorted = FALSE;
3715 
3716  return SCIP_OKAY;
3717 }
3718 
3719 /** returns the NLPI of the given name, or NULL if not existing */
3720 SCIP_NLPI* SCIPsetFindNlpi(
3721  SCIP_SET* set, /**< global SCIP settings */
3722  const char* name /**< name of NLPI */
3723  )
3724 {
3725  int i;
3726 
3727  assert(set != NULL);
3728  assert(name != NULL);
3729 
3730  for( i = 0; i < set->nnlpis; ++i )
3731  {
3732  if( strcmp(SCIPnlpiGetName(set->nlpis[i]), name) == 0 )
3733  return set->nlpis[i];
3734  }
3735 
3736  return NULL;
3737 }
3738 
3739 /** sorts NLPIs by priorities */
3740 void SCIPsetSortNlpis(
3741  SCIP_SET* set /**< global SCIP settings */
3742  )
3743 {
3744  assert(set != NULL);
3745 
3746  if( !set->nlpissorted )
3747  {
3748  SCIPsortPtr((void**)set->nlpis, SCIPnlpiComp, set->nnlpis);
3749  set->nlpissorted = TRUE;
3750  }
3751 }
3752 
3753 /** set priority of an NLPI */
3754 void SCIPsetSetPriorityNlpi(
3755  SCIP_SET* set, /**< global SCIP settings */
3756  SCIP_NLPI* nlpi, /**< NLPI */
3757  int priority /**< new priority of NLPI */
3758  )
3759 {
3760  assert(set != NULL);
3761  assert(nlpi != NULL);
3762 
3763  SCIPnlpiSetPriority(nlpi, priority);
3764  set->nlpissorted = FALSE;
3765 }
3766 
3767 /** inserts information about an external code in external codes list */
3768 SCIP_RETCODE SCIPsetIncludeExternalCode(
3769  SCIP_SET* set, /**< global SCIP settings */
3770  const char* name, /**< name of external code */
3771  const char* description /**< description of external code, can be NULL */
3772  )
3773 {
3774  assert(set != NULL);
3775  assert(name != NULL);
3776 
3777  if( set->nextcodes >= set->extcodessize )
3778  {
3779  set->extcodessize = SCIPsetCalcMemGrowSize(set, set->nextcodes+1);
3780  SCIP_ALLOC( BMSreallocMemoryArray(&set->extcodenames, set->extcodessize) );
3781  SCIP_ALLOC( BMSreallocMemoryArray(&set->extcodedescs, set->extcodessize) );
3782  }
3783  assert(set->nextcodes < set->extcodessize);
3784 
3785  BMSduplicateMemoryArray(&(set->extcodenames[set->nextcodes]), name, (int) (strlen(name)+1)); /*lint !e866*/
3786  if( description != NULL )
3787  {
3788  BMSduplicateMemoryArray(&(set->extcodedescs[set->nextcodes]), description, (int) (strlen(description)+1)); /*lint !e866*/
3789  }
3790  else
3791  {
3792  set->extcodedescs[set->nextcodes] = NULL;
3793  }
3794  set->nextcodes++;
3795 
3796  return SCIP_OKAY;
3797 }
3798 
3799 /** calls init methods of all plugins */
3800 SCIP_RETCODE SCIPsetInitPlugins(
3801  SCIP_SET* set, /**< global SCIP settings */
3802  BMS_BLKMEM* blkmem, /**< block memory */
3803  SCIP_STAT* stat /**< dynamic problem statistics */
3804  )
3805 {
3806  int i;
3807 
3808  assert(set != NULL);
3809 
3810  /* active variable pricers */
3811  SCIPsetSortPricers(set);
3812  for( i = 0; i < set->nactivepricers; ++i )
3813  {
3814  SCIP_CALL( SCIPpricerInit(set->pricers[i], set) );
3815  }
3816 
3817  /* constraint handlers */
3818  for( i = 0; i < set->nconshdlrs; ++i )
3819  {
3820  SCIP_CALL( SCIPconshdlrInit(set->conshdlrs[i], blkmem, set, stat) );
3821  }
3822 
3823  /* conflict handlers */
3824  for( i = 0; i < set->nconflicthdlrs; ++i )
3825  {
3826  SCIP_CALL( SCIPconflicthdlrInit(set->conflicthdlrs[i], set) );
3827  }
3828 
3829  /* presolvers */
3830  for( i = 0; i < set->npresols; ++i )
3831  {
3832  SCIP_CALL( SCIPpresolInit(set->presols[i], set) );
3833  }
3834 
3835  /* relaxators */
3836  for( i = 0; i < set->nrelaxs; ++i )
3837  {
3838  SCIP_CALL( SCIPrelaxInit(set->relaxs[i], set) );
3839  }
3840 
3841  /* separators */
3842  for( i = 0; i < set->nsepas; ++i )
3843  {
3844  SCIP_CALL( SCIPsepaInit(set->sepas[i], set) );
3845  }
3846 
3847  /* propagators */
3848  for( i = 0; i < set->nprops; ++i )
3849  {
3850  SCIP_CALL( SCIPpropInit(set->props[i], set) );
3851  }
3852 
3853  /* primal heuristics */
3854  for( i = 0; i < set->nheurs; ++i )
3855  {
3856  SCIP_CALL( SCIPheurInit(set->heurs[i], set) );
3857  }
3858 
3859  /* event handlers */
3860  for( i = 0; i < set->neventhdlrs; ++i )
3861  {
3862  SCIP_CALL( SCIPeventhdlrInit(set->eventhdlrs[i], set) );
3863  }
3864 
3865  /* node selectors */
3866  for( i = 0; i < set->nnodesels; ++i )
3867  {
3868  SCIP_CALL( SCIPnodeselInit(set->nodesels[i], set) );
3869  }
3870 
3871  /* branching rules */
3872  for( i = 0; i < set->nbranchrules; ++i )
3873  {
3874  SCIP_CALL( SCIPbranchruleInit(set->branchrules[i], set) );
3875  }
3876 
3877  /* display columns */
3878  for( i = 0; i < set->ndisps; ++i )
3879  {
3880  SCIP_CALL( SCIPdispInit(set->disps[i], set) );
3881  }
3882  SCIP_CALL( SCIPdispAutoActivate(set) );
3883 
3884  return SCIP_OKAY;
3885 }
3886 
3887 /** calls exit methods of all plugins */
3888 SCIP_RETCODE SCIPsetExitPlugins(
3889  SCIP_SET* set, /**< global SCIP settings */
3890  BMS_BLKMEM* blkmem, /**< block memory */
3891  SCIP_STAT* stat /**< dynamic problem statistics */
3892  )
3893 {
3894  int i;
3895 
3896  assert(set != NULL);
3897 
3898  /* active variable pricers */
3899  SCIPsetSortPricers(set);
3900  for( i = 0; i < set->nactivepricers; ++i )
3901  {
3902  SCIP_CALL( SCIPpricerExit(set->pricers[i], set) );
3903  }
3904 
3905  /* constraint handlers */
3906  for( i = 0; i < set->nconshdlrs; ++i )
3907  {
3908  SCIP_CALL( SCIPconshdlrExit(set->conshdlrs[i], blkmem, set, stat) );
3909  }
3910 
3911  /* conflict handlers */
3912  for( i = 0; i < set->nconflicthdlrs; ++i )
3913  {
3914  SCIP_CALL( SCIPconflicthdlrExit(set->conflicthdlrs[i], set) );
3915  }
3916 
3917  /* presolvers */
3918  for( i = 0; i < set->npresols; ++i )
3919  {
3920  SCIP_CALL( SCIPpresolExit(set->presols[i], set) );
3921  }
3922 
3923  /* relaxators */
3924  for( i = 0; i < set->nrelaxs; ++i )
3925  {
3926  SCIP_CALL( SCIPrelaxExit(set->relaxs[i], set) );
3927  }
3928 
3929  /* separators */
3930  for( i = 0; i < set->nsepas; ++i )
3931  {
3932  SCIP_CALL( SCIPsepaExit(set->sepas[i], set) );
3933  }
3934 
3935  /* propagators */
3936  for( i = 0; i < set->nprops; ++i )
3937  {
3938  SCIP_CALL( SCIPpropExit(set->props[i], set) );
3939  }
3940 
3941  /* primal heuristics */
3942  for( i = 0; i < set->nheurs; ++i )
3943  {
3944  SCIP_CALL( SCIPheurExit(set->heurs[i], set) );
3945  }
3946 
3947  /* event handlers */
3948  for( i = 0; i < set->neventhdlrs; ++i )
3949  {
3950  SCIP_CALL( SCIPeventhdlrExit(set->eventhdlrs[i], set) );
3951  }
3952 
3953  /* node selectors */
3954  for( i = 0; i < set->nnodesels; ++i )
3955  {
3956  SCIP_CALL( SCIPnodeselExit(set->nodesels[i], set) );
3957  }
3958 
3959  /* branching rules */
3960  for( i = 0; i < set->nbranchrules; ++i )
3961  {
3962  SCIP_CALL( SCIPbranchruleExit(set->branchrules[i], set) );
3963  }
3964 
3965  /* display columns */
3966  for( i = 0; i < set->ndisps; ++i )
3967  {
3968  SCIP_CALL( SCIPdispExit(set->disps[i], set) );
3969  }
3970 
3971  return SCIP_OKAY;
3972 }
3973 
3974 /** calls initpre methods of all plugins */
3975 SCIP_RETCODE SCIPsetInitprePlugins(
3976  SCIP_SET* set, /**< global SCIP settings */
3977  BMS_BLKMEM* blkmem, /**< block memory */
3978  SCIP_STAT* stat /**< dynamic problem statistics */
3979  )
3980 {
3981  int i;
3982 
3983  assert(set != NULL);
3984 
3985  /* inform presolvers that the presolving is abound to begin */
3986  for( i = 0; i < set->npresols; ++i )
3987  {
3988  SCIP_CALL( SCIPpresolInitpre(set->presols[i], set) );
3989  }
3990 
3991  /* inform propagators that the presolving is abound to begin */
3992  for( i = 0; i < set->nprops; ++i )
3993  {
3994  SCIP_CALL( SCIPpropInitpre(set->props[i], set) );
3995  }
3996 
3997  /* inform constraint handlers that the presolving is abound to begin */
3998  for( i = 0; i < set->nconshdlrs; ++i )
3999  {
4000  SCIP_CALL( SCIPconshdlrInitpre(set->conshdlrs[i], blkmem, set, stat) );
4001  }
4002 
4003  return SCIP_OKAY;
4004 }
4005 
4006 /** calls exitpre methods of all plugins */
4007 SCIP_RETCODE SCIPsetExitprePlugins(
4008  SCIP_SET* set, /**< global SCIP settings */
4009  BMS_BLKMEM* blkmem, /**< block memory */
4010  SCIP_STAT* stat /**< dynamic problem statistics */
4011  )
4012 {
4013  int i;
4014 
4015  assert(set != NULL);
4016 
4017  /* inform presolvers that the presolving is abound to begin */
4018  for( i = 0; i < set->npresols; ++i )
4019  {
4020  SCIP_CALL( SCIPpresolExitpre(set->presols[i], set) );
4021  }
4022 
4023  /* inform propagators that the presolving is abound to begin */
4024  for( i = 0; i < set->nprops; ++i )
4025  {
4026  SCIP_CALL( SCIPpropExitpre(set->props[i], set) );
4027  }
4028 
4029  /* inform constraint handlers that the presolving is abound to begin */
4030  for( i = 0; i < set->nconshdlrs; ++i )
4031  {
4032  SCIP_CALL( SCIPconshdlrExitpre(set->conshdlrs[i], blkmem, set, stat) );
4033  }
4034 
4035  return SCIP_OKAY;
4036 }
4037 
4038 /** calls initsol methods of all plugins */
4039 SCIP_RETCODE SCIPsetInitsolPlugins(
4040  SCIP_SET* set, /**< global SCIP settings */
4041  BMS_BLKMEM* blkmem, /**< block memory */
4042  SCIP_STAT* stat /**< dynamic problem statistics */
4043  )
4044 {
4045  int i;
4046 
4047  assert(set != NULL);
4048 
4049  /* active variable pricers */
4050  SCIPsetSortPricers(set);
4051  for( i = 0; i < set->nactivepricers; ++i )
4052  {
4053  SCIP_CALL( SCIPpricerInitsol(set->pricers[i], set) );
4054  }
4055 
4056  /* constraint handlers */
4057  for( i = 0; i < set->nconshdlrs; ++i )
4058  {
4059  SCIP_CALL( SCIPconshdlrInitsol(set->conshdlrs[i], blkmem, set, stat) );
4060  }
4061 
4062  /* conflict handlers */
4063  for( i = 0; i < set->nconflicthdlrs; ++i )
4064  {
4065  SCIP_CALL( SCIPconflicthdlrInitsol(set->conflicthdlrs[i], set) );
4066  }
4067 
4068  /* relaxators */
4069  for( i = 0; i < set->nrelaxs; ++i )
4070  {
4071  SCIP_CALL( SCIPrelaxInitsol(set->relaxs[i], set) );
4072  }
4073 
4074  /* separators */
4075  for( i = 0; i < set->nsepas; ++i )
4076  {
4077  SCIP_CALL( SCIPsepaInitsol(set->sepas[i], set) );
4078  }
4079 
4080  /* propagators */
4081  for( i = 0; i < set->nprops; ++i )
4082  {
4083  SCIP_CALL( SCIPpropInitsol(set->props[i], set) );
4084  }
4085 
4086  /* primal heuristics */
4087  for( i = 0; i < set->nheurs; ++i )
4088  {
4089  SCIP_CALL( SCIPheurInitsol(set->heurs[i], set) );
4090  }
4091 
4092  /* event handlers */
4093  for( i = 0; i < set->neventhdlrs; ++i )
4094  {
4095  SCIP_CALL( SCIPeventhdlrInitsol(set->eventhdlrs[i], set) );
4096  }
4097 
4098  /* node selectors */
4099  for( i = 0; i < set->nnodesels; ++i )
4100  {
4101  SCIP_CALL( SCIPnodeselInitsol(set->nodesels[i], set) );
4102  }
4103 
4104  /* branching rules */
4105  for( i = 0; i < set->nbranchrules; ++i )
4106  {
4107  SCIP_CALL( SCIPbranchruleInitsol(set->branchrules[i], set) );
4108  }
4109 
4110  /* display columns */
4111  for( i = 0; i < set->ndisps; ++i )
4112  {
4113  SCIP_CALL( SCIPdispInitsol(set->disps[i], set) );
4114  }
4115 
4116  /* reset feasibility tolerance for relaxations */
4117  set->sepa_primfeastol = SCIP_INVALID;
4118 
4119  return SCIP_OKAY;
4120 }
4121 
4122 /** calls exitsol methods of all plugins */
4123 SCIP_RETCODE SCIPsetExitsolPlugins(
4124  SCIP_SET* set, /**< global SCIP settings */
4125  BMS_BLKMEM* blkmem, /**< block memory */
4126  SCIP_STAT* stat, /**< dynamic problem statistics */
4127  SCIP_Bool restart /**< was this exit solve call triggered by a restart? */
4128  )
4129 {
4130  int i;
4131 
4132  assert(set != NULL);
4133 
4134  /* active variable pricers */
4135  SCIPsetSortPricers(set);
4136  for( i = 0; i < set->nactivepricers; ++i )
4137  {
4138  SCIP_CALL( SCIPpricerExitsol(set->pricers[i], set) );
4139  }
4140 
4141  /* constraint handlers */
4142  for( i = 0; i < set->nconshdlrs; ++i )
4143  {
4144  SCIP_CALL( SCIPconshdlrExitsol(set->conshdlrs[i], blkmem, set, stat, restart) );
4145  }
4146 
4147  /* conflict handlers */
4148  for( i = 0; i < set->nconflicthdlrs; ++i )
4149  {
4150  SCIP_CALL( SCIPconflicthdlrExitsol(set->conflicthdlrs[i], set) );
4151  }
4152 
4153  /* relaxators */
4154  for( i = 0; i < set->nrelaxs; ++i )
4155  {
4156  SCIP_CALL( SCIPrelaxExitsol(set->relaxs[i], set) );
4157  }
4158 
4159  /* separators */
4160  for( i = 0; i < set->nsepas; ++i )
4161  {
4162  SCIP_CALL( SCIPsepaExitsol(set->sepas[i], set) );
4163  }
4164 
4165  /* propagators */
4166  for( i = 0; i < set->nprops; ++i )
4167  {
4168  SCIP_CALL( SCIPpropExitsol(set->props[i], set, restart) );
4169  }
4170 
4171  /* primal heuristics */
4172  for( i = 0; i < set->nheurs; ++i )
4173  {
4174  SCIP_CALL( SCIPheurExitsol(set->heurs[i], set) );
4175  }
4176 
4177  /* event handlers */
4178  for( i = 0; i < set->neventhdlrs; ++i )
4179  {
4180  SCIP_CALL( SCIPeventhdlrExitsol(set->eventhdlrs[i], set) );
4181  }
4182 
4183  /* node selectors */
4184  for( i = 0; i < set->nnodesels; ++i )
4185  {
4186  SCIP_CALL( SCIPnodeselExitsol(set->nodesels[i], set) );
4187  }
4188 
4189  /* branching rules */
4190  for( i = 0; i < set->nbranchrules; ++i )
4191  {
4192  SCIP_CALL( SCIPbranchruleExitsol(set->branchrules[i], set) );
4193  }
4194 
4195  /* display columns */
4196  for( i = 0; i < set->ndisps; ++i )
4197  {
4198  SCIP_CALL( SCIPdispExitsol(set->disps[i], set) );
4199  }
4200 
4201  return SCIP_OKAY;
4202 }
4203 
4204 /** returns the estimated number of bytes used by extern software, e.g., the LP solver */
4205 SCIP_Longint SCIPsetGetMemExternEstim(
4206  SCIP_SET* set /**< global SCIP settings */
4207  )
4208 {
4209  return set->mem_externestim;
4210 }
4211 
4212 /** calculate memory size for dynamically allocated arrays */
4213 int SCIPsetCalcMemGrowSize(
4214  SCIP_SET* set, /**< global SCIP settings */
4215  int num /**< minimum number of entries to store */
4216  )
4217 {
4218  return calcGrowSize(set->mem_arraygrowinit, set->mem_arraygrowfac, num);
4219 }
4220 
4221 /** calculate memory size for tree array */
4222 int SCIPsetCalcTreeGrowSize(
4223  SCIP_SET* set, /**< global SCIP settings */
4224  int num /**< minimum number of entries to store */
4225  )
4226 {
4227  return calcGrowSize(set->mem_treegrowinit, set->mem_treegrowfac, num);
4228 }
4229 
4230 /** calculate memory size for path array */
4231 int SCIPsetCalcPathGrowSize(
4232  SCIP_SET* set, /**< global SCIP settings */
4233  int num /**< minimum number of entries to store */
4234  )
4235 {
4236  return calcGrowSize(set->mem_pathgrowinit, set->mem_pathgrowfac, num);
4237 }
4238 
4239 /** sets verbosity level for message output */
4240 SCIP_RETCODE SCIPsetSetVerbLevel(
4241  SCIP_SET* set, /**< global SCIP settings */
4242  SCIP_VERBLEVEL verblevel /**< verbosity level for message output */
4243  )
4244 {
4245  assert(set != NULL);
4246 
4247  if( verblevel > SCIP_VERBLEVEL_FULL )
4248  {
4249  SCIPerrorMessage("invalid verbosity level <%d>, maximum is <%d>\n", verblevel, SCIP_VERBLEVEL_FULL);
4250  return SCIP_INVALIDCALL;
4251  }
4252 
4253  set->disp_verblevel = verblevel;
4254 
4255  return SCIP_OKAY;
4256 }
4257 
4258 /** sets feasibility tolerance */
4259 SCIP_RETCODE SCIPsetSetFeastol(
4260  SCIP_SET* set, /**< global SCIP settings */
4261  SCIP_Real feastol /**< new feasibility tolerance */
4262  )
4263 {
4264  assert(set != NULL);
4265 
4266  set->num_feastol = feastol;
4267 
4268  /* the feasibility tolerance of the LP solver should never be larger than SCIP's feasibility tolerance; if necessary,
4269  * decrease it; use the SCIP change method in order to mark the LP unsolved
4270  */
4271  if( SCIPsetFeastol(set) < SCIPsetLpfeastol(set) )
4272  {
4273  SCIPdebugMessage("decreasing lpfeastol along with feastol to %g\n", SCIPsetFeastol(set));
4274  SCIP_CALL( SCIPchgLpfeastol(set->scip, SCIPsetFeastol(set), TRUE) );
4275  }
4276 
4277  return SCIP_OKAY;
4278 }
4279 
4280 /** sets primal feasibility tolerance of LP solver */
4281 SCIP_RETCODE SCIPsetSetLpfeastol(
4282  SCIP_SET* set, /**< global SCIP settings */
4283  SCIP_Real lpfeastol, /**< new primal feasibility tolerance of LP solver */
4284  SCIP_Bool printnewvalue /**< should "numerics/lpfeastol = ..." be printed? */
4285  )
4286 {
4287  SCIP_RETCODE retcode;
4288 
4289  assert(set != NULL);
4290 
4291  retcode = SCIP_OKAY;
4292 
4293  /* the feasibility tolerance of the LP solver should never be larger than SCIP's feasibility tolerance; if this is
4294  * tried, we correct it to feastol; note that when we are called, e.g., by paramChgdLpfeastol, lpfeastol has already
4295  * been modified and so we cannot leave the lpfeastol value unchanged; if we would not return SCIP_PARAMETERWRONGVAL
4296  * in this case, the interactive shell would print the incorrect value to be set
4297  */
4298  if( lpfeastol > SCIPsetFeastol(set) )
4299  {
4300  SCIPerrorMessage("LP feasibility tolerance must be at least as tight as SCIP's feasibility tolerance\n");
4301 
4302  retcode = SCIP_PARAMETERWRONGVAL;
4303  printnewvalue = TRUE;
4304 
4305  set->num_lpfeastol = SCIPsetFeastol(set);
4306  }
4307  else
4308  set->num_lpfeastol = lpfeastol;
4309 
4310  if( printnewvalue )
4311  {
4312  SCIPverbMessage(set->scip, SCIP_VERBLEVEL_HIGH, NULL, "numerics/lpfeastol = %.15g\n", SCIPsetLpfeastol(set));
4313  }
4314 
4315  return retcode;
4316 }
4317 
4318 /** sets feasibility tolerance for reduced costs in LP solution */
4319 SCIP_RETCODE SCIPsetSetDualfeastol(
4320  SCIP_SET* set, /**< global SCIP settings */
4321  SCIP_Real dualfeastol /**< new reduced costs feasibility tolerance */
4322  )
4323 {
4324  assert(set != NULL);
4325 
4326  set->num_dualfeastol = dualfeastol;
4327 
4328  return SCIP_OKAY;
4329 }
4330 
4331 /** sets LP convergence tolerance used in barrier algorithm */
4332 SCIP_RETCODE SCIPsetSetBarrierconvtol(
4333  SCIP_SET* set, /**< global SCIP settings */
4334  SCIP_Real barrierconvtol /**< new convergence tolerance used in barrier algorithm */
4335  )
4336 {
4337  assert(set != NULL);
4338 
4339  set->num_barrierconvtol = barrierconvtol;
4340 
4341  return SCIP_OKAY;
4342 }
4343 
4344 /** marks that some limit parameter was changed */
4345 void SCIPsetSetLimitChanged(
4346  SCIP_SET* set /**< global SCIP settings */
4347  )
4348 {
4349  set->limitchanged = TRUE;
4350 
4351  set->istimelimitfinite = !SCIPsetIsInfinity(set, set->limit_time);
4352 }
4353 
4354 /** returns the maximal number of variables priced into the LP per round */
4355 int SCIPsetGetPriceMaxvars(
4356  SCIP_SET* set, /**< global SCIP settings */
4357  SCIP_Bool root /**< are we at the root node? */
4358  )
4359 {
4360  assert(set != NULL);
4361 
4362  if( root )
4363  return set->price_maxvarsroot;
4364  else
4365  return set->price_maxvars;
4366 }
4367 
4368 /** returns the maximal number of cuts separated per round */
4369 int SCIPsetGetSepaMaxcuts(
4370  SCIP_SET* set, /**< global SCIP settings */
4371  SCIP_Bool root /**< are we at the root node? */
4372  )
4373 {
4374  assert(set != NULL);
4375 
4376  if( root )
4377  return set->sepa_maxcutsroot;
4378  else
4379  return set->sepa_maxcuts;
4380 }
4381 
4382 
4383 
4384 /*
4385  * simple functions implemented as defines
4386  */
4387 
4388 /* In debug mode, the following methods are implemented as function calls to ensure
4389  * type validity.
4390  * In optimized mode, the methods are implemented as defines to improve performance.
4391  * However, we want to have them in the library anyways, so we have to undef the defines.
4392  */
4393 
4394 #undef SCIPsetInfinity
4395 #undef SCIPsetEpsilon
4396 #undef SCIPsetSumepsilon
4397 #undef SCIPsetFeastol
4398 #undef SCIPsetLpfeastol
4399 #undef SCIPsetSepaprimfeastol
4400 #undef SCIPsetDualfeastol
4401 #undef SCIPsetBarrierconvtol
4402 #undef SCIPsetPseudocosteps
4403 #undef SCIPsetPseudocostdelta
4404 #undef SCIPsetCutoffbounddelta
4405 #undef SCIPsetRecompfac
4406 #undef SCIPsetIsEQ
4407 #undef SCIPsetIsLT
4408 #undef SCIPsetIsLE
4409 #undef SCIPsetIsGT
4410 #undef SCIPsetIsGE
4411 #undef SCIPsetIsInfinity
4412 #undef SCIPsetIsZero
4413 #undef SCIPsetIsPositive
4414 #undef SCIPsetIsNegative
4415 #undef SCIPsetIsIntegral
4416 #undef SCIPsetIsScalingIntegral
4417 #undef SCIPsetIsFracIntegral
4418 #undef SCIPsetFloor
4419 #undef SCIPsetCeil
4420 #undef SCIPsetRound
4421 #undef SCIPsetFrac
4422 #undef SCIPsetIsSumEQ
4423 #undef SCIPsetIsSumLT
4424 #undef SCIPsetIsSumLE
4425 #undef SCIPsetIsSumGT
4426 #undef SCIPsetIsSumGE
4427 #undef SCIPsetIsSumZero
4428 #undef SCIPsetIsSumPositive
4429 #undef SCIPsetIsSumNegative
4430 #undef SCIPsetSumFloor
4431 #undef SCIPsetSumCeil
4432 #undef SCIPsetSumRound
4433 #undef SCIPsetSumFrac
4434 #undef SCIPsetIsFeasEQ
4435 #undef SCIPsetIsFeasLT
4436 #undef SCIPsetIsFeasLE
4437 #undef SCIPsetIsFeasGT
4438 #undef SCIPsetIsFeasGE
4439 #undef SCIPsetIsFeasZero
4440 #undef SCIPsetIsFeasPositive
4441 #undef SCIPsetIsFeasNegative
4442 #undef SCIPsetIsFeasIntegral
4443 #undef SCIPsetIsFeasFracIntegral
4444 #undef SCIPsetFeasFloor
4445 #undef SCIPsetFeasCeil
4446 #undef SCIPsetFeasRound
4447 #undef SCIPsetFeasFrac
4448 #undef SCIPsetIsDualfeasEQ
4449 #undef SCIPsetIsDualfeasLT
4450 #undef SCIPsetIsDualfeasLE
4451 #undef SCIPsetIsDualfeasGT
4452 #undef SCIPsetIsDualfeasGE
4453 #undef SCIPsetIsDualfeasZero
4454 #undef SCIPsetIsDualfeasPositive
4455 #undef SCIPsetIsDualfeasNegative
4456 #undef SCIPsetIsDualfeasIntegral
4457 #undef SCIPsetIsDualfeasFracIntegral
4458 #undef SCIPsetDualfeasFloor
4459 #undef SCIPsetDualfeasCeil
4460 #undef SCIPsetDualfeasRound
4461 #undef SCIPsetDualfeasFrac
4462 #undef SCIPsetIsLbBetter
4463 #undef SCIPsetIsUbBetter
4464 #undef SCIPsetIsEfficacious
4465 #undef SCIPsetIsRelEQ
4466 #undef SCIPsetIsRelLT
4467 #undef SCIPsetIsRelLE
4468 #undef SCIPsetIsRelGT
4469 #undef SCIPsetIsRelGE
4470 #undef SCIPsetIsSumRelEQ
4471 #undef SCIPsetIsSumRelLT
4472 #undef SCIPsetIsSumRelLE
4473 #undef SCIPsetIsSumRelGT
4474 #undef SCIPsetIsSumRelGE
4475 #undef SCIPsetIsUpdateUnreliable
4476 #undef SCIPsetIsHugeValue
4477 #undef SCIPsetGetHugeValue
4478 
4479 /** returns value treated as infinity */
4480 SCIP_Real SCIPsetInfinity(
4481  SCIP_SET* set /**< global SCIP settings */
4482  )
4483 {
4484  assert(set != NULL);
4485 
4486  return set->num_infinity;
4487 }
4488 
4489 /** returns the minimum value that is regarded as huge and should be handled separately (e.g., in activity
4490  * computation)
4491  */
4492 SCIP_Real SCIPsetGetHugeValue(
4493  SCIP_SET* set /**< global SCIP settings */
4494  )
4495 {
4496  assert(set != NULL);
4497 
4498  return set->num_hugeval;
4499 }
4500 
4501 /** returns value treated as zero */
4502 SCIP_Real SCIPsetEpsilon(
4503  SCIP_SET* set /**< global SCIP settings */
4504  )
4505 {
4506  assert(set != NULL);
4507 
4508  return set->num_epsilon;
4509 }
4510 
4511 /** returns value treated as zero for sums of floating point values */
4512 SCIP_Real SCIPsetSumepsilon(
4513  SCIP_SET* set /**< global SCIP settings */
4514  )
4515 {
4516  assert(set != NULL);
4517 
4518  return set->num_sumepsilon;
4519 }
4520 
4521 /** returns feasibility tolerance for constraints */
4522 SCIP_Real SCIPsetFeastol(
4523  SCIP_SET* set /**< global SCIP settings */
4524  )
4525 {
4526  assert(set != NULL);
4527 
4528  return set->num_feastol;
4529 }
4530 
4531 /** returns feasibility tolerance for reduced costs */
4532 SCIP_Real SCIPsetDualfeastol(
4533  SCIP_SET* set /**< global SCIP settings */
4534  )
4535 {
4536  assert(set != NULL);
4537 
4538  return set->num_dualfeastol;
4539 }
4540 
4541 /** returns primal feasibility tolerance of LP solver */
4542 SCIP_Real SCIPsetLpfeastol(
4543  SCIP_SET* set /**< global SCIP settings */
4544  )
4545 {
4546  assert(set != NULL);
4547 
4548  if( set->sepa_primfeastol != SCIP_INVALID ) /*lint !e777*/
4549  return MIN(set->sepa_primfeastol, set->num_lpfeastol);
4550 
4551  return set->num_lpfeastol;
4552 }
4553 
4554 /** returns primal feasibility tolerance as specified by separation storage, or SCIP_INVALID */
4555 SCIP_Real SCIPsetSepaprimfeastol(
4556  SCIP_SET* set /**< global SCIP settings */
4557  )
4558 {
4559  return set->sepa_primfeastol;
4560 }
4561 
4562 /** returns convergence tolerance used in barrier algorithm */
4563 SCIP_Real SCIPsetBarrierconvtol(
4564  SCIP_SET* set /**< global SCIP settings */
4565  )
4566 {
4567  assert(set != NULL);
4568 
4569  return set->num_barrierconvtol;
4570 }
4571 
4572 /** returns minimal variable distance value to use for pseudo cost updates */
4573 SCIP_Real SCIPsetPseudocosteps(
4574  SCIP_SET* set /**< global SCIP settings */
4575  )
4576 {
4577  assert(set != NULL);
4578 
4579  return set->num_pseudocosteps;
4580 }
4581 
4582 /** returns minimal minimal objective distance value to use for pseudo cost updates */
4583 SCIP_Real SCIPsetPseudocostdelta(
4584  SCIP_SET* set /**< global SCIP settings */
4585  )
4586 {
4587  assert(set != NULL);
4588 
4589  return set->num_pseudocostdelta;
4590 }
4591 
4592 /** return the delta to use for computing the cutoff bound for integral objectives */
4593 SCIP_Real SCIPsetCutoffbounddelta(
4594  SCIP_SET* set /**< global SCIP settings */
4595  )
4596 {
4597  SCIP_Real feastol;
4598 
4599  assert(set != NULL);
4600 
4601  feastol = SCIPsetFeastol(set);
4602 
4603  return MIN(100.0 * feastol, 0.0001);
4604 }
4605 
4606 /** returns minimal decrease factor that causes the recomputation of a value
4607  * (e.g., pseudo objective) instead of an update */
4608 SCIP_Real SCIPsetRecompfac(
4609  SCIP_SET* set /**< global SCIP settings */
4610  )
4611 {
4612  assert(set != NULL);
4613 
4614  return set->num_recompfac;
4615 }
4616 
4617 /** checks, if value is (positive) infinite */
4618 SCIP_Bool SCIPsetIsInfinity(
4619  SCIP_SET* set, /**< global SCIP settings */
4620  SCIP_Real val /**< value to be compared against infinity */
4621  )
4622 {
4623  assert(set != NULL);
4624 
4625  return (val >= set->num_infinity);
4626 }
4627 
4628 /** checks, if value is huge and should be handled separately (e.g., in activity computation) */
4629 SCIP_Bool SCIPsetIsHugeValue(
4630  SCIP_SET* set, /**< global SCIP settings */
4631  SCIP_Real val /**< value to be checked whether it is huge */
4632  )
4633 {
4634  assert(set != NULL);
4635 
4636  return (val >= set->num_hugeval);
4637 }
4638 
4639 /** checks, if values are in range of epsilon */
4640 SCIP_Bool SCIPsetIsEQ(
4641  SCIP_SET* set, /**< global SCIP settings */
4642  SCIP_Real val1, /**< first value to be compared */
4643  SCIP_Real val2 /**< second value to be compared */
4644  )
4645 {
4646  assert(set != NULL);
4647 
4648  return EPSEQ(val1, val2, set->num_epsilon);
4649 }
4650 
4651 /** checks, if val1 is (more than epsilon) lower than val2 */
4652 SCIP_Bool SCIPsetIsLT(
4653  SCIP_SET* set, /**< global SCIP settings */
4654  SCIP_Real val1, /**< first value to be compared */
4655  SCIP_Real val2 /**< second value to be compared */
4656  )
4657 {
4658  assert(set != NULL);
4659 
4660  return EPSLT(val1, val2, set->num_epsilon);
4661 }
4662 
4663 /** checks, if val1 is not (more than epsilon) greater than val2 */
4664 SCIP_Bool SCIPsetIsLE(
4665  SCIP_SET* set, /**< global SCIP settings */
4666  SCIP_Real val1, /**< first value to be compared */
4667  SCIP_Real val2 /**< second value to be compared */
4668  )
4669 {
4670  assert(set != NULL);
4671 
4672  return EPSLE(val1, val2, set->num_epsilon);
4673 }
4674 
4675 /** checks, if val1 is (more than epsilon) greater than val2 */
4676 SCIP_Bool SCIPsetIsGT(
4677  SCIP_SET* set, /**< global SCIP settings */
4678  SCIP_Real val1, /**< first value to be compared */
4679  SCIP_Real val2 /**< second value to be compared */
4680  )
4681 {
4682  assert(set != NULL);
4683 
4684  return EPSGT(val1, val2, set->num_epsilon);
4685 }
4686 
4687 /** checks, if val1 is not (more than epsilon) lower than val2 */
4688 SCIP_Bool SCIPsetIsGE(
4689  SCIP_SET* set, /**< global SCIP settings */
4690  SCIP_Real val1, /**< first value to be compared */
4691  SCIP_Real val2 /**< second value to be compared */
4692  )
4693 {
4694  assert(set != NULL);
4695 
4696  return EPSGE(val1, val2, set->num_epsilon);
4697 }
4698 
4699 /** checks, if value is in range epsilon of 0.0 */
4700 SCIP_Bool SCIPsetIsZero(
4701  SCIP_SET* set, /**< global SCIP settings */
4702  SCIP_Real val /**< value to process */
4703  )
4704 {
4705  assert(set != NULL);
4706 
4707  return EPSZ(val, set->num_epsilon);
4708 }
4709 
4710 /** checks, if value is greater than epsilon */
4711 SCIP_Bool SCIPsetIsPositive(
4712  SCIP_SET* set, /**< global SCIP settings */
4713  SCIP_Real val /**< value to process */
4714  )
4715 {
4716  assert(set != NULL);
4717 
4718  return EPSP(val, set->num_epsilon);
4719 }
4720 
4721 /** checks, if value is lower than -epsilon */
4722 SCIP_Bool SCIPsetIsNegative(
4723  SCIP_SET* set, /**< global SCIP settings */
4724  SCIP_Real val /**< value to process */
4725  )
4726 {
4727  assert(set != NULL);
4728 
4729  return EPSN(val, set->num_epsilon);
4730 }
4731 
4732 /** checks, if value is integral within epsilon */
4733 SCIP_Bool SCIPsetIsIntegral(
4734  SCIP_SET* set, /**< global SCIP settings */
4735  SCIP_Real val /**< value to process */
4736  )
4737 {
4738  assert(set != NULL);
4739 
4740  return EPSISINT(val, set->num_epsilon);
4741 }
4742 
4743 /** checks whether the product val * scalar is integral in epsilon scaled by scalar */
4744 SCIP_Bool SCIPsetIsScalingIntegral(
4745  SCIP_SET* set, /**< global SCIP settings */
4746  SCIP_Real val, /**< unscaled value to check for scaled integrality */
4747  SCIP_Real scalar /**< value to scale val with for checking for integrality */
4748  )
4749 {
4750  SCIP_Real scaledeps;
4751 
4752  assert(set != NULL);
4753 
4754  scaledeps = REALABS(scalar);
4755  scaledeps = MAX(scaledeps, 1.0);
4756  scaledeps *= set->num_epsilon;
4757 
4758  return EPSISINT(scalar*val, scaledeps);
4759 }
4760 
4761 /** checks, if given fractional part is smaller than epsilon */
4762 SCIP_Bool SCIPsetIsFracIntegral(
4763  SCIP_SET* set, /**< global SCIP settings */
4764  SCIP_Real val /**< value to process */
4765  )
4766 {
4767  assert(set != NULL);
4768  assert(SCIPsetIsGE(set, val, -set->num_epsilon));
4769  assert(SCIPsetIsLE(set, val, 1.0+set->num_epsilon));
4770 
4771  return (val <= set->num_epsilon);
4772 }
4773 
4774 /** rounds value + feasibility tolerance down to the next integer in epsilon tolerance */
4775 SCIP_Real SCIPsetFloor(
4776  SCIP_SET* set, /**< global SCIP settings */
4777  SCIP_Real val /**< value to process */
4778  )
4779 {
4780  assert(set != NULL);
4781 
4782  return EPSFLOOR(val, set->num_epsilon);
4783 }
4784 
4785 /** rounds value - feasibility tolerance up to the next integer in epsilon tolerance */
4786 SCIP_Real SCIPsetCeil(
4787  SCIP_SET* set, /**< global SCIP settings */
4788  SCIP_Real val /**< value to process */
4789  )
4790 {
4791  assert(set != NULL);
4792 
4793  return EPSCEIL(val, set->num_epsilon);
4794 }
4795 
4796 /** rounds value to the nearest integer in epsilon tolerance */
4797 SCIP_Real SCIPsetRound(
4798  SCIP_SET* set, /**< global SCIP settings */
4799  SCIP_Real val /**< value to process */
4800  )
4801 {
4802  assert(set != NULL);
4803 
4804  return EPSROUND(val, set->num_epsilon);
4805 }
4806 
4807 /** returns fractional part of value, i.e. x - floor(x) in epsilon tolerance */
4808 SCIP_Real SCIPsetFrac(
4809  SCIP_SET* set, /**< global SCIP settings */
4810  SCIP_Real val /**< value to return fractional part for */
4811  )
4812 {
4813  assert(set != NULL);
4814 
4815  return EPSFRAC(val, set->num_epsilon);
4816 }
4817 
4818 /** checks, if values are in range of sumepsilon */
4819 SCIP_Bool SCIPsetIsSumEQ(
4820  SCIP_SET* set, /**< global SCIP settings */
4821  SCIP_Real val1, /**< first value to be compared */
4822  SCIP_Real val2 /**< second value to be compared */
4823  )
4824 {
4825  assert(set != NULL);
4826 
4827  return EPSEQ(val1, val2, set->num_sumepsilon);
4828 }
4829 
4830 /** checks, if val1 is (more than sumepsilon) lower than val2 */
4831 SCIP_Bool SCIPsetIsSumLT(
4832  SCIP_SET* set, /**< global SCIP settings */
4833  SCIP_Real val1, /**< first value to be compared */
4834  SCIP_Real val2 /**< second value to be compared */
4835  )
4836 {
4837  assert(set != NULL);
4838 
4839  return EPSLT(val1, val2, set->num_sumepsilon);
4840 }
4841 
4842 /** checks, if val1 is not (more than sumepsilon) greater than val2 */
4843 SCIP_Bool SCIPsetIsSumLE(
4844  SCIP_SET* set, /**< global SCIP settings */
4845  SCIP_Real val1, /**< first value to be compared */
4846  SCIP_Real val2 /**< second value to be compared */
4847  )
4848 {
4849  assert(set != NULL);
4850 
4851  return EPSLE(val1, val2, set->num_sumepsilon);
4852 }
4853 
4854 /** checks, if val1 is (more than sumepsilon) greater than val2 */
4855 SCIP_Bool SCIPsetIsSumGT(
4856  SCIP_SET* set, /**< global SCIP settings */
4857  SCIP_Real val1, /**< first value to be compared */
4858  SCIP_Real val2 /**< second value to be compared */
4859  )
4860 {
4861  assert(set != NULL);
4862 
4863  return EPSGT(val1, val2, set->num_sumepsilon);
4864 }
4865 
4866 /** checks, if val1 is not (more than sumepsilon) lower than val2 */
4867 SCIP_Bool SCIPsetIsSumGE(
4868  SCIP_SET* set, /**< global SCIP settings */
4869  SCIP_Real val1, /**< first value to be compared */
4870  SCIP_Real val2 /**< second value to be compared */
4871  )
4872 {
4873  assert(set != NULL);
4874 
4875  return EPSGE(val1, val2, set->num_sumepsilon);
4876 }
4877 
4878 /** checks, if value is in range sumepsilon of 0.0 */
4879 SCIP_Bool SCIPsetIsSumZero(
4880  SCIP_SET* set, /**< global SCIP settings */
4881  SCIP_Real val /**< value to process */
4882  )
4883 {
4884  assert(set != NULL);
4885 
4886  return EPSZ(val, set->num_sumepsilon);
4887 }
4888 
4889 /** checks, if value is greater than sumepsilon */
4890 SCIP_Bool SCIPsetIsSumPositive(
4891  SCIP_SET* set, /**< global SCIP settings */
4892  SCIP_Real val /**< value to process */
4893  )
4894 {
4895  assert(set != NULL);
4896 
4897  return EPSP(val, set->num_sumepsilon);
4898 }
4899 
4900 /** checks, if value is lower than -sumepsilon */
4901 SCIP_Bool SCIPsetIsSumNegative(
4902  SCIP_SET* set, /**< global SCIP settings */
4903  SCIP_Real val /**< value to process */
4904  )
4905 {
4906  assert(set != NULL);
4907 
4908  return EPSN(val, set->num_sumepsilon);
4909 }
4910 
4911 /** rounds value + sumepsilon tolerance down to the next integer */
4912 SCIP_Real SCIPsetSumFloor(
4913  SCIP_SET* set, /**< global SCIP settings */
4914  SCIP_Real val /**< value to process */
4915  )
4916 {
4917  assert(set != NULL);
4918 
4919  return EPSFLOOR(val, set->num_sumepsilon);
4920 }
4921 
4922 /** rounds value - sumepsilon tolerance up to the next integer */
4923 SCIP_Real SCIPsetSumCeil(
4924  SCIP_SET* set, /**< global SCIP settings */
4925  SCIP_Real val /**< value to process */
4926  )
4927 {
4928  assert(set != NULL);
4929 
4930  return EPSCEIL(val, set->num_sumepsilon);
4931 }
4932 
4933 /** rounds value to the nearest integer in sumepsilon tolerance */
4934 SCIP_Real SCIPsetSumRound(
4935  SCIP_SET* set, /**< global SCIP settings */
4936  SCIP_Real val /**< value to process */
4937  )
4938 {
4939  assert(set != NULL);
4940 
4941  return EPSROUND(val, set->num_sumepsilon);
4942 }
4943 
4944 /** returns fractional part of value, i.e. x - floor(x) in sumepsilon tolerance */
4945 SCIP_Real SCIPsetSumFrac(
4946  SCIP_SET* set, /**< global SCIP settings */
4947  SCIP_Real val /**< value to process */
4948  )
4949 {
4950  assert(set != NULL);
4951 
4952  return EPSFRAC(val, set->num_sumepsilon);
4953 }
4954 
4955 /** checks, if relative difference of values is in range of feastol */
4956 SCIP_Bool SCIPsetIsFeasEQ(
4957  SCIP_SET* set, /**< global SCIP settings */
4958  SCIP_Real val1, /**< first value to be compared */
4959  SCIP_Real val2 /**< second value to be compared */
4960  )
4961 {
4962  SCIP_Real diff;
4963 
4964  assert(set != NULL);
4965 
4966  diff = SCIPrelDiff(val1, val2);
4967 
4968  return EPSZ(diff, set->num_feastol);
4969 }
4970 
4971 /** checks, if relative difference of val1 and val2 is lower than feastol */
4972 SCIP_Bool SCIPsetIsFeasLT(
4973  SCIP_SET* set, /**< global SCIP settings */
4974  SCIP_Real val1, /**< first value to be compared */
4975  SCIP_Real val2 /**< second value to be compared */
4976  )
4977 {
4978  SCIP_Real diff;
4979 
4980  assert(set != NULL);
4981 
4982  diff = SCIPrelDiff(val1, val2);
4983 
4984  return EPSN(diff, set->num_feastol);
4985 }
4986 
4987 /** checks, if relative difference of val1 and val2 is not greater than feastol */
4988 SCIP_Bool SCIPsetIsFeasLE(
4989  SCIP_SET* set, /**< global SCIP settings */
4990  SCIP_Real val1, /**< first value to be compared */
4991  SCIP_Real val2 /**< second value to be compared */
4992  )
4993 {
4994  SCIP_Real diff;
4995 
4996  assert(set != NULL);
4997 
4998  diff = SCIPrelDiff(val1, val2);
4999 
5000  return !EPSP(diff, set->num_feastol);
5001 }
5002 
5003 /** checks, if relative difference of val1 and val2 is greater than feastol */
5004 SCIP_Bool SCIPsetIsFeasGT(
5005  SCIP_SET* set, /**< global SCIP settings */
5006  SCIP_Real val1, /**< first value to be compared */
5007  SCIP_Real val2 /**< second value to be compared */
5008  )
5009 {
5010  SCIP_Real diff;
5011 
5012  assert(set != NULL);
5013 
5014  diff = SCIPrelDiff(val1, val2);
5015 
5016  return EPSP(diff, set->num_feastol);
5017 }
5018 
5019 /** checks, if relative difference of val1 and val2 is not lower than -feastol */
5020 SCIP_Bool SCIPsetIsFeasGE(
5021  SCIP_SET* set, /**< global SCIP settings */
5022  SCIP_Real val1, /**< first value to be compared */
5023  SCIP_Real val2 /**< second value to be compared */
5024  )
5025 {
5026  SCIP_Real diff;
5027 
5028  assert(set != NULL);
5029 
5030  diff = SCIPrelDiff(val1, val2);
5031 
5032  return !EPSN(diff, set->num_feastol);
5033 }
5034 
5035 /** checks, if value is in range feasibility tolerance of 0.0 */
5036 SCIP_Bool SCIPsetIsFeasZero(
5037  SCIP_SET* set, /**< global SCIP settings */
5038  SCIP_Real val /**< value to process */
5039  )
5040 {
5041  assert(set != NULL);
5042 
5043  return EPSZ(val, set->num_feastol);
5044 }
5045 
5046 /** checks, if value is greater than feasibility tolerance */
5047 SCIP_Bool SCIPsetIsFeasPositive(
5048  SCIP_SET* set, /**< global SCIP settings */
5049  SCIP_Real val /**< value to process */
5050  )
5051 {
5052  assert(set != NULL);
5053 
5054  return EPSP(val, set->num_feastol);
5055 }
5056 
5057 /** checks, if value is lower than -feasibility tolerance */
5058 SCIP_Bool SCIPsetIsFeasNegative(
5059  SCIP_SET* set, /**< global SCIP settings */
5060  SCIP_Real val /**< value to process */
5061  )
5062 {
5063  assert(set != NULL);
5064 
5065  return EPSN(val, set->num_feastol);
5066 }
5067 
5068 /** checks, if value is integral within the feasibility bounds */
5069 SCIP_Bool SCIPsetIsFeasIntegral(
5070  SCIP_SET* set, /**< global SCIP settings */
5071  SCIP_Real val /**< value to process */
5072  )
5073 {
5074  assert(set != NULL);
5075 
5076  return EPSISINT(val, set->num_feastol);
5077 }
5078 
5079 /** checks, if given fractional part is smaller than feastol */
5080 SCIP_Bool SCIPsetIsFeasFracIntegral(
5081  SCIP_SET* set, /**< global SCIP settings */
5082  SCIP_Real val /**< value to process */
5083  )
5084 {
5085  assert(set != NULL);
5086  /* TODO: maybe we should compare with REALABS(val) to handle
5087  numerical issues, e.g., if val < 0 */
5088  assert(SCIPsetIsGE(set, val, -set->num_feastol));
5089  assert(SCIPsetIsLE(set, val, 1.0+set->num_feastol));
5090 
5091  return (val <= set->num_feastol);
5092 }
5093 
5094 /** rounds value + feasibility tolerance down to the next integer in feasibility tolerance */
5095 SCIP_Real SCIPsetFeasFloor(
5096  SCIP_SET* set, /**< global SCIP settings */
5097  SCIP_Real val /**< value to process */
5098  )
5099 {
5100  assert(set != NULL);
5101 
5102  return EPSFLOOR(val, set->num_feastol);
5103 }
5104 
5105 /** rounds value - feasibility tolerance up to the next integer in feasibility tolerance */
5106 SCIP_Real SCIPsetFeasCeil(
5107  SCIP_SET* set, /**< global SCIP settings */
5108  SCIP_Real val /**< value to process */
5109  )
5110 {
5111  assert(set != NULL);
5112 
5113  return EPSCEIL(val, set->num_feastol);
5114 }
5115 
5116 /** rounds value to the nearest integer in feasibility tolerance */
5117 SCIP_Real SCIPsetFeasRound(
5118  SCIP_SET* set, /**< global SCIP settings */
5119  SCIP_Real val /**< value to process */
5120  )
5121 {
5122  assert(set != NULL);
5123 
5124  return EPSROUND(val, set->num_feastol);
5125 }
5126 
5127 /** returns fractional part of value, i.e. x - floor(x) in feasibility tolerance */
5128 SCIP_Real SCIPsetFeasFrac(
5129  SCIP_SET* set, /**< global SCIP settings */
5130  SCIP_Real val /**< value to process */
5131  )
5132 {
5133  assert(set != NULL);
5134 
5135  return EPSFRAC(val, set->num_feastol);
5136 }
5137 
5138 /** checks, if relative difference of values is in range of dual feasibility tolerance */
5139 SCIP_Bool SCIPsetIsDualfeasEQ(
5140  SCIP_SET* set, /**< global SCIP settings */
5141  SCIP_Real val1, /**< first value to be compared */
5142  SCIP_Real val2 /**< second value to be compared */
5143  )
5144 {
5145  SCIP_Real diff;
5146 
5147  assert(set != NULL);
5148 
5149  diff = SCIPrelDiff(val1, val2);
5150 
5151  return EPSZ(diff, set->num_dualfeastol);
5152 }
5153 
5154 /** checks, if relative difference of val1 and val2 is lower than dual feasibility tolerance */
5155 SCIP_Bool SCIPsetIsDualfeasLT(
5156  SCIP_SET* set, /**< global SCIP settings */
5157  SCIP_Real val1, /**< first value to be compared */
5158  SCIP_Real val2 /**< second value to be compared */
5159  )
5160 {
5161  SCIP_Real diff;
5162 
5163  assert(set != NULL);
5164 
5165  diff = SCIPrelDiff(val1, val2);
5166 
5167  return EPSN(diff, set->num_dualfeastol);
5168 }
5169 
5170 /** checks, if relative difference of val1 and val2 is not greater than dual feasibility tolerance */
5171 SCIP_Bool SCIPsetIsDualfeasLE(
5172  SCIP_SET* set, /**< global SCIP settings */
5173  SCIP_Real val1, /**< first value to be compared */
5174  SCIP_Real val2 /**< second value to be compared */
5175  )
5176 {
5177  SCIP_Real diff;
5178 
5179  assert(set != NULL);
5180 
5181  diff = SCIPrelDiff(val1, val2);
5182 
5183  return !EPSP(diff, set->num_dualfeastol);
5184 }
5185 
5186 /** checks, if relative difference of val1 and val2 is greater than dual feasibility tolerance */
5187 SCIP_Bool SCIPsetIsDualfeasGT(
5188  SCIP_SET* set, /**< global SCIP settings */
5189  SCIP_Real val1, /**< first value to be compared */
5190  SCIP_Real val2 /**< second value to be compared */
5191  )
5192 {
5193  SCIP_Real diff;
5194 
5195  assert(set != NULL);
5196 
5197  diff = SCIPrelDiff(val1, val2);
5198 
5199  return EPSP(diff, set->num_dualfeastol);
5200 }
5201 
5202 /** checks, if relative difference of val1 and val2 is not lower than -dual feasibility tolerance */
5203 SCIP_Bool SCIPsetIsDualfeasGE(
5204  SCIP_SET* set, /**< global SCIP settings */
5205  SCIP_Real val1, /**< first value to be compared */
5206  SCIP_Real val2 /**< second value to be compared */
5207  )
5208 {
5209  SCIP_Real diff;
5210 
5211  assert(set != NULL);
5212 
5213  diff = SCIPrelDiff(val1, val2);
5214 
5215  return !EPSN(diff, set->num_dualfeastol);
5216 }
5217 
5218 /** checks, if value is in range feasibility tolerance of 0.0 */
5219 SCIP_Bool SCIPsetIsDualfeasZero(
5220  SCIP_SET* set, /**< global SCIP settings */
5221  SCIP_Real val /**< value to process */
5222  )
5223 {
5224  assert(set != NULL);
5225 
5226  return EPSZ(val, set->num_dualfeastol);
5227 }
5228 
5229 /** checks, if value is greater than dual feasibility tolerance */
5230 SCIP_Bool SCIPsetIsDualfeasPositive(
5231  SCIP_SET* set, /**< global SCIP settings */
5232  SCIP_Real val /**< value to process */
5233  )
5234 {
5235  assert(set != NULL);
5236 
5237  return EPSP(val, set->num_dualfeastol);
5238 }
5239 
5240 /** checks, if value is lower than -dual feasibility tolerance */
5241 SCIP_Bool SCIPsetIsDualfeasNegative(
5242  SCIP_SET* set, /**< global SCIP settings */
5243  SCIP_Real val /**< value to process */
5244  )
5245 {
5246  assert(set != NULL);
5247 
5248  return EPSN(val, set->num_dualfeastol);
5249 }
5250 
5251 /** checks, if value is integral within the dual feasibility bounds */
5252 SCIP_Bool SCIPsetIsDualfeasIntegral(
5253  SCIP_SET* set, /**< global SCIP settings */
5254  SCIP_Real val /**< value to process */
5255  )
5256 {
5257  assert(set != NULL);
5258 
5259  return EPSISINT(val, set->num_dualfeastol);
5260 }
5261 
5262 /** checks, if given fractional part is smaller than dual feasibility tolerance */
5263 SCIP_Bool SCIPsetIsDualfeasFracIntegral(
5264  SCIP_SET* set, /**< global SCIP settings */
5265  SCIP_Real val /**< value to process */
5266  )
5267 {
5268  assert(set != NULL);
5269  assert(SCIPsetIsGE(set, val, -set->num_dualfeastol));
5270  assert(SCIPsetIsLE(set, val, 1.0+set->num_dualfeastol));
5271 
5272  return (val <= set->num_dualfeastol);
5273 }
5274 
5275 /** rounds value + dual feasibility tolerance down to the next integer */
5276 SCIP_Real SCIPsetDualfeasFloor(
5277  SCIP_SET* set, /**< global SCIP settings */
5278  SCIP_Real val /**< value to process */
5279  )
5280 {
5281  assert(set != NULL);
5282 
5283  return EPSFLOOR(val, set->num_dualfeastol);
5284 }
5285 
5286 /** rounds value - dual feasibility tolerance up to the next integer */
5287 SCIP_Real SCIPsetDualfeasCeil(
5288  SCIP_SET* set, /**< global SCIP settings */
5289  SCIP_Real val /**< value to process */
5290  )
5291 {
5292  assert(set != NULL);
5293 
5294  return EPSCEIL(val, set->num_dualfeastol);
5295 }
5296 
5297 /** rounds value to the nearest integer in dual feasibility tolerance */
5298 SCIP_Real SCIPsetDualfeasRound(
5299  SCIP_SET* set, /**< global SCIP settings */
5300  SCIP_Real val /**< value to process */
5301  )
5302 {
5303  assert(set != NULL);
5304 
5305  return EPSROUND(val, set->num_dualfeastol);
5306 }
5307 
5308 /** returns fractional part of value, i.e. x - floor(x) in dual feasibility tolerance */
5309 SCIP_Real SCIPsetDualfeasFrac(
5310  SCIP_SET* set, /**< global SCIP settings */
5311  SCIP_Real val /**< value to process */
5312  )
5313 {
5314  assert(set != NULL);
5315 
5316  return EPSFRAC(val, set->num_dualfeastol);
5317 }
5318 
5319 /** checks, if the given new lower bound is tighter (w.r.t. bound strengthening epsilon) than the old one */
5320 SCIP_Bool SCIPsetIsLbBetter(
5321  SCIP_SET* set, /**< global SCIP settings */
5322  SCIP_Real newlb, /**< new lower bound */
5323  SCIP_Real oldlb, /**< old lower bound */
5324  SCIP_Real oldub /**< old upper bound */
5325  )
5326 {
5327  SCIP_Real eps;
5328 
5329  assert(set != NULL);
5330  assert(SCIPsetIsLE(set, oldlb, oldub));
5331 
5332  eps = REALABS(oldlb);
5333  eps = MIN(oldub - oldlb, eps);
5334  return EPSGT(newlb, oldlb, set->num_boundstreps * MAX(eps, 1e-3));
5335 }
5336 
5337 /** checks, if the given new upper bound is tighter (w.r.t. bound strengthening epsilon) than the old one */
5338 SCIP_Bool SCIPsetIsUbBetter(
5339  SCIP_SET* set, /**< global SCIP settings */
5340  SCIP_Real newub, /**< new upper bound */
5341  SCIP_Real oldlb, /**< old lower bound */
5342  SCIP_Real oldub /**< old upper bound */
5343  )
5344 {
5345  SCIP_Real eps;
5346 
5347  assert(set != NULL);
5348  assert(SCIPsetIsLE(set, oldlb, oldub));
5349 
5350  eps = REALABS(oldub);
5351  eps = MIN(oldub - oldlb, eps);
5352  return EPSLT(newub, oldub, set->num_boundstreps * MAX(eps, 1e-3));
5353 }
5354 
5355 /** checks, if the given cut's efficacy is larger than the minimal cut efficacy */
5356 SCIP_Bool SCIPsetIsEfficacious(
5357  SCIP_SET* set, /**< global SCIP settings */
5358  SCIP_Bool root, /**< should the root's minimal cut efficacy be used? */
5359  SCIP_Real efficacy /**< efficacy of the cut */
5360  )
5361 {
5362  assert(set != NULL);
5363 
5364  if( root )
5365  return EPSP(efficacy, set->sepa_minefficacyroot);
5366  else
5367  return EPSP(efficacy, set->sepa_minefficacy);
5368 }
5369 
5370 /** checks, if relative difference of values is in range of epsilon */
5371 SCIP_Bool SCIPsetIsRelEQ(
5372  SCIP_SET* set, /**< global SCIP settings */
5373  SCIP_Real val1, /**< first value to be compared */
5374  SCIP_Real val2 /**< second value to be compared */
5375  )
5376 {
5377  SCIP_Real diff;
5378 
5379  assert(set != NULL);
5380 
5381  diff = SCIPrelDiff(val1, val2);
5382 
5383  return EPSZ(diff, set->num_epsilon);
5384 }
5385 
5386 /** checks, if relative difference of val1 and val2 is lower than epsilon */
5387 SCIP_Bool SCIPsetIsRelLT(
5388  SCIP_SET* set, /**< global SCIP settings */
5389  SCIP_Real val1, /**< first value to be compared */
5390  SCIP_Real val2 /**< second value to be compared */
5391  )
5392 {
5393  SCIP_Real diff;
5394 
5395  assert(set != NULL);
5396 
5397  diff = SCIPrelDiff(val1, val2);
5398 
5399  return EPSN(diff, set->num_epsilon);
5400 }
5401 
5402 /** checks, if relative difference of val1 and val2 is not greater than epsilon */
5403 SCIP_Bool SCIPsetIsRelLE(
5404  SCIP_SET* set, /**< global SCIP settings */
5405  SCIP_Real val1, /**< first value to be compared */
5406  SCIP_Real val2 /**< second value to be compared */
5407  )
5408 {
5409  SCIP_Real diff;
5410 
5411  assert(set != NULL);
5412 
5413  diff = SCIPrelDiff(val1, val2);
5414 
5415  return !EPSP(diff, set->num_epsilon);
5416 }
5417 
5418 /** checks, if relative difference of val1 and val2 is greater than epsilon */
5419 SCIP_Bool SCIPsetIsRelGT(
5420  SCIP_SET* set, /**< global SCIP settings */
5421  SCIP_Real val1, /**< first value to be compared */
5422  SCIP_Real val2 /**< second value to be compared */
5423  )
5424 {
5425  SCIP_Real diff;
5426 
5427  assert(set != NULL);
5428 
5429  diff = SCIPrelDiff(val1, val2);
5430 
5431  return EPSP(diff, set->num_epsilon);
5432 }
5433 
5434 /** checks, if relative difference of val1 and val2 is not lower than -epsilon */
5435 SCIP_Bool SCIPsetIsRelGE(
5436  SCIP_SET* set, /**< global SCIP settings */
5437  SCIP_Real val1, /**< first value to be compared */
5438  SCIP_Real val2 /**< second value to be compared */
5439  )
5440 {
5441  SCIP_Real diff;
5442 
5443  assert(set != NULL);
5444 
5445  diff = SCIPrelDiff(val1, val2);
5446 
5447  return !EPSN(diff, set->num_epsilon);
5448 }
5449 
5450 /** checks, if relative difference of values is in range of sumepsilon */
5451 SCIP_Bool SCIPsetIsSumRelEQ(
5452  SCIP_SET* set, /**< global SCIP settings */
5453  SCIP_Real val1, /**< first value to be compared */
5454  SCIP_Real val2 /**< second value to be compared */
5455  )
5456 {
5457  SCIP_Real diff;
5458 
5459  assert(set != NULL);
5460 
5461  diff = SCIPrelDiff(val1, val2);
5462 
5463  return EPSZ(diff, set->num_sumepsilon);
5464 }
5465 
5466 /** checks, if relative difference of val1 and val2 is lower than sumepsilon */
5467 SCIP_Bool SCIPsetIsSumRelLT(
5468  SCIP_SET* set, /**< global SCIP settings */
5469  SCIP_Real val1, /**< first value to be compared */
5470  SCIP_Real val2 /**< second value to be compared */
5471  )
5472 {
5473  SCIP_Real diff;
5474 
5475  assert(set != NULL);
5476 
5477  diff = SCIPrelDiff(val1, val2);
5478 
5479  return EPSN(diff, set->num_sumepsilon);
5480 }
5481 
5482 /** checks, if relative difference of val1 and val2 is not greater than sumepsilon */
5483 SCIP_Bool SCIPsetIsSumRelLE(
5484  SCIP_SET* set, /**< global SCIP settings */
5485  SCIP_Real val1, /**< first value to be compared */
5486  SCIP_Real val2 /**< second value to be compared */
5487  )
5488 {
5489  SCIP_Real diff;
5490 
5491  assert(set != NULL);
5492 
5493  diff = SCIPrelDiff(val1, val2);
5494 
5495  return !EPSP(diff, set->num_sumepsilon);
5496 }
5497 
5498 /** checks, if relative difference of val1 and val2 is greater than sumepsilon */
5499 SCIP_Bool SCIPsetIsSumRelGT(
5500  SCIP_SET* set, /**< global SCIP settings */
5501  SCIP_Real val1, /**< first value to be compared */
5502  SCIP_Real val2 /**< second value to be compared */
5503  )
5504 {
5505  SCIP_Real diff;
5506 
5507  assert(set != NULL);
5508 
5509  diff = SCIPrelDiff(val1, val2);
5510 
5511  return EPSP(diff, set->num_sumepsilon);
5512 }
5513 
5514 /** checks, if relative difference of val1 and val2 is not lower than -sumepsilon */
5515 SCIP_Bool SCIPsetIsSumRelGE(
5516  SCIP_SET* set, /**< global SCIP settings */
5517  SCIP_Real val1, /**< first value to be compared */
5518  SCIP_Real val2 /**< second value to be compared */
5519  )
5520 {
5521  SCIP_Real diff;
5522 
5523  assert(set != NULL);
5524 
5525  diff = SCIPrelDiff(val1, val2);
5526 
5527  return !EPSN(diff, set->num_sumepsilon);
5528 }
5529 
5530 /** Checks, if an iteratively updated value is reliable or should be recomputed from scratch.
5531  * This is useful, if the value, e.g., the activity of a linear constraint or the pseudo objective value, gets a high
5532  * absolute value during the optimization process which is later reduced significantly. In this case, the last digits
5533  * were canceled out when increasing the value and are random after decreasing it.
5534  * We dot not consider the cancellations which can occur during increasing the absolute value because they just cannot
5535  * be expressed using fixed precision floating point arithmetic, anymore.
5536  * The idea to get more reliable values is to always store the last reliable value, where increasing the absolute of
5537  * the value is viewed as preserving reliability. Then, after each update, the new absolute value can be compared
5538  * against the last reliable one with this method, checking whether it was decreased by a factor of at least
5539  * "lp/recompfac" and should be recomputed.
5540  */
5541 SCIP_Bool SCIPsetIsUpdateUnreliable(
5542  SCIP_SET* set, /**< global SCIP settings */
5543  SCIP_Real newvalue, /**< new value after update */
5544  SCIP_Real oldvalue /**< old value, i.e., last reliable value */
5545  )
5546 {
5547  SCIP_Real quotient;
5548 
5549  assert(set != NULL);
5550 
5551  quotient = ABS(oldvalue) / MAX(ABS(newvalue), set->num_epsilon);
5552 
5553  return quotient >= set->num_recompfac;
5554 }
SCIPsetInitprePlugins
SCIP_RETCODE SCIPsetInitprePlugins(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_STAT *stat)
Definition: set.c:4026
SCIPsetIncludePresol
SCIP_RETCODE SCIPsetIncludePresol(SCIP_SET *set, SCIP_PRESOL *presol)
Definition: set.c:3059
SCIPpricerEnableOrDisableClocks
void SCIPpricerEnableOrDisableClocks(SCIP_PRICER *pricer, SCIP_Bool enable)
Definition: pricer.c:633
SCIPsetFeasRound
SCIP_Real SCIPsetFeasRound(SCIP_SET *set, SCIP_Real val)
Definition: set.c:5168
sepa.h
internal methods for separators
SCIPsetIsUpdateUnreliable
SCIP_Bool SCIPsetIsUpdateUnreliable(SCIP_SET *set, SCIP_Real newvalue, SCIP_Real oldvalue)
Definition: set.c:5592
SCIPsetExitsolPlugins
SCIP_RETCODE SCIPsetExitsolPlugins(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_STAT *stat, SCIP_Bool restart)
Definition: set.c:4174
SCIP_DEFAULT_SEPA_MINORTHO
#define SCIP_DEFAULT_SEPA_MINORTHO
Definition: set.c:335
SCIPsetSortPropsName
void SCIPsetSortPropsName(SCIP_SET *set)
Definition: set.c:3356
SCIP_DEFAULT_DISP_LPINFO
#define SCIP_DEFAULT_DISP_LPINFO
Definition: set.c:150
SCIP_Set::ndisps
int ndisps
Definition: struct_set.h:107
SCIPsetSetEmphasis
SCIP_RETCODE SCIPsetSetEmphasis(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMEMPHASIS paramemphasis, SCIP_Bool quiet)
Definition: set.c:2608
SCIPparamsetFix
SCIP_RETCODE SCIPparamsetFix(SCIP_PARAMSET *paramset, const char *name, SCIP_Bool fixed)
Definition: paramset.c:1896
SCIPpricerInit
SCIP_RETCODE SCIPpricerInit(SCIP_PRICER *pricer, SCIP_SET *set)
Definition: pricer.c:186
SCIP_DEFAULT_BRANCH_FIRSTSBCHILD
#define SCIP_DEFAULT_BRANCH_FIRSTSBCHILD
Definition: set.c:74
SCIP_DEFAULT_PRESOL_MAXROUNDS
#define SCIP_DEFAULT_PRESOL_MAXROUNDS
Definition: set.c:285
SCIPreaderCopyInclude
SCIP_RETCODE SCIPreaderCopyInclude(SCIP_READER *reader, SCIP_SET *set)
Definition: reader.c:43
SCIP_DEFAULT_BRANCH_ROUNDSBSOL
#define SCIP_DEFAULT_BRANCH_ROUNDSBSOL
Definition: set.c:76
SCIP_Presol
Definition: struct_presol.h:36
SCIPpropExitpre
SCIP_RETCODE SCIPpropExitpre(SCIP_PROP *prop, SCIP_SET *set)
Definition: prop.c:381
SCIP_Set::num_sumepsilon
SCIP_Real num_sumepsilon
Definition: struct_set.h:326
SCIP_Nodesel
Definition: struct_nodesel.h:51
SCIPsetIncludeEventhdlr
SCIP_RETCODE SCIPsetIncludeEventhdlr(SCIP_SET *set, SCIP_EVENTHDLR *eventhdlr)
Definition: set.c:3446
SCIPsepaIsInitialized
SCIP_Bool SCIPsepaIsInitialized(SCIP_SEPA *sepa)
Definition: sepa.c:890
SCIP_Set::num_dualfeastol
SCIP_Real num_dualfeastol
Definition: struct_set.h:329
SCIPparamsetAddChar
SCIP_RETCODE SCIPparamsetAddChar(SCIP_PARAMSET *paramset, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, char *valueptr, SCIP_Bool isadvanced, char defaultvalue, const char *allowedvalues, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: paramset.c:1596
SCIPpricerIsActive
SCIP_Bool SCIPpricerIsActive(SCIP_PRICER *pricer)
Definition: pricer.c:645
SCIPsetIsInfinity
SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)
Definition: set.c:4669
SCIPsetIsSumGE
SCIP_Bool SCIPsetIsSumGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:4918
SCIPpropInitsol
SCIP_RETCODE SCIPpropInitsol(SCIP_PROP *prop, SCIP_SET *set)
Definition: prop.c:405
SCIPdispInit
SCIP_RETCODE SCIPdispInit(SCIP_DISP *disp, SCIP_SET *set)
Definition: disp.c:161
SCIP_Set::sepa_minefficacyroot
SCIP_Real sepa_minefficacyroot
Definition: struct_set.h:374
SCIP_Set::num_infinity
SCIP_Real num_infinity
Definition: struct_set.h:324
SCIP_DEFAULT_VBC_REALTIME
#define SCIP_DEFAULT_VBC_REALTIME
Definition: set.c:374
SCIPactivatePricer
SCIP_RETCODE SCIPactivatePricer(SCIP *scip, SCIP_PRICER *pricer)
Definition: scip.c:4797
SCIP_DEFAULT_LP_CLEANUPCOLS
#define SCIP_DEFAULT_LP_CLEANUPCOLS
Definition: set.c:206
event.h
internal methods for managing events
SCIPparamsetWrite
SCIP_RETCODE SCIPparamsetWrite(SCIP_PARAMSET *paramset, SCIP_MESSAGEHDLR *messagehdlr, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
Definition: paramset.c:2436
SCIP_Set::readers
SCIP_READER ** readers
Definition: struct_set.h:61
SCIP_Set::mem_treegrowinit
int mem_treegrowinit
Definition: struct_set.h:294
SCIP_DEFAULT_BRANCH_DELAYPSCOST
#define SCIP_DEFAULT_BRANCH_DELAYPSCOST
Definition: set.c:70
SCIPsetIsLE
SCIP_Bool SCIPsetIsLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:4715
SCIPheurFree
SCIP_RETCODE SCIPheurFree(SCIP_HEUR **heur, SCIP_SET *set)
Definition: heur.c:189
SCIP_Set::sepassorted
SCIP_Bool sepassorted
Definition: struct_set.h:123
SCIPsetIsFeasZero
SCIP_Bool SCIPsetIsFeasZero(SCIP_SET *set, SCIP_Real val)
Definition: set.c:5087
SCIPsepaEnableOrDisableClocks
void SCIPsepaEnableOrDisableClocks(SCIP_SEPA *sepa, SCIP_Bool enable)
Definition: sepa.c:718
SCIP_Set::pricerssize
int pricerssize
Definition: struct_set.h:86
SCIP_DEFAULT_LP_LEXDUALMAXROUNDS
#define SCIP_DEFAULT_LP_LEXDUALMAXROUNDS
Definition: set.c:219
SCIP_Set::nnodesels
int nnodesels
Definition: struct_set.h:103
SCIP_DEFAULT_PRESOL_DONOTAGGR
#define SCIP_DEFAULT_PRESOL_DONOTAGGR
Definition: set.c:300
calcGrowSize
static int calcGrowSize(int initsize, SCIP_Real growfac, int num)
Definition: set.c:398
SCIP_DEFAULT_SEPA_MAXROUNDSROOTSUBRUN
#define SCIP_DEFAULT_SEPA_MAXROUNDSROOTSUBRUN
Definition: set.c:346
SCIP_Reader
Definition: struct_reader.h:35
SCIPnodeselEnableOrDisableClocks
void SCIPnodeselEnableOrDisableClocks(SCIP_NODESEL *nodesel, SCIP_Bool enable)
Definition: nodesel.c:1149
BMSfreeMemoryArrayNull
#define BMSfreeMemoryArrayNull(ptr)
Definition: memory.h:122
SCIPdispInitsol
SCIP_RETCODE SCIPdispInitsol(SCIP_DISP *disp, SCIP_SET *set)
Definition: disp.c:209
SCIPpresolInit
SCIP_RETCODE SCIPpresolInit(SCIP_PRESOL *presol, SCIP_SET *set)
Definition: presol.c:180
SCIP_DEFAULT_MISC_USESMALLTABLES
#define SCIP_DEFAULT_MISC_USESMALLTABLES
Definition: set.c:253
SCIP_DEFAULT_CONF_USEINFLP
#define SCIP_DEFAULT_CONF_USEINFLP
Definition: set.c:102
SCIP_DEFAULT_CONF_MAXLPLOOPS
#define SCIP_DEFAULT_CONF_MAXLPLOOPS
Definition: set.c:82
SCIP_Set::conflicthdlrs
SCIP_CONFLICTHDLR ** conflicthdlrs
Definition: struct_set.h:67
SCIP_DEFAULT_MISC_FINITESOLSTORE
#define SCIP_DEFAULT_MISC_FINITESOLSTORE
Definition: set.c:272
SCIPsetIsSumZero
SCIP_Bool SCIPsetIsSumZero(SCIP_SET *set, SCIP_Real val)
Definition: set.c:4930
SCIP_Set::nlpissorted
SCIP_Bool nlpissorted
Definition: struct_set.h:132
SCIPconshdlrExit
SCIP_RETCODE SCIPconshdlrExit(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2394
SCIPsetFindNlpi
SCIP_NLPI * SCIPsetFindNlpi(SCIP_SET *set, const char *name)
Definition: set.c:3771
SCIP_DEFAULT_LIMIT_SOLUTIONS
#define SCIP_DEFAULT_LIMIT_SOLUTIONS
Definition: set.c:169
SCIPsetFeastol
SCIP_Real SCIPsetFeastol(SCIP_SET *set)
Definition: set.c:4573
SCIP_DEFAULT_READ_DYNAMICCOLS
#define SCIP_DEFAULT_READ_DYNAMICCOLS
Definition: set.c:382
SCIPsetIsDualfeasEQ
SCIP_Bool SCIPsetIsDualfeasEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:5190
SCIP_DEFAULT_MEM_TREEGROWINIT
#define SCIP_DEFAULT_MEM_TREEGROWINIT
Definition: set.c:244
SCIPreaderGetName
const char * SCIPreaderGetName(SCIP_READER *reader)
Definition: reader.c:510
SCIPsetFindPricer
SCIP_PRICER * SCIPsetFindPricer(SCIP_SET *set, const char *name)
Definition: set.c:2774
SCIPheurGetName
const char * SCIPheurGetName(SCIP_HEUR *heur)
Definition: heur.c:591
SCIPdispAutoActivate
SCIP_RETCODE SCIPdispAutoActivate(SCIP_SET *set)
Definition: disp.c:448
SCIP_DEFAULT_CONF_RESTARTNUM
#define SCIP_DEFAULT_CONF_RESTARTNUM
Definition: set.c:122
SCIP_DEFAULT_LP_PRICING
#define SCIP_DEFAULT_LP_PRICING
Definition: set.c:190
SCIPpropCopyInclude
SCIP_RETCODE SCIPpropCopyInclude(SCIP_PROP *prop, SCIP_SET *set)
Definition: prop.c:91
SCIPsepaCopyInclude
SCIP_RETCODE SCIPsepaCopyInclude(SCIP_SEPA *sepa, SCIP_SET *set)
Definition: sepa.c:70
SCIP_DEFAULT_CONF_REPROPAGATE
#define SCIP_DEFAULT_CONF_REPROPAGATE
Definition: set.c:113
SCIP_Set::num_pseudocostdelta
SCIP_Real num_pseudocostdelta
Definition: struct_set.h:333
SCIPsetFloor
SCIP_Real SCIPsetFloor(SCIP_SET *set, SCIP_Real val)
Definition: set.c:4826
SCIPsetPseudocosteps
SCIP_Real SCIPsetPseudocosteps(SCIP_SET *set)
Definition: set.c:4624
SCIPsetIsFeasEQ
SCIP_Bool SCIPsetIsFeasEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:5007
SCIPsetSetRealParam
SCIP_RETCODE SCIPsetSetRealParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_Real value)
Definition: set.c:2456
SCIPrelaxInit
SCIP_RETCODE SCIPrelaxInit(SCIP_RELAX *relax, SCIP_SET *set)
Definition: relax.c:175
SCIPbranchruleExitsol
SCIP_RETCODE SCIPbranchruleExitsol(SCIP_BRANCHRULE *branchrule, SCIP_SET *set)
Definition: branch.c:1416
SCIPnodeselExitsol
SCIP_RETCODE SCIPnodeselExitsol(SCIP_NODESEL *nodesel, SCIP_SET *set)
Definition: nodesel.c:918
SCIP_DEFAULT_MISC_RESETSTAT
#define SCIP_DEFAULT_MISC_RESETSTAT
Definition: set.c:258
SCIP_Set::nodesels
SCIP_NODESEL ** nodesels
Definition: struct_set.h:74
SCIPnlpiGetName
const char * SCIPnlpiGetName(SCIP_NLPI *nlpi)
Definition: nlpi.c:741
SCIP_DEFAULT_MEM_ARRAYGROWFAC
#define SCIP_DEFAULT_MEM_ARRAYGROWFAC
Definition: set.c:240
SCIP_DEFAULT_SEPA_MAXRUNS
#define SCIP_DEFAULT_SEPA_MAXRUNS
Definition: set.c:343
SCIP_DEFAULT_LIMIT_TIME
#define SCIP_DEFAULT_LIMIT_TIME
Definition: set.c:159
SCIP_DEFAULT_MISC_PERMUTECONSS
#define SCIP_DEFAULT_MISC_PERMUTECONSS
Definition: set.c:255
SCIPparamSetInt
SCIP_RETCODE SCIPparamSetInt(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, int value, SCIP_Bool quiet)
Definition: paramset.c:3966
SCIP_DEFAULT_LP_LEXDUALROOTONLY
#define SCIP_DEFAULT_LP_LEXDUALROOTONLY
Definition: set.c:218
SCIPpresolFree
SCIP_RETCODE SCIPpresolFree(SCIP_PRESOL **presol, SCIP_SET *set)
Definition: presol.c:154
SCIP_DEFAULT_WRITE_GENNAMES_OFFSET
#define SCIP_DEFAULT_WRITE_GENNAMES_OFFSET
Definition: set.c:384
SCIPsetIsDualfeasGE
SCIP_Bool SCIPsetIsDualfeasGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:5254
SCIPdispFree
SCIP_RETCODE SCIPdispFree(SCIP_DISP **disp, SCIP_SET *set)
Definition: disp.c:136
SCIPeventhdlrExit
SCIP_RETCODE SCIPeventhdlrExit(SCIP_EVENTHDLR *eventhdlr, SCIP_SET *set)
Definition: event.c:170
SCIP_DEFAULT_PROP_MAXROUNDSROOT
#define SCIP_DEFAULT_PROP_MAXROUNDSROOT
Definition: set.c:320
SCIP_DEFAULT_LP_PRESOLVING
#define SCIP_DEFAULT_LP_PRESOLVING
Definition: set.c:216
clock.h
internal methods for clocks and timing issues
SCIP_Set::propsnamesorted
SCIP_Bool propsnamesorted
Definition: struct_set.h:127
SCIPparamsetSetToDefault
SCIP_RETCODE SCIPparamsetSetToDefault(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *paramname)
Definition: paramset.c:2522
SCIPsetIsSumGT
SCIP_Bool SCIPsetIsSumGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:4906
SCIPsetCreate
SCIP_RETCODE SCIPsetCreate(SCIP_SET **set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, SCIP *scip)
Definition: set.c:800
SCIPsetIncludeRelax
SCIP_RETCODE SCIPsetIncludeRelax(SCIP_SET *set, SCIP_RELAX *relax)
Definition: set.c:3132
SCIPsetIsPositive
SCIP_Bool SCIPsetIsPositive(SCIP_SET *set, SCIP_Real val)
Definition: set.c:4762
NULL
#define NULL
Definition: lpi_spx.cpp:129
SCIPsetFindEventhdlr
SCIP_EVENTHDLR * SCIPsetFindEventhdlr(SCIP_SET *set, const char *name)
Definition: set.c:3469
SCIP_DEFAULT_MEM_SAVEFAC
#define SCIP_DEFAULT_MEM_SAVEFAC
Definition: set.c:239
SCIPnlpiSetPriority
void SCIPnlpiSetPriority(SCIP_NLPI *nlpi, int priority)
Definition: nlpi.c:771
SCIP_Set::nprops
int nprops
Definition: struct_set.h:97
SCIP_DEFAULT_CONF_FULLSHORTENCONFLICT
#define SCIP_DEFAULT_CONF_FULLSHORTENCONFLICT
Definition: set.c:128
SCIP_PARAMDATA
struct SCIP_ParamData SCIP_PARAMDATA
Definition: type_paramset.h:73
SCIP_DEFAULT_LP_INITALGORITHM
#define SCIP_DEFAULT_LP_INITALGORITHM
Definition: set.c:184
SCIP_DEFAULT_CONS_AGELIMIT
#define SCIP_DEFAULT_CONS_AGELIMIT
Definition: set.c:135
SCIP_DEFAULT_PRESOL_ABORTFAC
#define SCIP_DEFAULT_PRESOL_ABORTFAC
Definition: set.c:282
SCIPsetIsSumRelGT
SCIP_Bool SCIPsetIsSumRelGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:5550
nlpi.h
internal methods for NLPI solver interfaces
SCIP_DEFAULT_SEPA_CUTAGELIMIT
#define SCIP_DEFAULT_SEPA_CUTAGELIMIT
Definition: set.c:355
SCIPsetIncludeConshdlr
SCIP_RETCODE SCIPsetIncludeConshdlr(SCIP_SET *set, SCIP_CONSHDLR *conshdlr)
Definition: set.c:2824
SCIPconshdlrGetSepaPriority
int SCIPconshdlrGetSepaPriority(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4672
SCIP_Set::pricersnamesorted
SCIP_Bool pricersnamesorted
Definition: struct_set.h:116
SCIP_DEFAULT_SEPA_FEASTOLFAC
#define SCIP_DEFAULT_SEPA_FEASTOLFAC
Definition: set.c:359
SCIP_Set::presolsnamesorted
SCIP_Bool presolsnamesorted
Definition: struct_set.h:120
SCIPsetGetStringParam
SCIP_RETCODE SCIPsetGetStringParam(SCIP_SET *set, const char *name, char **value)
Definition: set.c:2248
SCIPparamsetSetSeparating
SCIP_RETCODE SCIPparamsetSetSeparating(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: paramset.c:3787
SCIPeventhdlrCopyInclude
SCIP_RETCODE SCIPeventhdlrCopyInclude(SCIP_EVENTHDLR *eventhdlr, SCIP_SET *set)
Definition: event.c:45
SCIPnodeselGetMemsavePriority
int SCIPnodeselGetMemsavePriority(SCIP_NODESEL *nodesel)
Definition: nodesel.c:1026
SCIP_Set::sepa_maxcutsroot
int sepa_maxcutsroot
Definition: struct_set.h:393
SCIPsetResetParams
SCIP_RETCODE SCIPsetResetParams(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
Definition: set.c:2589
SCIPdispExit
SCIP_RETCODE SCIPdispExit(SCIP_DISP *disp, SCIP_SET *set)
Definition: disp.c:185
SCIP_Set::propssorted
SCIP_Bool propssorted
Definition: struct_set.h:125
SCIPsetIsScalingIntegral
SCIP_Bool SCIPsetIsScalingIntegral(SCIP_SET *set, SCIP_Real val, SCIP_Real scalar)
Definition: set.c:4795
SCIP_DEFAULT_LP_THREADS
#define SCIP_DEFAULT_LP_THREADS
Definition: set.c:226
SCIPsetInfinity
SCIP_Real SCIPsetInfinity(SCIP_SET *set)
Definition: set.c:4531
SCIP_DEFAULT_LIMIT_ABSGAP
#define SCIP_DEFAULT_LIMIT_ABSGAP
Definition: set.c:162
SCIP_DEFAULT_BRANCH_FORCEALL
#define SCIP_DEFAULT_BRANCH_FORCEALL
Definition: set.c:71
SCIPsetSortConflicthdlrsName
void SCIPsetSortConflicthdlrsName(SCIP_SET *set)
Definition: set.c:3044
SCIPsetIncludeDialog
SCIP_RETCODE SCIPsetIncludeDialog(SCIP_SET *set, SCIP_DIALOG *dialog)
Definition: set.c:3704
SCIP_Dialog
Definition: struct_dialog.h:35
SCIP_DEFAULT_CONF_MAXCONSS
#define SCIP_DEFAULT_CONF_MAXCONSS
Definition: set.c:94
SCIPpresolGetName
const char * SCIPpresolGetName(SCIP_PRESOL *presol)
Definition: presol.c:551
SCIP_Set::limitchanged
SCIP_Bool limitchanged
Definition: struct_set.h:133
SCIPpresolExit
SCIP_RETCODE SCIPpresolExit(SCIP_PRESOL *presol, SCIP_SET *set)
Definition: presol.c:240
SCIP_DEFAULT_MEM_ARRAYGROWINIT
#define SCIP_DEFAULT_MEM_ARRAYGROWINIT
Definition: set.c:243
SCIP_VERBLEVEL_HIGH
Definition: type_message.h:45
SCIP_Set::mem_pathgrowinit
int mem_pathgrowinit
Definition: struct_set.h:295
SCIP_CLOCKTYPE
enum SCIP_ClockType SCIP_CLOCKTYPE
Definition: type_clock.h:38
SCIP_DEFAULT_MISC_CATCHCTRLC
#define SCIP_DEFAULT_MISC_CATCHCTRLC
Definition: set.c:250
SCIP_DEFAULT_VBC_FILENAME
#define SCIP_DEFAULT_VBC_FILENAME
Definition: set.c:371
SCIP_VERBLEVEL_NONE
Definition: type_message.h:41
SCIPsetSortHeurs
void SCIPsetSortHeurs(SCIP_SET *set)
Definition: set.c:3416
FALSE
#define FALSE
Definition: def.h:52
SCIP_Set::sepas
SCIP_SEPA ** sepas
Definition: struct_set.h:70
EPSEQ
#define EPSEQ(x, y, eps)
Definition: def.h:147
EPSISINT
#define EPSISINT(x, eps)
Definition: def.h:159
SCIP_DEFAULT_MISC_CALCINTEGRAL
#define SCIP_DEFAULT_MISC_CALCINTEGRAL
Definition: set.c:271
SCIPpricerInitsol
SCIP_RETCODE SCIPpricerInitsol(SCIP_PRICER *pricer, SCIP_SET *set)
Definition: pricer.c:257
SCIP_DEFAULT_RECOMPFAC
#define SCIP_DEFAULT_RECOMPFAC
Definition: def.h:138
SCIP_DEFAULT_CONF_MAXVARSFAC
#define SCIP_DEFAULT_CONF_MAXVARSFAC
Definition: set.c:80
SCIP_Set::num_lpfeastol
SCIP_Real num_lpfeastol
Definition: struct_set.h:328
SCIPsetIsFeasIntegral
SCIP_Bool SCIPsetIsFeasIntegral(SCIP_SET *set, SCIP_Real val)
Definition: set.c:5120
SCIP_MAXEPSILON
#define SCIP_MAXEPSILON
Definition: def.h:140
SCIPsetGetNodesel
SCIP_NODESEL * SCIPsetGetNodesel(SCIP_SET *set, SCIP_STAT *stat)
Definition: set.c:3540
SCIPrelDiff
SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)
Definition: misc.c:7860
SCIP_Set::sepa_primfeastol
SCIP_Real sepa_primfeastol
Definition: struct_set.h:380
SCIPsetFindProp
SCIP_PROP * SCIPsetFindProp(SCIP_SET *set, const char *name)
Definition: set.c:3304
SCIPconshdlrInitsol
SCIP_RETCODE SCIPconshdlrInitsol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2587
SCIP_DEFAULT_MISC_USEVARTABLE
#define SCIP_DEFAULT_MISC_USEVARTABLE
Definition: set.c:251
SCIP_Set::nodeselssize
int nodeselssize
Definition: struct_set.h:104
SCIPsetIsZero
SCIP_Bool SCIPsetIsZero(SCIP_SET *set, SCIP_Real val)
Definition: set.c:4751
SCIP_Set::stage
SCIP_STAGE stage
Definition: struct_set.h:57
SCIP_Messagehdlr
Definition: struct_message.h:35
TRUE
#define TRUE
Definition: def.h:51
SCIP_RETCODE
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
SCIPsetFindPresol
SCIP_PRESOL * SCIPsetFindPresol(SCIP_SET *set, const char *name)
Definition: set.c:3082
SCIPheurInitsol
SCIP_RETCODE SCIPheurInitsol(SCIP_HEUR *heur, SCIP_SET *set)
Definition: heur.c:286
SCIP_Set::sepa_minefficacy
SCIP_Real sepa_minefficacy
Definition: struct_set.h:373
SCIPparamsetGetParam
SCIP_PARAM * SCIPparamsetGetParam(SCIP_PARAMSET *paramset, const char *name)
Definition: paramset.c:1692
SCIPbranchruleGetName
const char * SCIPbranchruleGetName(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:1843
SCIP_Param
Definition: struct_paramset.h:98
EPSP
#define EPSP(x, eps)
Definition: def.h:153
SCIPsetSetParam
SCIP_RETCODE SCIPsetSetParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, void *value)
Definition: set.c:2276
SCIP_Set::pricerssorted
SCIP_Bool pricerssorted
Definition: struct_set.h:115
SCIP_VERBLEVEL
enum SCIP_VerbLevel SCIP_VERBLEVEL
Definition: type_message.h:48
branch.h
internal methods for branching rules and branching candidate storage
SCIPnodeselInitsol
SCIP_RETCODE SCIPnodeselInitsol(SCIP_NODESEL *nodesel, SCIP_SET *set)
Definition: nodesel.c:894
SCIPconflicthdlrExitsol
SCIP_RETCODE SCIPconflicthdlrExitsol(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)
Definition: conflict.c:551
SCIPsetCutoffbounddelta
SCIP_Real SCIPsetCutoffbounddelta(SCIP_SET *set)
Definition: set.c:4644
SCIPsetCalcMemGrowSize
int SCIPsetCalcMemGrowSize(SCIP_SET *set, int num)
Definition: set.c:4264
SCIP_DEFAULT_PRESOL_MAXRESTARTS
#define SCIP_DEFAULT_PRESOL_MAXRESTARTS
Definition: set.c:286
SCIPsetIsSumLT
SCIP_Bool SCIPsetIsSumLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:4882
SCIPsetGetParams
SCIP_PARAM ** SCIPsetGetParams(SCIP_SET *set)
Definition: set.c:2689
SCIPsetRound
SCIP_Real SCIPsetRound(SCIP_SET *set, SCIP_Real val)
Definition: set.c:4848
SCIP_DEFAULT_CONF_IGNORERELAXEDBD
#define SCIP_DEFAULT_CONF_IGNORERELAXEDBD
Definition: set.c:126
SCIP_DEFAULT_LIMIT_STALLNODES
#define SCIP_DEFAULT_LIMIT_STALLNODES
Definition: set.c:166
SCIP_DEFAULT_LP_SCALING
#define SCIP_DEFAULT_LP_SCALING
Definition: set.c:215
SCIP_Set::mem_arraygrowfac
SCIP_Real mem_arraygrowfac
Definition: struct_set.h:290
SCIPsetIsDualfeasLE
SCIP_Bool SCIPsetIsDualfeasLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:5222
SCIPparamsetSetToDefaults
SCIP_RETCODE SCIPparamsetSetToDefaults(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
Definition: paramset.c:2504
SCIP_Set::nheurs
int nheurs
Definition: struct_set.h:99
EPSGE
#define EPSGE(x, y, eps)
Definition: def.h:151
SCIP_Set::heurssize
int heurssize
Definition: struct_set.h:100
SCIPsetIncludeNlpi
SCIP_RETCODE SCIPsetIncludeNlpi(SCIP_SET *set, SCIP_NLPI *nlpi)
Definition: set.c:3748
SCIP_DEFAULT_NLP_SOLVER
#define SCIP_DEFAULT_NLP_SOLVER
Definition: set.c:234
SCIPbranchruleInitsol
SCIP_RETCODE SCIPbranchruleInitsol(SCIP_BRANCHRULE *branchrule, SCIP_SET *set)
Definition: branch.c:1392
SCIPconshdlrInit
SCIP_RETCODE SCIPconshdlrInit(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2284
SCIPdebugMessage
#define SCIPdebugMessage
Definition: pub_message.h:77
SCIPsepaFree
SCIP_RETCODE SCIPsepaFree(SCIP_SEPA **sepa, SCIP_SET *set)
Definition: sepa.c:180
SCIP_DEFAULT_PROP_ABORTONCUTOFF
#define SCIP_DEFAULT_PROP_ABORTONCUTOFF
Definition: set.c:321
SCIPrelaxFree
SCIP_RETCODE SCIPrelaxFree(SCIP_RELAX **relax, SCIP_SET *set)
Definition: relax.c:149
SCIP_DEFAULT_LP_CLEARINITIALPROBINGLP
#define SCIP_DEFAULT_LP_CLEARINITIALPROBINGLP
Definition: set.c:195
SCIPnodeselGetStdPriority
int SCIPnodeselGetStdPriority(SCIP_NODESEL *nodesel)
Definition: nodesel.c:1002
EPSFRAC
#define EPSFRAC(x, eps)
Definition: def.h:158
paramset.h
internal methods for handling parameter settings
SCIPheurCopyInclude
SCIP_RETCODE SCIPheurCopyInclude(SCIP_HEUR *heur, SCIP_SET *set)
Definition: heur.c:87
SCIPsetIsNegative
SCIP_Bool SCIPsetIsNegative(SCIP_SET *set, SCIP_Real val)
Definition: set.c:4773
SCIP_Sepa
Definition: struct_sepa.h:36
SCIP_Set::presols
SCIP_PRESOL ** presols
Definition: struct_set.h:68
SCIP_Set::ndialogs
int ndialogs
Definition: struct_set.h:109
SCIP_LONGINT_MAX
#define SCIP_LONGINT_MAX
Definition: def.h:108
SCIPconshdlrNeedsCons
SCIP_Bool SCIPconshdlrNeedsCons(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4732
SCIP_VERBLEVEL_FULL
Definition: type_message.h:46
SCIP_DEFAULT_DISP_FREQ
#define SCIP_DEFAULT_DISP_FREQ
Definition: set.c:148
SCIP_Set::relaxs
SCIP_RELAX ** relaxs
Definition: struct_set.h:69
BMSfreeMemory
#define BMSfreeMemory(ptr)
Definition: memory.h:117
SCIPpropInit
SCIP_RETCODE SCIPpropInit(SCIP_PROP *prop, SCIP_SET *set)
Definition: prop.c:247
SCIP_DEFAULT_MISC_IMPROVINGSOLS
#define SCIP_DEFAULT_MISC_IMPROVINGSOLS
Definition: set.c:267
SCIPsetSumFloor
SCIP_Real SCIPsetSumFloor(SCIP_SET *set, SCIP_Real val)
Definition: set.c:4963
SCIP_Set::conshdlrs_include
SCIP_CONSHDLR ** conshdlrs_include
Definition: struct_set.h:66
SCIP_Set::mem_pathgrowfac
SCIP_Real mem_pathgrowfac
Definition: struct_set.h:292
SCIPsepaGetName
const char * SCIPsepaGetName(SCIP_SEPA *sepa)
Definition: sepa.c:633
SCIP_Pricer
Definition: struct_pricer.h:36
SCIPpricerCopyInclude
SCIP_RETCODE SCIPpricerCopyInclude(SCIP_PRICER *pricer, SCIP_SET *set, SCIP_Bool *valid)
Definition: pricer.c:77
SCIP_DEFAULT_LP_SOLVEDEPTH
#define SCIP_DEFAULT_LP_SOLVEDEPTH
Definition: set.c:183
SCIP_Set::readerssize
int readerssize
Definition: struct_set.h:83
SCIP_DEFAULT_SEPA_ORTHOFUNC
#define SCIP_DEFAULT_SEPA_ORTHOFUNC
Definition: set.c:339
SCIPparamGetReal
SCIP_Real SCIPparamGetReal(SCIP_PARAM *param)
Definition: paramset.c:812
SCIPsetCeil
SCIP_Real SCIPsetCeil(SCIP_SET *set, SCIP_Real val)
Definition: set.c:4837
SCIPsetGetHugeValue
SCIP_Real SCIPsetGetHugeValue(SCIP_SET *set)
Definition: set.c:4543
lp.h
internal methods for LP management
SCIPsetIsFeasFracIntegral
SCIP_Bool SCIPsetIsFeasFracIntegral(SCIP_SET *set, SCIP_Real val)
Definition: set.c:5131
SCIPsetSortHeursName
void SCIPsetSortHeursName(SCIP_SET *set)
Definition: set.c:3431
SCIP_Set::nbranchrules
int nbranchrules
Definition: struct_set.h:105
SCIPnodeselExit
SCIP_RETCODE SCIPnodeselExit(SCIP_NODESEL *nodesel, SCIP_SET *set)
Definition: nodesel.c:864
SCIP_Set::sepasnamesorted
SCIP_Bool sepasnamesorted
Definition: struct_set.h:124
SCIP_DEFAULT_LP_ROWREPSWITCH
#define SCIP_DEFAULT_LP_ROWREPSWITCH
Definition: set.c:223
SCIPconshdlrIsInitialized
SCIP_Bool SCIPconshdlrIsInitialized(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4822
SCIP_DEFAULT_LP_RESOLVEITERMIN
#define SCIP_DEFAULT_LP_RESOLVEITERMIN
Definition: set.c:230
SCIPsetIncludeSepa
SCIP_RETCODE SCIPsetIncludeSepa(SCIP_SET *set, SCIP_SEPA *sepa)
Definition: set.c:3206
SCIP_Set::heursnamesorted
SCIP_Bool heursnamesorted
Definition: struct_set.h:129
SCIP_Set::dispssize
int dispssize
Definition: struct_set.h:108
SCIPsetSetStringParam
SCIP_RETCODE SCIPsetSetStringParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, const char *value)
Definition: set.c:2532
SCIP_Conflicthdlr
Definition: struct_conflict.h:39
SCIP_Set::scip
SCIP * scip
Definition: struct_set.h:58
SCIP_PARAMSETTING
enum SCIP_ParamSetting SCIP_PARAMSETTING
Definition: type_paramset.h:56
SCIPsetGetSepaMaxcuts
int SCIPsetGetSepaMaxcuts(SCIP_SET *set, SCIP_Bool root)
Definition: set.c:4420
SCIP_DEFAULT_DISP_WIDTH
#define SCIP_DEFAULT_DISP_WIDTH
Definition: set.c:147
SCIPparamSetLongint
SCIP_RETCODE SCIPparamSetLongint(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Longint value, SCIP_Bool quiet)
Definition: paramset.c:4000
SCIPsetPseudocostdelta
SCIP_Real SCIPsetPseudocostdelta(SCIP_SET *set)
Definition: set.c:4634
SCIPreaderFree
SCIP_RETCODE SCIPreaderFree(SCIP_READER **reader, SCIP_SET *set)
Definition: reader.c:95
SCIP_DEFAULT_LP_ROOTITERLIM
#define SCIP_DEFAULT_LP_ROOTITERLIM
Definition: set.c:182
SCIPpricerExit
SCIP_RETCODE SCIPpricerExit(SCIP_PRICER *pricer, SCIP_SET *set)
Definition: pricer.c:226
SCIPsetSetFeastol
SCIP_RETCODE SCIPsetSetFeastol(SCIP_SET *set, SCIP_Real feastol)
Definition: set.c:4310
SCIPsepaInit
SCIP_RETCODE SCIPsepaInit(SCIP_SEPA *sepa, SCIP_SET *set)
Definition: sepa.c:206
SCIP_DEFAULT_EPSILON
#define SCIP_DEFAULT_EPSILON
Definition: def.h:129
SCIPsetAddCharParam
SCIP_RETCODE SCIPsetAddCharParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, char *valueptr, SCIP_Bool isadvanced, char defaultvalue, const char *allowedvalues, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: set.c:2111
SCIP_Set::neventhdlrs
int neventhdlrs
Definition: struct_set.h:101
SCIPsetIsGE
SCIP_Bool SCIPsetIsGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:4739
SCIP_DEFAULT_CONF_SETTLELOCAL
#define SCIP_DEFAULT_CONF_SETTLELOCAL
Definition: set.c:110
prop.h
internal methods for propagators
SCIPdispCopyInclude
SCIP_RETCODE SCIPdispCopyInclude(SCIP_DISP *disp, SCIP_SET *set)
Definition: disp.c:55
SCIP_Set
Definition: struct_set.h:55
SCIPpricerGetName
const char * SCIPpricerGetName(SCIP_PRICER *pricer)
Definition: pricer.c:549
SCIPnodeselCopyInclude
SCIP_RETCODE SCIPnodeselCopyInclude(SCIP_NODESEL *nodesel, SCIP_SET *set)
Definition: nodesel.c:717
SCIP_DEFAULT_TIME_ENABLED
#define SCIP_DEFAULT_TIME_ENABLED
Definition: set.c:365
SCIPchgDualfeastol
SCIP_RETCODE SCIPchgDualfeastol(SCIP *scip, SCIP_Real dualfeastol)
Definition: scip.c:37848
SCIP_Set::nlpis
SCIP_NLPI ** nlpis
Definition: struct_set.h:79
SCIP_Set::sepa_maxcuts
int sepa_maxcuts
Definition: struct_set.h:392
SCIPsetIsEfficacious
SCIP_Bool SCIPsetIsEfficacious(SCIP_SET *set, SCIP_Bool root, SCIP_Real efficacy)
Definition: set.c:5407
SCIP_DEFAULT_PRESOL_RESTARTMINRED
#define SCIP_DEFAULT_PRESOL_RESTARTMINRED
Definition: set.c:296
SCIP_DEFAULT_CONF_KEEPREPROP
#define SCIP_DEFAULT_CONF_KEEPREPROP
Definition: set.c:116
SCIP_DEFAULT_LIMIT_NODES
#define SCIP_DEFAULT_LIMIT_NODES
Definition: set.c:165
SCIPsetDualfeasFloor
SCIP_Real SCIPsetDualfeasFloor(SCIP_SET *set, SCIP_Real val)
Definition: set.c:5327
SCIPsetInitPlugins
SCIP_RETCODE SCIPsetInitPlugins(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_STAT *stat)
Definition: set.c:3851
SCIPsetFree
SCIP_RETCODE SCIPsetFree(SCIP_SET **set, BMS_BLKMEM *blkmem)
Definition: set.c:1873
SCIPreaderEnableOrDisableClocks
void SCIPreaderEnableOrDisableClocks(SCIP_READER *reader, SCIP_Bool enable)
Definition: reader.c:570
SCIPenableOrDisableStatisticTiming
SCIP_RETCODE SCIPenableOrDisableStatisticTiming(SCIP *scip)
Definition: scip.c:37447
SCIPeventhdlrFree
SCIP_RETCODE SCIPeventhdlrFree(SCIP_EVENTHDLR **eventhdlr, SCIP_SET *set)
Definition: event.c:106
SCIPsetIsLT
SCIP_Bool SCIPsetIsLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:4703
SCIPsetReadParams
SCIP_RETCODE SCIPsetReadParams(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *filename)
Definition: set.c:2547
SCIP_Set::extcodedescs
char ** extcodedescs
Definition: struct_set.h:81
SCIP_DEFAULT_PRICE_MAXVARS
#define SCIP_DEFAULT_PRICE_MAXVARS
Definition: set.c:307
SCIP_DEFAULT_PRICE_ABORTFAC
#define SCIP_DEFAULT_PRICE_ABORTFAC
Definition: set.c:304
SCIP_DEFAULT_TIME_READING
#define SCIP_DEFAULT_TIME_READING
Definition: set.c:366
SCIPparamsetSetToSubscipsOff
SCIP_RETCODE SCIPparamsetSetToSubscipsOff(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Bool quiet)
Definition: paramset.c:3622
SCIP_DEFAULT_CONF_LPITERATIONS
#define SCIP_DEFAULT_CONF_LPITERATIONS
Definition: set.c:85
SCIPconflicthdlrExit
SCIP_RETCODE SCIPconflicthdlrExit(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)
Definition: conflict.c:496
SCIP_DEFAULT_CONF_USEBOUNDLP
#define SCIP_DEFAULT_CONF_USEBOUNDLP
Definition: set.c:103
SCIP_Set::presolssize
int presolssize
Definition: struct_set.h:92
SCIPconshdlrCopyInclude
SCIP_RETCODE SCIPconshdlrCopyInclude(SCIP_CONSHDLR *conshdlr, SCIP_SET *set, SCIP_Bool *valid)
Definition: cons.c:1959
SCIP_DEFAULT_PRESOL_RESTARTFAC
#define SCIP_DEFAULT_PRESOL_RESTARTFAC
Definition: set.c:287
SCIPconflicthdlrInitsol
SCIP_RETCODE SCIPconflicthdlrInitsol(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)
Definition: conflict.c:527
SCIPsetIsSumLE
SCIP_Bool SCIPsetIsSumLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:4894
SCIPsetFindConshdlr
SCIP_CONSHDLR * SCIPsetFindConshdlr(SCIP_SET *set, const char *name)
Definition: set.c:2965
SCIPsepaInitsol
SCIP_RETCODE SCIPsepaInitsol(SCIP_SEPA *sepa, SCIP_SET *set)
Definition: sepa.c:284
SCIP_Set::num_recompfac
SCIP_Real num_recompfac
Definition: struct_set.h:334
SCIPsetIncludeHeur
SCIP_RETCODE SCIPsetIncludeHeur(SCIP_SET *set, SCIP_HEUR *heur)
Definition: set.c:3372
SCIP_DEFAULT_LP_LEXDUALALGO
#define SCIP_DEFAULT_LP_LEXDUALALGO
Definition: set.c:217
SCIPsetChgIntParam
SCIP_RETCODE SCIPsetChgIntParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAM *param, int value)
Definition: set.c:2343
SCIPsetIsParamFixed
SCIP_Bool SCIPsetIsParamFixed(SCIP_SET *set, const char *name)
Definition: set.c:2156
SCIPbranchruleIsInitialized
SCIP_Bool SCIPbranchruleIsInitialized(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:2045
SCIPnlpiCopy
SCIP_RETCODE SCIPnlpiCopy(BMS_BLKMEM *blkmem, SCIP_NLPI *sourcenlpi, SCIP_NLPI **targetnlpi)
Definition: nlpi.c:165
SCIP_DEFAULT_MISC_ESTIMEXTERNMEM
#define SCIP_DEFAULT_MISC_ESTIMEXTERNMEM
Definition: set.c:269
EPSN
#define EPSN(x, eps)
Definition: def.h:154
SCIPsetIsSumRelGE
SCIP_Bool SCIPsetIsSumRelGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:5566
SCIP_DEFAULT_SEPA_MAXROUNDS
#define SCIP_DEFAULT_SEPA_MAXROUNDS
Definition: set.c:344
SCIPsetSetSubscipsOff
SCIP_RETCODE SCIPsetSetSubscipsOff(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Bool quiet)
Definition: set.c:2623
SCIPsetSetPriorityNlpi
void SCIPsetSetPriorityNlpi(SCIP_SET *set, SCIP_NLPI *nlpi, int priority)
Definition: set.c:3805
SCIPsetReinsertConshdlrSepaPrio
void SCIPsetReinsertConshdlrSepaPrio(SCIP_SET *set, SCIP_CONSHDLR *conshdlr, int oldpriority)
Definition: set.c:2880
SCIPparamsetGetInt
SCIP_RETCODE SCIPparamsetGetInt(SCIP_PARAMSET *paramset, const char *name, int *value)
Definition: paramset.c:1736
SCIPconshdlrEnableOrDisableClocks
void SCIPconshdlrEnableOrDisableClocks(SCIP_CONSHDLR *conshdlr, SCIP_Bool enable)
Definition: cons.c:4293
SCIP_DEFAULT_CONF_CONFLITGRAPHWEIGHT
#define SCIP_DEFAULT_CONF_CONFLITGRAPHWEIGHT
Definition: set.c:130
SCIPsetCopyPlugins
SCIP_RETCODE SCIPsetCopyPlugins(SCIP_SET *sourceset, SCIP_SET *targetset, SCIP_Bool copyreaders, SCIP_Bool copypricers, SCIP_Bool copyconshdlrs, SCIP_Bool copyconflicthdlrs, SCIP_Bool copypresolvers, SCIP_Bool copyrelaxators, SCIP_Bool copyseparators, SCIP_Bool copypropagators, SCIP_Bool copyheuristics, SCIP_Bool copyeventhdlrs, SCIP_Bool copynodeselectors, SCIP_Bool copybranchrules, SCIP_Bool copydisplays, SCIP_Bool copydialogs, SCIP_Bool copynlpis, SCIP_Bool *allvalid)
Definition: set.c:579
SCIPsetChgBoolParam
SCIP_RETCODE SCIPsetChgBoolParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAM *param, SCIP_Bool value)
Definition: set.c:2291
SCIP_Set::conshdlrs_enfo
SCIP_CONSHDLR ** conshdlrs_enfo
Definition: struct_set.h:65
SCIP_DEFAULT_MEM_TREEGROWFAC
#define SCIP_DEFAULT_MEM_TREEGROWFAC
Definition: set.c:241
SCIP_DEFAULT_PRESOL_DONOTMULTAGGR
#define SCIP_DEFAULT_PRESOL_DONOTMULTAGGR
Definition: set.c:299
SCIP_DEFAULT_CONF_INTERCONSS
#define SCIP_DEFAULT_CONF_INTERCONSS
Definition: set.c:91
SCIPparamSetBool
SCIP_RETCODE SCIPparamSetBool(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Bool value, SCIP_Bool quiet)
Definition: paramset.c:3932
SCIPsetLpfeastol
SCIP_Real SCIPsetLpfeastol(SCIP_SET *set)
Definition: set.c:4593
SCIPerrorMessage
#define SCIPerrorMessage
Definition: pub_message.h:45
SCIPparamsetSetReal
SCIP_RETCODE SCIPparamsetSetReal(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_Real value)
Definition: paramset.c:2146
SCIP_DEFAULT_CONF_SEPARATE
#define SCIP_DEFAULT_CONF_SEPARATE
Definition: set.c:117
SCIPconflicthdlrIsInitialized
SCIP_Bool SCIPconflicthdlrIsInitialized(SCIP_CONFLICTHDLR *conflicthdlr)
Definition: conflict.c:750
SCIPdispExitsol
SCIP_RETCODE SCIPdispExitsol(SCIP_DISP *disp, SCIP_SET *set)
Definition: disp.c:227
SCIPnlpiFree
SCIP_RETCODE SCIPnlpiFree(SCIP_NLPI **nlpi)
Definition: nlpi.c:181
SCIP_Set::presolssorted
SCIP_Bool presolssorted
Definition: struct_set.h:119
SCIPrelaxExit
SCIP_RETCODE SCIPrelaxExit(SCIP_RELAX *relax, SCIP_SET *set)
Definition: relax.c:213
SCIP_DEFAULT_TIME_RARECLOCKCHECK
#define SCIP_DEFAULT_TIME_RARECLOCKCHECK
Definition: set.c:367
SCIP_DEFAULT_BRANCH_SCOREFUNC
#define SCIP_DEFAULT_BRANCH_SCOREFUNC
Definition: set.c:61
SCIP_Conshdlr
Definition: struct_cons.h:116
SCIPsetWriteParams
SCIP_RETCODE SCIPsetWriteParams(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
Definition: set.c:2561
SCIP_INVALIDCALL
Definition: type_retcode.h:42
SCIPparamsetSetDefaultInt
SCIP_RETCODE SCIPparamsetSetDefaultInt(SCIP_PARAMSET *paramset, const char *name, int defaultvalue)
Definition: paramset.c:2081
SCIPparamsetGetBool
SCIP_RETCODE SCIPparamsetGetBool(SCIP_PARAMSET *paramset, const char *name, SCIP_Bool *value)
Definition: paramset.c:1704
SCIP_DECL_PARAMCHGD
static SCIP_DECL_PARAMCHGD(paramChgdFeastol)
Definition: set.c:442
SCIPsetIsSumRelEQ
SCIP_Bool SCIPsetIsSumRelEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:5502
SCIP_Set::propspresolsorted
SCIP_Bool propspresolsorted
Definition: struct_set.h:126
SCIPparamSetChar
SCIP_RETCODE SCIPparamSetChar(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, char value, SCIP_Bool quiet)
Definition: paramset.c:4070
SCIPsetIsRelEQ
SCIP_Bool SCIPsetIsRelEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:5422
SCIP_PARAMETERWRONGVAL
Definition: type_retcode.h:48
SCIPconshdlrGetName
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:3873
SCIP_DEFAULT_SEPA_MINEFFICACY
#define SCIP_DEFAULT_SEPA_MINEFFICACY
Definition: set.c:333
SCIPconshdlrGetEnfoPriority
int SCIPconshdlrGetEnfoPriority(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4682
SCIPsetSetSeparating
SCIP_RETCODE SCIPsetSetSeparating(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: set.c:2676
SCIPpropIsInitialized
SCIP_Bool SCIPpropIsInitialized(SCIP_PROP *prop)
Definition: prop.c:1107
SCIPsetIsDualfeasIntegral
SCIP_Bool SCIPsetIsDualfeasIntegral(SCIP_SET *set, SCIP_Real val)
Definition: set.c:5303
SCIP_DEFAULT_MISC_EXACTSOLVE
#define SCIP_DEFAULT_MISC_EXACTSOLVE
Definition: set.c:257
SCIPblkmem
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
Definition: scip.c:37940
SCIPpricerFree
SCIP_RETCODE SCIPpricerFree(SCIP_PRICER **pricer, SCIP_SET *set)
Definition: pricer.c:160
SCIPpresolEnableOrDisableClocks
void SCIPpresolEnableOrDisableClocks(SCIP_PRESOL *presol, SCIP_Bool enable)
Definition: presol.c:625
SCIP_DEFAULT_LIMIT_BESTSOL
#define SCIP_DEFAULT_LIMIT_BESTSOL
Definition: set.c:170
SCIP_Set::conshdlrs
SCIP_CONSHDLR ** conshdlrs
Definition: struct_set.h:63
presol.h
internal methods for presolvers
SCIPbranchruleExit
SCIP_RETCODE SCIPbranchruleExit(SCIP_BRANCHRULE *branchrule, SCIP_SET *set)
Definition: branch.c:1362
SCIPsetInitsolPlugins
SCIP_RETCODE SCIPsetInitsolPlugins(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_STAT *stat)
Definition: set.c:4090
SCIP_DEFAULT_BRANCH_CLAMP
#define SCIP_DEFAULT_BRANCH_CLAMP
Definition: set.c:66
SCIPsetSetIntParam
SCIP_RETCODE SCIPsetSetIntParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, int value)
Definition: set.c:2366
SCIPsetFindRelax
SCIP_RELAX * SCIPsetFindRelax(SCIP_SET *set, const char *name)
Definition: set.c:3156
SCIPeventhdlrEnableOrDisableClocks
void SCIPeventhdlrEnableOrDisableClocks(SCIP_EVENTHDLR *eventhdlr, SCIP_Bool enable)
Definition: event.c:396
SCIPparamSetString
SCIP_RETCODE SCIPparamSetString(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *value, SCIP_Bool quiet)
Definition: paramset.c:4104
SCIPconshdlrInitpre
SCIP_RETCODE SCIPconshdlrInitpre(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2442
SCIPsetBarrierconvtol
SCIP_Real SCIPsetBarrierconvtol(SCIP_SET *set)
Definition: set.c:4614
SCIPconshdlrGetCheckPriority
int SCIPconshdlrGetCheckPriority(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4692
SCIPsetGetNParams
int SCIPsetGetNParams(SCIP_SET *set)
Definition: set.c:2699
SCIPsetFindConflicthdlr
SCIP_CONFLICTHDLR * SCIPsetFindConflicthdlr(SCIP_SET *set, const char *name)
Definition: set.c:3009
SCIPsetChgRealParam
SCIP_RETCODE SCIPsetChgRealParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAM *param, SCIP_Real value)
Definition: set.c:2433
SCIPsetExistsDialog
SCIP_Bool SCIPsetExistsDialog(SCIP_SET *set, SCIP_DIALOG *dialog)
Definition: set.c:3726
SCIPparamsetGetLongint
SCIP_RETCODE SCIPparamsetGetLongint(SCIP_PARAMSET *paramset, const char *name, SCIP_Longint *value)
Definition: paramset.c:1768
SCIPparamsetCreate
SCIP_RETCODE SCIPparamsetCreate(SCIP_PARAMSET **paramset, BMS_BLKMEM *blkmem)
Definition: paramset.c:1406
SCIPsetIsSumRelLT
SCIP_Bool SCIPsetIsSumRelLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:5518
SCIPsetFeasCeil
SCIP_Real SCIPsetFeasCeil(SCIP_SET *set, SCIP_Real val)
Definition: set.c:5157
SCIPsetSetLimitChanged
void SCIPsetSetLimitChanged(SCIP_SET *set)
Definition: set.c:4396
SCIP_DEFAULT_LP_ROWAGELIMIT
#define SCIP_DEFAULT_LP_ROWAGELIMIT
Definition: set.c:203
SCIP_DEFAULT_LP_RESOLVEALGORITHM
#define SCIP_DEFAULT_LP_RESOLVEALGORITHM
Definition: set.c:187
SCIP_DEFAULT_LP_COLAGELIMIT
#define SCIP_DEFAULT_LP_COLAGELIMIT
Definition: set.c:200
SCIPsetIsRelLE
SCIP_Bool SCIPsetIsRelLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:5454
SCIPsetChgLongintParam
SCIP_RETCODE SCIPsetChgLongintParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAM *param, SCIP_Longint value)
Definition: set.c:2395
SCIPparamsetSetEmphasis
SCIP_RETCODE SCIPparamsetSetEmphasis(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMEMPHASIS paramemphasis, SCIP_Bool quiet)
Definition: paramset.c:3456
SCIPparamsetAddLongint
SCIP_RETCODE SCIPparamsetAddLongint(SCIP_PARAMSET *paramset, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Longint *valueptr, SCIP_Bool isadvanced, SCIP_Longint defaultvalue, SCIP_Longint minvalue, SCIP_Longint maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: paramset.c:1536
SCIPnodeselIsInitialized
SCIP_Bool SCIPnodeselIsInitialized(SCIP_NODESEL *nodesel)
Definition: nodesel.c:1139
SCIPsetDualfeasCeil
SCIP_Real SCIPsetDualfeasCeil(SCIP_SET *set, SCIP_Real val)
Definition: set.c:5338
SCIPnodeselFree
SCIP_RETCODE SCIPnodeselFree(SCIP_NODESEL **nodesel, SCIP_SET *set)
Definition: nodesel.c:800
SCIPsetIsDualfeasFracIntegral
SCIP_Bool SCIPsetIsDualfeasFracIntegral(SCIP_SET *set, SCIP_Real val)
Definition: set.c:5314
SCIPparamsetAddString
SCIP_RETCODE SCIPparamsetAddString(SCIP_PARAMSET *paramset, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, char **valueptr, SCIP_Bool isadvanced, const char *defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: paramset.c:1625
SCIP_Set::nrelaxs
int nrelaxs
Definition: struct_set.h:93
SCIPsetIsDualfeasGT
SCIP_Bool SCIPsetIsDualfeasGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:5238
SCIPpropEnableOrDisableClocks
void SCIPpropEnableOrDisableClocks(SCIP_PROP *prop, SCIP_Bool enable)
Definition: prop.c:950
SCIPsetFrac
SCIP_Real SCIPsetFrac(SCIP_SET *set, SCIP_Real val)
Definition: set.c:4859
SCIPsetIncludePricer
SCIP_RETCODE SCIPsetIncludePricer(SCIP_SET *set, SCIP_PRICER *pricer)
Definition: set.c:2751
REALABS
#define REALABS(x)
Definition: def.h:146
SCIPsetFindSepa
SCIP_SEPA * SCIPsetFindSepa(SCIP_SET *set, const char *name)
Definition: set.c:3230
SCIPsetIsRelGT
SCIP_Bool SCIPsetIsRelGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:5470
SCIP_Set::conflicthdlrssize
int conflicthdlrssize
Definition: struct_set.h:90
SCIPconshdlrIsClonable
SCIP_Bool SCIPconshdlrIsClonable(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4832
nodesel.h
internal methods for node selectors and node priority queues
SCIP_DEFAULT_BRANCH_SCOREFAC
#define SCIP_DEFAULT_BRANCH_SCOREFAC
Definition: set.c:62
SCIP_OKAY
Definition: type_retcode.h:33
pricer.h
internal methods for variable pricers
SCIPconflicthdlrFree
SCIP_RETCODE SCIPconflicthdlrFree(SCIP_CONFLICTHDLR **conflicthdlr, SCIP_SET *set)
Definition: conflict.c:432
SCIP_Set::conflicthdlrsnamesorted
SCIP_Bool conflicthdlrsnamesorted
Definition: struct_set.h:118
SCIPsetSortProps
void SCIPsetSortProps(SCIP_SET *set)
Definition: set.c:3324
SCIPsortPtr
void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
set.h
internal methods for global SCIP settings
SCIP_DEFAULT_TIME_CLOCKTYPE
#define SCIP_DEFAULT_TIME_CLOCKTYPE
Definition: set.c:364
SCIP_CALL
#define SCIP_CALL(x)
Definition: def.h:258
SCIPrelaxCopyInclude
SCIP_RETCODE SCIPrelaxCopyInclude(SCIP_RELAX *relax, SCIP_SET *set)
Definition: relax.c:69
SCIPdispGetPosition
int SCIPdispGetPosition(SCIP_DISP *disp)
Definition: disp.c:332
SCIP_DEFAULT_READ_DYNAMICCONSS
#define SCIP_DEFAULT_READ_DYNAMICCONSS
Definition: set.c:381
SCIPsetIsFeasGE
SCIP_Bool SCIPsetIsFeasGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:5071
SCIP_DEFAULT_FEASTOL
#define SCIP_DEFAULT_FEASTOL
Definition: def.h:131
SCIPparamsetSetHeuristics
SCIP_RETCODE SCIPparamsetSetHeuristics(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: paramset.c:3715
SCIP_DEFAULT_LP_FREESOLVALBUFFERS
#define SCIP_DEFAULT_LP_FREESOLVALBUFFERS
Definition: set.c:199
SCIP_Set::sepassize
int sepassize
Definition: struct_set.h:96
SCIPsetSetLpfeastol
SCIP_RETCODE SCIPsetSetLpfeastol(SCIP_SET *set, SCIP_Real lpfeastol, SCIP_Bool printnewvalue)
Definition: set.c:4332
SCIPeventhdlrInitsol
SCIP_RETCODE SCIPeventhdlrInitsol(SCIP_EVENTHDLR *eventhdlr, SCIP_SET *set)
Definition: event.c:200
SCIPsetSetPresolving
SCIP_RETCODE SCIPsetSetPresolving(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: set.c:2658
SCIPsetIsLbBetter
SCIP_Bool SCIPsetIsLbBetter(SCIP_SET *set, SCIP_Real newlb, SCIP_Real oldlb, SCIP_Real oldub)
Definition: set.c:5371
SCIP_DEFAULT_PSEUDOCOSTEPS
#define SCIP_DEFAULT_PSEUDOCOSTEPS
Definition: def.h:136
SCIP_Set::branchrulessize
int branchrulessize
Definition: struct_set.h:106
SCIPsetCalcTreeGrowSize
int SCIPsetCalcTreeGrowSize(SCIP_SET *set, int num)
Definition: set.c:4273
SCIP_Set::relaxsnamesorted
SCIP_Bool relaxsnamesorted
Definition: struct_set.h:122
SCIP_DEFAULT_CONF_USESB
#define SCIP_DEFAULT_CONF_USESB
Definition: set.c:104
SCIP_Set::branchrulesnamesorted
SCIP_Bool branchrulesnamesorted
Definition: struct_set.h:131
relax.h
internal methods for relaxators
SCIPsetAddIntParam
SCIP_RETCODE SCIPsetAddIntParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: set.c:2039
SCIPsetIsEQ
SCIP_Bool SCIPsetIsEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:4691
SCIPnodeselInit
SCIP_RETCODE SCIPnodeselInit(SCIP_NODESEL *nodesel, SCIP_SET *set)
Definition: nodesel.c:828
SCIPparamsetGetNParams
int SCIPparamsetGetNParams(SCIP_PARAMSET *paramset)
Definition: paramset.c:3828
SCIP_Set::nsepas
int nsepas
Definition: struct_set.h:95
SCIP_Set::num_hugeval
SCIP_Real num_hugeval
Definition: struct_set.h:336
SCIPsetIsHugeValue
SCIP_Bool SCIPsetIsHugeValue(SCIP_SET *set, SCIP_Real val)
Definition: set.c:4680
SCIPconflicthdlrGetName
const char * SCIPconflicthdlrGetName(SCIP_CONFLICTHDLR *conflicthdlr)
Definition: conflict.c:706
SCIPchgFeastol
SCIP_RETCODE SCIPchgFeastol(SCIP *scip, SCIP_Real feastol)
Definition: scip.c:37804
SCIP_DEFAULT_LP_CLEANUPCOLSROOT
#define SCIP_DEFAULT_LP_CLEANUPCOLSROOT
Definition: set.c:207
SCIP_Heur
Definition: struct_heur.h:36
SCIP_DEFAULT_LP_CLEANUPROWSROOT
#define SCIP_DEFAULT_LP_CLEANUPROWSROOT
Definition: set.c:209
SCIP_DEFAULT_SEPA_MINEFFICACYROOT
#define SCIP_DEFAULT_SEPA_MINEFFICACYROOT
Definition: set.c:334
SCIP_Branchrule
Definition: struct_branch.h:68
SCIPsetSortPropsPresol
void SCIPsetSortPropsPresol(SCIP_SET *set)
Definition: set.c:3340
SCIPsetIsFeasLE
SCIP_Bool SCIPsetIsFeasLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:5039
SCIPsetSortPresolsName
void SCIPsetSortPresolsName(SCIP_SET *set)
Definition: set.c:3117
EPSCEIL
#define EPSCEIL(x, eps)
Definition: def.h:156
BMSduplicateMemoryArray
#define BMSduplicateMemoryArray(ptr, source, num)
Definition: memory.h:111
SCIP_Prop
Definition: struct_prop.h:36
SCIP_DEFAULT_MISC_PRINTREASON
#define SCIP_DEFAULT_MISC_PRINTREASON
Definition: set.c:268
SCIPsetFindReader
SCIP_READER * SCIPsetFindReader(SCIP_SET *set, const char *name)
Definition: set.c:2731
SCIPsetSortRelaxs
void SCIPsetSortRelaxs(SCIP_SET *set)
Definition: set.c:3176
SCIP_DEFAULT_TIME_STATISTICTIMING
#define SCIP_DEFAULT_TIME_STATISTICTIMING
Definition: set.c:368
SCIP_Set::branchrules
SCIP_BRANCHRULE ** branchrules
Definition: struct_set.h:76
SCIP_DEFAULT_LP_CLEANUPROWS
#define SCIP_DEFAULT_LP_CLEANUPROWS
Definition: set.c:208
SCIPconflicthdlrInit
SCIP_RETCODE SCIPconflicthdlrInit(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)
Definition: conflict.c:459
SCIP_DEFAULT_CONF_ENABLE
#define SCIP_DEFAULT_CONF_ENABLE
Definition: set.c:100
SCIP_DEFAULT_LIMIT_MAXORIGSOL
#define SCIP_DEFAULT_LIMIT_MAXORIGSOL
Definition: set.c:174
SCIPsetSetLongintParam
SCIP_RETCODE SCIPsetSetLongintParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_Longint value)
Definition: set.c:2418
SCIP_DEFAULT_SEPA_MAXBOUNDDIST
#define SCIP_DEFAULT_SEPA_MAXBOUNDDIST
Definition: set.c:328
SCIPsetIncludeProp
SCIP_RETCODE SCIPsetIncludeProp(SCIP_SET *set, SCIP_PROP *prop)
Definition: set.c:3280
SCIP_DEFAULT_LIMIT_RESTARTS
#define SCIP_DEFAULT_LIMIT_RESTARTS
Definition: set.c:175
SCIPsetIsIntegral
SCIP_Bool SCIPsetIsIntegral(SCIP_SET *set, SCIP_Real val)
Definition: set.c:4784
SCIPheurIsInitialized
SCIP_Bool SCIPheurIsInitialized(SCIP_HEUR *heur)
Definition: heur.c:747
SCIP_DEFAULT_HUGEVAL
#define SCIP_DEFAULT_HUGEVAL
Definition: def.h:139
SCIP_DEFAULT_MISC_PERMUTEVARS
#define SCIP_DEFAULT_MISC_PERMUTEVARS
Definition: set.c:256
SCIP_DEFAULT_PRICE_DELVARS
#define SCIP_DEFAULT_PRICE_DELVARS
Definition: set.c:309
SCIPparamSetReal
SCIP_RETCODE SCIPparamSetReal(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Real value, SCIP_Bool quiet)
Definition: paramset.c:4034
SCIPsetSetHeuristics
SCIP_RETCODE SCIPsetSetHeuristics(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: set.c:2640
dialog.h
internal methods for user interface dialog
SCIP_Bool
#define SCIP_Bool
Definition: def.h:49
SCIP_DEFAULT_MEM_PATHGROWFAC
#define SCIP_DEFAULT_MEM_PATHGROWFAC
Definition: set.c:242
SCIPsetSumepsilon
SCIP_Real SCIPsetSumepsilon(SCIP_SET *set)
Definition: set.c:4563
SCIPsetSortSepasName
void SCIPsetSortSepasName(SCIP_SET *set)
Definition: set.c:3265
SCIP_DEFAULT_LIMIT_MAXSOL
#define SCIP_DEFAULT_LIMIT_MAXSOL
Definition: set.c:173
SCIP_Set::paramset
SCIP_PARAMSET * paramset
Definition: struct_set.h:59
SCIPsetSetBarrierconvtol
SCIP_RETCODE SCIPsetSetBarrierconvtol(SCIP_SET *set, SCIP_Real barrierconvtol)
Definition: set.c:4383
SCIPsetFindNodesel
SCIP_NODESEL * SCIPsetFindNodesel(SCIP_SET *set, const char *name)
Definition: set.c:3520
SCIPparamsetSetInt
SCIP_RETCODE SCIPparamsetSetInt(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, int value)
Definition: paramset.c:2047
SCIPnodeselGetName
const char * SCIPnodeselGetName(SCIP_NODESEL *nodesel)
Definition: nodesel.c:982
SCIPsetCalcPathGrowSize
int SCIPsetCalcPathGrowSize(SCIP_SET *set, int num)
Definition: set.c:4282
SCIP_DEFAULT_PRICE_DELVARSROOT
#define SCIP_DEFAULT_PRICE_DELVARSROOT
Definition: set.c:312
SCIPrelaxInitsol
SCIP_RETCODE SCIPrelaxInitsol(SCIP_RELAX *relax, SCIP_SET *set)
Definition: relax.c:243
SCIP_Stat::memsavemode
SCIP_Bool memsavemode
Definition: struct_stat.h:208
SCIPdispIsInitialized
SCIP_Bool SCIPdispIsInitialized(SCIP_DISP *disp)
Definition: disp.c:352
SCIP_DEFAULT_MISC_PERMUTATIONSEED
#define SCIP_DEFAULT_MISC_PERMUTATIONSEED
Definition: set.c:254
SCIP_Set::dialogssize
int dialogssize
Definition: struct_set.h:110
SCIP_DEFAULT_CONF_REMOVEABLE
#define SCIP_DEFAULT_CONF_REMOVEABLE
Definition: set.c:119
SCIP_DEFAULT_PRESOL_IMMRESTARTFAC
#define SCIP_DEFAULT_PRESOL_IMMRESTARTFAC
Definition: set.c:290
SCIP_DEFAULT_CONF_DEPTHSCOREFAC
#define SCIP_DEFAULT_CONF_DEPTHSCOREFAC
Definition: set.c:120
SCIPparamsetGetReal
SCIP_RETCODE SCIPparamsetGetReal(SCIP_PARAMSET *paramset, const char *name, SCIP_Real *value)
Definition: paramset.c:1800
SCIP_DEFAULT_MISC_TRANSORIGSOLS
#define SCIP_DEFAULT_MISC_TRANSORIGSOLS
Definition: set.c:270
reader.h
internal methods for input file readers
SCIP_Set::mem_arraygrowinit
int mem_arraygrowinit
Definition: struct_set.h:293
SCIP_DEFAULT_BOUNDSTREPS
#define SCIP_DEFAULT_BOUNDSTREPS
Definition: def.h:135
SCIPsetGetIntParam
SCIP_RETCODE SCIPsetGetIntParam(SCIP_SET *set, const char *name, int *value)
Definition: set.c:2192
SCIP_Set::heurs
SCIP_HEUR ** heurs
Definition: struct_set.h:72
SCIPheurInit
SCIP_RETCODE SCIPheurInit(SCIP_HEUR *heur, SCIP_SET *set)
Definition: heur.c:215
SCIPsetIncludeExternalCode
SCIP_RETCODE SCIPsetIncludeExternalCode(SCIP_SET *set, const char *name, const char *description)
Definition: set.c:3819
MAX
#define MAX(x, y)
Definition: tclique_def.h:75
SCIP_Set::num_boundstreps
SCIP_Real num_boundstreps
Definition: struct_set.h:331
SCIPpricerExitsol
SCIP_RETCODE SCIPpricerExitsol(SCIP_PRICER *pricer, SCIP_SET *set)
Definition: pricer.c:281
SCIPsetSortNlpis
void SCIPsetSortNlpis(SCIP_SET *set)
Definition: set.c:3791
SCIP_Set::nreaders
int nreaders
Definition: struct_set.h:82
SCIP_DEFAULT_LP_SOLVEFREQ
#define SCIP_DEFAULT_LP_SOLVEFREQ
Definition: set.c:180
SCIPparamsetSetDefaultBool
SCIP_RETCODE SCIPparamsetSetDefaultBool(SCIP_PARAMSET *paramset, const char *name, SCIP_Bool defaultvalue)
Definition: paramset.c:2016
SCIPsetCopyParams
SCIP_RETCODE SCIPsetCopyParams(SCIP_SET *sourceset, SCIP_SET *targetset, SCIP_MESSAGEHDLR *messagehdlr)
Definition: set.c:783
SCIPparamsetGetString
SCIP_RETCODE SCIPparamsetGetString(SCIP_PARAMSET *paramset, const char *name, char **value)
Definition: paramset.c:1864
SCIPchgBarrierconvtol
SCIP_RETCODE SCIPchgBarrierconvtol(SCIP *scip, SCIP_Real barrierconvtol)
Definition: scip.c:37873
SCIP_Set::relaxssize
int relaxssize
Definition: struct_set.h:94
SCIPbufferCreate
SCIP_RETCODE SCIPbufferCreate(SCIP_BUFFER **buffer)
Definition: buffer.c:36
SCIPsetDualfeasFrac
SCIP_Real SCIPsetDualfeasFrac(SCIP_SET *set, SCIP_Real val)
Definition: set.c:5360
SCIPbranchruleEnableOrDisableClocks
void SCIPbranchruleEnableOrDisableClocks(SCIP_BRANCHRULE *branchrule, SCIP_Bool enable)
Definition: branch.c:1931
SCIPparamsetSetBool
SCIP_RETCODE SCIPparamsetSetBool(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_Bool value)
Definition: paramset.c:1982
SCIP_DEFAULT_DISP_VERBLEVEL
#define SCIP_DEFAULT_DISP_VERBLEVEL
Definition: set.c:146
SCIPsetIsRelLT
SCIP_Bool SCIPsetIsRelLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:5438
SCIP_DEFAULT_LP_LEXDUALSTALLING
#define SCIP_DEFAULT_LP_LEXDUALSTALLING
Definition: set.c:221
SCIPparamsetCopyParams
SCIP_RETCODE SCIPparamsetCopyParams(SCIP_PARAMSET *sourceparamset, SCIP_PARAMSET *targetparamset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
Definition: paramset.c:3838
SCIPsetDualfeasRound
SCIP_Real SCIPsetDualfeasRound(SCIP_SET *set, SCIP_Real val)
Definition: set.c:5349
SCIP_DEFAULT_BRANCH_LPGAINNORMALIZE
#define SCIP_DEFAULT_BRANCH_LPGAINNORMALIZE
Definition: set.c:69
SCIP_DEFAULT_SEPA_MINORTHOROOT
#define SCIP_DEFAULT_SEPA_MINORTHOROOT
Definition: set.c:336
SCIPparamsetSetPresolving
SCIP_RETCODE SCIPparamsetSetPresolving(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: paramset.c:3751
SCIP_DEFAULT_CONF_USEPSEUDO
#define SCIP_DEFAULT_CONF_USEPSEUDO
Definition: set.c:107
SCIPheurEnableOrDisableClocks
void SCIPheurEnableOrDisableClocks(SCIP_HEUR *heur, SCIP_Bool enable)
Definition: heur.c:757
EPSLE
#define EPSLE(x, y, eps)
Definition: def.h:149
SCIPrelaxEnableOrDisableClocks
void SCIPrelaxEnableOrDisableClocks(SCIP_RELAX *relax, SCIP_Bool enable)
Definition: relax.c:505
SCIPeventhdlrIsInitialized
SCIP_Bool SCIPeventhdlrIsInitialized(SCIP_EVENTHDLR *eventhdlr)
Definition: event.c:386
SCIP_Set::num_pseudocosteps
SCIP_Real num_pseudocosteps
Definition: struct_set.h:332
SCIP_DEFAULT_PRESOL_SUBRESTARTFAC
#define SCIP_DEFAULT_PRESOL_SUBRESTARTFAC
Definition: set.c:293
SCIPsetSetDefaultBoolParam
SCIP_RETCODE SCIPsetSetDefaultBoolParam(SCIP_SET *set, const char *name, SCIP_Bool defaultvalue)
Definition: set.c:2328
SCIP_DEFAULT_CONF_MINMAXVARS
#define SCIP_DEFAULT_CONF_MINMAXVARS
Definition: set.c:81
SCIP_Set::nodesel
SCIP_NODESEL * nodesel
Definition: struct_set.h:75
SCIPsetAddStringParam
SCIP_RETCODE SCIPsetAddStringParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, char **valueptr, SCIP_Bool isadvanced, const char *defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: set.c:2134
SCIPsetSetCharParam
SCIP_RETCODE SCIPsetSetCharParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, char value)
Definition: set.c:2494
SCIPsetIsSumNegative
SCIP_Bool SCIPsetIsSumNegative(SCIP_SET *set, SCIP_Real val)
Definition: set.c:4952
SCIPsetFindHeur
SCIP_HEUR * SCIPsetFindHeur(SCIP_SET *set, const char *name)
Definition: set.c:3396
SCIP_Set::dialogs
SCIP_DIALOG ** dialogs
Definition: struct_set.h:78
SCIPsetGetMemExternEstim
SCIP_Longint SCIPsetGetMemExternEstim(SCIP_SET *set)
Definition: set.c:4256
SCIP_DEFAULT_LIMIT_MEMORY
#define SCIP_DEFAULT_LIMIT_MEMORY
Definition: set.c:160
SCIP_Set::limit_time
SCIP_Real limit_time
Definition: struct_set.h:220
SCIP_DEFAULT_LP_RESOLVERESTORE
#define SCIP_DEFAULT_LP_RESOLVERESTORE
Definition: set.c:198
SCIPsetFindDisp
SCIP_DISP * SCIPsetFindDisp(SCIP_SET *set, const char *name)
Definition: set.c:3684
SCIP_Set::nconflicthdlrs
int nconflicthdlrs
Definition: struct_set.h:89
SCIP_DEFAULT_LP_LEXDUALBASIC
#define SCIP_DEFAULT_LP_LEXDUALBASIC
Definition: set.c:220
SCIP_DEFAULT_HISTORY_VALUEBASED
#define SCIP_DEFAULT_HISTORY_VALUEBASED
Definition: set.c:155
SCIPsetIncludeNodesel
SCIP_RETCODE SCIPsetIncludeNodesel(SCIP_SET *set, SCIP_NODESEL *nodesel)
Definition: set.c:3489
SCIPpropInitpre
SCIP_RETCODE SCIPpropInitpre(SCIP_PROP *prop, SCIP_SET *set)
Definition: prop.c:344
SCIPsetIsFeasLT
SCIP_Bool SCIPsetIsFeasLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:5023
SCIPsetIsSumEQ
SCIP_Bool SCIPsetIsSumEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:4870
SCIPbufferFree
void SCIPbufferFree(SCIP_BUFFER **buffer)
Definition: buffer.c:53
SCIPparamsetAddInt
SCIP_RETCODE SCIPparamsetAddInt(SCIP_PARAMSET *paramset, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: paramset.c:1506
SCIP_DEFAULT_LP_ITERLIM
#define SCIP_DEFAULT_LP_ITERLIM
Definition: set.c:181
SCIPsetGetCharParam
SCIP_RETCODE SCIPsetGetCharParam(SCIP_SET *set, const char *name, char *value)
Definition: set.c:2234
SCIP_Set::num_epsilon
SCIP_Real num_epsilon
Definition: struct_set.h:325
SCIPsetEnableOrDisablePluginClocks
void SCIPsetEnableOrDisablePluginClocks(SCIP_SET *set, SCIP_Bool enabled)
Definition: set.c:518
SCIPsetGetParam
SCIP_PARAM * SCIPsetGetParam(SCIP_SET *set, const char *name)
Definition: set.c:2167
SCIPverbMessage
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
Definition: scip.c:1256
SCIPsetFeasFrac
SCIP_Real SCIPsetFeasFrac(SCIP_SET *set, SCIP_Real val)
Definition: set.c:5179
SCIPsetSepaprimfeastol
SCIP_Real SCIPsetSepaprimfeastol(SCIP_SET *set)
Definition: set.c:4606
SCIP_PARAMEMPHASIS
enum SCIP_ParamEmphasis SCIP_PARAMEMPHASIS
Definition: type_paramset.h:70
SCIP_REAL_MAX
#define SCIP_REAL_MAX
Definition: def.h:124
SCIPsetIsDualfeasPositive
SCIP_Bool SCIPsetIsDualfeasPositive(SCIP_SET *set, SCIP_Real val)
Definition: set.c:5281
SCIPsetGetRealParam
SCIP_RETCODE SCIPsetGetRealParam(SCIP_SET *set, const char *name, SCIP_Real *value)
Definition: set.c:2220
SCIPconshdlrExitpre
SCIP_RETCODE SCIPconshdlrExitpre(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: cons.c:2541
SCIPchgLpfeastol
SCIP_RETCODE SCIPchgLpfeastol(SCIP *scip, SCIP_Real lpfeastol, SCIP_Bool printnewvalue)
Definition: scip.c:37822
SCIP_Set::branchrulessorted
SCIP_Bool branchrulessorted
Definition: struct_set.h:130
SCIPparamsetSetString
SCIP_RETCODE SCIPparamsetSetString(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, const char *value)
Definition: paramset.c:2214
EPSLT
#define EPSLT(x, y, eps)
Definition: def.h:148
SCIP_DEFAULT_SEPA_MAXSTALLROUNDS
#define SCIP_DEFAULT_SEPA_MAXSTALLROUNDS
Definition: set.c:350
SCIP_REAL_MIN
#define SCIP_REAL_MIN
Definition: def.h:125
SCIP_DEFAULT_CONS_OBSOLETEAGE
#define SCIP_DEFAULT_CONS_OBSOLETEAGE
Definition: set.c:138
SCIP_DEFAULT_LP_FASTMIP
#define SCIP_DEFAULT_LP_FASTMIP
Definition: set.c:214
SCIPsetIsSumPositive
SCIP_Bool SCIPsetIsSumPositive(SCIP_SET *set, SCIP_Real val)
Definition: set.c:4941
SCIPsetFeasFloor
SCIP_Real SCIPsetFeasFloor(SCIP_SET *set, SCIP_Real val)
Definition: set.c:5146
SCIP_DEFAULT_CONF_USEPROP
#define SCIP_DEFAULT_CONF_USEPROP
Definition: set.c:101
EPSGT
#define EPSGT(x, y, eps)
Definition: def.h:150
SCIP_STAGE_INIT
Definition: type_set.h:33
SCIP_Set::price_maxvars
int price_maxvars
Definition: struct_set.h:356
SCIP_DEFAULT_BRANCH_CHECKSBSOL
#define SCIP_DEFAULT_BRANCH_CHECKSBSOL
Definition: set.c:75
SCIPsetSortBranchrules
void SCIPsetSortBranchrules(SCIP_SET *set)
Definition: set.c:3622
SCIP_Set::npricers
int npricers
Definition: struct_set.h:84
SCIP_Set::propssize
int propssize
Definition: struct_set.h:98
SCIP_DEFAULT_CONF_FUIPLEVELS
#define SCIP_DEFAULT_CONF_FUIPLEVELS
Definition: set.c:88
SCIP_DEFAULT_INFINITY
#define SCIP_DEFAULT_INFINITY
Definition: def.h:128
SCIP_DEFAULT_SEPA_EFFICACYNORM
#define SCIP_DEFAULT_SEPA_EFFICACYNORM
Definition: set.c:340
SCIP_DEFAULT_MEM_PATHGROWINIT
#define SCIP_DEFAULT_MEM_PATHGROWINIT
Definition: set.c:245
SCIP_DEFAULT_LP_RESOLVEITERFAC
#define SCIP_DEFAULT_LP_RESOLVEITERFAC
Definition: set.c:227
SCIP_Set::extcodenames
char ** extcodenames
Definition: struct_set.h:80
SCIPdialogCopyInclude
SCIP_RETCODE SCIPdialogCopyInclude(SCIP_DIALOG *dialog, SCIP_SET *set)
Definition: dialog.c:285
SCIP_DEFAULT_DUALFEASTOL
#define SCIP_DEFAULT_DUALFEASTOL
Definition: def.h:133
SCIP_Set::extcodessize
int extcodessize
Definition: struct_set.h:114
conflict.h
internal methods for conflict analysis
SCIPsetSortPresols
void SCIPsetSortPresols(SCIP_SET *set)
Definition: set.c:3102
SCIPsepaExit
SCIP_RETCODE SCIPsepaExit(SCIP_SEPA *sepa, SCIP_SET *set)
Definition: sepa.c:254
SCIPsetSortRelaxsName
void SCIPsetSortRelaxsName(SCIP_SET *set)
Definition: set.c:3191
SCIPsetResetParam
SCIP_RETCODE SCIPsetResetParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name)
Definition: set.c:2577
SCIP_Set::disp_verblevel
SCIP_VERBLEVEL disp_verblevel
Definition: struct_set.h:210
SCIP_DEFAULT_DISP_HEADERFREQ
#define SCIP_DEFAULT_DISP_HEADERFREQ
Definition: set.c:149
SCIPsetChgParamFixed
SCIP_RETCODE SCIPsetChgParamFixed(SCIP_SET *set, const char *name, SCIP_Bool fixed)
Definition: set.c:2262
SCIP_Set::nactivepricers
int nactivepricers
Definition: struct_set.h:85
SCIPsetSortConflicthdlrs
void SCIPsetSortConflicthdlrs(SCIP_SET *set)
Definition: set.c:3029
SCIP_DEFAULT_LP_CONDITIONLIMIT
#define SCIP_DEFAULT_LP_CONDITIONLIMIT
Definition: set.c:211
SCIP_DEFAULT_CONS_DISABLEENFOPS
#define SCIP_DEFAULT_CONS_DISABLEENFOPS
Definition: set.c:141
SCIP_DEFAULT_MISC_USECONSTABLE
#define SCIP_DEFAULT_MISC_USECONSTABLE
Definition: set.c:252
SCIP_DEFAULT_LPFEASTOL
#define SCIP_DEFAULT_LPFEASTOL
Definition: def.h:132
SCIP_DEFAULT_SEPA_MAXCUTS
#define SCIP_DEFAULT_SEPA_MAXCUTS
Definition: set.c:353
SCIPsetIncludeBranchrule
SCIP_RETCODE SCIPsetIncludeBranchrule(SCIP_SET *set, SCIP_BRANCHRULE *branchrule)
Definition: set.c:3578
SCIP_DEFAULT_WRITE_ALLCONSS
#define SCIP_DEFAULT_WRITE_ALLCONSS
Definition: set.c:391
SCIP_Disp
Definition: struct_disp.h:35
SCIP_DEFAULT_READ_DYNAMICROWS
#define SCIP_DEFAULT_READ_DYNAMICROWS
Definition: set.c:383
SCIPbranchruleInit
SCIP_RETCODE SCIPbranchruleInit(SCIP_BRANCHRULE *branchrule, SCIP_SET *set)
Definition: branch.c:1318
SCIPbranchruleCopyInclude
SCIP_RETCODE SCIPbranchruleCopyInclude(SCIP_BRANCHRULE *branchrule, SCIP_SET *set)
Definition: branch.c:1193
SCIP_Set::num_feastol
SCIP_Real num_feastol
Definition: struct_set.h:327
SCIP_DEFAULT_CONF_RESTARTFAC
#define SCIP_DEFAULT_CONF_RESTARTFAC
Definition: set.c:125
SCIPsetSumCeil
SCIP_Real SCIPsetSumCeil(SCIP_SET *set, SCIP_Real val)
Definition: set.c:4974
SCIPpresolCopyInclude
SCIP_RETCODE SCIPpresolCopyInclude(SCIP_PRESOL *presol, SCIP_SET *set)
Definition: presol.c:72
SCIPparamsetAddReal
SCIP_RETCODE SCIPparamsetAddReal(SCIP_PARAMSET *paramset, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: paramset.c:1566
SCIPsetSumRound
SCIP_Real SCIPsetSumRound(SCIP_SET *set, SCIP_Real val)
Definition: set.c:4985
SCIPeventhdlrGetName
const char * SCIPeventhdlrGetName(SCIP_EVENTHDLR *eventhdlr)
Definition: event.c:278
SCIP_DEFAULT_SUMEPSILON
#define SCIP_DEFAULT_SUMEPSILON
Definition: def.h:130
SCIP_Set::props
SCIP_PROP ** props
Definition: struct_set.h:71
SCIPheurExit
SCIP_RETCODE SCIPheurExit(SCIP_HEUR *heur, SCIP_SET *set)
Definition: heur.c:256
SCIP_DEFAULT_LP_DISABLECUTOFF
#define SCIP_DEFAULT_LP_DISABLECUTOFF
Definition: set.c:222
SCIP_DEFAULT_BARRIERCONVTOL
#define SCIP_DEFAULT_BARRIERCONVTOL
Definition: def.h:134
SCIP_DEFAULT_LIMIT_GAP
#define SCIP_DEFAULT_LIMIT_GAP
Definition: set.c:161
SCIP_DEFAULT_SEPA_POOLFREQ
#define SCIP_DEFAULT_SEPA_POOLFREQ
Definition: set.c:358
SCIPsetIsSumRelLE
SCIP_Bool SCIPsetIsSumRelLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:5534
SCIPeventhdlrExitsol
SCIP_RETCODE SCIPeventhdlrExitsol(SCIP_EVENTHDLR *eventhdlr, SCIP_SET *set)
Definition: event.c:224
SCIP_DEFAULT_SEPA_MAXCUTSROOT
#define SCIP_DEFAULT_SEPA_MAXCUTSROOT
Definition: set.c:354
SCIP_DEFAULT_READ_INITIALCONSS
#define SCIP_DEFAULT_READ_INITIALCONSS
Definition: set.c:380
SCIPsetIsGT
SCIP_Bool SCIPsetIsGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:4727
SCIPsetAddLongintParam
SCIP_RETCODE SCIPsetAddLongintParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Longint *valueptr, SCIP_Bool isadvanced, SCIP_Longint defaultvalue, SCIP_Longint minvalue, SCIP_Longint maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: set.c:2063
SCIP_DEFAULT_CONF_DYNAMIC
#define SCIP_DEFAULT_CONF_DYNAMIC
Definition: set.c:118
SCIPmarkLimitChanged
void SCIPmarkLimitChanged(SCIP *scip)
Definition: scip.c:37892
SCIPrelaxIsInitialized
SCIP_Bool SCIPrelaxIsInitialized(SCIP_RELAX *relax)
Definition: relax.c:537
SCIP_DEFAULT_NODESEL_CHILDSEL
#define SCIP_DEFAULT_NODESEL_CHILDSEL
Definition: set.c:276
SCIP_Real
#define SCIP_Real
Definition: def.h:123
stat.h
internal methods for problem statistics
SCIPbranchruleFree
SCIP_RETCODE SCIPbranchruleFree(SCIP_BRANCHRULE **branchrule, SCIP_SET *set)
Definition: branch.c:1292
SCIPsetIncludeReader
SCIP_RETCODE SCIPsetIncludeReader(SCIP_SET *set, SCIP_READER *reader)
Definition: set.c:2709
SCIP_Set::pricers
SCIP_PRICER ** pricers
Definition: struct_set.h:62
EPSROUND
#define EPSROUND(x, eps)
Definition: def.h:157
SCIPconshdlrExitsol
SCIP_RETCODE SCIPconshdlrExitsol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool restart)
Definition: cons.c:2627
SCIP_STAGE
enum SCIP_Stage SCIP_STAGE
Definition: type_set.h:48
SCIPsetFindBranchrule
SCIP_BRANCHRULE * SCIPsetFindBranchrule(SCIP_SET *set, const char *name)
Definition: set.c:3602
MIN
#define MIN(x, y)
Definition: memory.c:59
SCIPsetIsFeasPositive
SCIP_Bool SCIPsetIsFeasPositive(SCIP_SET *set, SCIP_Real val)
Definition: set.c:5098
SCIP_DEFAULT_CONF_MAXVARSDETECTIMPLIEDBOUNDS
#define SCIP_DEFAULT_CONF_MAXVARSDETECTIMPLIEDBOUNDS
Definition: set.c:127
SCIPsetDualfeastol
SCIP_Real SCIPsetDualfeastol(SCIP_SET *set)
Definition: set.c:4583
SCIPdispGetName
const char * SCIPdispGetName(SCIP_DISP *disp)
Definition: disp.c:282
SCIPsetSortPricers
void SCIPsetSortPricers(SCIP_SET *set)
Definition: set.c:2794
SCIPparamsetFree
void SCIPparamsetFree(SCIP_PARAMSET **paramset, BMS_BLKMEM *blkmem)
Definition: paramset.c:1426
SCIP_Set::conshdlrs_sepa
SCIP_CONSHDLR ** conshdlrs_sepa
Definition: struct_set.h:64
SCIP_DEFAULT_VBC_DISPSOLS
#define SCIP_DEFAULT_VBC_DISPSOLS
Definition: set.c:377
SCIP_DEFAULT_SEPA_OBJPARALFAC
#define SCIP_DEFAULT_SEPA_OBJPARALFAC
Definition: set.c:337
SCIP_DEFAULT_CONF_CONFLITWEIGHT
#define SCIP_DEFAULT_CONF_CONFLITWEIGHT
Definition: set.c:129
SCIPparamsetRead
SCIP_RETCODE SCIPparamsetRead(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *filename)
Definition: paramset.c:2387
BMSallocMemory
#define BMSallocMemory(ptr)
Definition: memory.h:92
SCIP_INVALID
#define SCIP_INVALID
Definition: def.h:142
BMSreallocMemoryArray
#define BMSreallocMemoryArray(ptr, num)
Definition: memory.h:80
SCIP_Set::nnlpis
int nnlpis
Definition: struct_set.h:111
SCIP_DEFAULT_CONF_PREFERBINARY
#define SCIP_DEFAULT_CONF_PREFERBINARY
Definition: set.c:108
SCIPparamsetSetLongint
SCIP_RETCODE SCIPparamsetSetLongint(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_Longint value)
Definition: paramset.c:2112
cons.h
internal methods for constraints and constraint handlers
SCIP_Set::nextcodes
int nextcodes
Definition: struct_set.h:113
SCIPrelaxGetName
const char * SCIPrelaxGetName(SCIP_RELAX *relax)
Definition: relax.c:441
SCIPparamsetSetChar
SCIP_RETCODE SCIPparamsetSetChar(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, char value)
Definition: paramset.c:2180
SCIPpresolExitpre
SCIP_RETCODE SCIPpresolExitpre(SCIP_PRESOL *presol, SCIP_SET *set)
Definition: presol.c:307
SCIP_Longint
#define SCIP_Longint
Definition: def.h:107
SCIPsetSetDefaultIntParam
SCIP_RETCODE SCIPsetSetDefaultIntParam(SCIP_SET *set, const char *name, int defaultvalue)
Definition: set.c:2381
SCIPsetSetDualfeastol
SCIP_RETCODE SCIPsetSetDualfeastol(SCIP_SET *set, SCIP_Real dualfeastol)
Definition: set.c:4370
SCIPsetIsDualfeasZero
SCIP_Bool SCIPsetIsDualfeasZero(SCIP_SET *set, SCIP_Real val)
Definition: set.c:5270
SCIP_Set::heurssorted
SCIP_Bool heurssorted
Definition: struct_set.h:128
SCIP_Set::eventhdlrssize
int eventhdlrssize
Definition: struct_set.h:102
SCIPconflicthdlrEnableOrDisableClocks
void SCIPconflicthdlrEnableOrDisableClocks(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_Bool enable)
Definition: conflict.c:760
SCIPsetIsFeasGT
SCIP_Bool SCIPsetIsFeasGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:5055
SCIPparamsetIsFixed
SCIP_Bool SCIPparamsetIsFixed(SCIP_PARAMSET *paramset, const char *name)
Definition: paramset.c:1670
SCIPsetChgStringParam
SCIP_RETCODE SCIPsetChgStringParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAM *param, const char *value)
Definition: set.c:2509
SCIPsetGetLongintParam
SCIP_RETCODE SCIPsetGetLongintParam(SCIP_SET *set, const char *name, SCIP_Longint *value)
Definition: set.c:2206
SCIPsetRecompfac
SCIP_Real SCIPsetRecompfac(SCIP_SET *set)
Definition: set.c:4659
SCIPsetSetVerbLevel
SCIP_RETCODE SCIPsetSetVerbLevel(SCIP_SET *set, SCIP_VERBLEVEL verblevel)
Definition: set.c:4291
SCIP_Relax
Definition: struct_relax.h:36
SCIP_DEFAULT_PRICE_MAXVARSROOT
#define SCIP_DEFAULT_PRICE_MAXVARSROOT
Definition: set.c:308
SCIPparamsetGetChar
SCIP_RETCODE SCIPparamsetGetChar(SCIP_PARAMSET *paramset, const char *name, char *value)
Definition: paramset.c:1832
SCIPsetChgCharParam
SCIP_RETCODE SCIPsetChgCharParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAM *param, char value)
Definition: set.c:2471
SCIPsetEpsilon
SCIP_Real SCIPsetEpsilon(SCIP_SET *set)
Definition: set.c:4553
SCIPsetGetStage
SCIP_STAGE SCIPsetGetStage(SCIP_SET *set)
Definition: set.c:2007
SCIP_Set::conshdlrssize
int conshdlrssize
Definition: struct_set.h:88
SCIPautoselectDisps
SCIP_RETCODE SCIPautoselectDisps(SCIP *scip)
Definition: scip.c:8026
SCIP_Set::num_barrierconvtol
SCIP_Real num_barrierconvtol
Definition: struct_set.h:330
SCIP_Set::istimelimitfinite
SCIP_Bool istimelimitfinite
Definition: struct_set.h:236
SCIPparamsetGetParams
SCIP_PARAM ** SCIPparamsetGetParams(SCIP_PARAMSET *paramset)
Definition: paramset.c:3818
SCIP_DEFAULT_CONF_SCOREFAC
#define SCIP_DEFAULT_CONF_SCOREFAC
Definition: set.c:121
SCIP_DEFAULT_BRANCH_PREFERBINARY
#define SCIP_DEFAULT_BRANCH_PREFERBINARY
Definition: set.c:65
SCIPsetIsUbBetter
SCIP_Bool SCIPsetIsUbBetter(SCIP_SET *set, SCIP_Real newub, SCIP_Real oldlb, SCIP_Real oldub)
Definition: set.c:5389
SCIP_Stat
Definition: struct_stat.h:44
SCIP_Set::nconshdlrs
int nconshdlrs
Definition: struct_set.h:87
SCIPsetIsDualfeasNegative
SCIP_Bool SCIPsetIsDualfeasNegative(SCIP_SET *set, SCIP_Real val)
Definition: set.c:5292
EPSFLOOR
#define EPSFLOOR(x, eps)
Definition: def.h:155
SCIP_DEFAULT_LP_CHECKSTABILITY
#define SCIP_DEFAULT_LP_CHECKSTABILITY
Definition: set.c:210
SCIPsetSumFrac
SCIP_Real SCIPsetSumFrac(SCIP_SET *set, SCIP_Real val)
Definition: set.c:4996
SCIP_MINEPSILON
#define SCIP_MINEPSILON
Definition: def.h:141
SCIP_Set::conflicthdlrssorted
SCIP_Bool conflicthdlrssorted
Definition: struct_set.h:117
SCIPparamsetAddBool
SCIP_RETCODE SCIPparamsetAddBool(SCIP_PARAMSET *paramset, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: paramset.c:1479
def.h
common defines and data types used in all packages of SCIP
BMS_BLKMEM
struct BMS_BlkMem BMS_BLKMEM
Definition: memory.h:371
SCIPconshdlrFree
SCIP_RETCODE SCIPconshdlrFree(SCIP_CONSHDLR **conshdlr, SCIP_SET *set)
Definition: cons.c:2239
SCIPsetAddRealParam
SCIP_RETCODE SCIPsetAddRealParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: set.c:2087
SCIPsetExitPlugins
SCIP_RETCODE SCIPsetExitPlugins(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_STAT *stat)
Definition: set.c:3939
SCIP_Set::mem_treegrowfac
SCIP_Real mem_treegrowfac
Definition: struct_set.h:291
heur.h
internal methods for primal heuristics
SCIP_DEFAULT_LP_CHECKDUALFEAS
#define SCIP_DEFAULT_LP_CHECKDUALFEAS
Definition: set.c:213
SCIPsetGetBoolParam
SCIP_RETCODE SCIPsetGetBoolParam(SCIP_SET *set, const char *name, SCIP_Bool *value)
Definition: set.c:2178
SCIPconflicthdlrCopyInclude
SCIP_RETCODE SCIPconflicthdlrCopyInclude(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)
Definition: conflict.c:360
SCIPheurExitsol
SCIP_RETCODE SCIPheurExitsol(SCIP_HEUR *heur, SCIP_SET *set)
Definition: heur.c:316
SCIP_Set::disps
SCIP_DISP ** disps
Definition: struct_set.h:77
SCIP_DEFAULT_SEPA_MAXROUNDSROOT
#define SCIP_DEFAULT_SEPA_MAXROUNDSROOT
Definition: set.c:345
SCIPsetExitprePlugins
SCIP_RETCODE SCIPsetExitprePlugins(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_STAT *stat)
Definition: set.c:4058
SCIP_DEFAULT_CONF_RECONVLEVELS
#define SCIP_DEFAULT_CONF_RECONVLEVELS
Definition: set.c:97
SCIP_Set::npresols
int npresols
Definition: struct_set.h:91
SCIP_DEFAULT_CONF_ALLOWLOCAL
#define SCIP_DEFAULT_CONF_ALLOWLOCAL
Definition: set.c:109
SCIP_ALLOC
#define SCIP_ALLOC(x)
Definition: def.h:269
SCIP_DEFAULT_LP_CHECKPRIMFEAS
#define SCIP_DEFAULT_LP_CHECKPRIMFEAS
Definition: set.c:212
SCIPsepaExitsol
SCIP_RETCODE SCIPsepaExitsol(SCIP_SEPA *sepa, SCIP_SET *set)
Definition: sepa.c:311
SCIPsetIsRelGE
SCIP_Bool SCIPsetIsRelGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:5486
SCIPsetAddBoolParam
SCIP_RETCODE SCIPsetAddBoolParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: set.c:2017
SCIPsetIsDualfeasLT
SCIP_Bool SCIPsetIsDualfeasLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:5206
SCIPsetIncludeConflicthdlr
SCIP_RETCODE SCIPsetIncludeConflicthdlr(SCIP_SET *set, SCIP_CONFLICTHDLR *conflicthdlr)
Definition: set.c:2985
SCIPsetSortSepas
void SCIPsetSortSepas(SCIP_SET *set)
Definition: set.c:3250
SCIPsetSetBoolParam
SCIP_RETCODE SCIPsetSetBoolParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_Bool value)
Definition: set.c:2313
SCIPsetIsFracIntegral
SCIP_Bool SCIPsetIsFracIntegral(SCIP_SET *set, SCIP_Real val)
Definition: set.c:4813
SCIP_DEFAULT_NLP_DISABLE
#define SCIP_DEFAULT_NLP_DISABLE
Definition: set.c:235
SCIPincludeNlpi
SCIP_RETCODE SCIPincludeNlpi(SCIP *scip, SCIP_NLPI *nlpi)
Definition: scip.c:8054
SCIPpresolInitpre
SCIP_RETCODE SCIPpresolInitpre(SCIP_PRESOL *presol, SCIP_SET *set)
Definition: presol.c:271
SCIPsetIncludeDisp
SCIP_RETCODE SCIPsetIncludeDisp(SCIP_SET *set, SCIP_DISP *disp)
Definition: set.c:3652
SCIP_DEFAULT_SEPA_MAXADDROUNDS
#define SCIP_DEFAULT_SEPA_MAXADDROUNDS
Definition: set.c:347
SCIP_Set::nlpissize
int nlpissize
Definition: struct_set.h:112
SCIP_DEFAULT_SEPA_ORTHOFAC
#define SCIP_DEFAULT_SEPA_ORTHOFAC
Definition: set.c:338
EPSZ
#define EPSZ(x, eps)
Definition: def.h:152
SCIPpropExit
SCIP_RETCODE SCIPpropExit(SCIP_PROP *prop, SCIP_SET *set)
Definition: prop.c:314
SCIPpropGetName
const char * SCIPpropGetName(SCIP_PROP *prop)
Definition: prop.c:872
SCIPpropFree
SCIP_RETCODE SCIPpropFree(SCIP_PROP **prop, SCIP_SET *set)
Definition: prop.c:218
SCIP_Eventhdlr
Definition: struct_event.h:185
SCIP_Set::eventhdlrs
SCIP_EVENTHDLR ** eventhdlrs
Definition: struct_set.h:73
scip.h
SCIP callable library.
SCIPsetIsFeasNegative
SCIP_Bool SCIPsetIsFeasNegative(SCIP_SET *set, SCIP_Real val)
Definition: set.c:5109
SCIPpropExitsol
SCIP_RETCODE SCIPpropExitsol(SCIP_PROP *prop, SCIP_SET *set, SCIP_Bool restart)
Definition: prop.c:429
SCIPeventhdlrInit
SCIP_RETCODE SCIPeventhdlrInit(SCIP_EVENTHDLR *eventhdlr, SCIP_SET *set)
Definition: event.c:134
SCIP_DEFAULT_PSEUDOCOSTDELTA
#define SCIP_DEFAULT_PSEUDOCOSTDELTA
Definition: def.h:137
SCIPsetSortBranchrulesName
void SCIPsetSortBranchrulesName(SCIP_SET *set)
Definition: set.c:3637
SCIP_DEFAULT_PROP_MAXROUNDS
#define SCIP_DEFAULT_PROP_MAXROUNDS
Definition: set.c:319
SCIPrelaxExitsol
SCIP_RETCODE SCIPrelaxExitsol(SCIP_RELAX *relax, SCIP_SET *set)
Definition: relax.c:267
SCIPsetGetPriceMaxvars
int SCIPsetGetPriceMaxvars(SCIP_SET *set, SCIP_Bool root)
Definition: set.c:4406
SCIPparamsetSet
SCIP_RETCODE SCIPparamsetSet(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, void *value)
Definition: paramset.c:1920
SCIP_Set::relaxssorted
SCIP_Bool relaxssorted
Definition: struct_set.h:121
disp.h
internal methods for displaying runtime statistics
SCIPsetSortPricersName
void SCIPsetSortPricersName(SCIP_SET *set)
Definition: set.c:2809
SCIP_Set::mem_externestim
SCIP_Longint mem_externestim
Definition: struct_set.h:288
SCIP_Set::price_maxvarsroot
int price_maxvarsroot
Definition: struct_set.h:357
SCIP_Nlpi
Definition: struct_nlpi.h:35