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_cutsel.h"
50 #include "scip/type_table.h"
51 #include "scip/type_prop.h"
52 #include "scip/type_nlpi.h"
53 #include "scip/type_concsolver.h"
54 #include "scip/type_benders.h"
55 #include "scip/type_expr.h"
56 #include "scip/debug.h"
69 BMS_BUFMEM* cleanbuffer; /**< memory buffers for short living temporary objects init. to all zero */
101 SCIP_BENDERS** benders; /**< the data structures managing the Benders' decomposition algorithm */
186 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 */
187 SCIP_Real branch_scorefac; /**< branching score factor to weigh downward and upward gain prediction
190 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 */
191 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 */
192 SCIP_Real branch_midpullreldomtrig; /**< multiply midpull by relative domain width if the latter is below this value */
193 char branch_lpgainnorm; /**< strategy for normalizing LP gain when updating pseudo costs of continuous variables */
194 SCIP_Bool branch_delaypscost; /**< whether to delay pseudo costs updates for continuous variables to after separation */
195 SCIP_Bool branch_divingpscost;/**< should pseudo costs be updated also in diving and probing mode? */
198 SCIP_Bool branch_checksbsol; /**< should LP solutions during strong branching with propagation be checked for feasibility? */
199 SCIP_Bool branch_roundsbsol; /**< should LP solutions during strong branching with propagation be rounded? (only when checksbsol=TRUE) */
200 SCIP_Bool branch_sumadjustscore; /**< score adjustment near zero by \b adding epsilon (TRUE) or using maximum (FALSE) */
203 SCIP_Real conf_maxvarsfac; /**< maximal fraction of variables involved in a conflict constraint */
204 int conf_minmaxvars; /**< minimal absolute maximum of variables involved in a conflict constraint */
211 int conf_interconss; /**< maximal number of intermediate conflict constraints generated in conflict
216 int conf_reconvlevels; /**< number of depth levels up to which UIP reconvergence constraints are
219 SCIP_Bool conf_cleanbnddepend;/**< should conflicts related to an old cutoff bound be removed? */
220 SCIP_Bool conf_useprop; /**< should propagation conflict analysis be used? (uses conflict graph only) */
227 SCIP_Bool conf_usesb; /**< should infeasible/bound exceeding strong branching conflict analysis be
232 SCIP_Bool conf_allowlocal; /**< should conflict constraints be generated that are only valid locally? */
233 SCIP_Bool conf_settlelocal; /**< should conflict constraints be attached only to the local subtree where
235 SCIP_Bool conf_repropagate; /**< should earlier nodes be repropagated in order to replace branching
237 SCIP_Bool conf_keepreprop; /**< should constraints be kept for repropagation even if they are too long? */
240 SCIP_Bool conf_removable; /**< should the conflict's relaxations be subject to LP aging and cleanup? */
241 SCIP_Real conf_depthscorefac; /**< score factor for depth level in bound relaxation heuristic */
242 SCIP_Real conf_proofscorefac; /**< score factor for contribution to infeasibility proof in bound relaxation heuristic */
243 SCIP_Real conf_uplockscorefac;/**< score factor for number of up locks in bound relaxation heuristic */
244 SCIP_Real conf_downlockscorefac;/**< score factor for number of down locks in bound relaxation heuristic */
245 SCIP_Real conf_scorefac; /**< factor to decrease importance of variables' earlier conflict scores */
250 int conf_maxvarsdetectimpliedbounds;/**< maximal number of variables to try to detect global bound
254 SCIP_Bool conf_fullshortenconflict;/**< try to shorten the whole conflict set or terminate early
257 SCIP_Real conf_conflictweight;/**< the weight the VSIDS score is weight by updating the VSIDS for a
260 SCIP_Real conf_conflictgraphweight; /**< the weight the VSIDS score is weight by updating the VSIDS for a
264 SCIP_Real conf_weightrepropdepth;/**< weight of the prepropagtion depth of a conflict used in score calculation */
265 SCIP_Real conf_weightvaliddepth;/**< weight of the valid depth of a conflict used in score calculation */
267 SCIP_Real conf_minimprove; /**< minimal improvement of primal bound to remove conflicts depending on
283 int disp_headerfreq; /**< frequency for displaying header lines (every n'th node information line) */
285 SCIP_Bool disp_allviols; /**< display all violations of the best solution after the solving process finished? */
286 SCIP_Bool disp_relevantstats; /**< should the relevant statistics be displayed at the end of solving? */
289 SCIP_Bool heur_useuctsubscip; /**< should setting of common subscip parameters include the activation of the UCT node selector? */
292 SCIP_Bool history_valuebased; /**< should statistics be collected for variable domain value pairs? */
293 SCIP_Bool history_allowmerge; /**< should variable histories be merged from sub-SCIPs whenever possible? */
294 SCIP_Bool history_allowtransfer; /**< should variable histories be transferred to initialize SCIP copies? */
300 SCIP_Real limit_absgap; /**< solving stops, if the absolute difference between primal and dual bound
303 SCIP_Longint limit_totalnodes; /**< maximal number of total nodes (incl. restarts) to process (-1: no limit) */
304 SCIP_Longint limit_stallnodes; /**< solving stops, if the given number of nodes was processed since the
306 int limit_solutions; /**< solving stops, if the given number of solutions were found (-1: no limit) */
310 int limit_maxorigsol; /**< maximal number of solutions candidates to store in the solution storage of the original problem */
311 int limit_restarts; /**< solving stops, if the given number of restarts was triggered (-1: no limit) */
321 char lp_initalgorithm; /**< LP algorithm for solving initial LP relaxations ('s'implex, 'b'arrier,
323 char lp_resolvealgorithm;/**< LP algorithm for resolving LP relaxations if a starting basis exists
327 SCIP_Bool lp_clearinitialprobinglp;/**< should lp state be cleared at the end of probing mode when LP
329 SCIP_Bool lp_resolverestore; /**< should the LP be resolved to restore the state at start of diving (if
331 SCIP_Bool lp_freesolvalbuffers; /**< should the buffers for storing LP solution values during diving be
338 SCIP_Bool lp_cleanupcolsroot; /**< should new non-basic columns be removed after root LP solving? */
342 SCIP_Real lp_conditionlimit; /**< maximum condition number of LP basis counted as stable (-1.0: no check) */
343 SCIP_Real lp_markowitz; /**< minimal Markowitz threshold to control sparsity/stability in LU factorization */
344 SCIP_Bool lp_checkprimfeas; /**< should LP solutions be checked for primal feasibility, resolving LP when numerical troubles occur? */
345 SCIP_Bool lp_checkdualfeas; /**< should LP solutions be checked for dual feasibility, resolving LP when numerical troubles occur? */
347 int lp_fastmip; /**< which FASTMIP setting of LP solver should be used? 0: off, 1: medium, 2: full */
351 SCIP_Bool lp_lexdualrootonly; /**< should the lexicographic dual algorithm be applied only at the root node */
353 SCIP_Bool lp_lexdualbasic; /**< choose fractional basic variables in lexicographic dual algorithm */
355 int lp_disablecutoff; /**< disable the cutoff bound in the LP solver? (0: enabled, 1: disabled, 2: auto) */
359 SCIP_Real lp_resolveiterfac; /**< factor of average LP iterations that is used as LP iteration limit
362 int lp_solutionpolishing;/**< LP solution polishing method (0: disabled, 1: only root, 2: always, 3: auto) */
364 SCIP_Bool lp_alwaysgetduals; /**< should the dual solution always be collected for LP solutions. */
367 SCIP_Bool nlp_disable; /**< should the NLP be disabled even if a constraint handler enabled it? */
371 SCIP_Real mem_savefac; /**< fraction of maximal memory usage resulting in switch to memory saving mode */
381 SCIP_Bool misc_usevartable; /**< should a hashtable be used to map from variable names to variables? */
382 SCIP_Bool misc_useconstable; /**< should a hashtable be used to map from constraint names to constraints? */
383 SCIP_Bool misc_usesmalltables;/**< should smaller hashtables be used? yields better performance for small problems with about 100 variables */
384 SCIP_Bool misc_exactsolve; /**< should the problem be solved exactly (with proven dual bounds)? */
385 SCIP_Bool misc_resetstat; /**< should the statistics be reset if the transformed problem is freed
389 SCIP_Bool misc_improvingsols; /**< should only solutions be checked which improve the primal bound */
390 SCIP_Bool misc_printreason; /**< should the reason be printed if a given start solution is infeasible? */
392 SCIP_Bool misc_avoidmemout; /**< try to avoid running into memory limit by restricting plugins like heuristics? */
393 SCIP_Bool misc_transorigsols; /**< should SCIP try to transfer original solutions to the transformed space (after presolving)? */
394 SCIP_Bool misc_transsolsorig; /**< should SCIP try to transfer transformed solutions to the original space (after solving)? */
395 SCIP_Bool misc_calcintegral; /**< should SCIP calculate the primal dual integral value which may require
397 SCIP_Bool misc_finitesolstore;/**< should SCIP try to remove infinite fixings from solutions copied to the solution store? */
398 SCIP_Bool misc_outputorigsol; /**< should the best solution be transformed to the orignal space and be output in command line run? */
399 SCIP_Bool misc_allowstrongdualreds; /**< should strong dual reductions be allowed in propagation and presolving? */
400 SCIP_Bool misc_allowweakdualreds; /**< should weak dual reductions be allowed in propagation and presolving? */
402 int misc_usesymmetry; /**< bitset describing used symmetry handling technique (0: off; 1: polyhedral (orbitopes and/or symresacks);
403 * 2: orbital fixing; 3: orbitopes and orbital fixing; 4: Schreier Sims cuts; 5: Schreier Sims cuts and
409 int random_randomseedshift;/**< global shift of all random seeds in the plugins, this will have no impact on the permutation and LP seeds */
410 int random_permutationseed;/**< seed value for permuting the problem after reading/transformation
412 int random_randomseed; /**< random seed for LP solver, e.g. for perturbations in the simplex (0: LP default) */
413 SCIP_Bool random_permuteconss; /**< should order of constraints be permuted (depends on permutationseed)? */
414 SCIP_Bool random_permutevars; /**< should order of variables be permuted (depends on permutationseed)? */
417 char nodesel_childsel; /**< child selection rule ('d'own, 'u'p, 'p'seudo costs, 'i'nference, 'l'p value,
425 SCIP_Real num_checkfeastolfac;/**< factor to change the feasibility tolerance when testing the best
427 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) */
431 SCIP_Real num_pseudocosteps; /**< minimal variable distance value to use for pseudo cost updates */
432 SCIP_Real num_pseudocostdelta;/**< minimal objective distance value to use for pseudo cost updates */
437 SCIP_Real num_relaxfeastol; /**< primal feasibility tolerance for relaxations (set by core or plugins, not a parameter) */
440 SCIP_Real presol_abortfac; /**< abort presolve, if l.t. this frac of the problem was changed in last round */
443 SCIP_Real presol_clqtablefac; /**< limit on number of entries in clique table relative to number of problem nonzeros */
444 SCIP_Real presol_restartfac; /**< fraction of integer variables that were fixed in the root node
446 SCIP_Real presol_immrestartfac;/**< fraction of integer variables that were fixed in the root node triggering an
448 SCIP_Real presol_subrestartfac;/**< fraction of integer variables that were globally fixed during the
450 SCIP_Real presol_restartminred;/**< minimal fraction of integer variables removed after restart to allow for
456 SCIP_Real price_abortfac; /**< pricing is aborted, if fac * maxpricevars pricing candidates were found */
459 SCIP_Bool price_delvars; /**< should variables created at the current node be deleted when the node is solved
461 SCIP_Bool price_delvarsroot; /**< should variables created at the root node be deleted when the root is solved
465 SCIP_Bool decomp_benderslabels; /**< should the variables be labeled for the application of Benders'
467 SCIP_Bool decomp_applybenders; /**< if a decomposition exists, should Benders' decomposition be applied*/
468 int decomp_maxgraphedge; /**< maximum number of edges in block graph computation (-1: no limit, 0: disable block graph computation) */
472 SCIP_Real benders_soltol; /**< the tolerance for checking optimality in Benders' decomposition */
473 SCIP_Bool benders_cutlpsol; /**< should cuts be generated from the solution to the LP relaxation? */
478 int prop_maxroundsroot; /**< maximal number of propagation rounds in the root node (-1: unlimited) */
479 SCIP_Bool prop_abortoncutoff; /**< should propagation be aborted immediately? setting this to FALSE could
483 SCIP_Real reopt_objsimsol; /**< similarity of two objective functions to reuse stored solutions. */
484 SCIP_Real reopt_objsimrootlp; /**< similarity of two sequential objective function to disable solving the
487 SCIP_Real reopt_objsimdelay; /**< minimum similarity for using reoptimization of the search tree. */
488 char reopt_varorderinterdiction; /** use the 'd'efault or a 'r'andom variable order for interdiction
495 int reopt_maxdiffofnodes;/**< maximal number of bound changes between two stored nodes on one path */
509 SCIP_Bool reopt_shrinkinner; /**< replace branched inner nodes by their child nodes, if the number of
512 SCIP_Bool reopt_sepaglbinfsubtrees;/**< save global constraints to separate infeasible subtrees */
513 SCIP_Bool reopt_sepabestsol; /**< separate only the best solution, i.e., for constrained shortest path */
514 SCIP_Bool reopt_storevarhistory;/**< use variable history of the previous solve if the objective function
517 SCIP_Bool reopt_usepscost; /**< reuse pseudo costs if the objective function changed only slightly */
519 SCIP_Bool reopt_usesplitcons; /**< use constraints to reconstruct the subtree pruned be dual reduction
524 SCIP_Real sepa_maxbounddist; /**< maximal relative distance from current node's dual bound to primal bound
527 SCIP_Real sepa_maxlocalbounddist;/**< maximal relative distance from current node's dual bound to primal bound
530 SCIP_Real sepa_maxcoefratio; /**< maximal ratio between coefficients in strongcg, cmir, and flowcover cuts */
531 SCIP_Real sepa_maxcoefratiofacrowprep; /**< maximal ratio between coefficients (as factor of 1/feastol) to ensure in rowprep cleanup */
533 SCIP_Real sepa_minefficacyroot; /**< minimal efficacy for a cut to enter the LP in the root node */
535 SCIP_Real sepa_minorthoroot; /**< minimal orthogonality for a cut to enter the LP in the root node */
536 SCIP_Real sepa_minactivityquot; /**< minimum cut activity quotient to convert cuts into constraints
538 char sepa_orthofunc; /**< function used for calc. scalar prod. in orthogonality test ('e'uclidean, 'd'iscrete) */
539 char sepa_efficacynorm; /**< row norm to use for efficacy calculation ('e'uclidean, 'm'aximum, 's'um,
543 SCIP_Bool sepa_filtercutpoolrel; /**< should cutpool separate only cuts with high relative efficacy? */
544 int sepa_maxruns; /**< maximal number of runs for which separation is enabled (-1: unlimited) */
546 int sepa_maxroundsroot; /**< maximal number of separation rounds in the root node (-1: unlimited) */
547 int sepa_maxroundsrootsubrun; /**< maximal number of separation rounds in the root node of a subsequent run (-1: unlimited) */
548 int sepa_maxaddrounds; /**< maximal additional number of separation rounds in subsequent price-and-cut
552 int sepa_maxstallroundsroot;/**< maximal number of consecutive separation rounds without objective
556 int sepa_cutagelimit; /**< maximum age a cut can reach before it is deleted from the global cut pool */
567 SCIP_Bool concurrent_changechildsel; /**< change the child selection rule in different solvers? */
568 SCIP_Bool concurrent_commvarbnds; /**< should the concurrent solvers communicate global variable bound changes? */
569 SCIP_Bool concurrent_presolvebefore; /**< should the problem be presolved before it is copied to the concurrent solvers? */
573 SCIP_Real concurrent_freqfactor; /**< factor by which the frequency of synchronization changes */
574 SCIP_Real concurrent_targetprogress; /**< when adapting the synchronization frequency this value is the targeted
576 int concurrent_maxnsols; /**< maximum number of solutions that will get stored in one synchronization */
577 int concurrent_nbestsols; /**< number of best solutions that should be considered for synchronization */
580 char* concurrent_paramsetprefix; /**< path prefix for parameter setting files of concurrent solver scip-custom */
586 SCIP_Bool time_rareclockcheck;/**< should clock checks of solving time be performed less frequently (might exceed time limit slightly) */
591 SCIP_Bool compr_enable; /**< should automatic tree compression after presolving be enabled? (only for reoptimization) */
595 char* visual_vbcfilename; /**< name of the VBC tool output file, or - if no VBC output should be created */
596 char* visual_bakfilename; /**< name of the BAK tool output file, or - if no BAK output should be created */
597 SCIP_Bool visual_realtime; /**< should the real solving time be used instead of time step counter in visualization? */
609 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