SCIP Doxygen Documentation
 
Loading...
Searching...
No Matches
struct_set.h
Go to the documentation of this file.
1/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2/* */
3/* This file is part of the program and library */
4/* SCIP --- Solving Constraint Integer Programs */
5/* */
6/* Copyright (c) 2002-2023 Zuse Institute Berlin (ZIB) */
7/* */
8/* Licensed under the Apache License, Version 2.0 (the "License"); */
9/* you may not use this file except in compliance with the License. */
10/* You may obtain a copy of the License at */
11/* */
12/* http://www.apache.org/licenses/LICENSE-2.0 */
13/* */
14/* Unless required by applicable law or agreed to in writing, software */
15/* distributed under the License is distributed on an "AS IS" BASIS, */
16/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
17/* See the License for the specific language governing permissions and */
18/* limitations under the License. */
19/* */
20/* You should have received a copy of the Apache-2.0 license */
21/* along with SCIP; see the file LICENSE. If not visit scipopt.org. */
22/* */
23/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
24
25/**@file struct_set.h
26 * @ingroup INTERNALAPI
27 * @brief datastructures for global SCIP settings
28 * @author Tobias Achterberg
29 */
30
31/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
32
33#ifndef __SCIP_STRUCT_SET_H__
34#define __SCIP_STRUCT_SET_H__
35
36
37#include "scip/def.h"
38#include "scip/message.h"
39#include "scip/type_bandit.h"
40#include "scip/type_set.h"
41#include "scip/type_clock.h"
42#include "scip/type_paramset.h"
43#include "scip/type_event.h"
44#include "scip/type_scip.h"
45#include "scip/type_branch.h"
46#include "scip/type_conflict.h"
47#include "scip/type_cons.h"
48#include "scip/type_disp.h"
49#include "scip/type_dialog.h"
50#include "scip/type_heur.h"
51#include "scip/type_compr.h"
52#include "scip/type_nodesel.h"
53#include "scip/type_presol.h"
54#include "scip/type_pricer.h"
55#include "scip/type_reader.h"
56#include "scip/type_relax.h"
57#include "scip/type_sepa.h"
58#include "scip/type_cutsel.h"
59#include "scip/type_table.h"
60#include "scip/type_prop.h"
61#include "scip/type_nlpi.h"
63#include "scip/type_benders.h"
64#include "scip/type_expr.h"
65#include "scip/debug.h"
66
67#ifdef __cplusplus
68extern "C" {
69#endif
70
71/** global SCIP settings */
73{
74 SCIP_STAGE stage; /**< SCIP operation stage */
75 SCIP* scip; /**< very ugly: pointer to scip main data structure for callback methods */
76 SCIP_PARAMSET* paramset; /**< set of parameters */
77 BMS_BUFMEM* buffer; /**< memory buffers for short living temporary objects */
78 BMS_BUFMEM* cleanbuffer; /**< memory buffers for short living temporary objects init. to all zero */
79 SCIP_READER** readers; /**< file readers */
80 SCIP_PRICER** pricers; /**< variable pricers */
81 SCIP_CONSHDLR** conshdlrs; /**< constraint handlers (sorted by check priority) */
82 SCIP_CONSHDLR** conshdlrs_sepa; /**< constraint handlers (sorted by separation priority) */
83 SCIP_CONSHDLR** conshdlrs_enfo; /**< constraint handlers (sorted by enforcement priority) */
84 SCIP_CONSHDLR** conshdlrs_include; /**< constraint handlers (sorted by inclusion order) */
85 SCIP_CONFLICTHDLR** conflicthdlrs; /**< conflict handlers */
86 SCIP_PRESOL** presols; /**< presolvers */
87 SCIP_RELAX** relaxs; /**< relaxators */
88 SCIP_SEPA** sepas; /**< separators */
89 SCIP_CUTSEL** cutsels; /**< cut selectors */
90 SCIP_PROP** props; /**< propagators */
91 SCIP_PROP** props_presol; /**< propagators (sorted by presol priority) */
92 SCIP_HEUR** heurs; /**< primal heuristics */
93 SCIP_COMPR** comprs; /**< tree compressions */
94 SCIP_EVENTHDLR** eventhdlrs; /**< event handlers */
95 SCIP_NODESEL** nodesels; /**< node selectors */
96 SCIP_NODESEL* nodesel; /**< currently used node selector, or NULL if invalid */
97 SCIP_BRANCHRULE** branchrules; /**< branching rules */
98 SCIP_DISP** disps; /**< display columns */
99 SCIP_TABLE** tables; /**< statistics tables */
100 SCIP_DIALOG** dialogs; /**< dialogs */
101 SCIP_EXPRHDLR** exprhdlrs; /**< expression handlers */
102 SCIP_EXPRHDLR* exprhdlrvar; /**< expression handler for variables (for quick access) */
103 SCIP_EXPRHDLR* exprhdlrval; /**< expression handler for constant values (for quick access) */
104 SCIP_EXPRHDLR* exprhdlrsum; /**< expression handler for sums (for quick access) */
105 SCIP_EXPRHDLR* exprhdlrproduct; /**< expression handler for products (for quick access) */
106 SCIP_EXPRHDLR* exprhdlrpow; /**< expression handler for power (for quick access) */
107 SCIP_NLPI** nlpis; /**< interfaces to NLP solvers */
108 SCIP_CONCSOLVERTYPE** concsolvertypes; /**< concurrent solver types */
109 SCIP_CONCSOLVER** concsolvers; /**< the concurrent solvers used for solving */
110 SCIP_BENDERS** benders; /**< the data structures managing the Benders' decomposition algorithm */
111 SCIP_DEBUGSOLDATA* debugsoldata; /**< data for debug solutions */
112 SCIP_BANDITVTABLE** banditvtables; /**< virtual function tables for bandit algorithms */
113 char** extcodenames; /**< names of externals codes */
114 char** extcodedescs; /**< descriptions of external codes */
115 int nreaders; /**< number of file readers */
116 int readerssize; /**< size of readers array */
117 int npricers; /**< number of variable pricers */
118 int nactivepricers; /**< number of variable pricers used in the current problem */
119 int pricerssize; /**< size of pricers array */
120 int nconshdlrs; /**< number of constraint handlers */
121 int conshdlrssize; /**< size of conshdlrs array */
122 int nconflicthdlrs; /**< number of conflict handlers */
123 int conflicthdlrssize; /**< size of conflicthdlrs array */
124 int npresols; /**< number of presolvers */
125 int presolssize; /**< size of presols array */
126 int nrelaxs; /**< number of relaxators */
127 int relaxssize; /**< size of relaxs array */
128 int nsepas; /**< number of separators */
129 int sepassize; /**< size of sepas array */
130 int ncutsels; /**< number of cut selectors */
131 int cutselssize; /**< size of cutsels array */
132 int nprops; /**< number of propagators */
133 int propssize; /**< size of props array */
134 int nheurs; /**< number of primal heuristics */
135 int heurssize; /**< size of heurs array */
136 int ncomprs; /**< number of tree compressions */
137 int comprssize; /**< size of comprs array */
138 int neventhdlrs; /**< number of event handlers */
139 int eventhdlrssize; /**< size of eventhdlrs array */
140 int nnodesels; /**< number of node selectors */
141 int nodeselssize; /**< size of nodesels array */
142 int nbranchrules; /**< number of branching rules */
143 int branchrulessize; /**< size of branchrules array */
144 int ndisps; /**< number of display columns */
145 int dispssize; /**< size of disps array */
146 int ntables; /**< number of statistics tables */
147 int tablessize; /**< size of tables array */
148 int ndialogs; /**< number of dialogs */
149 int dialogssize; /**< size of dialogs array */
150 int nexprhdlrs; /**< number of expression handlers */
151 int exprhdlrssize; /**< size of expression handlers array */
152 int nnlpis; /**< number of NLPIs */
153 int nlpissize; /**< size of NLPIs array */
154 int nconcsolvertypes; /**< number of concurrent solver types */
155 int concsolvertypessize;/**< size of concurrent solver types array */
156 int nconcsolvers; /**< number of concurrent solvers used for solving */
157 int concsolverssize; /**< size of concurrent solvers array */
158 int nbenders; /**< number of Benders' decomposition algorithms */
159 int nactivebenders; /**< number of Benders' decomposition algorithms that are used */
160 int benderssize; /**< size of Benders' decomposition algorithms array */
161 int nextcodes; /**< number of external codes */
162 int extcodessize; /**< size of external code arrays */
163 int nbanditvtables; /**< number of bandit algorithm virtual function tables */
164 int banditvtablessize; /**< size of banditvtables array */
165 SCIP_Bool pricerssorted; /**< are the pricers sorted by activity and priority? */
166 SCIP_Bool pricersnamesorted; /**< are the pricers sorted by name? */
167 SCIP_Bool conflicthdlrssorted;/**< are the conflict handlers sorted by priority? */
168 SCIP_Bool conflicthdlrsnamesorted;/**< are the conflict handlers sorted by name? */
169 SCIP_Bool presolssorted; /**< are the presolvers sorted by priority? */
170 SCIP_Bool presolsnamesorted; /**< are the presolvers sorted by name? */
171 SCIP_Bool relaxssorted; /**< are the relaxators sorted by priority? */
172 SCIP_Bool relaxsnamesorted; /**< are the relaxators sorted by name? */
173 SCIP_Bool sepassorted; /**< are the separators sorted by priority? */
174 SCIP_Bool sepasnamesorted; /**< are the separators sorted by name? */
175 SCIP_Bool cutselssorted; /**< are the cutsels sorted by priority? */
176 SCIP_Bool propssorted; /**< are the propagators sorted by priority? */
177 SCIP_Bool propspresolsorted; /**< are the propagators in prop_presol sorted? */
178 SCIP_Bool propsnamesorted; /**< are the propagators sorted by name? */
179 SCIP_Bool heurssorted; /**< are the heuristics sorted by priority? */
180 SCIP_Bool heursnamesorted; /**< are the heuristics sorted by name? */
181 SCIP_Bool comprssorted; /**< are the compressions sorted by priority? */
182 SCIP_Bool comprsnamesorted; /**< are the compressions sorted by name? */
183 SCIP_Bool branchrulessorted; /**< are the branching rules sorted by priority? */
184 SCIP_Bool branchrulesnamesorted;/**< are the branching rules sorted by name? */
185 SCIP_Bool tablessorted; /**< are the tables sorted by position? */
186 SCIP_Bool exprhdlrssorted; /**< are the expression handlers sorted by name? */
187 SCIP_Bool nlpissorted; /**< are the NLPIs sorted by priority? */
188 SCIP_Bool benderssorted; /**< are the Benders' algorithms sorted by activity and priority? */
189 SCIP_Bool bendersnamesorted; /**< are the Benders' algorithms sorted by name? */
190 SCIP_Bool limitchanged; /**< marks whether any of the limit parameters was changed */
191 SCIP_Bool subscipsoff; /**< marks whether the sub-SCIPs have been deactivated */
192
193 /* branching settings */
194 char branch_scorefunc; /**< branching score function ('s'um, 'p'roduct, 'q'uotient) */
195 char branch_firstsbchild;/**< child node to be regarded first during strong branching (only with propagation): 'u'p child, 'd'own child, 'h'istory-based, or 'a'utomatic */
196 SCIP_Real branch_scorefac; /**< branching score factor to weigh downward and upward gain prediction
197 * in sum score function */
198 SCIP_Bool branch_preferbinary;/**< should branching on binary variables be preferred? */
199 SCIP_Real branch_clamp; /**< minimal fractional distance of branching point to a continuous variable' bounds; a value of 0.5 leads to branching always in the middle of a bounded domain */
200 SCIP_Real branch_midpull; /**< 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 */
201 SCIP_Real branch_midpullreldomtrig; /**< multiply midpull by relative domain width if the latter is below this value */
202 char branch_lpgainnorm; /**< strategy for normalizing LP gain when updating pseudo costs of continuous variables */
203 SCIP_Bool branch_delaypscost; /**< whether to delay pseudo costs updates for continuous variables to after separation */
204 SCIP_Bool branch_divingpscost;/**< should pseudo costs be updated also in diving and probing mode? */
205 SCIP_Bool branch_forceall; /**< should all strong branching children be regarded even if
206 * one is detected to be infeasible? (only with propagation) */
207 SCIP_Bool branch_checksbsol; /**< should LP solutions during strong branching with propagation be checked for feasibility? */
208 SCIP_Bool branch_roundsbsol; /**< should LP solutions during strong branching with propagation be rounded? (only when checksbsol=TRUE) */
209 SCIP_Bool branch_sumadjustscore; /**< score adjustment near zero by \b adding epsilon (TRUE) or using maximum (FALSE) */
210
211 /* conflict analysis settings */
212 SCIP_Real conf_maxvarsfac; /**< maximal fraction of variables involved in a conflict constraint */
213 int conf_minmaxvars; /**< minimal absolute maximum of variables involved in a conflict constraint */
214 int conf_maxlploops; /**< maximal number of LP resolving loops during conflict analysis
215 * (-1: no limit) */
216 int conf_lpiterations; /**< maximal number of LP iterations in each LP resolving loop
217 * (-1: no limit) */
218 int conf_fuiplevels; /**< number of depth levels up to which first UIP's are used in conflict
219 * analysis (-1: use All-FirstUIP rule) */
220 int conf_interconss; /**< maximal number of intermediate conflict constraints generated in conflict
221 * graph (-1: use every intermediate constraint) */
222 int conf_maxconss; /**< maximal number of conflict constraints accepted at an infeasible node
223 * (-1: use all generated conflict constraints) */
224 int conf_maxstoresize; /**< maximal size of conflict store */
225 int conf_reconvlevels; /**< number of depth levels up to which UIP reconvergence constraints are
226 * generated (-1: generate reconvergence constraints in all depth levels) */
227 SCIP_Bool conf_enable; /**< should conflict analysis be enabled? */
228 SCIP_Bool conf_cleanbnddepend;/**< should conflicts related to an old cutoff bound be removed? */
229 SCIP_Bool conf_useprop; /**< should propagation conflict analysis be used? (uses conflict graph only) */
230 char conf_useinflp; /**< should infeasible LP conflict analysis be used?
231 * ('o'ff, 'c'onflict graph, 'd'ual ray, 'b'oth conflict graph and dual ray)
232 */
233 char conf_useboundlp; /**< should bound exceeding LP conflict analysis be used?
234 * ('o'ff, 'c'onflict graph, 'd'ual ray, 'b'oth conflict graph and dual ray)
235 */
236 SCIP_Bool conf_usesb; /**< should infeasible/bound exceeding strong branching conflict analysis be
237 * used? */
238 SCIP_Bool conf_usepseudo; /**< should pseudo solution conflict analysis be used? */
239 SCIP_Bool conf_prefinfproof; /**< prefer infeasibility proof to boundexceeding proof */
240 SCIP_Bool conf_preferbinary; /**< should binary conflicts be preferred? */
241 SCIP_Bool conf_allowlocal; /**< should conflict constraints be generated that are only valid locally? */
242 SCIP_Bool conf_settlelocal; /**< should conflict constraints be attached only to the local subtree where
243 * they can be useful? */
244 SCIP_Bool conf_repropagate; /**< should earlier nodes be repropagated in order to replace branching
245 * decisions by deductions? */
246 SCIP_Bool conf_keepreprop; /**< should constraints be kept for repropagation even if they are too long? */
247 SCIP_Bool conf_separate; /**< should the conflict constraints be separated? */
248 SCIP_Bool conf_dynamic; /**< should the conflict constraints be subject to aging? */
249 SCIP_Bool conf_removable; /**< should the conflict's relaxations be subject to LP aging and cleanup? */
250 SCIP_Real conf_depthscorefac; /**< score factor for depth level in bound relaxation heuristic */
251 SCIP_Real conf_proofscorefac; /**< score factor for contribution to infeasibility proof in bound relaxation heuristic */
252 SCIP_Real conf_uplockscorefac;/**< score factor for number of up locks in bound relaxation heuristic */
253 SCIP_Real conf_downlockscorefac;/**< score factor for number of down locks in bound relaxation heuristic */
254 SCIP_Real conf_scorefac; /**< factor to decrease importance of variables' earlier conflict scores */
255 int conf_restartnum; /**< number of successful conflict analysis calls that trigger a restart
256 * (0: disable conflict restarts) */
257 SCIP_Real conf_restartfac; /**< factor to increase restartnum with after each restart */
258 SCIP_Bool conf_ignorerelaxedbd;/**< should relaxed bounds be ignored? */
259 int conf_maxvarsdetectimpliedbounds;/**< maximal number of variables to try to detect global bound
260 * implications and shorten the whole conflict set (0:
261 * disabled )
262 */
263 SCIP_Bool conf_fullshortenconflict;/**< try to shorten the whole conflict set or terminate early
264 * (depending on the 'maxvarsdetectimpliedbounds' parameter)
265 */
266 SCIP_Real conf_conflictweight;/**< the weight the VSIDS score is weight by updating the VSIDS for a
267 * variable if it is part of a conflict
268 */
269 SCIP_Real conf_conflictgraphweight; /**< the weight the VSIDS score is weight by updating the VSIDS for a
270 * variable if it is part of a conflict graph
271 */
272 SCIP_Real conf_weightsize; /**< weight of the size of a conflict used in score calculation */
273 SCIP_Real conf_weightrepropdepth;/**< weight of the prepropagtion depth of a conflict used in score calculation */
274 SCIP_Real conf_weightvaliddepth;/**< weight of the valid depth of a conflict used in score calculation */
275 SCIP_Bool conf_sepaaltproofs; /**< separate valid inequalities from dualray proofs */
276 SCIP_Real conf_minimprove; /**< minimal improvement of primal bound to remove conflicts depending on
277 * a previous incumbent.
278 */
279 SCIP_Bool conf_uselocalrows; /**< use local rows to construct infeasibility proofs */
280
281 /* constraint settings */
282 int cons_agelimit; /**< maximum age an unnecessary constraint can reach before it is deleted
283 * (0: dynamic, -1: disable aging) */
284 int cons_obsoleteage; /**< age of a constraint after which it is marked obsolete
285 * (0: dynamic, -1: disable obsoletion) */
286 SCIP_Bool cons_disableenfops; /**< should enforcement of pseudo solution be disabled? */
287
288 /* display settings */
289 SCIP_VERBLEVEL disp_verblevel; /**< verbosity level of output */
290 int disp_width; /**< maximal number of characters in a node information line */
291 int disp_freq; /**< frequency for displaying node information lines */
292 int disp_headerfreq; /**< frequency for displaying header lines (every n'th node information line) */
293 SCIP_Bool disp_lpinfo; /**< should the LP solver display status messages? */
294 SCIP_Bool disp_allviols; /**< display all violations of the best solution after the solving process finished? */
295 SCIP_Bool disp_relevantstats; /**< should the relevant statistics be displayed at the end of solving? */
296
297 /* heuristics settings */
298 SCIP_Bool heur_useuctsubscip; /**< should setting of common subscip parameters include the activation of the UCT node selector? */
299
300 /* history settings */
301 SCIP_Bool history_valuebased; /**< should statistics be collected for variable domain value pairs? */
302 SCIP_Bool history_allowmerge; /**< should variable histories be merged from sub-SCIPs whenever possible? */
303 SCIP_Bool history_allowtransfer; /**< should variable histories be transferred to initialize SCIP copies? */
304
305 /* limit settings */
306 SCIP_Real limit_time; /**< maximal time in seconds to run */
307 SCIP_Real limit_memory; /**< maximal memory usage in MB */
308 SCIP_Real limit_gap; /**< solving stops, if the given gap is reached */
309 SCIP_Real limit_absgap; /**< solving stops, if the absolute difference between primal and dual bound
310 * reaches this value */
311 SCIP_Longint limit_nodes; /**< maximal number of nodes to process (-1: no limit) */
312 SCIP_Longint limit_totalnodes; /**< maximal number of total nodes (incl. restarts) to process (-1: no limit) */
313 SCIP_Longint limit_stallnodes; /**< solving stops, if the given number of nodes was processed since the
314 * last improvement of the primal solution value (-1: no limit) */
315 int limit_solutions; /**< solving stops, if the given number of solutions were found; this limit is first checked in presolving (-1: no limit) */
316 int limit_bestsol; /**< solving stops, if the given number of solution improvements were found
317 * (-1: no limit) */
318 int limit_maxsol; /**< maximal number of solutions to store in the solution storage */
319 int limit_maxorigsol; /**< maximal number of solutions candidates to store in the solution storage of the original problem */
320 int limit_restarts; /**< solving stops, if the given number of restarts was triggered (-1: no limit) */
321 int limit_autorestartnodes;/**< nodes to trigger automatic restart */
322
323 SCIP_Bool istimelimitfinite; /**< is the time limit finite */
324
325 /* LP settings */
326 int lp_solvefreq; /**< frequency for solving LP at the nodes (-1: never; 0: only root LP) */
327 SCIP_Longint lp_iterlim; /**< iteration limit for each single LP solve; -1: no limit */
328 SCIP_Longint lp_rootiterlim; /**< iteration limit for initial root LP solve; -1: no limit */
329 int lp_solvedepth; /**< maximal depth for solving LP at the nodes (-1: no depth limit) */
330 char lp_initalgorithm; /**< LP algorithm for solving initial LP relaxations ('s'implex, 'b'arrier,
331 * barrier with 'c'rossover) */
332 char lp_resolvealgorithm;/**< LP algorithm for resolving LP relaxations if a starting basis exists
333 * ('s'implex, 'b'arrier, barrier with 'c'rossover) */
334 char lp_pricing; /**< LP pricing strategy ('a'uto, 'f'ull pricing, 's'teepest edge pricing,
335 * 'q'uickstart steepest edge pricing, 'd'evex pricing) */
336 SCIP_Bool lp_clearinitialprobinglp;/**< should lp state be cleared at the end of probing mode when LP
337 * was initially unsolved, e.g., when called right after presolving? */
338 SCIP_Bool lp_resolverestore; /**< should the LP be resolved to restore the state at start of diving (if
339 * FALSE we buffer the solution values)? */
340 SCIP_Bool lp_freesolvalbuffers; /**< should the buffers for storing LP solution values during diving be
341 * freed at end of diving? */
342 int lp_colagelimit; /**< maximum age a column can reach before it is deleted from the SCIP_LP
343 * (-1: don't delete columns due to aging) */
344 int lp_rowagelimit; /**< maximum age a row can reach before it is deleted from the LP
345 * (-1: don't delete rows due to aging) */
346 SCIP_Bool lp_cleanupcols; /**< should new non-basic columns be removed after LP solving? */
347 SCIP_Bool lp_cleanupcolsroot; /**< should new non-basic columns be removed after root LP solving? */
348 SCIP_Bool lp_cleanuprows; /**< should new basic rows be removed after LP solving? */
349 SCIP_Bool lp_cleanuprowsroot; /**< should new basic rows be removed after root LP solving? */
350 SCIP_Bool lp_checkstability; /**< should LP solver's return status be checked for stability? */
351 SCIP_Real lp_conditionlimit; /**< maximum condition number of LP basis counted as stable (-1.0: no check) */
352 SCIP_Real lp_markowitz; /**< minimal Markowitz threshold to control sparsity/stability in LU factorization */
353 SCIP_Bool lp_checkprimfeas; /**< should LP solutions be checked for primal feasibility, resolving LP when numerical troubles occur? */
354 SCIP_Bool lp_checkdualfeas; /**< should LP solutions be checked for dual feasibility, resolving LP when numerical troubles occur? */
355 SCIP_Bool lp_checkfarkas; /**< should infeasibility proofs from the LP be checked? */
356 int lp_fastmip; /**< which FASTMIP setting of LP solver should be used? 0: off, 1: medium, 2: full */
357 int lp_scaling; /**< LP scaling (0: none, 1: normal, 2: aggressive) */
358 SCIP_Bool lp_presolving; /**< should presolving of LP solver be used? */
359 SCIP_Bool lp_lexdualalgo; /**< should the lexicographic dual algorithm be used? */
360 SCIP_Bool lp_lexdualrootonly; /**< should the lexicographic dual algorithm be applied only at the root node */
361 int lp_lexdualmaxrounds;/**< maximum number of rounds in the lexicographic dual algorithm */
362 SCIP_Bool lp_lexdualbasic; /**< choose fractional basic variables in lexicographic dual algorithm */
363 SCIP_Bool lp_lexdualstalling; /**< turn on the lex dual algorithm only when stalling? */
364 int lp_disablecutoff; /**< disable the cutoff bound in the LP solver? (0: enabled, 1: disabled, 2: auto) */
365 SCIP_Real lp_rowrepswitch; /**< simplex algorithm shall use row representation of the basis
366 * if number of rows divided by number of columns exceeds this value */
367 int lp_threads; /**< number of threads used for solving the LP (0: automatic) */
368 SCIP_Real lp_resolveiterfac; /**< factor of average LP iterations that is used as LP iteration limit
369 * for LP resolve (-1: unlimited) */
370 int lp_resolveitermin; /**< minimum number of iterations that are allowed for LP resolve */
371 int lp_solutionpolishing;/**< LP solution polishing method (0: disabled, 1: only root, 2: always, 3: auto) */
372 int lp_refactorinterval;/**< LP refactorization interval (0: automatic) */
373 SCIP_Bool lp_alwaysgetduals; /**< should the dual solution always be collected for LP solutions. */
374
375 /* NLP settings */
376 SCIP_Bool nlp_disable; /**< should the NLP be disabled even if a constraint handler enabled it? */
377 char* nlp_solver; /**< name of NLP solver to use */
378
379 /* memory settings */
380 SCIP_Real mem_savefac; /**< fraction of maximal memory usage resulting in switch to memory saving mode */
381 SCIP_Real mem_arraygrowfac; /**< memory growing factor for dynamically allocated arrays */
382 SCIP_Real mem_treegrowfac; /**< memory growing factor for tree array */
383 SCIP_Real mem_pathgrowfac; /**< memory growing factor for path array */
384 int mem_arraygrowinit; /**< initial size of dynamically allocated arrays */
385 int mem_treegrowinit; /**< initial size of tree array */
386 int mem_pathgrowinit; /**< initial size of path array */
387
388 /* miscellaneous settings */
389 SCIP_Bool misc_catchctrlc; /**< should the CTRL-C interrupt be caught by SCIP? */
390 SCIP_Bool misc_usevartable; /**< should a hashtable be used to map from variable names to variables? */
391 SCIP_Bool misc_useconstable; /**< should a hashtable be used to map from constraint names to constraints? */
392 SCIP_Bool misc_usesmalltables;/**< should smaller hashtables be used? yields better performance for small problems with about 100 variables */
393 SCIP_Bool misc_exactsolve; /**< should the problem be solved exactly (with proven dual bounds)? */
394 SCIP_Bool misc_resetstat; /**< should the statistics be reset if the transformed problem is freed
395 * otherwise the statistics get reset after original problem is freed (in
396 * case of bender decomposition this parameter should be set to FALSE and
397 * therefore can be used to collect statistics over all runs) */
398 SCIP_Bool misc_improvingsols; /**< should only solutions be checked which improve the primal bound */
399 SCIP_Bool misc_printreason; /**< should the reason be printed if a given start solution is infeasible? */
400 SCIP_Bool misc_estimexternmem;/**< should the usage of external memory be estimated? */
401 SCIP_Bool misc_avoidmemout; /**< try to avoid running into memory limit by restricting plugins like heuristics? */
402 SCIP_Bool misc_transorigsols; /**< should SCIP try to transfer original solutions to the transformed space (after presolving)? */
403 SCIP_Bool misc_transsolsorig; /**< should SCIP try to transfer transformed solutions to the original space (after solving)? */
404 SCIP_Bool misc_calcintegral; /**< should SCIP calculate the primal dual integral value which may require
405 * a large number of additional clock calls (and decrease the performance)? */
406 SCIP_Bool misc_finitesolstore;/**< should SCIP try to remove infinite fixings from solutions copied to the solution store? */
407 SCIP_Bool misc_outputorigsol; /**< should the best solution be transformed to the orignal space and be output in command line run? */
408 SCIP_Bool misc_allowstrongdualreds; /**< should strong dual reductions be allowed in propagation and presolving? */
409 SCIP_Bool misc_allowweakdualreds; /**< should weak dual reductions be allowed in propagation and presolving? */
410 SCIP_Real misc_referencevalue;/**< objective value for reference purposes */
411 int misc_usesymmetry; /**< bitset describing used symmetry handling technique (0: off; 1: polyhedral (orbitopes and/or symresacks);
412 * 2: orbital fixing; 3: orbitopes and orbital fixing; 4: Schreier Sims cuts; 5: Schreier Sims cuts and
413 * symresacks) */
414 char* misc_debugsol; /**< path to a debug solution */
415 SCIP_Bool misc_scaleobj; /**< should the objective function be scaled? */
416 SCIP_Bool misc_showdivingstats;/**< should detailed statistics for diving heuristics be shown? */
417
418 /* randomization parameters */
419 int random_randomseedshift;/**< global shift of all random seeds in the plugins, this will have no impact on the permutation and LP seeds */
420 int random_permutationseed;/**< seed value for permuting the problem after reading/transformation
421 * (0: no permutation) */
422 int random_randomseed; /**< random seed for LP solver, e.g. for perturbations in the simplex (0: LP default) */
423 SCIP_Bool random_permuteconss; /**< should order of constraints be permuted (depends on permutationseed)? */
424 SCIP_Bool random_permutevars; /**< should order of variables be permuted (depends on permutationseed)? */
425
426 /* node selection settings */
427 char nodesel_childsel; /**< child selection rule ('d'own, 'u'p, 'p'seudo costs, 'i'nference, 'l'p value,
428 * 'r'oot LP value difference, 'h'brid inference/root LP value difference) */
429
430 /* numerical settings */
431 SCIP_Real num_infinity; /**< values larger than this are considered infinity */
432 SCIP_Real num_epsilon; /**< absolute values smaller than this are considered zero */
433 SCIP_Real num_sumepsilon; /**< absolute values of sums smaller than this are considered zero */
434 SCIP_Real num_feastol; /**< feasibility tolerance for constraints */
435 SCIP_Real num_checkfeastolfac;/**< factor to change the feasibility tolerance when testing the best
436 * solution for feasibility (after solving process) */
437 SCIP_Real num_lpfeastolfactor;/**< factor w.r.t. primal feasibility tolerance that determines default (and maximal) primal feasibility tolerance of LP solver (user parameter, see also num_relaxfeastol) */
438 SCIP_Real num_dualfeastol; /**< feasibility tolerance for reduced costs */
439 SCIP_Real num_barrierconvtol; /**< convergence tolerance used in barrier algorithm */
440 SCIP_Real num_boundstreps; /**< minimal improve for strengthening bounds */
441 SCIP_Real num_pseudocosteps; /**< minimal variable distance value to use for pseudo cost updates */
442 SCIP_Real num_pseudocostdelta;/**< minimal objective distance value to use for pseudo cost updates */
443 SCIP_Real num_recompfac; /**< minimal decrease factor that causes the recomputation of a value
444 * (e.g., pseudo objective) instead of an update */
445 SCIP_Real num_hugeval; /**< values larger than this are considered huge and should be handled
446 * separately (e.g., in activity computation) */
447 SCIP_Real num_relaxfeastol; /**< primal feasibility tolerance for relaxations (set by core or plugins, not a parameter) */
448
449 /* presolving settings */
450 SCIP_Real presol_abortfac; /**< abort presolve, if l.t. this frac of the problem was changed in last round */
451 int presol_maxrounds; /**< maximal number of presolving rounds (-1: unlimited) */
452 int presol_maxrestarts; /**< maximal number of restarts (-1: unlimited) */
453 SCIP_Real presol_clqtablefac; /**< limit on number of entries in clique table relative to number of problem nonzeros */
454 SCIP_Real presol_restartfac; /**< fraction of integer variables that were fixed in the root node
455 * triggering a restart with preprocessing after root node evaluation */
456 SCIP_Real presol_immrestartfac;/**< fraction of integer variables that were fixed in the root node triggering an
457 * immediate restart with preprocessing */
458 SCIP_Real presol_subrestartfac;/**< fraction of integer variables that were globally fixed during the
459 * solving process triggering a restart with preprocessing */
460 SCIP_Real presol_restartminred;/**< minimal fraction of integer variables removed after restart to allow for
461 * an additional restart */
462 SCIP_Bool presol_donotmultaggr;/**< should multi-aggregation of variables be forbidden? */
463 SCIP_Bool presol_donotaggr; /**< should aggregation of variables be forbidden? */
464
465 /* pricing settings */
466 SCIP_Real price_abortfac; /**< pricing is aborted, if fac * maxpricevars pricing candidates were found */
467 int price_maxvars; /**< maximal number of variables priced in per pricing round */
468 int price_maxvarsroot; /**< maximal number of priced variables at the root node */
469 SCIP_Bool price_delvars; /**< should variables created at the current node be deleted when the node is solved
470 * in case they are not present in the LP anymore? */
471 SCIP_Bool price_delvarsroot; /**< should variables created at the root node be deleted when the root is solved
472 * in case they are not present in the LP anymore? */
473
474 /* Decomposition settings */
475 SCIP_Bool decomp_benderslabels; /**< should the variables be labeled for the application of Benders'
476 * decomposition */
477 SCIP_Bool decomp_applybenders; /**< if a decomposition exists, should Benders' decomposition be applied*/
478 int decomp_maxgraphedge; /**< maximum number of edges in block graph computation (-1: no limit, 0: disable block graph computation) */
479 SCIP_Bool decomp_disablemeasures; /**< disable expensive measures */
480
481 /* Benders' decomposition settings */
482 SCIP_Real benders_soltol; /**< the tolerance for checking optimality in Benders' decomposition */
483 SCIP_Bool benders_cutlpsol; /**< should cuts be generated from the solution to the LP relaxation? */
484 SCIP_Bool benders_copybenders;/**< should Benders' decomposition be copied for sub-SCIPs? */
485
486 /* propagation settings */
487 int prop_maxrounds; /**< maximal number of propagation rounds per node (-1: unlimited) */
488 int prop_maxroundsroot; /**< maximal number of propagation rounds in the root node (-1: unlimited) */
489 SCIP_Bool prop_abortoncutoff; /**< should propagation be aborted immediately? setting this to FALSE could
490 * help conflict analysis to produce more conflict constraints */
491
492 /* reoptimization settings */
493 SCIP_Real reopt_objsimsol; /**< similarity of two objective functions to reuse stored solutions. */
494 SCIP_Real reopt_objsimrootlp; /**< similarity of two sequential objective function to disable solving the
495 * root LP.
496 */
497 SCIP_Real reopt_objsimdelay; /**< minimum similarity for using reoptimization of the search tree. */
498 char reopt_varorderinterdiction; /** use the 'd'efault or a 'r'andom variable order for interdiction
499 * branching when applying the reoptimization
500 */
501 int reopt_forceheurrestart; /**< force a restart if the last n optimal solutions were found by
502 * heuristic reoptsols
503 */
504 int reopt_maxcutage; /**< maximal age of cuts to use them in reoptimization */
505 int reopt_maxdiffofnodes;/**< maximal number of bound changes between two stored nodes on one path */
506 int reopt_maxsavednodes;/**< maximal number of saved nodes */
507 int reopt_solvelp; /**< strategy for solving the LP at nodes from reoptimization */
508 int reopt_solvelpdiff; /**< maximal number of bound changes at node to skip solving the LP */
509 int reopt_savesols; /**< number of best solutions which should be saved for the following runs.
510 * (-1: save all)
511 */
512 SCIP_Bool reopt_commontimelimit;/**< time limit over all reoptimization rounds? */
513 SCIP_Bool reopt_enable; /**< enable reoptimization */
514 SCIP_Bool reopt_reducetofrontier; /**< delete stored nodes which were not reoptimized */
515 SCIP_Bool reopt_saveconsprop; /**< save constraint propagations */
516 SCIP_Bool reopt_sbinit; /**< try to fix variables before reoptimizing by probing like strong
517 * branching
518 */
519 SCIP_Bool reopt_shrinkinner; /**< replace branched inner nodes by their child nodes, if the number of
520 * bound changes is not to large
521 */
522 SCIP_Bool reopt_sepaglbinfsubtrees;/**< save global constraints to separate infeasible subtrees */
523 SCIP_Bool reopt_sepabestsol; /**< separate only the best solution, i.e., for constrained shortest path */
524 SCIP_Bool reopt_storevarhistory;/**< use variable history of the previous solve if the objective function
525 * has changed only slightly
526 */
527 SCIP_Bool reopt_usepscost; /**< reuse pseudo costs if the objective function changed only slightly */
528 SCIP_Bool reopt_usecuts; /**< reoptimize cuts found at the root node */
529 SCIP_Bool reopt_usesplitcons; /**< use constraints to reconstruct the subtree pruned be dual reduction
530 * when reactivating the node
531 */
532
533 /* separation settings */
534 SCIP_Real sepa_maxbounddist; /**< maximal relative distance from current node's dual bound to primal bound
535 * compared to best node's dual bound for applying separation
536 * (0.0: only on current best node, 1.0: on all nodes) */
537 SCIP_Real sepa_maxlocalbounddist;/**< maximal relative distance from current node's dual bound to primal bound
538 * compared to best node's dual bound for applying local separation
539 * (0.0: only on current best node, 1.0: on all nodes) */
540 SCIP_Real sepa_maxcoefratio; /**< maximal ratio between coefficients in strongcg, cmir, and flowcover cuts */
541 SCIP_Real sepa_maxcoefratiofacrowprep; /**< maximal ratio between coefficients (as factor of 1/feastol) to ensure in rowprep cleanup */
542 SCIP_Real sepa_minefficacy; /**< minimal efficacy for a cut to enter the LP */
543 SCIP_Real sepa_minefficacyroot; /**< minimal efficacy for a cut to enter the LP in the root node */
544 SCIP_Real sepa_minortho; /**< minimal orthogonality for a cut to enter the LP */
545 SCIP_Real sepa_minorthoroot; /**< minimal orthogonality for a cut to enter the LP in the root node */
546 SCIP_Real sepa_minactivityquot; /**< minimum cut activity quotient to convert cuts into constraints
547 * during a restart (0.0: all cuts are converted) */
548 char sepa_orthofunc; /**< function used for calc. scalar prod. in orthogonality test ('e'uclidean, 'd'iscrete) */
549 char sepa_efficacynorm; /**< row norm to use for efficacy calculation ('e'uclidean, 'm'aximum, 's'um,
550 * 'd'iscrete) */
551 char sepa_cutselrestart; /**< cut selection during restart ('a'ge, activity 'q'uotient) */
552 char sepa_cutselsubscip; /**< cut selection for sub SCIPs ('a'ge, activity 'q'uotient) */
553 SCIP_Bool sepa_filtercutpoolrel; /**< should cutpool separate only cuts with high relative efficacy? */
554 int sepa_maxruns; /**< maximal number of runs for which separation is enabled (-1: unlimited) */
555 int sepa_maxrounds; /**< maximal number of separation rounds per node (-1: unlimited) */
556 int sepa_maxroundsroot; /**< maximal number of separation rounds in the root node (-1: unlimited) */
557 int sepa_maxroundsrootsubrun; /**< maximal number of separation rounds in the root node of a subsequent run (-1: unlimited) */
558 int sepa_maxaddrounds; /**< maximal additional number of separation rounds in subsequent price-and-cut
559 * loops (-1: no additional restriction) */
560 int sepa_maxstallrounds;/**< maximal number of consecutive separation rounds without objective
561 * or integrality improvement (-1: no additional restriction) */
562 int sepa_maxstallroundsroot;/**< maximal number of consecutive separation rounds without objective
563 * or integrality improvement (-1: no additional restriction) */
564 int sepa_maxcuts; /**< maximal number of cuts separated per separation round */
565 int sepa_maxcutsroot; /**< maximal number of separated cuts at the root node */
566 int sepa_cutagelimit; /**< maximum age a cut can reach before it is deleted from the global cut pool */
567 int sepa_poolfreq; /**< separation frequency for the global cut pool */
568
569 /* parallel settings */
570 int parallel_mode; /**< the mode for the parallel implementation. 0: opportunistic or
571 * 1: deterministic */
572 int parallel_minnthreads;/**< the minimum number of threads used for parallel code */
573 int parallel_maxnthreads;/**< the maximum number of threads used for parallel code */
574
575 /* concurrent solver settings */
576 SCIP_Bool concurrent_changeseeds; /**< change the seeds in the different solvers? */
577 SCIP_Bool concurrent_changechildsel; /**< change the child selection rule in different solvers? */
578 SCIP_Bool concurrent_commvarbnds; /**< should the concurrent solvers communicate global variable bound changes? */
579 SCIP_Bool concurrent_presolvebefore; /**< should the problem be presolved before it is copied to the concurrent solvers? */
580 int concurrent_initseed; /**< the seed for computing the concurrent solver seeds */
581 SCIP_Real concurrent_freqinit; /**< initial frequency of synchronization */
582 SCIP_Real concurrent_freqmax; /**< maximal frequency of synchronization */
583 SCIP_Real concurrent_freqfactor; /**< factor by which the frequency of synchronization changes */
584 SCIP_Real concurrent_targetprogress; /**< when adapting the synchronization frequency this value is the targeted
585 * relative difference by which the absolute gap decreases per synchronization */
586 int concurrent_maxnsols; /**< maximum number of solutions that will get stored in one synchronization */
587 int concurrent_nbestsols; /**< number of best solutions that should be considered for synchronization */
588 int concurrent_maxnsyncdelay; /**< max number of synchronizations before data is used */
589 SCIP_Real concurrent_minsyncdelay; /**< min offset before synchronization data is used */
590 char* concurrent_paramsetprefix; /**< path prefix for parameter setting files of concurrent solver scip-custom */
591
592 /* timing settings */
593 SCIP_CLOCKTYPE time_clocktype; /**< default clock type to use */
594 SCIP_Bool time_enabled; /**< is timing enabled? */
595 SCIP_Bool time_reading; /**< belongs reading time to solving time? */
596 SCIP_Bool time_rareclockcheck;/**< should clock checks of solving time be performed less frequently (might exceed time limit slightly) */
597 SCIP_Bool time_statistictiming; /**< should timing for statistic output be enabled? */
598 SCIP_Bool time_nlpieval; /**< should time for evaluation in NLP solves be measured? */
599
600 /* tree compression parameters (for reoptimization) */
601 SCIP_Bool compr_enable; /**< should automatic tree compression after presolving be enabled? (only for reoptimization) */
602 SCIP_Real compr_time; /**< maximum time to run tree compression heuristics */
603
604 /* visualization settings */
605 char* visual_vbcfilename; /**< name of the VBC tool output file, or - if no VBC output should be created */
606 char* visual_bakfilename; /**< name of the BAK tool output file, or - if no BAK output should be created */
607 SCIP_Bool visual_realtime; /**< should the real solving time be used instead of time step counter in visualization? */
608 SCIP_Bool visual_dispsols; /**< should the node where solutions are found be visualized? */
609 SCIP_Bool visual_displb; /**< should lower bound information be visualized? */
610 SCIP_Bool visual_objextern; /**< should be output the external value of the objective? */
611
612 /* Reading */
613 SCIP_Bool read_initialconss; /**< should model constraints be marked as initial? */
614 SCIP_Bool read_dynamicconss; /**< should model constraints be subject to aging? */
615 SCIP_Bool read_dynamiccols; /**< should columns be added and removed dynamically to the LP? */
616 SCIP_Bool read_dynamicrows; /**< should rows be added and removed dynamically to the LP? */
617
618 /* Writing */
619 SCIP_Bool write_allconss; /**< should all constraints be written (including the redundant constraints)? */
620 SCIP_Bool write_printzeros; /**< should variables set to zero be printed? */
621 int write_genoffset; /**< when writing the problem with generic names, we start with index
622 * 0; using this parameter we can change the starting index to be
623 * different */
624};
625
626#ifdef __cplusplus
627}
628#endif
629
630#endif
methods for debugging
struct SCIP_DebugSolData SCIP_DEBUGSOLDATA
Definition debug.h:59
common defines and data types used in all packages of SCIP
message output methods
char sepa_orthofunc
Definition struct_set.h:548
SCIP_READER ** readers
Definition struct_set.h:79
int nconcsolvers
Definition struct_set.h:156
SCIP_EXPRHDLR * exprhdlrpow
Definition struct_set.h:106
int nactivebenders
Definition struct_set.h:159
SCIP_DEBUGSOLDATA * debugsoldata
Definition struct_set.h:111
SCIP_CONFLICTHDLR ** conflicthdlrs
Definition struct_set.h:85
int presol_maxrounds
Definition struct_set.h:451
SCIP_Bool cutselssorted
Definition struct_set.h:175
SCIP_Longint limit_totalnodes
Definition struct_set.h:312
SCIP_Real presol_restartfac
Definition struct_set.h:454
int sepa_maxcuts
Definition struct_set.h:564
int cutselssize
Definition struct_set.h:131
SCIP_Bool conf_dynamic
Definition struct_set.h:248
SCIP_Real num_relaxfeastol
Definition struct_set.h:447
SCIP_Bool bendersnamesorted
Definition struct_set.h:189
int benderssize
Definition struct_set.h:160
SCIP_Bool reopt_storevarhistory
Definition struct_set.h:524
int sepassize
Definition struct_set.h:129
BMS_BUFMEM * buffer
Definition struct_set.h:77
int propssize
Definition struct_set.h:133
SCIP_Real sepa_maxcoefratio
Definition struct_set.h:540
SCIP_Bool lp_checkstability
Definition struct_set.h:350
SCIP_Bool lp_lexdualrootonly
Definition struct_set.h:360
SCIP_Real num_barrierconvtol
Definition struct_set.h:439
SCIP_Bool concurrent_changechildsel
Definition struct_set.h:577
SCIP_Bool branchrulessorted
Definition struct_set.h:183
SCIP_Bool lp_cleanupcols
Definition struct_set.h:346
SCIP_PRESOL ** presols
Definition struct_set.h:86
SCIP_Bool conf_prefinfproof
Definition struct_set.h:239
SCIP_Real conf_uplockscorefac
Definition struct_set.h:252
SCIP_Bool lp_lexdualstalling
Definition struct_set.h:363
char * visual_bakfilename
Definition struct_set.h:606
int ncomprs
Definition struct_set.h:136
int decomp_maxgraphedge
Definition struct_set.h:478
char ** extcodedescs
Definition struct_set.h:114
int random_permutationseed
Definition struct_set.h:420
SCIP_Bool time_rareclockcheck
Definition struct_set.h:596
SCIP_Bool time_nlpieval
Definition struct_set.h:598
SCIP_Real concurrent_minsyncdelay
Definition struct_set.h:589
int exprhdlrssize
Definition struct_set.h:151
int parallel_mode
Definition struct_set.h:570
SCIP_Bool conflicthdlrsnamesorted
Definition struct_set.h:168
SCIP_Real num_pseudocostdelta
Definition struct_set.h:442
SCIP_Bool propsnamesorted
Definition struct_set.h:178
SCIP_EXPRHDLR * exprhdlrproduct
Definition struct_set.h:105
SCIP_EXPRHDLR * exprhdlrvar
Definition struct_set.h:102
SCIP_Bool reopt_enable
Definition struct_set.h:513
SCIP_CONSHDLR ** conshdlrs_sepa
Definition struct_set.h:82
SCIP_Bool lp_checkdualfeas
Definition struct_set.h:354
SCIP_Bool misc_showdivingstats
Definition struct_set.h:416
int nexprhdlrs
Definition struct_set.h:150
SCIP_Real reopt_objsimrootlp
Definition struct_set.h:494
SCIP_Bool misc_calcintegral
Definition struct_set.h:404
SCIP_Bool lp_lexdualalgo
Definition struct_set.h:359
int sepa_maxcutsroot
Definition struct_set.h:565
SCIP_Bool limitchanged
Definition struct_set.h:190
SCIP_Bool conf_repropagate
Definition struct_set.h:244
SCIP_Bool conf_keepreprop
Definition struct_set.h:246
SCIP_Bool misc_avoidmemout
Definition struct_set.h:401
SCIP_Real reopt_objsimsol
Definition struct_set.h:493
SCIP_Real limit_memory
Definition struct_set.h:307
int mem_arraygrowinit
Definition struct_set.h:384
SCIP_Real mem_arraygrowfac
Definition struct_set.h:381
int extcodessize
Definition struct_set.h:162
int ncutsels
Definition struct_set.h:130
int disp_freq
Definition struct_set.h:291
SCIP_Bool concurrent_commvarbnds
Definition struct_set.h:578
SCIP_CONSHDLR ** conshdlrs
Definition struct_set.h:81
int parallel_minnthreads
Definition struct_set.h:572
int neventhdlrs
Definition struct_set.h:138
int sepa_maxaddrounds
Definition struct_set.h:558
int lp_scaling
Definition struct_set.h:357
SCIP_Bool misc_useconstable
Definition struct_set.h:391
SCIP_STAGE stage
Definition struct_set.h:74
int sepa_poolfreq
Definition struct_set.h:567
SCIP_Bool disp_relevantstats
Definition struct_set.h:295
SCIP_Real conf_conflictweight
Definition struct_set.h:266
SCIP_Bool branch_divingpscost
Definition struct_set.h:204
int nconcsolvertypes
Definition struct_set.h:154
SCIP_Real conf_depthscorefac
Definition struct_set.h:250
int reopt_maxcutage
Definition struct_set.h:504
SCIP_Bool lp_checkprimfeas
Definition struct_set.h:353
char sepa_efficacynorm
Definition struct_set.h:549
int nnodesels
Definition struct_set.h:140
SCIP_Bool reopt_sbinit
Definition struct_set.h:516
int readerssize
Definition struct_set.h:116
SCIP_Bool read_initialconss
Definition struct_set.h:613
SCIP_Bool misc_finitesolstore
Definition struct_set.h:406
SCIP_Bool conf_settlelocal
Definition struct_set.h:242
int reopt_maxsavednodes
Definition struct_set.h:506
SCIP_Bool misc_transorigsols
Definition struct_set.h:402
int conf_minmaxvars
Definition struct_set.h:213
int sepa_maxroundsrootsubrun
Definition struct_set.h:557
SCIP_Real conf_restartfac
Definition struct_set.h:257
int nextcodes
Definition struct_set.h:161
int reopt_solvelpdiff
Definition struct_set.h:508
char branch_lpgainnorm
Definition struct_set.h:202
SCIP_CONCSOLVER ** concsolvers
Definition struct_set.h:109
SCIP_SEPA ** sepas
Definition struct_set.h:88
SCIP_Bool read_dynamiccols
Definition struct_set.h:615
SCIP_Bool misc_resetstat
Definition struct_set.h:394
int conf_maxlploops
Definition struct_set.h:214
SCIP_Bool branch_preferbinary
Definition struct_set.h:198
SCIP_Real price_abortfac
Definition struct_set.h:466
int nreaders
Definition struct_set.h:115
SCIP_Real num_lpfeastolfactor
Definition struct_set.h:437
int mem_treegrowinit
Definition struct_set.h:385
int reopt_maxdiffofnodes
Definition struct_set.h:505
SCIP_Bool conf_fullshortenconflict
Definition struct_set.h:263
SCIP_Bool branch_delaypscost
Definition struct_set.h:203
SCIP_Real num_hugeval
Definition struct_set.h:445
int conf_reconvlevels
Definition struct_set.h:225
int price_maxvars
Definition struct_set.h:467
SCIP_Real benders_soltol
Definition struct_set.h:482
int sepa_maxruns
Definition struct_set.h:554
SCIP_Bool sepassorted
Definition struct_set.h:173
SCIP_HEUR ** heurs
Definition struct_set.h:92
int conf_lpiterations
Definition struct_set.h:216
int sepa_maxstallrounds
Definition struct_set.h:560
SCIP_Bool branch_sumadjustscore
Definition struct_set.h:209
int conshdlrssize
Definition struct_set.h:121
int lp_solutionpolishing
Definition struct_set.h:371
SCIP_Bool propssorted
Definition struct_set.h:176
SCIP_Bool heurssorted
Definition struct_set.h:179
SCIP_Bool comprsnamesorted
Definition struct_set.h:182
SCIP_Real branch_midpull
Definition struct_set.h:200
SCIP_DIALOG ** dialogs
Definition struct_set.h:100
char nodesel_childsel
Definition struct_set.h:427
SCIP_Real num_boundstreps
Definition struct_set.h:440
int conf_maxconss
Definition struct_set.h:222
SCIP_Real presol_clqtablefac
Definition struct_set.h:453
int lp_refactorinterval
Definition struct_set.h:372
SCIP_Bool misc_printreason
Definition struct_set.h:399
SCIP_Longint limit_nodes
Definition struct_set.h:311
SCIP_Real limit_absgap
Definition struct_set.h:309
SCIP_Bool misc_improvingsols
Definition struct_set.h:398
SCIP_BENDERS ** benders
Definition struct_set.h:110
int concsolvertypessize
Definition struct_set.h:155
int sepa_maxrounds
Definition struct_set.h:555
SCIP_Bool pricersnamesorted
Definition struct_set.h:166
SCIP_Real mem_savefac
Definition struct_set.h:380
SCIP_Bool random_permutevars
Definition struct_set.h:424
SCIP_Real conf_maxvarsfac
Definition struct_set.h:212
char sepa_cutselsubscip
Definition struct_set.h:552
SCIP_Real conf_scorefac
Definition struct_set.h:254
char conf_useboundlp
Definition struct_set.h:233
char conf_useinflp
Definition struct_set.h:230
char ** extcodenames
Definition struct_set.h:113
int mem_pathgrowinit
Definition struct_set.h:386
SCIP_Real presol_restartminred
Definition struct_set.h:460
int nlpissize
Definition struct_set.h:153
int reopt_savesols
Definition struct_set.h:509
SCIP_Real conf_minimprove
Definition struct_set.h:276
SCIP_COMPR ** comprs
Definition struct_set.h:93
int conf_fuiplevels
Definition struct_set.h:218
int limit_maxorigsol
Definition struct_set.h:319
int sepa_maxstallroundsroot
Definition struct_set.h:562
int concurrent_maxnsyncdelay
Definition struct_set.h:588
int npricers
Definition struct_set.h:117
SCIP_VERBLEVEL disp_verblevel
Definition struct_set.h:289
SCIP_Bool relaxsnamesorted
Definition struct_set.h:172
SCIP_Bool conf_useprop
Definition struct_set.h:229
SCIP_Bool propspresolsorted
Definition struct_set.h:177
SCIP_Bool conf_uselocalrows
Definition struct_set.h:279
SCIP_Real conf_weightrepropdepth
Definition struct_set.h:273
SCIP_Bool benderssorted
Definition struct_set.h:188
SCIP_Bool visual_displb
Definition struct_set.h:609
int branchrulessize
Definition struct_set.h:143
SCIP_Bool misc_exactsolve
Definition struct_set.h:393
SCIP_Real sepa_maxcoefratiofacrowprep
Definition struct_set.h:541
SCIP_Bool reopt_saveconsprop
Definition struct_set.h:515
int write_genoffset
Definition struct_set.h:621
SCIP_Bool price_delvarsroot
Definition struct_set.h:471
SCIP_Bool nlpissorted
Definition struct_set.h:187
SCIP_Bool branch_roundsbsol
Definition struct_set.h:208
SCIP_Bool benders_cutlpsol
Definition struct_set.h:483
SCIP_Bool decomp_applybenders
Definition struct_set.h:477
int conf_restartnum
Definition struct_set.h:255
int limit_restarts
Definition struct_set.h:320
SCIP_Bool sepasnamesorted
Definition struct_set.h:174
SCIP_Real mem_treegrowfac
Definition struct_set.h:382
SCIP_CUTSEL ** cutsels
Definition struct_set.h:89
SCIP_Bool lp_clearinitialprobinglp
Definition struct_set.h:336
SCIP_Bool misc_transsolsorig
Definition struct_set.h:403
int dispssize
Definition struct_set.h:145
SCIP_Real presol_immrestartfac
Definition struct_set.h:456
int conf_maxvarsdetectimpliedbounds
Definition struct_set.h:259
SCIP_Bool sepa_filtercutpoolrel
Definition struct_set.h:553
SCIP_Real sepa_minefficacyroot
Definition struct_set.h:543
SCIP_Bool compr_enable
Definition struct_set.h:601
SCIP_CONCSOLVERTYPE ** concsolvertypes
Definition struct_set.h:108
SCIP_Real conf_downlockscorefac
Definition struct_set.h:253
SCIP_Bool decomp_benderslabels
Definition struct_set.h:475
SCIP_Longint lp_rootiterlim
Definition struct_set.h:328
SCIP_Bool lp_alwaysgetduals
Definition struct_set.h:373
int dialogssize
Definition struct_set.h:149
SCIP_NODESEL * nodesel
Definition struct_set.h:96
char sepa_cutselrestart
Definition struct_set.h:551
int sepa_cutagelimit
Definition struct_set.h:566
SCIP_Bool reopt_reducetofrontier
Definition struct_set.h:514
SCIP_Real num_epsilon
Definition struct_set.h:432
int reopt_forceheurrestart
Definition struct_set.h:501
int nactivepricers
Definition struct_set.h:118
int nconflicthdlrs
Definition struct_set.h:122
SCIP_EXPRHDLR * exprhdlrsum
Definition struct_set.h:104
SCIP_Bool comprssorted
Definition struct_set.h:181
int random_randomseedshift
Definition struct_set.h:419
int conflicthdlrssize
Definition struct_set.h:123
SCIP_Real num_feastol
Definition struct_set.h:434
SCIP_CONSHDLR ** conshdlrs_enfo
Definition struct_set.h:83
int disp_width
Definition struct_set.h:290
SCIP_Bool conf_sepaaltproofs
Definition struct_set.h:275
SCIP_Real presol_abortfac
Definition struct_set.h:450
SCIP_PROP ** props
Definition struct_set.h:90
SCIP_Bool relaxssorted
Definition struct_set.h:171
SCIP_Real sepa_minortho
Definition struct_set.h:544
SCIP_Bool misc_estimexternmem
Definition struct_set.h:400
SCIP_Bool misc_usevartable
Definition struct_set.h:390
int limit_maxsol
Definition struct_set.h:318
int concurrent_initseed
Definition struct_set.h:580
SCIP_Real limit_time
Definition struct_set.h:306
char branch_firstsbchild
Definition struct_set.h:195
int prop_maxroundsroot
Definition struct_set.h:488
SCIP_Real sepa_maxbounddist
Definition struct_set.h:534
SCIP_Bool istimelimitfinite
Definition struct_set.h:323
SCIP_Bool reopt_shrinkinner
Definition struct_set.h:519
int presol_maxrestarts
Definition struct_set.h:452
SCIP_NODESEL ** nodesels
Definition struct_set.h:95
SCIP_Real num_recompfac
Definition struct_set.h:443
SCIP_Bool misc_outputorigsol
Definition struct_set.h:407
SCIP_CONSHDLR ** conshdlrs_include
Definition struct_set.h:84
SCIP_Longint lp_iterlim
Definition struct_set.h:327
SCIP_Real sepa_minorthoroot
Definition struct_set.h:545
SCIP_EVENTHDLR ** eventhdlrs
Definition struct_set.h:94
int presolssize
Definition struct_set.h:125
SCIP_Real misc_referencevalue
Definition struct_set.h:410
int cons_agelimit
Definition struct_set.h:282
int lp_threads
Definition struct_set.h:367
char * nlp_solver
Definition struct_set.h:377
SCIP_Real conf_weightvaliddepth
Definition struct_set.h:274
SCIP_Bool prop_abortoncutoff
Definition struct_set.h:489
int price_maxvarsroot
Definition struct_set.h:468
SCIP_Bool time_statistictiming
Definition struct_set.h:597
SCIP_Real concurrent_freqfactor
Definition struct_set.h:583
SCIP_Bool misc_scaleobj
Definition struct_set.h:415
SCIP_Bool conf_cleanbnddepend
Definition struct_set.h:228
SCIP_Bool conf_removable
Definition struct_set.h:249
SCIP_Real lp_rowrepswitch
Definition struct_set.h:365
SCIP_NLPI ** nlpis
Definition struct_set.h:107
SCIP_Real num_checkfeastolfac
Definition struct_set.h:435
SCIP_Real mem_pathgrowfac
Definition struct_set.h:383
SCIP_Bool disp_allviols
Definition struct_set.h:294
SCIP_Real branch_clamp
Definition struct_set.h:199
SCIP_TABLE ** tables
Definition struct_set.h:99
SCIP_Real branch_scorefac
Definition struct_set.h:196
SCIP_Real conf_conflictgraphweight
Definition struct_set.h:269
SCIP_Bool lp_resolverestore
Definition struct_set.h:338
SCIP_Bool conf_separate
Definition struct_set.h:247
int comprssize
Definition struct_set.h:137
int lp_colagelimit
Definition struct_set.h:342
int lp_lexdualmaxrounds
Definition struct_set.h:361
SCIP_Bool history_allowtransfer
Definition struct_set.h:303
SCIP_Bool lp_presolving
Definition struct_set.h:358
SCIP_Real lp_markowitz
Definition struct_set.h:352
int conf_maxstoresize
Definition struct_set.h:224
int prop_maxrounds
Definition struct_set.h:487
SCIP_Bool branch_checksbsol
Definition struct_set.h:207
SCIP_Bool conf_preferbinary
Definition struct_set.h:240
int limit_solutions
Definition struct_set.h:315
SCIP_Real lp_resolveiterfac
Definition struct_set.h:368
SCIP_DISP ** disps
Definition struct_set.h:98
int lp_solvefreq
Definition struct_set.h:326
SCIP_Bool lp_cleanupcolsroot
Definition struct_set.h:347
SCIP_Bool misc_usesmalltables
Definition struct_set.h:392
int npresols
Definition struct_set.h:124
SCIP_Bool nlp_disable
Definition struct_set.h:376
char lp_pricing
Definition struct_set.h:334
SCIP_Bool concurrent_presolvebefore
Definition struct_set.h:579
SCIP_BRANCHRULE ** branchrules
Definition struct_set.h:97
SCIP_Bool random_permuteconss
Definition struct_set.h:423
SCIP_Real num_pseudocosteps
Definition struct_set.h:441
int tablessize
Definition struct_set.h:147
int reopt_solvelp
Definition struct_set.h:507
SCIP_Bool time_enabled
Definition struct_set.h:594
int relaxssize
Definition struct_set.h:127
int concurrent_maxnsols
Definition struct_set.h:586
SCIP_Bool reopt_commontimelimit
Definition struct_set.h:512
char reopt_varorderinterdiction
Definition struct_set.h:498
SCIP_Real lp_conditionlimit
Definition struct_set.h:351
SCIP_Bool branch_forceall
Definition struct_set.h:205
int ntables
Definition struct_set.h:146
SCIP_Bool lp_freesolvalbuffers
Definition struct_set.h:340
SCIP_Bool branchrulesnamesorted
Definition struct_set.h:184
SCIP * scip
Definition struct_set.h:75
SCIP_Bool reopt_usepscost
Definition struct_set.h:527
SCIP_Real num_dualfeastol
Definition struct_set.h:438
SCIP_Bool presolsnamesorted
Definition struct_set.h:170
SCIP_Bool price_delvars
Definition struct_set.h:469
SCIP_Bool history_allowmerge
Definition struct_set.h:302
int pricerssize
Definition struct_set.h:119
SCIP_EXPRHDLR ** exprhdlrs
Definition struct_set.h:101
int conf_interconss
Definition struct_set.h:220
SCIP_Bool conf_usepseudo
Definition struct_set.h:238
SCIP_Bool reopt_sepaglbinfsubtrees
Definition struct_set.h:522
int lp_solvedepth
Definition struct_set.h:329
SCIP_Bool misc_allowweakdualreds
Definition struct_set.h:409
SCIP_Bool decomp_disablemeasures
Definition struct_set.h:479
int ndialogs
Definition struct_set.h:148
SCIP_Real concurrent_targetprogress
Definition struct_set.h:584
int banditvtablessize
Definition struct_set.h:164
SCIP_Longint limit_stallnodes
Definition struct_set.h:313
char * misc_debugsol
Definition struct_set.h:414
SCIP_Bool misc_catchctrlc
Definition struct_set.h:389
int concurrent_nbestsols
Definition struct_set.h:587
SCIP_Real presol_subrestartfac
Definition struct_set.h:458
SCIP_Real sepa_maxlocalbounddist
Definition struct_set.h:537
int limit_autorestartnodes
Definition struct_set.h:321
SCIP_Bool benders_copybenders
Definition struct_set.h:484
SCIP_Bool reopt_usesplitcons
Definition struct_set.h:529
SCIP_Real num_sumepsilon
Definition struct_set.h:433
int lp_fastmip
Definition struct_set.h:356
SCIP_Bool cons_disableenfops
Definition struct_set.h:286
BMS_BUFMEM * cleanbuffer
Definition struct_set.h:78
int heurssize
Definition struct_set.h:135
int disp_headerfreq
Definition struct_set.h:292
SCIP_PROP ** props_presol
Definition struct_set.h:91
int limit_bestsol
Definition struct_set.h:316
SCIP_Real sepa_minefficacy
Definition struct_set.h:542
SCIP_Bool lp_checkfarkas
Definition struct_set.h:355
int nbenders
Definition struct_set.h:158
SCIP_RELAX ** relaxs
Definition struct_set.h:87
int nodeselssize
Definition struct_set.h:141
SCIP_Real num_infinity
Definition struct_set.h:431
SCIP_Bool reopt_sepabestsol
Definition struct_set.h:523
SCIP_Bool conf_allowlocal
Definition struct_set.h:241
SCIP_Bool heur_useuctsubscip
Definition struct_set.h:298
SCIP_BANDITVTABLE ** banditvtables
Definition struct_set.h:112
SCIP_Bool write_allconss
Definition struct_set.h:619
char * concurrent_paramsetprefix
Definition struct_set.h:590
SCIP_PARAMSET * paramset
Definition struct_set.h:76
SCIP_Bool pricerssorted
Definition struct_set.h:165
SCIP_Real limit_gap
Definition struct_set.h:308
SCIP_Bool reopt_usecuts
Definition struct_set.h:528
SCIP_Bool heursnamesorted
Definition struct_set.h:180
int nrelaxs
Definition struct_set.h:126
SCIP_Real concurrent_freqinit
Definition struct_set.h:581
SCIP_Real branch_midpullreldomtrig
Definition struct_set.h:201
SCIP_Real conf_proofscorefac
Definition struct_set.h:251
SCIP_Bool visual_realtime
Definition struct_set.h:607
SCIP_Bool concurrent_changeseeds
Definition struct_set.h:576
int concsolverssize
Definition struct_set.h:157
SCIP_CLOCKTYPE time_clocktype
Definition struct_set.h:593
SCIP_Real reopt_objsimdelay
Definition struct_set.h:497
SCIP_Bool conf_usesb
Definition struct_set.h:236
SCIP_Bool read_dynamicrows
Definition struct_set.h:616
char * visual_vbcfilename
Definition struct_set.h:605
SCIP_Real concurrent_freqmax
Definition struct_set.h:582
char branch_scorefunc
Definition struct_set.h:194
char lp_resolvealgorithm
Definition struct_set.h:332
int nconshdlrs
Definition struct_set.h:120
SCIP_Bool disp_lpinfo
Definition struct_set.h:293
SCIP_Real compr_time
Definition struct_set.h:602
SCIP_Bool lp_cleanuprowsroot
Definition struct_set.h:349
int misc_usesymmetry
Definition struct_set.h:411
char lp_initalgorithm
Definition struct_set.h:330
SCIP_Bool misc_allowstrongdualreds
Definition struct_set.h:408
SCIP_Bool presol_donotaggr
Definition struct_set.h:463
SCIP_Bool time_reading
Definition struct_set.h:595
SCIP_Bool write_printzeros
Definition struct_set.h:620
SCIP_PRICER ** pricers
Definition struct_set.h:80
int cons_obsoleteage
Definition struct_set.h:284
SCIP_Bool read_dynamicconss
Definition struct_set.h:614
int lp_disablecutoff
Definition struct_set.h:364
SCIP_Bool lp_lexdualbasic
Definition struct_set.h:362
SCIP_Real conf_weightsize
Definition struct_set.h:272
SCIP_Bool visual_objextern
Definition struct_set.h:610
SCIP_Bool exprhdlrssorted
Definition struct_set.h:186
SCIP_Bool conf_ignorerelaxedbd
Definition struct_set.h:258
SCIP_Bool history_valuebased
Definition struct_set.h:301
SCIP_Bool subscipsoff
Definition struct_set.h:191
int nbanditvtables
Definition struct_set.h:163
int lp_rowagelimit
Definition struct_set.h:344
SCIP_Bool presol_donotmultaggr
Definition struct_set.h:462
SCIP_Bool tablessorted
Definition struct_set.h:185
int sepa_maxroundsroot
Definition struct_set.h:556
SCIP_Bool conflicthdlrssorted
Definition struct_set.h:167
int lp_resolveitermin
Definition struct_set.h:370
SCIP_Bool presolssorted
Definition struct_set.h:169
SCIP_Real sepa_minactivityquot
Definition struct_set.h:546
SCIP_EXPRHDLR * exprhdlrval
Definition struct_set.h:103
SCIP_Bool visual_dispsols
Definition struct_set.h:608
int eventhdlrssize
Definition struct_set.h:139
int parallel_maxnthreads
Definition struct_set.h:573
int random_randomseed
Definition struct_set.h:422
int nbranchrules
Definition struct_set.h:142
SCIP_Bool lp_cleanuprows
Definition struct_set.h:348
SCIP_Bool conf_enable
Definition struct_set.h:227
type definitions for bandit selection algorithms
type definitions for Benders' decomposition methods
type definitions for branching rules
type definitions for clocks and timing issues
enum SCIP_ClockType SCIP_CLOCKTYPE
Definition type_clock.h:47
type definitions for tree compression
type definitions for concurrent solvers
type definitions for conflict analysis
type definitions for constraints and constraint handlers
type definitions for cut selectors
type definitions for user interface dialog
type definitions for displaying runtime statistics
type definitions for managing events
type and macro definitions related to algebraic expressions
type definitions for primal heuristics
enum SCIP_VerbLevel SCIP_VERBLEVEL
type definitions for NLP solver interfaces
type definitions for node selectors
type definitions for handling parameter settings
type definitions for presolvers
type definitions for variable pricers
type definitions for propagators
type definitions for input file readers
type definitions for relaxators
type definitions for SCIP's main datastructure
type definitions for separators
type definitions for global SCIP settings
enum SCIP_Stage SCIP_STAGE
Definition type_set.h:59
type definitions for displaying statistics tables