80#define CONSHDLR_NAME "cardinality"
81#define CONSHDLR_DESC "cardinality constraint handler"
82#define CONSHDLR_SEPAPRIORITY 10
83#define CONSHDLR_ENFOPRIORITY 100
84#define CONSHDLR_CHECKPRIORITY -10
85#define CONSHDLR_SEPAFREQ 10
86#define CONSHDLR_PROPFREQ 1
87#define CONSHDLR_EAGERFREQ 100
89#define CONSHDLR_MAXPREROUNDS -1
91#define CONSHDLR_DELAYSEPA FALSE
92#define CONSHDLR_DELAYPROP FALSE
93#define CONSHDLR_NEEDSCONS TRUE
95#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP
96#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_FAST
99#define DEFAULT_BRANCHBALANCED FALSE
100#define DEFAULT_BALANCEDDEPTH 20
101#define DEFAULT_BALANCEDCUTOFF 2.0
105#define EVENTHDLR_NAME "cardinality"
106#define EVENTHDLR_DESC "bound change event handler for cardinality constraints"
108#define EVENTHDLR_EVENT_TYPE (SCIP_EVENTTYPE_BOUNDCHANGED | SCIP_EVENTTYPE_GBDCHANGED)
122 int neventdatascurrent;
133struct SCIP_ConshdlrData
136 SCIP_Bool branchbalanced;
138 SCIP_Real balancedcutoff;
150 unsigned int varmarked:1;
151 unsigned int indvarmarked:1;
175 (*eventdata)->consdata = consdata;
176 (*eventdata)->var =
var;
177 (*eventdata)->indvar = indvar;
178 (*eventdata)->varmarked =
FALSE;
179 (*eventdata)->indvarmarked =
FALSE;
180 (*eventdata)->pos = (
unsigned int)pos;
226 SCIP_Bool* infeasible
250 SCIP_CALL(
SCIPcreateConsLinear(
scip, &cons,
"branch", 1, &
var, &val, 0.0, 0.0,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
284 SCIP_Bool* infeasible,
316 for(
i = 0;
i < naggrvars; ++
i )
329 for(
i = 0;
i < naggrvars; ++
i )
335 *tightened = *tightened ||
fixed;
400 assert(consdata->nvars <= consdata->maxvars);
402 if( num > consdata->maxvars )
443 SCIP_Bool transformed,
461 assert(consdata->ntreatnonzeros >= 0 );
463 ++consdata->ntreatnonzeros;
503 SCIP_Bool transformed;
513 if( consdata->weights ==
NULL && consdata->maxvars > 0 )
515 SCIPerrorMessage(
"cannot add variable to cardinality constraint <%s> that does not contain weights.\n",
523 if( conshdlrdata->varhash ==
NULL )
580 assert(consdata->maxvars >= consdata->nvars+1);
583 for( pos = consdata->nvars; pos >= 1; --pos )
586 if( consdata->weights[pos-1] > weight )
588 consdata->vars[pos] = consdata->vars[pos-1];
589 consdata->indvars[pos] = consdata->indvars[pos-1];
590 consdata->eventdatas[pos] = consdata->eventdatas[pos-1];
591 consdata->weights[pos] = consdata->weights[pos-1];
593 if( consdata->eventdatas[pos] !=
NULL )
595 consdata->eventdatas[pos]->pos = (
unsigned int)pos;
608 consdata->vars[pos] =
var;
609 consdata->indvars[pos] = indvar;
610 consdata->eventdatas[pos] = eventdata;
611 consdata->weights[pos] = weight;
630 SCIP_Bool transformed;
642 if( conshdlrdata->varhash ==
NULL )
705 consdata->vars[consdata->nvars] =
var;
706 consdata->indvars[consdata->nvars] = indvar;
707 consdata->eventdatas[consdata->nvars] = eventdata;
709 if( consdata->weights !=
NULL && consdata->nvars > 0 )
710 consdata->weights[consdata->nvars] = consdata->weights[consdata->nvars-1] + 1.0;
713 assert(consdata->weights !=
NULL || consdata->nvars > 0);
737 &consdata->eventdatas[pos]) );
741 --(consdata->ntreatnonzeros);
744 for(
j = pos;
j < consdata->nvars-1; ++
j )
746 consdata->vars[
j] = consdata->vars[
j+1];
747 consdata->indvars[
j] = consdata->indvars[
j+1];
748 consdata->eventdatas[
j] = consdata->eventdatas[
j+1];
749 if( consdata->weights !=
NULL )
750 consdata->weights[
j] = consdata->weights[
j+1];
752 consdata->eventdatas[
j]->pos = (
unsigned int)
j;
776 for(
c = 0;
c < nconss; ++
c )
786 nvars = consdata->nvars;
787 vars = consdata->vars;
788 indvars = consdata->indvars;
816 eventdatas = consdata->eventdatas;
817 nvars = consdata->nvars;
824 eventdata = eventdatas[
j];
825 eventdata->varmarked =
FALSE;
826 eventdata->indvarmarked =
FALSE;
858 SCIP_Bool infeasible;
879 consdata->neventdatascurrent = 0;
884 vars = consdata->vars;
885 indvars = consdata->indvars;
918 &consdata->eventdatas[
j]) );
920 &consdata->eventdatas[
j]) );
928 consdata->eventdatas[
j]->var =
var;
935 for(
l =
j+1;
l < consdata->nvars; ++
l )
995 SCIPdebugMsg(
scip,
"deleting variable <%s> from constraint <%s>, since it may be treated as nonzero.\n",
997 --(consdata->cardval);
1035 if( consdata->cardval < 0 )
1037 SCIPdebugMsg(
scip,
"The problem is infeasible: more variables have bounds that keep them from being 0 than allowed.\n");
1043 else if( consdata->cardval == 0 )
1046 for(
j = 0;
j < consdata->nvars; ++
j )
1063 if( consdata->nvars <= consdata->cardval )
1065 SCIPdebugMsg(
scip,
"Deleting cardinality constraint <%s> with <%d> variables and cardinality value <%d>.\n",
1084 for(
j = 0;
j < consdata->nvars; ++
j )
1146 if( consdata->ntreatnonzeros > consdata->cardval )
1148 SCIPdebugMsg(
scip,
"the node is infeasible, more than %d variables are fixed to be nonzero.\n", consdata->cardval);
1156 if( consdata->ntreatnonzeros == consdata->cardval )
1160 SCIP_Bool infeasible;
1161 SCIP_Bool tightened;
1169 nvars = consdata->nvars;
1170 vars = consdata->vars;
1171 indvars = consdata->indvars;
1199 SCIPdebugMsg(
scip,
"the node is infeasible, more than %d variables are fixed to be nonzero.\n",
1209 SCIPdebugMsg(
scip,
"fixed variable <%s> to 0, since constraint <%s> with cardinality value %d is \
1218 assert(cnt == consdata->ntreatnonzeros);
1237 if( consdata->neventdatascurrent > 0 )
1246 eventdatas = consdata->eventdatascurrent;
1252 SCIP_Bool infeasible;
1253 SCIP_Bool tightened;
1256 eventdata = eventdatas[
j];
1261 assert(
var == eventdata->var ||
var == eventdata->indvar);
1265 if( eventdata->indvar ==
var )
1267 assert(eventdata->indvarmarked);
1284 SCIPdebugMsg(
scip,
"the node is infeasible, indicator variable %s is fixed to zero although implied "
1294 SCIPdebugMsg(
scip,
"fixed variable <%s> to 0, since indicator variable %s is 0.\n",
1300 eventdata->indvarmarked =
FALSE;
1306 assert(eventdata->varmarked);
1313 indvar = eventdata->indvar;
1322 SCIPdebugMsg(
scip,
"the node is infeasible, implied variable %s is fixed to nonzero "
1330 SCIPdebugMsg(
scip,
"fixed variable <%s> to 1.0, since implied variable %s is nonzero.\n",
1335 eventdata->varmarked =
FALSE;
1339 consdata->neventdatascurrent = 0;
1358 SCIP_Bool infeasible;
1368 SCIPdebugMsg(
scip,
"apply unbalanced branching on variable <%s> of constraint <%s>.\n",
1461 SCIP_Real balancedcutoff
1485 SCIPerrorMessage(
"balanced branching is only possible if separation frequency of constraint handler is 1.\n");
1545 for(
j = 0;
j <=
ind; ++
j )
1610 SCIP_Bool infeasible;
1618 for(
j = 0;
j <=
ind; ++
j )
1628 for(
j = 0;
j <=
ind; ++
j )
1653 SCIP_Bool infeasible;
1749 SCIP_Real maxweight;
1755 SCIP_Bool branchbalanced =
FALSE;
1780 for(
c = 0;
c < nconss; ++
c )
1803 nvars = consdata->nvars;
1804 vars = consdata->vars;
1805 indvars = consdata->indvars;
1806 cardval = consdata->cardval;
1815 SCIPdebugMsg(
scip,
"propagating <%s> in enforcing (cutoff: %u, domain reductions: %d).\n",
1890 SCIPdebugMsg(
scip,
"Detected cut off: constraint <%s> has %d many variables that can be treated as nonzero, \
1896 else if( cnt > 0 &&
nnonzero + 1 > cardval )
1898 SCIP_Bool infeasible;
1901 for( v = 0; v <
nvars; ++v )
1924 if( cnt > cardval -
nnonzero && weight > maxweight )
1956 nvars = consdata->nvars;
1957 vars = consdata->vars;
1958 indvars = consdata->indvars;
1959 cardval = consdata->cardval;
1964 && (conshdlrdata->balanceddepth == -1 ||
SCIPgetDepth(
scip) <= conshdlrdata->balanceddepth)
1967 branchbalanced =
TRUE;
1971 if( branchbalanced )
1973 SCIP_CALL(
branchBalancedCardinality(
scip, conshdlr,
sol,
branchcons,
vars, indvars,
nvars, cardval,
branchnnonzero,
branchpos,
1974 conshdlrdata->balancedcutoff) );
2033 nvars = consdata->nvars;
2043 cardval = consdata->cardval;
2061 vars[cnt] = consdata->vars[
j];
2062 vals[cnt++] = 1.0/val;
2085 cardval = consdata->cardval;
2103 vars[cnt] = consdata->vars[
j];
2104 vals[cnt++] = 1.0/val;
2151 for(
c = nconss-1;
c >= 0; --
c )
2177 if( consdata->rowub ==
NULL || consdata->rowlb ==
NULL )
2180 (consdata->rowlb ==
NULL) ? &consdata->rowlb :
NULL,
2181 (consdata->rowub ==
NULL) ? &consdata->rowub :
NULL) );
2183 rowub = consdata->rowub;
2184 rowlb = consdata->rowlb;
2321 if( conshdlrdata->varhash !=
NULL )
2346 for(
c = 0;
c < nconss; ++
c )
2358 if( consdata->rowub !=
NULL )
2362 if( consdata->rowlb !=
NULL )
2369 if( conshdlrdata->varhash !=
NULL )
2400 for(
j = 0;
j < (*consdata)->nvars; ++
j )
2403 (*consdata)->indvars[
j], &(*consdata)->eventdatas[
j]) );
2408 if( (*consdata)->weights !=
NULL )
2419 if( (*consdata)->rowub !=
NULL )
2423 if( (*consdata)->rowlb !=
NULL )
2467 consdata->cons =
NULL;
2471 consdata->rowub =
NULL;
2472 consdata->rowlb =
NULL;
2473 consdata->eventdatascurrent =
NULL;
2474 consdata->neventdatascurrent = 0;
2475 consdata->ntreatnonzeros = 0;
2488 consdata->weights =
NULL;
2499 ++(consdata->ntreatnonzeros);
2515 for(
j = 0;
j < consdata->nvars; ++
j )
2518 consdata->vars[
j], consdata->indvars[
j],
j, &consdata->eventdatas[
j]) );
2523 if(
SCIPisGT(
scip, (SCIP_Real)consdata->ntreatnonzeros, consdata->cardval) )
2525 SCIPdebugMsg(
scip,
"constraint <%s> has %d variables fixed to be nonzero, allthough the constraint allows \
2568 for(
c = 0;
c < nconss; ++
c )
2581 assert(consdata->nvars >= 0);
2582 assert(consdata->nvars <= consdata->maxvars);
2714 for(
c = 0;
c < nconss; ++
c )
2725 cardval = consdata->cardval;
2729 for(
j = 0;
j < consdata->nvars; ++
j )
2749 for(
l = 0;
l < consdata->nvars; ++
l )
2789 for(
c = 0;
c < nconss; ++
c )
2849 vars = consdata->vars;
2850 indvars = consdata->indvars;
2851 nvars = consdata->nvars;
2859 indvar = indvars[
j];
2895 for(
j = 0;
j < consdata->nvars; ++
j )
2900 if( consdata->weights ==
NULL )
2921 const char* consname;
2978 targetweights, initial, separate, enforce, check,
propagate, local, dynamic, removable, stickingatnode) );
3009 SCIP_CALL(
SCIPcreateConsCardinality(
scip, cons, name, 0,
NULL, 0,
NULL,
NULL, initial, separate, enforce, check,
propagate, local, dynamic, removable, stickingatnode) );
3081 if( *
success && *s ==
'<' && *(s+1) ==
'=' )
3088 cardval = (int)
strtod(s, &t);
3092 SCIPerrorMessage(
"Syntax error during parsing of the cardinality restriction value: %s\n", s);
3136 (*nvars) = consdata->nvars;
3163 nconsvars = consdata->nvars;
3174 for(
i = 0;
i < nconsvars; ++
i )
3180 vars[0] = consdata->vars[
i];
3209 vars[0] = consdata->indvars[
i];
3265 nconsvars = consdata->nvars;
3276 for(
i = 0;
i < nconsvars; ++
i )
3281 vars[0] = consdata->vars[
i];
3348 vars[0] = consdata->indvars[
i];
3404 consdata = eventdata->consdata;
3406 assert(0 <= consdata->ntreatnonzeros && consdata->ntreatnonzeros <= consdata->nvars);
3417 if( ( eventdata->varmarked &&
var == eventdata->var) || ( eventdata->indvarmarked &&
var == eventdata->indvar) )
3421 for(
i = 0;
i < consdata->neventdatascurrent; ++
i )
3423 if(
var == consdata->eventvarscurrent[
i] )
3459 if(
var == eventdata->indvar )
3465 ++(consdata->ntreatnonzeros);
3467 --(consdata->ntreatnonzeros);
3470 assert(oldbound == 1.0 && newbound == 0.0 );
3473 consdata->eventdatascurrent[consdata->neventdatascurrent] = eventdata;
3474 consdata->eventvarscurrent[consdata->neventdatascurrent] =
var;
3475 ++consdata->neventdatascurrent;
3476 eventdata->indvarmarked =
TRUE;
3477 assert(consdata->neventdatascurrent <= 4 * consdata->maxvars);
3480 assert(0 <= consdata->ntreatnonzeros && consdata->ntreatnonzeros <= consdata->nvars);
3485 if(
var == eventdata->var && ! eventdata->varmarked )
3493 consdata->eventdatascurrent[consdata->neventdatascurrent] = eventdata;
3494 consdata->eventvarscurrent[consdata->neventdatascurrent] =
var;
3495 ++consdata->neventdatascurrent;
3496 eventdata->varmarked =
TRUE;
3497 assert(consdata->neventdatascurrent <= 4 * consdata->maxvars );
3507 consdata->eventdatascurrent[consdata->neventdatascurrent] = eventdata;
3508 consdata->eventvarscurrent[consdata->neventdatascurrent] =
var;
3509 ++consdata->neventdatascurrent;
3510 eventdata->varmarked =
TRUE;
3511 assert(consdata->neventdatascurrent <= 4 * consdata->maxvars );
3516 assert(0 <= consdata->ntreatnonzeros && consdata->ntreatnonzeros <= consdata->nvars);
3518 SCIPdebugMsg(
scip,
"event exec cons <%s>: changed bound of variable <%s> from %f to %f (ntreatnonzeros: %d).\n",
3520 oldbound, newbound, consdata->ntreatnonzeros);
3537 conshdlrdata->eventhdlr =
NULL;
3538 conshdlrdata->varhash =
NULL;
3543 if( conshdlrdata->eventhdlr ==
NULL )
3545 SCIPerrorMessage(
"event handler for cardinality constraints not found.\n");
3578 "whether to use balanced instead of unbalanced branching",
3582 "maximum depth for using balanced branching (-1: no limit)",
3586 "determines that balanced branching is only used if the branching cut off value "
3587 "w.r.t. the current LP solution is greater than a given value",
3628 SCIP_Bool removable,
3630 SCIP_Bool stickingatnode
3638 SCIP_Bool modifiable;
3639 SCIP_Bool transformed;
3646 if( conshdlr ==
NULL )
3661 consdata->cons =
NULL;
3662 consdata->vars =
NULL;
3663 consdata->indvars =
NULL;
3664 consdata->eventdatas =
NULL;
3665 consdata->nvars =
nvars;
3666 consdata->cardval = cardval;
3667 consdata->maxvars =
nvars;
3668 consdata->rowub =
NULL;
3669 consdata->rowlb =
NULL;
3670 consdata->eventdatascurrent =
NULL;
3671 consdata->eventvarscurrent =
NULL;
3672 consdata->neventdatascurrent = 0;
3673 consdata->ntreatnonzeros = transformed ? 0 : -1;
3674 consdata->weights =
NULL;
3682 if( indvars !=
NULL )
3688 if( conshdlrdata->varhash ==
NULL )
3695 for( v = 0; v <
nvars; ++v )
3712 consdata->indvars[v] =
implvar;
3722 consdata->indvars[v] =
var;
3740 if( weights !=
NULL )
3750 for( v = 0; v <
nvars; ++v )
3765 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
3766 local, modifiable, dynamic, removable, stickingatnode) );
3768 consdata->cons = *cons;
3772 for( v =
nvars - 1; v >= 0; --v )
3787 consdata->indvars[v], v, transformed, &consdata->eventdatas[v]) );
3788 assert(! transformed || consdata->eventdatas[v] !=
NULL);
3815 SCIP_CALL(
SCIPcreateConsCardinality(
scip, cons, name,
nvars,
vars, cardval, indvars, weights,
TRUE,
TRUE,
TRUE,
TRUE,
3842 SCIPdebugMsg(
scip,
"modify right hand side of cardinality constraint from <%i> to <%i>\n", consdata->cardval, cardval);
3845 consdata->cardval = cardval;
3943 return consdata->nvars;
3967 return consdata->vars;
3990 return consdata->cardval;
4014 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, .
#define SCIP_LONGINT_FORMAT
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)
int SCIPgetNVars(SCIP *scip)
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,)
SCIP_RETCODE SCIPsetConshdlrGetSignedPermsymGraph(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 SCIPsetConshdlrGetPermsymGraph(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
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_RETCODE SCIPaddSymgraphEdge(SCIP *scip, SYM_GRAPH *graph, int first, int second, SCIP_Bool hasval, SCIP_Real val)
SCIP_RETCODE SCIPaddSymgraphOpnode(SCIP *scip, SYM_GRAPH *graph, int op, int *nodeidx)
SCIP_RETCODE SCIPgetSymActiveVariables(SCIP *scip, SYM_SYMTYPE symtype, SCIP_VAR ***vars, SCIP_Real **scalars, int *nvars, SCIP_Real *constant, SCIP_Bool transformed)
SCIP_RETCODE SCIPaddSymgraphValnode(SCIP *scip, SYM_GRAPH *graph, SCIP_Real val, int *nodeidx)
int SCIPgetSymgraphVarnodeidx(SCIP *scip, SYM_GRAPH *graph, SCIP_VAR *var)
SCIP_RETCODE SCIPaddSymgraphConsnode(SCIP *scip, SYM_GRAPH *graph, SCIP_CONS *cons, SCIP_Real lhs, SCIP_Real rhs, int *nodeidx)
SCIP_RETCODE SCIPaddSymgraphVarAggregation(SCIP *scip, SYM_GRAPH *graph, int rootidx, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Real constant)
int SCIPgetSymgraphNegatedVarnodeidx(SCIP *scip, SYM_GRAPH *graph, SCIP_VAR *var)
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 SCIPisEQ(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
structs for symmetry computations
methods for dealing with symmetry detection graphs
#define SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(x)
#define SCIP_DECL_CONSGETPERMSYMGRAPH(x)
#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
@ SYM_CONSOPTYPE_CARD_TUPLE
@ SCIP_VARSTATUS_MULTAGGR