Scippy

SCIP

Solving Constraint Integer Programs

Detailed Description

main solving loop and node processing

Author
Tobias Achterberg
Timo Berthold
Marc Pfetsch
Gerald Gamrath

Definition in file solve.c.

#include <assert.h>
#include "lpi/lpi.h"
#include "scip/branch.h"
#include "scip/clock.h"
#include "scip/concurrent.h"
#include "scip/conflict.h"
#include "scip/cons.h"
#include "scip/cutpool.h"
#include "scip/disp.h"
#include "scip/event.h"
#include "scip/heur.h"
#include "scip/interrupt.h"
#include "scip/lp.h"
#include "scip/nodesel.h"
#include "scip/pricer.h"
#include "scip/pricestore.h"
#include "scip/primal.h"
#include "scip/prob.h"
#include "scip/prop.h"
#include "scip/pub_cons.h"
#include "scip/pub_heur.h"
#include "scip/pub_message.h"
#include "scip/pub_misc.h"
#include "scip/pub_pricer.h"
#include "scip/pub_prop.h"
#include "scip/pub_relax.h"
#include "scip/pub_sepa.h"
#include "scip/pub_tree.h"
#include "scip/pub_var.h"
#include "scip/relax.h"
#include "scip/reopt.h"
#include "scip/scip_concurrent.h"
#include "scip/scip_mem.h"
#include "scip/scip_prob.h"
#include "scip/scip_sol.h"
#include "scip/scip_solvingstats.h"
#include "scip/sepa.h"
#include "scip/sepastore.h"
#include "scip/set.h"
#include "scip/sol.h"
#include "scip/solve.h"
#include "scip/stat.h"
#include "scip/struct_cons.h"
#include "scip/struct_event.h"
#include "scip/struct_lp.h"
#include "scip/struct_mem.h"
#include "scip/struct_primal.h"
#include "scip/struct_prob.h"
#include "scip/struct_set.h"
#include "scip/struct_stat.h"
#include "scip/struct_tree.h"
#include "scip/struct_var.h"
#include "scip/syncstore.h"
#include "scip/tree.h"
#include "scip/var.h"
#include "scip/visual.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_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_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_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)
 

Macro Definition Documentation

◆ MAXNLPERRORS

#define MAXNLPERRORS   10

maximal number of LP error loops in a single node

Definition at line 94 of file solve.c.

◆ MAXNCLOCKSKIPS

#define MAXNCLOCKSKIPS   64

maximum number of SCIPsolveIsStopped() calls without checking the clock

Definition at line 95 of file solve.c.

◆ NINITCALLS

#define NINITCALLS   1000L

minimum number of calls to SCIPsolveIsStopped() prior to dynamic clock skips

Definition at line 96 of file solve.c.

◆ SAFETYFACTOR

#define SAFETYFACTOR   1e-2

the probability that SCIP skips the clock call after the time limit has already been reached

Definition at line 97 of file solve.c.

Typedef Documentation

◆ PSEUDOCOSTFLAG

Definition at line 743 of file solve.c.

Enumeration Type Documentation

◆ PseudocostFlag

pseudo cost flag stored in the variables to mark them for the pseudo cost update

Enumerator
PSEUDOCOST_NONE 

variable's bounds were not changed

PSEUDOCOST_IGNORE 

bound changes on variable should be ignored for pseudo cost updates

PSEUDOCOST_UPDATE 

pseudo cost value of variable should be updated

Definition at line 737 of file solve.c.

Function Documentation

◆ SCIPsolveIsStopped()

SCIP_Bool SCIPsolveIsStopped ( SCIP_SET set,
SCIP_STAT stat,
SCIP_Bool  checknodelimits 
)

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

Parameters
setglobal SCIP settings
statdynamic problem statistics
checknodelimitsshould the node limits be involved in the check?

Definition at line 102 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, NULL, SAFETYFACTOR, SCIP_INVALID, SCIP_Real, SCIP_STAGE_PRESOLVING, SCIP_STAGE_SOLVING, SCIP_STATUS_BESTSOLLIMIT, SCIP_STATUS_DUALLIMIT, SCIP_STATUS_GAPLIMIT, SCIP_STATUS_MEMLIMIT, SCIP_STATUS_NODELIMIT, SCIP_STATUS_PRIMALLIMIT, SCIP_STATUS_SOLLIMIT, SCIP_STATUS_STALLNODELIMIT, SCIP_STATUS_TERMINATE, SCIP_STATUS_TIMELIMIT, SCIP_STATUS_TOTALNODELIMIT, SCIP_STATUS_UNKNOWN, SCIP_STATUS_USERINTERRUPT, SCIPclockGetLastTime(), SCIPclockGetTime(), SCIPgetConcurrentMemTotal(), SCIPgetDualbound(), SCIPgetGap(), SCIPgetLowerbound(), SCIPgetNBestSolsFound(), SCIPgetNConcurrentSolvers(), SCIPgetNLimSolsFound(), SCIPgetObjsense(), SCIPgetPrimalbound(), SCIPgetSyncstore(), SCIPgetTransObjscale(), SCIPgetUpperbound(), SCIPinterrupted(), SCIPresetInterrupted(), SCIPsetIsLE(), SCIPsetIsLT(), SCIPsetIsNegative(), SCIPsetIsPositive(), SCIPstatIncrement, SCIPsyncstoreSolveIsStopped(), SCIPterminated(), SCIP_Stat::solvingtime, SCIP_Stat::status, TRUE, and SCIP_Stat::userinterrupt.

Referenced by presolve(), priceAndCutLoop(), propagateDomains(), propAndSolve(), SCIPgetVarsStrongbranchesFrac(), SCIPgetVarsStrongbranchesInt(), SCIPgetVarStrongbranchFrac(), SCIPgetVarStrongbranchInt(), SCIPgetVarStrongbranchWithPropagation(), SCIPisStopped(), SCIPlpSolveAndEval(), SCIPpriceLoop(), SCIPprimalHeuristics(), SCIPprintStage(), SCIPsolve(), SCIPsolveCIP(), separationRoundSol(), solveNode(), and solveNodeLP().

◆ SCIPprimalHeuristics()

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

Parameters
setglobal SCIP settings
statdynamic problem statistics
probtransformed problem after presolve
primalprimal data
treebranch and bound tree, or NULL if called during presolving
lpLP data, or NULL if called during presolving or propagation
nextnodenext node that will be processed, or NULL if no more nodes left (only needed when calling after node heuristics)
heurtimingcurrent point in the node solving process
nodeinfeasiblewas the current node already detected to be infeasible?
foundsolpointer to store whether a solution has been found
unboundedpointer to store whether an unbounded ray was found in the LP

Definition at line 218 of file solve.c.

References BMSgetNUsedBufferMemory(), SCIP_Primal::cutoffbound, FALSE, SCIP_Tree::focuslpstatefork, h, SCIP_Primal::nbestsolsfound, NULL, 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().

◆ propagationRound()

static SCIP_RETCODE propagationRound ( BMS_BLKMEM blkmem,
SCIP_SET set,
SCIP_STAT stat,
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

applies one round of propagation

Parameters
blkmemblock memory buffers
setglobal SCIP settings
statdynamic problem statistics
treebranch and bound tree
depthdepth level to use for propagator frequency checks
fullpropagationshould all constraints be propagated (or only new ones)?
onlydelayedshould only delayed propagators be called?
delayedpointer to store whether a propagator was delayed
propagainpointer to store whether propagation should be applied again
timingmasktiming mask to decide which propagators are executed
cutoffpointer to store whether the node can be cut off
postponepointer to store whether the node should be postponed

Definition at line 404 of file solve.c.

References BMSgetNUsedBufferMemory(), SCIP_Tree::cutoffdepth, FALSE, NULL, 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().

◆ propagateDomains()

static SCIP_RETCODE propagateDomains ( BMS_BLKMEM blkmem,
SCIP_SET set,
SCIP_STAT stat,
SCIP_TREE tree,
int  depth,
int  maxproprounds,
SCIP_Bool  fullpropagation,
SCIP_PROPTIMING  timingmask,
SCIP_Bool cutoff,
SCIP_Bool postpone 
)
static

applies domain propagation on current node

Parameters
blkmemblock memory buffers
setglobal SCIP settings
statdynamic problem statistics
treebranch and bound tree
depthdepth level to use for propagator frequency checks
maxproproundsmaximal number of propagation rounds (-1: no limit, 0: parameter settings)
fullpropagationshould all constraints be propagated (or only new ones)?
timingmasktiming mask to decide which propagators are executed
cutoffpointer to store whether the node can be cut off
postponepointer to store whether the node should be postponed

Definition at line 573 of file solve.c.

References FALSE, NULL, 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().

◆ SCIPpropagateDomains()

SCIP_RETCODE SCIPpropagateDomains ( 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_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

Parameters
blkmemblock memory buffers
setglobal SCIP settings
statdynamic problem statistics
transprobtransformed problem
origproboriginal problem
treebranch and bound tree
reoptreoptimization data structure
lpLP data
branchcandbranching candidate storage
eventqueueevent queue
conflictconflict analysis data
cliquetableclique table data structure
depthdepth level to use for propagator frequency checks
maxproproundsmaximal number of propagation rounds (-1: no limit, 0: parameter settings)
timingmasktiming mask to decide which propagators are executed
cutoffpointer to store whether the node can be cut off

Definition at line 648 of file solve.c.

References propagateDomains(), SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIPconflictFlushConss(), and TRUE.

Referenced by nodeRepropagate(), and SCIPpropagateProbing().

◆ isPseudocostUpdateValid()

static SCIP_Bool isPseudocostUpdateValid ( SCIP_VAR var,
SCIP_SET set,
SCIP_Real  oldlpsolval,
SCIP_Bool  updateintegers,
SCIP_Bool  updatecontinuous 
)
static

returns whether the given variable with the old LP solution value should lead to an update of the pseudo cost entry

Parameters
varproblem variable
setglobal SCIP settings
oldlpsolvalsolution value of variable in old LP
updateintegerswhether to update pseudo costs for integer variables
updatecontinuouswhether to update pseudo costs for continuous variables

Definition at line 680 of file solve.c.

References FALSE, NULL, REALABS, SCIP_INVALID, SCIP_Real, SCIP_VARTYPE_CONTINUOUS, SCIPsetIsEQ(), SCIPsetIsGT(), SCIPsetIsInfinity(), SCIPsetIsLT(), SCIPvarGetLbLocal(), SCIPvarGetLPSol(), SCIPvarGetType(), SCIPvarGetUbLocal(), and TRUE.

Referenced by updatePseudocost().

◆ updatePseudocost()

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

updates the variable's pseudo cost values after the node's initial LP was solved

Parameters
setglobal SCIP settings
statdynamic problem statistics
probtransformed problem after presolve
treebranch and bound tree
lpLP data
updateintegerswhether to update pseudo costs for integer variables
updatecontinuouswhether to update pseudo costs for continuous variables

Definition at line 747 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, NULL, 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().

◆ updateEstimate()

static SCIP_RETCODE updateEstimate ( SCIP_SET set,
SCIP_STAT stat,
SCIP_TREE tree,
SCIP_LP lp,
SCIP_BRANCHCAND branchcand 
)
static

updates the estimated value of a primal feasible solution for the focus node after the LP was solved

Parameters
setglobal SCIP settings
statproblem statistics
treebranch and bound tree
lpcurrent LP data
branchcandbranching candidate storage

Definition at line 1062 of file solve.c.

References MIN, NULL, SCIP_CALL, SCIP_LPSOLSTAT_OPTIMAL, SCIP_OKAY, SCIP_Real, SCIPbranchcandGetLPCands(), SCIPlpGetSolstat(), SCIPlpIsRelax(), SCIPnodeGetLowerbound(), SCIPnodeSetEstimate(), SCIPsetIsInfinity(), SCIPtreeGetFocusNode(), SCIPtreeHasFocusNodeLP(), and SCIPvarGetPseudocost().

Referenced by priceAndCutLoop(), and propAndSolve().

◆ SCIPinitConssLP()

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

Parameters
blkmemblock memory buffers
setglobal SCIP settings
sepastoreseparation storage
cutpoolglobal cutpool
statdynamic problem statistics
transprobtransformed problem
origproboriginal problem
treebranch and bound tree
reoptreoptimization data structure
lpLP data
branchcandbranching candidate storage
eventqueueevent queue
eventfilterglobal event filter
cliquetableclique table data structure
rootis this the initial root LP?
firstsubtreeinitis this the first call in the current subtree after jumping through the tree?
cutoffpointer to store whether the node can be cut off

Definition at line 1112 of file solve.c.

References FALSE, SCIP_Tree::focusnode, h, NULL, SCIP_CALL, SCIP_EFFICIACYCHOICE_LP, SCIP_OKAY, SCIPconshdlrInitLP(), SCIPreoptApplyCuts(), SCIPsepastoreApplyCuts(), SCIPsepastoreClearCuts(), SCIPsepastoreEndInitialLP(), SCIPsepastoreStartInitialLP(), and SCIPsetDebugMsg.

Referenced by initLP(), priceAndCutLoop(), SCIPconstructCurrentLP(), SCIPpriceLoop(), solveNodeLP(), and solveProbingLP().

◆ initLP()

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 
)
static

constructs the initial LP of the current node

Parameters
blkmemblock memory buffers
setglobal SCIP settings
statdynamic problem statistics
transprobtransformed problem
origproboriginal problem
treebranch and bound tree
reoptreoptimization data structure
lpLP data
pricestorepricing storage
sepastoreseparation storage
cutpoolglobal cut pool
branchcandbranching candidate storage
eventqueueevent queue
eventfilterglobal event filter
cliquetableclique table data structure
rootis this the initial root LP?
cutoffpointer to store whether the node can be cut off

Definition at line 1177 of file solve.c.

References FALSE, SCIP_Lp::nremovablecols, SCIP_Lp::nremovablerows, NULL, SCIP_Prob::nvars, SCIP_CALL, SCIP_OKAY, SCIP_VARSTATUS_COLUMN, SCIPcolIsInLP(), SCIPinitConssLP(), SCIPlpGetNCols(), SCIPlpGetNRows(), SCIPpricestoreAddVar(), SCIPpricestoreApplyVars(), SCIPpricestoreEndInitialLP(), SCIPpricestoreStartInitialLP(), SCIPsetDebugMsg, SCIPsetIsGT(), SCIPvarGetCol(), SCIPvarGetLbLocal(), SCIPvarGetProbindex(), SCIPvarGetStatus(), SCIPvarGetUbLocal(), SCIPvarIsInitial(), TRUE, and SCIP_Prob::vars.

Referenced by SCIPconstructCurrentLP().

◆ 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

Parameters
blkmemblock memory buffers
setglobal SCIP settings
statdynamic problem statistics
transprobtransformed problem
origproboriginal problem
treebranch and bound tree
reoptreoptimization data structure
lpLP data
pricestorepricing storage
sepastoreseparation storage
cutpoolglobal cutpool
branchcandbranching candidate storage
eventqueueevent queue
eventfilterglobal event filter
cliquetableclique table data structure
newinitconssdo we have to add new initial constraints?
cutoffpointer to store whether the node can be cut off

Definition at line 1285 of file solve.c.

References SCIP_Row::age, SCIP_Tree::correctlpdepth, FALSE, SCIP_Row::fromcutpool, initLP(), SCIP_Row::local, NULL, 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().

◆ updatePrimalRay()

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

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

Parameters
blkmemblock memory buffers
setglobal SCIP settings
statdynamic problem statistics
probtransformed problem after presolve
primalprimal data
treebranch and bound tree
lpLP data
lperrorhas there been an LP error?

Definition at line 1376 of file solve.c.

References BMSclearMemoryArray, FALSE, NULL, 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().

◆ solveNodeInitialLP()

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

load and solve the initial LP of a node

Parameters
blkmemblock memory buffers
setglobal SCIP settings
messagehdlrmessage handler
statdynamic problem statistics
transprobtransformed problem after presolve
origproboriginal problem
primalprimal data
treebranch and bound tree
reoptreoptimization data structure
lpLP data
pricestorepricing storage
sepastoreseparation storage
cutpoolglobal cutpool
branchcandbranching candidate storage
eventfilterevent filter for global (not variable dependent) events
eventqueueevent queue
cliquetableclique table data structure
newinitconssdo we have to add new initial constraints?
cutoffpointer to store whether the node can be cut off
lperrorpointer to store whether an unresolved error in LP solving occured

Definition at line 1443 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, NULL, 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().

◆ separationRoundResolveLP()

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

makes sure the LP is flushed and solved

Parameters
blkmemblock memory buffers
setglobal SCIP settings
messagehdlrmessage handler
statdynamic problem statistics
eventqueueevent queue
eventfilterglobal event filter
probtransformed problem after presolve
primalprimal data
treebranch and bound tree
lpLP data
lperrorpointer to store whether an unresolved error in LP solving occured
mustsepapointer to store TRUE if additional separation rounds should be performed
mustpricepointer to store TRUE if additional pricing rounds should be performed

Definition at line 1566 of file solve.c.

References FALSE, SCIP_Lp::flushed, NULL, SCIP_CALL, SCIP_OKAY, SCIPlpSolveAndEval(), SCIPsetDebugMsg, SCIP_Lp::solved, TRUE, and updatePrimalRay().

Referenced by separationRoundLP().

◆ separationRoundLP()

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

applies one round of LP separation

Parameters
blkmemblock memory buffers
setglobal SCIP settings
messagehdlrmessage handler
statdynamic problem statistics
eventqueueevent queue
eventfilterglobal event filter
probtransformed problem after presolve
primalprimal data
treebranch and bound tree
lpLP data
sepastoreseparation storage
actdepthcurrent depth in the tree
bounddistcurrent relative distance of local dual bound to global dual bound
allowlocalshould the separators be asked to separate local cuts
onlydelayedshould only delayed separators be called?
delayedpointer to store whether a separator was delayed
enoughcutspointer to store whether enough cuts have been found this round
cutoffpointer to store whether the node can be cut off
lperrorpointer to store whether an unresolved error in LP solving occured
mustsepapointer to store TRUE if additional separation rounds should be performed
mustpricepointer to store TRUE if additional pricing rounds should be performed

Definition at line 1607 of file solve.c.

References BMSgetNUsedBufferMemory(), FALSE, SCIP_Lp::flushed, NULL, 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(), SCIPsetCeil(), SCIPsetDebugMsg, SCIPsetGetSepaMaxcuts(), SCIPsetGetSepaMaxcutsGenFactor(), SCIPsetIsNegative(), SCIPsetIsZero(), SCIPsetSortSepas(), separationRoundResolveLP(), SCIP_Lp::solved, and TRUE.

Referenced by priceAndCutLoop(), and SCIPseparationRound().

◆ separationRoundSol()

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 
)
static

applies one round of separation on the given primal solution

Parameters
blkmemblock memory buffers
setglobal SCIP settings
statdynamic problem statistics
sepastoreseparation storage
solprimal solution that should be separated, or NULL for LP solution
actdepthcurrent depth in the tree
allowlocalshould the separator be asked to separate local cuts
onlydelayedshould only delayed separators be called?
delayedpointer to store whether a separator was delayed
enoughcutspointer to store whether enough cuts have been found this round
cutoffpointer to store whether the node can be cut off

Definition at line 1863 of file solve.c.

References FALSE, NULL, 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(), SCIPsetCeil(), SCIPsetDebugMsg, SCIPsetGetSepaMaxcuts(), SCIPsetGetSepaMaxcutsGenFactor(), SCIPsetIsNegative(), SCIPsetIsZero(), SCIPsetSortSepas(), SCIPsolveIsStopped(), and TRUE.

Referenced by SCIPseparationRound().

◆ 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

Parameters
blkmemblock memory buffers
setglobal SCIP settings
messagehdlrmessage handler
statdynamic problem statistics
eventqueueevent queue
eventfilterglobal event filter
probtransformed problem after presolve
primalprimal data
treebranch and bound tree
lpLP data
sepastoreseparation storage
solprimal solution that should be separated, or NULL for LP solution
actdepthcurrent depth in the tree
allowlocalshould the separator be asked to separate local cuts
onlydelayedshould only delayed separators be called?
delayedpointer to store whether a separator was delayed
cutoffpointer to store whether the node can be cut off

Definition at line 2042 of file solve.c.

References FALSE, NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, separationRoundLP(), and separationRoundSol().

Referenced by SCIPseparateSol().

◆ SCIPpriceLoop()

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

Parameters
blkmemblock memory buffers
setglobal SCIP settings
messagehdlrmessage handler
statdynamic problem statistics
transprobtransformed problem
origproboriginal problem
primalprimal data
treebranch and bound tree
reoptreoptimization data structure
lpLP data
pricestorepricing storage
sepastoreseparation storage
cutpoolglobal cutpool
branchcandbranching candidate storage
eventqueueevent queue
eventfilterglobal event filter
cliquetableclique table data structure
pretendrootshould the pricers be called as if we are at the root node?
displayinfoshould info lines be displayed after each pricing round?
maxpriceroundsmaximal number of pricing rounds (-1: no limit); a finite limit means that the LP might not be solved to optimality!
npricedcolvarspointer to store number of column variables after problem vars were priced
mustsepapointer to store TRUE if a separation round should follow
lperrorpointer to store whether an unresolved error in LP solving occured
abortedpointer to store whether the pricing was aborted and the lower bound must not be used

Definition at line 2095 of file solve.c.

References SCIP_Primal::cutoffbound, FALSE, SCIP_Lp::flushed, SCIP_Prob::ncolvars, SCIP_Stat::npricerounds, NULL, 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().

◆ cutpoolSeparate()

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

separates cuts of the cut pool

Parameters
cutpoolcut pool
blkmemblock memory
setglobal SCIP settings
statproblem statistics data
eventqueueevent queue
eventfilterevent filter for global events
lpcurrent LP data
sepastoreseparation storage
cutpoolisdelayedis the cutpool delayed (count cuts found)?
rootare we at the root node?
actdepththe depth of the focus node
enoughcutspointer to store if enough cuts were found in current separation round
cutoffpointer to store if a cutoff was detected

Definition at line 2312 of file solve.c.

References NULL, SCIP_CALL, SCIP_CUTOFF, SCIP_Longint, SCIP_NEWROUND, SCIP_OKAY, SCIPcutpoolSeparate(), SCIPsepastoreGetNCuts(), SCIPsetCeil(), SCIPsetGetSepaMaxcuts(), SCIPsetGetSepaMaxcutsGenFactor(), SCIPsetIsNegative(), SCIPsetIsZero(), and TRUE.

Referenced by priceAndCutLoop().

◆ priceAndCutLoop()

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

solve the current LP of a node with a price-and-cut loop

Parameters
blkmemblock memory buffers
setglobal SCIP settings
messagehdlrmessage handler
statdynamic problem statistics
memblock memory pools
transprobtransformed problem
origproboriginal problem
primalprimal data
treebranch and bound tree
reoptreoptimization data structure
lpLP data
pricestorepricing storage
sepastoreseparation storage
cutpoolglobal cut pool
delayedcutpoolglobal delayed cut pool
branchcandbranching candidate storage
conflictconflict analysis data
conflictstoreconflict store
eventfilterevent filter for global (not variable dependent) events
eventqueueevent queue
cliquetableclique table data structure
fullseparationare we in the first prop-and-cut-and-price loop?
propagateagainpointer to store whether we want to propagate again
cutoffpointer to store whether the node can be cut off
unboundedpointer to store whether an unbounded ray was found in the LP
lperrorpointer to store whether an unresolved error in LP solving occured
pricingabortedpointer to store whether the pricing was aborted and the lower bound must not be used

Definition at line 2352 of file solve.c.

References BMSgetNUsedBufferMemory(), SCIP_Mem::buffer, SCIP_Primal::cutoffbound, cutpoolSeparate(), SCIP_Stat::domchgcount, FALSE, SCIP_Lp::flushed, SCIP_Lp::installing, MIN, SCIP_Stat::nboundchgs, SCIP_Prob::ncolvars, SCIP_Stat::ninitconssadded, SCIP_Stat::nruns, SCIP_Stat::nseparounds, NULL, propagateDomains(), SCIP_Lp::resolvelperror, SCIP_Bool, SCIP_CALL, SCIP_EFFICIACYCHOICE_LP, SCIP_EVENTTYPE_LPSOLVED, SCIP_HEURTIMING_DURINGLPLOOP, SCIP_Longint, SCIP_LONGINT_FORMAT, 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(), SCIPsetGetSepaMaxcutsGenFactor(), SCIPsetInfinity(), SCIPsetIsGE(), SCIPsetIsLE(), SCIPsetIsLT(), SCIPsetIsZero(), SCIPsolveIsStopped(), SCIPtreeGetCurrentDepth(), SCIPtreeGetFocusNode(), SCIPtreeGetLowerbound(), separationRoundLP(), SCIP_Lp::solved, TRUE, updateEstimate(), updatePrimalRay(), and updatePseudocost().

Referenced by solveNodeLP().

◆ applyBounding()

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

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

Parameters
blkmemblock memory buffers
setglobal SCIP settings
statdynamic problem statistics
transprobtranformed problem after presolve
origproboriginal problem
primalprimal data
treebranch and bound tree
reoptreoptimization data structure
lpLP data
branchcandbranching candidate storage
eventqueueevent queue
conflictconflict analysis data
cliquetableclique table data structure
cutoffpointer to store TRUE, if the node can be cut off

Definition at line 2962 of file solve.c.

References SCIP_Primal::cutoffbound, NULL, 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().

◆ markRelaxsUnsolved()

static void markRelaxsUnsolved ( SCIP_SET set,
SCIP_RELAXATION relaxation 
)
static

marks all relaxators to be unsolved

Parameters
setglobal SCIP settings
relaxationglobal relaxation data

Definition at line 3022 of file solve.c.

References FALSE, NULL, r, SCIPrelaxationSetSolValid(), and SCIPrelaxMarkUnsolved().

Referenced by applyCuts(), enforceConstraints(), propAndSolve(), solveNode(), and solveNodeLP().

◆ solveNodeLP()

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

solves the current node's LP in a price-and-cut loop

Parameters
blkmemblock memory buffers
setglobal SCIP settings
messagehdlrmessage handler
statdynamic problem statistics
memblock memory pools
origproboriginal problem
transprobtransformed problem after presolve
primalprimal data
treebranch and bound tree
reoptreoptimization data structure
lpLP data
relaxationrelaxators
pricestorepricing storage
sepastoreseparation storage
cutpoolglobal cut pool
delayedcutpoolglobal delayed cut pool
branchcandbranching candidate storage
conflictconflict analysis data
conflictstoreconflict store
eventfilterevent filter for global (not variable dependent) events
eventqueueevent queue
cliquetableclique table data structure
initiallpsolvedwas the initial LP already solved?
fullseparationare we in the first prop-and-cut-and-price loop?
newinitconssdo we have to add new initial constraints?
propagateagainpointer to store whether we want to propagate again
solverelaxagainpointer to store TRUE, if the external relaxators should be called again
cutoffpointer to store TRUE, if the node can be cut off
unboundedpointer to store TRUE, if an unbounded ray was found in the LP
lperrorpointer to store TRUE, if an unresolved error in LP solving occured
pricingabortedpointer to store TRUE, if the pricing was aborted and the lower bound must not be used

Definition at line 3040 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_Stat::nbarrierzeroitlps, SCIP_Primal::nbestsolsfound, SCIP_Stat::nboundchgs, SCIP_Prob::ncolvars, SCIP_Stat::ndualzeroitlps, 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::nnodezeroitlps, SCIP_Stat::nprimalzeroitlps, SCIP_Stat::nrootlpiterations, SCIP_Stat::nrootlps, NULL, 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().

◆ solveNodeRelax()

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

calls relaxators

Parameters
setglobal SCIP settings
statdynamic problem statistics
treebranch and bound tree
relaxationrelaxators
transprobtransformed problem
origproboriginal problem
depthdepth of current node
beforelpshould the relaxators with non-negative or negative priority be called?
cutoffpointer to store TRUE, if the node can be cut off
propagateagainpointer to store TRUE, if domain propagation should be applied again
solvelpagainpointer to store TRUE, if the node's LP has to be solved again
solverelaxagainpointer to store TRUE, if the external relaxators should be called again
relaxcalledpointer to store TRUE, if at least one relaxator was called (unmodified otherwise)

Definition at line 3284 of file solve.c.

References NULL, r, 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().

◆ enforceConstraints()

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

enforces constraints by branching, separation, or domain reduction

Parameters
blkmemblock memory buffers
setglobal SCIP settings
messagehdlrmessage handler
statdynamic problem statistics
probtransformed problem after presolve
primalprimal data
treebranch and bound tree
lpLP data
relaxationglobal relaxation data
sepastoreseparation storage
branchcandbranching candidate storage
branchedpointer to store whether a branching was created
cutoffpointer to store TRUE, if the node can be cut off
infeasiblepointer to store TRUE, if the LP/pseudo solution is infeasible
propagateagainpointer to store TRUE, if domain propagation should be applied again
solvelpagainpointer to store TRUE, if the node's LP has to be solved again
solverelaxagainpointer to store TRUE, if the external relaxators should be called again
forcedshould enforcement of pseudo solution be forced?

Definition at line 3384 of file solve.c.

References SCIP_Stat::disableenforelaxmsg, FALSE, SCIP_Lp::flushed, h, markRelaxsUnsolved(), SCIP_Tree::nchildren, SCIP_Stat::ninternalnodes, SCIP_Stat::ntotalinternalnodes, NULL, 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().

◆ applyCuts()

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

applies the cuts stored in the separation store, or clears the store if the node can be cut off

Parameters
blkmemblock memory buffers
setglobal SCIP settings
statdynamic problem statistics
transprobtransformed problem
origproboriginal problem
treebranch and bound tree
reoptreotimization data structure
lpLP data
relaxationrelaxators
sepastoreseparation storage
branchcandbranching candidate storage
eventqueueevent queue
eventfilterglobal event filter
cliquetableclique table data structure
rootis this the initial root LP?
efficiacychoicetype of solution to base efficiacy computation on
cutoffpointer to whether the node can be cut off
propagateagainpointer to store TRUE, if domain propagation should be applied again
solvelpagainpointer to store TRUE, if the node's LP has to be solved again
solverelaxagainpointer to store TRUE, if the node's relaxation has to be solved again

Definition at line 3675 of file solve.c.

References SCIP_Stat::domchgcount, markRelaxsUnsolved(), NULL, SCIP_CALL, SCIP_Longint, SCIP_OKAY, SCIPsepastoreApplyCuts(), SCIPsepastoreClearCuts(), SCIPsepastoreGetNCuts(), SCIPsepastoreGetNCutsApplied(), and TRUE.

Referenced by propAndSolve(), and solveNode().

◆ updateLoopStatus()

static void updateLoopStatus ( SCIP_SET set,
SCIP_STAT stat,
SCIP_TREE tree,
int  depth,
SCIP_Bool cutoff,
SCIP_Bool propagateagain,
SCIP_Bool solverelaxagain 
)
static

updates the cutoff, propagateagain, and solverelaxagain status of the current solving loop

Parameters
setglobal SCIP settings
statdynamic problem statistics
treebranch and bound tree
depthdepth of current node
cutoffpointer to store TRUE, if the node can be cut off
propagateagainpointer to store TRUE, if domain propagation should be applied again
solverelaxagainpointer to store TRUE, if at least one relaxator should be called again

Definition at line 3731 of file solve.c.

References SCIP_Tree::cutoffdepth, FALSE, SCIP_Tree::nchildren, NULL, r, SCIPnodeIsPropagatedAgain(), SCIPrelaxIsSolved(), and SCIPtreeGetFocusNode().

Referenced by solveNode().

◆ propAndSolve()

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

propagate domains and solve relaxation and lp

Parameters
blkmemblock memory buffers
setglobal SCIP settings
messagehdlrmessage handler
statdynamic problem statistics
memblock memory pools
origproboriginal problem
transprobtransformed problem after presolve
primalprimal data
treebranch and bound tree
reoptreoptimization data structure
lpLP data
relaxationglobal relaxation data
pricestorepricing storage
sepastoreseparation storage
branchcandbranching candidate storage
cutpoolglobal cut pool
delayedcutpoolglobal delayed cut pool
conflictconflict analysis data
conflictstoreconflict store
eventfilterevent filter for global (not variable dependent) events
eventqueueevent queue
cliquetableclique table data structure
focusnodefocused node
actdepthdepth in the b&b tree
propagateshould we propagate
solvelpshould we solve the lp
solverelaxshould we solve the relaxation
forcedlpsolveis there a need for a solve lp
initiallpsolvedwas the initial LP already solved?
fullseparationare we in the first prop-and-cut-and-price loop?
afterlpproplpspointer to store the last LP count for which AFTERLP propagation was performed
heurtimingtiming for running heuristics after propagation call
nlperrorspointer to store the number of lp errors
fullpropagationpointer to store whether we want to do a fullpropagation next time
propagateagainpointer to store whether we want to propagate again
lpsolvedpointer to store whether the lp was solved
relaxcalledpointer to store whether a relaxator was called; initialized with last loop's result
solvelpagainpointer to store whether we want to solve the lp again
solverelaxagainpointer to store whether we want to solve the relaxation again
cutoffpointer to store whether the node can be cut off
postponepointer to store whether the node should be postponed
unboundedpointer to store whether the focus node is unbounded
stoppedpointer to store whether solving was interrupted
lperrorpointer to store TRUE, if an unresolved error in LP solving occured
pricingabortedpointer to store TRUE, if the pricing was aborted and the lower bound must not be used
forcedenforcementpointer to store whether the enforcement of pseudo solution should be forced

Definition at line 3774 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, NULL, propagateDomains(), SCIP_Lp::resolvelperror, SCIP_Bool, SCIP_CALL, SCIP_EFFICIACYCHOICE_RELAX, SCIP_HEURTIMING_AFTERPROPLOOP, SCIP_Longint, SCIP_LONGINT_FORMAT, 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().

◆ restartAllowed()

static SCIP_Bool restartAllowed ( SCIP_SET set,
SCIP_STAT stat 
)
static

check if a restart can be performed

Parameters
setglobal SCIP settings
statdynamic problem statistics

Definition at line 4125 of file solve.c.

References SCIP_Stat::nruns, and NULL.

Referenced by SCIPsolveCIP(), and solveNode().

◆ solveNode()

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

solves the focus node

Parameters
blkmemblock memory buffers
setglobal SCIP settings
messagehdlrmessage handler
statdynamic problem statistics
memblock memory pools
origproboriginal problem
transprobtransformed problem after presolve
primalprimal data
treebranch and bound tree
reoptreoptimization data structure
lpLP data
relaxationglobal relaxation data
pricestorepricing storage
sepastoreseparation storage
branchcandbranching candidate storage
cutpoolglobal cut pool
delayedcutpoolglobal delayed cut pool
conflictconflict analysis data
conflictstoreconflict store
eventfilterevent filter for global (not variable dependent) events
eventqueueevent queue
cliquetableclique table data structure
cutoffpointer to store whether the node can be cut off
postponepointer to store whether the node should be postponed
unboundedpointer to store whether the focus node is unbounded
infeasiblepointer to store whether the focus node's solution is infeasible
restartshould solving process be started again with presolving?
afternodeheurpointer to store whether AFTERNODE heuristics were already called
stoppedpointer to store whether solving was interrupted

Definition at line 4142 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, MIN, SCIP_Primal::nbestsolsfound, SCIP_Tree::nchildren, SCIP_Prob::ncontvars, 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, NULL, 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_LONGINT_FORMAT, 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(), SCIPlpResetFeastol(), 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().

◆ addCurrentSolution()

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 
)
static

if feasible, adds current solution to the solution storage

Parameters
blkmemblock memory buffers
setglobal SCIP settings
messagehdlrmessage handler
statdynamic problem statistics
origproboriginal problem
transprobtransformed problem after presolve
primalprimal data
relaxationglobal relaxation data
treebranch and bound tree
reoptreoptimization data structure
lpLP data
eventqueueevent queue
eventfilterevent filter for global (not variable dependent) events
checksolshould the solution be checked?

Definition at line 4807 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, NULL, 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().

◆ 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

Parameters
blkmemblock memory buffers
setglobal SCIP settings
messagehdlrmessage handler
statdynamic problem statistics
memblock memory pools
origproboriginal problem
transprobtransformed problem after presolve
primalprimal data
treebranch and bound tree
reoptreoptimization data structure
lpLP data
relaxationglobal relaxation data
pricestorepricing storage
sepastoreseparation storage
cutpoolglobal cut pool
delayedcutpoolglobal delayed cut pool
branchcandbranching candidate storage
conflictconflict analysis data
conflictstoreconflict store
eventfilterevent filter for global (not variable dependent) events
eventqueueevent queue
cliquetableclique table data structure
restartshould solving process be started again with presolving?

Definition at line 4944 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, MIN, 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, NULL, 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_LONGINT_FORMAT, 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(), SCIPgetUpperbound(), SCIPlpGetObjval(), SCIPlpGetSolstat(), SCIPmessagePrintVerbInfo(), SCIPnodeFocus(), SCIPnodeGetDepth(), SCIPnodeGetLowerbound(), SCIPnodeselSelect(), SCIPprimalHeuristics(), SCIPprobGetObjlim(), SCIPprobInternObjval(), SCIPrelaxationGetSolObj(), SCIPrelaxationIsLpIncludedForSol(), SCIPrelaxationIsSolValid(), SCIPreoptCheckCutoff(), SCIPsetDebugMsg, SCIPsetGetNodesel(), SCIPsetInfinity(), SCIPsetIsGE(), SCIPsetIsGT(), SCIPsetIsInfinity(), SCIPsolCreateLPSol(), SCIPsolCreatePseudoSol(), SCIPsolCreateRelaxSol(), SCIPsolFree(), SCIPsolGetObj(), SCIPsolveIsStopped(), SCIPstatUpdateMemsaveMode(), SCIPstatUpdatePrimalDualIntegrals(), 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().