solve.c File Reference

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.

Referenced by solveNode().

MAXNCLOCKSKIPS

#define MAXNCLOCKSKIPS   64

maximum number of SCIPsolveIsStopped() calls without checking the clock

Definition at line 95 of file solve.c.

Referenced by SCIPsolveIsStopped().

NINITCALLS

#define NINITCALLS   1000L

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

Definition at line 96 of file solve.c.

Referenced by SCIPsolveIsStopped().

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.

Referenced by SCIPsolveIsStopped().

Typedef Documentation

PSEUDOCOSTFLAG

typedef enum PseudocostFlag PSEUDOCOSTFLAG

Definition at line 739 of file solve.c.

Enumeration Type Documentation

PseudocostFlag

enum 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 733 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

set	global SCIP settings
stat	dynamic problem statistics
checknodelimits	should 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_Real, SCIP_STAGE_PRESOLVING, SCIP_STAGE_SOLVING, SCIP_STATUS_BESTSOLLIMIT, SCIP_STATUS_GAPLIMIT, SCIP_STATUS_MEMLIMIT, SCIP_STATUS_NODELIMIT, SCIP_STATUS_SOLLIMIT, SCIP_STATUS_STALLNODELIMIT, SCIP_STATUS_TERMINATE, SCIP_STATUS_TIMELIMIT, SCIP_STATUS_TOTALNODELIMIT, SCIP_STATUS_UNKNOWN, SCIP_STATUS_USERINTERRUPT, SCIPclockGetLastTime(), SCIPclockGetTime(), SCIPgetConcurrentMemTotal(), SCIPgetGap(), SCIPgetLowerbound(), SCIPgetNBestSolsFound(), SCIPgetNConcurrentSolvers(), SCIPgetNLimSolsFound(), SCIPgetSyncstore(), SCIPgetTransObjscale(), SCIPgetUpperbound(), SCIPinterrupted(), SCIPresetInterrupted(), SCIPsetIsLE(), SCIPsetIsLT(), 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

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 214 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

blkmem	block memory buffers
set	global SCIP settings
stat	dynamic problem statistics
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 400 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

blkmem	block memory buffers
set	global SCIP settings
stat	dynamic problem statistics
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 569 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

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
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 644 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

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 676 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

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 743 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

set	global SCIP settings
stat	problem statistics
tree	branch and bound tree
lp	current LP data
branchcand	branching candidate storage

Definition at line 1058 of file solve.c.

References 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

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 1108 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

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 1173 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

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 1281 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

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 1372 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

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 1439 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

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 1562 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

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 1603 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(), SCIPsetDebugMsg, SCIPsetGetSepaMaxcuts(), 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

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 1817 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(), SCIPsetDebugMsg, SCIPsetGetSepaMaxcuts(), 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

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 1960 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

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 2013 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

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 2230 of file solve.c.

References NULL, SCIP_CALL, SCIP_CUTOFF, SCIP_Longint, SCIP_NEWROUND, SCIP_OKAY, SCIPcutpoolSeparate(), SCIPsepastoreGetNCuts(), and SCIPsetGetSepaMaxcuts().

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

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 2261 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::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_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().

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

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 2845 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

set	global SCIP settings
relaxation	global relaxation data

Definition at line 2905 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

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 2923 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

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 3167 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

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 3267 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

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 3558 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

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 3614 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

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 3657 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_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

set	global SCIP settings
stat	dynamic problem statistics

Definition at line 4008 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

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 4027 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::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_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

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 4692 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

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 4829 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, 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_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().