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