SCIP
Solving Constraint Integer Programs
Solving Constraint Integer Programs
main solving loop and node processing
Definition in file solve.c.
#include <assert.h>#include "scip/def.h"#include "scip/set.h"#include "scip/stat.h"#include "scip/clock.h"#include "scip/visual.h"#include "scip/interrupt.h"#include "scip/event.h"#include "scip/lp.h"#include "scip/mem.h"#include "scip/var.h"#include "scip/prob.h"#include "scip/sol.h"#include "scip/primal.h"#include "scip/tree.h"#include "scip/reopt.h"#include "scip/pricestore.h"#include "scip/sepastore.h"#include "scip/cutpool.h"#include "scip/solve.h"#include "scip/scip.h"#include "scip/branch.h"#include "scip/conflict.h"#include "scip/cons.h"#include "scip/disp.h"#include "scip/heur.h"#include "scip/nodesel.h"#include "scip/pricer.h"#include "scip/relax.h"#include "scip/sepa.h"#include "scip/prop.h"#include "scip/pub_misc.h"#include "scip/debug.h"#include "scip/concurrent.h"#include "scip/syncstore.h"Go to the source code of this file.
Macros | |
| #define | MAXNLPERRORS 10 |
| #define | MAXNCLOCKSKIPS 64 |
| #define | NINITCALLS 1000L |
| #define | SAFETYFACTOR 1e-2 |
Typedefs | |
| typedef enum PseudocostFlag | PSEUDOCOSTFLAG |
Enumerations | |
| enum | PseudocostFlag { PSEUDOCOST_NONE = 0, PSEUDOCOST_IGNORE = 1, PSEUDOCOST_UPDATE = 2 } |
Functions | |
| SCIP_Bool | SCIPsolveIsStopped (SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool checknodelimits) |
| SCIP_RETCODE | SCIPprimalHeuristics (SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_NODE *nextnode, SCIP_HEURTIMING heurtiming, SCIP_Bool nodeinfeasible, SCIP_Bool *foundsol, SCIP_Bool *unbounded) |
| static SCIP_RETCODE | propagationRound (BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree, int depth, SCIP_Bool fullpropagation, SCIP_Bool onlydelayed, SCIP_Bool *delayed, SCIP_Bool *propagain, SCIP_PROPTIMING timingmask, SCIP_Bool *cutoff, SCIP_Bool *postpone) |
| static SCIP_RETCODE | propagateDomains (BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree, int depth, int maxproprounds, SCIP_Bool fullpropagation, SCIP_PROPTIMING timingmask, SCIP_Bool *cutoff, SCIP_Bool *postpone) |
| SCIP_RETCODE | SCIPpropagateDomains (BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CONFLICT *conflict, SCIP_CLIQUETABLE *cliquetable, int depth, int maxproprounds, SCIP_PROPTIMING timingmask, SCIP_Bool *cutoff) |
| static SCIP_Bool | isPseudocostUpdateValid (SCIP_VAR *var, SCIP_SET *set, SCIP_Real oldlpsolval, SCIP_Bool updateintegers, SCIP_Bool updatecontinuous) |
| static SCIP_RETCODE | updatePseudocost (SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_TREE *tree, SCIP_LP *lp, SCIP_Bool updateintegers, SCIP_Bool updatecontinuous) |
| static SCIP_RETCODE | updateEstimate (SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand) |
| SCIP_RETCODE | SCIPinitConssLP (BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool root, SCIP_Bool firstsubtreeinit, SCIP_Bool *cutoff) |
| static SCIP_RETCODE | initLP (BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool root, SCIP_Bool *cutoff) |
| SCIP_RETCODE | SCIPconstructCurrentLP (BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool newinitconss, SCIP_Bool *cutoff) |
| static SCIP_RETCODE | updatePrimalRay (BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_Bool lperror) |
| static SCIP_RETCODE | solveNodeInitialLP (BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool newinitconss, SCIP_Bool *cutoff, SCIP_Bool *lperror) |
| static SCIP_RETCODE | separationRoundResolveLP (BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_Bool *lperror, SCIP_Bool *mustsepa, SCIP_Bool *mustprice) |
| static SCIP_RETCODE | separationRoundLP (BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_SEPASTORE *sepastore, int actdepth, SCIP_Real bounddist, SCIP_Bool allowlocal, SCIP_Bool onlydelayed, SCIP_Bool *delayed, SCIP_Bool *enoughcuts, SCIP_Bool *cutoff, SCIP_Bool *lperror, SCIP_Bool *mustsepa, SCIP_Bool *mustprice) |
| static SCIP_RETCODE | separationRoundSol (BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SEPASTORE *sepastore, SCIP_SOL *sol, int actdepth, SCIP_Bool allowlocal, SCIP_Bool onlydelayed, SCIP_Bool *delayed, SCIP_Bool *enoughcuts, SCIP_Bool *cutoff) |
| SCIP_RETCODE | SCIPseparationRound (BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_SEPASTORE *sepastore, SCIP_SOL *sol, int actdepth, SCIP_Bool allowlocal, SCIP_Bool onlydelayed, SCIP_Bool *delayed, SCIP_Bool *cutoff) |
| SCIP_RETCODE | SCIPpriceLoop (BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool pretendroot, SCIP_Bool displayinfo, int maxpricerounds, int *npricedcolvars, SCIP_Bool *mustsepa, SCIP_Bool *lperror, SCIP_Bool *aborted) |
| static SCIP_RETCODE | cutpoolSeparate (SCIP_CUTPOOL *cutpool, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp, SCIP_SEPASTORE *sepastore, SCIP_Bool cutpoolisdelayed, SCIP_Bool root, int actdepth, SCIP_Bool *enoughcuts, SCIP_Bool *cutoff) |
| static SCIP_RETCODE | priceAndCutLoop (BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_MEM *mem, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_CUTPOOL *delayedcutpool, SCIP_BRANCHCAND *branchcand, SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool fullseparation, SCIP_Bool *propagateagain, SCIP_Bool *cutoff, SCIP_Bool *unbounded, SCIP_Bool *lperror, SCIP_Bool *pricingaborted) |
| static SCIP_RETCODE | applyBounding (BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CONFLICT *conflict, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *cutoff) |
| static void | markRelaxsUnsolved (SCIP_SET *set, SCIP_RELAXATION *relaxation) |
| static SCIP_RETCODE | solveNodeLP (BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_MEM *mem, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_RELAXATION *relaxation, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_CUTPOOL *delayedcutpool, SCIP_BRANCHCAND *branchcand, SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool initiallpsolved, SCIP_Bool fullseparation, SCIP_Bool newinitconss, SCIP_Bool *propagateagain, SCIP_Bool *solverelaxagain, SCIP_Bool *cutoff, SCIP_Bool *unbounded, SCIP_Bool *lperror, SCIP_Bool *pricingaborted) |
| static SCIP_RETCODE | solveNodeRelax (SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_RELAXATION *relaxation, SCIP_PROB *transprob, SCIP_PROB *origprob, int depth, SCIP_Bool beforelp, SCIP_Bool *cutoff, SCIP_Bool *propagateagain, SCIP_Bool *solvelpagain, SCIP_Bool *solverelaxagain, SCIP_Bool *relaxcalled) |
| static SCIP_RETCODE | enforceConstraints (BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_RELAXATION *relaxation, SCIP_SEPASTORE *sepastore, SCIP_BRANCHCAND *branchcand, SCIP_Bool *branched, SCIP_Bool *cutoff, SCIP_Bool *infeasible, SCIP_Bool *propagateagain, SCIP_Bool *solvelpagain, SCIP_Bool *solverelaxagain, SCIP_Bool forced) |
| static SCIP_RETCODE | applyCuts (BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_RELAXATION *relaxation, SCIP_SEPASTORE *sepastore, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool root, SCIP_EFFICIACYCHOICE efficiacychoice, SCIP_Bool *cutoff, SCIP_Bool *propagateagain, SCIP_Bool *solvelpagain, SCIP_Bool *solverelaxagain) |
| static void | updateLoopStatus (SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, int depth, SCIP_Bool *cutoff, SCIP_Bool *propagateagain, SCIP_Bool *solverelaxagain) |
| static SCIP_RETCODE | propAndSolve (BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_MEM *mem, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_RELAXATION *relaxation, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_BRANCHCAND *branchcand, SCIP_CUTPOOL *cutpool, SCIP_CUTPOOL *delayedcutpool, SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_NODE *focusnode, int actdepth, SCIP_Bool propagate, SCIP_Bool solvelp, SCIP_Bool solverelax, SCIP_Bool forcedlpsolve, SCIP_Bool initiallpsolved, SCIP_Bool fullseparation, SCIP_Longint *afterlpproplps, SCIP_HEURTIMING *heurtiming, int *nlperrors, SCIP_Bool *fullpropagation, SCIP_Bool *propagateagain, SCIP_Bool *lpsolved, SCIP_Bool *relaxcalled, SCIP_Bool *solvelpagain, SCIP_Bool *solverelaxagain, SCIP_Bool *cutoff, SCIP_Bool *postpone, SCIP_Bool *unbounded, SCIP_Bool *stopped, SCIP_Bool *lperror, SCIP_Bool *pricingaborted, SCIP_Bool *forcedenforcement) |
| static SCIP_Bool | restartAllowed (SCIP_SET *set, SCIP_STAT *stat) |
| static SCIP_RETCODE | solveNode (BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_MEM *mem, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_RELAXATION *relaxation, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_BRANCHCAND *branchcand, SCIP_CUTPOOL *cutpool, SCIP_CUTPOOL *delayedcutpool, SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *cutoff, SCIP_Bool *postpone, SCIP_Bool *unbounded, SCIP_Bool *infeasible, SCIP_Bool *restart, SCIP_Bool *afternodeheur, SCIP_Bool *stopped) |
| static SCIP_RETCODE | addCurrentSolution (BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_PRIMAL *primal, SCIP_RELAXATION *relaxation, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_Bool checksol) |
| SCIP_RETCODE | SCIPsolveCIP (BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_MEM *mem, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_RELAXATION *relaxation, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_CUTPOOL *delayedcutpool, SCIP_BRANCHCAND *branchcand, SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *restart) |
| #define MAXNLPERRORS 10 |
maximal number of LP error loops in a single node
Definition at line 63 of file solve.c.
Referenced by solveNode().
| #define MAXNCLOCKSKIPS 64 |
maximum number of SCIPsolveIsStopped() calls without checking the clock
Definition at line 64 of file solve.c.
Referenced by SCIPsolveIsStopped().
| #define NINITCALLS 1000L |
minimum number of calls to SCIPsolveIsStopped() prior to dynamic clock skips
Definition at line 65 of file solve.c.
Referenced by SCIPsolveIsStopped().
| #define SAFETYFACTOR 1e-2 |
the probability that SCIP skips the clock call after the time limit has already been reached
Definition at line 66 of file solve.c.
Referenced by SCIPsolveIsStopped().
| typedef enum PseudocostFlag PSEUDOCOSTFLAG |
| enum PseudocostFlag |
returns whether the solving process will be / was stopped before proving optimality; if the solving process was stopped, stores the reason as status in stat
| set | global SCIP settings |
| stat | dynamic problem statistics |
| checknodelimits | should the node limits be involved in the check? |
Definition at line 71 of file solve.c.
References SCIP_Stat::bestsolnode, SCIP_Stat::externmemestim, FALSE, MAXNCLOCKSKIPS, SCIP_Stat::nclockskipsleft, NINITCALLS, SCIP_Stat::nisstoppedcalls, SCIP_Stat::nnodes, SCIP_Stat::ntotalnodes, SAFETYFACTOR, SCIP_Real, SCIP_STAGE_PRESOLVED, SCIP_STAGE_SOLVING, SCIP_STATUS_BESTSOLLIMIT, SCIP_STATUS_GAPLIMIT, SCIP_STATUS_MEMLIMIT, SCIP_STATUS_NODELIMIT, SCIP_STATUS_SOLLIMIT, SCIP_STATUS_STALLNODELIMIT, SCIP_STATUS_TIMELIMIT, SCIP_STATUS_TOTALNODELIMIT, SCIP_STATUS_UNKNOWN, SCIP_STATUS_USERINTERRUPT, SCIPclockGetLastTime(), SCIPclockGetTime(), SCIPgetConcurrentMemTotal(), SCIPgetGap(), SCIPgetLowerbound(), SCIPgetNBestSolsFound(), SCIPgetNConcurrentSolvers(), SCIPgetNLimSolsFound(), SCIPgetSyncstore(), SCIPgetUpperbound(), SCIPinterrupted(), SCIPresetInterrupted(), SCIPsetIsLE(), SCIPsetIsLT(), SCIPstatIncrement, SCIPsyncstoreSolveIsStopped(), SCIP_Stat::solvingtime, SCIP_Stat::status, TRUE, and SCIP_Stat::userinterrupt.
Referenced by presolve(), priceAndCutLoop(), propagateDomains(), propAndSolve(), SCIPbranchExecLP(), SCIPgetVarsStrongbranchesFrac(), SCIPgetVarsStrongbranchesInt(), SCIPgetVarStrongbranchFrac(), SCIPgetVarStrongbranchInt(), SCIPgetVarStrongbranchWithPropagation(), SCIPisStopped(), SCIPlpSolveAndEval(), SCIPpriceLoop(), SCIPprimalHeuristics(), SCIPprintStage(), SCIPsolve(), SCIPsolveCIP(), separationRoundSol(), solveNode(), and solveNodeLP().
| SCIP_RETCODE SCIPprimalHeuristics | ( | SCIP_SET * | set, |
| SCIP_STAT * | stat, | ||
| SCIP_PROB * | prob, | ||
| SCIP_PRIMAL * | primal, | ||
| SCIP_TREE * | tree, | ||
| SCIP_LP * | lp, | ||
| SCIP_NODE * | nextnode, | ||
| SCIP_HEURTIMING | heurtiming, | ||
| SCIP_Bool | nodeinfeasible, | ||
| SCIP_Bool * | foundsol, | ||
| SCIP_Bool * | unbounded | ||
| ) |
calls primal heuristics
| set | global SCIP settings |
| stat | dynamic problem statistics |
| prob | transformed problem after presolve |
| primal | primal data |
| tree | branch and bound tree, or NULL if called during presolving |
| lp | LP data, or NULL if called during presolving or propagation |
| nextnode | next node that will be processed, or NULL if no more nodes left (only needed when calling after node heuristics) |
| heurtiming | current point in the node solving process |
| nodeinfeasible | was the current node already detected to be infeasible? |
| foundsol | pointer to store whether a solution has been found |
| unbounded | pointer to store whether an unbounded ray was found in the LP |
Definition at line 177 of file solve.c.
References BMSgetNUsedBufferMemory(), SCIP_Primal::cutoffbound, FALSE, SCIP_Tree::focuslpstatefork, SCIP_Primal::nbestsolsfound, SCIP_Lp::resolvelperror, SCIP_Bool, SCIP_CALL, SCIP_FOUNDSOL, SCIP_HEURTIMING_AFTERLPLOOP, SCIP_HEURTIMING_AFTERLPNODE, SCIP_HEURTIMING_AFTERLPPLUNGE, SCIP_HEURTIMING_AFTERNODE, SCIP_HEURTIMING_AFTERPROPLOOP, SCIP_HEURTIMING_AFTERPSEUDONODE, SCIP_HEURTIMING_AFTERPSEUDOPLUNGE, SCIP_HEURTIMING_BEFORENODE, SCIP_HEURTIMING_BEFOREPRESOL, SCIP_HEURTIMING_DURINGLPLOOP, SCIP_HEURTIMING_DURINGPRESOLLOOP, SCIP_HEURTIMING_DURINGPRICINGLOOP, SCIP_Longint, SCIP_NODETYPE_CHILD, SCIP_NODETYPE_LEAF, SCIP_NODETYPE_SIBLING, SCIP_OKAY, SCIP_Real, SCIP_UNBOUNDED, SCIPABORT, SCIPbuffer(), SCIPerrorMessage, SCIPheurExec(), SCIPheurGetName(), SCIPheurGetPriority(), SCIPheurShouldBeExecuted(), SCIPlpDiving(), SCIPlpGetPseudoObjval(), SCIPnodeGetDepth(), SCIPnodeGetLowerbound(), SCIPnodeGetType(), SCIPsetDebugMsg, SCIPsetInfinity(), SCIPsetSortHeurs(), SCIPsolveIsStopped(), SCIPtreeGetCurrentDepth(), SCIPtreeGetFocusDepth(), SCIPtreeGetFocusNode(), SCIPtreeGetNNodes(), SCIPtreeHasFocusNodeLP(), SCIPtreeProbing(), and TRUE.
Referenced by presolve(), presolveRound(), priceAndCutLoop(), propAndSolve(), SCIPpriceLoop(), SCIPsolveCIP(), and solveNode().
|
static |
applies one round of propagation
| blkmem | block memory buffers |
| set | global SCIP settings |
| stat | dynamic problem statistics |
| primal | primal data |
| tree | branch and bound tree |
| depth | depth level to use for propagator frequency checks |
| fullpropagation | should all constraints be propagated (or only new ones)? |
| onlydelayed | should only delayed propagators be called? |
| delayed | pointer to store whether a propagator was delayed |
| propagain | pointer to store whether propagation should be applied again |
| timingmask | timing mask to decide which propagators are executed |
| cutoff | pointer to store whether the node can be cut off |
| postpone | pointer to store whether the node should be postponed |
Definition at line 364 of file solve.c.
References BMSgetNUsedBufferMemory(), SCIP_Tree::cutoffdepth, FALSE, SCIP_Tree::sbprobing, SCIP_Bool, SCIP_CALL, SCIP_CUTOFF, SCIP_DELAYED, SCIP_DELAYNODE, SCIP_OKAY, SCIP_REDUCEDDOM, SCIP_STAGE_SOLVING, SCIPABORT, SCIPbuffer(), SCIPconshdlrGetName(), SCIPconshdlrGetPropTiming(), SCIPconshdlrPropagate(), SCIPconshdlrWasPropagationDelayed(), SCIPerrorMessage, SCIPpropExec(), SCIPpropGetName(), SCIPpropGetPriority(), SCIPpropGetTimingmask(), SCIPpropWasDelayed(), SCIPsetDebugMsg, SCIPsetSortProps(), SCIPtreeGetCurrentDepth(), and TRUE.
Referenced by propagateDomains().
|
static |
applies domain propagation on current node
| blkmem | block memory buffers |
| set | global SCIP settings |
| stat | dynamic problem statistics |
| primal | primal data |
| tree | branch and bound tree |
| depth | depth level to use for propagator frequency checks |
| maxproprounds | maximal number of propagation rounds (-1: no limit, 0: parameter settings) |
| fullpropagation | should all constraints be propagated (or only new ones)? |
| timingmask | timing mask to decide which propagators are executed |
| cutoff | pointer to store whether the node can be cut off |
| postpone | pointer to store whether the node should be postponed |
Definition at line 534 of file solve.c.
References FALSE, propagationRound(), SCIP_Bool, SCIP_CALL, SCIP_NODETYPE_FOCUSNODE, SCIP_NODETYPE_PROBINGNODE, SCIP_NODETYPE_REFOCUSNODE, SCIP_OKAY, SCIPnodeGetDepth(), SCIPnodeGetType(), SCIPnodeIsActive(), SCIPnodeMarkPropagated(), SCIPsetDebugMsg, SCIPsolveIsStopped(), SCIPtreeGetCurrentNode(), and TRUE.
Referenced by priceAndCutLoop(), propAndSolve(), and SCIPpropagateDomains().
| SCIP_RETCODE SCIPpropagateDomains | ( | BMS_BLKMEM * | blkmem, |
| SCIP_SET * | set, | ||
| SCIP_STAT * | stat, | ||
| SCIP_PROB * | transprob, | ||
| SCIP_PROB * | origprob, | ||
| SCIP_PRIMAL * | primal, | ||
| SCIP_TREE * | tree, | ||
| SCIP_REOPT * | reopt, | ||
| SCIP_LP * | lp, | ||
| SCIP_BRANCHCAND * | branchcand, | ||
| SCIP_EVENTQUEUE * | eventqueue, | ||
| SCIP_CONFLICT * | conflict, | ||
| SCIP_CLIQUETABLE * | cliquetable, | ||
| int | depth, | ||
| int | maxproprounds, | ||
| SCIP_PROPTIMING | timingmask, | ||
| SCIP_Bool * | cutoff | ||
| ) |
applies domain propagation on current node and flushes the conflict store afterwards
| blkmem | block memory buffers |
| set | global SCIP settings |
| stat | dynamic problem statistics |
| transprob | transformed problem |
| origprob | original problem |
| primal | primal data |
| tree | branch and bound tree |
| reopt | reoptimization data structure |
| lp | LP data |
| branchcand | branching candidate storage |
| eventqueue | event queue |
| conflict | conflict analysis data |
| cliquetable | clique table data structure |
| depth | depth level to use for propagator frequency checks |
| maxproprounds | maximal number of propagation rounds (-1: no limit, 0: parameter settings) |
| timingmask | timing mask to decide which propagators are executed |
| cutoff | pointer to store whether the node can be cut off |
Definition at line 610 of file solve.c.
References propagateDomains(), SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIPconflictFlushConss(), and TRUE.
Referenced by nodeRepropagate(), and SCIPpropagateProbing().
|
static |
returns whether the given variable with the old LP solution value should lead to an update of the pseudo cost entry
| var | problem variable |
| set | global SCIP settings |
| oldlpsolval | solution value of variable in old LP |
| updateintegers | whether to update pseudo costs for integer variables |
| updatecontinuous | whether to update pseudo costs for continuous variables |
Definition at line 643 of file solve.c.
References FALSE, REALABS, SCIP_INVALID, SCIP_Real, SCIP_VARTYPE_CONTINUOUS, SCIPsetIsEQ(), SCIPsetIsGT(), SCIPsetIsInfinity(), SCIPsetIsLT(), SCIPvarGetLbLocal(), SCIPvarGetLPSol(), SCIPvarGetType(), SCIPvarGetUbLocal(), and TRUE.
Referenced by updatePseudocost().
|
static |
updates the variable's pseudo cost values after the node's initial LP was solved
| set | global SCIP settings |
| stat | dynamic problem statistics |
| prob | transformed problem after presolve |
| tree | branch and bound tree |
| lp | LP data |
| updateintegers | whether to update pseudo costs for integer variables |
| updatecontinuous | whether to update pseudo costs for continuous variables |
Definition at line 710 of file solve.c.
References SCIP_DomChgBound::boundchgs, SCIP_BdChgInfo::boundchgtype, SCIP_BoundChg::boundtype, SCIP_BoundChg::branchingdata, SCIP_Node::data, SCIP_Node::depth, SCIP_Node::domchg, SCIP_DomChg::domchgbound, SCIP_Tree::focuslpstatefork, SCIP_Node::fork, isPseudocostUpdateValid(), SCIP_Node::lowerbound, SCIP_Fork::lpobjval, MAX, SCIP_DomChgBound::nboundchgs, SCIP_BoundChg::newbound, SCIP_BdChgInfo::newbound, SCIP_BdChgInfo::oldbound, SCIP_Tree::path, PSEUDOCOST_IGNORE, PSEUDOCOST_NONE, PSEUDOCOST_UPDATE, SCIP_Var::pseudocostflag, SCIP_BOUNDCHGTYPE_BRANCHING, SCIP_BOUNDTYPE_LOWER, SCIP_BOUNDTYPE_UPPER, SCIP_CALL, SCIP_INVALID, SCIP_LPSOLSTAT_OPTIMAL, SCIP_NODETYPE_FOCUSNODE, SCIP_NODETYPE_FORK, SCIP_OKAY, SCIP_Real, SCIP_VARTYPE_CONTINUOUS, SCIPlpGetObjval(), SCIPlpGetSolstat(), SCIPnodeGetDepth(), SCIPnodeGetType(), SCIPnodeIsActive(), SCIPsetAllocBufferArray, SCIPsetDebugMsg, SCIPsetFreeBufferArray, SCIPsetIsInfinity(), SCIPsetReallocBufferArray, SCIPtreeGetFocusNode(), SCIPvarGetBdchgInfoLb(), SCIPvarGetBdchgInfoUb(), SCIPvarGetLbLocal(), SCIPvarGetLPSol(), SCIPvarGetName(), SCIPvarGetNBdchgInfosLb(), SCIPvarGetNBdchgInfosUb(), SCIPvarGetType(), SCIPvarGetUbLocal(), SCIPvarUpdatePseudocost(), SCIP_Lp::solved, and SCIP_BoundChg::var.
Referenced by priceAndCutLoop(), and solveNodeInitialLP().
|
static |
updates the estimated value of a primal feasible solution for the focus node after the LP was solved
| set | global SCIP settings |
| stat | problem statistics |
| tree | branch and bound tree |
| lp | current LP data |
| branchcand | branching candidate storage |
Definition at line 1026 of file solve.c.
References SCIP_CALL, SCIP_LPSOLSTAT_OPTIMAL, SCIP_OKAY, SCIP_Real, SCIPbranchcandGetLPCands(), SCIPlpGetSolstat(), SCIPlpIsRelax(), SCIPnodeGetLowerbound(), SCIPnodeSetEstimate(), SCIPsetIsInfinity(), SCIPtreeGetFocusNode(), SCIPtreeHasFocusNodeLP(), and SCIPvarGetPseudocost().
Referenced by priceAndCutLoop(), and propAndSolve().
| SCIP_RETCODE SCIPinitConssLP | ( | BMS_BLKMEM * | blkmem, |
| SCIP_SET * | set, | ||
| SCIP_SEPASTORE * | sepastore, | ||
| SCIP_CUTPOOL * | cutpool, | ||
| SCIP_STAT * | stat, | ||
| SCIP_PROB * | transprob, | ||
| SCIP_PROB * | origprob, | ||
| SCIP_TREE * | tree, | ||
| SCIP_REOPT * | reopt, | ||
| SCIP_LP * | lp, | ||
| SCIP_BRANCHCAND * | branchcand, | ||
| SCIP_EVENTQUEUE * | eventqueue, | ||
| SCIP_EVENTFILTER * | eventfilter, | ||
| SCIP_CLIQUETABLE * | cliquetable, | ||
| SCIP_Bool | root, | ||
| SCIP_Bool | firstsubtreeinit, | ||
| SCIP_Bool * | cutoff | ||
| ) |
puts all constraints with initial flag TRUE into the LP
| blkmem | block memory buffers |
| set | global SCIP settings |
| sepastore | separation storage |
| cutpool | global cutpool |
| stat | dynamic problem statistics |
| transprob | transformed problem |
| origprob | original problem |
| tree | branch and bound tree |
| reopt | reoptimization data structure |
| lp | LP data |
| branchcand | branching candidate storage |
| eventqueue | event queue |
| eventfilter | global event filter |
| cliquetable | clique table data structure |
| root | is this the initial root LP? |
| firstsubtreeinit | is this the first call in the current subtree after jumping through the tree? |
| cutoff | pointer to store whether the node can be cut off |
Definition at line 1076 of file solve.c.
References FALSE, SCIP_Tree::focusnode, SCIP_CALL, SCIP_EFFICIACYCHOICE_LP, SCIP_OKAY, SCIPconshdlrInitLP(), SCIPreoptApplyCuts(), SCIPsepastoreApplyCuts(), SCIPsepastoreClearCuts(), SCIPsepastoreEndInitialLP(), SCIPsepastoreStartInitialLP(), and SCIPsetDebugMsg.
Referenced by initLP(), priceAndCutLoop(), SCIPconstructCurrentLP(), SCIPpriceLoop(), solveNodeLP(), and solveProbingLP().
|
static |
constructs the initial LP of the current node
| blkmem | block memory buffers |
| set | global SCIP settings |
| stat | dynamic problem statistics |
| transprob | transformed problem |
| origprob | original problem |
| tree | branch and bound tree |
| reopt | reoptimization data structure |
| lp | LP data |
| pricestore | pricing storage |
| sepastore | separation storage |
| cutpool | global cut pool |
| branchcand | branching candidate storage |
| eventqueue | event queue |
| eventfilter | global event filter |
| cliquetable | clique table data structure |
| root | is this the initial root LP? |
| cutoff | pointer to store whether the node can be cut off |
Definition at line 1142 of file solve.c.
References FALSE, SCIP_Lp::nremovablecols, SCIP_Lp::nremovablerows, SCIP_Prob::nvars, SCIP_CALL, SCIP_OKAY, SCIPinitConssLP(), SCIPlpGetNCols(), SCIPlpGetNRows(), SCIPpricestoreAddVar(), SCIPpricestoreApplyVars(), SCIPpricestoreEndInitialLP(), SCIPpricestoreStartInitialLP(), SCIPsetDebugMsg, SCIPsetIsGT(), SCIPvarGetLbLocal(), SCIPvarGetProbindex(), SCIPvarGetUbLocal(), SCIPvarIsInitial(), TRUE, and SCIP_Prob::vars.
Referenced by SCIPconstructCurrentLP().
| SCIP_RETCODE SCIPconstructCurrentLP | ( | BMS_BLKMEM * | blkmem, |
| SCIP_SET * | set, | ||
| SCIP_STAT * | stat, | ||
| SCIP_PROB * | transprob, | ||
| SCIP_PROB * | origprob, | ||
| SCIP_TREE * | tree, | ||
| SCIP_REOPT * | reopt, | ||
| SCIP_LP * | lp, | ||
| SCIP_PRICESTORE * | pricestore, | ||
| SCIP_SEPASTORE * | sepastore, | ||
| SCIP_CUTPOOL * | cutpool, | ||
| SCIP_BRANCHCAND * | branchcand, | ||
| SCIP_EVENTQUEUE * | eventqueue, | ||
| SCIP_EVENTFILTER * | eventfilter, | ||
| SCIP_CLIQUETABLE * | cliquetable, | ||
| SCIP_Bool | newinitconss, | ||
| SCIP_Bool * | cutoff | ||
| ) |
constructs the LP of the current node, but does not load the LP state and warmstart information
| blkmem | block memory buffers |
| set | global SCIP settings |
| stat | dynamic problem statistics |
| transprob | transformed problem |
| origprob | original problem |
| tree | branch and bound tree |
| reopt | reoptimization data structure |
| lp | LP data |
| pricestore | pricing storage |
| sepastore | separation storage |
| cutpool | global cutpool |
| branchcand | branching candidate storage |
| eventqueue | event queue |
| eventfilter | global event filter |
| cliquetable | clique table data structure |
| newinitconss | do we have to add new initial constraints? |
| cutoff | pointer to store whether the node can be cut off |
Definition at line 1218 of file solve.c.
References SCIP_Row::age, SCIP_Tree::correctlpdepth, FALSE, initLP(), SCIP_Row::local, SCIP_Tree::pathnlprows, SCIP_Lp::rows, SCIP_Bool, SCIP_CALL, SCIP_EFFICIACYCHOICE_LP, SCIP_OKAY, SCIPinitConssLP(), SCIPnodeGetDepth(), SCIPsepastoreAddCut(), SCIPsepastoreApplyCuts(), SCIPsepastoreClearCuts(), SCIPsepastoreEndInitialLP(), SCIPsepastoreStartInitialLP(), SCIPsetDebugMsg, SCIPtreeGetCurrentDepth(), SCIPtreeGetFocusNode(), SCIPtreeIsFocusNodeLPConstructed(), SCIPtreeLoadLP(), and TRUE.
Referenced by SCIPconstructLP(), SCIPwriteLP(), and solveNodeInitialLP().
|
static |
updates the primal ray stored in primal data clears previously stored primal ray, if existing and there was no LP error stores current primal ray, if LP is unbounded and there has been no error
| blkmem | block memory buffers |
| set | global SCIP settings |
| stat | dynamic problem statistics |
| prob | transformed problem after presolve |
| primal | primal data |
| tree | branch and bound tree |
| lp | LP data |
| lperror | has there been an LP error? |
Definition at line 1307 of file solve.c.
References BMSclearMemoryArray, FALSE, SCIP_Prob::nvars, SCIP_Primal::primalray, SCIP_CALL, SCIP_LPSOLSTAT_UNBOUNDEDRAY, SCIP_OKAY, SCIP_Real, SCIPdebug, SCIPlpGetPrimalRay(), SCIPlpGetSolstat(), SCIPprintRay(), SCIPsetAllocBufferArray, SCIPsetDebugMsg, SCIPsetFreeBufferArray, SCIPsolCreate(), SCIPsolFree(), SCIPsolSetVal(), and SCIP_Prob::vars.
Referenced by priceAndCutLoop(), SCIPpriceLoop(), separationRoundResolveLP(), and solveNodeInitialLP().
|
static |
load and solve the initial LP of a node
| blkmem | block memory buffers |
| set | global SCIP settings |
| messagehdlr | message handler |
| stat | dynamic problem statistics |
| transprob | transformed problem after presolve |
| origprob | original problem |
| primal | primal data |
| tree | branch and bound tree |
| reopt | reoptimization data structure |
| lp | LP data |
| pricestore | pricing storage |
| sepastore | separation storage |
| cutpool | global cutpool |
| branchcand | branching candidate storage |
| eventfilter | event filter for global (not variable dependent) events |
| eventqueue | event queue |
| cliquetable | clique table data structure |
| newinitconss | do we have to add new initial constraints? |
| cutoff | pointer to store whether the node can be cut off |
| lperror | pointer to store whether an unresolved error in LP solving occured |
Definition at line 1374 of file solve.c.
References SCIP_Node::depth, FALSE, SCIP_Stat::firstlpdualbound, SCIP_Stat::firstlptime, SCIP_Lp::flushed, SCIP_Stat::nlpiterations, SCIP_Stat::nnodelps, SCIP_Stat::nrootfirstlpiterations, SCIP_CALL, SCIP_EVENTTYPE_FIRSTLPSOLVED, SCIP_Longint, SCIP_LPSOLSTAT_ITERLIMIT, SCIP_LPSOLSTAT_OBJLIMIT, SCIP_LPSOLSTAT_OPTIMAL, SCIP_LPSOLSTAT_TIMELIMIT, SCIP_LPSOLSTAT_UNBOUNDEDRAY, SCIP_NODETYPE_FOCUSNODE, SCIP_OKAY, SCIP_Real, SCIPclockGetTime(), SCIPconstructCurrentLP(), SCIPeventChgNode(), SCIPeventChgType(), SCIPeventProcess(), SCIPlpGetObjval(), SCIPlpGetProvedLowerbound(), SCIPlpGetSolstat(), SCIPlpIsRelax(), SCIPlpSolveAndEval(), SCIPnodeGetDepth(), SCIPnodeGetType(), SCIPnodeUpdateLowerboundLP(), SCIPprobAllColsInLP(), SCIPprobExternObjval(), SCIPsetDebugMsg, SCIPtreeGetFocusNode(), SCIPtreeLoadLPState(), SCIP_Lp::solved, SCIP_Stat::solvingtime, TRUE, updatePrimalRay(), and updatePseudocost().
Referenced by solveNodeLP().
|
static |
makes sure the LP is flushed and solved
| blkmem | block memory buffers |
| set | global SCIP settings |
| messagehdlr | message handler |
| stat | dynamic problem statistics |
| eventqueue | event queue |
| eventfilter | global event filter |
| prob | transformed problem after presolve |
| primal | primal data |
| tree | branch and bound tree |
| lp | LP data |
| lperror | pointer to store whether an unresolved error in LP solving occured |
| mustsepa | pointer to store TRUE if additional separation rounds should be performed |
| mustprice | pointer to store TRUE if additional pricing rounds should be performed |
Definition at line 1497 of file solve.c.
References FALSE, SCIP_Lp::flushed, SCIP_CALL, SCIP_OKAY, SCIPlpSolveAndEval(), SCIPsetDebugMsg, SCIP_Lp::solved, TRUE, and updatePrimalRay().
Referenced by separationRoundLP().
|
static |
applies one round of LP separation
| blkmem | block memory buffers |
| set | global SCIP settings |
| messagehdlr | message handler |
| stat | dynamic problem statistics |
| eventqueue | event queue |
| eventfilter | global event filter |
| prob | transformed problem after presolve |
| primal | primal data |
| tree | branch and bound tree |
| lp | LP data |
| sepastore | separation storage |
| actdepth | current depth in the tree |
| bounddist | current relative distance of local dual bound to global dual bound |
| allowlocal | should the separators be asked to separate local cuts |
| onlydelayed | should only delayed separators be called? |
| delayed | pointer to store whether a separator was delayed |
| enoughcuts | pointer to store whether enough cuts have been found this round |
| cutoff | pointer to store whether the node can be cut off |
| lperror | pointer to store whether an unresolved error in LP solving occured |
| mustsepa | pointer to store TRUE if additional separation rounds should be performed |
| mustprice | pointer to store TRUE if additional pricing rounds should be performed |
Definition at line 1538 of file solve.c.
References BMSgetNUsedBufferMemory(), FALSE, SCIP_Lp::flushed, SCIP_Bool, SCIP_CALL, SCIP_CONSADDED, SCIP_CUTOFF, SCIP_DELAYED, SCIP_Longint, SCIP_LPSOLSTAT_OPTIMAL, SCIP_LPSOLSTAT_UNBOUNDEDRAY, SCIP_NEWROUND, SCIP_OKAY, SCIP_REDUCEDDOM, SCIP_SEPARATED, SCIPABORT, SCIPbuffer(), SCIPconshdlrGetName(), SCIPconshdlrGetSepaPriority(), SCIPconshdlrSeparateLP(), SCIPconshdlrWasLPSeparationDelayed(), SCIPerrorMessage, SCIPlpGetSolstat(), SCIPsepaExecLP(), SCIPsepaGetName(), SCIPsepaGetPriority(), SCIPsepastoreGetNCuts(), SCIPsepaWasLPDelayed(), SCIPsetDebugMsg, SCIPsetGetSepaMaxcuts(), SCIPsetSortSepas(), separationRoundResolveLP(), SCIP_Lp::solved, and TRUE.
Referenced by priceAndCutLoop(), and SCIPseparationRound().
|
static |
applies one round of separation on the given primal solution
| blkmem | block memory buffers |
| set | global SCIP settings |
| stat | dynamic problem statistics |
| sepastore | separation storage |
| sol | primal solution that should be separated, or NULL for LP solution |
| actdepth | current depth in the tree |
| allowlocal | should the separator be asked to separate local cuts |
| onlydelayed | should only delayed separators be called? |
| delayed | pointer to store whether a separator was delayed |
| enoughcuts | pointer to store whether enough cuts have been found this round |
| cutoff | pointer to store whether the node can be cut off |
Definition at line 1752 of file solve.c.
References FALSE, SCIP_Bool, SCIP_CALL, SCIP_CONSADDED, SCIP_CUTOFF, SCIP_DELAYED, SCIP_Longint, SCIP_NEWROUND, SCIP_OKAY, SCIP_REDUCEDDOM, SCIP_SEPARATED, SCIPconshdlrGetName(), SCIPconshdlrSeparateSol(), SCIPconshdlrWasSolSeparationDelayed(), SCIPsepaExecSol(), SCIPsepaGetName(), SCIPsepaGetPriority(), SCIPsepastoreGetNCuts(), SCIPsepaWasSolDelayed(), SCIPsetDebugMsg, SCIPsetGetSepaMaxcuts(), SCIPsetSortSepas(), SCIPsolveIsStopped(), and TRUE.
Referenced by SCIPseparationRound().
| SCIP_RETCODE SCIPseparationRound | ( | BMS_BLKMEM * | blkmem, |
| SCIP_SET * | set, | ||
| SCIP_MESSAGEHDLR * | messagehdlr, | ||
| SCIP_STAT * | stat, | ||
| SCIP_EVENTQUEUE * | eventqueue, | ||
| SCIP_EVENTFILTER * | eventfilter, | ||
| SCIP_PROB * | prob, | ||
| SCIP_PRIMAL * | primal, | ||
| SCIP_TREE * | tree, | ||
| SCIP_LP * | lp, | ||
| SCIP_SEPASTORE * | sepastore, | ||
| SCIP_SOL * | sol, | ||
| int | actdepth, | ||
| SCIP_Bool | allowlocal, | ||
| SCIP_Bool | onlydelayed, | ||
| SCIP_Bool * | delayed, | ||
| SCIP_Bool * | cutoff | ||
| ) |
applies one round of separation on the given primal solution or on the LP solution
| blkmem | block memory buffers |
| set | global SCIP settings |
| messagehdlr | message handler |
| stat | dynamic problem statistics |
| eventqueue | event queue |
| eventfilter | global event filter |
| prob | transformed problem after presolve |
| primal | primal data |
| tree | branch and bound tree |
| lp | LP data |
| sepastore | separation storage |
| sol | primal solution that should be separated, or NULL for LP solution |
| actdepth | current depth in the tree |
| allowlocal | should the separator be asked to separate local cuts |
| onlydelayed | should only delayed separators be called? |
| delayed | pointer to store whether a separator was delayed |
| cutoff | pointer to store whether the node can be cut off |
Definition at line 1895 of file solve.c.
References FALSE, SCIP_Bool, SCIP_CALL, SCIP_OKAY, separationRoundLP(), and separationRoundSol().
Referenced by SCIPseparateSol().
| SCIP_RETCODE SCIPpriceLoop | ( | BMS_BLKMEM * | blkmem, |
| SCIP_SET * | set, | ||
| SCIP_MESSAGEHDLR * | messagehdlr, | ||
| SCIP_STAT * | stat, | ||
| SCIP_PROB * | transprob, | ||
| SCIP_PROB * | origprob, | ||
| SCIP_PRIMAL * | primal, | ||
| SCIP_TREE * | tree, | ||
| SCIP_REOPT * | reopt, | ||
| SCIP_LP * | lp, | ||
| SCIP_PRICESTORE * | pricestore, | ||
| SCIP_SEPASTORE * | sepastore, | ||
| SCIP_CUTPOOL * | cutpool, | ||
| SCIP_BRANCHCAND * | branchcand, | ||
| SCIP_EVENTQUEUE * | eventqueue, | ||
| SCIP_EVENTFILTER * | eventfilter, | ||
| SCIP_CLIQUETABLE * | cliquetable, | ||
| SCIP_Bool | pretendroot, | ||
| SCIP_Bool | displayinfo, | ||
| int | maxpricerounds, | ||
| int * | npricedcolvars, | ||
| SCIP_Bool * | mustsepa, | ||
| SCIP_Bool * | lperror, | ||
| SCIP_Bool * | aborted | ||
| ) |
solves the current LP completely with pricing in new variables
| blkmem | block memory buffers |
| set | global SCIP settings |
| messagehdlr | message handler |
| stat | dynamic problem statistics |
| transprob | transformed problem |
| origprob | original problem |
| primal | primal data |
| tree | branch and bound tree |
| reopt | reoptimization data structure |
| lp | LP data |
| pricestore | pricing storage |
| sepastore | separation storage |
| cutpool | global cutpool |
| branchcand | branching candidate storage |
| eventqueue | event queue |
| eventfilter | global event filter |
| cliquetable | clique table data structure |
| pretendroot | should the pricers be called as if we are at the root node? |
| displayinfo | should info lines be displayed after each pricing round? |
| maxpricerounds | maximal number of pricing rounds (-1: no limit); a finite limit means that the LP might not be solved to optimality! |
| npricedcolvars | pointer to store number of column variables after problem vars were priced |
| mustsepa | pointer to store TRUE if a separation round should follow |
| lperror | pointer to store whether an unresolved error in LP solving occured |
| aborted | pointer to store whether the pricing was aborted and the lower bound must not be used |
Definition at line 1948 of file solve.c.
References SCIP_Primal::cutoffbound, FALSE, SCIP_Lp::flushed, SCIP_Prob::ncolvars, SCIP_Stat::npricerounds, SCIP_Bool, SCIP_CALL, SCIP_DIDNOTRUN, SCIP_HEURTIMING_DURINGPRICINGLOOP, SCIP_LPSOLSTAT_ERROR, SCIP_LPSOLSTAT_INFEASIBLE, SCIP_LPSOLSTAT_NOTSOLVED, SCIP_LPSOLSTAT_OBJLIMIT, SCIP_LPSOLSTAT_OPTIMAL, SCIP_LPSOLSTAT_UNBOUNDEDRAY, SCIP_OKAY, SCIP_Real, SCIP_SUCCESS, SCIP_VERBLEVEL_FULL, SCIP_VERBLEVEL_HIGH, SCIPdispPrintLine(), SCIPgetLowerbound(), SCIPgetUpperbound(), SCIPinitConssLP(), SCIPlpGetSolstat(), SCIPlpSetIsRelax(), SCIPlpSolveAndEval(), SCIPmessagePrintWarning(), SCIPnodeGetLowerbound(), SCIPnodeUpdateLowerbound(), SCIPpricerExec(), SCIPpricerGetName(), SCIPpricestoreAddProbVars(), SCIPpricestoreApplyVars(), SCIPpricestoreGetNBoundResets(), SCIPpricestoreGetNVars(), SCIPpricestoreResetBounds(), SCIPprimalHeuristics(), SCIPprobAllColsInLP(), SCIPsetDebugMsg, SCIPsetGetPriceMaxvars(), SCIPsetIsLE(), SCIPsetIsLT(), SCIPsetSortPricers(), SCIPsolveIsStopped(), SCIPtreeGetCurrentNode(), SCIPtreeGetFocusNode(), SCIPtreeProbing(), SCIP_Lp::solved, TRUE, and updatePrimalRay().
Referenced by priceAndCutLoop(), and solveProbingLP().
|
static |
separates cuts of the cut pool
| cutpool | cut pool |
| blkmem | block memory |
| set | global SCIP settings |
| stat | problem statistics data |
| eventqueue | event queue |
| eventfilter | event filter for global events |
| lp | current LP data |
| sepastore | separation storage |
| cutpoolisdelayed | is the cutpool delayed (count cuts found)? |
| root | are we at the root node? |
| actdepth | the depth of the focus node |
| enoughcuts | pointer to store if enough cuts were found in current separation round |
| cutoff | pointer to store if a cutoff was detected |
Definition at line 2165 of file solve.c.
References SCIP_CALL, SCIP_CUTOFF, SCIP_Longint, SCIP_NEWROUND, SCIP_OKAY, SCIPcutpoolSeparate(), SCIPsepastoreGetNCuts(), and SCIPsetGetSepaMaxcuts().
Referenced by priceAndCutLoop().
|
static |
solve the current LP of a node with a price-and-cut loop
| blkmem | block memory buffers |
| set | global SCIP settings |
| messagehdlr | message handler |
| stat | dynamic problem statistics |
| mem | block memory pools |
| transprob | transformed problem |
| origprob | original problem |
| primal | primal data |
| tree | branch and bound tree |
| reopt | reoptimization data structure |
| lp | LP data |
| pricestore | pricing storage |
| sepastore | separation storage |
| cutpool | global cut pool |
| delayedcutpool | global delayed cut pool |
| branchcand | branching candidate storage |
| conflict | conflict analysis data |
| conflictstore | conflict store |
| eventfilter | event filter for global (not variable dependent) events |
| eventqueue | event queue |
| cliquetable | clique table data structure |
| fullseparation | are we in the first prop-and-cut-and-price loop? |
| propagateagain | pointer to store whether we want to propagate again |
| cutoff | pointer to store whether the node can be cut off |
| unbounded | pointer to store whether an unbounded ray was found in the LP |
| lperror | pointer to store whether an unresolved error in LP solving occured |
| pricingaborted | pointer to store whether the pricing was aborted and the lower bound must not be used |
Definition at line 2196 of file solve.c.
References BMSgetNUsedBufferMemory(), SCIP_Mem::buffer, SCIP_Primal::cutoffbound, cutpoolSeparate(), SCIP_Stat::domchgcount, FALSE, SCIP_Lp::flushed, SCIP_Lp::installing, SCIP_Stat::nboundchgs, SCIP_Prob::ncolvars, SCIP_Stat::nincseparounds, SCIP_Stat::ninitconssadded, SCIP_Lp::nrows, SCIP_Stat::nruns, SCIP_Stat::nseparounds, propagateDomains(), SCIP_Lp::resolvelperror, SCIP_Bool, SCIP_CALL, SCIP_EFFICIACYCHOICE_LP, SCIP_EVENTTYPE_LPSOLVED, SCIP_HEURTIMING_DURINGLPLOOP, SCIP_Longint, SCIP_LPSOLSTAT_INFEASIBLE, SCIP_LPSOLSTAT_ITERLIMIT, SCIP_LPSOLSTAT_NOTSOLVED, SCIP_LPSOLSTAT_OBJLIMIT, SCIP_LPSOLSTAT_OPTIMAL, SCIP_LPSOLSTAT_TIMELIMIT, SCIP_LPSOLSTAT_UNBOUNDEDRAY, SCIP_NODETYPE_FOCUSNODE, SCIP_OKAY, SCIP_PROPTIMING_DURINGLPLOOP, SCIP_Real, SCIP_REAL_MIN, SCIP_VERBLEVEL_FULL, SCIP_VERBLEVEL_HIGH, SCIPbranchcandGetLPCands(), SCIPconflictAnalyzeLP(), SCIPdispPrintLine(), SCIPeventChgNode(), SCIPeventChgType(), SCIPeventProcess(), SCIPinitConssLP(), SCIPlpFlush(), SCIPlpGetObjval(), SCIPlpGetSolstat(), SCIPlpIsRelax(), SCIPlpIsSolved(), SCIPlpRemoveRedundantRows(), SCIPlpSolveAndEval(), SCIPmessagePrintVerbInfo(), SCIPnodeGetDepth(), SCIPnodeGetLowerbound(), SCIPnodeGetType(), SCIPnodeUpdateLowerbound(), SCIPnodeUpdateLowerboundLP(), SCIPpriceLoop(), SCIPprimalHeuristics(), SCIPprobAllColsInLP(), SCIPprobUpdateBestRootSol(), SCIPrelDiff(), SCIPsepastoreApplyCuts(), SCIPsepastoreClearCuts(), SCIPsepastoreGetNCuts(), SCIPsetDebugMsg, SCIPsetGetSepaMaxcuts(), SCIPsetInfinity(), SCIPsetIsGE(), SCIPsetIsLE(), SCIPsetIsLT(), SCIPsolveIsStopped(), SCIPtreeGetCurrentDepth(), SCIPtreeGetFocusNode(), SCIPtreeGetLowerbound(), separationRoundLP(), SCIP_Lp::solved, TRUE, updateEstimate(), updatePrimalRay(), and updatePseudocost().
Referenced by solveNodeLP().
|
static |
updates the current lower bound with the pseudo objective value, cuts off node by bounding, and applies conflict analysis if the pseudo objective lead to the cutoff
| blkmem | block memory buffers |
| set | global SCIP settings |
| stat | dynamic problem statistics |
| transprob | tranformed problem after presolve |
| origprob | original problem |
| primal | primal data |
| tree | branch and bound tree |
| reopt | reoptimization data structure |
| lp | LP data |
| branchcand | branching candidate storage |
| eventqueue | event queue |
| conflict | conflict analysis data |
| cliquetable | clique table data structure |
| cutoff | pointer to store TRUE, if the node can be cut off |
Definition at line 2793 of file solve.c.
References SCIP_Primal::cutoffbound, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPconflictAnalyzePseudo(), SCIPgetOrigObjoffset(), SCIPlpGetPseudoObjval(), SCIPnodeGetLowerbound(), SCIPnodeUpdateLowerbound(), SCIPprobExternObjval(), SCIPsetDebugMsg, SCIPsetInfinity(), SCIPsetIsGE(), SCIPsetIsInfinity(), SCIPtreeGetFocusNode(), and TRUE.
Referenced by propAndSolve(), SCIPsolveCIP(), solveNode(), and solveNodeLP().
|
static |
marks all relaxators to be unsolved
| set | global SCIP settings |
| relaxation | global relaxation data |
Definition at line 2853 of file solve.c.
References FALSE, SCIPrelaxationSetSolValid(), and SCIPrelaxMarkUnsolved().
Referenced by applyCuts(), enforceConstraints(), propAndSolve(), solveNode(), and solveNodeLP().
|
static |
solves the current node's LP in a price-and-cut loop
| blkmem | block memory buffers |
| set | global SCIP settings |
| messagehdlr | message handler |
| stat | dynamic problem statistics |
| mem | block memory pools |
| origprob | original problem |
| transprob | transformed problem after presolve |
| primal | primal data |
| tree | branch and bound tree |
| reopt | reoptimization data structure |
| lp | LP data |
| relaxation | relaxators |
| pricestore | pricing storage |
| sepastore | separation storage |
| cutpool | global cut pool |
| delayedcutpool | global delayed cut pool |
| branchcand | branching candidate storage |
| conflict | conflict analysis data |
| conflictstore | conflict store |
| eventfilter | event filter for global (not variable dependent) events |
| eventqueue | event queue |
| cliquetable | clique table data structure |
| initiallpsolved | was the initial LP already solved? |
| fullseparation | are we in the first prop-and-cut-and-price loop? |
| newinitconss | do we have to add new initial constraints? |
| propagateagain | pointer to store whether we want to propagate again |
| solverelaxagain | pointer to store TRUE, if the external relaxators should be called again |
| cutoff | pointer to store TRUE, if the node can be cut off |
| unbounded | pointer to store TRUE, if an unbounded ray was found in the LP |
| lperror | pointer to store TRUE, if an unresolved error in LP solving occured |
| pricingaborted | pointer to store TRUE, if the pricing was aborted and the lower bound must not be used |
Definition at line 2871 of file solve.c.
References applyBounding(), SCIP_Lp::cutoffbound, SCIP_Stat::domchgcount, SCIP_Tree::effectiverootdepth, FALSE, SCIP_Lp::flushed, SCIP_Tree::focusnode, SCIP_Node::lowerbound, markRelaxsUnsolved(), SCIP_Primal::nbestsolsfound, SCIP_Stat::nboundchgs, SCIP_Prob::ncolvars, SCIP_Stat::ninitconssadded, SCIP_Stat::ninitlpiterations, SCIP_Stat::ninitlps, SCIP_Stat::nlpbestsolsfound, SCIP_Stat::nlpiterations, SCIP_Stat::nlps, SCIP_Stat::nlpsolsfound, SCIP_Stat::nnodelpiterations, SCIP_Stat::nnodelps, SCIP_Stat::nrootlpiterations, SCIP_Stat::nrootlps, priceAndCutLoop(), SCIP_Primal::primalray, SCIP_Tree::root, SCIP_Bool, SCIP_CALL, SCIP_EVENTTYPE_NODEFEASIBLE, SCIP_Longint, SCIP_LPSOLSTAT_INFEASIBLE, SCIP_LPSOLSTAT_ITERLIMIT, SCIP_LPSOLSTAT_NOTSOLVED, SCIP_LPSOLSTAT_OBJLIMIT, SCIP_LPSOLSTAT_OPTIMAL, SCIP_LPSOLSTAT_UNBOUNDEDRAY, SCIP_OKAY, SCIP_Real, SCIPinitConssLP(), SCIPlpGetLPI(), SCIPlpGetObjval(), SCIPlpGetSolstat(), SCIPlpiInfinity(), SCIPlpSolveAndEval(), SCIPnodeGetDepth(), SCIPprimalTrySol(), SCIPprimalTrySolFree(), SCIPreoptCheckCutoff(), SCIPsepastoreGetNCuts(), SCIPsepastoreGetNCutsApplied(), SCIPsetDebugMsg, SCIPsetInfinity(), SCIPsolCheck(), SCIPsolCreateLPSol(), SCIPsolFree(), SCIPsolveIsStopped(), SCIPstoreSolutionGap(), SCIPtreeGetCurrentDepth(), SCIPtreeHasFocusNodeLP(), SCIP_Lp::solved, solveNodeInitialLP(), and TRUE.
Referenced by propAndSolve().
|
static |
calls relaxators
| set | global SCIP settings |
| stat | dynamic problem statistics |
| tree | branch and bound tree |
| relaxation | relaxators |
| transprob | transformed problem |
| origprob | original problem |
| depth | depth of current node |
| beforelp | should the relaxators with non-negative or negative priority be called? |
| cutoff | pointer to store TRUE, if the node can be cut off |
| propagateagain | pointer to store TRUE, if domain propagation should be applied again |
| solvelpagain | pointer to store TRUE, if the node's LP has to be solved again |
| solverelaxagain | pointer to store TRUE, if the external relaxators should be called again |
| relaxcalled | pointer to store TRUE, if at least one relaxator was called (unmodified otherwise) |
Definition at line 3113 of file solve.c.
References SCIP_CALL, SCIP_CONSADDED, SCIP_CUTOFF, SCIP_DIDNOTRUN, SCIP_INVALIDRESULT, SCIP_NODETYPE_FOCUSNODE, SCIP_OKAY, SCIP_Real, SCIP_REDUCEDDOM, SCIP_SEPARATED, SCIP_SUCCESS, SCIP_SUSPENDED, SCIPerrorMessage, SCIPnodeGetType(), SCIPnodeUpdateLowerbound(), SCIPrelaxExec(), SCIPrelaxGetName(), SCIPrelaxGetPriority(), SCIPsetDebugMsg, SCIPsetInfinity(), SCIPsetSortRelaxs(), SCIPtreeGetFocusNode(), and TRUE.
Referenced by propAndSolve().
|
static |
enforces constraints by branching, separation, or domain reduction
| blkmem | block memory buffers |
| set | global SCIP settings |
| messagehdlr | message handler |
| stat | dynamic problem statistics |
| prob | transformed problem after presolve |
| primal | primal data |
| tree | branch and bound tree |
| lp | LP data |
| relaxation | global relaxation data |
| sepastore | separation storage |
| branchcand | branching candidate storage |
| branched | pointer to store whether a branching was created |
| cutoff | pointer to store TRUE, if the node can be cut off |
| infeasible | pointer to store TRUE, if the LP/pseudo solution is infeasible |
| propagateagain | pointer to store TRUE, if domain propagation should be applied again |
| solvelpagain | pointer to store TRUE, if the node's LP has to be solved again |
| solverelaxagain | pointer to store TRUE, if the external relaxators should be called again |
| forced | should enforcement of pseudo solution be forced? |
Definition at line 3213 of file solve.c.
References SCIP_Stat::disableenforelaxmsg, FALSE, SCIP_Lp::flushed, markRelaxsUnsolved(), SCIP_Tree::nchildren, SCIP_Stat::ninternalnodes, SCIP_Stat::ntotalinternalnodes, SCIP_Bool, SCIP_BRANCHED, SCIP_CALL, SCIP_CONSADDED, SCIP_CUTOFF, SCIP_DIDNOTRUN, SCIP_FEASIBLE, SCIP_INFEASIBLE, SCIP_INVALIDRESULT, SCIP_LPSOLSTAT_OBJLIMIT, SCIP_LPSOLSTAT_OPTIMAL, SCIP_LPSOLSTAT_UNBOUNDEDRAY, SCIP_OKAY, SCIP_Real, SCIP_REDUCEDDOM, SCIP_SEPARATED, SCIP_SOLVELP, SCIP_VERBLEVEL_FULL, SCIP_VERBLEVEL_HIGH, SCIPconshdlrEnforceLPSol(), SCIPconshdlrEnforcePseudoSol(), SCIPconshdlrEnforceRelaxSol(), SCIPconshdlrGetName(), SCIPerrorMessage, SCIPlpGetObjval(), SCIPlpGetPseudoObjval(), SCIPlpGetSolstat(), SCIPmessagePrintVerbInfo(), SCIPnodeGetLowerbound(), SCIPrelaxationGetSolObj(), SCIPrelaxationIsLpIncludedForSol(), SCIPrelaxationIsSolValid(), SCIPsepastoreEndForceCuts(), SCIPsepastoreGetNCuts(), SCIPsepastoreStartForceCuts(), SCIPsetDebugMsg, SCIPsetIsFeasLT(), SCIPsetIsGT(), SCIPsolCreateRelaxSol(), SCIPsolFree(), SCIPtreeGetFocusNode(), SCIPtreeHasFocusNodeLP(), SCIPtreeSetFocusNodeLP(), SCIP_Lp::solved, and TRUE.
Referenced by solveNode().
|
static |
applies the cuts stored in the separation store, or clears the store if the node can be cut off
| blkmem | block memory buffers |
| set | global SCIP settings |
| stat | dynamic problem statistics |
| transprob | transformed problem |
| origprob | original problem |
| tree | branch and bound tree |
| reopt | reotimization data structure |
| lp | LP data |
| relaxation | relaxators |
| sepastore | separation storage |
| branchcand | branching candidate storage |
| eventqueue | event queue |
| eventfilter | global event filter |
| cliquetable | clique table data structure |
| root | is this the initial root LP? |
| efficiacychoice | type of solution to base efficiacy computation on |
| cutoff | pointer to whether the node can be cut off |
| propagateagain | pointer to store TRUE, if domain propagation should be applied again |
| solvelpagain | pointer to store TRUE, if the node's LP has to be solved again |
| solverelaxagain | pointer to store TRUE, if the node's relaxation has to be solved again |
Definition at line 3505 of file solve.c.
References SCIP_Stat::domchgcount, markRelaxsUnsolved(), SCIP_CALL, SCIP_Longint, SCIP_OKAY, SCIPsepastoreApplyCuts(), SCIPsepastoreClearCuts(), SCIPsepastoreGetNCuts(), SCIPsepastoreGetNCutsApplied(), and TRUE.
Referenced by propAndSolve(), and solveNode().
|
static |
updates the cutoff, propagateagain, and solverelaxagain status of the current solving loop
| set | global SCIP settings |
| stat | dynamic problem statistics |
| tree | branch and bound tree |
| depth | depth of current node |
| cutoff | pointer to store TRUE, if the node can be cut off |
| propagateagain | pointer to store TRUE, if domain propagation should be applied again |
| solverelaxagain | pointer to store TRUE, if at least one relaxator should be called again |
Definition at line 3561 of file solve.c.
References SCIP_Tree::cutoffdepth, FALSE, SCIP_Tree::nchildren, SCIPnodeIsPropagatedAgain(), SCIPrelaxIsSolved(), and SCIPtreeGetFocusNode().
Referenced by solveNode().
|
static |
propagate domains and solve relaxation and lp
| blkmem | block memory buffers |
| set | global SCIP settings |
| messagehdlr | message handler |
| stat | dynamic problem statistics |
| mem | block memory pools |
| origprob | original problem |
| transprob | transformed problem after presolve |
| primal | primal data |
| tree | branch and bound tree |
| reopt | reoptimization data structure |
| lp | LP data |
| relaxation | global relaxation data |
| pricestore | pricing storage |
| sepastore | separation storage |
| branchcand | branching candidate storage |
| cutpool | global cut pool |
| delayedcutpool | global delayed cut pool |
| conflict | conflict analysis data |
| conflictstore | conflict store |
| eventfilter | event filter for global (not variable dependent) events |
| eventqueue | event queue |
| cliquetable | clique table data structure |
| focusnode | focused node |
| actdepth | depth in the b&b tree |
| propagate | should we propagate |
| solvelp | should we solve the lp |
| solverelax | should we solve the relaxation |
| forcedlpsolve | is there a need for a solve lp |
| initiallpsolved | was the initial LP already solved? |
| fullseparation | are we in the first prop-and-cut-and-price loop? |
| afterlpproplps | pointer to store the last LP count for which AFTERLP propagation was performed |
| heurtiming | timing for running heuristics after propagation call |
| nlperrors | pointer to store the number of lp errors |
| fullpropagation | pointer to store whether we want to do a fullpropagation next time |
| propagateagain | pointer to store whether we want to propagate again |
| lpsolved | pointer to store whether the lp was solved |
| relaxcalled | pointer to store whether a relaxator was called; initialized with last loop's result |
| solvelpagain | pointer to store whether we want to solve the lp again |
| solverelaxagain | pointer to store whether we want to solve the relaxation again |
| cutoff | pointer to store whether the node can be cut off |
| postpone | pointer to store whether the node should be postponed |
| unbounded | pointer to store whether the focus node is unbounded |
| stopped | pointer to store whether solving was interrupted |
| lperror | pointer to store TRUE, if an unresolved error in LP solving occured |
| pricingaborted | pointer to store TRUE, if the pricing was aborted and the lower bound must not be used |
| forcedenforcement | pointer to store whether the enforcement of pseudo solution should be forced |
Definition at line 3604 of file solve.c.
References applyBounding(), applyCuts(), BMSgetNUsedBufferMemory(), SCIP_Mem::buffer, SCIP_Primal::cutoffbound, SCIP_Tree::cutoffdepth, SCIP_Node::estimate, FALSE, SCIP_Lp::flushed, SCIP_Stat::lpcount, markRelaxsUnsolved(), SCIP_Stat::nboundchgs, SCIP_Tree::nchildren, SCIP_Prob::ncontvars, SCIP_Stat::ninitconssadded, SCIP_Stat::nlpiterations, SCIP_Stat::nlps, SCIP_Stat::nnodelps, SCIP_Stat::nnodes, propagateDomains(), SCIP_Lp::resolvelperror, SCIP_Bool, SCIP_CALL, SCIP_EFFICIACYCHOICE_RELAX, SCIP_HEURTIMING_AFTERPROPLOOP, SCIP_Longint, SCIP_LPERROR, SCIP_LPSOLSTAT_INFEASIBLE, SCIP_LPSOLSTAT_ITERLIMIT, SCIP_LPSOLSTAT_OPTIMAL, SCIP_LPSOLSTAT_TIMELIMIT, SCIP_LPSOLSTAT_UNBOUNDEDRAY, SCIP_OKAY, SCIP_PROPTIMING_AFTERLPLOOP, SCIP_PROPTIMING_BEFORELP, SCIP_VERBLEVEL_FULL, SCIP_VERBLEVEL_HIGH, SCIPbranchcandClearExternCands(), SCIPbranchcandGetNPseudoCands(), SCIPconflictGetNConflicts(), SCIPerrorMessage, SCIPlpGetObjval(), SCIPlpGetSolstat(), SCIPlpIsRelax(), SCIPmessagePrintVerbInfo(), SCIPnodeCreateChild(), SCIPnodeGetLowerbound(), SCIPnodeUpdateLowerboundLP(), SCIPprimalHeuristics(), SCIPprobAllColsInLP(), SCIPprobUpdateBestRootSol(), SCIPsepastoreGetNCuts(), SCIPsetDebugMsg, SCIPsetInfinity(), SCIPsolveIsStopped(), SCIPtreeGetCurrentDepth(), SCIPtreeHasFocusNodeLP(), SCIPtreeProbing(), SCIPtreeSetFocusNodeLP(), SCIP_Lp::solved, solveNodeLP(), solveNodeRelax(), TRUE, and updateEstimate().
Referenced by solveNode().
check if a restart can be performed
| set | global SCIP settings |
| stat | dynamic problem statistics |
Definition at line 3956 of file solve.c.
References SCIP_Stat::nruns.
Referenced by SCIPsolveCIP(), and solveNode().
|
static |
solves the focus node
| blkmem | block memory buffers |
| set | global SCIP settings |
| messagehdlr | message handler |
| stat | dynamic problem statistics |
| mem | block memory pools |
| origprob | original problem |
| transprob | transformed problem after presolve |
| primal | primal data |
| tree | branch and bound tree |
| reopt | reoptimization data structure |
| lp | LP data |
| relaxation | global relaxation data |
| pricestore | pricing storage |
| sepastore | separation storage |
| branchcand | branching candidate storage |
| cutpool | global cut pool |
| delayedcutpool | global delayed cut pool |
| conflict | conflict analysis data |
| conflictstore | conflict store |
| eventfilter | event filter for global (not variable dependent) events |
| eventqueue | event queue |
| cliquetable | clique table data structure |
| cutoff | pointer to store whether the node can be cut off |
| postpone | pointer to store whether the node should be postponed |
| unbounded | pointer to store whether the focus node is unbounded |
| infeasible | pointer to store whether the focus node's solution is infeasible |
| restart | should solving process be started again with presolving? |
| afternodeheur | pointer to store whether AFTERNODE heuristics were already called |
| stopped | pointer to store whether solving was interrupted |
Definition at line 3975 of file solve.c.
References applyBounding(), applyCuts(), BMSgetNUsedBufferMemory(), SCIP_Stat::branchedunbdvar, SCIP_Mem::buffer, SCIP_Primal::cutoffbound, SCIP_Stat::domchgcount, enforceConstraints(), SCIP_Node::estimate, FALSE, SCIP_Tree::forcinglpmessage, SCIP_Stat::lastbranchvar, SCIP_Lp::looseobjvalinf, SCIP_Stat::lpcount, markRelaxsUnsolved(), MAXNLPERRORS, SCIP_Primal::nbestsolsfound, SCIP_Tree::nchildren, SCIP_Prob::ncontvars, SCIP_Stat::nincseparounds, SCIP_Stat::ninternalnodes, SCIP_Stat::nlpbestsolsfound, SCIP_Stat::nlps, SCIP_Stat::nlpsolsfound, SCIP_Stat::nnodes, SCIP_Stat::npricerounds, SCIP_Stat::nrelaxbestsolsfound, SCIP_Stat::nrelaxsolsfound, SCIP_Stat::nrootintfixingsrun, SCIP_Stat::nruns, SCIP_Stat::nseparounds, SCIP_Tree::nsiblings, SCIP_Stat::ntotalinternalnodes, SCIP_Prob::nvars, SCIP_Stat::prevrunnvars, propAndSolve(), SCIP_Stat::regressioncandsobjval, SCIP_Lp::resolvelperror, restartAllowed(), SCIP_Bool, SCIP_BRANCHED, SCIP_CALL, SCIP_CONSADDED, SCIP_CUTOFF, SCIP_DIDNOTFIND, SCIP_DIDNOTRUN, SCIP_EFFICIACYCHOICE_LP, SCIP_HEURTIMING_AFTERLPLOOP, SCIP_HEURTIMING_AFTERNODE, SCIP_HEURTIMING_BEFORENODE, SCIP_INVALID, SCIP_INVALIDRESULT, SCIP_Longint, SCIP_LPERROR, SCIP_LPSOLSTAT_ITERLIMIT, SCIP_LPSOLSTAT_OPTIMAL, SCIP_LPSOLSTAT_TIMELIMIT, SCIP_NODETYPE_FOCUSNODE, SCIP_OKAY, SCIP_Real, SCIP_REDUCEDDOM, SCIP_SEPARATED, SCIP_VARTYPE_CONTINUOUS, SCIP_VERBLEVEL_FULL, SCIP_VERBLEVEL_HIGH, SCIP_VERBLEVEL_NORMAL, SCIPbranchcandClearExternCands(), SCIPbranchcandGetExternMaxPrio(), SCIPbranchcandGetLPCands(), SCIPbranchcandGetLPMaxPrio(), SCIPbranchcandGetNExternCands(), SCIPbranchcandGetNPrioExternCands(), SCIPbranchcandGetNPrioLPCands(), SCIPbranchcandGetNPseudoCands(), SCIPbranchExecExtern(), SCIPbranchExecLP(), SCIPbranchExecPseudo(), SCIPconflictFlushConss(), SCIPconflictGetNConflicts(), SCIPdebugRemoveNode, SCIPerrorMessage, SCIPlpGetGlobalPseudoObjval(), SCIPlpGetObjval(), SCIPlpGetPseudoObjval(), SCIPlpGetSolstat(), SCIPmessagePrintVerbInfo(), SCIPnodeCreateChild(), SCIPnodeGetDepth(), SCIPnodeGetType(), SCIPnodeUpdateLowerbound(), SCIPprimalHeuristics(), SCIPprimalTrySol(), SCIPprimalTrySolFree(), SCIPprobStoreRootSol(), SCIPregressionAddObservation(), SCIPrelaxationGetSolObj(), SCIPrelaxationIsLpIncludedForSol(), SCIPrelaxationIsSolValid(), SCIPrelaxationSetSolValid(), SCIPreoptGetSolveLP(), SCIPsepastoreGetNCuts(), SCIPsetDebugMsg, SCIPsetInfinity(), SCIPsetIsFeasEQ(), SCIPsetIsGT(), SCIPsetIsInfinity(), SCIPsetIsLT(), SCIPsolCreateCurrentSol(), SCIPsolCreateRelaxSol(), SCIPsolFree(), SCIPsolveIsStopped(), SCIPstoreSolutionGap(), SCIPtreeGetFocusNode(), SCIPtreeGetNNodes(), SCIPtreeHasFocusNodeLP(), SCIPtreeSetFocusNodeLP(), SCIPvarGetLbLocal(), SCIPvarGetName(), SCIPvarGetType(), SCIPvarGetUbLocal(), TRUE, updateLoopStatus(), and SCIP_Stat::userrestart.
Referenced by SCIPsolveCIP().
|
static |
if feasible, adds current solution to the solution storage
| blkmem | block memory buffers |
| set | global SCIP settings |
| messagehdlr | message handler |
| stat | dynamic problem statistics |
| origprob | original problem |
| transprob | transformed problem after presolve |
| primal | primal data |
| relaxation | global relaxation data |
| tree | branch and bound tree |
| reopt | reoptimization data structure |
| lp | LP data |
| eventqueue | event queue |
| eventfilter | event filter for global (not variable dependent) events |
| checksol | should the solution be checked? |
Definition at line 4628 of file solve.c.
References FALSE, SCIP_Stat::lpsoltime, SCIP_Primal::nbestsolsfound, SCIP_Stat::nlpbestsolsfound, SCIP_Stat::nlpsolsfound, SCIP_Stat::npsbestsolsfound, SCIP_Stat::npssolsfound, SCIP_Stat::nrelaxbestsolsfound, SCIP_Stat::nrelaxsolsfound, SCIP_Lp::primalfeasible, SCIP_Stat::pseudosoltime, SCIP_Stat::relaxsoltime, SCIP_Bool, SCIP_CALL, SCIP_Longint, SCIP_OKAY, SCIPclockStart(), SCIPclockStop(), SCIPlpGetObjval(), SCIPprimalAddSolFree(), SCIPprimalTrySolFree(), SCIPrelaxationGetSolObj(), SCIPrelaxationIsLpIncludedForSol(), SCIPrelaxationIsSolValid(), SCIPsetDebugMsg, SCIPsetIsGT(), SCIPsolCreateLPSol(), SCIPsolCreatePseudoSol(), SCIPsolCreateRelaxSol(), SCIPsolGetObj(), SCIPstoreSolutionGap(), SCIPtreeHasFocusNodeLP(), and TRUE.
Referenced by SCIPsolveCIP().
| SCIP_RETCODE SCIPsolveCIP | ( | BMS_BLKMEM * | blkmem, |
| SCIP_SET * | set, | ||
| SCIP_MESSAGEHDLR * | messagehdlr, | ||
| SCIP_STAT * | stat, | ||
| SCIP_MEM * | mem, | ||
| SCIP_PROB * | origprob, | ||
| SCIP_PROB * | transprob, | ||
| SCIP_PRIMAL * | primal, | ||
| SCIP_TREE * | tree, | ||
| SCIP_REOPT * | reopt, | ||
| SCIP_LP * | lp, | ||
| SCIP_RELAXATION * | relaxation, | ||
| SCIP_PRICESTORE * | pricestore, | ||
| SCIP_SEPASTORE * | sepastore, | ||
| SCIP_CUTPOOL * | cutpool, | ||
| SCIP_CUTPOOL * | delayedcutpool, | ||
| SCIP_BRANCHCAND * | branchcand, | ||
| SCIP_CONFLICT * | conflict, | ||
| SCIP_CONFLICTSTORE * | conflictstore, | ||
| SCIP_EVENTFILTER * | eventfilter, | ||
| SCIP_EVENTQUEUE * | eventqueue, | ||
| SCIP_CLIQUETABLE * | cliquetable, | ||
| SCIP_Bool * | restart | ||
| ) |
main solving loop
| blkmem | block memory buffers |
| set | global SCIP settings |
| messagehdlr | message handler |
| stat | dynamic problem statistics |
| mem | block memory pools |
| origprob | original problem |
| transprob | transformed problem after presolve |
| primal | primal data |
| tree | branch and bound tree |
| reopt | reoptimization data structure |
| lp | LP data |
| relaxation | global relaxation data |
| pricestore | pricing storage |
| sepastore | separation storage |
| cutpool | global cut pool |
| delayedcutpool | global delayed cut pool |
| branchcand | branching candidate storage |
| conflict | conflict analysis data |
| conflictstore | conflict store |
| eventfilter | event filter for global (not variable dependent) events |
| eventqueue | event queue |
| cliquetable | clique table data structure |
| restart | should solving process be started again with presolving? |
Definition at line 4766 of file solve.c.
References addCurrentSolution(), applyBounding(), BMSgetNUsedBufferMemory(), SCIP_Mem::buffer, SCIP_Primal::cutoffbound, SCIP_Tree::cutoffdelayed, SCIP_Tree::effectiverootdepth, FALSE, SCIP_Lp::flushed, SCIP_Tree::focusnode, SCIP_Stat::lastbranchdir, SCIP_Stat::lastbranchvalue, SCIP_Stat::lastbranchvar, SCIP_Node::lowerbound, MAX, SCIP_Stat::maxdepth, SCIP_Stat::maxtotaldepth, SCIP_Tree::nchildren, SCIP_Stat::nconfrestarts, SCIP_Prob::ncontvars, SCIP_Stat::ndelayedcutoffs, SCIP_Stat::nfeasleaves, SCIP_Stat::ninfeasleaves, SCIP_Primal::nlimsolsfound, nnodes, SCIP_Stat::nnodes, SCIP_Stat::nnodesaboverefbound, SCIP_Stat::nobjleaves, SCIP_Stat::nodeactivationtime, SCIP_Stat::nrootintfixingsrun, SCIP_Stat::nruns, SCIP_Tree::nsiblings, SCIP_Primal::nsols, SCIP_Stat::ntotalnodes, SCIP_Prob::nvars, SCIP_Stat::prevrunnvars, SCIP_Stat::referencebound, restartAllowed(), SCIP_Tree::root, SCIP_Bool, SCIP_CALL, SCIP_DIDNOTFIND, SCIP_DIDNOTRUN, SCIP_EVENTTYPE_NODEBRANCHED, SCIP_EVENTTYPE_NODEFEASIBLE, SCIP_EVENTTYPE_NODEFOCUSED, SCIP_EVENTTYPE_NODEINFEASIBLE, SCIP_HEURTIMING_AFTERNODE, SCIP_Longint, SCIP_LPSOLSTAT_OBJLIMIT, SCIP_OKAY, SCIP_Real, SCIP_REAL_MAX, SCIP_REDUCEDDOM, SCIP_STATUS_INFEASIBLE, SCIP_STATUS_INFORUNBD, SCIP_STATUS_OPTIMAL, SCIP_STATUS_RESTARTLIMIT, SCIP_STATUS_UNBOUNDED, SCIP_STATUS_UNKNOWN, SCIP_VERBLEVEL_HIGH, SCIPbranchcandGetNPseudoCands(), SCIPbranchExecPseudo(), SCIPcheckSolOrig(), SCIPclockStart(), SCIPclockStop(), SCIPconflictGetNBoundexceedingLPSuccess(), SCIPconflictGetNInfeasibleLPSuccess(), SCIPconflictGetNPropSuccess(), SCIPconflictGetNPseudoSuccess(), SCIPconflictGetNStrongbranchSuccess(), SCIPdispPrintLine(), SCIPerrorMessage, SCIPeventChgNode(), SCIPeventChgType(), SCIPeventProcess(), SCIPlpGetObjval(), SCIPlpGetSolstat(), SCIPmessagePrintVerbInfo(), SCIPnodeFocus(), SCIPnodeGetDepth(), SCIPnodeGetLowerbound(), SCIPnodeselSelect(), SCIPprimalHeuristics(), SCIPprobGetObjlim(), SCIPprobInternObjval(), SCIPrelaxationGetSolObj(), SCIPrelaxationIsLpIncludedForSol(), SCIPrelaxationIsSolValid(), SCIPreoptCheckCutoff(), SCIPsetDebugMsg, SCIPsetGetNodesel(), SCIPsetInfinity(), SCIPsetIsGE(), SCIPsetIsGT(), SCIPsolCreateLPSol(), SCIPsolCreatePseudoSol(), SCIPsolCreateRelaxSol(), SCIPsolFree(), SCIPsolGetObj(), SCIPsolveIsStopped(), SCIPstatUpdateMemsaveMode(), SCIPstatUpdatePrimalDualIntegral(), SCIPtreeCutoff(), SCIPtreeGetCurrentDepth(), SCIPtreeGetCurrentNode(), SCIPtreeGetFocusNode(), SCIPtreeGetNLeaves(), SCIPtreeGetNNodes(), SCIPtreeHasCurrentNodeLP(), SCIPtreeHasFocusNodeLP(), SCIPtreeSetNodesel(), SCIPvarIncCutoffSum(), SCIPvisualCutoffNode(), SCIPvisualSolvedNode(), SCIP_Primal::sols, SCIP_Lp::solved, solveNode(), SCIP_Stat::status, TRUE, SCIP_Stat::userrestart, and SCIP_Stat::visual.
Referenced by SCIPsolve().