Go to the documentation of this file.
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"
62 #include "scip/type_concsolver.h"
63 #include "scip/type_benders.h"
64 #include "scip/type_expr.h"
65 #include "scip/debug.h"
78 BMS_BUFMEM* cleanbuffer; /**< memory buffers for short living temporary objects init. to all zero */
110 SCIP_BENDERS** benders; /**< the data structures managing the Benders' decomposition algorithm */
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
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? */
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) */
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 */
220 int conf_interconss; /**< maximal number of intermediate conflict constraints generated in conflict
225 int conf_reconvlevels; /**< number of depth levels up to which UIP reconvergence constraints are
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) */
236 SCIP_Bool conf_usesb; /**< should infeasible/bound exceeding strong branching conflict analysis be
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
244 SCIP_Bool conf_repropagate; /**< should earlier nodes be repropagated in order to replace branching
246 SCIP_Bool conf_keepreprop; /**< should constraints be kept for repropagation even if they are too long? */
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 */
259 int conf_maxvarsdetectimpliedbounds;/**< maximal number of variables to try to detect global bound
263 SCIP_Bool conf_fullshortenconflict;/**< try to shorten the whole conflict set or terminate early
266 SCIP_Real conf_conflictweight;/**< the weight the VSIDS score is weight by updating the VSIDS for a
269 SCIP_Real conf_conflictgraphweight; /**< the weight the VSIDS score is weight by updating the VSIDS for a
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 */
276 SCIP_Real conf_minimprove; /**< minimal improvement of primal bound to remove conflicts depending on
292 int disp_headerfreq; /**< frequency for displaying header lines (every n'th node information line) */
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? */
298 SCIP_Bool heur_useuctsubscip; /**< should setting of common subscip parameters include the activation of the UCT node selector? */
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? */
309 SCIP_Real limit_absgap; /**< solving stops, if the absolute difference between primal and dual bound
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
315 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_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) */
330 char lp_initalgorithm; /**< LP algorithm for solving initial LP relaxations ('s'implex, 'b'arrier,
332 char lp_resolvealgorithm;/**< LP algorithm for resolving LP relaxations if a starting basis exists
336 SCIP_Bool lp_clearinitialprobinglp;/**< should lp state be cleared at the end of probing mode when LP
338 SCIP_Bool lp_resolverestore; /**< should the LP be resolved to restore the state at start of diving (if
340 SCIP_Bool lp_freesolvalbuffers; /**< should the buffers for storing LP solution values during diving be
347 SCIP_Bool lp_cleanupcolsroot; /**< should new non-basic columns be removed after root LP solving? */
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? */
356 int lp_fastmip; /**< which FASTMIP setting of LP solver should be used? 0: off, 1: medium, 2: full */
360 SCIP_Bool lp_lexdualrootonly; /**< should the lexicographic dual algorithm be applied only at the root node */
362 SCIP_Bool lp_lexdualbasic; /**< choose fractional basic variables in lexicographic dual algorithm */
364 int lp_disablecutoff; /**< disable the cutoff bound in the LP solver? (0: enabled, 1: disabled, 2: auto) */
368 SCIP_Real lp_resolveiterfac; /**< factor of average LP iterations that is used as LP iteration limit
371 int lp_solutionpolishing;/**< LP solution polishing method (0: disabled, 1: only root, 2: always, 3: auto) */
373 SCIP_Bool lp_alwaysgetduals; /**< should the dual solution always be collected for LP solutions. */
376 SCIP_Bool nlp_disable; /**< should the NLP be disabled even if a constraint handler enabled it? */
380 SCIP_Real mem_savefac; /**< fraction of maximal memory usage resulting in switch to memory saving mode */
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
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? */
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
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? */
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
416 SCIP_Bool misc_showdivingstats;/**< should detailed statistics for diving heuristics be shown? */
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
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)? */
427 char nodesel_childsel; /**< child selection rule ('d'own, 'u'p, 'p'seudo costs, 'i'nference, 'l'p value,
435 SCIP_Real num_checkfeastolfac;/**< factor to change the feasibility tolerance when testing the best
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) */
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 */
447 SCIP_Real num_relaxfeastol; /**< primal feasibility tolerance for relaxations (set by core or plugins, not a parameter) */
450 SCIP_Real presol_abortfac; /**< abort presolve, if l.t. this frac of the problem was changed in last round */
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
456 SCIP_Real presol_immrestartfac;/**< fraction of integer variables that were fixed in the root node triggering an
458 SCIP_Real presol_subrestartfac;/**< fraction of integer variables that were globally fixed during the
460 SCIP_Real presol_restartminred;/**< minimal fraction of integer variables removed after restart to allow for
466 SCIP_Real price_abortfac; /**< pricing is aborted, if fac * maxpricevars pricing candidates were found */
469 SCIP_Bool price_delvars; /**< should variables created at the current node be deleted when the node is solved
471 SCIP_Bool price_delvarsroot; /**< should variables created at the root node be deleted when the root is solved
475 SCIP_Bool decomp_benderslabels; /**< should the variables be labeled for the application of Benders'
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) */
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? */
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
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
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
505 int reopt_maxdiffofnodes;/**< maximal number of bound changes between two stored nodes on one path */
519 SCIP_Bool reopt_shrinkinner; /**< replace branched inner nodes by their child nodes, if the number of
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
527 SCIP_Bool reopt_usepscost; /**< reuse pseudo costs if the objective function changed only slightly */
529 SCIP_Bool reopt_usesplitcons; /**< use constraints to reconstruct the subtree pruned be dual reduction
534 SCIP_Real sepa_maxbounddist; /**< maximal relative distance from current node's dual bound to primal bound
537 SCIP_Real sepa_maxlocalbounddist;/**< maximal relative distance from current node's dual bound to primal bound
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 */
543 SCIP_Real sepa_minefficacyroot; /**< minimal efficacy for a cut to enter the LP in the root node */
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
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,
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) */
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
562 int sepa_maxstallroundsroot;/**< maximal number of consecutive separation rounds without objective
566 int sepa_cutagelimit; /**< maximum age a cut can reach before it is deleted from the global cut pool */
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? */
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
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 */
590 char* concurrent_paramsetprefix; /**< path prefix for parameter setting files of concurrent solver scip-custom */
596 SCIP_Bool time_rareclockcheck;/**< should clock checks of solving time be performed less frequently (might exceed time limit slightly) */
601 SCIP_Bool compr_enable; /**< should automatic tree compression after presolving be enabled? (only for reoptimization) */
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? */
619 SCIP_Bool write_allconss; /**< should all constraints be written (including the redundant constraints)? */
type definitions for cut selectors
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 and macro definitions related to algebraic expressions
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 NLP solver interfaces
type definitions for concurrent solvers
type definitions for displaying runtime statistics