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
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;
250 SCIP_CALL(
SCIPcreateConsLinear(
scip, &cons,
"branch", 1, &
var, &val, 0.0, 0.0,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
316 for(
i = 0;
i < naggrvars; ++
i )
321 allnonnegative =
FALSE;
329 for(
i = 0;
i < naggrvars; ++
i )
335 *tightened = *tightened || fixed;
400 assert(consdata->nvars <= consdata->maxvars);
402 if( num > consdata->maxvars )
413 if ( reserveweights )
417 consdata->maxvars = newsize;
419 assert(num <= consdata->maxvars);
461 assert(consdata->ntreatnonzeros >= 0 );
463 ++consdata->ntreatnonzeros;
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;
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;
790 for( j = 0; j <
nvars; ++j )
816 eventdatas = consdata->eventdatas;
817 nvars = consdata->nvars;
820 for( j = 0; j <
nvars; ++j )
824 eventdata = eventdatas[j];
825 eventdata->varmarked =
FALSE;
826 eventdata->indvarmarked =
FALSE;
879 consdata->neventdatascurrent = 0;
883 allvarsbinary =
TRUE;
884 vars = consdata->vars;
885 indvars = consdata->indvars;
888 while ( j < consdata->
nvars )
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);
1028 allvarsbinary =
FALSE;
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 )
1169 nvars = consdata->nvars;
1170 vars = consdata->vars;
1171 indvars = consdata->indvars;
1177 for( j = 0; j <
nvars; ++j )
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 \
1214 allvarfixed =
FALSE;
1218 assert(cnt == consdata->ntreatnonzeros);
1221 if( *nchgdomain > 0 )
1237 if( consdata->neventdatascurrent > 0 )
1244 neventdatas = consdata->neventdatascurrent;
1245 eventvars = consdata->eventvarscurrent;
1246 eventdatas = consdata->eventdatascurrent;
1249 for( j = 0; j < neventdatas; ++j )
1256 eventdata = eventdatas[j];
1261 assert(
var == eventdata->var ||
var == eventdata->indvar);
1265 if( eventdata->indvar ==
var )
1267 assert(eventdata->indvarmarked);
1274 implvar = eventdata->var;
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;
1368 SCIPdebugMsg(
scip,
"apply unbalanced branching on variable <%s> of constraint <%s>.\n",
1385 assert(branchnnonzero + 1 <= cardval);
1386 if( branchnnonzero + 1 == cardval )
1398 for( j = 0; j <
nvars; ++j )
1423 for( j = 0; j <
nvars; ++j )
1485 SCIPerrorMessage(
"balanced branching is only possible if separation frequency of constraint handler is 1.\n");
1500 nbuffer =
nvars-branchnnonzero;
1505 for( j = 0; j <
nvars; ++j )
1520 weight1 += val * (
SCIP_Real) (j - (nnonzero + nzero));
1522 branchindvars[nbranchvars] = indvars[j];
1523 branchvars[nbranchvars++] =
var;
1534 assert(nnonzero == branchnnonzero);
1537 assert(cnt >= cardval-nnonzero);
1539 w = weight1/weight2;
1542 assert(0 <= ind && ind < nbranchvars-1);
1545 for( j = 0; j <= ind; ++j )
1562 for( j = ind+1; j < nbranchvars; ++j )
1581 newcardval = cardval - nnonzero;
1582 splitval1 = sum1 + (
SCIP_Real)newcardval - sum2 - 1.0;
1584 splitval1 =
MAX(splitval1, 0);
1585 assert((
int)splitval1 >= 0);
1586 assert((
int)splitval1 <=
MIN(newcardval-1, ind));
1588 splitval2 -= splitval1;
1596 branchnnonzero, branchpos) );
1618 for( j = 0; j <= ind; ++j )
1628 for( j = 0; j <= ind; ++j )
1661 for( j = ind+1; j < nbranchvars; ++j )
1666 assert(nbranchvars - (ind + 1) > 0);
1672 for( j = ind+1; j < nbranchvars; ++j )
1685 for( j = ind+1; j < nbranchvars; ++j )
1687 branchvars[cnt] = branchvars[j];
1688 branchindvars[cnt++] = branchindvars[j];
1690 assert(cnt == nbranchvars - (ind + 1));
1769 branchnnonzero = -1;
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",
1822 if( nchgdomain > 0 )
1833 for( j = 0; j <
nvars; ++j )
1888 if( nnonzero > cardval )
1890 SCIPdebugMsg(
scip,
"Detected cut off: constraint <%s> has %d many variables that can be treated as nonzero, \
1891 although only %d many are feasible.\n",
SCIPconsGetName(cons), nnonzero, cardval);
1896 else if( cnt > 0 && nnonzero + 1 > cardval )
1901 for( v = 0; v <
nvars; ++v )
1924 if( cnt > cardval - nnonzero && weight > maxweight )
1928 branchnnonzero = nnonzero;
1930 branchallneg = allneg;
1931 branchallpos = allpos;
1936 if( branchcons ==
NULL )
1950 assert(branchnnonzero >= 0);
1956 nvars = consdata->nvars;
1957 vars = consdata->vars;
1958 indvars = consdata->indvars;
1959 cardval = consdata->cardval;
1963 if( conshdlrdata->branchbalanced && !
SCIPisFeasNegative(
scip, maxweight) && ( branchallneg || branchallpos )
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;
2044 for( j = 0; j <
nvars; ++j )
2061 vars[cnt] = consdata->vars[j];
2062 vals[cnt++] = 1.0/val;
2085 cardval = consdata->cardval;
2086 for( j = 0; j <
nvars; ++j )
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 )
2461 assert(sourcedata->nvars > 0);
2462 assert(sourcedata->nvars <= sourcedata->maxvars);
2467 consdata->cons =
NULL;
2468 consdata->nvars = sourcedata->nvars;
2469 consdata->maxvars = sourcedata->nvars;
2470 consdata->cardval = sourcedata->cardval;
2471 consdata->rowub =
NULL;
2472 consdata->rowlb =
NULL;
2473 consdata->eventdatascurrent =
NULL;
2474 consdata->neventdatascurrent = 0;
2475 consdata->ntreatnonzeros = 0;
2483 if( sourcedata->weights !=
NULL )
2488 consdata->weights =
NULL;
2490 for( j = 0; j < sourcedata->nvars; ++j )
2492 assert(sourcedata->vars[j] != 0);
2493 assert(sourcedata->indvars[j] != 0);
2499 ++(consdata->ntreatnonzeros);
2511 consdata->cons = *targetcons;
2515 for( j = 0; j < consdata->nvars; ++j )
2518 consdata->vars[j], consdata->indvars[j], j, &consdata->eventdatas[j]) );
2525 SCIPdebugMsg(
scip,
"constraint <%s> has %d variables fixed to be nonzero, allthough the constraint allows \
2526 only %d nonzero variables\n",
SCIPconsGetName(*targetcons), consdata->ntreatnonzeros, consdata->cardval);
2552 SCIPdebug( oldnfixedvars = *nfixedvars; )
2554 SCIPdebug( oldnupgdconss = *nupgdconss; )
2558 if( nrounds == 0 || nnewfixedvars > 0 || nnewaggrvars > 0 )
2568 for(
c = 0;
c < nconss; ++
c )
2581 assert(consdata->nvars >= 0);
2582 assert(consdata->nvars <= consdata->maxvars);
2587 ndelconss, nupgdconss, nfixedvars, &nremovedvars) );
2600 (*nchgcoefs) += nremovedvars;
2603 and upgraded %d constraints.\n", *nfixedvars - oldnfixedvars, nremovedvars, *ndelconss - oldndelconss,
2604 *nupgdconss - oldnupgdconss); )
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 )
2811 if( nchgdomain > 0 )
2849 vars = consdata->vars;
2850 indvars = consdata->indvars;
2851 nvars = consdata->nvars;
2854 for( j = 0; j <
nvars; ++j )
2859 indvar = indvars[j];
2895 for( j = 0; j < consdata->nvars; ++j )
2900 if( consdata->weights ==
NULL )
2921 const char* consname;
2944 nvars = sourceconsdata->nvars;
2949 sourcevars = sourceconsdata->vars;
2951 sourceindvars = sourceconsdata->indvars;
2953 sourceweights = sourceconsdata->weights;
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) );
3043 weight = strtod(s, &t);
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);
3114 if( varssize < consdata->
nvars )
3136 (*nvars) = consdata->nvars;
3163 nconsvars = consdata->nvars;
3174 for(
i = 0;
i < nconsvars; ++
i )
3180 vars[0] = consdata->vars[
i];
3201 else if( nlocvars == 1 )
3209 vars[0] = consdata->indvars[
i];
3230 else if( nlocvars == 1 )
3268 nconsvars = consdata->nvars;
3279 for(
i = 0;
i < nconsvars; ++
i )
3284 vars[0] = consdata->vars[
i];
3310 for( j = 0; j < nlocvars; ++j )
3324 else if( nlocvars == 1 )
3332 allownegation =
TRUE;
3351 vars[0] = consdata->indvars[
i];
3372 else if( nlocvars == 1 )
3410 consdata = eventdata->consdata;
3412 assert(0 <= consdata->ntreatnonzeros && consdata->ntreatnonzeros <= consdata->nvars);
3423 if( ( eventdata->varmarked &&
var == eventdata->var) || ( eventdata->indvarmarked &&
var == eventdata->indvar) )
3427 for(
i = 0;
i < consdata->neventdatascurrent; ++
i )
3429 if(
var == consdata->eventvarscurrent[
i] )
3465 if(
var == eventdata->indvar )
3471 ++(consdata->ntreatnonzeros);
3473 --(consdata->ntreatnonzeros);
3476 assert(oldbound == 1.0 && newbound == 0.0 );
3479 consdata->eventdatascurrent[consdata->neventdatascurrent] = eventdata;
3480 consdata->eventvarscurrent[consdata->neventdatascurrent] =
var;
3481 ++consdata->neventdatascurrent;
3482 eventdata->indvarmarked =
TRUE;
3483 assert(consdata->neventdatascurrent <= 4 * consdata->maxvars);
3486 assert(0 <= consdata->ntreatnonzeros && consdata->ntreatnonzeros <= consdata->nvars);
3491 if(
var == eventdata->var && ! eventdata->varmarked )
3499 consdata->eventdatascurrent[consdata->neventdatascurrent] = eventdata;
3500 consdata->eventvarscurrent[consdata->neventdatascurrent] =
var;
3501 ++consdata->neventdatascurrent;
3502 eventdata->varmarked =
TRUE;
3503 assert(consdata->neventdatascurrent <= 4 * consdata->maxvars );
3513 consdata->eventdatascurrent[consdata->neventdatascurrent] = eventdata;
3514 consdata->eventvarscurrent[consdata->neventdatascurrent] =
var;
3515 ++consdata->neventdatascurrent;
3516 eventdata->varmarked =
TRUE;
3517 assert(consdata->neventdatascurrent <= 4 * consdata->maxvars );
3522 assert(0 <= consdata->ntreatnonzeros && consdata->ntreatnonzeros <= consdata->nvars);
3524 SCIPdebugMsg(
scip,
"event exec cons <%s>: changed bound of variable <%s> from %f to %f (ntreatnonzeros: %d).\n",
3526 oldbound, newbound, consdata->ntreatnonzeros);
3543 conshdlrdata->eventhdlr =
NULL;
3544 conshdlrdata->varhash =
NULL;
3548 eventExecCardinality,
NULL) );
3549 if( conshdlrdata->eventhdlr ==
NULL )
3551 SCIPerrorMessage(
"event handler for cardinality constraints not found.\n");
3558 consEnfolpCardinality, consEnfopsCardinality, consCheckCardinality, consLockCardinality, conshdlrdata) );
3584 "whether to use balanced instead of unbalanced branching",
3588 "maximum depth for using balanced branching (-1: no limit)",
3592 "determines that balanced branching is only used if the branching cut off value "
3593 "w.r.t. the current LP solution is greater than a given value",
3652 if( conshdlr ==
NULL )
3667 consdata->cons =
NULL;
3668 consdata->vars =
NULL;
3669 consdata->indvars =
NULL;
3670 consdata->eventdatas =
NULL;
3671 consdata->nvars =
nvars;
3672 consdata->cardval = cardval;
3673 consdata->maxvars =
nvars;
3674 consdata->rowub =
NULL;
3675 consdata->rowlb =
NULL;
3676 consdata->eventdatascurrent =
NULL;
3677 consdata->eventvarscurrent =
NULL;
3678 consdata->neventdatascurrent = 0;
3679 consdata->ntreatnonzeros = transformed ? 0 : -1;
3680 consdata->weights =
NULL;
3688 if( indvars !=
NULL )
3694 if( conshdlrdata->varhash ==
NULL )
3701 for( v = 0; v <
nvars; ++v )
3718 consdata->indvars[v] = implvar;
3728 consdata->indvars[v] =
var;
3746 if( weights !=
NULL )
3756 for( v = 0; v <
nvars; ++v )
3771 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
3772 local, modifiable, dynamic, removable, stickingatnode) );
3774 consdata->cons = *cons;
3778 for( v =
nvars - 1; v >= 0; --v )
3793 consdata->indvars[v], v, transformed, &consdata->eventdatas[v]) );
3794 assert(! transformed || consdata->eventdatas[v] !=
NULL);
3821 SCIP_CALL(
SCIPcreateConsCardinality(
scip, cons, name,
nvars,
vars, cardval, indvars, weights,
TRUE,
TRUE,
TRUE,
TRUE,
3848 SCIPdebugMsg(
scip,
"modify right hand side of cardinality constraint from <%i> to <%i>\n", consdata->cardval, cardval);
3851 consdata->cardval = cardval;
3949 return consdata->nvars;
3973 return consdata->vars;
3996 return consdata->cardval;
4020 return consdata->weights;
#define CONSHDLR_NEEDSCONS
#define CONSHDLR_SEPAFREQ
#define CONSHDLR_CHECKPRIORITY
#define CONSHDLR_PROP_TIMING
#define CONSHDLR_MAXPREROUNDS
#define CONSHDLR_SEPAPRIORITY
#define CONSHDLR_PROPFREQ
#define CONSHDLR_PRESOLTIMING
#define CONSHDLR_EAGERFREQ
#define CONSHDLR_ENFOPRIORITY
#define CONSHDLR_DELAYSEPA
#define CONSHDLR_DELAYPROP
static SCIP_RETCODE unlockVariableCardinality(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_VAR *indvar)
static SCIP_RETCODE consdataEnsurevarsSizeCardinality(SCIP *scip, SCIP_CONSDATA *consdata, int num, SCIP_Bool reserveweights)
static SCIP_RETCODE lockVariableCardinality(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_VAR *indvar)
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
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 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)
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)
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)
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_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)
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)
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)
struct SCIP_Cons SCIP_CONS
#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)
struct SCIP_Conshdlr SCIP_CONSHDLR
#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)
struct SCIP_Eventhdlr SCIP_EVENTHDLR
#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
struct SCIP_HashMap SCIP_HASHMAP
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SYM_CONSOPTYPE_CARD_TUPLE
struct SCIP_Node SCIP_NODE
@ SCIP_VARSTATUS_MULTAGGR