# SCIP

Solving Constraint Integer Programs

cons_optcumulative.c File Reference

## Detailed Description

constraint handler for cumulative constraints with optional activities

Given a set of jobs $$J$$. Each job~ $$j$$ has a binary variables $$x_j$$ which is one if this job is scheduled on that machine (otherwise it is zero), an integer start time variables $$S_j$$, a processing time $$p_j$$, and a demands $$d_j$$. Besides that an integer resource capacity $$C$$.

The optcumulative enfoces the cumulative conditions for those jobs which are assigned to that machine. Let $$J'$$ be the subset of jobs assigned to that optcumulative constraint, then the cumulative constraint ensures that for each point in time $$t$$ $$\sum_{j\in J': S_j \leq t < S_j + p_j} d_j \leq C$$ holds.

Propagation:

LP Relaxation:

• let est(J) the earliest start time of all jobs of set $$J$$ and lct(J) the latest completion time for all jobs of set $$J$$, then the following linear constraint has to hold $$\sum_{j\in J} p_j \cdot d_j \leq (lct(J) - est(J)) \cdot C$$

Definition in file cons_optcumulative.c.

#include <assert.h>
#include <string.h>
#include "cons_optcumulative.h"
#include "scip/cons_cumulative.h"
#include "scip/cons_knapsack.h"
#include "scip/scipdefplugins.h"

Go to the source code of this file.

## Macros

#define consInitOptcumulative   NULL

#define consExitOptcumulative   NULL

#define consExitpreOptcumulative   NULL

#define consInitsolOptcumulative   NULL

#define consEnforelaxOptcomulative   NULL

#define consSepasolOptcumulative   NULL

#define consActiveOptcumulative   NULL

#define consDeactiveOptcumulative   NULL

#define consEnableOptcumulative   NULL

#define consDisableOptcumulative   NULL

#define consDelvarsOptcumulative   NULL

Constraint handler properties
#define CONSHDLR_NAME   "optcumulative"

#define CONSHDLR_DESC   "constraint handler for cumulative constraints with optional activities"

#define CONSHDLR_SEPAPRIORITY   0

#define CONSHDLR_ENFOPRIORITY   -2060000

#define CONSHDLR_CHECKPRIORITY   -3100000

#define CONSHDLR_SEPAFREQ   1

#define CONSHDLR_PROPFREQ   1

#define CONSHDLR_EAGERFREQ   100

#define CONSHDLR_MAXPREROUNDS   -1

#define CONSHDLR_DELAYSEPA   FALSE

#define CONSHDLR_DELAYPROP   FALSE

#define CONSHDLR_NEEDSCONS   TRUE

#define CONSHDLR_PROP_TIMING   SCIP_PROPTIMING_BEFORELP

#define CONSHDLR_PRESOLTIMING   SCIP_PRESOLTIMING_MEDIUM

Event handler properties
#define EVENTHDLR_BINVARS_NAME   "optcumulativebinvars"

#define EVENTHDLR_BINVARS_DESC   "bound change event handler for binary variables of optcumulative constraints"

#define EVENTHDLR_INTVARS_NAME   "optcumulativeintvars"

#define EVENTHDLR_INTVARS_DESC   "bound change event handler for integer variables of optcumulative constraints"

Default parameter values
#define DEFAULT_ROWRELAX   FALSE

#define DEFAULT_CONFLICTANALYSIS   TRUE

#define DEFAULT_INTERVALRELAX   TRUE

## Functions

static SCIP_RETCODE unlockRounding (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *binvar, SCIP_VAR *var, SCIP_Bool downlock, SCIP_Bool uplock)

static SCIP_RETCODE catchEventBinvar (SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, int pos)

static SCIP_RETCODE dropEventBinvar (SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, int pos)

static SCIP_RETCODE catchEventIntvar (SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, int pos)

static SCIP_RETCODE dropEventIntvar (SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, int pos)

static SCIP_RETCODE catchAllEvents (SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlrbinvars, SCIP_EVENTHDLR *eventhdlrintvars)

static SCIP_RETCODE dropAllEvents (SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlrbinvars, SCIP_EVENTHDLR *eventhdlrintvars)

static void createSortedEventpoints (SCIP *scip, SCIP_CONSDATA *consdata, int *starttimes, int *endtimes, int *startindices, int *endindices, SCIP_Bool local)

static SCIP_Longint computeMaxEnergy (SCIP *scip, SCIP_CONSDATA *consdata, int starttime, int endtime)

static SCIP_RETCODE collectVars (SCIP *scip, SCIP_CONSDATA *consdata, SCIP_VAR **vars, SCIP_Longint *weights, int *nvars, int starttime, int endtime)

static int removeRedundantRows (SCIP_Longint *rowtightness, int *startidxs, int nrows, SCIP_Longint tightness)

static SCIP_RETCODE createRow (SCIP *scip, SCIP_CONSHDLR *conshdlr, const char *name, SCIP_VAR **vars, SCIP_Longint *weights, int nvars, SCIP_Longint capacity, SCIP_Bool local, SCIP_Bool *rowadded, SCIP_Bool *consadded, SCIP_Bool *cutoff)

static SCIP_RETCODE addRelaxation (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_CONS *cons, SCIP_Bool *rowadded, SCIP_Bool *consadded, SCIP_Bool *cutoff)

static void collectActivities (SCIP_CONSDATA *consdata, SCIP_VAR **binvars, SCIP_VAR **vars, int *durations, int *demands, int *nfixedones, int *nfixedzeros, SCIP_Bool *auxiliary)

static void collectSolActivities (SCIP *scip, SCIP_CONSDATA *consdata, SCIP_SOL *sol, SCIP_VAR **binvars, SCIP_VAR **vars, int *durations, int *demands, int *nvars, int *nfixedones, int *nfixedzeros, SCIP_Bool *auxiliary)

static SCIP_RETCODE solveCumulative (SCIP *scip, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, SCIP_Bool local, SCIP_Real *ests, SCIP_Real *lsts, SCIP_Longint maxnodes, SCIP_Bool *solved, SCIP_Bool *infeasible, SCIP_Bool *unbounded, SCIP_Bool *error)

static SCIP_RETCODE createConflictCons (SCIP *scip, const char *name, SCIP_VAR **binvars, int nvars)

static SCIP_RETCODE checkRedundancy (SCIP *scip, SCIP_CONS *cons, int *ndelconss, SCIP_Bool *redundant)

static SCIP_RETCODE solveSubproblem (SCIP *scip, SCIP_CONS *cons, SCIP_Bool conflictanalysis, SCIP_CONSDATA *consdata, SCIP_VAR **binvars, SCIP_VAR **vars, int *durations, int *demands, int nvars, int *nfixedvars, int *nchgbds, int *ndelconss, SCIP_Bool *cutoff)

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

static SCIP_RETCODE enfopsCons (SCIP *scip, SCIP_CONS *cons, SCIP_SOL *trysol, SCIP_Bool *violated, SCIP_Bool *consadded, SCIP_Bool *solfeasible)

static SCIP_RETCODE upgradeCons (SCIP *scip, SCIP_CONS *cons, int *ndelconss, int *nupgdconss, SCIP_Bool *mustpropagate)

static SCIP_RETCODE fixIntegerVariable (SCIP *scip, SCIP_VAR *var, SCIP_Bool downlock, SCIP_Bool uplock, int *nchgbds)

static SCIP_RETCODE consdataDeletePos (SCIP *scip, SCIP_CONSDATA *consdata, SCIP_CONS *cons, int pos)

static SCIP_RETCODE applyZeroFixings (SCIP *scip, SCIP_CONS *cons, int *nchgcoefs, int *nchgbds)

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

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

static SCIP_RETCODE createSetPackingCons (SCIP *scip, SCIP_VAR *var1, SCIP_VAR *var2)

static SCIP_RETCODE createVarboundCons (SCIP *scip, SCIP_VAR *binvar, SCIP_VAR *intvar, int bound, SCIP_Bool lower)

static SCIP_RETCODE createBounddisjunctionCons (SCIP *scip, SCIP_VAR *binvar, SCIP_VAR *intvar, int lb, int ub)

static SCIP_RETCODE detectImplications (SCIP *scip, SCIP_CONS *cons, int *nchgcoefs, int *naddconss)

static SCIP_RETCODE propagateCons (SCIP *scip, SCIP_CONS *cons, SCIP_Bool conflictanalysis, int *nfixedvars, int *nchgbds, int *ndelconss, SCIP_Bool *cutoff)

static SCIP_DECL_CONSHDLRCOPY (conshdlrCopyOptcumulative)

static SCIP_DECL_CONSFREE (consFreeOptcumulative)

static SCIP_DECL_CONSINITPRE (consInitpreOptcumulative)

static SCIP_DECL_CONSEXITSOL (consExitsolOptcumulative)

static SCIP_DECL_CONSDELETE (consDeleteOptcumulative)

static SCIP_DECL_CONSTRANS (consTransOptcumulative)

static SCIP_DECL_CONSINITLP (consInitlpOptcumulative)

static SCIP_DECL_CONSSEPALP (consSepalpOptcumulative)

static SCIP_DECL_CONSENFOLP (consEnfolpOptcumulative)

static SCIP_DECL_CONSENFOPS (consEnfopsOptcumulative)

static SCIP_DECL_CONSCHECK (consCheckOptcumulative)

static SCIP_DECL_CONSPROP (consPropOptcumulative)

static SCIP_DECL_CONSPRESOL (consPresolOptcumulative)

static SCIP_DECL_CONSRESPROP (consRespropOptcumulative)

static SCIP_DECL_CONSLOCK (consLockOptcumulative)

static SCIP_DECL_CONSPRINT (consPrintOptcumulative)

static SCIP_DECL_CONSCOPY (consCopyOptcumulative)

static SCIP_DECL_CONSPARSE (consParseOptcumulative)

static SCIP_DECL_EVENTEXEC (eventExecOptcumulativeBinvars)

static SCIP_DECL_EVENTEXEC (eventExecOptcumulativeIntvars)

SCIP_RETCODE SCIPincludeConshdlrOptcumulative (SCIP *scip)

SCIP_RETCODE SCIPcreateConsOptcumulative (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_VAR **binvars, int *durations, int *demands, int 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 SCIPsetHminOptcumulative (SCIP *scip, SCIP_CONS *cons, int hmin)

int SCIPgetHminOptcumulative (SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPsetHmaxOptcumulative (SCIP *scip, SCIP_CONS *cons, int hmax)

int SCIPgetHmaxOptcumulative (SCIP *scip, SCIP_CONS *cons)

Debug Methods
static void checkCounters (SCIP_CONSDATA *consdata)

Miscellaneous Methods
static int convertBoundToInt (SCIP *scip, SCIP_Real bound)

Constraint data methods
static SCIP_RETCODE consdataCreate (SCIP *scip, SCIP_CONSDATA **consdata, int nvars, SCIP_VAR **vars, SCIP_VAR **binvars, int *durations, int *demands, int capacity, SCIP_Bool check)

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

static SCIP_RETCODE consdataPrint (SCIP *scip, SCIP_CONSDATA *consdata, FILE *file)

Constraint handler data

Method used to create and free the constraint handler data when including and removing the cumulative constraint handler.

static SCIP_RETCODE conshdlrdataCreate (SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata, SCIP_EVENTHDLR *eventhdlrbinvars, SCIP_EVENTHDLR *eventhdlrintvars)

static SCIP_RETCODE conshdlrdataFree (SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata)

## ◆ CONSHDLR_NAME

 #define CONSHDLR_NAME   "optcumulative"

## ◆ CONSHDLR_DESC

 #define CONSHDLR_DESC   "constraint handler for cumulative constraints with optional activities"

Definition at line 79 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ CONSHDLR_SEPAPRIORITY

 #define CONSHDLR_SEPAPRIORITY   0

priority of the constraint handler for separation

Definition at line 80 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ CONSHDLR_ENFOPRIORITY

 #define CONSHDLR_ENFOPRIORITY   -2060000

priority of the constraint handler for constraint enforcing

Definition at line 81 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ CONSHDLR_CHECKPRIORITY

 #define CONSHDLR_CHECKPRIORITY   -3100000

priority of the constraint handler for checking feasibility

Definition at line 82 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ CONSHDLR_SEPAFREQ

 #define CONSHDLR_SEPAFREQ   1

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

Definition at line 83 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ CONSHDLR_PROPFREQ

 #define CONSHDLR_PROPFREQ   1

frequency for propagating domains; zero means only preprocessing propagation

Definition at line 84 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ CONSHDLR_EAGERFREQ

 #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 85 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ CONSHDLR_MAXPREROUNDS

 #define CONSHDLR_MAXPREROUNDS   -1

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

Definition at line 88 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ CONSHDLR_DELAYSEPA

 #define CONSHDLR_DELAYSEPA   FALSE

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

Definition at line 89 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ CONSHDLR_DELAYPROP

 #define CONSHDLR_DELAYPROP   FALSE

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

Definition at line 90 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ CONSHDLR_NEEDSCONS

 #define CONSHDLR_NEEDSCONS   TRUE

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

Definition at line 91 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ CONSHDLR_PROP_TIMING

 #define CONSHDLR_PROP_TIMING   SCIP_PROPTIMING_BEFORELP

Definition at line 93 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ CONSHDLR_PRESOLTIMING

 #define CONSHDLR_PRESOLTIMING   SCIP_PRESOLTIMING_MEDIUM

Definition at line 94 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ EVENTHDLR_BINVARS_NAME

 #define EVENTHDLR_BINVARS_NAME   "optcumulativebinvars"

Definition at line 103 of file cons_optcumulative.c.

Referenced by SCIP_DECL_EVENTEXEC(), and SCIPincludeConshdlrOptcumulative().

## ◆ EVENTHDLR_BINVARS_DESC

 #define EVENTHDLR_BINVARS_DESC   "bound change event handler for binary variables of optcumulative constraints"

Definition at line 104 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ EVENTHDLR_INTVARS_NAME

 #define EVENTHDLR_INTVARS_NAME   "optcumulativeintvars"

Definition at line 106 of file cons_optcumulative.c.

Referenced by SCIP_DECL_EVENTEXEC(), and SCIPincludeConshdlrOptcumulative().

## ◆ EVENTHDLR_INTVARS_DESC

 #define EVENTHDLR_INTVARS_DESC   "bound change event handler for integer variables of optcumulative constraints"

Definition at line 107 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ DEFAULT_ROWRELAX

 #define DEFAULT_ROWRELAX   FALSE

add linear relaxation as LP row (otherwise a knapsack constraint is created)?

Definition at line 116 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ DEFAULT_CONFLICTANALYSIS

 #define DEFAULT_CONFLICTANALYSIS   TRUE

participate in conflict analysis?"

Definition at line 117 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ DEFAULT_INTERVALRELAX

 #define DEFAULT_INTERVALRELAX   TRUE

create a relaxation for each start and end time point interval

Definition at line 118 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ consInitOptcumulative

 #define consInitOptcumulative   NULL

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

Definition at line 3021 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ consExitOptcumulative

 #define consExitOptcumulative   NULL

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

Definition at line 3025 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ consExitpreOptcumulative

 #define consExitpreOptcumulative   NULL

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

Definition at line 3060 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ consInitsolOptcumulative

 #define consInitsolOptcumulative   NULL

solving process initialization method of constraint handler (called when branch and bound process is about to begin)

Definition at line 3064 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ consEnforelaxOptcomulative

 #define consEnforelaxOptcomulative   NULL

constraint enforcing method of constraint handler for relaxation solutions

Definition at line 3067 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ consSepasolOptcumulative

 #define consSepasolOptcumulative   NULL

separation method of constraint handler for arbitrary primal solutions

Definition at line 3235 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ consActiveOptcumulative

 #define consActiveOptcumulative   NULL

constraint activation notification method of constraint handler

Definition at line 3818 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ consDeactiveOptcumulative

 #define consDeactiveOptcumulative   NULL

constraint deactivation notification method of constraint handler

Definition at line 3822 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ consEnableOptcumulative

 #define consEnableOptcumulative   NULL

constraint enabling notification method of constraint handler

Definition at line 3826 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ consDisableOptcumulative

 #define consDisableOptcumulative   NULL

constraint disabling notification method of constraint handler

Definition at line 3830 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ consDelvarsOptcumulative

 #define consDelvarsOptcumulative   NULL

variable deletion method of constraint handler

Definition at line 3833 of file cons_optcumulative.c.

Referenced by SCIPincludeConshdlrOptcumulative().

## ◆ checkCounters()

 static void checkCounters ( SCIP_CONSDATA * consdata )
static

check constraint state (nglbfixedones and nglbfixedzeros)

Parameters
 consdata optcumulative constraint data

Definition at line 177 of file cons_optcumulative.c.

Referenced by applyZeroFixings(), catchAllEvents(), consdataDeletePos(), propagateCons(), and upgradeCons().

## ◆ convertBoundToInt()

 static int convertBoundToInt ( SCIP * scip, SCIP_Real bound )
static

converts the given double bound which is integral to an int; in optimized mode the function gets inlined for performance; in debug mode we check some additional conditions

Parameters
 scip SCIP data structure bound double bound to convert

Definition at line 228 of file cons_optcumulative.c.

References bound, consdataCreate(), SCIP_Real, SCIPisEQ(), and SCIPisIntegral().

## ◆ consdataCreate()

 static SCIP_RETCODE consdataCreate ( SCIP * scip, SCIP_CONSDATA ** consdata, int nvars, SCIP_VAR ** vars, SCIP_VAR ** binvars, int * durations, int * demands, int capacity, SCIP_Bool check )
static

creates constraint data of optcumulative constraint

Parameters
 scip SCIP data structure consdata pointer to consdata nvars number of variables vars array of integer variables binvars array of variable representing if the job has to be processed on this machine durations array containing corresponding durations demands array containing corresponding demands capacity available cumulative capacity check is the corresponding constraint a check constraint

Definition at line 251 of file cons_optcumulative.c.

Referenced by convertBoundToInt(), SCIP_DECL_CONSTRANS(), and SCIPcreateConsOptcumulative().

## ◆ consdataFree()

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

frees a optcumulative constraint data

Parameters
 scip SCIP data structure consdata pointer to linear constraint data

Definition at line 348 of file cons_optcumulative.c.

Referenced by consdataCreate(), and SCIP_DECL_CONSDELETE().

## ◆ consdataPrint()

 static SCIP_RETCODE consdataPrint ( SCIP * scip, SCIP_CONSDATA * consdata, FILE * file )
static

prints optcumulative constraint to file stream

Parameters
 scip SCIP data structure consdata optcumulative constraint data file output file (or NULL for standard output)

Definition at line 391 of file cons_optcumulative.c.

Referenced by consdataFree(), and SCIP_DECL_CONSPRINT().

## ◆ conshdlrdataCreate()

 static SCIP_RETCODE conshdlrdataCreate ( SCIP * scip, SCIP_CONSHDLRDATA ** conshdlrdata, SCIP_EVENTHDLR * eventhdlrbinvars, SCIP_EVENTHDLR * eventhdlrintvars )
static

creates constaint handler data for set partitioning / packing / covering constraint handler

Parameters
 scip SCIP data structure conshdlrdata pointer to store the constraint handler data eventhdlrbinvars used event handler for tracing bound changes on binary variables eventhdlrintvars used event handler for tracing bound changes on integer variables

Definition at line 434 of file cons_optcumulative.c.

References conshdlrdataFree(), NULL, SCIP_CALL, SCIP_OKAY, and SCIPallocBlockMemory.

Referenced by consdataPrint(), and SCIPincludeConshdlrOptcumulative().

## ◆ conshdlrdataFree()

 static SCIP_RETCODE conshdlrdataFree ( SCIP * scip, SCIP_CONSHDLRDATA ** conshdlrdata )
static

frees constraint handler data for set partitioning / packing / covering constraint handler

Parameters
 scip SCIP data structure conshdlrdata pointer to the constraint handler data

Definition at line 457 of file cons_optcumulative.c.

References NULL, SCIP_OKAY, SCIPfreeBlockMemory, and unlockRounding().

Referenced by conshdlrdataCreate(), and SCIP_DECL_CONSFREE().

## ◆ unlockRounding()

 static SCIP_RETCODE unlockRounding ( SCIP * scip, SCIP_CONS * cons, SCIP_VAR * binvar, SCIP_VAR * var, SCIP_Bool downlock, SCIP_Bool uplock )
static

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

Parameters
 scip SCIP data structure cons optcumulative constraint binvar decision variable var start time variable downlock has the integer start time variable a down lock uplock has the integer start time variable an up lock

Definition at line 474 of file cons_optcumulative.c.

References catchEventBinvar(), FALSE, SCIP_CALL, SCIP_OKAY, SCIPunlockVarCons(), and TRUE.

Referenced by consdataDeletePos(), and conshdlrdataFree().

## ◆ catchEventBinvar()

 static SCIP_RETCODE catchEventBinvar ( SCIP * scip, SCIP_CONS * cons, SCIP_EVENTHDLR * eventhdlr, int pos )
static

catches events for binary variable at given position

Parameters
 scip SCIP data structure cons set partitioning / packing / covering constraint eventhdlr event handler to call for the event processing pos array position of variable to catch bound change events for

Definition at line 494 of file cons_optcumulative.c.

Referenced by catchAllEvents(), and unlockRounding().

## ◆ dropEventBinvar()

 static SCIP_RETCODE dropEventBinvar ( SCIP * scip, SCIP_CONS * cons, SCIP_EVENTHDLR * eventhdlr, int pos )
static

drops events for binary variable at given position

Parameters
 scip SCIP data structure cons set partitioning / packing / covering constraint eventhdlr event handler to call for the event processing pos array position of variable to catch bound change events for

Definition at line 547 of file cons_optcumulative.c.

Referenced by catchEventBinvar(), consdataDeletePos(), and dropAllEvents().

## ◆ catchEventIntvar()

 static SCIP_RETCODE catchEventIntvar ( SCIP * scip, SCIP_CONS * cons, SCIP_EVENTHDLR * eventhdlr, int pos )
static

catches events for integer variable at given position

Parameters
 scip SCIP data structure cons set partitioning / packing / covering constraint eventhdlr event handler to call for the event processing pos array position of variable to catch bound change events for

Definition at line 594 of file cons_optcumulative.c.

Referenced by catchAllEvents(), and dropEventBinvar().

## ◆ dropEventIntvar()

 static SCIP_RETCODE dropEventIntvar ( SCIP * scip, SCIP_CONS * cons, SCIP_EVENTHDLR * eventhdlr, int pos )
static

drops events for integer variable at given position

Parameters
 scip SCIP data structure cons set partitioning / packing / covering constraint eventhdlr event handler to call for the event processing pos array position of variable to catch bound change events for

Definition at line 629 of file cons_optcumulative.c.

Referenced by catchEventIntvar(), consdataDeletePos(), and dropAllEvents().

## ◆ catchAllEvents()

 static SCIP_RETCODE catchAllEvents ( SCIP * scip, SCIP_CONS * cons, SCIP_EVENTHDLR * eventhdlrbinvars, SCIP_EVENTHDLR * eventhdlrintvars )
static

catches bound change events for all variables in transformed optcumulative constraint

Parameters
 scip SCIP data structure cons set partitioning / packing / covering constraint eventhdlrbinvars event handler to call for the event processing on binary variables eventhdlrintvars event handler to call for the event processing on integer variables

Definition at line 659 of file cons_optcumulative.c.

Referenced by dropEventIntvar(), SCIP_DECL_CONSTRANS(), and SCIPcreateConsOptcumulative().

## ◆ dropAllEvents()

 static SCIP_RETCODE dropAllEvents ( SCIP * scip, SCIP_CONS * cons, SCIP_EVENTHDLR * eventhdlrbinvars, SCIP_EVENTHDLR * eventhdlrintvars )
static

drops bound change events for all variables in transformed optcumulative constraint

Parameters
 scip SCIP data structure cons set partitioning / packing / covering constraint eventhdlrbinvars event handler to call for the event processing on binary variables eventhdlrintvars event handler to call for the event processing on integer variables

Definition at line 692 of file cons_optcumulative.c.

Referenced by catchAllEvents(), and SCIP_DECL_CONSDELETE().

## ◆ createSortedEventpoints()

 static void createSortedEventpoints ( SCIP * scip, SCIP_CONSDATA * consdata, int * starttimes, int * endtimes, int * startindices, int * endindices, SCIP_Bool local )
static

initialize the sorted event point arrays

Parameters
 scip SCIP data structure consdata constraint data starttimes array to store sorted start events endtimes array to store sorted end events startindices permutation with rspect to the start times endindices permutation with rspect to the end times local shall local bounds be used

Definition at line 724 of file cons_optcumulative.c.

Referenced by addRelaxation(), and dropAllEvents().

## ◆ computeMaxEnergy()

 static SCIP_Longint computeMaxEnergy ( SCIP * scip, SCIP_CONSDATA * consdata, int starttime, int endtime )
static

computes the maximum energy for all variables which correspond to jobs which start between the given start time and end time

Returns
Maximum energy for the given time window
Parameters
 scip SCIP data structure consdata optcumulative constraint data starttime start time endtime end time

Definition at line 770 of file cons_optcumulative.c.

Referenced by addRelaxation(), and createSortedEventpoints().

## ◆ collectVars()

 static SCIP_RETCODE collectVars ( SCIP * scip, SCIP_CONSDATA * consdata, SCIP_VAR ** vars, SCIP_Longint * weights, int * nvars, int starttime, int endtime )
static

collects all variables which correspond to jobs which start between the given start time and end time

Parameters
 scip SCIP data structure consdata optcumulative constraint data vars array to store the variables weights array to store the weights nvars pointer to store the number of collected variables starttime start time endtime end time

Definition at line 801 of file cons_optcumulative.c.

Referenced by addRelaxation(), and computeMaxEnergy().

## ◆ removeRedundantRows()

 static int removeRedundantRows ( SCIP_Longint * rowtightness, int * startidxs, int nrows, SCIP_Longint tightness )
static

remove row which have a tightness which is smaller or equal to the given one

Returns
The number of remaining rows
Parameters
 rowtightness array containing the tightness for the previously selected rows startidxs array containing for each row the index for the start event nrows current number of rows tightness tightness to use to detect redundant rows

Definition at line 839 of file cons_optcumulative.c.

References createRow().

Referenced by addRelaxation(), and collectVars().

## ◆ createRow()

 static SCIP_RETCODE createRow ( SCIP * scip, SCIP_CONSHDLR * conshdlr, const char * name, SCIP_VAR ** vars, SCIP_Longint * weights, int nvars, SCIP_Longint capacity, SCIP_Bool local, SCIP_Bool * rowadded, SCIP_Bool * consadded, SCIP_Bool * cutoff )
static

depending on the parameters setting a row or an knapsack constraint is created

Parameters
 scip SCIP data structure conshdlr constraint handler name name of the row vars array of variable representing if the job has to be processed on this machine weights start time variables of the activities which are assigned nvars number of variables capacity available cumulative capacity local create local row rowadded pointer to store if a row was added consadded pointer to store if a constraint was added cutoff pointer to store whether a cutoff occurred

Definition at line 866 of file cons_optcumulative.c.

Referenced by addRelaxation(), enfopsCons(), and removeRedundantRows().

## ◆ addRelaxation()

 static SCIP_RETCODE addRelaxation ( SCIP * scip, SCIP_CONSHDLR * conshdlr, SCIP_CONSHDLRDATA * conshdlrdata, SCIP_CONS * cons, SCIP_Bool * rowadded, SCIP_Bool * consadded, SCIP_Bool * cutoff )
static

adds linear relaxation as cut to the LP

Parameters
 scip SCIP data structure conshdlr constraint handler conshdlrdata constraint handler data structure cons optcumulative constraint rowadded pointer to store if a row was added consadded pointer to store if a constraint was added cutoff pointer to store whether a cutoff occurred

Definition at line 937 of file cons_optcumulative.c.

Referenced by createRow(), SCIP_DECL_CONSINITLP(), and SCIP_DECL_CONSSEPALP().

## ◆ collectActivities()

 static void collectActivities ( SCIP_CONSDATA * consdata, SCIP_VAR ** binvars, SCIP_VAR ** vars, int * durations, int * demands, int * nfixedones, int * nfixedzeros, SCIP_Bool * auxiliary )
static

collect all activities which are locally (that means in the current branch and bound node) assigned to that machine

Parameters
 consdata constraint data binvars array of variable representing if the job has to be processed on this machine vars start time variables of the activities which are assigned durations durations of the activities demands demands of the activities nfixedones pointer to store number of activities assigned to that machine nfixedzeros pointer to store number of binary variables fixed to zeor auxiliary pointer to store if the integer start time variables of the assigned activities are auxiliary variables; that is the case if the optcumulative choice constraints is the only one having locks on these variables

Definition at line 1164 of file cons_optcumulative.c.

Referenced by addRelaxation(), propagateCons(), and upgradeCons().

## ◆ collectSolActivities()

 static void collectSolActivities ( SCIP * scip, SCIP_CONSDATA * consdata, SCIP_SOL * sol, SCIP_VAR ** binvars, SCIP_VAR ** vars, int * durations, int * demands, int * nvars, int * nfixedones, int * nfixedzeros, SCIP_Bool * auxiliary )
static

collect all activities which are assigned to that machine in the given solution

Parameters
 scip SCIP data structure consdata constraint data sol primal solution, or NULL for current LP/pseudo solution binvars array of variable representing if the job has to be processed on this machine vars start time variables of the activities which are assigned durations durations of the activities demands demands of the activities nvars pointer to store number of activities assigned to that machine nfixedones pointer to store number of binary variables locally fixed to one nfixedzeros pointer to store number of binary variables locally fixed to zero auxiliary pointer to store if the integer start time variables of the assigned activities are auxiliary variables; that is the case if the machine choice constraints is the only one haveing locks on these variables

Definition at line 1219 of file cons_optcumulative.c.

Referenced by checkCons(), collectActivities(), and enfopsCons().

## ◆ solveCumulative()

 static SCIP_RETCODE solveCumulative ( SCIP * scip, int nvars, SCIP_VAR ** vars, int * durations, int * demands, int capacity, int hmin, int hmax, SCIP_Bool local, SCIP_Real * ests, SCIP_Real * lsts, SCIP_Longint maxnodes, SCIP_Bool * solved, SCIP_Bool * infeasible, SCIP_Bool * unbounded, SCIP_Bool * error )
static

solves given cumulative condition as independent sub problem

Note
The time and memory limit of the SCIP environment in transferred to sub solver
If the problem was solved to the earliest start times (ests) and latest start times (lsts) array contain the solution values; If the problem was not solved these two arrays contain the global bounds at the time the sub solver was interrupted.
Parameters
 scip SCIP data structure nvars number of start time variables (activities) vars start time variables durations array of durations demands array of demands capacity cumulative capacity hmin left bound of time axis to be considered (including hmin) hmax right bound of time axis to be considered (not including hmax) local use local bounds, otherwise global ests array to store the earlier start time for each job lsts array to store the latest start time for each job maxnodes maximum number of branch-and-bound nodes to solve the single cumulative constraint (-1: no limit) solved pointer to store if the problem is solved (to optimality) infeasible pointer to store if the problem is infeasible unbounded pointer to store if the problem is unbounded error pointer to store if an error occurred

Definition at line 1277 of file cons_optcumulative.c.

## ◆ createConflictCons()

 static SCIP_RETCODE createConflictCons ( SCIP * scip, const char * name, SCIP_VAR ** binvars, int nvars )
static

create a logicor constraint which ensures that the jobs related to binary variables are not assigned in the same time to this optional cumulative constraint

Parameters
 scip SCIP data structure name name of conflict constraint binvars array of binary variables nvars number of variables

Definition at line 1351 of file cons_optcumulative.c.

Referenced by checkRedundancy(), enfopsCons(), and solveCumulative().

## ◆ checkRedundancy()

 static SCIP_RETCODE checkRedundancy ( SCIP * scip, SCIP_CONS * cons, int * ndelconss, SCIP_Bool * redundant )
static

check of the given constraint is redundant

Parameters
 scip SCIP data structure cons optcumulative constraint which collapsed to a cumulative constraint locally ndelconss pointer to store the number of deleted constraints redundant pointer to store if the constraint is redundant

Definition at line 1385 of file cons_optcumulative.c.

Referenced by createConflictCons(), and SCIP_DECL_CONSPROP().

## ◆ solveSubproblem()

 static SCIP_RETCODE solveSubproblem ( SCIP * scip, SCIP_CONS * cons, SCIP_Bool conflictanalysis, SCIP_CONSDATA * consdata, SCIP_VAR ** binvars, SCIP_VAR ** vars, int * durations, int * demands, int nvars, int * nfixedvars, int * nchgbds, int * ndelconss, SCIP_Bool * cutoff )
static

solve the cumulative sub problem

Parameters
 scip SCIP data structure cons optcumulative constraint which collapsed to a cumulative constraint locally conflictanalysis should conflict analysis be called for infeasible subproblems consdata constraint data binvars array of variable representing if the job has to be processed on this machine vars start time variables of the activities which are assigned durations durations of the activities demands demands of the activities nvars number of activities assigned to that machine nfixedvars pointer to store the numbver of fixed variables nchgbds pointer to store the number of changed bounds ndelconss pointer to store the number of deleted constraints cutoff pointer to store if the constraint is violated

Definition at line 1532 of file cons_optcumulative.c.

Referenced by checkRedundancy(), and propagateCons().

## ◆ checkCons()

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

check if the given constrait is valid; checks each starting point of a job whether the remaining capacity is at least zero or not. If not (*violated) is set to TRUE

Parameters
 scip SCIP data structure cons constraint to be checked sol primal solution, or NULL for current LP/pseudo solution violated pointer to store if the constraint is violated printreason should the reason for the violation be printed?

Definition at line 1693 of file cons_optcumulative.c.

Referenced by SCIP_DECL_CONSCHECK(), and solveSubproblem().

## ◆ enfopsCons()

 static SCIP_RETCODE enfopsCons ( SCIP * scip, SCIP_CONS * cons, SCIP_SOL * trysol, SCIP_Bool * violated, SCIP_Bool * consadded, SCIP_Bool * solfeasible )
static

check if the given constrait is valid; checks each starting point of a job whether the remaining capacity is at least zero or not. If not (*violated) is set to TRUE

Parameters
 scip SCIP data structure cons constraint to be checked trysol primal solution to construct, or NULL violated pointer to store if the constraint is violated/infeasible consadded pointer to store if a constraint was added solfeasible pointer to store if the constraint solution is potentially feasible

Definition at line 1748 of file cons_optcumulative.c.

Referenced by checkCons(), SCIP_DECL_CONSENFOLP(), and SCIP_DECL_CONSENFOPS().

## ◆ upgradeCons()

 static SCIP_RETCODE upgradeCons ( SCIP * scip, SCIP_CONS * cons, int * ndelconss, int * nupgdconss, SCIP_Bool * mustpropagate )
static

upgrade constraints to an cumulative constraint

Parameters
 scip SCIP data structure cons constraint to be checked ndelconss pointer to store the number of deleted constraints nupgdconss pointer to store the number of upgrade constraints mustpropagate pointer to store if the constraints has to be propagated

Definition at line 1952 of file cons_optcumulative.c.

Referenced by enfopsCons(), SCIP_DECL_CONSPRESOL(), and SCIP_DECL_CONSPROP().

## ◆ fixIntegerVariable()

 static SCIP_RETCODE fixIntegerVariable ( SCIP * scip, SCIP_VAR * var, SCIP_Bool downlock, SCIP_Bool uplock, int * nchgbds )
static

since the binary variable is fixed to zero, depending in the objective coefficient of the integer variable and the rounding locks, we might can fix the integer variable

Parameters
 scip SCIP data structure var integer variable to fix downlock does the variable has down lock given by the optcumulative constraint uplock does the variable has up lock given by the optcumulative constraint nchgbds pointer to store the number changed variable bounds

Definition at line 2076 of file cons_optcumulative.c.

Referenced by applyZeroFixings(), propagateCons(), and upgradeCons().

## ◆ consdataDeletePos()

 static SCIP_RETCODE consdataDeletePos ( SCIP * scip, SCIP_CONSDATA * consdata, SCIP_CONS * cons, int pos )
static

deletes coefficient at given position from constraint data

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

Definition at line 2149 of file cons_optcumulative.c.

## ◆ applyZeroFixings()

 static SCIP_RETCODE applyZeroFixings ( SCIP * scip, SCIP_CONS * cons, int * nchgcoefs, int * nchgbds )
static

remove all jobs for which the binary variable is globally fixed to zero

Parameters
 scip SCIP data structure cons constraint to be checked nchgcoefs pointer to store the number changed coefficients nchgbds pointer to store the number changed variable bounds

Definition at line 2209 of file cons_optcumulative.c.

Referenced by consdataDeletePos(), SCIP_DECL_CONSPRESOL(), and SCIP_DECL_CONSPROP().

## ◆ removeIrrelevantJobs()

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

remove jobs which have a duration or demand of zero (zero energy) or lay outside the efficient horizon [hmin, hmax); this is done in the SCIP_DECL_CONSINITPRE() callback

Parameters
 scip SCIP data structure cons constraint to propagate

Definition at line 2257 of file cons_optcumulative.c.

Referenced by applyZeroFixings(), and SCIP_DECL_CONSINITPRE().

## ◆ presolveCumulativeCondition()

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

presolve cumulative condition w.r.t. effective horizon by detecting irrelevant variables

Parameters
 scip SCIP data structure cons constraint to be checked nfixedvars pointer to store the number of fixed variables nchgcoefs pointer to store the number of changed coefficients nchgsides pointer to store the number of changed sides cutoff buffer to store whether a cutoff is detected

Definition at line 2318 of file cons_optcumulative.c.

Referenced by removeIrrelevantJobs(), and SCIP_DECL_CONSPRESOL().

## ◆ createSetPackingCons()

 static SCIP_RETCODE createSetPackingCons ( SCIP * scip, SCIP_VAR * var1, SCIP_VAR * var2 )
static

create an an set partitioning constraint

Parameters
 scip SCIP data structure var1 first variable var2 second variable

Definition at line 2403 of file cons_optcumulative.c.

Referenced by detectImplications(), and presolveCumulativeCondition().

## ◆ createVarboundCons()

 static SCIP_RETCODE createVarboundCons ( SCIP * scip, SCIP_VAR * binvar, SCIP_VAR * intvar, int bound, SCIP_Bool lower )
static

create variable bound constraint

Parameters
 scip SCIP data structure binvar binary variable x intvar integer variable y bound variable bound lower variable lower bound? (Otherwise upper bound)

Definition at line 2424 of file cons_optcumulative.c.

Referenced by createSetPackingCons(), and detectImplications().

## ◆ createBounddisjunctionCons()

 static SCIP_RETCODE createBounddisjunctionCons ( SCIP * scip, SCIP_VAR * binvar, SCIP_VAR * intvar, int lb, int ub )
static

create bound disjunction constraint

Parameters
 scip SCIP data structure binvar binary variable x intvar integer variable y lb lower bound ub lower bound

Definition at line 2462 of file cons_optcumulative.c.

Referenced by createVarboundCons(), and detectImplications().

## ◆ detectImplications()

 static SCIP_RETCODE detectImplications ( SCIP * scip, SCIP_CONS * cons, int * nchgcoefs, int * naddconss )
static

detect implication

Parameters
 scip SCIP data structure cons optcumulative constraint nchgcoefs pointer to store the number of changed coefficients naddconss pointer to store the number of added constraints

Definition at line 2508 of file cons_optcumulative.c.

Referenced by createBounddisjunctionCons(), and SCIP_DECL_CONSPRESOL().

## ◆ propagateCons()

 static SCIP_RETCODE propagateCons ( SCIP * scip, SCIP_CONS * cons, SCIP_Bool conflictanalysis, int * nfixedvars, int * nchgbds, int * ndelconss, SCIP_Bool * cutoff )
static

propgates given constraint

Parameters
 scip SCIP data structure cons constraint to be checked conflictanalysis should conflict analysis be called for infeasible subproblems nfixedvars pointer to store the number of fixed variables nchgbds pointer to store the number changed variable bounds ndelconss pointer to store the number of deleted constraints cutoff pointer to store if a cutoff (infeasibility) was detected

Definition at line 2720 of file cons_optcumulative.c.

Referenced by detectImplications(), SCIP_DECL_CONSPRESOL(), and SCIP_DECL_CONSPROP().

## ◆ SCIP_DECL_CONSHDLRCOPY()

 static SCIP_DECL_CONSHDLRCOPY ( conshdlrCopyOptcumulative )
static

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

Definition at line 2989 of file cons_optcumulative.c.

Referenced by propagateCons().

## ◆ SCIP_DECL_CONSFREE()

 static SCIP_DECL_CONSFREE ( consFreeOptcumulative )
static

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

Definition at line 3005 of file cons_optcumulative.c.

Referenced by SCIP_DECL_CONSHDLRCOPY().

## ◆ SCIP_DECL_CONSINITPRE()

 static SCIP_DECL_CONSINITPRE ( consInitpreOptcumulative )
static

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

Definition at line 3030 of file cons_optcumulative.c.

## ◆ SCIP_DECL_CONSEXITSOL()

 static SCIP_DECL_CONSEXITSOL ( consExitsolOptcumulative )
static

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

Definition at line 3071 of file cons_optcumulative.c.

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

## ◆ SCIP_DECL_CONSDELETE()

 static SCIP_DECL_CONSDELETE ( consDeleteOptcumulative )
static

frees specific constraint data

Definition at line 3097 of file cons_optcumulative.c.

Referenced by SCIP_DECL_CONSEXITSOL().

## ◆ SCIP_DECL_CONSTRANS()

 static SCIP_DECL_CONSTRANS ( consTransOptcumulative )
static

transforms constraint data into data belonging to the transformed problem

Definition at line 3126 of file cons_optcumulative.c.

Referenced by SCIP_DECL_CONSDELETE().

## ◆ SCIP_DECL_CONSINITLP()

 static SCIP_DECL_CONSINITLP ( consInitlpOptcumulative )
static

LP initialization method of constraint handler

Definition at line 3174 of file cons_optcumulative.c.

Referenced by SCIP_DECL_CONSTRANS().

## ◆ SCIP_DECL_CONSSEPALP()

 static SCIP_DECL_CONSSEPALP ( consSepalpOptcumulative )
static

separation method of constraint handler for LP solutions

Definition at line 3201 of file cons_optcumulative.c.

Referenced by SCIP_DECL_CONSINITLP().

## ◆ SCIP_DECL_CONSENFOLP()

 static SCIP_DECL_CONSENFOLP ( consEnfolpOptcumulative )
static

constraint enforcing method of constraint handler for LP solutions

Definition at line 3240 of file cons_optcumulative.c.

## ◆ SCIP_DECL_CONSENFOPS()

 static SCIP_DECL_CONSENFOPS ( consEnfopsOptcumulative )
static

constraint enforcing method of constraint handler for pseudo solutions

Definition at line 3311 of file cons_optcumulative.c.

Referenced by SCIP_DECL_CONSENFOLP().

## ◆ SCIP_DECL_CONSCHECK()

 static SCIP_DECL_CONSCHECK ( consCheckOptcumulative )
static

feasibility check method of constraint handler for integral solutions

Definition at line 3367 of file cons_optcumulative.c.

Referenced by SCIP_DECL_CONSENFOPS().

## ◆ SCIP_DECL_CONSPROP()

 static SCIP_DECL_CONSPROP ( consPropOptcumulative )
static

domain propagation method of constraint handler

Definition at line 3395 of file cons_optcumulative.c.

Referenced by SCIP_DECL_CONSCHECK().

## ◆ SCIP_DECL_CONSPRESOL()

 static SCIP_DECL_CONSPRESOL ( consPresolOptcumulative )
static

presolving method of constraint handler

Definition at line 3494 of file cons_optcumulative.c.

Referenced by SCIP_DECL_CONSPROP().

## ◆ SCIP_DECL_CONSRESPROP()

 static SCIP_DECL_CONSRESPROP ( consRespropOptcumulative )
static

propagation conflict resolving method of constraint handler

Definition at line 3664 of file cons_optcumulative.c.

Referenced by SCIP_DECL_CONSPRESOL().

## ◆ SCIP_DECL_CONSLOCK()

 static SCIP_DECL_CONSLOCK ( consLockOptcumulative )
static

variable rounding lock method of constraint handler

Definition at line 3776 of file cons_optcumulative.c.

References NULL, SCIP_CALL, SCIP_LOCKTYPE_MODEL, SCIP_OKAY, SCIPaddVarLocksType(), and SCIPconsGetData().

Referenced by SCIP_DECL_CONSRESPROP().

## ◆ SCIP_DECL_CONSPRINT()

 static SCIP_DECL_CONSPRINT ( consPrintOptcumulative )
static

constraint display method of constraint handler

Definition at line 3837 of file cons_optcumulative.c.

References consdataPrint(), NULL, SCIP_CALL, SCIP_DECL_CONSCOPY(), SCIP_OKAY, and SCIPconsGetData().

## ◆ SCIP_DECL_CONSCOPY()

 static SCIP_DECL_CONSCOPY ( consCopyOptcumulative )
static

constraint copying method of constraint handler

Definition at line 3850 of file cons_optcumulative.c.

Referenced by SCIP_DECL_CONSPRINT().

## ◆ SCIP_DECL_CONSPARSE()

 static SCIP_DECL_CONSPARSE ( consParseOptcumulative )
static

constraint parsing method of constraint handler

Definition at line 3913 of file cons_optcumulative.c.

Referenced by SCIP_DECL_CONSCOPY().

## ◆ SCIP_DECL_EVENTEXEC() [1/2]

 static SCIP_DECL_EVENTEXEC ( eventExecOptcumulativeBinvars )
static

Definition at line 4022 of file cons_optcumulative.c.

Referenced by SCIP_DECL_CONSPARSE().

## ◆ SCIP_DECL_EVENTEXEC() [2/2]

 static SCIP_DECL_EVENTEXEC ( eventExecOptcumulativeIntvars )
static

Definition at line 4071 of file cons_optcumulative.c.

## ◆ SCIPincludeConshdlrOptcumulative()

 SCIP_RETCODE SCIPincludeConshdlrOptcumulative ( SCIP * scip )

## ◆ SCIPcreateConsOptcumulative()

 SCIP_RETCODE SCIPcreateConsOptcumulative ( SCIP * scip, SCIP_CONS ** cons, const char * name, int nvars, SCIP_VAR ** vars, SCIP_VAR ** binvars, int * durations, int * demands, int 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 optcumulative constraint

Parameters
 scip SCIP data structure cons pointer to hold the created constraint name name of constraint nvars number of variables (jobs) vars array of integer variable which corresponds to starting times for a job binvars array of variable representing if the job has to be processed on this machine durations array containing corresponding durations demands array containing corresponding demands capacity available cumulative capacity 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 seperated 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 4175 of file cons_optcumulative.c.

## ◆ SCIPsetHminOptcumulative()

 SCIP_RETCODE SCIPsetHminOptcumulative ( SCIP * scip, SCIP_CONS * cons, int hmin )

set the left bound of the time axis to be considered (including hmin)

Parameters
 scip SCIP data structure cons constraint data hmin left bound of time axis to be considered

Definition at line 4254 of file cons_optcumulative.c.

Referenced by SCIP_DECL_CONSPARSE(), and SCIPcreateConsOptcumulative().

## ◆ SCIPgetHminOptcumulative()

 int SCIPgetHminOptcumulative ( SCIP * scip, SCIP_CONS * cons )

returns the left bound of the time axis to be considered

Parameters
 scip SCIP data structure cons constraint

Definition at line 4278 of file cons_optcumulative.c.

Referenced by SCIPsetHminOptcumulative().

## ◆ SCIPsetHmaxOptcumulative()

 SCIP_RETCODE SCIPsetHmaxOptcumulative ( SCIP * scip, SCIP_CONS * cons, int hmax )

set the right bound of the time axis to be considered (not including hmax)

Parameters
 scip SCIP data structure cons constraint data hmax right bound of time axis to be considered

Definition at line 4298 of file cons_optcumulative.c.

Referenced by SCIP_DECL_CONSPARSE(), and SCIPgetHminOptcumulative().

## ◆ SCIPgetHmaxOptcumulative()

 int SCIPgetHmaxOptcumulative ( SCIP * scip, SCIP_CONS * cons )

returns the right bound of the time axis to be considered

Parameters
 scip SCIP data structure cons constraint

Definition at line 4321 of file cons_optcumulative.c.

Referenced by SCIPsetHmaxOptcumulative().