Detailed Description

Constraint handler for knapsack constraints of the form $a^T x \le b$ , x binary and $a \ge 0$ .

Author: Tobias Achterberg; Xin Liu; Kati Wolter; Michael Winkler

#include <assert.h>
#include <string.h>
#include <limits.h>
#include <stdio.h>
#include <ctype.h>
#include "scip/cons_knapsack.h"
#include "scip/cons_linear.h"
#include "scip/cons_logicor.h"
#include "scip/cons_setppc.h"
#include "scip/pub_misc.h"

Go to the source code of this file.

Macros
#define	CONSHDLR_NAME "knapsack"

#define	CONSHDLR_DESC "knapsack constraint of the form a^T x <= b, x binary and a >= 0"

#define	CONSHDLR_SEPAPRIORITY +600000

#define	CONSHDLR_ENFOPRIORITY -600000

#define	CONSHDLR_CHECKPRIORITY -600000

#define	CONSHDLR_SEPAFREQ 0

#define	CONSHDLR_PROPFREQ 1

#define	CONSHDLR_EAGERFREQ 100

#define	CONSHDLR_MAXPREROUNDS -1

#define	CONSHDLR_DELAYSEPA FALSE

#define	CONSHDLR_DELAYPROP FALSE

#define	CONSHDLR_DELAYPRESOL FALSE

#define	CONSHDLR_NEEDSCONS TRUE

#define	CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP

#define	EVENTHDLR_NAME "knapsack"

#define	EVENTHDLR_DESC "bound change event handler for knapsack constraints"

#define	LINCONSUPGD_PRIORITY +100000

#define	MAX_USECLIQUES_SIZE 1000

#define	MAX_ZEROITEMS_SIZE 10000

#define	KNAPSACKRELAX_MAXDELTA 0.1

#define	KNAPSACKRELAX_MAXDNOM 1000LL

#define	KNAPSACKRELAX_MAXSCALE 1000.0

#define	DEFAULT_SEPACARDFREQ 1

#define	DEFAULT_MAXROUNDS 5

#define	DEFAULT_MAXROUNDSROOT -1

#define	DEFAULT_MAXSEPACUTS 50

#define	DEFAULT_MAXSEPACUTSROOT 200

#define	DEFAULT_MAXCARDBOUNDDIST 0.0

#define	DEFAULT_DISAGGREGATION TRUE

#define	DEFAULT_SIMPLIFYINEQUALITIES TRUE

#define	DEFAULT_NEGATEDCLIQUE TRUE

#define	MAXABSVBCOEF 1e+5

#define	USESUPADDLIFT FALSE

#define	DEFAULT_PRESOLUSEHASHING TRUE

#define	HASHSIZE_KNAPSACKCONS 131101

#define	DEFAULT_PRESOLPAIRWISE TRUE

#define	NMINCOMPARISONS 200000

#define	MINGAINPERNMINCOMPARISONS 1e-06

#define	DEFAULT_DUALPRESOLVING TRUE

#define	DEFAULT_DETECTCUTOFFBOUND TRUE

#define	DEFAULT_DETECTLOWERBOUND TRUE

#define	MAXCOVERSIZEITERLEWI 1000

#define	DEFAULT_USEGUBS FALSE

#define	GUBCONSGROWVALUE 6

#define	GUBSPLITGNC1GUBS FALSE

#define	IDX(j, d) ((j)*(intcap)+(d))

#define	MAXNCLIQUEVARSCOMP 1000000

#define	MAX_CLIQUELENGTH 50

Typedefs
typedef struct sortkeypair	SORTKEYPAIR

typedef enum GUBVarstatus	GUBVARSTATUS

typedef enum GUBConsstatus	GUBCONSSTATUS

typedef struct SCIP_GUBCons	SCIP_GUBCONS

typedef struct SCIP_GUBSet	SCIP_GUBSET

Enumerations
enum	GUBVarstatus { GUBVARSTATUS_UNINITIAL = -1, GUBVARSTATUS_CAPACITYEXCEEDED = 0, GUBVARSTATUS_BELONGSTOSET_R = 1, GUBVARSTATUS_BELONGSTOSET_F = 2, GUBVARSTATUS_BELONGSTOSET_C2 = 3, GUBVARSTATUS_BELONGSTOSET_C1 = 4 }

enum	GUBConsstatus { GUBCONSSTATUS_UNINITIAL = -1, GUBCONSSTATUS_BELONGSTOSET_GR = 0, GUBCONSSTATUS_BELONGSTOSET_GF = 1, GUBCONSSTATUS_BELONGSTOSET_GC2 = 2, GUBCONSSTATUS_BELONGSTOSET_GNC1 = 3, GUBCONSSTATUS_BELONGSTOSET_GOC1 = 4 }

Functions
static	SCIP_DECL_SORTPTRCOMP (compSortkeypairs)

static SCIP_RETCODE	eventdataCreate (SCIP scip, SCIP_EVENTDATA eventdata, SCIP_CONSDATA consdata, SCIP_Longint weight)

static SCIP_RETCODE	eventdataFree (SCIP scip, SCIP_EVENTDATA *eventdata)

static void	sortItems (SCIP_CONSDATA *consdata)

static SCIP_RETCODE	calcCliquepartition (SCIP scip, SCIP_CONSDATA consdata, SCIP_Bool normalclique, SCIP_Bool negatedclique)

static SCIP_RETCODE	lockRounding (SCIP scip, SCIP_CONS cons, SCIP_VAR *var)

static SCIP_RETCODE	unlockRounding (SCIP scip, SCIP_CONS cons, SCIP_VAR *var)

static SCIP_RETCODE	catchEvents (SCIP scip, SCIP_CONSDATA consdata, SCIP_EVENTHDLR *eventhdlr)

static SCIP_RETCODE	dropEvents (SCIP scip, SCIP_CONSDATA consdata, SCIP_EVENTHDLR *eventhdlr)

static SCIP_RETCODE	consdataEnsureVarsSize (SCIP scip, SCIP_CONSDATA consdata, int num, SCIP_Bool transformed)

static SCIP_RETCODE	consdataCreate (SCIP scip, SCIP_CONSDATA consdata, SCIP_EVENTHDLR eventhdlr, int nvars, SCIP_VAR *vars, SCIP_Longint weights, SCIP_Longint capacity)

static SCIP_RETCODE	consdataFree (SCIP scip, SCIP_CONSDATA consdata, SCIP_EVENTHDLR eventhdlr)

static void	consdataChgWeight (SCIP_CONSDATA *consdata, int item, SCIP_Longint newweight)

static SCIP_RETCODE	createRelaxation (SCIP scip, SCIP_CONS cons)

static SCIP_RETCODE	addRelaxation (SCIP scip, SCIP_CONS cons, SCIP_SOL sol, SCIP_Bool cutoff)

static SCIP_RETCODE	checkCons (SCIP scip, SCIP_CONS cons, SCIP_SOL sol, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_Bool violated)

SCIP_RETCODE	SCIPsolveKnapsackExactly (SCIP scip, int nitems, SCIP_Longint weights, SCIP_Real profits, SCIP_Longint capacity, int items, int solitems, int nonsolitems, int nsolitems, int nnonsolitems, SCIP_Real solval, SCIP_Bool success)

SCIP_RETCODE	SCIPsolveKnapsackApproximately (SCIP scip, int nitems, SCIP_Longint weights, SCIP_Real profits, SCIP_Longint capacity, int items, int solitems, int nonsolitems, int nsolitems, int nnonsolitems, SCIP_Real *solval)

static SCIP_Bool	checkSolveKnapsack (SCIP scip, int nitems, SCIP_Longint transweights, SCIP_Real transprofits, int items, SCIP_Longint weights, SCIP_Real solvals, SCIP_Bool modtransused)

static SCIP_RETCODE	GUBconsCreate (SCIP scip, SCIP_GUBCONS *gubcons)

static SCIP_RETCODE	GUBconsFree (SCIP scip, SCIP_GUBCONS *gubcons)

static SCIP_RETCODE	GUBconsAddVar (SCIP scip, SCIP_GUBCONS gubcons, int var)

static SCIP_RETCODE	GUBconsDelVar (SCIP scip, SCIP_GUBCONS gubcons, int var, int gubvarsidx)

static SCIP_RETCODE	GUBsetMoveVar (SCIP scip, SCIP_GUBSET gubset, SCIP_VAR **vars, int var, int oldgubcons, int newgubcons)

static void	GUBsetSwapVars (SCIP scip, SCIP_GUBSET gubset, int var1, int var2)

static SCIP_RETCODE	GUBsetCreate (SCIP scip, SCIP_GUBSET gubset, int nvars, SCIP_Longint weights, SCIP_Longint capacity)

static SCIP_RETCODE	GUBsetFree (SCIP scip, SCIP_GUBSET *gubset)

static SCIP_RETCODE	GUBsetCheck (SCIP scip, SCIP_GUBSET gubset, SCIP_VAR **vars)

static SCIP_RETCODE	GUBsetCalcCliquePartition (SCIP const scip, SCIP_VAR const vars, int const nvars, int const cliquepartition, int const ncliques, SCIP_Real solvals)

static SCIP_RETCODE	GUBsetGetCliquePartition (SCIP scip, SCIP_GUBSET gubset, SCIP_VAR *vars, SCIP_Real solvals)

static SCIP_RETCODE	getCover (SCIP scip, SCIP_VAR vars, int nvars, SCIP_Longint weights, SCIP_Longint capacity, SCIP_Real solvals, int covervars, int noncovervars, int ncovervars, int nnoncovervars, SCIP_Longint coverweight, SCIP_Bool found, SCIP_Bool modtransused, int ntightened, SCIP_Bool *fractional)

static SCIP_Bool	checkMinweightidx (SCIP_Longint weights, SCIP_Longint capacity, int covervars, int ncovervars, SCIP_Longint coverweight, int minweightidx, int j)

static void	getPartitionCovervars (SCIP scip, SCIP_Real solvals, int covervars, int ncovervars, int varsC1, int varsC2, int nvarsC1, int *nvarsC2)

static SCIP_RETCODE	changePartitionCovervars (SCIP scip, SCIP_Longint weights, int varsC1, int varsC2, int nvarsC1, int nvarsC2)

static SCIP_RETCODE	changePartitionFeasiblesetvars (SCIP scip, SCIP_Longint weights, int varsC1, int varsC2, int nvarsC1, int nvarsC2)

static void	getPartitionNoncovervars (SCIP scip, SCIP_Real solvals, int noncovervars, int nnoncovervars, int varsF, int varsR, int nvarsF, int *nvarsR)

static SCIP_RETCODE	getLiftingSequence (SCIP scip, SCIP_Real solvals, SCIP_Longint weights, int varsF, int varsC2, int varsR, int nvarsF, int nvarsC2, int nvarsR)

static SCIP_RETCODE	getLiftingSequenceGUB (SCIP scip, SCIP_GUBSET gubset, SCIP_Real solvals, SCIP_Longint weights, int varsC1, int varsC2, int varsF, int varsR, int nvarsC1, int nvarsC2, int nvarsF, int nvarsR, int gubconsGC1, int gubconsGC2, int gubconsGFC1, int gubconsGR, int ngubconsGC1, int ngubconsGC2, int ngubconsGFC1, int ngubconsGR, int ngubconscapexceed, int maxgubvarssize)

static SCIP_RETCODE	enlargeMinweights (SCIP scip, SCIP_Longint minweightsptr, int minweightslen, int *minweightssize, int newlen)

static SCIP_RETCODE	sequentialUpAndDownLifting (SCIP scip, SCIP_VAR vars, int nvars, int ntightened, SCIP_Longint weights, SCIP_Longint capacity, SCIP_Real solvals, int varsM1, int varsM2, int varsF, int varsR, int nvarsM1, int nvarsM2, int nvarsF, int nvarsR, int alpha0, int liftcoefs, SCIP_Real cutact, int liftrhs)

static SCIP_Longint	safeAddMinweightsGUB (SCIP_Longint val1, SCIP_Longint val2)

static void	computeMinweightsGUB (SCIP_Longint minweights, SCIP_Longint finished, SCIP_Longint *unfinished, int minweightslen)

static SCIP_RETCODE	sequentialUpAndDownLiftingGUB (SCIP scip, SCIP_GUBSET gubset, SCIP_VAR *vars, int ngubconscapexceed, SCIP_Longint weights, SCIP_Longint capacity, SCIP_Real solvals, int gubconsGC1, int gubconsGC2, int gubconsGFC1, int gubconsGR, int ngubconsGC1, int ngubconsGC2, int ngubconsGFC1, int ngubconsGR, int alpha0, int liftcoefs, SCIP_Real cutact, int liftrhs, int maxgubvarssize)

static SCIP_RETCODE	superadditiveUpLifting (SCIP scip, SCIP_VAR vars, int nvars, int ntightened, SCIP_Longint weights, SCIP_Longint capacity, SCIP_Real solvals, int covervars, int noncovervars, int ncovervars, int nnoncovervars, SCIP_Longint coverweight, SCIP_Real liftcoefs, SCIP_Real *cutact)

static SCIP_RETCODE	separateSequLiftedMinimalCoverInequality (SCIP scip, SCIP_CONS cons, SCIP_SEPA sepa, SCIP_VAR vars, int nvars, int ntightened, SCIP_Longint weights, SCIP_Longint capacity, SCIP_Real solvals, int mincovervars, int nonmincovervars, int nmincovervars, int nnonmincovervars, SCIP_SOL sol, SCIP_GUBSET gubset, SCIP_Bool cutoff, int *ncuts)

static SCIP_RETCODE	separateSequLiftedExtendedWeightInequality (SCIP scip, SCIP_CONS cons, SCIP_SEPA sepa, SCIP_VAR vars, int nvars, int ntightened, SCIP_Longint weights, SCIP_Longint capacity, SCIP_Real solvals, int feassetvars, int nonfeassetvars, int nfeassetvars, int nnonfeassetvars, SCIP_SOL sol, SCIP_Bool cutoff, int ncuts)

static SCIP_RETCODE	separateSupLiftedMinimalCoverInequality (SCIP scip, SCIP_CONS cons, SCIP_SEPA sepa, SCIP_VAR vars, int nvars, int ntightened, SCIP_Longint weights, SCIP_Longint capacity, SCIP_Real solvals, int mincovervars, int nonmincovervars, int nmincovervars, int nnonmincovervars, SCIP_Longint mincoverweight, SCIP_SOL sol, SCIP_Bool cutoff, int ncuts)

static SCIP_RETCODE	makeCoverMinimal (SCIP scip, SCIP_Longint weights, SCIP_Longint capacity, SCIP_Real solvals, int covervars, int noncovervars, int ncovervars, int nnoncovervars, SCIP_Longint coverweight, SCIP_Bool modtransused)

static SCIP_RETCODE	getFeasibleSet (SCIP scip, SCIP_CONS cons, SCIP_SEPA sepa, SCIP_VAR vars, int nvars, int ntightened, SCIP_Longint weights, SCIP_Longint capacity, SCIP_Real solvals, int covervars, int noncovervars, int ncovervars, int nnoncovervars, SCIP_Longint coverweight, SCIP_Bool modtransused, SCIP_SOL sol, SCIP_Bool cutoff, int *ncuts)

SCIP_RETCODE	SCIPseparateKnapsackCuts (SCIP scip, SCIP_CONS cons, SCIP_SEPA sepa, SCIP_VAR vars, int nvars, SCIP_Longint weights, SCIP_Longint capacity, SCIP_SOL sol, SCIP_Bool usegubs, SCIP_Bool cutoff, int *ncuts)

SCIP_RETCODE	SCIPseparateRelaxedKnapsack (SCIP scip, SCIP_CONS cons, SCIP_SEPA sepa, int nknapvars, SCIP_VAR knapvars, SCIP_Real knapvals, SCIP_Real valscale, SCIP_Real rhs, SCIP_SOL sol, SCIP_Bool cutoff, int *ncuts)

static SCIP_RETCODE	separateCons (SCIP scip, SCIP_CONS cons, SCIP_SOL sol, SCIP_Bool sepacuts, SCIP_Bool usegubs, SCIP_Bool cutoff, int *ncuts)

static SCIP_RETCODE	addCoef (SCIP scip, SCIP_CONS cons, SCIP_VAR *var, SCIP_Longint weight)

static SCIP_RETCODE	delCoefPos (SCIP scip, SCIP_CONS cons, int pos)

static SCIP_RETCODE	removeZeroWeights (SCIP scip, SCIP_CONS cons)

static SCIP_RETCODE	performVarDeletions (SCIP scip, SCIP_CONSHDLR conshdlr, SCIP_CONS **conss, int nconss)

static SCIP_RETCODE	mergeMultiples (SCIP scip, SCIP_CONS cons, SCIP_Bool *cutoff)

static SCIP_RETCODE	dualPresolving (SCIP scip, SCIP_CONS cons, int nfixedvars, int ndelconss, SCIP_Bool *deleted)

static SCIP_RETCODE	checkParallelObjective (SCIP scip, SCIP_CONS cons, SCIP_CONSHDLRDATA *conshdlrdata)

static SCIP_RETCODE	stableSort (SCIP scip, SCIP_CONSDATA consdata, SCIP_VAR *vars, SCIP_Longint weights, int *cliquestartposs, SCIP_Bool usenegatedclique)

static SCIP_RETCODE	propagateCons (SCIP scip, SCIP_CONS cons, SCIP_Bool cutoff, SCIP_Bool redundant, int *nfixedvars, SCIP_Bool usenegatedclique)

static SCIP_RETCODE	upgradeCons (SCIP scip, SCIP_CONS cons, int ndelconss, int naddconss)

static SCIP_RETCODE	deleteRedundantVars (SCIP scip, SCIP_CONS cons, SCIP_Longint frontsum, int splitpos, int nchgcoefs, int nchgsides, int *naddconss)

static SCIP_RETCODE	detectRedundantVars (SCIP scip, SCIP_CONS cons, int ndelconss, int nchgcoefs, int nchgsides, int naddconss)

static void	normalizeWeights (SCIP_CONS cons, int nchgcoefs, int *nchgsides)

static SCIP_RETCODE	dualWeightsTightening (SCIP scip, SCIP_CONS cons, int ndelconss, int nchgcoefs, int nchgsides, int naddconss)

static SCIP_RETCODE	prepareCons (SCIP scip, SCIP_CONS cons, int nfixedvars, int ndelconss, int *nchgcoefs)

static SCIP_RETCODE	simplifyInequalities (SCIP scip, SCIP_CONS cons, int nfixedvars, int ndelconss, int nchgcoefs, int nchgsides, int naddconss, SCIP_Bool cutoff)

static SCIP_RETCODE	applyFixings (SCIP scip, SCIP_CONS cons, SCIP_Bool *cutoff)

static SCIP_RETCODE	insertZerolist (SCIP scip, int liftcands, int nliftcands, int firstidxs, SCIP_Longint zeroweightsums, int zeroitems, int nextidxs, int zeroitemssize, int nzeroitems, int probindex, SCIP_Bool value, int knapsackidx, SCIP_Longint knapsackweight, SCIP_Bool *memlimitreached)

static SCIP_RETCODE	tightenWeightsLift (SCIP scip, SCIP_CONS cons, int nchgcoefs, SCIP_Bool cutoff)

static SCIP_RETCODE	tightenWeights (SCIP scip, SCIP_CONS cons, int nchgcoefs, int nchgsides, int naddconss, int ndelconss, SCIP_Bool *cutoff)

static SCIP_RETCODE	addNegatedCliques (SCIP const scip, SCIP_CONS const cons, SCIP_Bool const cutoff, int const nbdchgs)

static SCIP_RETCODE	addCliques (SCIP const scip, SCIP_CONS const cons, SCIP_Bool const cutoff, int const nbdchgs)

static	SCIP_DECL_HASHGETKEY (hashGetKeyKnapsackcons)

static	SCIP_DECL_HASHKEYEQ (hashKeyEqKnapsackcons)

static	SCIP_DECL_HASHKEYVAL (hashKeyValKnapsackcons)

static SCIP_RETCODE	detectRedundantConstraints (SCIP scip, BMS_BLKMEM blkmem, SCIP_CONS *conss, int nconss, SCIP_Bool cutoff, int *ndelconss)

static SCIP_RETCODE	preprocessConstraintPairs (SCIP scip, SCIP_CONS conss, int firstchange, int chkind, int ndelconss)

static SCIP_RETCODE	createNormalizedKnapsack (SCIP scip, SCIP_CONS cons, const char name, int nvars, SCIP_VAR *vars, SCIP_Real vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)

static	SCIP_DECL_LINCONSUPGD (linconsUpgdKnapsack)

static	SCIP_DECL_CONSHDLRCOPY (conshdlrCopyKnapsack)

static	SCIP_DECL_CONSFREE (consFreeKnapsack)

static	SCIP_DECL_CONSINIT (consInitKnapsack)

static	SCIP_DECL_CONSEXIT (consExitKnapsack)

static	SCIP_DECL_CONSINITPRE (consInitpreKnapsack)

static	SCIP_DECL_CONSEXITPRE (consExitpreKnapsack)

static	SCIP_DECL_CONSEXITSOL (consExitsolKnapsack)

static	SCIP_DECL_CONSDELETE (consDeleteKnapsack)

static	SCIP_DECL_CONSTRANS (consTransKnapsack)

static	SCIP_DECL_CONSINITLP (consInitlpKnapsack)

static	SCIP_DECL_CONSSEPALP (consSepalpKnapsack)

static	SCIP_DECL_CONSSEPASOL (consSepasolKnapsack)

static	SCIP_DECL_CONSENFOLP (consEnfolpKnapsack)

static	SCIP_DECL_CONSENFOPS (consEnfopsKnapsack)

static	SCIP_DECL_CONSCHECK (consCheckKnapsack)

static	SCIP_DECL_CONSPROP (consPropKnapsack)

static	SCIP_DECL_CONSPRESOL (consPresolKnapsack)

static	SCIP_DECL_CONSRESPROP (consRespropKnapsack)

static	SCIP_DECL_CONSLOCK (consLockKnapsack)

static	SCIP_DECL_CONSDELVARS (consDelvarsKnapsack)

static	SCIP_DECL_CONSPRINT (consPrintKnapsack)

static	SCIP_DECL_CONSCOPY (consCopyKnapsack)

static	SCIP_DECL_CONSPARSE (consParseKnapsack)

static	SCIP_DECL_CONSGETVARS (consGetVarsKnapsack)

static	SCIP_DECL_CONSGETNVARS (consGetNVarsKnapsack)

static	SCIP_DECL_EVENTEXEC (eventExecKnapsack)

SCIP_RETCODE	SCIPincludeConshdlrKnapsack (SCIP *scip)

SCIP_RETCODE	SCIPcreateConsKnapsack (SCIP scip, SCIP_CONS cons, const char name, int nvars, SCIP_VAR *vars, SCIP_Longint weights, SCIP_Longint capacity, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)

SCIP_RETCODE	SCIPcreateConsBasicKnapsack (SCIP scip, SCIP_CONS cons, const char name, int nvars, SCIP_VAR *vars, SCIP_Longint weights, SCIP_Longint capacity)

SCIP_RETCODE	SCIPaddCoefKnapsack (SCIP scip, SCIP_CONS cons, SCIP_VAR *var, SCIP_Longint weight)

SCIP_Longint	SCIPgetCapacityKnapsack (SCIP scip, SCIP_CONS cons)

SCIP_RETCODE	SCIPchgCapacityKnapsack (SCIP scip, SCIP_CONS cons, SCIP_Longint capacity)

int	SCIPgetNVarsKnapsack (SCIP scip, SCIP_CONS cons)

SCIP_VAR **	SCIPgetVarsKnapsack (SCIP scip, SCIP_CONS cons)

SCIP_Longint *	SCIPgetWeightsKnapsack (SCIP scip, SCIP_CONS cons)

SCIP_Real	SCIPgetDualsolKnapsack (SCIP scip, SCIP_CONS cons)

SCIP_Real	SCIPgetDualfarkasKnapsack (SCIP scip, SCIP_CONS cons)

SCIP_ROW *	SCIPgetRowKnapsack (SCIP scip, SCIP_CONS cons)

Macro Definition Documentation

#define CONSHDLR_NAME "knapsack"

Definition at line 39 of file cons_knapsack.c.

Referenced by SCIPcreateConsKnapsack(), and SCIPseparateRelaxedKnapsack().

#define CONSHDLR_DESC "knapsack constraint of the form a^T x <= b, x binary and a >= 0"

Definition at line 40 of file cons_knapsack.c.

#define CONSHDLR_SEPAPRIORITY +600000

priority of the constraint handler for separation

Definition at line 41 of file cons_knapsack.c.

#define CONSHDLR_ENFOPRIORITY -600000

priority of the constraint handler for constraint enforcing

Definition at line 42 of file cons_knapsack.c.

#define CONSHDLR_CHECKPRIORITY -600000

priority of the constraint handler for checking feasibility

Definition at line 43 of file cons_knapsack.c.

#define CONSHDLR_SEPAFREQ 0

frequency for separating cuts; zero means to separate only in the root node

Definition at line 44 of file cons_knapsack.c.

#define CONSHDLR_PROPFREQ 1

frequency for propagating domains; zero means only preprocessing propagation

Definition at line 45 of file cons_knapsack.c.

#define CONSHDLR_EAGERFREQ 100

frequency for using all instead of only the useful constraints in separation, propagation and enforcement, -1 for no eager evaluations, 0 for first only

Definition at line 46 of file cons_knapsack.c.

#define CONSHDLR_MAXPREROUNDS -1

maximal number of presolving rounds the constraint handler participates in (-1: no limit)

Definition at line 49 of file cons_knapsack.c.

#define CONSHDLR_DELAYSEPA FALSE

should separation method be delayed, if other separators found cuts?

Definition at line 50 of file cons_knapsack.c.

#define CONSHDLR_DELAYPROP FALSE

should propagation method be delayed, if other propagators found reductions?

Definition at line 51 of file cons_knapsack.c.

#define CONSHDLR_DELAYPRESOL FALSE

should presolving method be delayed, if other presolvers found reductions?

Definition at line 52 of file cons_knapsack.c.

#define CONSHDLR_NEEDSCONS TRUE

should the constraint handler be skipped, if no constraints are available?

Definition at line 53 of file cons_knapsack.c.

#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP

Definition at line 55 of file cons_knapsack.c.

#define EVENTHDLR_NAME "knapsack"

Definition at line 57 of file cons_knapsack.c.

#define EVENTHDLR_DESC "bound change event handler for knapsack constraints"

Definition at line 58 of file cons_knapsack.c.

#define LINCONSUPGD_PRIORITY +100000

priority of the constraint handler for upgrading of linear constraints

Definition at line 60 of file cons_knapsack.c.

#define MAX_USECLIQUES_SIZE 1000

maximal number of items in knapsack where clique information is used

Definition at line 66 of file cons_knapsack.c.

Referenced by tightenWeights().

#define MAX_ZEROITEMS_SIZE 10000

maximal number of items to store in the zero list in preprocessing

Definition at line 67 of file cons_knapsack.c.

Referenced by insertZerolist().

#define KNAPSACKRELAX_MAXDELTA 0.1

maximal allowed rounding distance for scaling in knapsack relaxation

Definition at line 69 of file cons_knapsack.c.

Referenced by SCIPseparateRelaxedKnapsack().

#define KNAPSACKRELAX_MAXDNOM 1000LL

maximal allowed denominator in knapsack rational relaxation

Definition at line 70 of file cons_knapsack.c.

Referenced by SCIPseparateRelaxedKnapsack().

#define KNAPSACKRELAX_MAXSCALE 1000.0

maximal allowed scaling factor in knapsack rational relaxation

Definition at line 71 of file cons_knapsack.c.

Referenced by SCIPseparateRelaxedKnapsack().

#define DEFAULT_SEPACARDFREQ 1

multiplier on separation frequency, how often knapsack cuts are separated

Definition at line 73 of file cons_knapsack.c.

#define DEFAULT_MAXROUNDS 5

maximal number of separation rounds per node (-1: unlimited)

Definition at line 74 of file cons_knapsack.c.

#define DEFAULT_MAXROUNDSROOT -1

maximal number of separation rounds in the root node (-1: unlimited)

Definition at line 75 of file cons_knapsack.c.

#define DEFAULT_MAXSEPACUTS 50

maximal number of cuts separated per separation round

Definition at line 76 of file cons_knapsack.c.

#define DEFAULT_MAXSEPACUTSROOT 200

maximal number of cuts separated per separation round in the root node

Definition at line 77 of file cons_knapsack.c.

#define DEFAULT_MAXCARDBOUNDDIST 0.0

maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for separating knapsack cuts

Definition at line 78 of file cons_knapsack.c.

#define DEFAULT_DISAGGREGATION TRUE

should disaggregation of knapsack constraints be allowed in preprocessing?

Definition at line 81 of file cons_knapsack.c.

#define DEFAULT_SIMPLIFYINEQUALITIES TRUE

should presolving try to simplify knapsacks

Definition at line 82 of file cons_knapsack.c.

#define DEFAULT_NEGATEDCLIQUE TRUE

should negated clique information be used in solving process

Definition at line 83 of file cons_knapsack.c.

#define MAXABSVBCOEF 1e+5

maximal absolute coefficient in variable bounds used for knapsack relaxation

Definition at line 85 of file cons_knapsack.c.

Referenced by SCIPseparateRelaxedKnapsack().

#define USESUPADDLIFT FALSE

should lifted minimal cover inequalities using superadditive up-lifting be separated in addition

Definition at line 86 of file cons_knapsack.c.

Referenced by SCIPseparateKnapsackCuts().

#define DEFAULT_PRESOLUSEHASHING TRUE

should hash table be used for detecting redundant constraints in advance

Definition at line 88 of file cons_knapsack.c.

#define HASHSIZE_KNAPSACKCONS 131101

minimal size of hash table in linear constraint tables

Definition at line 89 of file cons_knapsack.c.

Referenced by detectRedundantConstraints().

#define DEFAULT_PRESOLPAIRWISE TRUE

should pairwise constraint comparison be performed in presolving?

Definition at line 91 of file cons_knapsack.c.

#define NMINCOMPARISONS 200000

number for minimal pairwise presolving comparisons

Definition at line 92 of file cons_knapsack.c.

#define MINGAINPERNMINCOMPARISONS 1e-06

minimal gain per minimal pairwise presolving comparisons to repeat pairwise comparison round

Definition at line 93 of file cons_knapsack.c.

#define DEFAULT_DUALPRESOLVING TRUE

should dual presolving steps be performed?

Definition at line 96 of file cons_knapsack.c.

#define DEFAULT_DETECTCUTOFFBOUND TRUE

should presolving try to detect constraints parallel to the objective function defining an upper bound and prevent these constraints from entering the LP

Definition at line 97 of file cons_knapsack.c.

#define DEFAULT_DETECTLOWERBOUND TRUE

should presolving try to detect constraints parallel to the objective function defining a lower bound and prevent these constraints from entering the LP

Definition at line 102 of file cons_knapsack.c.

#define MAXCOVERSIZEITERLEWI 1000

maximal size for which LEWI are iteratively separated by reducing the feasible set

Definition at line 108 of file cons_knapsack.c.

Referenced by getFeasibleSet().

#define DEFAULT_USEGUBS FALSE

should GUB information be used for separation?

Definition at line 110 of file cons_knapsack.c.

Referenced by SCIPseparateRelaxedKnapsack().

#define GUBCONSGROWVALUE 6

memory growing value for GUB constraint array

Definition at line 111 of file cons_knapsack.c.

#define GUBSPLITGNC1GUBS FALSE

should GNC1 GUB conss without F vars be split into GOC1 and GR GUB conss?

Definition at line 112 of file cons_knapsack.c.

#define IDX	(	j,
		d
	)	((j)*(intcap)+(d))

Definition at line 942 of file cons_knapsack.c.

Referenced by SCIPsolveKnapsackExactly().

#define MAXNCLIQUEVARSCOMP 1000000

calculates a partition of the given set of binary variables into cliques; afterwards the output array contains one value for each variable, such that two variables got the same value iff they were assigned to the same clique; the first variable is always assigned to clique 0, and a variable can only be assigned to clique i if at least one of the preceding variables was assigned to clique i-1; note: in contrast to SCIPcalcCliquePartition(), variables with LP value 1 are put into trivial cliques (with one variable) and for the remaining variables, a partition with a small number of cliques is constructed

Definition at line 2089 of file cons_knapsack.c.

Referenced by GUBsetCalcCliquePartition().

#define MAX_CLIQUELENGTH 50

Definition at line 9638 of file cons_knapsack.c.

Typedef Documentation

typedef struct sortkeypair SORTKEYPAIR

Definition at line 218 of file cons_knapsack.c.

typedef enum GUBVarstatus GUBVARSTATUS

Definition at line 230 of file cons_knapsack.c.

typedef enum GUBConsstatus GUBCONSSTATUS

Definition at line 242 of file cons_knapsack.c.

typedef struct SCIP_GUBCons SCIP_GUBCONS

Definition at line 252 of file cons_knapsack.c.

typedef struct SCIP_GUBSet SCIP_GUBSET

Definition at line 264 of file cons_knapsack.c.

Enumeration Type Documentation

enum GUBVarstatus

status of GUB constraint

Enumerator
GUBVARSTATUS_UNINITIAL
GUBVARSTATUS_CAPACITYEXCEEDED	unintitialized variable status
GUBVARSTATUS_BELONGSTOSET_R	variable with weight exceeding the knapsack capacity
GUBVARSTATUS_BELONGSTOSET_F	variable in noncovervars R
GUBVARSTATUS_BELONGSTOSET_C2	variable in noncovervars F
GUBVARSTATUS_BELONGSTOSET_C1	variable in covervars C2

Definition at line 221 of file cons_knapsack.c.

enum GUBConsstatus

status of variable in GUB constraint

Enumerator
GUBCONSSTATUS_UNINITIAL
GUBCONSSTATUS_BELONGSTOSET_GR	unintitialized GUB constraint status
GUBCONSSTATUS_BELONGSTOSET_GF	all GUB variables are in noncovervars R
GUBCONSSTATUS_BELONGSTOSET_GC2	all GUB variables are in noncovervars F (and noncovervars R)
GUBCONSSTATUS_BELONGSTOSET_GNC1	all GUB variables are in covervars C2
GUBCONSSTATUS_BELONGSTOSET_GOC1	some GUB variables are in covervars C1, others in noncovervars R or F

Definition at line 233 of file cons_knapsack.c.

Function Documentation

static SCIP_DECL_SORTPTRCOMP ( compSortkeypairs )

static

comparison method for two sorting key pairs

Definition at line 272 of file cons_knapsack.c.

static SCIP_RETCODE eventdataCreate	(	SCIP *	scip,
		SCIP_EVENTDATA **	eventdata,
		SCIP_CONSDATA *	consdata,
		SCIP_Longint	weight
	)

static

creates event data

Parameters

scip	SCIP data structure
eventdata	pointer to store event data
consdata	constraint data
weight	weight of variable

Definition at line 291 of file cons_knapsack.c.

static SCIP_RETCODE eventdataFree	(	SCIP *	scip,
		SCIP_EVENTDATA **	eventdata
	)

static

frees event data

Parameters

scip	SCIP data structure
eventdata	pointer to event data

Definition at line 309 of file cons_knapsack.c.

static void sortItems ( SCIP_CONSDATA * consdata )

static

sorts items in knapsack with nonincreasing weights

Parameters

consdata constraint data

Definition at line 323 of file cons_knapsack.c.

Referenced by prepareCons(), preprocessConstraintPairs(), propagateCons(), and tightenWeights().

static SCIP_RETCODE calcCliquepartition	(	SCIP *	scip,
		SCIP_CONSDATA *	consdata,
		SCIP_Bool	normalclique,
		SCIP_Bool	negatedclique
	)

static

calculates a partition of the variables into cliques

Parameters

scip	SCIP data structure
consdata	constraint data
normalclique	Should normal cliquepartition be created?
negatedclique	Should negated cliquepartition be created?

Definition at line 423 of file cons_knapsack.c.

Referenced by detectRedundantVars(), propagateCons(), and tightenWeights().

static SCIP_RETCODE lockRounding	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var
	)

static

installs rounding locks for the given variable in the given knapsack constraint

Parameters

scip	SCIP data structure
cons	knapsack constraint
var	variable of constraint entry

Definition at line 453 of file cons_knapsack.c.

static SCIP_RETCODE unlockRounding	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var
	)

static

removes rounding locks for the given variable in the given knapsack constraint

Parameters

scip	SCIP data structure
cons	knapsack constraint
var	variable of constraint entry

Definition at line 467 of file cons_knapsack.c.

static SCIP_RETCODE catchEvents	(	SCIP *	scip,
		SCIP_CONSDATA *	consdata,
		SCIP_EVENTHDLR *	eventhdlr
	)

static

catches bound change events for variables in knapsack

Parameters

scip	SCIP data structure
consdata	constraint data
eventhdlr	event handler to call for the event processing

Definition at line 481 of file cons_knapsack.c.

Referenced by consdataCreate().

static SCIP_RETCODE dropEvents	(	SCIP *	scip,
		SCIP_CONSDATA *	consdata,
		SCIP_EVENTHDLR *	eventhdlr
	)

static

drops bound change events for variables in knapsack

Parameters

scip	SCIP data structure
consdata	constraint data
eventhdlr	event handler to call for the event processing

Definition at line 508 of file cons_knapsack.c.

static SCIP_RETCODE consdataEnsureVarsSize	(	SCIP *	scip,
		SCIP_CONSDATA *	consdata,
		int	num,
		SCIP_Bool	transformed
	)

static

ensures, that vars and vals arrays can store at least num entries

Parameters

scip	SCIP data structure
consdata	knapsack constraint data
num	minimum number of entries to store
transformed	is constraint from transformed problem?

Definition at line 535 of file cons_knapsack.c.

static SCIP_RETCODE consdataCreate	(	SCIP *	scip,
		SCIP_CONSDATA **	consdata,
		SCIP_EVENTHDLR *	eventhdlr,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Longint *	weights,
		SCIP_Longint	capacity
	)

static

creates knapsack constraint data

Parameters

scip	SCIP data structure
consdata	pointer to store constraint data
eventhdlr	event handler to call for the event processing
nvars	number of variables in knapsack
vars	variables of knapsack
weights	weights of knapsack items
capacity	capacity of knapsack

Definition at line 573 of file cons_knapsack.c.

References catchEvents(), FALSE, NULL, SCIP_GUBSet::nvars, SCIP_CALL, SCIP_OKAY, SCIP_VARSTATUS_MULTAGGR, SCIPallocBlockMemory, SCIPallocBlockMemoryArray, SCIPcaptureVar(), SCIPduplicateBlockMemoryArray, SCIPfreeBlockMemoryArray, SCIPgetTransformedVars(), SCIPisTransformed(), SCIPreallocBlockMemoryArray, SCIPvarGetLbLocal(), SCIPvarGetProbvar(), and SCIPvarGetStatus().

Referenced by SCIPcreateConsKnapsack().

static SCIP_RETCODE consdataFree	(	SCIP *	scip,
		SCIP_CONSDATA **	consdata,
		SCIP_EVENTHDLR *	eventhdlr
	)

static

frees knapsack constraint data

Parameters

scip	SCIP data structure
consdata	pointer to the constraint data
eventhdlr	event handler to call for the event processing

Definition at line 698 of file cons_knapsack.c.

static void consdataChgWeight	(	SCIP_CONSDATA *	consdata,
		int	item,
		SCIP_Longint	newweight
	)

static

changes a single weight in knapsack constraint data

Parameters

consdata	knapsack constraint data
item	item number
newweight	new weight of item

Definition at line 748 of file cons_knapsack.c.

Referenced by deleteRedundantVars(), dualWeightsTightening(), simplifyInequalities(), and tightenWeights().

static SCIP_RETCODE createRelaxation	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

static

creates LP row corresponding to knapsack constraint

Parameters

scip	SCIP data structure
cons	knapsack constraint

Definition at line 786 of file cons_knapsack.c.

static SCIP_RETCODE addRelaxation	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SOL *	sol,
		SCIP_Bool *	cutoff
	)

static

adds linear relaxation of knapsack constraint to the LP

Parameters

scip	SCIP data structure
cons	knapsack constraint
sol	primal CIP solution, NULL for current LP solution
cutoff	whether a cutoff has been detected

Definition at line 814 of file cons_knapsack.c.

Referenced by separateCons().

static SCIP_RETCODE checkCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SOL *	sol,
		SCIP_Bool	checklprows,
		SCIP_Bool	printreason,
		SCIP_Bool *	violated
	)

static

checks knapsack constraint for feasibility of given solution: returns TRUE iff constraint is feasible

Parameters

scip	SCIP data structure
cons	constraint to check
sol	solution to check, NULL for current solution
checklprows	should LP rows be checked?
printreason	should the reason for the violation be printed?
violated	pointer to store whether the constraint is violated

Definition at line 849 of file cons_knapsack.c.

References FALSE, NULL, SCIP_Bool, SCIP_CALL, SCIP_Longint, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMessage, SCIPgetSolVal(), SCIPincConsAge(), SCIPinfoMessage(), SCIPisFeasGT(), SCIPisHugeValue(), SCIPprintCons(), SCIPresetConsAge(), SCIProwIsInLP(), SCIPvarIsBinary(), and TRUE.

Referenced by separateCons().

SCIP_RETCODE SCIPsolveKnapsackExactly	(	SCIP *	scip,
		int	nitems,
		SCIP_Longint *	weights,
		SCIP_Real *	profits,
		SCIP_Longint	capacity,
		int *	items,
		int *	solitems,
		int *	nonsolitems,
		int *	nsolitems,
		int *	nnonsolitems,
		SCIP_Real *	solval,
		SCIP_Bool *	success
	)

solves knapsack problem in maximization form exactly using dynamic programming; if needed, one can provide arrays to store all selected items and all not selected items

Note: in case you provide the solitems or nonsolitems array you also have to provide the counter part as well

Parameters

scip	SCIP data structure
nitems	number of available items
weights	item weights
profits	item profits
capacity	capacity of knapsack
items	item numbers
solitems	array to store items in solution, or NULL
nonsolitems	array to store items not in solution, or NULL
nsolitems	pointer to store number of items in solution, or NULL
nnonsolitems	pointer to store number of items not in solution, or NULL
solval	pointer to store optimal solution value, or NULL
success	pointer to store if an error occured during solving(normally a memory problem)

Definition at line 949 of file cons_knapsack.c.

References FALSE, IDX, MAX, NULL, SCIP_Bool, SCIP_CALL, SCIP_Longint, SCIP_LONGINT_MAX, SCIP_NOMEMORY, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPallocMemoryArray, SCIPcalcGreComDiv(), SCIPdebugMessage, SCIPfreeBufferArray, SCIPfreeMemoryArray, SCIPsortDownRealIntLong(), SCIPsortDownRealLongRealInt(), and TRUE.

Referenced by dualPresolving(), getFlowCover(), and getHighestCapacityUsage().

SCIP_RETCODE SCIPsolveKnapsackApproximately	(	SCIP *	scip,
		int	nitems,
		SCIP_Longint *	weights,
		SCIP_Real *	profits,
		SCIP_Longint	capacity,
		int *	items,
		int *	solitems,
		int *	nonsolitems,
		int *	nsolitems,
		int *	nnonsolitems,
		SCIP_Real *	solval
	)

solves knapsack problem in maximization form approximately by solving the LP-relaxation of the problem using Dantzig's method and rounding down the solution; if needed, one can provide arrays to store all selected items and all not selected items

Parameters

scip	SCIP data structure
nitems	number of available items
weights	item weights
profits	item profits
capacity	capacity of knapsack
items	item numbers
solitems	array to store items in solution, or NULL
nonsolitems	array to store items not in solution, or NULL
nsolitems	pointer to store number of items in solution, or NULL
nnonsolitems	pointer to store number of items not in solution, or NULL
solval	pointer to store optimal solution value, or NULL

Definition at line 1492 of file cons_knapsack.c.

References NULL, SCIP_CALL, SCIP_Longint, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPfreeBufferArray, and SCIPsortDownRealLongRealInt().

Referenced by getCover().

static SCIP_Bool checkSolveKnapsack	(	SCIP *	scip,
		int	nitems,
		SCIP_Longint *	transweights,
		SCIP_Real *	transprofits,
		int *	items,
		SCIP_Longint *	weights,
		SCIP_Real *	solvals,
		SCIP_Bool	modtransused
	)

static

returns, whether the the arrays transweights, transprofits and items are sorted such that p_1 / w_1 >= p_2 / w_2 >= ... >= p_n / w_n and these arrays are not changed

Parameters

scip	SCIP data structure
nitems	number of available items
transweights	item weights
transprofits	item profits
items	item numbers
weights	weights of variables in knapsack constraint
solvals	solution values of all problem variables
modtransused	TRUE for mod trans sepa prob was used to find cover

Definition at line 1563 of file cons_knapsack.c.

References FALSE, NULL, SCIPisFeasEQ(), SCIPisFeasGE(), SCIPisFeasLT(), and TRUE.

Referenced by getCover().

static SCIP_RETCODE GUBconsCreate	(	SCIP *	scip,
		SCIP_GUBCONS **	gubcons
	)

static

creates an empty GUB constraint

Parameters

scip	SCIP data structure
gubcons	pointer to store GUB constraint data

Definition at line 1678 of file cons_knapsack.c.

Referenced by getLiftingSequenceGUB(), and GUBsetCreate().

static SCIP_RETCODE GUBconsFree	(	SCIP *	scip,
		SCIP_GUBCONS **	gubcons
	)

static

frees GUB constraint

Parameters

scip	SCIP data structure
gubcons	pointer to GUB constraint data structure

Definition at line 1699 of file cons_knapsack.c.

Referenced by GUBsetMoveVar().

static SCIP_RETCODE GUBconsAddVar	(	SCIP *	scip,
		SCIP_GUBCONS *	gubcons,
		int	var
	)

static

adds variable to given GUB constraint

Parameters

scip	SCIP data structure
gubcons	GUB constraint data
var	index of given variable in knapsack constraint

Definition at line 1719 of file cons_knapsack.c.

Referenced by GUBsetCreate(), and GUBsetMoveVar().

static SCIP_RETCODE GUBconsDelVar	(	SCIP *	scip,
		SCIP_GUBCONS *	gubcons,
		int	var,
		int	gubvarsidx
	)

static

deletes variable from its current GUB constraint

Parameters

scip	SCIP data structure
gubcons	GUB constraint data
var	index of given variable in knapsack constraint
gubvarsidx	index of the variable in its current GUB constraint

Definition at line 1754 of file cons_knapsack.c.

Referenced by GUBsetMoveVar().

static SCIP_RETCODE GUBsetMoveVar	(	SCIP *	scip,
		SCIP_GUBSET *	gubset,
		SCIP_VAR **	vars,
		int	var,
		int	oldgubcons,
		int	newgubcons
	)

static

moves variable from current GUB constraint to a different existing (nonempty) GUB constraint

Parameters

scip	SCIP data structure
gubset	GUB set data structure
vars	variables in knapsack constraint
var	index of given variable in knapsack constraint
oldgubcons	index of old GUB constraint of given variable
newgubcons	index of new GUB constraint of given variable

Definition at line 1791 of file cons_knapsack.c.

References GUBconsAddVar(), GUBconsDelVar(), GUBconsFree(), SCIP_GUBSet::gubconss, SCIP_GUBSet::gubconssidx, SCIP_GUBSet::gubconsstatus, SCIP_GUBCons::gubvars, SCIP_GUBSet::gubvarsidx, SCIP_GUBSet::ngubconss, SCIP_GUBCons::ngubvars, NULL, SCIP_CALL, SCIP_OKAY, SCIPdebugMessage, and SCIPvarGetName().

Referenced by getLiftingSequenceGUB().

static void GUBsetSwapVars	(	SCIP *	scip,
		SCIP_GUBSET *	gubset,
		int	var1,
		int	var2
	)

static

swaps two variables in the same GUB constraint

Parameters

scip	SCIP data structure
gubset	GUB set data structure
var1	first variable to be swapped
var2	second variable to be swapped

Definition at line 1882 of file cons_knapsack.c.

Referenced by getLiftingSequenceGUB().

static SCIP_RETCODE GUBsetCreate	(	SCIP *	scip,
		SCIP_GUBSET **	gubset,
		int	nvars,
		SCIP_Longint *	weights,
		SCIP_Longint	capacity
	)

static

initializes partition of knapsack variables into nonoverlapping trivial GUB constraints (GUB with one variable)

Parameters

scip	SCIP data structure
gubset	pointer to store GUB set data structure
nvars	number of variables in the knapsack constraint
weights	weights of variables in knapsack constraint
capacity	capacity of knapsack

Definition at line 1922 of file cons_knapsack.c.

References GUBconsAddVar(), GUBconsCreate(), GUBCONSSTATUS_UNINITIAL, GUBVARSTATUS_CAPACITYEXCEEDED, NULL, SCIP_GUBSet::nvars, SCIP_CALL, SCIP_OKAY, SCIPallocBufferArray, and SCIPallocMemory.

Referenced by SCIPseparateKnapsackCuts().

static SCIP_RETCODE GUBsetFree	(	SCIP *	scip,
		SCIP_GUBSET **	gubset
	)

static

frees GUB set data structure

Parameters

scip	SCIP data structure
gubset	pointer to GUB set data structure

Definition at line 1972 of file cons_knapsack.c.

Referenced by SCIPseparateKnapsackCuts().

static SCIP_RETCODE GUBsetCheck	(	SCIP *	scip,
		SCIP_GUBSET *	gubset,
		SCIP_VAR **	vars
	)

static

checks whether GUB set data structure is consistent

Parameters

scip	SCIP data structure
gubset	GUB set data structure
vars	variables in the knapsack constraint

Definition at line 2006 of file cons_knapsack.c.

static SCIP_RETCODE GUBsetCalcCliquePartition	(	SCIP *const	scip,
		SCIP_VAR **const	vars,
		int const	nvars,
		int *const	cliquepartition,
		int *const	ncliques,
		SCIP_Real *	solvals
	)

static

Parameters

scip	SCIP data structure
vars	binary variables in the clique from which at most one can be set to 1
nvars	number of variables in the clique
cliquepartition	array of length nvars to store the clique partition
ncliques	pointer to store number of cliques actually contained in the partition
solvals	solution values of all given binary variables

Definition at line 2091 of file cons_knapsack.c.

References MAXNCLIQUEVARSCOMP, MIN, NULL, SCIP_GUBSet::nvars, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIPallocBufferArray, SCIPduplicateBufferArray, SCIPfreeBufferArray, SCIPisFeasEQ(), SCIPsortIntInt(), SCIPvarGetNCliques(), SCIPvarIsActive(), SCIPvarsGetProbvarBinary(), SCIPvarsHaveCommonClique(), and TRUE.

static SCIP_RETCODE GUBsetGetCliquePartition	(	SCIP *	scip,
		SCIP_GUBSET *	gubset,
		SCIP_VAR **	vars,
		SCIP_Real *	solvals
	)

static

constructs sophisticated partion of knapsack variables into nonoverlapping GUBs; current partion uses trivial GUBs

Parameters

scip	SCIP data structure
gubset	GUB set data structure
vars	variables in the knapsack constraint
solvals	solution values of all knapsack variables

Definition at line 2250 of file cons_knapsack.c.

Referenced by SCIPseparateKnapsackCuts().

static SCIP_RETCODE getCover	(	SCIP *	scip,
		SCIP_VAR **	vars,
		int	nvars,
		SCIP_Longint *	weights,
		SCIP_Longint	capacity,
		SCIP_Real *	solvals,
		int *	covervars,
		int *	noncovervars,
		int *	ncovervars,
		int *	nnoncovervars,
		SCIP_Longint *	coverweight,
		SCIP_Bool *	found,
		SCIP_Bool	modtransused,
		int *	ntightened,
		SCIP_Bool *	fractional
	)

static

gets a most violated cover C ( $\sum_{j \in C} a_j > a_0$ ) for a given knapsack constraint $\sum_{j \in N} a_j x_j \leq a_0$ taking into consideration the following fixing: $j \in C$ , if $j \in N_1 = \{j \in N : x^*_j = 1\}$ and $j \in N \setminus C$ , if $j \in N_0 = \{j \in N : x^*_j = 0\}$ , if one exists.

Parameters

scip	SCIP data structure
vars	variables in knapsack constraint
nvars	number of variables in knapsack constraint
weights	weights of variables in knapsack constraint
capacity	capacity of knapsack
solvals	solution values of all problem variables
covervars	pointer to store cover variables
noncovervars	pointer to store noncover variables
ncovervars	pointer to store number of cover variables
nnoncovervars	pointer to store number of noncover variables
coverweight	pointer to store weight of cover
found	pointer to store whether a cover was found
modtransused	should modified transformed separation problem be used to find cover
ntightened	pointer to store number of variables with tightened upper bound
fractional	pointer to store whether the LP sol for knapsack vars is fractional

Definition at line 2347 of file cons_knapsack.c.

References checkSolveKnapsack(), FALSE, NULL, SCIP_GUBSet::nvars, SCIP_Bool, SCIP_CALL, SCIP_Longint, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPdebugMessage, SCIPfreeBufferArray, SCIPisFeasEQ(), SCIPisFeasGT(), SCIPisFeasLT(), SCIPisFeasPositive(), SCIPsolveKnapsackApproximately(), SCIPtightenVarUb(), SCIPvarIsBinary(), and TRUE.

Referenced by SCIPseparateKnapsackCuts().

static SCIP_Bool checkMinweightidx	(	SCIP_Longint *	weights,
		SCIP_Longint	capacity,
		int *	covervars,
		int	ncovervars,
		SCIP_Longint	coverweight,
		int	minweightidx,
		int	j
	)

static

checks if minweightidx is set correctly

Parameters

weights	weights of variables in knapsack constraint
capacity	capacity of knapsack
covervars	pointer to store cover variables
ncovervars	pointer to store number of cover variables
coverweight	pointer to store weight of cover
minweightidx	index of variable in cover variables with minimum weight
j	current index in cover variables

Definition at line 2578 of file cons_knapsack.c.

References FALSE, NULL, SCIP_Longint, and TRUE.

Referenced by makeCoverMinimal().

static void getPartitionCovervars	(	SCIP *	scip,
		SCIP_Real *	solvals,
		int *	covervars,
		int	ncovervars,
		int *	varsC1,
		int *	varsC2,
		int *	nvarsC1,
		int *	nvarsC2
	)

static

gets partition $(C_1,C_2)$ of minimal cover $C$ , i.e. $C_1 \cup C_2 = C$ and $C_1 \cap C_2 = \emptyset$ , with $C_1$ not empty; chooses partition as follows $C_2 = \{ j \in C : x^*_j = 1 \}$ and $C_1 = C \setminus C_2$

Parameters

scip	SCIP data structure
solvals	solution values of all problem variables
covervars	cover variables
ncovervars	number of cover variables
varsC1	pointer to store variables in C1
varsC2	pointer to store variables in C2
nvarsC1	pointer to store number of variables in C1
nvarsC2	pointer to store number of variables in C2

Definition at line 2621 of file cons_knapsack.c.

References NULL, SCIPisFeasGT(), SCIPisGE(), and SCIPisLT().

Referenced by separateSequLiftedExtendedWeightInequality(), and separateSequLiftedMinimalCoverInequality().

static SCIP_RETCODE changePartitionCovervars	(	SCIP *	scip,
		SCIP_Longint *	weights,
		int *	varsC1,
		int *	varsC2,
		int *	nvarsC1,
		int *	nvarsC2
	)

static

changes given partition (C_1,C_2) of minimal cover C, if |C1| = 1, by moving one and two (if possible) variables from C2 to C1 if |C1| = 1 and |C1| = 0, respectively.

Parameters

scip	SCIP data structure
weights	weights of variables in knapsack constraint
varsC1	pointer to store variables in C1
varsC2	pointer to store variables in C2
nvarsC1	pointer to store number of variables in C1
nvarsC2	pointer to store number of variables in C2

Definition at line 2670 of file cons_knapsack.c.

References SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPfreeBufferArray, and SCIPsortDownRealInt().

Referenced by separateSequLiftedMinimalCoverInequality().

static SCIP_RETCODE changePartitionFeasiblesetvars	(	SCIP *	scip,
		SCIP_Longint *	weights,
		int *	varsC1,
		int *	varsC2,
		int *	nvarsC1,
		int *	nvarsC2
	)

static

changes given partition (C_1,C_2) of feasible set C, if |C1| = 1, by moving one variable from C2 to C1

Parameters

scip	SCIP data structure
weights	weights of variables in knapsack constraint
varsC1	pointer to store variables in C1
varsC2	pointer to store variables in C2
nvarsC1	pointer to store number of variables in C1
nvarsC2	pointer to store number of variables in C2

Definition at line 2710 of file cons_knapsack.c.

References SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPfreeBufferArray, and SCIPsortDownRealInt().

Referenced by separateSequLiftedExtendedWeightInequality().

static void getPartitionNoncovervars	(	SCIP *	scip,
		SCIP_Real *	solvals,
		int *	noncovervars,
		int	nnoncovervars,
		int *	varsF,
		int *	varsR,
		int *	nvarsF,
		int *	nvarsR
	)

static

gets partition $(F,R)$ of $N \setminus C$ where $C$ is a minimal cover, i.e. $F \cup R = N \setminus C$ and $F \cap R = \emptyset$ ; chooses partition as follows $R = \{ j \in N \setminus C : x^*_j = 0 \}$ and $F = (N \setminus C) \setminus F$

Parameters

scip	SCIP data structure
solvals	solution values of all problem variables
noncovervars	noncover variables
nnoncovervars	number of noncover variables
varsF	pointer to store variables in F
varsR	pointer to store variables in R
nvarsF	pointer to store number of variables in F
nvarsR	pointer to store number of variables in R

Definition at line 2751 of file cons_knapsack.c.

References NULL, SCIPisFeasEQ(), and SCIPisFeasGT().

Referenced by separateSequLiftedExtendedWeightInequality(), and separateSequLiftedMinimalCoverInequality().

static SCIP_RETCODE getLiftingSequence	(	SCIP *	scip,
		SCIP_Real *	solvals,
		SCIP_Longint *	weights,
		int *	varsF,
		int *	varsC2,
		int *	varsR,
		int	nvarsF,
		int	nvarsC2,
		int	nvarsR
	)

static

sorts variables in F, C_2, and R according to the second level lifting sequence that will be used in the sequential lifting procedure

Parameters

scip	SCIP data structure
solvals	solution values of all problem variables
weights	weights of variables in knapsack constraint
varsF	pointer to store variables in F
varsC2	pointer to store variables in C2
varsR	pointer to store variables in R
nvarsF	number of variables in F
nvarsC2	number of variables in C2
nvarsR	number of variables in R

Definition at line 2799 of file cons_knapsack.c.

References NULL, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPallocMemoryArray, SCIPfreeBufferArray, SCIPfreeMemoryArray, SCIPsortDownPtrInt(), and SCIPsortDownRealInt().

Referenced by separateSequLiftedExtendedWeightInequality(), and separateSequLiftedMinimalCoverInequality().

static SCIP_RETCODE getLiftingSequenceGUB	(	SCIP *	scip,
		SCIP_GUBSET *	gubset,
		SCIP_Real *	solvals,
		SCIP_Longint *	weights,
		int *	varsC1,
		int *	varsC2,
		int *	varsF,
		int *	varsR,
		int	nvarsC1,
		int	nvarsC2,
		int	nvarsF,
		int	nvarsR,
		int *	gubconsGC1,
		int *	gubconsGC2,
		int *	gubconsGFC1,
		int *	gubconsGR,
		int *	ngubconsGC1,
		int *	ngubconsGC2,
		int *	ngubconsGFC1,
		int *	ngubconsGR,
		int *	ngubconscapexceed,
		int *	maxgubvarssize
	)

static

categorizies GUBs of knapsack GUB partion into GOC1, GNC1, GF, GC2, and GR and computes a lifting sequence of the GUBs for the sequential GUB wise lifting procedure

Parameters

scip	SCIP data structure
gubset	GUB set data structure
solvals	solution values of variables in knapsack constraint
weights	weights of variables in knapsack constraint
varsC1	variables in C1
varsC2	variables in C2
varsF	variables in F
varsR	variables in R
nvarsC1	number of variables in C1
nvarsC2	number of variables in C2
nvarsF	number of variables in F
nvarsR	number of variables in R
gubconsGC1	pointer to store GUBs in GC1(GNC1+GOC1)
gubconsGC2	pointer to store GUBs in GC2
gubconsGFC1	pointer to store GUBs in GFC1(GNC1+GF)
gubconsGR	pointer to store GUBs in GR
ngubconsGC1	pointer to store number of GUBs in GC1(GNC1+GOC1)
ngubconsGC2	pointer to store number of GUBs in GC2
ngubconsGFC1	pointer to store number of GUBs in GFC1(GNC1+GF)
ngubconsGR	pointer to store number of GUBs in GR
ngubconscapexceed	pointer to store number of GUBs with only capacity exceeding variables
maxgubvarssize	pointer to store the maximal size of GUB constraints

Definition at line 2885 of file cons_knapsack.c.

References BMSclearMemoryArray, FALSE, GUBconsCreate(), SCIP_GUBSet::gubconss, SCIP_GUBSet::gubconssidx, SCIP_GUBSet::gubconsstatus, GUBCONSSTATUS_BELONGSTOSET_GC2, GUBCONSSTATUS_BELONGSTOSET_GF, GUBCONSSTATUS_BELONGSTOSET_GNC1, GUBCONSSTATUS_BELONGSTOSET_GOC1, GUBCONSSTATUS_BELONGSTOSET_GR, GUBCONSSTATUS_UNINITIAL, GUBsetMoveVar(), GUBsetSwapVars(), SCIP_GUBCons::gubvars, SCIP_GUBSet::gubvarsidx, SCIP_GUBCons::gubvarssize, SCIP_GUBCons::gubvarsstatus, GUBVARSTATUS_BELONGSTOSET_C1, GUBVARSTATUS_BELONGSTOSET_C2, GUBVARSTATUS_BELONGSTOSET_F, GUBVARSTATUS_BELONGSTOSET_R, GUBVARSTATUS_CAPACITYEXCEEDED, SCIP_GUBSet::ngubconss, SCIP_GUBCons::ngubvars, NULL, SCIP_GUBSet::nvars, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPallocBuffer, SCIPallocBufferArray, SCIPallocMemoryArray, SCIPfreeBuffer, SCIPfreeBufferArray, SCIPfreeMemoryArray, SCIPsortDownPtrInt(), SCIPsortDownRealInt(), SCIPsortRealInt(), and TRUE.

Referenced by separateSequLiftedMinimalCoverInequality().

static SCIP_RETCODE enlargeMinweights	(	SCIP *	scip,
		SCIP_Longint **	minweightsptr,
		int *	minweightslen,
		int *	minweightssize,
		int	newlen
	)

static

enlarges minweight table to at least the given length

Parameters

scip	SCIP data structure
minweightsptr	pointer to minweights table
minweightslen	pointer to store number of entries in minweights table (incl. z=0)
minweightssize	pointer to current size of minweights table
newlen	new length of minweights table

Definition at line 3405 of file cons_knapsack.c.

References NULL, SCIP_CALL, SCIP_LONGINT_MAX, SCIP_OKAY, SCIPcalcMemGrowSize(), and SCIPreallocBufferArray.

Referenced by sequentialUpAndDownLifting(), and sequentialUpAndDownLiftingGUB().

static SCIP_RETCODE sequentialUpAndDownLifting	(	SCIP *	scip,
		SCIP_VAR **	vars,
		int	nvars,
		int	ntightened,
		SCIP_Longint *	weights,
		SCIP_Longint	capacity,
		SCIP_Real *	solvals,
		int *	varsM1,
		int *	varsM2,
		int *	varsF,
		int *	varsR,
		int	nvarsM1,
		int	nvarsM2,
		int	nvarsF,
		int	nvarsR,
		int	alpha0,
		int *	liftcoefs,
		SCIP_Real *	cutact,
		int *	liftrhs
	)

static

lifts given inequality sum_{j in M_1} x_j <= alpha_0 valid for S^0 = { x in {0,1}^|M_1| : sum_{j in M_1} a_j x_j <= a_0 - sum_{j in M_2} a_j } to a valid inequality sum_{j in M_1} x_j + sum_{j in F} alpha_j x_j + sum_{j in M_2} alpha_j x_j + sum_{j in R} alpha_j x_j <= alpha_0 + sum_{j in M_2} alpha_j for S = { x in {0,1}^|N| : sum_{j in N} a_j x_j <= a_0 }; uses sequential up-lifting for the variables in F, sequential down-lifting for the variable in M_2, and sequential up-lifting for the variables in R; procedure can be used to strengthen minimal cover inequalities and extended weight inequalities.

Parameters

scip	SCIP data structure
vars	variables in knapsack constraint
nvars	number of variables in knapsack constraint
ntightened	number of variables with tightened upper bound
weights	weights of variables in knapsack constraint
capacity	capacity of knapsack
solvals	solution values of all problem variables
varsM1	variables in M_1
varsM2	variables in M_2
varsF	variables in F
varsR	variables in R
nvarsM1	number of variables in M_1
nvarsM2	number of variables in M_2
nvarsF	number of variables in F
nvarsR	number of variables in R
alpha0	rights hand side of given valid inequality
liftcoefs	pointer to store lifting coefficient of vars in knapsack constraint
cutact	pointer to store activity of lifted valid inequality
liftrhs	pointer to store right hand side of the lifted valid inequality

Definition at line 3455 of file cons_knapsack.c.

References BMSclearMemoryArray, enlargeMinweights(), MIN, NULL, SCIP_CALL, SCIP_Longint, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPfreeBufferArray, SCIPisFeasEQ(), SCIPisFeasGT(), and SCIPsortRealInt().

Referenced by separateSequLiftedExtendedWeightInequality(), and separateSequLiftedMinimalCoverInequality().

static SCIP_Longint safeAddMinweightsGUB	(	SCIP_Longint	val1,
		SCIP_Longint	val2
	)

static

adds two minweight values in a safe way, i.e,, ensures no overflow

Parameters

val1	first value to add
val2	second value to add

Definition at line 3833 of file cons_knapsack.c.

References SCIP_LONGINT_MAX.

Referenced by sequentialUpAndDownLiftingGUB().

static void computeMinweightsGUB	(	SCIP_Longint *	minweights,
		SCIP_Longint *	finished,
		SCIP_Longint *	unfinished,
		int	minweightslen
	)

static

computes minweights table for lifting with GUBs by combining unfished and fished tables

Parameters

minweights	minweight table to compute
finished	given finished table
unfinished	given unfinished table
minweightslen	length of minweight, finished, and unfinished tables

Definition at line 3852 of file cons_knapsack.c.

Referenced by sequentialUpAndDownLiftingGUB().

static SCIP_RETCODE sequentialUpAndDownLiftingGUB	(	SCIP *	scip,
		SCIP_GUBSET *	gubset,
		SCIP_VAR **	vars,
		int	ngubconscapexceed,
		SCIP_Longint *	weights,
		SCIP_Longint	capacity,
		SCIP_Real *	solvals,
		int *	gubconsGC1,
		int *	gubconsGC2,
		int *	gubconsGFC1,
		int *	gubconsGR,
		int	ngubconsGC1,
		int	ngubconsGC2,
		int	ngubconsGFC1,
		int	ngubconsGR,
		int	alpha0,
		int *	liftcoefs,
		SCIP_Real *	cutact,
		int *	liftrhs,
		int	maxgubvarssize
	)

static

lifts given inequality sum_{j in C_1} x_j <= alpha_0 valid for S^0 = { x in {0,1}^|C_1| : sum_{j in C_1} a_j x_j <= a_0 - sum_{j in C_2} a_j; sum_{j in Q_i} x_j <= 1, forall i in I } to a valid inequality sum_{j in C_1} x_j + sum_{j in F} alpha_j x_j + sum_{j in C_2} alpha_j x_j + sum_{j in R} alpha_j x_j <= alpha_0 + sum_{j in C_2} alpha_j for S = { x in {0,1}^|N| : sum_{j in N} a_j x_j <= a_0; sum_{j in Q_i} x_j <= 1, forall i in I }; uses sequential up-lifting for the variables in GUB constraints in gubconsGFC1, sequential down-lifting for the variables in GUB constraints in gubconsGC2, and sequential up-lifting for the variabels in GUB constraints in gubconsGR.

Parameters

scip	SCIP data structure
gubset	GUB set data structure
vars	variables in knapsack constraint
ngubconscapexceed	number of GUBs with only capacity exceeding variables
weights	weights of variables in knapsack constraint
capacity	capacity of knapsack
solvals	solution values of all knapsack variables
gubconsGC1	GUBs in GC1(GNC1+GOC1)
gubconsGC2	GUBs in GC2
gubconsGFC1	GUBs in GFC1(GNC1+GF)
gubconsGR	GUBs in GR
ngubconsGC1	number of GUBs in GC1(GNC1+GOC1)
ngubconsGC2	number of GUBs in GC2
ngubconsGFC1	number of GUBs in GFC1(GNC1+GF)
ngubconsGR	number of GUBs in GR
alpha0	rights hand side of given valid inequality
liftcoefs	pointer to store lifting coefficient of vars in knapsack constraint
cutact	pointer to store activity of lifted valid inequality
liftrhs	pointer to store right hand side of the lifted valid inequality
maxgubvarssize	maximal size of GUB constraints

Definition at line 3904 of file cons_knapsack.c.

References BMSclearMemoryArray, computeMinweightsGUB(), enlargeMinweights(), SCIP_GUBSet::gubconss, SCIP_GUBSet::gubconsstatus, GUBCONSSTATUS_BELONGSTOSET_GC2, GUBCONSSTATUS_BELONGSTOSET_GF, GUBCONSSTATUS_BELONGSTOSET_GNC1, GUBCONSSTATUS_BELONGSTOSET_GOC1, GUBCONSSTATUS_BELONGSTOSET_GR, SCIP_GUBCons::gubvars, SCIP_GUBCons::gubvarsstatus, GUBVARSTATUS_BELONGSTOSET_C1, GUBVARSTATUS_BELONGSTOSET_C2, GUBVARSTATUS_BELONGSTOSET_F, GUBVARSTATUS_BELONGSTOSET_R, GUBVARSTATUS_CAPACITYEXCEEDED, MIN, SCIP_GUBSet::ngubconss, SCIP_GUBCons::ngubvars, NULL, SCIP_GUBSet::nvars, safeAddMinweightsGUB(), SCIP_CALL, SCIP_Longint, SCIP_LONGINT_MAX, SCIP_OKAY, SCIPallocBufferArray, SCIPfreeBufferArray, and SCIPisFeasEQ().

Referenced by separateSequLiftedMinimalCoverInequality().

static SCIP_RETCODE superadditiveUpLifting	(	SCIP *	scip,
		SCIP_VAR **	vars,
		int	nvars,
		int	ntightened,
		SCIP_Longint *	weights,
		SCIP_Longint	capacity,
		SCIP_Real *	solvals,
		int *	covervars,
		int *	noncovervars,
		int	ncovervars,
		int	nnoncovervars,
		SCIP_Longint	coverweight,
		SCIP_Real *	liftcoefs,
		SCIP_Real *	cutact
	)

static

lifts given minimal cover inequality

$\sum_{j \in C} x_j \leq |C| - 1$

valid for

$S^0 = \{ x \in {0,1}^{|C|} : \sum_{j \in C} a_j x_j \leq a_0 \}$

to a valid inequality

$\sum_{j \in C} x_j + \sum_{j \in N \setminus C} \alpha_j x_j \leq |C| - 1$

for

$S = \{ x \in {0,1}^{|N|} : \sum_{j \in N} a_j x_j \leq a_0 \};$

uses superadditive up-lifting for the variables in $N \setminus C$ .

Parameters

scip	SCIP data structure
vars	variables in knapsack constraint
nvars	number of variables in knapsack constraint
ntightened	number of variables with tightened upper bound
weights	weights of variables in knapsack constraint
capacity	capacity of knapsack
solvals	solution values of all problem variables
covervars	cover variables
noncovervars	noncover variables
ncovervars	number of cover variables
nnoncovervars	number of noncover variables
coverweight	weight of cover
liftcoefs	pointer to store lifting coefficient of vars in knapsack constraint
cutact	pointer to store activity of lifted valid inequality

Definition at line 4636 of file cons_knapsack.c.

References BMSclearMemoryArray, MAX, NULL, SCIP_CALL, SCIP_Longint, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPfreeBufferArray, SCIPsortDownRealInt(), and SCIPsortRealInt().

Referenced by separateSupLiftedMinimalCoverInequality().

static SCIP_RETCODE separateSequLiftedMinimalCoverInequality	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SEPA *	sepa,
		SCIP_VAR **	vars,
		int	nvars,
		int	ntightened,
		SCIP_Longint *	weights,
		SCIP_Longint	capacity,
		SCIP_Real *	solvals,
		int *	mincovervars,
		int *	nonmincovervars,
		int	nmincovervars,
		int	nnonmincovervars,
		SCIP_SOL *	sol,
		SCIP_GUBSET *	gubset,
		SCIP_Bool *	cutoff,
		int *	ncuts
	)

static

separates lifted minimal cover inequalities using sequential up- and down-lifting and GUB information, if wanted, for given knapsack problem

Parameters

scip	SCIP data structure
cons	originating constraint of the knapsack problem, or NULL
sepa	originating separator of the knapsack problem, or NULL
vars	variables in knapsack constraint
nvars	number of variables in knapsack constraint
ntightened	number of variables with tightened upper bound
weights	weights of variables in knapsack constraint
capacity	capacity of knapsack
solvals	solution values of all problem variables
mincovervars	mincover variables
nonmincovervars	nonmincover variables
nmincovervars	number of mincover variables
nnonmincovervars	number of nonmincover variables
sol	primal SCIP solution to separate, NULL for current LP solution
gubset	GUB set data structure, NULL if no GUB information should be used
cutoff	pointer to store whether a cutoff has been detected
ncuts	pointer to add up the number of found cuts

Definition at line 4767 of file cons_knapsack.c.

References changePartitionCovervars(), FALSE, getLiftingSequence(), getLiftingSequenceGUB(), getPartitionCovervars(), getPartitionNoncovervars(), MAX, MIN, SCIP_GUBSet::ngubconss, NULL, SCIP_GUBSet::nvars, SCIP_CALL, SCIP_MAXSTRLEN, SCIP_OKAY, SCIP_Real, SCIPaddCut(), SCIPaddVarToRow(), SCIPallocBufferArray, SCIPcacheRowExtensions(), SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetNCutsFound(), SCIPconsIsLocal(), SCIPconsIsRemovable(), SCIPcreateEmptyRowCons(), SCIPcreateEmptyRowSepa(), SCIPcreateEmptyRowUnspec(), SCIPflushRowExtensions(), SCIPfreeBufferArray, SCIPinfinity(), SCIPisCutEfficacious(), SCIPisEfficacious(), SCIPreleaseRow(), SCIPresetConsAge(), SCIPsepaGetName(), SCIPsepaGetNCutsFound(), SCIPsnprintf(), sequentialUpAndDownLifting(), sequentialUpAndDownLiftingGUB(), sqrt(), and TRUE.

Referenced by SCIPseparateKnapsackCuts().

static SCIP_RETCODE separateSequLiftedExtendedWeightInequality	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SEPA *	sepa,
		SCIP_VAR **	vars,
		int	nvars,
		int	ntightened,
		SCIP_Longint *	weights,
		SCIP_Longint	capacity,
		SCIP_Real *	solvals,
		int *	feassetvars,
		int *	nonfeassetvars,
		int	nfeassetvars,
		int	nnonfeassetvars,
		SCIP_SOL *	sol,
		SCIP_Bool *	cutoff,
		int *	ncuts
	)

static

separates lifted extended weight inequalities using sequential up- and down-lifting for given knapsack problem

Parameters

scip	SCIP data structure
cons	constraint that originates the knapsack problem, or NULL
sepa	originating separator of the knapsack problem, or NULL
vars	variables in knapsack constraint
nvars	number of variables in knapsack constraint
ntightened	number of variables with tightened upper bound
weights	weights of variables in knapsack constraint
capacity	capacity of knapsack
solvals	solution values of all problem variables
feassetvars	variables in feasible set
nonfeassetvars	variables not in feasible set
nfeassetvars	number of variables in feasible set
nnonfeassetvars	number of variables not in feasible set
sol	primal SCIP solution to separate, NULL for current LP solution
cutoff	whether a cutoff has been detected
ncuts	pointer to add up the number of found cuts

Definition at line 5001 of file cons_knapsack.c.

References changePartitionFeasiblesetvars(), FALSE, getLiftingSequence(), getPartitionCovervars(), getPartitionNoncovervars(), MAX, NULL, SCIP_CALL, SCIP_MAXSTRLEN, SCIP_OKAY, SCIP_Real, SCIPaddCut(), SCIPaddVarToRow(), SCIPallocBufferArray, SCIPcacheRowExtensions(), SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetNCutsFound(), SCIPconsIsLocal(), SCIPconsIsRemovable(), SCIPcreateEmptyRowCons(), SCIPcreateEmptyRowSepa(), SCIPcreateEmptyRowUnspec(), SCIPflushRowExtensions(), SCIPfreeBufferArray, SCIPinfinity(), SCIPisCutEfficacious(), SCIPisEfficacious(), SCIPreleaseRow(), SCIPresetConsAge(), SCIPsepaGetName(), SCIPsepaGetNCutsFound(), SCIPsnprintf(), sequentialUpAndDownLifting(), sqrt(), and TRUE.

Referenced by getFeasibleSet().

static SCIP_RETCODE separateSupLiftedMinimalCoverInequality	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SEPA *	sepa,
		SCIP_VAR **	vars,
		int	nvars,
		int	ntightened,
		SCIP_Longint *	weights,
		SCIP_Longint	capacity,
		SCIP_Real *	solvals,
		int *	mincovervars,
		int *	nonmincovervars,
		int	nmincovervars,
		int	nnonmincovervars,
		SCIP_Longint	mincoverweight,
		SCIP_SOL *	sol,
		SCIP_Bool *	cutoff,
		int *	ncuts
	)

static

separates lifted minimal cover inequalities using superadditive up-lifting for given knapsack problem

Parameters

scip	SCIP data structure
cons	constraint that originates the knapsack problem, or NULL
sepa	originating separator of the knapsack problem, or NULL
vars	variables in knapsack constraint
nvars	number of variables in knapsack constraint
ntightened	number of variables with tightened upper bound
weights	weights of variables in knapsack constraint
capacity	capacity of knapsack
solvals	solution values of all problem variables
mincovervars	mincover variables
nonmincovervars	nonmincover variables
nmincovervars	number of mincover variables
nnonmincovervars	number of nonmincover variables
mincoverweight	weight of minimal cover
sol	primal SCIP solution to separate, NULL for current LP solution
cutoff	whether a cutoff has been detected
ncuts	pointer to add up the number of found cuts

Definition at line 5168 of file cons_knapsack.c.

References FALSE, MAX, NULL, SCIP_CALL, SCIP_MAXSTRLEN, SCIP_OKAY, SCIP_Real, SCIPaddCut(), SCIPaddVarToRow(), SCIPallocBufferArray, SCIPcacheRowExtensions(), SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetNCutsFound(), SCIPconsIsLocal(), SCIPconsIsRemovable(), SCIPcreateEmptyRowCons(), SCIPcreateEmptyRowSepa(), SCIPcreateEmptyRowUnspec(), SCIPflushRowExtensions(), SCIPfreeBufferArray, SCIPinfinity(), SCIPisCutEfficacious(), SCIPisEfficacious(), SCIPisFeasGE(), SCIPisFeasGT(), SCIPreleaseRow(), SCIPresetConsAge(), SCIPsepaGetName(), SCIPsepaGetNCutsFound(), SCIPsnprintf(), sqrt(), superadditiveUpLifting(), and TRUE.

Referenced by SCIPseparateKnapsackCuts().

static SCIP_RETCODE makeCoverMinimal	(	SCIP *	scip,
		SCIP_Longint *	weights,
		SCIP_Longint	capacity,
		SCIP_Real *	solvals,
		int *	covervars,
		int *	noncovervars,
		int *	ncovervars,
		int *	nnoncovervars,
		SCIP_Longint *	coverweight,
		SCIP_Bool	modtransused
	)

static

converts given cover C to a minimal cover by removing variables in the reverse order in which the variables were chosen to be in C, i.e. in the order of non-increasing (1 - x*_j)/a_j, if the transformed separation problem was used to find C and in the order of non-increasing (1 - x*_j), if the modified transformed separation problem was used to find C; note that all variables with x*_j = 1 will be removed last

Parameters

scip	SCIP data structure
weights	weights of variables in knapsack constraint
capacity	capacity of knapsack
solvals	solution values of all problem variables
covervars	pointer to store cover variables
noncovervars	pointer to store noncover variables
ncovervars	pointer to store number of cover variables
nnoncovervars	pointer to store number of noncover variables
coverweight	pointer to store weight of cover
modtransused	TRUE if mod trans sepa prob was used to find cover

Definition at line 5282 of file cons_knapsack.c.

References checkMinweightidx(), NULL, SCIP_CALL, SCIP_Longint, SCIP_OKAY, SCIP_Real, SCIPallocBlockMemory, SCIPallocBlockMemoryArray, SCIPfreeBlockMemory, SCIPfreeBlockMemoryArray, and SCIPsortPtrInt().

Referenced by SCIPseparateKnapsackCuts().

static SCIP_RETCODE getFeasibleSet	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SEPA *	sepa,
		SCIP_VAR **	vars,
		int	nvars,
		int	ntightened,
		SCIP_Longint *	weights,
		SCIP_Longint	capacity,
		SCIP_Real *	solvals,
		int *	covervars,
		int *	noncovervars,
		int *	ncovervars,
		int *	nnoncovervars,
		SCIP_Longint *	coverweight,
		SCIP_Bool	modtransused,
		SCIP_SOL *	sol,
		SCIP_Bool *	cutoff,
		int *	ncuts
	)

static

converts given initial cover C_init to a feasible set by removing variables in the reverse order in which they were chosen to be in C_init: non-increasing (1 - x*_j)/a_j, if transformed separation problem was used to find C_init non-increasing (1 - x*_j), if modified transformed separation problem was used to find C_init. separates lifted extended weight inequalities using sequential up- and down-lifting for this feasible set and all subsequent feasible sets.

Parameters

scip	SCIP data structure
cons	constraint that originates the knapsack problem
sepa	originating separator of the knapsack problem, or NULL
vars	variables in knapsack constraint
nvars	number of variables in knapsack constraint
ntightened	number of variables with tightened upper bound
weights	weights of variables in knapsack constraint
capacity	capacity of knapsack
solvals	solution values of all problem variables
covervars	pointer to store cover variables
noncovervars	pointer to store noncover variables
ncovervars	pointer to store number of cover variables
nnoncovervars	pointer to store number of noncover variables
coverweight	pointer to store weight of cover
modtransused	TRUE if mod trans sepa prob was used to find cover
sol	primal SCIP solution to separate, NULL for current LP solution
cutoff	whether a cutoff has been detected
ncuts	pointer to add up the number of found cuts

Definition at line 5425 of file cons_knapsack.c.

References FALSE, MAXCOVERSIZEITERLEWI, NULL, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPfreeBufferArray, SCIPisFeasGE(), SCIPisFeasLE(), SCIPsortRealInt(), and separateSequLiftedExtendedWeightInequality().

Referenced by SCIPseparateKnapsackCuts().

SCIP_RETCODE SCIPseparateKnapsackCuts	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SEPA *	sepa,
		SCIP_VAR **	vars,
		int	nvars,
		SCIP_Longint *	weights,
		SCIP_Longint	capacity,
		SCIP_SOL *	sol,
		SCIP_Bool	usegubs,
		SCIP_Bool *	cutoff,
		int *	ncuts
	)

separates different classes of valid inequalities for the 0-1 knapsack problem

Parameters

scip	SCIP data structure
cons	originating constraint of the knapsack problem, or NULL
sepa	originating separator of the knapsack problem, or NULL
vars	variables in knapsack constraint
nvars	number of variables in knapsack constraint
weights	weights of variables in knapsack constraint
capacity	capacity of knapsack
sol	primal SCIP solution to separate, NULL for current LP solution
usegubs	should GUB information be used for separation?
cutoff	whether a cutoff has been detected
ncuts	pointer to add up the number of found cuts

Definition at line 5524 of file cons_knapsack.c.

References FALSE, getCover(), getFeasibleSet(), GUBsetCreate(), GUBsetFree(), GUBsetGetCliquePartition(), makeCoverMinimal(), SCIP_GUBSet::ngubconss, NULL, SCIP_GUBSet::nvars, SCIP_Bool, SCIP_CALL, SCIP_Longint, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPconsGetName(), SCIPdebugMessage, SCIPdebugPrintf, SCIPfreeBufferArray, SCIPgetSolVals(), SCIPincConsAge(), SCIPvarGetName(), separateSequLiftedMinimalCoverInequality(), separateSupLiftedMinimalCoverInequality(), TRUE, and USESUPADDLIFT.

Referenced by SCIPseparateRelaxedKnapsack(), and separateCons().

SCIP_RETCODE SCIPseparateRelaxedKnapsack	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SEPA *	sepa,
		int	nknapvars,
		SCIP_VAR **	knapvars,
		SCIP_Real *	knapvals,
		SCIP_Real	valscale,
		SCIP_Real	rhs,
		SCIP_SOL *	sol,
		SCIP_Bool *	cutoff,
		int *	ncuts
	)

Parameters

scip	SCIP data structure
cons	originating constraint of the knapsack problem, or NULL
sepa	originating separator of the knapsack problem, or NULL
nknapvars	number of variables in the continuous knapsack constraint
knapvars	variables in the continuous knapsack constraint
knapvals	coefficient of the variables in the continuous knapsack constraint
valscale	-1.0 if lhs of row is used as rhs of c. k. constraint, +1.0 otherwise
rhs	right hand side of the continuous knapsack constraint
sol	primal CIP solution, NULL for current LP solution
cutoff	pointer to store whether a cutoff was found
ncuts	pointer to add up the number of found cuts

Definition at line 5737 of file cons_knapsack.c.

References BMSclearMemoryArray, CONSHDLR_NAME, DEFAULT_USEGUBS, FALSE, KNAPSACKRELAX_MAXDELTA, KNAPSACKRELAX_MAXDNOM, KNAPSACKRELAX_MAXSCALE, MAXABSVBCOEF, NULL, REALABS, SCIP_Bool, SCIP_CALL, SCIP_Longint, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPcalcIntegralScalar(), SCIPconsGetName(), SCIPconshdlrGetData(), SCIPdebug, SCIPdebugMessage, SCIPdebugPrintCons, SCIPdebugPrintf, SCIPepsilon(), SCIPfeasFloor(), SCIPfindConshdlr(), SCIPfloor(), SCIPfreeBufferArray, SCIPgetNContVars(), SCIPgetNegatedVar(), SCIPgetNVars(), SCIPgetSolVal(), SCIPgetVars(), SCIPisGE(), SCIPisGT(), SCIPisInfinity(), SCIPisLE(), SCIPisLT(), SCIPreallocMemoryArray, SCIPseparateKnapsackCuts(), SCIPvarGetLbGlobal(), SCIPvarGetLbLocal(), SCIPvarGetName(), SCIPvarGetNVlbs(), SCIPvarGetNVubs(), SCIPvarGetProbindex(), SCIPvarGetUbGlobal(), SCIPvarGetUbLocal(), SCIPvarGetVlbCoefs(), SCIPvarGetVlbConstants(), SCIPvarGetVlbVars(), SCIPvarGetVubCoefs(), SCIPvarGetVubConstants(), SCIPvarGetVubVars(), SCIPvarIsActive(), SCIPvarIsBinary(), and TRUE.

Referenced by addCut().

static SCIP_RETCODE separateCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SOL *	sol,
		SCIP_Bool	sepacuts,
		SCIP_Bool	usegubs,
		SCIP_Bool *	cutoff,
		int *	ncuts
	)

static

separates given knapsack constraint

Parameters

scip	SCIP data structure
cons	knapsack constraint
sol	primal SCIP solution, NULL for current LP solution
sepacuts	should knapsack cuts be separated?
usegubs	should GUB information be used for separation?
cutoff	whether a cutoff has been detected
ncuts	pointer to add up the number of found cuts

Definition at line 6155 of file cons_knapsack.c.

References addRelaxation(), checkCons(), FALSE, NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMessage, and SCIPseparateKnapsackCuts().

static SCIP_RETCODE addCoef	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var,
		SCIP_Longint	weight
	)

static

adds coefficient to constraint data

Parameters

scip	SCIP data structure
cons	knapsack constraint
var	variable to add to knapsack
weight	weight of variable in knapsack

Definition at line 6197 of file cons_knapsack.c.

Referenced by applyFixings().

static SCIP_RETCODE delCoefPos	(	SCIP *	scip,
		SCIP_CONS *	cons,
		int	pos
	)

static

deletes coefficient at given position from constraint data

Parameters

scip	SCIP data structure
cons	knapsack constraint
pos	position of coefficient to delete

Definition at line 6279 of file cons_knapsack.c.

Referenced by applyFixings(), deleteRedundantVars(), dualWeightsTightening(), prepareCons(), and simplifyInequalities().

static SCIP_RETCODE removeZeroWeights	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

static

removes all items with weight zero from knapsack constraint

Parameters

scip	SCIP data structure
cons	knapsack constraint

Definition at line 6475 of file cons_knapsack.c.

Referenced by tightenWeights().

static SCIP_RETCODE performVarDeletions	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_CONS **	conss,
		int	nconss
	)

static

Parameters

scip	SCIP data structure
conshdlr	constraint handler
conss	array of constraints
nconss	number of constraints

Definition at line 6499 of file cons_knapsack.c.

Referenced by SCIP_DECL_CONSDELVARS().

static SCIP_RETCODE mergeMultiples	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool *	cutoff
	)

static

replaces multiple occurrences of a variable or its negation by a single coefficient

Parameters

scip	SCIP data structure
cons	knapsack constraint
cutoff	pointer to store whether the node can be cut off

Definition at line 6541 of file cons_knapsack.c.

Referenced by applyFixings(), simplifyInequalities(), and tightenWeights().

static SCIP_RETCODE dualPresolving	(	SCIP *	scip,
		SCIP_CONS *	cons,
		int *	nfixedvars,
		int *	ndelconss,
		SCIP_Bool *	deleted
	)

static

in case the knapsack constraint is independent of every else, solve the knapsack problem (exactly) and apply the fixings (dual reductions)

Parameters

scip	SCIP data structure
cons	knapsack constraint
nfixedvars	pointer to count number of fixings
ndelconss	pointer to count number of deleted constraints
deleted	pointer to store if the constraint is deleted

Definition at line 6684 of file cons_knapsack.c.

References FALSE, NULL, SCIP_GUBSet::nvars, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPconsGetData(), SCIPconsGetName(), SCIPconsIsChecked(), SCIPconsIsModifiable(), SCIPdebugMessage, SCIPdebugPrintCons, SCIPdelCons(), SCIPfreeBufferArray, SCIPsolveKnapsackExactly(), SCIPtightenVarLb(), SCIPtightenVarUb(), SCIPvarGetLbGlobal(), SCIPvarGetName(), SCIPvarGetNLocksDown(), SCIPvarGetNLocksUp(), SCIPvarGetObj(), SCIPvarGetProbvarBinary(), SCIPvarGetUbGlobal(), SCIPvarIsActive(), and TRUE.

static SCIP_RETCODE checkParallelObjective	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_CONSHDLRDATA *	conshdlrdata
	)

static

check if the knapsack constraint is parallel to objective function; if so update the cutoff bound and avoid that the constraint enters the LP by setting the initial and separated flag to FALSE

Parameters

scip	SCIP data structure
cons	knapsack constraint
conshdlrdata	knapsack constraint handler data

Definition at line 6825 of file cons_knapsack.c.

static SCIP_RETCODE stableSort	(	SCIP *	scip,
		SCIP_CONSDATA *	consdata,
		SCIP_VAR **	vars,
		SCIP_Longint *	weights,
		int *	cliquestartposs,
		SCIP_Bool	usenegatedclique
	)

static

sort the variables and weights w.r.t. the clique partition; thereby ensure the current order of the variables when a weight of one variable is greater or equal another weight and both variables are in the same cliques

Parameters

scip	SCIP data structure
consdata	knapsack constraint data
vars	array for sorted variables
weights	array for sorted weights
cliquestartposs	starting position array for each clique
usenegatedclique	should negated or normal clique partition be used

Definition at line 6970 of file cons_knapsack.c.

References BMSclearMemoryArray, NULL, SCIP_CALL, SCIP_Longint, SCIP_OKAY, SCIPallocBufferArray, and SCIPfreeBufferArray.

Referenced by propagateCons().

static SCIP_RETCODE propagateCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool *	cutoff,
		SCIP_Bool *	redundant,
		int *	nfixedvars,
		SCIP_Bool	usenegatedclique
	)

static

propagation method for knapsack constraints

Parameters

scip	SCIP data structure
cons	knapsack constraint
cutoff	pointer to store whether the node can be cut off
redundant	pointer to store whether constraint is redundant
nfixedvars	pointer to count number of fixings
usenegatedclique	should negated clique information be used

Definition at line 7094 of file cons_knapsack.c.

References BMSclearMemoryArray, calcCliquepartition(), FALSE, NULL, SCIP_GUBSet::nvars, SCIP_Bool, SCIP_CALL, SCIP_Longint, SCIP_OKAY, SCIP_STAGE_SOLVING, SCIPaddConflictBinvar(), SCIPallocBufferArray, SCIPanalyzeConflictCons(), SCIPconsGetData(), SCIPconsGetName(), SCIPconsIsModifiable(), SCIPdebugMessage, SCIPdelConsLocal(), SCIPduplicateBufferArray, SCIPfreeBufferArray, SCIPgetStage(), SCIPincConsAge(), SCIPinferBinvarCons(), SCIPinitConflictAnalysis(), SCIPinProbing(), SCIPinRepropagation(), SCIPisConflictAnalysisApplicable(), SCIPresetConsAge(), SCIPvarGetIndex(), SCIPvarGetLbLocal(), SCIPvarGetName(), SCIPvarGetUbLocal(), sortItems(), stableSort(), and TRUE.

static SCIP_RETCODE upgradeCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		int *	ndelconss,
		int *	naddconss
	)

static

all but one variable fit into the knapsack constraint, so we can upgrade this constraint to an logicor constraint containing all negated variables of this knapsack constraint

Parameters

scip	SCIP data structure
cons	knapsack constraint
ndelconss	pointer to store the amount of deleted constraints
naddconss	pointer to count number of added constraints

Definition at line 7538 of file cons_knapsack.c.

Referenced by detectRedundantVars(), and dualWeightsTightening().

static SCIP_RETCODE deleteRedundantVars	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Longint	frontsum,
		int	splitpos,
		int *	nchgcoefs,
		int *	nchgsides,
		int *	naddconss
	)

static

delete redundant variables

i.e. 5x1 + 5x2 + 5x3 + 2x4 + 1x5 <= 13 => x4, x5 always fits into the knapsack, so we can delete them

i.e. 5x1 + 5x2 + 5x3 + 2x4 + 1x5 <= 8 and we have the cliqueinformation (x1,x2,x3) is a clique => x4, x5 always fits into the knapsack, so we can delete them

i.e. 5x1 + 5x2 + 5x3 + 1x4 + 1x5 <= 6 and we have the cliqueinformation (x1,x2,x3) is a clique and (x4,x5) too => we create the set partitioning constraint x4 + x5 <= 1 and delete them in this knapsack

Parameters

scip	SCIP data structure
cons	knapsack constraint
frontsum	sum of front items which fit if we try to take from the first till the last
splitpos	split position till when all front items are fitting, splitpos is the first which did not fit
nchgcoefs	pointer to store the amount of changed coefficients
nchgsides	pointer to store the amount of changed sides
naddconss	pointer to count number of added constraints

Definition at line 7610 of file cons_knapsack.c.

References consdataChgWeight(), delCoefPos(), NULL, SCIP_GUBSet::nvars, SCIP_CALL, SCIP_Longint, SCIP_MAXSTRLEN, SCIP_OKAY, SCIPaddCons(), SCIPallocBufferArray, SCIPcalcCliquePartition(), SCIPcalcGreComDiv(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetData(), SCIPconsIsChecked(), SCIPconsIsDynamic(), SCIPconsIsEnforced(), SCIPconsIsInitial(), SCIPconsIsLocal(), SCIPconsIsModifiable(), SCIPconsIsPropagated(), SCIPconsIsRemovable(), SCIPconsIsSeparated(), SCIPconsIsStickingAtNode(), SCIPcreateConsSetpack(), SCIPdebugMessage, SCIPdebugPrintCons, SCIPfreeBufferArray, SCIPreleaseCons(), and SCIPsnprintf().

Referenced by detectRedundantVars().

static SCIP_RETCODE detectRedundantVars	(	SCIP *	scip,
		SCIP_CONS *	cons,
		int *	ndelconss,
		int *	nchgcoefs,
		int *	nchgsides,
		int *	naddconss
	)

static

Parameters

scip	SCIP data structure
cons	knapsack constraint
ndelconss	pointer to store the amount of deleted constraints
nchgcoefs	pointer to store the amount of changed coefficients
nchgsides	pointer to store the amount of changed sides
naddconss	pointer to count number of added constraints

Definition at line 7861 of file cons_knapsack.c.

References calcCliquepartition(), deleteRedundantVars(), FALSE, NULL, SCIP_GUBSet::nvars, SCIP_CALL, SCIP_Longint, SCIP_MAXSTRLEN, SCIP_OKAY, SCIPaddCons(), SCIPallocBufferArray, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetData(), SCIPconsIsChecked(), SCIPconsIsDeleted(), SCIPconsIsDynamic(), SCIPconsIsEnforced(), SCIPconsIsInitial(), SCIPconsIsLocal(), SCIPconsIsModifiable(), SCIPconsIsPropagated(), SCIPconsIsRemovable(), SCIPconsIsSeparated(), SCIPconsIsStickingAtNode(), SCIPcreateConsSetpack(), SCIPdebugMessage, SCIPdebugPrintCons, SCIPdelConsLocal(), SCIPfreeBufferArray, SCIPreleaseCons(), SCIPsnprintf(), TRUE, and upgradeCons().

Referenced by simplifyInequalities().

static void normalizeWeights	(	SCIP_CONS *	cons,
		int *	nchgcoefs,
		int *	nchgsides
	)

static

divides weights by their greatest common divisor and divides capacity by the same value, rounding down the result

Parameters

cons	knapsack constraint
nchgcoefs	pointer to count total number of changed coefficients
nchgsides	pointer to count number of side changes

Definition at line 8050 of file cons_knapsack.c.

Referenced by dualWeightsTightening().

static SCIP_RETCODE dualWeightsTightening	(	SCIP *	scip,
		SCIP_CONS *	cons,
		int *	ndelconss,
		int *	nchgcoefs,
		int *	nchgsides,
		int *	naddconss
	)

static

dual weights tightening for knapsack constraints

a) check if all two pairs exceed the capacity, then we can upgrade this constraint to a set-packing constraint b) check if all but the smallest weight fit into the knapsack, then we can upgrade this constraint to a logicor constraint
check if besides big coefficients, that fit only by itself, for a certain amount of variables all combination of these are a minimal cover, then might reduce the weights and the capacity, e.g.

+219y1 + 180y2 + 74x1 + 70x2 + 63x3 + 62x4 + 53x5 <= 219 <=> 3y1 + 3y2 + x1 + x2 + x3 + x4 + x5 <= 3
use the duality between a^Tx <= capacity <=> a^T~x >= weightsum - capacity to tighten weights, e.g.

11x1 + 10x2 + 7x3 + 7x4 + 5x5 <= 27 <=> 10~x1 + 10~x2 + 7~x3 + 7~x4 + 5~x5 >= 13

the above constraint can be changed to 8~x1 + 8~x2 + 6.5~x3 + 6.5~x4 + 5~x5 >= 13

16~x1 + 16~x2 + 13~x3 + 13~x4 + 10~x5 >= 26 <=> 16x1 + 16x2 + 13x3 + 13x4 + 10x5 <= 42

Parameters

scip	SCIP data structure
cons	knapsack constraint
ndelconss	pointer to store the amount of deleted constraints
nchgcoefs	pointer to store the amount of changed coefficients
nchgsides	pointer to store the amount of changed sides
naddconss	pointer to count number of added constraints

Definition at line 8122 of file cons_knapsack.c.

References consdataChgWeight(), delCoefPos(), FALSE, MIN, normalizeWeights(), NULL, SCIP_GUBSet::nvars, SCIP_Bool, SCIP_CALL, SCIP_ERROR, SCIP_Longint, SCIP_OKAY, SCIPaddCons(), SCIPconsGetData(), SCIPconsGetName(), SCIPconsIsChecked(), SCIPconsIsDeleted(), SCIPconsIsDynamic(), SCIPconsIsEnforced(), SCIPconsIsInitial(), SCIPconsIsLocal(), SCIPconsIsModifiable(), SCIPconsIsPropagated(), SCIPconsIsRemovable(), SCIPconsIsSeparated(), SCIPconsIsStickingAtNode(), SCIPcreateConsSetpack(), SCIPdebugMessage, SCIPdelCons(), SCIPreleaseCons(), TRUE, and upgradeCons().

Referenced by simplifyInequalities().

static SCIP_RETCODE prepareCons	(	SCIP *	scip,
		SCIP_CONS *	cons,
		int *	nfixedvars,
		int *	ndelconss,
		int *	nchgcoefs
	)

static

fixes variables with weights bigger than the capacity and delete redundant constraints, also sort weights

Parameters

scip	SCIP data structure
cons	knapsack constraint
nfixedvars	pointer to store the amount of fixed variables
ndelconss	pointer to store the amount of deleted constraints
nchgcoefs	pointer to store the amount of changed coefficients

Definition at line 8975 of file cons_knapsack.c.

References delCoefPos(), NULL, SCIP_GUBSet::nvars, SCIP_Bool, SCIP_CALL, SCIP_Longint, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), SCIPdelCons(), SCIPfixVar(), SCIPisHugeValue(), and sortItems().

Referenced by simplifyInequalities().

static SCIP_RETCODE simplifyInequalities	(	SCIP *	scip,
		SCIP_CONS *	cons,
		int *	nfixedvars,
		int *	ndelconss,
		int *	nchgcoefs,
		int *	nchgsides,
		int *	naddconss,
		SCIP_Bool *	cutoff
	)

static

tries to simplify weights and delete redundant variables in knapsack a^Tx <= capacity

use the duality between a^Tx <= capacity <=> -a^T~x <= capacity - weightsum to tighten weights, e.g.

11x1 + 10x2 + 7x3 + 5x4 + 5x5 <= 25 <=> -10~x1 - 10~x2 - 7~x3 - 5~x4 - 5~x5 <= -13

the above constraint can be changed to

-8~x1 - 8~x2 - 7~x3 - 5~x4 - 5~x5 <= -12 <=> 8x1 + 8x2 + 7x3 + 5x4 + 5x5 <= 20
if variables in a constraint do not affect the (in-)feasibility of the constraint, we can delte them, e.g.

7x1 + 6x2 + 5x3 + 5x4 + x5 + x6 <= 20 => x5 and x6 are redundant and can be removed
Tries to use gcd information an all but one weight to change this not-included weight and normalize the constraint further, e.g.

9x1 + 6x2 + 6x3 + 5x4 <= 13 => 9x1 + 6x2 + 6x3 + 6x4 <= 12 => 3x1 + 2x2 + 2x3 + 2x4 <= 4 => 4x1 + 2x2 + 2x3 + 2x4 <= 4 => 2x1 + x2 + x3 + x4 <= 2 9x1 + 6x2 + 6x3 + 7x4 <= 13 => 9x1 + 6x2 + 6x3 + 6x4 <= 12 => see above

Parameters

scip	SCIP data structure
cons	knapsack constraint
nfixedvars	pointer to store the amount of fixed variables
ndelconss	pointer to store the amount of deleted constraints
nchgcoefs	pointer to store the amount of changed coefficients
nchgsides	pointer to store the amount of changed sides
naddconss	pointer to count number of added constraints
cutoff	pointer to store whether the node can be cut off

Definition at line 9092 of file cons_knapsack.c.

References consdataChgWeight(), delCoefPos(), detectRedundantVars(), dualWeightsTightening(), FALSE, mergeMultiples(), NULL, SCIP_GUBSet::nvars, prepareCons(), SCIP_CALL, SCIP_Longint, SCIP_OKAY, SCIP_Real, SCIPcalcGreComDiv(), SCIPconsGetData(), SCIPconsGetName(), SCIPconsIsDeleted(), SCIPconsIsModifiable(), SCIPdebugMessage, SCIPdebugPrintCons, SCIPisHugeValue(), and SCIPvarGetName().

static SCIP_RETCODE applyFixings	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool *	cutoff
	)

static

deletes all fixed variables from knapsack constraint, and replaces variables with binary representatives

Parameters

scip	SCIP data structure
cons	knapsack constraint
cutoff	pointer to store whether the node can be cut off, or NULL if this information is not needed; in this case, we apply all fixings instead of stopping after the first infeasible one

Definition at line 9354 of file cons_knapsack.c.

References addCoef(), delCoefPos(), FALSE, mergeMultiples(), NULL, SCIP_Bool, SCIP_CALL, SCIP_ERROR, SCIP_Longint, SCIP_OKAY, SCIP_Real, SCIP_VARSTATUS_MULTAGGR, SCIPconsGetData(), SCIPdebugMessage, SCIPdebugPrintCons, SCIPerrorMessage, SCIPflattenVarAggregationGraph(), SCIPfloor(), SCIPgetBinvarRepresentative(), SCIPgetNegatedVar(), SCIPisFeasEQ(), SCIPisIntegral(), SCIPisNegative(), SCIPvarGetLbGlobal(), SCIPvarGetMultaggrConstant(), SCIPvarGetMultaggrNVars(), SCIPvarGetMultaggrScalars(), SCIPvarGetMultaggrVars(), SCIPvarGetNegatedVar(), SCIPvarGetStatus(), SCIPvarGetUbGlobal(), SCIPvarIsBinary(), SCIPvarIsNegated(), and TRUE.

Referenced by SCIP_DECL_CONSEXITPRE().

static SCIP_RETCODE insertZerolist	(	SCIP *	scip,
		int **	liftcands,
		int *	nliftcands,
		int **	firstidxs,
		SCIP_Longint **	zeroweightsums,
		int **	zeroitems,
		int **	nextidxs,
		int *	zeroitemssize,
		int *	nzeroitems,
		int	probindex,
		SCIP_Bool	value,
		int	knapsackidx,
		SCIP_Longint	knapsackweight,
		SCIP_Bool *	memlimitreached
	)

static

inserts an element into the list of binary zero implications

Parameters

scip	SCIP data structure
liftcands	array of the lifting candidates
nliftcands	number of lifting candidates
firstidxs	array of first zeroitems indices
zeroweightsums	array of sums of weights of the implied-to-zero items
zeroitems	pointer to zero items array
nextidxs	pointer to array of next zeroitems indeces
zeroitemssize	pointer to size of zero items array
nzeroitems	pointer to length of zero items array
probindex	problem index of variable y in implication y == v -> x == 0
value	value v of variable y in implication
knapsackidx	index of variable x in knapsack
knapsackweight	weight of variable x in knapsack
memlimitreached	pointer to store whether the memory limit was reached

Definition at line 9564 of file cons_knapsack.c.

References FALSE, MAX_ZEROITEMS_SIZE, MIN, NULL, SCIP_CALL, SCIP_OKAY, SCIPdebugMessage, SCIPgetNContVars(), SCIPgetNVars(), SCIPreallocBufferArray, and TRUE.

static SCIP_RETCODE tightenWeightsLift	(	SCIP *	scip,
		SCIP_CONS *	cons,
		int *	nchgcoefs,
		SCIP_Bool *	cutoff
	)

static

applies rule (3) of the weight tightening procedure, which can lift other variables into the knapsack: (3) for a clique C let C(xi == v) := C \ {j: xi == v -> xj == 0}), let cliqueweightsum(xi == v) := sum(W(C(xi == v))) if cliqueweightsum(xi == v) < capacity:

fixing variable xi to v would make the knapsack constraint redundant
the weight of the variable or its negation (depending on v) can be increased as long as it has the same redundancy effect: wi' := capacity - cliqueweightsum(xi == v) this rule can also be applied to binary variables not in the knapsack!

Parameters

scip	SCIP data structure
cons	knapsack constraint
nchgcoefs	pointer to count total number of changed coefficients
cutoff	pointer to store whether the node can be cut off

Definition at line 9650 of file cons_knapsack.c.

Referenced by tightenWeights().

static SCIP_RETCODE tightenWeights	(	SCIP *	scip,
		SCIP_CONS *	cons,
		int *	nchgcoefs,
		int *	nchgsides,
		int *	naddconss,
		int *	ndelconss,
		SCIP_Bool *	cutoff
	)

static

tightens item weights and capacity in presolving: given a knapsack sum(wi*xi) <= capacity (1) let weightsum := sum(wi) if weightsum - wi < capacity:

not using item i would make the knapsack constraint redundant
wi and capacity can be changed to have the same redundancy effect and the same results for fixing xi to zero or one, but with a reduced wi and tightened capacity to tighten the LP relaxation
change coefficients: wi' := weightsum - capacity capacity' := capacity - (wi - wi') (2) increase weights from front to back(sortation is necessary) if there is no space left for another weight
determine the four(can be adjusted) minimal weightsums of the knapsack, i.e. in increasing order weights[nvars - 1], weights[nvars - 2], MIN(weights[nvars - 3], weights[nvars - 1] + weights[nvars - 2]), MIN(MAX(weights[nvars - 3], weights[nvars - 1] + weights[nvars - 2]), weights[nvars - 4]), note that there can be multiple times the same weight, this can be improved
check if summing up a minimal weightsum with a big weight exceeds the capacity, then we can increase the big weight, to capacity - lastmininmalweightsum, e.g. : 19x1 + 15x2 + 10x3 + 5x4 + 5x5 <= 19 -> minimal weightsums: 5, 5, 10, 10 -> 15 + 5 > 19 => increase 15 to 19 - 0 = 19 -> 10 + 10 > 19 => increase 10 to 19 - 5 = 14, resulting in 19x1 + 19x2 + 14x3 + 5x4 + 5x5 <= 19 (3) let W(C) be the maximal weight of clique C, cliqueweightsum := sum(W(C)) if cliqueweightsum - W(C) < capacity:
not using any item of C would make the knapsack constraint redundant
weights wi, i in C, and capacity can be changed to have the same redundancy effect and the same results for fixing xi, i in C, to zero or one, but with a reduced wi and tightened capacity to tighten the LP relaxation
change coefficients: delta := capacity - (cliqueweightsum - W(C)) wi' := max(wi - delta, 0) capacity' := capacity - delta This rule has to add the used cliques in order to ensure they are enforced - otherwise, the reduction might introduce infeasible solutions. (4) for a clique C let C(xi == v) := C \ {j: xi == v -> xj == 0}), let cliqueweightsum(xi == v) := sum(W(C(xi == v))) if cliqueweightsum(xi == v) < capacity:
fixing variable xi to v would make the knapsack constraint redundant
the weight of the variable or its negation (depending on v) can be increased as long as it has the same redundancy effect: wi' := capacity - cliqueweightsum(xi == v) This rule can also be applied to binary variables not in the knapsack! (5) if min{w} + wi > capacity:
using item i would force to fix other items to zero
wi can be increased to the capacity

Parameters

scip	SCIP data structure
cons	knapsack constraint
nchgcoefs	pointer to count total number of changed coefficients
nchgsides	pointer to count number of side changes
naddconss	pointer to count number of added constraints
ndelconss	pointer to count number of deleted constraints
cutoff	pointer to store whether the node can be cut off

Definition at line 10274 of file cons_knapsack.c.

References calcCliquepartition(), consdataChgWeight(), FALSE, MAX, MAX_USECLIQUES_SIZE, mergeMultiples(), NULL, SCIP_GUBSet::nvars, removeZeroWeights(), SCIP_Bool, SCIP_CALL, SCIP_ERROR, SCIP_Longint, SCIP_MAXSTRLEN, SCIP_OKAY, SCIPaddCons(), SCIPallocBufferArray, SCIPcalcCliquePartition(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetData(), SCIPconsIsChecked(), SCIPconsIsDeleted(), SCIPconsIsDynamic(), SCIPconsIsEnforced(), SCIPconsIsInitial(), SCIPconsIsLocal(), SCIPconsIsModifiable(), SCIPconsIsPropagated(), SCIPconsIsRemovable(), SCIPconsIsSeparated(), SCIPconsIsStickingAtNode(), SCIPcreateConsSetpack(), SCIPdebugMessage, SCIPdebugPrintCons, SCIPdelCons(), SCIPfreeBufferArray, SCIPreleaseCons(), SCIPsnprintf(), SCIPvarGetName(), sortItems(), tightenWeightsLift(), and TRUE.

static SCIP_RETCODE addNegatedCliques	(	SCIP *const	scip,
		SCIP_CONS *const	cons,
		SCIP_Bool *const	cutoff,
		int *const	nbdchgs
	)

static

adds negated cliques of the knapsack constraint to the global clique table

Parameters

scip	SCIP data structure
cons	knapsack constraint
cutoff	pointer to store whether the node can be cut off
nbdchgs	pointer to count the number of performed bound changes

Definition at line 10830 of file cons_knapsack.c.

static SCIP_RETCODE addCliques	(	SCIP *const	scip,
		SCIP_CONS *const	cons,
		SCIP_Bool *const	cutoff,
		int *const	nbdchgs
	)

static

adds cliques of the knapsack constraint to the global clique table

Parameters

scip	SCIP data structure
cons	knapsack constraint
cutoff	pointer to store whether the node can be cut off
nbdchgs	pointer to count the number of performed bound changes

Definition at line 11038 of file cons_knapsack.c.

static SCIP_DECL_HASHGETKEY ( hashGetKeyKnapsackcons )

static

gets the key of the given element

Definition at line 11271 of file cons_knapsack.c.

static SCIP_DECL_HASHKEYEQ ( hashKeyEqKnapsackcons )

static

returns TRUE iff both keys are equal; two constraints are equal if they have the same variables and the same coefficients

Definition at line 11281 of file cons_knapsack.c.

static SCIP_DECL_HASHKEYVAL ( hashKeyValKnapsackcons )

static

returns the hash value of the key

Definition at line 11324 of file cons_knapsack.c.

static SCIP_RETCODE detectRedundantConstraints	(	SCIP *	scip,
		BMS_BLKMEM *	blkmem,
		SCIP_CONS **	conss,
		int	nconss,
		SCIP_Bool *	cutoff,
		int *	ndelconss
	)

static

compares each constraint with all other constraints for possible redundancy and removes or changes constraint accordingly; in contrast to preprocessConstraintPairs(), it uses a hash table

Parameters

scip	SCIP data structure
blkmem	block memory
conss	constraint set
nconss	number of constraints in constraint set
cutoff	pointer to store whether the problem is infeasible
ndelconss	pointer to count number of deleted constraints

Definition at line 11368 of file cons_knapsack.c.

References HASHSIZE_KNAPSACKCONS, MAX, NULL, SCIP_CALL, SCIP_OKAY, SCIPcalcHashtableSize(), SCIPconsGetData(), SCIPconsGetName(), SCIPconsIsActive(), SCIPconsIsModifiable(), SCIPdebugMessage, SCIPdelCons(), SCIPhashtableCreate(), SCIPhashtableFree(), SCIPhashtableInsert(), SCIPhashtableRemove(), SCIPhashtableRetrieve(), SCIPupdateConsFlags(), and TRUE.

static SCIP_RETCODE preprocessConstraintPairs	(	SCIP *	scip,
		SCIP_CONS **	conss,
		int	firstchange,
		int	chkind,
		int *	ndelconss
	)

static

compares constraint with all prior constraints for possible redundancy or aggregation, and removes or changes constraint accordingly

Parameters

scip	SCIP data structure
conss	constraint set
firstchange	first constraint that changed since last pair preprocessing round
chkind	index of constraint to check against all prior indices upto startind
ndelconss	pointer to count number of deleted constraints

Definition at line 11491 of file cons_knapsack.c.

References FALSE, NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), SCIPconsGetName(), SCIPconsIsActive(), SCIPconsIsModifiable(), SCIPdebugMessage, SCIPdebugPrintCons, SCIPdelCons(), SCIPisGT(), SCIPisLT(), SCIPupdateConsFlags(), sortItems(), and TRUE.

static SCIP_RETCODE createNormalizedKnapsack	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real *	vals,
		SCIP_Real	lhs,
		SCIP_Real	rhs,
		SCIP_Bool	initial,
		SCIP_Bool	separate,
		SCIP_Bool	enforce,
		SCIP_Bool	check,
		SCIP_Bool	propagate,
		SCIP_Bool	local,
		SCIP_Bool	modifiable,
		SCIP_Bool	dynamic,
		SCIP_Bool	removable,
		SCIP_Bool	stickingatnode
	)

static

creates and captures a knapsack constraint out of a linear inequality

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of variables in the constraint
vars	array with variables of constraint entries
vals	array with inequality coefficients
lhs	left hand side of inequality
rhs	right hand side of inequality
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 11685 of file cons_knapsack.c.

References NULL, SCIP_GUBSet::nvars, SCIP_CALL, SCIP_Longint, SCIP_OKAY, SCIPallocBufferArray, SCIPcreateConsKnapsack(), SCIPfeasFloor(), SCIPfreeBufferArray, SCIPgetNegatedVar(), SCIPisFeasIntegral(), and SCIPisInfinity().

Referenced by SCIP_DECL_LINCONSUPGD().

static SCIP_DECL_LINCONSUPGD ( linconsUpgdKnapsack )

static

tries to upgrade a linear constraint into a knapsack constraint

Definition at line 11780 of file cons_knapsack.c.

References createNormalizedKnapsack(), SCIP_CALL, SCIPconsGetName(), SCIPconsIsChecked(), SCIPconsIsDynamic(), SCIPconsIsEnforced(), SCIPconsIsInitial(), SCIPconsIsLocal(), SCIPconsIsModifiable(), SCIPconsIsPropagated(), SCIPconsIsRemovable(), SCIPconsIsSeparated(), SCIPconsIsStickingAtNode(), and SCIPdebugMessage.

static SCIP_DECL_CONSHDLRCOPY ( conshdlrCopyKnapsack )

static

copy method for constraint handler plugins (called when SCIP copies plugins)

Definition at line 11818 of file cons_knapsack.c.

static SCIP_DECL_CONSFREE ( consFreeKnapsack )

static

destructor of constraint handler to free constraint handler data (called when SCIP is exiting)

Definition at line 11834 of file cons_knapsack.c.

static SCIP_DECL_CONSINIT ( consInitKnapsack )

static

initialization method of constraint handler (called after problem was transformed)

Definition at line 11852 of file cons_knapsack.c.

static SCIP_DECL_CONSEXIT ( consExitKnapsack )

static

deinitialization method of constraint handler (called before transformed problem is freed)

Definition at line 11875 of file cons_knapsack.c.

static SCIP_DECL_CONSINITPRE ( consInitpreKnapsack )

static

presolving initialization method of constraint handler (called when presolving is about to begin)

Definition at line 11894 of file cons_knapsack.c.

static SCIP_DECL_CONSEXITPRE ( consExitpreKnapsack )

static

presolving deinitialization method of constraint handler (called after presolving has been finished)

Definition at line 11942 of file cons_knapsack.c.

References applyFixings(), NULL, SCIP_CALL, and SCIPconsIsDeleted().

static SCIP_DECL_CONSEXITSOL ( consExitsolKnapsack )

static

solving process deinitialization method of constraint handler (called before branch and bound process data is freed)

Definition at line 11986 of file cons_knapsack.c.

References NULL, SCIP_CALL, SCIPconsGetData(), and SCIPreleaseRow().

static SCIP_DECL_CONSDELETE ( consDeleteKnapsack )

static

frees specific constraint data

Definition at line 12010 of file cons_knapsack.c.

static SCIP_DECL_CONSTRANS ( consTransKnapsack )

static

transforms constraint data into data belonging to the transformed problem

Definition at line 12030 of file cons_knapsack.c.

static SCIP_DECL_CONSINITLP ( consInitlpKnapsack )

static

LP initialization method of constraint handler (called before the initial LP relaxation at a node is solved)

Definition at line 12067 of file cons_knapsack.c.

static SCIP_DECL_CONSSEPALP ( consSepalpKnapsack )

static

separation method of constraint handler for LP solutions

Definition at line 12084 of file cons_knapsack.c.

static SCIP_DECL_CONSSEPASOL ( consSepasolKnapsack )

static

separation method of constraint handler for arbitrary primal solutions

Definition at line 12158 of file cons_knapsack.c.

static SCIP_DECL_CONSENFOLP ( consEnfolpKnapsack )

static

constraint enforcing method of constraint handler for LP solutions

Definition at line 12219 of file cons_knapsack.c.

static SCIP_DECL_CONSENFOPS ( consEnfopsKnapsack )

static

constraint enforcing method of constraint handler for pseudo solutions

Definition at line 12272 of file cons_knapsack.c.

static SCIP_DECL_CONSCHECK ( consCheckKnapsack )

static

feasibility check method of constraint handler for integral solutions

Definition at line 12293 of file cons_knapsack.c.

static SCIP_DECL_CONSPROP ( consPropKnapsack )

static

domain propagation method of constraint handler

Definition at line 12314 of file cons_knapsack.c.

static SCIP_DECL_CONSPRESOL ( consPresolKnapsack )

static

presolving method of constraint handler

Definition at line 12360 of file cons_knapsack.c.

static SCIP_DECL_CONSRESPROP ( consRespropKnapsack )

static

propagation conflict resolving method of constraint handler

Definition at line 12567 of file cons_knapsack.c.

static SCIP_DECL_CONSLOCK ( consLockKnapsack )

static

variable rounding lock method of constraint handler

Definition at line 12650 of file cons_knapsack.c.

References SCIP_CALL, and SCIPaddVarLocks().

static SCIP_DECL_CONSDELVARS ( consDelvarsKnapsack )

static

variable deletion method of constraint handler

Definition at line 12669 of file cons_knapsack.c.

References performVarDeletions(), and SCIP_CALL.

static SCIP_DECL_CONSPRINT ( consPrintKnapsack )

static

constraint display method of constraint handler

Definition at line 12685 of file cons_knapsack.c.

static SCIP_DECL_CONSCOPY ( consCopyKnapsack )

static

constraint copying method of constraint handler

Definition at line 12711 of file cons_knapsack.c.

static SCIP_DECL_CONSPARSE ( consParseKnapsack )

static

constraint parsing method of constraint handler

Definition at line 12747 of file cons_knapsack.c.

static SCIP_DECL_CONSGETVARS ( consGetVarsKnapsack )

static

constraint method of constraint handler which returns the variables (if possible)

Definition at line 12847 of file cons_knapsack.c.

References BMScopyMemoryArray, NULL, and TRUE.

static SCIP_DECL_CONSGETNVARS ( consGetNVarsKnapsack )

static

constraint method of constraint handler which returns the number of variables (if possible)

Definition at line 12869 of file cons_knapsack.c.

static SCIP_DECL_EVENTEXEC ( eventExecKnapsack )

static

execution method of bound change event handler

Definition at line 12888 of file cons_knapsack.c.

SCIP_RETCODE SCIPincludeConshdlrKnapsack ( SCIP * scip )

creates the handler for knapsack constraints and includes it in SCIP

Parameters

scip	SCIP data structure

Definition at line 12952 of file cons_knapsack.c.

Referenced by SCIPincludeDefaultPlugins().

SCIP_RETCODE SCIPcreateConsKnapsack	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Longint *	weights,
		SCIP_Longint	capacity,
		SCIP_Bool	initial,
		SCIP_Bool	separate,
		SCIP_Bool	enforce,
		SCIP_Bool	check,
		SCIP_Bool	propagate,
		SCIP_Bool	local,
		SCIP_Bool	modifiable,
		SCIP_Bool	dynamic,
		SCIP_Bool	removable,
		SCIP_Bool	stickingatnode
	)

creates and captures a knapsack constraint

Note: the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of items in the knapsack
vars	array with item variables
weights	array with item weights
capacity	capacity of knapsack
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 13082 of file cons_knapsack.c.

References consdataCreate(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIPconshdlrGetData(), SCIPcreateCons(), SCIPerrorMessage, and SCIPfindConshdlr().

Referenced by createAndAddLinearCons(), createCapacityRestriction(), createNormalizedKnapsack(), and SCIPcreateConsBasicKnapsack().

SCIP_RETCODE SCIPcreateConsBasicKnapsack	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Longint *	weights,
		SCIP_Longint	capacity
	)

creates and captures a knapsack constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsKnapsack(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h

See Also: SCIPcreateConsKnapsack() for information about the basic constraint flag configuration

Note: the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of items in the knapsack
vars	array with item variables
weights	array with item weights
capacity	capacity of knapsack

Definition at line 13150 of file cons_knapsack.c.

References FALSE, NULL, SCIP_CALL, SCIP_OKAY, SCIPcreateConsKnapsack(), and TRUE.

SCIP_RETCODE SCIPaddCoefKnapsack	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var,
		SCIP_Longint	weight
	)

adds new item to knapsack constraint

Parameters

scip	SCIP data structure
cons	constraint data
var	item variable
weight	item weight

Definition at line 13169 of file cons_knapsack.c.

Referenced by addCoefTerm(), createCapacityRestriction(), and SCIPaddCoefPseudoboolean().

SCIP_Longint SCIPgetCapacityKnapsack	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

gets the capacity of the knapsack constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 13190 of file cons_knapsack.c.

References SCIPABORT, and SCIPerrorMessage.

Referenced by addKnapsackConstraints(), checkKnapsack(), getLinearConsSides(), initMatrix(), SCIP_DECL_READERWRITE(), SCIPwriteGms(), SCIPwriteLp(), SCIPwritePip(), writeFzn(), writeOpbConstraints(), and writeOpbObjective().

SCIP_RETCODE SCIPchgCapacityKnapsack	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Longint	capacity
	)

changes capacity of the knapsack constraint

Note: This method can only be called during problem creation stage (SCIP_STAGE_PROBLEM)

Parameters

scip	SCIP data structure
cons	constraint data
capacity	new capacity of knapsack

Definition at line 13214 of file cons_knapsack.c.

References SCIP_INVALIDDATA, and SCIPerrorMessage.

int SCIPgetNVarsKnapsack	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

gets the number of items in the knapsack constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 13243 of file cons_knapsack.c.

References SCIPABORT, and SCIPerrorMessage.

Referenced by addKnapsackConstraints(), checkKnapsack(), getLinearConsNVars(), getLinearConsVarsData(), initMatrix(), SCIP_DECL_READERWRITE(), SCIPwriteCcg(), SCIPwriteGms(), SCIPwriteLp(), SCIPwritePbm(), SCIPwritePip(), SCIPwritePpm(), writeFzn(), writeOpbConstraints(), and writeOpbObjective().

SCIP_VAR** SCIPgetVarsKnapsack	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

gets the array of variables in the knapsack constraint; the user must not modify this array!

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 13264 of file cons_knapsack.c.

References NULL, SCIPABORT, and SCIPerrorMessage.

Referenced by addKnapsackConstraints(), checkKnapsack(), getLinearConsVarsData(), initMatrix(), SCIP_DECL_READERWRITE(), SCIPwriteCcg(), SCIPwriteGms(), SCIPwriteLp(), SCIPwritePbm(), SCIPwritePip(), SCIPwritePpm(), writeFzn(), writeOpbConstraints(), and writeOpbObjective().

SCIP_Longint* SCIPgetWeightsKnapsack	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

gets the array of weights in the knapsack constraint; the user must not modify this array!

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 13285 of file cons_knapsack.c.

References NULL, SCIPABORT, and SCIPerrorMessage.

Referenced by addKnapsackConstraints(), checkKnapsack(), getLinearConsVarsData(), initMatrix(), SCIP_DECL_READERWRITE(), SCIPwriteCcg(), SCIPwriteGms(), SCIPwriteLp(), SCIPwritePbm(), SCIPwritePip(), SCIPwritePpm(), writeFzn(), and writeOpbConstraints().

SCIP_Real SCIPgetDualsolKnapsack	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

gets the dual solution of the knapsack constraint in the current LP

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 13306 of file cons_knapsack.c.

References SCIP_INVALID, SCIPABORT, and SCIPerrorMessage.

SCIP_Real SCIPgetDualfarkasKnapsack	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

gets the dual Farkas value of the knapsack constraint in the current infeasible LP

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 13330 of file cons_knapsack.c.

References SCIP_INVALID, SCIPABORT, and SCIPerrorMessage.

SCIP_ROW* SCIPgetRowKnapsack	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

returns the linear relaxation of the given knapsack constraint; may return NULL if no LP row was yet created; the user must not modify the row!

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 13356 of file cons_knapsack.c.

References NULL, SCIPABORT, and SCIPerrorMessage.

SCIP

Detailed Description

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation