struct_set.h
Go to the documentation of this file.
31/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
79 BMS_BUFMEM* cleanbuffer; /**< memory buffers for short living temporary objects init. to all zero */
111 SCIP_BENDERS** benders; /**< the data structures managing the Benders' decomposition algorithm */
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
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? */
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) */
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 */
221 int conf_interconss; /**< maximal number of intermediate conflict constraints generated in conflict
226 int conf_reconvlevels; /**< number of depth levels up to which UIP reconvergence constraints are
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) */
237 SCIP_Bool conf_usesb; /**< should infeasible/bound exceeding strong branching conflict analysis be
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
245 SCIP_Bool conf_repropagate; /**< should earlier nodes be repropagated in order to replace branching
247 SCIP_Bool conf_keepreprop; /**< should constraints be kept for repropagation even if they are too long? */
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 */
260 int conf_maxvarsdetectimpliedbounds;/**< maximal number of variables to try to detect global bound
264 SCIP_Bool conf_fullshortenconflict;/**< try to shorten the whole conflict set or terminate early
267 SCIP_Real conf_conflictweight;/**< the weight the VSIDS score is weight by updating the VSIDS for a
270 SCIP_Real conf_conflictgraphweight; /**< the weight the VSIDS score is weight by updating the VSIDS for a
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 */
277 SCIP_Real conf_minimprove; /**< minimal improvement of primal bound to remove conflicts depending on
293 int disp_headerfreq; /**< frequency for displaying header lines (every n'th node information line) */
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? */
299 SCIP_Bool heur_useuctsubscip; /**< should setting of common subscip parameters include the activation of the UCT node selector? */
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? */
310 SCIP_Real limit_absgap; /**< solving stops, if the absolute difference between primal and dual bound
312 SCIP_Real limit_primal; /**< solving stops, if primal bound is at least as good as given value */
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
318 int limit_solutions; /**< solving stops, if the given number of solutions were found; this limit is first checked in presolving (-1: no limit) */
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) */
332 char lp_initalgorithm; /**< LP algorithm for solving initial LP relaxations ('s'implex, 'b'arrier,
334 char lp_resolvealgorithm;/**< LP algorithm for resolving LP relaxations if a starting basis exists
338 SCIP_Bool lp_clearinitialprobinglp;/**< should lp state be cleared at the end of probing mode when LP
340 SCIP_Bool lp_resolverestore; /**< should the LP be resolved to restore the state at start of diving (if
342 SCIP_Bool lp_freesolvalbuffers; /**< should the buffers for storing LP solution values during diving be
349 SCIP_Bool lp_cleanupcolsroot; /**< should new non-basic columns be removed after root LP solving? */
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? */
358 int lp_fastmip; /**< which FASTMIP setting of LP solver should be used? 0: off, 1: medium, 2: full */
362 SCIP_Bool lp_lexdualrootonly; /**< should the lexicographic dual algorithm be applied only at the root node */
364 SCIP_Bool lp_lexdualbasic; /**< choose fractional basic variables in lexicographic dual algorithm */
366 int lp_disablecutoff; /**< disable the cutoff bound in the LP solver? (0: enabled, 1: disabled, 2: auto) */
370 SCIP_Real lp_resolveiterfac; /**< factor of average LP iterations that is used as LP iteration limit
373 int lp_solutionpolishing;/**< LP solution polishing method (0: disabled, 1: only root, 2: always, 3: auto) */
375 SCIP_Bool lp_alwaysgetduals; /**< should the dual solution always be collected for LP solutions. */
378 SCIP_Bool nlp_disable; /**< should the NLP be disabled even if a constraint handler enabled it? */
382 SCIP_Real mem_savefac; /**< fraction of maximal memory usage resulting in switch to memory saving mode */
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
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? */
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
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? */
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
418 SCIP_Bool misc_showdivingstats;/**< should detailed statistics for diving heuristics be shown? */
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
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)? */
429 char nodesel_childsel; /**< child selection rule ('d'own, 'u'p, 'p'seudo costs, 'i'nference, 'l'p value,
437 SCIP_Real num_checkfeastolfac;/**< factor to change the feasibility tolerance when testing the best
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) */
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 */
449 SCIP_Real num_relaxfeastol; /**< primal feasibility tolerance for relaxations (set by core or plugins, not a parameter) */
452 SCIP_Real presol_abortfac; /**< abort presolve, if l.t. this frac of the problem was changed in last round */
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
458 SCIP_Real presol_immrestartfac;/**< fraction of integer variables that were fixed in the root node triggering an
460 SCIP_Real presol_subrestartfac;/**< fraction of integer variables that were globally fixed during the
462 SCIP_Real presol_restartminred;/**< minimal fraction of integer variables removed after restart to allow for
468 SCIP_Real price_abortfac; /**< pricing is aborted, if fac * maxpricevars pricing candidates were found */
471 SCIP_Bool price_delvars; /**< should variables created at the current node be deleted when the node is solved
473 SCIP_Bool price_delvarsroot; /**< should variables created at the root node be deleted when the root is solved
477 SCIP_Bool decomp_benderslabels; /**< should the variables be labeled for the application of Benders'
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) */
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? */
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
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
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
507 int reopt_maxdiffofnodes;/**< maximal number of bound changes between two stored nodes on one path */
521 SCIP_Bool reopt_shrinkinner; /**< replace branched inner nodes by their child nodes, if the number of
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
529 SCIP_Bool reopt_usepscost; /**< reuse pseudo costs if the objective function changed only slightly */
531 SCIP_Bool reopt_usesplitcons; /**< use constraints to reconstruct the subtree pruned be dual reduction
536 SCIP_Real sepa_maxbounddist; /**< maximal relative distance from current node's dual bound to primal bound
539 SCIP_Real sepa_maxlocalbounddist;/**< maximal relative distance from current node's dual bound to primal bound
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 */
545 SCIP_Real sepa_minefficacyroot; /**< minimal efficacy for a cut to enter the LP in the root node */
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
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,
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) */
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
564 int sepa_maxstallroundsroot;/**< maximal number of consecutive separation rounds without objective
566 SCIP_Real sepa_maxcutsgenfactor; /**< factor w.r.t. maxcuts for maximal number of cuts generated per
568 SCIP_Real sepa_maxcutsrootgenfactor; /**< factor w.r.t. maxcutsroot for maximal number of generated cuts
572 int sepa_cutagelimit; /**< maximum age a cut can reach before it is deleted from the global cut pool */
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? */
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
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 */
596 char* concurrent_paramsetprefix; /**< path prefix for parameter setting files of concurrent solver scip-custom */
602 SCIP_Bool time_rareclockcheck;/**< should clock checks of solving time be performed less frequently (might exceed time limit slightly) */
607 SCIP_Bool compr_enable; /**< should automatic tree compression after presolving be enabled? (only for reoptimization) */
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? */
625 SCIP_Bool write_allconss; /**< should all constraints be written (including the redundant constraints)? */
methods for debugging
common defines and data types used in all packages of SCIP
message output methods
Definition: memory.c:2504
Definition: struct_bandit.h:48
Definition: struct_benders.h:58
Definition: struct_branch.h:79
Definition: struct_compr.h:47
Definition: struct_concsolver.h:47
Definition: struct_concsolver.h:65
Definition: struct_conflict.h:50
Definition: struct_cons.h:127
Definition: struct_cutsel.h:47
Definition: struct_dialog.h:46
Definition: struct_disp.h:46
Definition: struct_event.h:205
Definition: struct_expr.h:44
Definition: struct_heur.h:98
Definition: struct_nlpi.h:47
Definition: struct_nodesel.h:62
Definition: struct_paramset.h:130
Definition: struct_presol.h:47
Definition: struct_pricer.h:47
Definition: struct_prop.h:47
Definition: struct_reader.h:46
Definition: struct_relax.h:47
Definition: struct_sepa.h:47
Definition: struct_set.h:74
SCIP_Real sepa_maxcoefratiofacrowprep
Definition: struct_set.h:543
int conf_maxvarsdetectimpliedbounds
Definition: struct_set.h:260
Definition: struct_table.h:46
Definition: struct_scip.h:70
type definitions for bandit selection algorithms
type definitions for Benders' decomposition methods
type definitions for branching rules
type definitions for clocks and timing issues
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
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
type definitions for displaying statistics tables