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