76#define CONSHDLR_NAME "cardinality"
77#define CONSHDLR_DESC "cardinality constraint handler"
78#define CONSHDLR_SEPAPRIORITY 10
79#define CONSHDLR_ENFOPRIORITY 100
80#define CONSHDLR_CHECKPRIORITY -10
81#define CONSHDLR_SEPAFREQ 10
82#define CONSHDLR_PROPFREQ 1
83#define CONSHDLR_EAGERFREQ 100
85#define CONSHDLR_MAXPREROUNDS -1
87#define CONSHDLR_DELAYSEPA FALSE
88#define CONSHDLR_DELAYPROP FALSE
89#define CONSHDLR_NEEDSCONS TRUE
91#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP
92#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_FAST
95#define DEFAULT_BRANCHBALANCED FALSE
96#define DEFAULT_BALANCEDDEPTH 20
97#define DEFAULT_BALANCEDCUTOFF 2.0
101#define EVENTHDLR_NAME "cardinality"
102#define EVENTHDLR_DESC "bound change event handler for cardinality constraints"
104#define EVENTHDLR_EVENT_TYPE (SCIP_EVENTTYPE_BOUNDCHANGED | SCIP_EVENTTYPE_GBDCHANGED)
118 int neventdatascurrent;
129struct SCIP_ConshdlrData
132 SCIP_Bool branchbalanced;
134 SCIP_Real balancedcutoff;
146 unsigned int varmarked:1;
147 unsigned int indvarmarked:1;
171 (*eventdata)->consdata = consdata;
172 (*eventdata)->var =
var;
173 (*eventdata)->indvar = indvar;
174 (*eventdata)->varmarked =
FALSE;
175 (*eventdata)->indvarmarked =
FALSE;
176 (*eventdata)->pos = (
unsigned int)pos;
222 SCIP_Bool* infeasible
246 SCIP_CALL(
SCIPcreateConsLinear(
scip, &cons,
"branch", 1, &
var, &val, 0.0, 0.0,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
280 SCIP_Bool* infeasible,
312 for(
i = 0;
i < naggrvars; ++
i )
325 for(
i = 0;
i < naggrvars; ++
i )
331 *tightened = *tightened ||
fixed;
396 assert(consdata->nvars <= consdata->maxvars);
398 if( num > consdata->maxvars )
439 SCIP_Bool transformed,
457 assert(consdata->ntreatnonzeros >= 0 );
459 ++consdata->ntreatnonzeros;
499 SCIP_Bool transformed;
509 if( consdata->weights ==
NULL && consdata->maxvars > 0 )
511 SCIPerrorMessage(
"cannot add variable to cardinality constraint <%s> that does not contain weights.\n",
519 if( conshdlrdata->varhash ==
NULL )
576 assert(consdata->maxvars >= consdata->nvars+1);
579 for( pos = consdata->nvars; pos >= 1; --pos )
582 if( consdata->weights[pos-1] > weight )
584 consdata->vars[pos] = consdata->vars[pos-1];
585 consdata->indvars[pos] = consdata->indvars[pos-1];
586 consdata->eventdatas[pos] = consdata->eventdatas[pos-1];
587 consdata->weights[pos] = consdata->weights[pos-1];
589 if( consdata->eventdatas[pos] !=
NULL )
591 consdata->eventdatas[pos]->pos = (
unsigned int)pos;
604 consdata->vars[pos] =
var;
605 consdata->indvars[pos] = indvar;
606 consdata->eventdatas[pos] = eventdata;
607 consdata->weights[pos] = weight;
626 SCIP_Bool transformed;
638 if( conshdlrdata->varhash ==
NULL )
701 consdata->vars[consdata->nvars] =
var;
702 consdata->indvars[consdata->nvars] = indvar;
703 consdata->eventdatas[consdata->nvars] = eventdata;
705 if( consdata->weights !=
NULL && consdata->nvars > 0 )
706 consdata->weights[consdata->nvars] = consdata->weights[consdata->nvars-1] + 1.0;
709 assert(consdata->weights !=
NULL || consdata->nvars > 0);
733 &consdata->eventdatas[pos]) );
737 --(consdata->ntreatnonzeros);
740 for(
j = pos;
j < consdata->nvars-1; ++
j )
742 consdata->vars[
j] = consdata->vars[
j+1];
743 consdata->indvars[
j] = consdata->indvars[
j+1];
744 consdata->eventdatas[
j] = consdata->eventdatas[
j+1];
745 if( consdata->weights !=
NULL )
746 consdata->weights[
j] = consdata->weights[
j+1];
748 consdata->eventdatas[
j]->pos = (
unsigned int)
j;
772 for(
c = 0;
c < nconss; ++
c )
782 nvars = consdata->nvars;
783 vars = consdata->vars;
784 indvars = consdata->indvars;
812 eventdatas = consdata->eventdatas;
813 nvars = consdata->nvars;
820 eventdata = eventdatas[
j];
821 eventdata->varmarked =
FALSE;
822 eventdata->indvarmarked =
FALSE;
854 SCIP_Bool infeasible;
875 consdata->neventdatascurrent = 0;
880 vars = consdata->vars;
881 indvars = consdata->indvars;
914 &consdata->eventdatas[
j]) );
916 &consdata->eventdatas[
j]) );
924 consdata->eventdatas[
j]->var =
var;
931 for(
l =
j+1;
l < consdata->nvars; ++
l )
991 SCIPdebugMsg(
scip,
"deleting variable <%s> from constraint <%s>, since it may be treated as nonzero.\n",
993 --(consdata->cardval);
1031 if( consdata->cardval < 0 )
1033 SCIPdebugMsg(
scip,
"The problem is infeasible: more variables have bounds that keep them from being 0 than allowed.\n");
1039 else if( consdata->cardval == 0 )
1042 for(
j = 0;
j < consdata->nvars; ++
j )
1059 if( consdata->nvars <= consdata->cardval )
1061 SCIPdebugMsg(
scip,
"Deleting cardinality constraint <%s> with <%d> variables and cardinality value <%d>.\n",
1080 for(
j = 0;
j < consdata->nvars; ++
j )
1142 if( consdata->ntreatnonzeros > consdata->cardval )
1144 SCIPdebugMsg(
scip,
"the node is infeasible, more than %d variables are fixed to be nonzero.\n", consdata->cardval);
1152 if( consdata->ntreatnonzeros == consdata->cardval )
1156 SCIP_Bool infeasible;
1157 SCIP_Bool tightened;
1165 nvars = consdata->nvars;
1166 vars = consdata->vars;
1167 indvars = consdata->indvars;
1195 SCIPdebugMsg(
scip,
"the node is infeasible, more than %d variables are fixed to be nonzero.\n",
1205 SCIPdebugMsg(
scip,
"fixed variable <%s> to 0, since constraint <%s> with cardinality value %d is \
1214 assert(cnt == consdata->ntreatnonzeros);
1233 if( consdata->neventdatascurrent > 0 )
1242 eventdatas = consdata->eventdatascurrent;
1248 SCIP_Bool infeasible;
1249 SCIP_Bool tightened;
1252 eventdata = eventdatas[
j];
1257 assert(
var == eventdata->var ||
var == eventdata->indvar);
1261 if( eventdata->indvar ==
var )
1263 assert(eventdata->indvarmarked);
1280 SCIPdebugMsg(
scip,
"the node is infeasible, indicator variable %s is fixed to zero although implied "
1290 SCIPdebugMsg(
scip,
"fixed variable <%s> to 0, since indicator variable %s is 0.\n",
1296 eventdata->indvarmarked =
FALSE;
1302 assert(eventdata->varmarked);
1309 indvar = eventdata->indvar;
1318 SCIPdebugMsg(
scip,
"the node is infeasible, implied variable %s is fixed to nonzero "
1326 SCIPdebugMsg(
scip,
"fixed variable <%s> to 1.0, since implied variable %s is nonzero.\n",
1331 eventdata->varmarked =
FALSE;
1335 consdata->neventdatascurrent = 0;
1354 SCIP_Bool infeasible;
1364 SCIPdebugMsg(
scip,
"apply unbalanced branching on variable <%s> of constraint <%s>.\n",
1457 SCIP_Real balancedcutoff
1481 SCIPerrorMessage(
"balanced branching is only possible if separation frequency of constraint handler is 1.\n");
1541 for(
j = 0;
j <=
ind; ++
j )
1606 SCIP_Bool infeasible;
1614 for(
j = 0;
j <=
ind; ++
j )
1624 for(
j = 0;
j <=
ind; ++
j )
1649 SCIP_Bool infeasible;
1745 SCIP_Real maxweight;
1751 SCIP_Bool branchbalanced =
FALSE;
1776 for(
c = 0;
c < nconss; ++
c )
1799 nvars = consdata->nvars;
1800 vars = consdata->vars;
1801 indvars = consdata->indvars;
1802 cardval = consdata->cardval;
1811 SCIPdebugMsg(
scip,
"propagating <%s> in enforcing (cutoff: %u, domain reductions: %d).\n",
1886 SCIPdebugMsg(
scip,
"Detected cut off: constraint <%s> has %d many variables that can be treated as nonzero, \
1892 else if( cnt > 0 &&
nnonzero + 1 > cardval )
1894 SCIP_Bool infeasible;
1897 for( v = 0; v <
nvars; ++v )
1920 if( cnt > cardval -
nnonzero && weight > maxweight )
1952 nvars = consdata->nvars;
1953 vars = consdata->vars;
1954 indvars = consdata->indvars;
1955 cardval = consdata->cardval;
1960 && (conshdlrdata->balanceddepth == -1 ||
SCIPgetDepth(
scip) <= conshdlrdata->balanceddepth)
1963 branchbalanced =
TRUE;
1967 if( branchbalanced )
1969 SCIP_CALL(
branchBalancedCardinality(
scip, conshdlr,
sol,
branchcons,
vars, indvars,
nvars, cardval,
branchnnonzero,
branchpos,
1970 conshdlrdata->balancedcutoff) );
2029 nvars = consdata->nvars;
2039 cardval = consdata->cardval;
2057 vars[cnt] = consdata->vars[
j];
2058 vals[cnt++] = 1.0/val;
2081 cardval = consdata->cardval;
2099 vars[cnt] = consdata->vars[
j];
2100 vals[cnt++] = 1.0/val;
2147 for(
c = nconss-1;
c >= 0; --
c )
2173 if( consdata->rowub ==
NULL || consdata->rowlb ==
NULL )
2176 (consdata->rowlb ==
NULL) ? &consdata->rowlb :
NULL,
2177 (consdata->rowub ==
NULL) ? &consdata->rowub :
NULL) );
2179 rowub = consdata->rowub;
2180 rowlb = consdata->rowlb;
2317 if( conshdlrdata->varhash !=
NULL )
2342 for(
c = 0;
c < nconss; ++
c )
2354 if( consdata->rowub !=
NULL )
2358 if( consdata->rowlb !=
NULL )
2365 if( conshdlrdata->varhash !=
NULL )
2396 for(
j = 0;
j < (*consdata)->nvars; ++
j )
2399 (*consdata)->indvars[
j], &(*consdata)->eventdatas[
j]) );
2404 if( (*consdata)->weights !=
NULL )
2415 if( (*consdata)->rowub !=
NULL )
2419 if( (*consdata)->rowlb !=
NULL )
2463 consdata->cons =
NULL;
2467 consdata->rowub =
NULL;
2468 consdata->rowlb =
NULL;
2469 consdata->eventdatascurrent =
NULL;
2470 consdata->neventdatascurrent = 0;
2471 consdata->ntreatnonzeros = 0;
2484 consdata->weights =
NULL;
2495 ++(consdata->ntreatnonzeros);
2511 for(
j = 0;
j < consdata->nvars; ++
j )
2514 consdata->vars[
j], consdata->indvars[
j],
j, &consdata->eventdatas[
j]) );
2519 if(
SCIPisGT(
scip, (SCIP_Real)consdata->ntreatnonzeros, consdata->cardval) )
2521 SCIPdebugMsg(
scip,
"constraint <%s> has %d variables fixed to be nonzero, allthough the constraint allows \
2564 for(
c = 0;
c < nconss; ++
c )
2577 assert(consdata->nvars >= 0);
2578 assert(consdata->nvars <= consdata->maxvars);
2710 for(
c = 0;
c < nconss; ++
c )
2721 cardval = consdata->cardval;
2725 for(
j = 0;
j < consdata->nvars; ++
j )
2745 for(
l = 0;
l < consdata->nvars; ++
l )
2785 for(
c = 0;
c < nconss; ++
c )
2845 vars = consdata->vars;
2846 indvars = consdata->indvars;
2847 nvars = consdata->nvars;
2855 indvar = indvars[
j];
2891 for(
j = 0;
j < consdata->nvars; ++
j )
2896 if( consdata->weights ==
NULL )
2917 const char* consname;
2974 targetweights, initial, separate, enforce, check,
propagate, local, dynamic, removable, stickingatnode) );
3005 SCIP_CALL(
SCIPcreateConsCardinality(
scip, cons, name, 0,
NULL, 0,
NULL,
NULL, initial, separate, enforce, check,
propagate, local, dynamic, removable, stickingatnode) );
3077 if( *
success && *s ==
'<' && *(s+1) ==
'=' )
3084 cardval = (int)
strtod(s, &t);
3088 SCIPerrorMessage(
"Syntax error during parsing of the cardinality restriction value: %s\n", s);
3132 (*nvars) = consdata->nvars;
3159 consdata = eventdata->consdata;
3161 assert(0 <= consdata->ntreatnonzeros && consdata->ntreatnonzeros <= consdata->nvars);
3172 if( ( eventdata->varmarked &&
var == eventdata->var) || ( eventdata->indvarmarked &&
var == eventdata->indvar) )
3176 for(
i = 0;
i < consdata->neventdatascurrent; ++
i )
3178 if(
var == consdata->eventvarscurrent[
i] )
3214 if(
var == eventdata->indvar )
3220 ++(consdata->ntreatnonzeros);
3222 --(consdata->ntreatnonzeros);
3225 assert(oldbound == 1.0 && newbound == 0.0 );
3228 consdata->eventdatascurrent[consdata->neventdatascurrent] = eventdata;
3229 consdata->eventvarscurrent[consdata->neventdatascurrent] =
var;
3230 ++consdata->neventdatascurrent;
3231 eventdata->indvarmarked =
TRUE;
3232 assert(consdata->neventdatascurrent <= 4 * consdata->maxvars);
3235 assert(0 <= consdata->ntreatnonzeros && consdata->ntreatnonzeros <= consdata->nvars);
3240 if(
var == eventdata->var && ! eventdata->varmarked )
3248 consdata->eventdatascurrent[consdata->neventdatascurrent] = eventdata;
3249 consdata->eventvarscurrent[consdata->neventdatascurrent] =
var;
3250 ++consdata->neventdatascurrent;
3251 eventdata->varmarked =
TRUE;
3252 assert(consdata->neventdatascurrent <= 4 * consdata->maxvars );
3262 consdata->eventdatascurrent[consdata->neventdatascurrent] = eventdata;
3263 consdata->eventvarscurrent[consdata->neventdatascurrent] =
var;
3264 ++consdata->neventdatascurrent;
3265 eventdata->varmarked =
TRUE;
3266 assert(consdata->neventdatascurrent <= 4 * consdata->maxvars );
3271 assert(0 <= consdata->ntreatnonzeros && consdata->ntreatnonzeros <= consdata->nvars);
3273 SCIPdebugMsg(
scip,
"event exec cons <%s>: changed bound of variable <%s> from %f to %f (ntreatnonzeros: %d).\n",
3275 oldbound, newbound, consdata->ntreatnonzeros);
3292 conshdlrdata->eventhdlr =
NULL;
3293 conshdlrdata->varhash =
NULL;
3298 if( conshdlrdata->eventhdlr ==
NULL )
3300 SCIPerrorMessage(
"event handler for cardinality constraints not found.\n");
3331 "whether to use balanced instead of unbalanced branching",
3335 "maximum depth for using balanced branching (-1: no limit)",
3339 "determines that balanced branching is only used if the branching cut off value "
3340 "w.r.t. the current LP solution is greater than a given value",
3381 SCIP_Bool removable,
3383 SCIP_Bool stickingatnode
3391 SCIP_Bool modifiable;
3392 SCIP_Bool transformed;
3399 if( conshdlr ==
NULL )
3414 consdata->cons =
NULL;
3415 consdata->vars =
NULL;
3416 consdata->indvars =
NULL;
3417 consdata->eventdatas =
NULL;
3418 consdata->nvars =
nvars;
3419 consdata->cardval = cardval;
3420 consdata->maxvars =
nvars;
3421 consdata->rowub =
NULL;
3422 consdata->rowlb =
NULL;
3423 consdata->eventdatascurrent =
NULL;
3424 consdata->eventvarscurrent =
NULL;
3425 consdata->neventdatascurrent = 0;
3426 consdata->ntreatnonzeros = transformed ? 0 : -1;
3427 consdata->weights =
NULL;
3435 if( indvars !=
NULL )
3441 if( conshdlrdata->varhash ==
NULL )
3448 for( v = 0; v <
nvars; ++v )
3465 consdata->indvars[v] =
implvar;
3475 consdata->indvars[v] =
var;
3493 if( weights !=
NULL )
3503 for( v = 0; v <
nvars; ++v )
3518 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
3519 local, modifiable, dynamic, removable, stickingatnode) );
3521 consdata->cons = *cons;
3525 for( v =
nvars - 1; v >= 0; --v )
3540 consdata->indvars[v], v, transformed, &consdata->eventdatas[v]) );
3541 assert(! transformed || consdata->eventdatas[v] !=
NULL);
3568 SCIP_CALL(
SCIPcreateConsCardinality(
scip, cons, name,
nvars,
vars, cardval, indvars, weights,
TRUE,
TRUE,
TRUE,
TRUE,
3595 SCIPdebugMsg(
scip,
"modify right hand side of cardinality constraint from <%i> to <%i>\n", consdata->cardval, cardval);
3598 consdata->cardval = cardval;
3696 return consdata->nvars;
3720 return consdata->vars;
3743 return consdata->cardval;
3767 return consdata->weights;
static SCIP_RETCODE unlockVariableCardinality(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_VAR *indvar)
#define CONSHDLR_NEEDSCONS
#define CONSHDLR_SEPAFREQ
#define CONSHDLR_CHECKPRIORITY
#define CONSHDLR_PROP_TIMING
static SCIP_RETCODE consdataEnsurevarsSizeCardinality(SCIP *scip, SCIP_CONSDATA *consdata, int num, SCIP_Bool reserveweights)
#define CONSHDLR_MAXPREROUNDS
static SCIP_RETCODE lockVariableCardinality(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_VAR *indvar)
#define CONSHDLR_SEPAPRIORITY
static SCIP_RETCODE appendVarCardinality(SCIP *scip, SCIP_CONS *cons, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_VAR *var, SCIP_VAR *indvar)
static void consdataUnmarkEventdataVars(SCIP_CONSDATA *consdata)
static SCIP_RETCODE fixVariableZeroNode(SCIP *scip, SCIP_VAR *var, SCIP_NODE *node, SCIP_Bool *infeasible)
static SCIP_RETCODE generateRowCardinality(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_Bool local, SCIP_ROW **rowlb, SCIP_ROW **rowub)
static SCIP_RETCODE deleteVarCardinality(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr, int pos)
static SCIP_RETCODE fixVariableZero(SCIP *scip, SCIP_VAR *var, SCIP_Bool *infeasible, SCIP_Bool *tightened)
static SCIP_RETCODE polishPrimalSolution(SCIP *scip, SCIP_CONS **conss, int nconss, SCIP_SOL *sol, SCIP_SOL *primsol)
static SCIP_RETCODE branchBalancedCardinality(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_SOL *sol, SCIP_CONS *branchcons, SCIP_VAR **vars, SCIP_VAR **indvars, int nvars, int cardval, int branchnnonzero, int branchpos, SCIP_Real balancedcutoff)
#define DEFAULT_BALANCEDDEPTH
static SCIP_RETCODE initsepaBoundInequalityFromCardinality(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_SOL *sol, SCIP_Bool solvedinitlp, int *ngen, SCIP_Bool *cutoff)
#define DEFAULT_BALANCEDCUTOFF
#define CONSHDLR_PROPFREQ
static SCIP_RETCODE enforceCardinality(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_SOL *sol, int nconss, SCIP_CONS **conss, SCIP_RESULT *result)
static SCIP_RETCODE presolRoundCardinality(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool *cutoff, SCIP_Bool *success, int *ndelconss, int *nupgdconss, int *nfixedvars, int *nremovedvars)
#define CONSHDLR_PRESOLTIMING
#define DEFAULT_BRANCHBALANCED
static SCIP_RETCODE catchVarEventCardinality(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_CONSDATA *consdata, SCIP_VAR *var, SCIP_VAR *indvar, int pos, SCIP_EVENTDATA **eventdata)
static SCIP_RETCODE addVarCardinality(SCIP *scip, SCIP_CONS *cons, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_VAR *var, SCIP_VAR *indvar, SCIP_Real weight)
#define CONSHDLR_EAGERFREQ
static SCIP_RETCODE separateCardinality(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_SOL *sol, int nconss, SCIP_CONS **conss, SCIP_RESULT *result)
static SCIP_RETCODE handleNewVariableCardinality(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_VAR *var, SCIP_VAR *indvar, int pos, SCIP_Bool transformed, SCIP_EVENTDATA **eventdata)
#define EVENTHDLR_EVENT_TYPE
static SCIP_RETCODE propCardinality(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_Bool *cutoff, int *nchgdomain)
#define CONSHDLR_ENFOPRIORITY
#define CONSHDLR_DELAYSEPA
static SCIP_RETCODE dropVarEventCardinality(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_CONSDATA *consdata, SCIP_VAR *var, SCIP_VAR *indvar, SCIP_EVENTDATA **eventdata)
static SCIP_RETCODE branchUnbalancedCardinality(SCIP *scip, SCIP_SOL *sol, SCIP_CONS *branchcons, SCIP_VAR **vars, SCIP_VAR **indvars, int nvars, int cardval, int branchnnonzero, int branchpos)
#define CONSHDLR_DELAYPROP
constraint handler for cardinality constraints
Constraint handler for knapsack constraints of the form , x binary and .
Constraint handler for linear constraints in their most general form, .
SCIP_Real * SCIPgetWeightsCardinality(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsCardinality(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, int cardval, SCIP_VAR **indvars, SCIP_Real *weights, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_RETCODE SCIPcreateConsBasicCardinality(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, int cardval, SCIP_VAR **indvars, SCIP_Real *weights)
int SCIPgetCardvalCardinality(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPappendVarCardinality(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_VAR *indvar)
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 SCIPaddVarCardinality(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_VAR *indvar, SCIP_Real weight)
int SCIPgetNVarsCardinality(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsLinear(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)
SCIP_VAR ** SCIPgetVarsCardinality(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPchgCardvalCardinality(SCIP *scip, SCIP_CONS *cons, int cardval)
SCIP_RETCODE SCIPincludeConshdlrCardinality(SCIP *scip)
SCIP_RETCODE SCIPgetVarCopy(SCIP *sourcescip, SCIP *targetscip, SCIP_VAR *sourcevar, SCIP_VAR **targetvar, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool *success)
SCIP_Bool SCIPisTransformed(SCIP *scip)
SCIP_Bool SCIPisStopped(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)
int SCIPgetNTotalVars(SCIP *scip)
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPhashmapInsert(SCIP_HASHMAP *hashmap, void *origin, void *image)
SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)
SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPdelConsLocal(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPaddConsNode(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode)
SCIP_Real SCIPgetLocalTransEstimate(SCIP *scip)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
SCIP_RETCODE SCIPaddIntParam(SCIP *scip, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPaddRealParam(SCIP *scip, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPaddBoolParam(SCIP *scip, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_Real SCIPcalcNodeselPriority(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR branchdir, SCIP_Real targetvalue)
SCIP_Real SCIPcalcChildEstimate(SCIP *scip, SCIP_VAR *var, SCIP_Real targetvalue)
SCIP_Real SCIPcalcChildEstimateIncrease(SCIP *scip, SCIP_VAR *var, SCIP_Real varsol, SCIP_Real targetvalue)
SCIP_RETCODE SCIPcreateChild(SCIP *scip, SCIP_NODE **node, SCIP_Real nodeselprio, SCIP_Real estimate)
SCIP_RETCODE SCIPsetConshdlrFree(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrPresol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)
SCIP_RETCODE SCIPsetConshdlrSepa(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), int sepafreq, int sepapriority, SCIP_Bool delaysepa)
SCIP_RETCODE SCIPsetConshdlrProp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPROP((*consprop)), int propfreq, SCIP_Bool delayprop, SCIP_PROPTIMING proptiming)
SCIP_RETCODE SCIPsetConshdlrEnforelax(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPincludeConshdlrBasic(SCIP *scip, SCIP_CONSHDLR **conshdlrptr, const char *name, const char *desc, int enfopriority, int chckpriority, int eagerfreq, SCIP_Bool needscons, SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_CONSHDLRDATA *conshdlrdata)
SCIP_RETCODE SCIPsetConshdlrParse(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrGetVars(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrPrint(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrCopy(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)),)
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
SCIP_RETCODE SCIPsetConshdlrDelete(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONSHDLRDATA * SCIPconshdlrGetData(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetSepaFreq(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrTrans(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrExitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrInitlp(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrGetNVars(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONSDATA * SCIPconsGetData(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)
SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)
SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)
SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsTransformed(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateCons(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_CONSHDLR *conshdlr, SCIP_CONSDATA *consdata, 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_Bool SCIPconsIsPropagated(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsLocal(SCIP_CONS *cons)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_RETCODE SCIPresetConsAge(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)
SCIP_Bool SCIPisCutEfficacious(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)
SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
const char * SCIPeventhdlrGetName(SCIP_EVENTHDLR *eventhdlr)
SCIP_EVENTTYPE SCIPeventGetType(SCIP_EVENT *event)
SCIP_RETCODE SCIPcatchVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
SCIP_RETCODE SCIPdropVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
SCIP_Real SCIPeventGetOldbound(SCIP_EVENT *event)
SCIP_VAR * SCIPeventGetVar(SCIP_EVENT *event)
SCIP_Real SCIPeventGetNewbound(SCIP_EVENT *event)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
int SCIPcalcMemGrowSize(SCIP *scip, int num)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPduplicateBufferArray(scip, ptr, source, num)
#define SCIPallocBlockMemoryArray(scip, ptr, num)
#define SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)
SCIP_Real SCIProwGetLhs(SCIP_ROW *row)
SCIP_Real SCIProwGetRhs(SCIP_ROW *row)
SCIP_RETCODE SCIPcreateEmptyRowCons(SCIP *scip, SCIP_ROW **row, SCIP_CONS *cons, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)
SCIP_RETCODE SCIPaddVarsToRow(SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
SCIP_RETCODE SCIPcreateSolCopy(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol)
void SCIPupdateSolConsViolation(SCIP *scip, SCIP_SOL *sol, SCIP_Real absviol, SCIP_Real relviol)
SCIP_RETCODE SCIPtrySol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *stored)
SCIP_RETCODE SCIPsetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real val)
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
SCIP_Longint SCIPgetNNodes(SCIP *scip)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfloor(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasNegative(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasPositive(SCIP *scip, SCIP_Real val)
int SCIPgetDepth(SCIP *scip)
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
SCIP_Real SCIPvarGetMultaggrConstant(SCIP_VAR *var)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_RETCODE SCIPchgVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)
SCIP_RETCODE SCIPchgVarUbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPparseVarName(SCIP *scip, const char *str, SCIP_VAR **var, char **endptr)
SCIP_RETCODE SCIPgetProbvarSum(SCIP *scip, SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPaddVarLocksType(SCIP *scip, SCIP_VAR *var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)
SCIP_RETCODE SCIPunlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_RETCODE SCIPflattenVarAggregationGraph(SCIP *scip, SCIP_VAR *var)
SCIP_VAR ** SCIPvarGetMultaggrVars(SCIP_VAR *var)
int SCIPvarGetMultaggrNVars(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_RETCODE SCIPcreateVar(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPmarkDoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
SCIP_RETCODE SCIPchgVarLbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPwriteVarName(SCIP *scip, FILE *file, SCIP_VAR *var, SCIP_Bool type)
SCIP_RETCODE SCIPgetTransformedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
SCIP_Real * SCIPvarGetMultaggrScalars(SCIP_VAR *var)
void SCIPsortRealPtrPtrInt(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIP_RETCODE SCIPskipSpace(char **s)
SCIPfreeSol(scip, &heurdata->sol))
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Bool propagate
memory allocation routines
#define BMScopyMemoryArray(ptr, source, num)
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
public methods for managing constraints
public methods for managing events
public methods for LP management
public methods for message output
public data structures and miscellaneous methods
methods for sorting joint arrays of various types
public methods for problem variables
public methods for branching rule plugins and branching
public methods for constraint handler plugins and constraints
public methods for problem copies
public methods for cuts and aggregation rows
public methods for event handler plugins and event handlers
public methods for the LP relaxation, rows and columns
public methods for memory management
public methods for message handling
public methods for numerical tolerances
public methods for SCIP parameter handling
public methods for global and local (sub)problems
public methods for solutions
public methods for querying solving statistics
public methods for the branch-and-bound tree
public methods for SCIP variables
#define SCIP_DECL_CONSENFOLP(x)
#define SCIP_DECL_CONSDELETE(x)
#define SCIP_DECL_CONSGETVARS(x)
#define SCIP_DECL_CONSPRINT(x)
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
#define SCIP_DECL_CONSSEPALP(x)
#define SCIP_DECL_CONSENFORELAX(x)
#define SCIP_DECL_CONSPROP(x)
#define SCIP_DECL_CONSGETNVARS(x)
#define SCIP_DECL_CONSENFOPS(x)
#define SCIP_DECL_CONSPARSE(x)
#define SCIP_DECL_CONSTRANS(x)
#define SCIP_DECL_CONSPRESOL(x)
#define SCIP_DECL_CONSINITLP(x)
#define SCIP_DECL_CONSLOCK(x)
#define SCIP_DECL_CONSCOPY(x)
struct SCIP_ConsData SCIP_CONSDATA
#define SCIP_DECL_CONSCHECK(x)
#define SCIP_DECL_CONSHDLRCOPY(x)
#define SCIP_DECL_CONSEXITSOL(x)
#define SCIP_DECL_CONSFREE(x)
#define SCIP_DECL_CONSSEPASOL(x)
#define SCIP_EVENTTYPE_BOUNDCHANGED
#define SCIP_EVENTTYPE_GUBCHANGED
#define SCIP_EVENTTYPE_GBDCHANGED
struct SCIP_EventData SCIP_EVENTDATA
#define SCIP_EVENTTYPE_UBTIGHTENED
#define SCIP_DECL_EVENTEXEC(x)
#define SCIP_EVENTTYPE_LBRELAXED
#define SCIP_EVENTTYPE_GLBCHANGED
#define SCIP_EVENTTYPE_LBTIGHTENED
@ SCIP_BRANCHDIR_DOWNWARDS
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_VARSTATUS_MULTAGGR