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