Scippy

SCIP

Solving Constraint Integer Programs

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