Scippy

SCIP

Solving Constraint Integer Programs

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