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

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

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

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

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

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

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

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

set	global SCIP settings
stat	problem statistics
tree	branch and bound tree
lp	current LP data
branchcand	branching 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

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

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

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

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

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

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

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

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

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

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

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

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

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

set	global SCIP settings
relaxation	global 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

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

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

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

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

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

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

set	global SCIP settings
stat	dynamic 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

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

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

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 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().

SCIP

Detailed Description

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ MAXNLPERRORS

◆ MAXNCLOCKSKIPS

◆ NINITCALLS

◆ SAFETYFACTOR

Typedef Documentation

◆ PSEUDOCOSTFLAG

Enumeration Type Documentation

◆ PseudocostFlag

Function Documentation

◆ SCIPsolveIsStopped()

◆ SCIPprimalHeuristics()

◆ propagationRound()

◆ propagateDomains()

◆ SCIPpropagateDomains()

◆ isPseudocostUpdateValid()

◆ updatePseudocost()

◆ updateEstimate()

◆ SCIPinitConssLP()

◆ initLP()

◆ SCIPconstructCurrentLP()

◆ updatePrimalRay()

◆ solveNodeInitialLP()

◆ separationRoundResolveLP()

◆ separationRoundLP()

◆ separationRoundSol()

◆ SCIPseparationRound()

◆ SCIPpriceLoop()

◆ cutpoolSeparate()

◆ priceAndCutLoop()

◆ applyBounding()

◆ markRelaxsUnsolved()

◆ solveNodeLP()

◆ solveNodeRelax()

◆ enforceConstraints()

◆ applyCuts()

◆ updateLoopStatus()

◆ propAndSolve()

◆ restartAllowed()

◆ solveNode()

◆ addCurrentSolution()

◆ SCIPsolveCIP()