Go to the documentation of this file.
28 #include "scip/def.h"
29 #include "scip/message.h"
30 #include "scip/type_bandit.h"
31 #include "scip/type_set.h"
32 #include "scip/type_clock.h"
33 #include "scip/type_paramset.h"
34 #include "scip/type_event.h"
35 #include "scip/type_scip.h"
36 #include "scip/type_branch.h"
37 #include "scip/type_conflict.h"
38 #include "scip/type_cons.h"
39 #include "scip/type_disp.h"
40 #include "scip/type_dialog.h"
41 #include "scip/type_heur.h"
42 #include "scip/type_compr.h"
43 #include "scip/type_nodesel.h"
44 #include "scip/type_presol.h"
45 #include "scip/type_pricer.h"
46 #include "scip/type_reader.h"
47 #include "scip/type_relax.h"
48 #include "scip/type_sepa.h"
49 #include "scip/type_table.h"
50 #include "scip/type_prop.h"
51 #include "nlpi/type_nlpi.h"
52 #include "scip/type_concsolver.h"
53 #include "scip/type_benders.h"
54 #include "scip/debug.h"
67 BMS_BUFMEM* cleanbuffer; /**< memory buffers for short living temporary objects init. to all zero */
92 SCIP_BENDERS** benders; /**< the data structures managing the Benders' decomposition algorithm */
171 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 */
172 SCIP_Real branch_scorefac; /**< branching score factor to weigh downward and upward gain prediction
175 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 */
176 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 */
177 SCIP_Real branch_midpullreldomtrig; /**< multiply midpull by relative domain width if the latter is below this value */
178 char branch_lpgainnorm; /**< strategy for normalizing LP gain when updating pseudo costs of continuous variables */
179 SCIP_Bool branch_delaypscost; /**< whether to delay pseudo costs updates for continuous variables to after separation */
180 SCIP_Bool branch_divingpscost;/**< should pseudo costs be updated also in diving and probing mode? */
183 SCIP_Bool branch_checksbsol; /**< should LP solutions during strong branching with propagation be checked for feasibility? */
184 SCIP_Bool branch_roundsbsol; /**< should LP solutions during strong branching with propagation be rounded? (only when checksbsol=TRUE) */
185 SCIP_Bool branch_sumadjustscore; /**< score adjustment near zero by \b adding epsilon (TRUE) or using maximum (FALSE) */
188 SCIP_Real conf_maxvarsfac; /**< maximal fraction of variables involved in a conflict constraint */
189 int conf_minmaxvars; /**< minimal absolute maximum of variables involved in a conflict constraint */
196 int conf_interconss; /**< maximal number of intermediate conflict constraints generated in conflict
201 int conf_reconvlevels; /**< number of depth levels up to which UIP reconvergence constraints are
204 SCIP_Bool conf_cleanbnddepend;/**< should conflicts related to an old cutoff bound be removed? */
205 SCIP_Bool conf_useprop; /**< should propagation conflict analysis be used? (uses conflict graph only) */
212 SCIP_Bool conf_usesb; /**< should infeasible/bound exceeding strong branching conflict analysis be
217 SCIP_Bool conf_allowlocal; /**< should conflict constraints be generated that are only valid locally? */
218 SCIP_Bool conf_settlelocal; /**< should conflict constraints be attached only to the local subtree where
220 SCIP_Bool conf_repropagate; /**< should earlier nodes be repropagated in order to replace branching
222 SCIP_Bool conf_keepreprop; /**< should constraints be kept for repropagation even if they are too long? */
225 SCIP_Bool conf_removable; /**< should the conflict's relaxations be subject to LP aging and cleanup? */
226 SCIP_Real conf_depthscorefac; /**< score factor for depth level in bound relaxation heuristic */
227 SCIP_Real conf_proofscorefac; /**< score factor for contribution to infeasibility proof in bound relaxation heuristic */
228 SCIP_Real conf_uplockscorefac;/**< score factor for number of up locks in bound relaxation heuristic */
229 SCIP_Real conf_downlockscorefac;/**< score factor for number of down locks in bound relaxation heuristic */
230 SCIP_Real conf_scorefac; /**< factor to decrease importance of variables' earlier conflict scores */
235 int conf_maxvarsdetectimpliedbounds;/**< maximal number of variables to try to detect global bound
239 SCIP_Bool conf_fullshortenconflict;/**< try to shorten the whole conflict set or terminate early
242 SCIP_Real conf_conflictweight;/**< the weight the VSIDS score is weight by updating the VSIDS for a
245 SCIP_Real conf_conflictgraphweight; /**< the weight the VSIDS score is weight by updating the VSIDS for a
249 SCIP_Real conf_weightrepropdepth;/**< weight of the prepropagtion depth of a conflict used in score calculation */
250 SCIP_Real conf_weightvaliddepth;/**< weight of the valid depth of a conflict used in score calculation */
252 SCIP_Real conf_minimprove; /**< minimal improvement of primal bound to remove conflicts depending on
268 int disp_headerfreq; /**< frequency for displaying header lines (every n'th node information line) */
270 SCIP_Bool disp_allviols; /**< display all violations of the best solution after the solving process finished? */
271 SCIP_Bool disp_relevantstats; /**< should the relevant statistics be displayed at the end of solving? */
274 SCIP_Bool heur_useuctsubscip; /**< should setting of common subscip parameters include the activation of the UCT node selector? */
277 SCIP_Bool history_valuebased; /**< should statistics be collected for variable domain value pairs? */
278 SCIP_Bool history_allowmerge; /**< should variable histories be merged from sub-SCIPs whenever possible? */
279 SCIP_Bool history_allowtransfer; /**< should variable histories be transferred to initialize SCIP copies? */
285 SCIP_Real limit_absgap; /**< solving stops, if the absolute difference between primal and dual bound
288 SCIP_Longint limit_totalnodes; /**< maximal number of total nodes (incl. restarts) to process (-1: no limit) */
289 SCIP_Longint limit_stallnodes; /**< solving stops, if the given number of nodes was processed since the
291 int limit_solutions; /**< solving stops, if the given number of solutions were found (-1: no limit) */
295 int limit_maxorigsol; /**< maximal number of solutions candidates to store in the solution storage of the original problem */
296 int limit_restarts; /**< solving stops, if the given number of restarts was triggered (-1: no limit) */
306 char lp_initalgorithm; /**< LP algorithm for solving initial LP relaxations ('s'implex, 'b'arrier,
308 char lp_resolvealgorithm;/**< LP algorithm for resolving LP relaxations if a starting basis exists
312 SCIP_Bool lp_clearinitialprobinglp;/**< should lp state be cleared at the end of probing mode when LP
314 SCIP_Bool lp_resolverestore; /**< should the LP be resolved to restore the state at start of diving (if
316 SCIP_Bool lp_freesolvalbuffers; /**< should the buffers for storing LP solution values during diving be
323 SCIP_Bool lp_cleanupcolsroot; /**< should new non-basic columns be removed after root LP solving? */
327 SCIP_Real lp_conditionlimit; /**< maximum condition number of LP basis counted as stable (-1.0: no check) */
328 SCIP_Real lp_markowitz; /**< minimal Markowitz threshold to control sparsity/stability in LU factorization */
329 SCIP_Bool lp_checkprimfeas; /**< should LP solutions be checked for primal feasibility, resolving LP when numerical troubles occur? */
330 SCIP_Bool lp_checkdualfeas; /**< should LP solutions be checked for dual feasibility, resolving LP when numerical troubles occur? */
332 int lp_fastmip; /**< which FASTMIP setting of LP solver should be used? 0: off, 1: medium, 2: full */
336 SCIP_Bool lp_lexdualrootonly; /**< should the lexicographic dual algorithm be applied only at the root node */
338 SCIP_Bool lp_lexdualbasic; /**< choose fractional basic variables in lexicographic dual algorithm */
340 int lp_disablecutoff; /**< disable the cutoff bound in the LP solver? (0: enabled, 1: disabled, 2: auto) */
344 SCIP_Real lp_resolveiterfac; /**< factor of average LP iterations that is used as LP iteration limit
347 int lp_solutionpolishing;/**< LP solution polishing method (0: disabled, 1: only root, 2: always, 3: auto) */
349 SCIP_Bool lp_alwaysgetduals; /**< should the dual solution always be collected for LP solutions. */
352 SCIP_Bool nlp_disable; /**< should the NLP be disabled even if a constraint handler enabled it? */
356 SCIP_Real mem_savefac; /**< fraction of maximal memory usage resulting in switch to memory saving mode */
366 SCIP_Bool misc_usevartable; /**< should a hashtable be used to map from variable names to variables? */
367 SCIP_Bool misc_useconstable; /**< should a hashtable be used to map from constraint names to constraints? */
368 SCIP_Bool misc_usesmalltables;/**< should smaller hashtables be used? yields better performance for small problems with about 100 variables */
369 SCIP_Bool misc_exactsolve; /**< should the problem be solved exactly (with proven dual bounds)? */
370 SCIP_Bool misc_resetstat; /**< should the statistics be reset if the transformed problem is freed
374 SCIP_Bool misc_improvingsols; /**< should only solutions be checked which improve the primal bound */
375 SCIP_Bool misc_printreason; /**< should the reason be printed if a given start solution is infeasible? */
377 SCIP_Bool misc_transorigsols; /**< should SCIP try to transfer original solutions to the transformed space (after presolving)? */
378 SCIP_Bool misc_transsolsorig; /**< should SCIP try to transfer transformed solutions to the original space (after solving)? */
379 SCIP_Bool misc_calcintegral; /**< should SCIP calculate the primal dual integral value which may require
381 SCIP_Bool misc_finitesolstore;/**< should SCIP try to remove infinite fixings from solutions copied to the solution store? */
382 SCIP_Bool misc_outputorigsol; /**< should the best solution be transformed to the orignal space and be output in command line run? */
383 SCIP_Bool misc_allowstrongdualreds; /**< should strong dual reductions be allowed in propagation and presolving? */
384 SCIP_Bool misc_allowweakdualreds; /**< should weak dual reductions be allowed in propagation and presolving? */
386 int misc_usesymmetry; /**< bitset describing used symmetry handling technique (0: off; 1: polyhedral (orbitopes and/or symresacks);
392 int random_randomseedshift;/**< global shift of all random seeds in the plugins, this will have no impact on the permutation and LP seeds */
393 int random_permutationseed;/**< seed value for permuting the problem after reading/transformation
395 int random_randomseed; /**< random seed for LP solver, e.g. for perturbations in the simplex (0: LP default) */
396 SCIP_Bool random_permuteconss; /**< should order of constraints be permuted (depends on permutationseed)? */
397 SCIP_Bool random_permutevars; /**< should order of variables be permuted (depends on permutationseed)? */
400 char nodesel_childsel; /**< child selection rule ('d'own, 'u'p, 'p'seudo costs, 'i'nference, 'l'p value,
408 SCIP_Real num_checkfeastolfac;/**< factor to change the feasibility tolerance when testing the best
410 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) */
414 SCIP_Real num_pseudocosteps; /**< minimal variable distance value to use for pseudo cost updates */
415 SCIP_Real num_pseudocostdelta;/**< minimal objective distance value to use for pseudo cost updates */
420 SCIP_Real num_relaxfeastol; /**< primal feasibility tolerance for relaxations (set by core or plugins, not a parameter) */
423 SCIP_Real presol_abortfac; /**< abort presolve, if l.t. this frac of the problem was changed in last round */
426 SCIP_Real presol_clqtablefac; /**< limit on number of entries in clique table relative to number of problem nonzeros */
427 SCIP_Real presol_restartfac; /**< fraction of integer variables that were fixed in the root node
429 SCIP_Real presol_immrestartfac;/**< fraction of integer variables that were fixed in the root node triggering an
431 SCIP_Real presol_subrestartfac;/**< fraction of integer variables that were globally fixed during the
433 SCIP_Real presol_restartminred;/**< minimal fraction of integer variables removed after restart to allow for
439 SCIP_Real price_abortfac; /**< pricing is aborted, if fac * maxpricevars pricing candidates were found */
442 SCIP_Bool price_delvars; /**< should variables created at the current node be deleted when the node is solved
444 SCIP_Bool price_delvarsroot; /**< should variables created at the root node be deleted when the root is solved
448 SCIP_Bool decomp_benderslabels; /**< should the variables be labeled for the application of Benders'
450 SCIP_Bool decomp_applybenders; /**< if a decomposition exists, should Benders' decomposition be applied*/
451 int decomp_maxgraphedge; /**< maximum number of edges in block graph computation, or -1 for no limit */
454 SCIP_Real benders_soltol; /**< the tolerance for checking optimality in Benders' decomposition */
455 SCIP_Bool benders_cutlpsol; /**< should cuts be generated from the solution to the LP relaxation? */
460 int prop_maxroundsroot; /**< maximal number of propagation rounds in the root node (-1: unlimited) */
461 SCIP_Bool prop_abortoncutoff; /**< should propagation be aborted immediately? setting this to FALSE could
465 SCIP_Real reopt_objsimsol; /**< similarity of two objective functions to reuse stored solutions. */
466 SCIP_Real reopt_objsimrootlp; /**< similarity of two sequential objective function to disable solving the
469 SCIP_Real reopt_objsimdelay; /**< minimum similarity for using reoptimization of the search tree. */
470 char reopt_varorderinterdiction; /** use the 'd'efault or a 'r'andom variable order for interdiction
477 int reopt_maxdiffofnodes;/**< maximal number of bound changes between two stored nodes on one path */
491 SCIP_Bool reopt_shrinkinner; /**< replace branched inner nodes by their child nodes, if the number of
494 SCIP_Bool reopt_sepaglbinfsubtrees;/**< save global constraints to separate infeasible subtrees */
495 SCIP_Bool reopt_sepabestsol; /**< separate only the best solution, i.e., for constrained shortest path */
496 SCIP_Bool reopt_storevarhistory;/**< use variable history of the previous solve if the objective function
499 SCIP_Bool reopt_usepscost; /**< reuse pseudo costs if the objective function changed only slightly */
501 SCIP_Bool reopt_usesplitcons; /**< use constraints to reconstruct the subtree pruned be dual reduction
506 SCIP_Real sepa_maxbounddist; /**< maximal relative distance from current node's dual bound to primal bound
509 SCIP_Real sepa_maxlocalbounddist;/**< maximal relative distance from current node's dual bound to primal bound
512 SCIP_Real sepa_maxcoefratio; /**< maximal ratio between coefficients in strongcg, cmir, and flowcover cuts */
514 SCIP_Real sepa_minefficacyroot; /**< minimal efficacy for a cut to enter the LP in the root node */
516 SCIP_Real sepa_minorthoroot; /**< minimal orthogonality for a cut to enter the LP in the root node */
518 SCIP_Real sepa_dircutoffdistfac;/**< factor to scale directed cutoff distance of cut in score calc. */
520 SCIP_Real sepa_intsupportfac; /**< factor to scale integral support of cut in score calculation */
521 SCIP_Real sepa_minactivityquot; /**< minimum cut activity quotient to convert cuts into constraints
523 char sepa_orthofunc; /**< function used for calc. scalar prod. in orthogonality test ('e'uclidean, 'd'iscrete) */
524 char sepa_efficacynorm; /**< row norm to use for efficacy calculation ('e'uclidean, 'm'aximum, 's'um,
528 int sepa_maxruns; /**< maximal number of runs for which separation is enabled (-1: unlimited) */
530 int sepa_maxroundsroot; /**< maximal number of separation rounds in the root node (-1: unlimited) */
531 int sepa_maxroundsrootsubrun; /**< maximal number of separation rounds in the root node of a subsequent run (-1: unlimited) */
532 int sepa_maxaddrounds; /**< maximal additional number of separation rounds in subsequent price-and-cut
536 int sepa_maxstallroundsroot;/**< maximal number of consecutive separation rounds without objective
540 int sepa_cutagelimit; /**< maximum age a cut can reach before it is deleted from the global cut pool */
551 SCIP_Bool concurrent_changechildsel; /**< change the child selection rule in different solvers? */
552 SCIP_Bool concurrent_commvarbnds; /**< should the concurrent solvers communicate global variable bound changes? */
553 SCIP_Bool concurrent_presolvebefore; /**< should the problem be presolved before it is copied to the concurrent solvers? */
557 SCIP_Real concurrent_freqfactor; /**< factor by which the frequency of synchronization changes */
558 SCIP_Real concurrent_targetprogress; /**< when adapting the synchronization frequency this value is the targeted
560 int concurrent_maxnsols; /**< maximum number of solutions that will get stored in one synchronization */
561 int concurrent_nbestsols; /**< number of best solutions that should be considered for synchronization */
564 char* concurrent_paramsetprefix; /**< path prefix for parameter setting files of concurrent solver scip-custom */
570 SCIP_Bool time_rareclockcheck;/**< should clock checks of solving time be performed less frequently (might exceed time limit slightly) */
574 SCIP_Bool compr_enable; /**< should automatic tree compression after presolving be enabled? (only for reoptimization) */
578 char* visual_vbcfilename; /**< name of the VBC tool output file, or - if no VBC output should be created */
579 char* visual_bakfilename; /**< name of the BAK tool output file, or - if no BAK output should be created */
580 SCIP_Bool visual_realtime; /**< should the real solving time be used instead of time step counter in visualization? */
592 SCIP_Bool write_allconss; /**< should all constraints be written (including the redundant constraints)? */
type definitions for global SCIP settings
type definitions for presolvers
message output methods
type definitions for branching rules
type definitions for variable pricers
type definitions for primal heuristics
type definitions for SCIP's main datastructure
type definitions for bandit selection algorithms
type definitions for relaxators
type definitions for conflict analysis
type definitions for managing events
type definitions for input file readers
methods for debugging
type definitions for Benders' decomposition methods
type definitions for clocks and timing issues
type definitions for propagators
type definitions for tree compression
type definitions for separators
type definitions for handling parameter settings
type definitions for user interface dialog
common defines and data types used in all packages of SCIP
type definitions for node selectors
type definitions for displaying statistics tables
type definitions for constraints and constraint handlers
type definitions for specific NLP solver interfaces
type definitions for concurrent solvers
type definitions for displaying runtime statistics