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 */
170 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 */
171 SCIP_Real branch_scorefac; /**< branching score factor to weigh downward and upward gain prediction
174 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 */
175 char branch_lpgainnorm; /**< strategy for normalizing LP gain when updating pseudo costs of continuous variables */
176 SCIP_Bool branch_delaypscost; /**< whether to delay pseudo costs updates for continuous variables to after separation */
177 SCIP_Bool branch_divingpscost;/**< should pseudo costs be updated also in diving and probing mode? */
180 SCIP_Bool branch_checksbsol; /**< should LP solutions during strong branching with propagation be checked for feasibility? */
181 SCIP_Bool branch_roundsbsol; /**< should LP solutions during strong branching with propagation be rounded? (only when checksbsol=TRUE) */
182 SCIP_Bool branch_sumadjustscore; /**< score adjustment near zero by \b adding epsilon (TRUE) or using maximum (FALSE) */
185 SCIP_Real conf_maxvarsfac; /**< maximal fraction of variables involved in a conflict constraint */
186 int conf_minmaxvars; /**< minimal absolute maximum of variables involved in a conflict constraint */
193 int conf_interconss; /**< maximal number of intermediate conflict constraints generated in conflict
198 int conf_reconvlevels; /**< number of depth levels up to which UIP reconvergence constraints are
201 SCIP_Bool conf_cleanbnddepend;/**< should conflicts related to an old cutoff bound be removed? */
202 SCIP_Bool conf_useprop; /**< should propagation conflict analysis be used? (uses conflict graph only) */
209 SCIP_Bool conf_usesb; /**< should infeasible/bound exceeding strong branching conflict analysis be
214 SCIP_Bool conf_allowlocal; /**< should conflict constraints be generated that are only valid locally? */
215 SCIP_Bool conf_settlelocal; /**< should conflict constraints be attached only to the local subtree where
217 SCIP_Bool conf_repropagate; /**< should earlier nodes be repropagated in order to replace branching
219 SCIP_Bool conf_keepreprop; /**< should constraints be kept for repropagation even if they are too long? */
222 SCIP_Bool conf_removable; /**< should the conflict's relaxations be subject to LP aging and cleanup? */
223 SCIP_Real conf_depthscorefac; /**< score factor for depth level in bound relaxation heuristic */
224 SCIP_Real conf_proofscorefac; /**< score factor for contribution to infeasibility proof in bound relaxation heuristic */
225 SCIP_Real conf_uplockscorefac;/**< score factor for number of up locks in bound relaxation heuristic */
226 SCIP_Real conf_downlockscorefac;/**< score factor for number of down locks in bound relaxation heuristic */
227 SCIP_Real conf_scorefac; /**< factor to decrease importance of variables' earlier conflict scores */
232 int conf_maxvarsdetectimpliedbounds;/**< maximal number of variables to try to detect global bound
236 SCIP_Bool conf_fullshortenconflict;/**< try to shorten the whole conflict set or terminate early
239 SCIP_Real conf_conflictweight;/**< the weight the VSIDS score is weight by updating the VSIDS for a
242 SCIP_Real conf_conflictgraphweight; /**< the weight the VSIDS score is weight by updating the VSIDS for a
246 SCIP_Real conf_weightrepropdepth;/**< weight of the prepropagtion depth of a conflict used in score calculation */
247 SCIP_Real conf_weightvaliddepth;/**< weight of the valid depth of a conflict used in score calculation */
249 SCIP_Real conf_minimprove; /**< minimal improvement of primal bound to remove conflicts depending on
264 int disp_headerfreq; /**< frequency for displaying header lines (every n'th node information line) */
266 SCIP_Bool disp_allviols; /**< display all violations of the best solution after the solving process finished? */
267 SCIP_Bool disp_relevantstats; /**< should the relevant statistics be displayed at the end of solving? */
270 SCIP_Bool history_valuebased; /**< should statistics be collected for variable domain value pairs? */
271 SCIP_Bool history_allowmerge; /**< should variable histories be merged from sub-SCIPs whenever possible? */
272 SCIP_Bool history_allowtransfer; /**< should variable histories be transferred to initialize SCIP copies? */
278 SCIP_Real limit_absgap; /**< solving stops, if the absolute difference between primal and dual bound
281 SCIP_Longint limit_totalnodes; /**< maximal number of total nodes (incl. restarts) to process (-1: no limit) */
282 SCIP_Longint limit_stallnodes; /**< solving stops, if the given number of nodes was processed since the
284 int limit_solutions; /**< solving stops, if the given number of solutions were found (-1: no limit) */
288 int limit_maxorigsol; /**< maximal number of solutions candidates to store in the solution storage of the original problem */
289 int limit_restarts; /**< solving stops, if the given number of restarts was triggered (-1: no limit) */
299 char lp_initalgorithm; /**< LP algorithm for solving initial LP relaxations ('s'implex, 'b'arrier,
301 char lp_resolvealgorithm;/**< LP algorithm for resolving LP relaxations if a starting basis exists
305 SCIP_Bool lp_clearinitialprobinglp;/**< should lp state be cleared at the end of probing mode when LP
307 SCIP_Bool lp_resolverestore; /**< should the LP be resolved to restore the state at start of diving (if
309 SCIP_Bool lp_freesolvalbuffers; /**< should the buffers for storing LP solution values during diving be
316 SCIP_Bool lp_cleanupcolsroot; /**< should new non-basic columns be removed after root LP solving? */
320 SCIP_Real lp_conditionlimit; /**< maximum condition number of LP basis counted as stable (-1.0: no check) */
321 SCIP_Bool lp_checkprimfeas; /**< should LP solutions be checked for primal feasibility, resolving LP when numerical troubles occur? */
322 SCIP_Bool lp_checkdualfeas; /**< should LP solutions be checked for dual feasibility, resolving LP when numerical troubles occur? */
324 int lp_fastmip; /**< which FASTMIP setting of LP solver should be used? 0: off, 1: medium, 2: full */
328 SCIP_Bool lp_lexdualrootonly; /**< should the lexicographic dual algorithm be applied only at the root node */
330 SCIP_Bool lp_lexdualbasic; /**< choose fractional basic variables in lexicographic dual algorithm */
332 int lp_disablecutoff; /**< disable the cutoff bound in the LP solver? (0: enabled, 1: disabled, 2: auto) */
336 SCIP_Real lp_resolveiterfac; /**< factor of average LP iterations that is used as LP iteration limit
339 int lp_solutionpolishing;/**< LP solution polishing method (0: disabled, 1: only root, 2: always, 3: auto) */
341 SCIP_Bool lp_alwaysgetduals; /**< should the dual solution always be collected for LP solutions. */
344 SCIP_Bool nlp_disable; /**< should the NLP be disabled even if a constraint handler enabled it? */
348 SCIP_Real mem_savefac; /**< fraction of maximal memory usage resulting in switch to memory saving mode */
358 SCIP_Bool misc_usevartable; /**< should a hashtable be used to map from variable names to variables? */
359 SCIP_Bool misc_useconstable; /**< should a hashtable be used to map from constraint names to constraints? */
360 SCIP_Bool misc_usesmalltables;/**< should smaller hashtables be used? yields better performance for small problems with about 100 variables */
361 SCIP_Bool misc_exactsolve; /**< should the problem be solved exactly (with proven dual bounds)? */
362 SCIP_Bool misc_resetstat; /**< should the statistics be reset if the transformed problem is freed
366 SCIP_Bool misc_improvingsols; /**< should only solutions be checked which improve the primal bound */
367 SCIP_Bool misc_printreason; /**< should the reason be printed if a given start solution is infeasible? */
369 SCIP_Bool misc_transorigsols; /**< should SCIP try to transfer original solutions to the transformed space (after presolving)? */
370 SCIP_Bool misc_transsolsorig; /**< should SCIP try to transfer transformed solutions to the original space (after solving)? */
371 SCIP_Bool misc_calcintegral; /**< should SCIP calculate the primal dual integral value which may require
373 SCIP_Bool misc_finitesolstore;/**< should SCIP try to remove infinite fixings from solutions copied to the solution store? */
374 SCIP_Bool misc_outputorigsol; /**< should the best solution be transformed to the orignal space and be output in command line run? */
375 SCIP_Bool misc_allowdualreds; /**< should dual reductions in propagation methods and presolver be allowed? */
376 SCIP_Bool misc_allowobjprop; /**< should propagation to the current objective be allowed in propagation methods? */
378 int misc_usesymmetry; /**< used symmetry handling technique (0: off; 1: polyhedral; 2: orbital fixing) */
383 int random_randomseedshift;/**< global shift of all random seeds in the plugins, this will have no impact on the permutation and LP seeds */
384 int random_permutationseed;/**< seed value for permuting the problem after reading/transformation
386 int random_randomseed; /**< random seed for LP solver, e.g. for perturbations in the simplex (0: LP default) */
387 SCIP_Bool random_permuteconss; /**< should order of constraints be permuted (depends on permutationseed)? */
388 SCIP_Bool random_permutevars; /**< should order of variables be permuted (depends on permutationseed)? */
391 char nodesel_childsel; /**< child selection rule ('d'own, 'u'p, 'p'seudo costs, 'i'nference, 'l'p value,
399 SCIP_Real num_checkfeastolfac;/**< factor to change the feasibility tolerance when testing the best
401 SCIP_Real num_lpfeastol; /**< primal feasibility tolerance of LP solver (user parameter, see also num_relaxfeastol) */
405 SCIP_Real num_pseudocosteps; /**< minimal variable distance value to use for pseudo cost updates */
406 SCIP_Real num_pseudocostdelta;/**< minimal objective distance value to use for pseudo cost updates */
411 SCIP_Real num_relaxfeastol; /**< primal feasibility tolerance for relaxations (set by core or plugins, not a parameter) */
414 SCIP_Real presol_abortfac; /**< abort presolve, if l.t. this frac of the problem was changed in last round */
417 SCIP_Real presol_restartfac; /**< fraction of integer variables that were fixed in the root node
419 SCIP_Real presol_immrestartfac;/**< fraction of integer variables that were fixed in the root node triggering an
421 SCIP_Real presol_subrestartfac;/**< fraction of integer variables that were globally fixed during the
423 SCIP_Real presol_restartminred;/**< minimal fraction of integer variables removed after restart to allow for
429 SCIP_Real price_abortfac; /**< pricing is aborted, if fac * maxpricevars pricing candidates were found */
432 SCIP_Bool price_delvars; /**< should variables created at the current node be deleted when the node is solved
434 SCIP_Bool price_delvarsroot; /**< should variables created at the root node be deleted when the root is solved
437 SCIP_Real benders_soltol; /**< the tolerance for checking optimality in Benders' decomposition */
438 SCIP_Bool benders_cutlpsol; /**< should cuts be generated from the solution to the LP relaxation? */
443 int prop_maxroundsroot; /**< maximal number of propagation rounds in the root node (-1: unlimited) */
444 SCIP_Bool prop_abortoncutoff; /**< should propagation be aborted immediately? setting this to FALSE could
448 SCIP_Real reopt_objsimsol; /**< similarity of two objective functions to reuse stored solutions. */
449 SCIP_Real reopt_objsimrootlp; /**< similarity of two sequential objective function to disable solving the
452 SCIP_Real reopt_objsimdelay; /**< minimum similarity for using reoptimization of the search tree. */
453 char reopt_varorderinterdiction; /** use the 'd'efault or a 'r'andom variable order for interdiction
460 int reopt_maxdiffofnodes;/**< maximal number of bound changes between two stored nodes on one path */
474 SCIP_Bool reopt_shrinkinner; /**< replace branched inner nodes by their child nodes, if the number of
477 SCIP_Bool reopt_sepaglbinfsubtrees;/**< save global constraints to separate infeasible subtrees */
478 SCIP_Bool reopt_sepabestsol; /**< separate only the best solution, i.e., for constrained shortest path */
479 SCIP_Bool reopt_storevarhistory;/**< use variable history of the previous solve if the objective function
482 SCIP_Bool reopt_usepscost; /**< reuse pseudo costs if the objective function changed only slightly */
484 SCIP_Bool reopt_usesplitcons; /**< use constraints to reconstruct the subtree pruned be dual reduction
489 SCIP_Real sepa_maxbounddist; /**< maximal relative distance from current node's dual bound to primal bound
492 SCIP_Real sepa_maxlocalbounddist;/**< maximal relative distance from current node's dual bound to primal bound
495 SCIP_Real sepa_maxcoefratio; /**< maximal ratio between coefficients in strongcg, cmir, and flowcover cuts */
497 SCIP_Real sepa_minefficacyroot; /**< minimal efficacy for a cut to enter the LP in the root node */
499 SCIP_Real sepa_minorthoroot; /**< minimal orthogonality for a cut to enter the LP in the root node */
501 SCIP_Real sepa_dircutoffdistfac;/**< factor to scale directed cutoff distance of cut in score calc. */
503 SCIP_Real sepa_intsupportfac; /**< factor to scale integral support of cut in score calculation */
504 SCIP_Real sepa_minactivityquot; /**< minimum cut activity quotient to convert cuts into constraints
506 char sepa_orthofunc; /**< function used for calc. scalar prod. in orthogonality test ('e'uclidean, 'd'iscrete) */
507 char sepa_efficacynorm; /**< row norm to use for efficacy calculation ('e'uclidean, 'm'aximum, 's'um,
511 int sepa_maxruns; /**< maximal number of runs for which separation is enabled (-1: unlimited) */
513 int sepa_maxroundsroot; /**< maximal number of separation rounds in the root node (-1: unlimited) */
514 int sepa_maxroundsrootsubrun; /**< maximal number of separation rounds in the root node of a subsequent run (-1: unlimited) */
515 int sepa_maxaddrounds; /**< maximal additional number of separation rounds in subsequent price-and-cut
519 int sepa_maxstallroundsroot;/**< maximal number of consecutive separation rounds without objective
523 int sepa_cutagelimit; /**< maximum age a cut can reach before it is deleted from the global cut pool */
534 SCIP_Bool concurrent_changechildsel; /**< change the child selection rule in different solvers? */
535 SCIP_Bool concurrent_commvarbnds; /**< should the concurrent solvers communicate global variable bound changes? */
536 SCIP_Bool concurrent_presolvebefore; /**< should the problem be presolved before it is copied to the concurrent solvers? */
540 SCIP_Real concurrent_freqfactor; /**< factor by which the frequency of synchronization changes */
541 SCIP_Real concurrent_targetprogress; /**< when adapting the synchronization frequency this value is the targeted
543 int concurrent_maxnsols; /**< maximum number of solutions that will get stored in one synchronization */
544 int concurrent_nbestsols; /**< number of best solutions that should be considered for synchronization */
547 char* concurrent_paramsetprefix; /**< path prefix for parameter setting files of concurrent solver scip-custom */
553 SCIP_Bool time_rareclockcheck;/**< should clock checks of solving time be performed less frequently (might exceed time limit slightly) */
557 SCIP_Bool compr_enable; /**< should automatic tree compression after presolving be enabled? (only for reoptimization) */
561 char* visual_vbcfilename; /**< name of the VBC tool output file, or - if no VBC output should be created */
562 char* visual_bakfilename; /**< name of the BAK tool output file, or - if no BAK output should be created */
563 SCIP_Bool visual_realtime; /**< should the real solving time be used instead of time step counter in visualization? */
575 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