118#define CONSHDLR_NAME "SOS1"
119#define CONSHDLR_DESC "SOS1 constraint handler"
120#define CONSHDLR_SEPAPRIORITY 1000
121#define CONSHDLR_ENFOPRIORITY 100
122#define CONSHDLR_CHECKPRIORITY -10
123#define CONSHDLR_SEPAFREQ 10
124#define CONSHDLR_PROPFREQ 1
125#define CONSHDLR_EAGERFREQ 100
127#define CONSHDLR_MAXPREROUNDS -1
128#define CONSHDLR_DELAYSEPA FALSE
129#define CONSHDLR_DELAYPROP FALSE
130#define CONSHDLR_NEEDSCONS TRUE
131#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP
132#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_MEDIUM
135#define DEFAULT_MAXSOSADJACENCY 10000
139#define DEFAULT_MAXEXTENSIONS 1
140#define DEFAULT_MAXTIGHTENBDS 5
141#define DEFAULT_PERFIMPLANALYSIS FALSE
142#define DEFAULT_DEPTHIMPLANALYSIS -1
145#define DEFAULT_CONFLICTPROP TRUE
146#define DEFAULT_IMPLPROP TRUE
147#define DEFAULT_SOSCONSPROP FALSE
150#define DEFAULT_BRANCHSTRATEGIES "nbs"
151#define DEFAULT_BRANCHINGRULE 'n'
153#define DEFAULT_AUTOSOS1BRANCH TRUE
154#define DEFAULT_FIXNONZERO FALSE
156#define DEFAULT_ADDCOMPS FALSE
158#define DEFAULT_MAXADDCOMPS -1
159#define DEFAULT_ADDCOMPSDEPTH 30
160#define DEFAULT_ADDCOMPSFEAS -0.6
161#define DEFAULT_ADDBDSFEAS 1.0
162#define DEFAULT_ADDEXTENDEDBDS TRUE
165#define DEFAULT_NSTRONGROUNDS 0
167#define DEFAULT_NSTRONGITER 10000
170#define DEFAULT_BOUNDCUTSFROMSOS1 FALSE
171#define DEFAULT_BOUNDCUTSFROMGRAPH TRUE
172#define DEFAULT_AUTOCUTSFROMSOS1 TRUE
173#define DEFAULT_BOUNDCUTSFREQ 10
174#define DEFAULT_BOUNDCUTSDEPTH 40
175#define DEFAULT_MAXBOUNDCUTS 50
176#define DEFAULT_MAXBOUNDCUTSROOT 150
177#define DEFAULT_STRTHENBOUNDCUTS TRUE
178#define DEFAULT_IMPLCUTSFREQ 0
179#define DEFAULT_IMPLCUTSDEPTH 40
180#define DEFAULT_MAXIMPLCUTS 50
181#define DEFAULT_MAXIMPLCUTSROOT 150
184#define EVENTHDLR_NAME "SOS1"
185#define EVENTHDLR_DESC "bound change event handler for SOS1 constraints"
187#define EVENTHDLR_EVENT_TYPE (SCIP_EVENTTYPE_BOUNDCHANGED | SCIP_EVENTTYPE_GBDCHANGED)
190#define DIVINGCUTOFFVALUE 1e6
213 SCIP_Real lbboundcoef;
214 SCIP_Real ubboundcoef;
215 SCIP_Bool lbboundcomp;
217 SCIP_Bool ubboundcomp;
249struct SCIP_ConshdlrData
254 SCIP_Bool isconflocal;
269 int maxnfixnonzerovars;
275 SCIP_Bool perfimplanalysis;
276 int depthimplanalysis;
278 SCIP_Bool conflictprop;
280 SCIP_Bool sosconsprop;
284 SCIP_Bool autosos1branch;
285 SCIP_Bool fixnonzero;
291 SCIP_Real addcompsfeas;
292 SCIP_Real addbdsfeas;
293 SCIP_Bool addextendedbds;
295 SCIP_Bool branchnonzeros;
296 SCIP_Bool branchweight;
297 SCIP_Bool switchsos1branch;
303 SCIP_Bool boundcutsfromsos1;
304 SCIP_Bool boundcutsfromgraph;
305 SCIP_Bool autocutsfromsos1;
306 SCIP_Bool switchcutsfromsos1;
310 int maxboundcutsroot;
312 SCIP_Bool strthenboundcuts;
416 for (s = 0; s <
nsucc; ++s)
578 SCIP_Bool* infeasible
601 SCIP_CALL(
SCIPcreateConsLinear(
scip, &cons,
"branch", 1, &
var, &val, 0.0, 0.0,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
632 SCIP_Bool* infeasible,
664 for (
i = 0;
i < naggrvars; ++
i)
677 for (
i = 0;
i < naggrvars; ++
i)
683 *tightened = *tightened ||
fixed;
708 SCIP_Bool* infeasible,
709 SCIP_Bool* tightened,
731 *tightened = *tightened ||
tighten;
735 *tightened = *tightened ||
tighten;
794 assert( consdata->nvars <= consdata->maxvars );
796 if ( num > consdata->maxvars )
820 SCIP_Bool transformed
842 assert( consdata->nfixednonzeros >= 0 );
844 ++consdata->nfixednonzeros;
866 conflictgraph = conshdlrdata->conflictgraph;
867 if ( conflictgraph ==
NULL )
879 SCIPdebugMsg(
scip,
"Switched to SOS1 branching rule, since conflict graph could be infeasible.\n");
880 conshdlrdata->switchsos1branch =
TRUE;
886 if ( ! consdata->local )
892 vars = consdata->vars;
893 nvars = consdata->nvars;
895 for (v = 0; v <
nvars; ++v)
936 SCIPdebugMsg(
scip,
"Switched to SOS1 branching rule, since conflict graph could be infeasible.\n");
937 conshdlrdata->switchsos1branch =
TRUE;
958 SCIP_Bool transformed;
969 if ( consdata->weights ==
NULL && consdata->maxvars > 0 )
988 assert( consdata->maxvars >= consdata->nvars+1 );
991 for (pos = 0; pos < consdata->nvars; ++pos)
993 if ( consdata->weights[pos] > weight )
999 for (
j = consdata->nvars;
j > pos; --
j)
1001 consdata->vars[
j] = consdata->vars[
j-1];
1002 consdata->weights[
j] = consdata->weights[
j-1];
1006 consdata->vars[pos] =
var;
1007 consdata->weights[pos] = weight;
1027 SCIP_Bool transformed;
1035 assert( consdata->nvars >= 0 );
1048 if ( consdata->weights !=
NULL )
1058 consdata->vars[consdata->nvars] =
var;
1059 if ( consdata->weights !=
NULL )
1061 if ( consdata->nvars > 0 )
1062 consdata->weights[consdata->nvars] = consdata->weights[consdata->nvars-1] + 1.0;
1064 consdata->weights[consdata->nvars] = 0.0;
1096 for (
j = pos;
j < consdata->nvars-1; ++
j)
1098 consdata->vars[
j] = consdata->vars[
j+1];
1099 if ( consdata->weights !=
NULL )
1100 consdata->weights[
j] = consdata->weights[
j+1];
1267 assert( *ncliques <
MAX(1, conshdlrdata->maxextensions) * nconss );
1291 for (
j = 0;
j < consdata->nvars; ++
j)
1301 ++(conshdlrdata->cntextsos1);
1309 if ( *maxextensions <= 0 )
1320 SCIP_CALL(
extensionOperatorSOS1(
scip, conshdlrdata,
adjacencymatrix,
vertexcliquegraph, nsos1vars, nconss, cons,
vars, weights,
FALSE,
usebacktrack,
1321 cliques, ncliques,
cliquesizes,
newclique,
workingsetnew,
nworkingsetnew,
nextsnew, pos, maxextensions, naddconss,
success) );
1322 if ( *maxextensions <= 0 )
1339 SCIP_CALL(
extensionOperatorSOS1(
scip, conshdlrdata,
adjacencymatrix,
vertexcliquegraph, nsos1vars, nconss, cons,
vars, weights,
FALSE,
usebacktrack,
1340 cliques, ncliques,
cliquesizes,
newclique,
workingset,
nworkingset,
nextsnew, pos, maxextensions, naddconss,
success) );
1341 assert( *maxextensions <= 0 );
1399 for (v = 1; v < nlinvars; ++v)
1409 for (s = 0; s <
nsucc; ++s)
1473 if (
succ[
i] > clique[
j] )
1478 else if (
succ[
i] == clique[
j] )
1489 for (v = 1; v <
nvars; ++v)
1563 for (s = 0; s <
nsucc; ++s)
1613 SCIP_Bool infeasible;
1639 vars = consdata->vars;
1675 for (
l =
j+1;
l < consdata->nvars; ++
l)
1722 if ( consdata->nvars < 2 )
1735 if ( nfixednonzeros > 1 )
1737 SCIPdebugMsg(
scip,
"The problem is infeasible: more than one variable has bounds that keep it from being 0.\n");
1744 if ( nfixednonzeros == 1 )
1749 for (
j = 0;
j < consdata->nvars; ++
j)
1843 int** cliques =
NULL;
1847 int* indconss =
NULL;
1867 csize =
MAX(1, conshdlrdata->maxextensions) * nconss;
1883 for (
c = 0;
c < nconss; ++
c)
1917 assert( consdata->nvars >= 0 );
1918 assert( consdata->nvars <= consdata->maxvars );
1926 SCIP_CALL(
presolRoundConsSOS1(
scip, cons, consdata, eventhdlr, &
substituted, &
cutoff, &
success, ndelconss, nupgdconss, nfixedvars,
nremovedvars) );
1944 nvars = consdata->nvars;
1947 vars = consdata->vars;
1949 if (
nvars > 1 && conshdlrdata->maxextensions != 0 )
2032 maxextensions = conshdlrdata->maxextensions;
2035 TRUE, (maxextensions <= 1) ?
FALSE :
TRUE, cliques, &ncliques,
cliquesizes,
newclique,
comsucc,
ncomsucc, 0, -1, &maxextensions,
2071 for (
c = ncliques-1;
c >= 0; --
c)
2110 SCIP_Bool* infeasible
2122 if ( conshdlrdata->depthimplanalysis >= 0 && *
probingdepth >= conshdlrdata->depthimplanalysis )
2131 for (s = 0; s <
nsucc; ++s)
2173 SCIP_CALL(
SCIPcreateConsSOS1(
scip, &
soscons,
namesos, 0,
NULL,
NULL,
TRUE,
TRUE,
TRUE,
FALSE,
TRUE,
2197 for (s = 0; s <
nsucc; ++s)
2217 SCIP_CALL(
performImplicationGraphAnalysis(
scip, conshdlrdata, conflictgraph,
totalvars, implgraph,
implhash,
adjacencymatrix,
givennode,
succnode,
impllbs,
implubs,
implnodes, naddconss,
probingdepth, infeasible) );
2237 SCIP_CALL(
performImplicationGraphAnalysis(
scip, conshdlrdata, conflictgraph,
totalvars, implgraph,
implhash,
adjacencymatrix,
givennode,
succnode,
impllbs,
implubs,
implnodes, naddconss,
probingdepth, infeasible) );
2270 for (s = 0; s <
nsucc; ++s)
2295 SCIP_Bool* infeasible
2347 for (s = 0; s <
nsucc; ++s)
2358 data->lbimpl = newbound;
2368 data->ubimpl = newbound;
2384 data->lbimpl = newbound;
2391 data->ubimpl = newbound;
2431 SCIP_Bool* infeasible
2441 *infeasible =
FALSE;
2537 SCIP_CALL(
updateArcData(
scip, implgraph,
implhash,
totalvars,
var,
vars[
w], lb, ub, newbound,
TRUE, nchgbds, update, infeasible) );
2541 SCIP_CALL(
updateArcData(
scip, implgraph,
implhash,
totalvars,
var,
vars[
w], lb, ub, newbound,
FALSE, nchgbds, update, infeasible) );
2548 SCIP_CALL(
updateArcData(
scip, implgraph,
implhash,
totalvars,
var,
vars[
w], lb, ub, newbound,
FALSE, nchgbds, update, infeasible) );
2552 SCIP_CALL(
updateArcData(
scip, implgraph,
implhash,
totalvars,
var,
vars[
w], lb, ub, newbound,
TRUE, nchgbds, update, infeasible) );
2612 for (s = 0; s <
nsucc; ++s)
2727 if ( conshdlrlinear ==
NULL )
2861 for (v = 0; v < nsos1vars; ++v)
2923 for (s = 0; s <
nsucc; ++s)
2965 SCIP_Bool tightened;
2966 SCIP_Bool infeasible;
2997 for (
w = 0;
w < nsos1vars; ++
w)
3118 SCIP_CALL(
updateImplicationGraphSOS1(
scip, conshdlrdata, conflictgraph,
adjacencymatrix, implgraph,
implhash,
implnodes,
totalvars,
cliquecovers,
cliquecoversizes,
varincover,
3119 trafolinvars,
trafolinvals,
ntrafolinvars,
trafoubs,
var,
trafoubv,
newboundnonzero,
ninftynonzero,
TRUE, nchgbds, &update, &infeasible) );
3167 SCIP_Bool tightened;
3168 SCIP_Bool infeasible;
3197 for (
w = 0;
w < nsos1vars; ++
w)
3321 SCIP_CALL(
updateImplicationGraphSOS1(
scip, conshdlrdata, conflictgraph,
adjacencymatrix, implgraph,
implhash,
implnodes,
totalvars,
cliquecovers,
cliquecoversizes,
varincover,
3322 trafolinvars,
trafolinvals,
ntrafolinvars,
trafolbs,
var,
trafolbv,
newboundnonzero,
ninftynonzero,
FALSE, nchgbds, &update, &infeasible) );
3393 for (
i = 0;
i < nsos1vars; ++
i)
3424 for (
j = 0; (
j < conshdlrdata->maxtightenbds || conshdlrdata->maxtightenbds == -1 ) && !
cutoff; ++
j)
3432 SCIP_CALL(
tightenVarsBoundsSOS1(
scip, conshdlrdata, conflictgraph, implgraph,
implhash,
adjacencymatrix,
totalvars,
ntotalvars, nsos1vars, nchgbds, &
implupdate, &
cutoff) );
3451 SCIP_Bool infeasible;
3462 for (
i = 0;
i < nsos1vars; ++
i)
3467 for (
j = 0;
j < nsos1vars; ++
j)
3476 SCIP_CALL(
performImplicationGraphAnalysis(
scip, conshdlrdata, conflictgraph,
totalvars, implgraph,
implhash,
adjacencymatrix,
i,
i,
impllbs,
implubs,
implnodes, naddconss, &
probingdepth, &infeasible) );
3485 SCIPdebugMsg(
scip,
"fixed variable %s with lower bound %f and upper bound %f to zero\n",
3521 for (s =
nsucc-1; s >= 0; --s)
3553 if ( consdata->nfixednonzeros > 1 )
3555 SCIPdebugMsg(
scip,
"the node is infeasible, more than 1 variable is fixed to be nonzero.\n");
3562 if ( consdata->nfixednonzeros == 1 )
3565 SCIP_Bool infeasible;
3566 SCIP_Bool tightened;
3574 nvars = consdata->nvars;
3575 vars = consdata->vars;
3657 inferinfo = -node - 1;
3665 for (s = 0; s <
nsucc; ++s)
3677 SCIP_Bool infeasible;
3678 SCIP_Bool tightened;
3697 if ( implprop && implgraph !=
NULL )
3714 for (s = 0; s <
nsucc; ++s)
3733 SCIP_Bool infeasible;
3734 SCIP_Bool tightened;
3749 SCIP_Bool infeasible;
3750 SCIP_Bool tightened;
3802 assert( conshdlrdata->nimplnodes == 0 );
3810 if ( conshdlrdata->maxsosadjacency != -1 && nsos1vars > conshdlrdata->maxsosadjacency )
3813 SCIPdebugMsg(
scip,
"Implication graph was not created since number of SOS1 variables (%d) is larger than %d.\n", nsos1vars, conshdlrdata->maxsosadjacency);
3836 for (
i = 0;
i < nsos1vars; ++
i)
3861 conshdlrdata->nimplnodes = nimplnodes;
3864 for (
i = 0;
i < nimplnodes; ++
i)
3880 for (
i = 0;
i < nsos1vars; ++
i)
3884 for (
i = 0;
i < nsos1vars; ++
i)
3886 for (
j = 0;
j <
i+1; ++
j)
3890 for (
i = 0;
i < nsos1vars; ++
i)
3907 for (
j = 0; (
j < maxrounds || maxrounds == -1 ); ++
j)
3914 assert( nimplnodes > 0 );
3915 SCIP_CALL(
tightenVarsBoundsSOS1(
scip, conshdlrdata, conflictgraph, conshdlrdata->implgraph,
implhash,
adjacencymatrix,
implvars, nimplnodes, nsos1vars, nchgbds, &
implupdate,
cutoff) );
3921 for (
i = nsos1vars-1;
i >= 0; --
i)
3934 else if ( *nchgbds > 0 )
3959 if ( conshdlrdata->implgraph ==
NULL )
3961 assert( conshdlrdata->nimplnodes == 0 );
3966 for (
j = conshdlrdata->nimplnodes-1;
j >= 0; --
j)
3975 for (s =
nsucc-1; s >= 0; --s)
3983 for (
j = conshdlrdata->nimplnodes-1;
j >= 0; --
j)
3994 conshdlrdata->nimplnodes = 0;
4042 for (s = 0; s <
nsucc1; ++s)
4259 for (
i = 0;
i < nsos1vars; ++
i)
4276 SCIP_Real
sum1 = 0.0;
4277 SCIP_Real
sum2 = 0.0;
4339 SCIP_Bool fixnonzero,
4343 SCIP_Bool* infeasible,
4357 assert( inititer >= -1 );
4367 *infeasible =
FALSE;
4427 if ( ! *infeasible )
4543 for (
j = 0;
j < nsos1vars; ++
j)
4563 if ( conshdlrdata->nstrongiter == -2 )
4567 inititer =
MAX(inititer, 10);
4568 inititer =
MIN(inititer, 500);
4571 inititer = conshdlrdata->nstrongiter;
4587 for (
j = 0;
j < nstrongrounds; ++
j)
4663 SCIP_Bool infeasible;
4706 SCIP_Real coef = 0.0;
4773 *
feas += coef * solval;
4789 for (s = 0; s <
nsucc; ++s)
4876 *
feas += coef * solval;
4972 for (
i = 0;
i < nsos1vars; ++
i)
4996 for (s = 0; s <
nsucc; ++s)
5012 for (
i = 0;
i < nsos1vars; ++
i)
5039 for (s = 0; s <
nsucc; ++s)
5051 SCIP_Bool infeasible;
5117 if ( conshdlrdata->addextendedbds )
5119 if ( localconflicts ==
NULL )
5122 localconflicts = conshdlrdata->localconflicts;
5136 conshdlrdata->isconflocal =
TRUE;
5204 SCIP_CALL(
SCIPcreateConsSOS1(
scip, &
conssos1, name, 0,
NULL,
NULL,
TRUE,
TRUE,
TRUE,
FALSE,
TRUE,
5228 SCIP_CALL(
SCIPcreateConsLinear(
scip, &
conssos1, name, 0,
NULL,
NULL, -
SCIPinfinity(
scip), 0.0,
TRUE,
FALSE,
TRUE,
FALSE,
FALSE,
5237 SCIP_CALL(
SCIPcreateConsLinear(
scip, &
conssos1, name, 0,
NULL,
NULL, -
SCIPinfinity(
scip), 1.0,
TRUE,
FALSE,
TRUE,
FALSE,
FALSE,
5256 if ( conshdlrdata->maxaddcomps >= 0 && *naddedconss > conshdlrdata->maxaddcomps )
5264 if ( conshdlrdata->maxaddcomps >= 0 && *naddedconss > conshdlrdata->maxaddcomps )
5290 for (
j = 0;
j < nsos1vars; ++
j)
5361 SCIP_Bool infeasible;
5385 nsos1vars = conshdlrdata->nsos1vars;
5388 if ( nsos1vars == 0 || nconss == 0 )
5395 conflictgraph = conshdlrdata->conflictgraph;
5396 assert( ! conshdlrdata->isconflocal );
5399 for (
c = 0;
c < nconss; ++
c)
5412 if ( consdata->nvars < 2 )
5431 if ( consdata->local )
5438 if ( conshdlrdata->localconflicts ==
NULL )
5443 vars = consdata->vars;
5444 nvars = consdata->nvars;
5475 conshdlrdata->isconflocal =
TRUE;
5485 if ( conshdlrdata->isconflocal )
5487 for (
j = 0;
j < nsos1vars; ++
j)
5503 if ( conshdlrdata->isconflocal )
5506 conshdlrdata->isconflocal =
FALSE;
5513 for (
j = 0;
j < nsos1vars; ++
j)
5529 if ( conshdlrdata->branchingrule ==
'b' )
5533 if ( conshdlrdata->nstrongrounds >= 0 )
5534 nstrongrounds =
MIN(conshdlrdata->nstrongrounds, nsos1vars);
5544 nstrongrounds =
MIN(nsos1vars, nstrongrounds);
5555 if ( nstrongrounds == 0 )
5572 if ( conshdlrdata->isconflocal )
5575 conshdlrdata->isconflocal =
FALSE;
5596 if ( conshdlrdata->isconflocal )
5599 conshdlrdata->isconflocal =
FALSE;
5612 if ( ! conshdlrdata->branchsos )
5615 if ( conshdlrdata->isconflocal )
5618 conshdlrdata->isconflocal =
FALSE;
5634 SCIPerrorMessage(
"Incompatible parameter setting: branchsos can only be set to false if all SOS1 variables are binary.\n");
5735 if ( conshdlrdata->addcomps && ( conshdlrdata->addcompsdepth == -1 || conshdlrdata->addcompsdepth >=
SCIPgetDepth(
scip) ) )
5739 assert( ! conshdlrdata->fixnonzero );
5745 if ( naddedconss == 0 )
5754 if ( nstrongrounds > 0 )
5761 if ( conshdlrdata->isconflocal )
5764 conshdlrdata->isconflocal =
FALSE;
5845 for (
c = 0;
c < nconss; ++
c)
5861 nvars = consdata->nvars;
5862 vars = consdata->vars;
5891 if ( conshdlrdata->branchnonzeros )
5895 if ( conshdlrdata->branchweight && consdata->weights !=
NULL )
5898 if ( consdata->weights[
j] > weight )
5899 weight = consdata->weights[
j];
5923 if ( ! conshdlrdata->branchsos )
5928 for (
j = 0;
j < consdata->nvars; ++
j)
5934 if (
j == consdata->nvars )
5941 SCIPerrorMessage(
"Incompatible parameter setting: branchsos can only be set to false if all SOS1 variables are binary.\n");
5950 nvars = consdata->nvars;
5951 vars = consdata->vars;
5955 SCIP_Bool infeasible;
5973 SCIP_Bool infeasible;
6014 for (
j = 0;
j <=
ind; ++
j)
6023 for (
j = 0;
j <=
ind; ++
j)
6076 if ( conshdlrdata->addcomps && conshdlrdata->fixnonzero )
6078 SCIPerrorMessage(
"Incompatible parameter setting: addcomps = TRUE and fixnonzero = TRUE.\n");
6082 if ( conshdlrdata->fixnonzero && ( conshdlrdata->branchingrule ==
'b' || conshdlrdata->branchingrule ==
's' ) )
6084 SCIPerrorMessage(
"Incompatible parameter setting: nonzero fixing is not compatible with bipartite or sos1 branching.\n");
6088 if ( conshdlrdata->branchingrule ==
's' && conshdlrdata->nstrongrounds != 0 )
6090 SCIPerrorMessage(
"Strong branching is not available for SOS1 branching.\n");
6094 if ( conshdlrdata->branchingrule ==
's' || conshdlrdata->switchsos1branch )
6101 if ( conshdlrdata->branchingrule !=
'n' && conshdlrdata->branchingrule !=
'b' )
6103 SCIPerrorMessage(
"branching rule %c unknown\n", conshdlrdata->branchingrule);
6135 for (
j = 0;
j < nsos1vars; ++
j)
6142 for (
j = 0;
j < nsos1vars; ++
j)
6169 tcliquedata = conshdlrdata->tcliquedata;
6177 tcliquedata->
ncuts = 0;
6178 tcliquedata->
nboundcuts = conshdlrdata->nboundcuts;
6180 tcliquedata->
maxboundcuts = conshdlrdata->maxboundcutsroot;
6202 for (
j = 0;
j < nsos1vars; ++
j)
6213 if ( conshdlrdata->strthenboundcuts )
6220 if ( conshdlrdata->strthenboundcuts )
6266 if ( rowlb !=
NULL )
6270 SCIP_Bool infeasible;
6277 ++tcliquedata->
ncuts;
6283 if ( rowub !=
NULL )
6287 SCIP_Bool infeasible;
6294 ++tcliquedata->
ncuts;
6331 SCIP_Bool strengthen,
6332 SCIP_Bool removable,
6349 assert( ! local || ! global );
6357 if ( rowub !=
NULL )
6402 if ( ubboundvar ==
NULL )
6408 else if ( ubboundvar ==
nodedata->ubboundvar )
6434 vals[cnt++] = 1.0/val;
6439 if (
j ==
nnodes && cnt >= 2 )
6449 rhs = rhs * vals[0] * vals[1];
6456 vars[cnt] = ubboundvar;
6478 if ( rowlb !=
NULL )
6523 if ( lbboundvar ==
NULL )
6557 vals[cnt++] = 1.0/val;
6562 if (
j ==
nnodes && cnt >= 2 )
6572 rhs = rhs * vals[0] * vals[1];
6579 vars[cnt] = lbboundvar;
6641 scip = tcliquedata->scip;
6642 sol = tcliquedata->sol;
6655 if ( tcliquedata->strthenboundcuts )
6662 if ( tcliquedata->strthenboundcuts )
6703 if ( rowlb !=
NULL )
6712 if ( rowub !=
NULL )
6730 if( tcliquedata->maxboundcuts >= 0 )
6732 if ( tcliquedata->ncuts > tcliquedata->maxboundcuts/2 )
6734 if ( tcliquedata->ncuts >= tcliquedata->maxboundcuts )
6763 SCIP_Real scaleval = 1000.0;
6764 int maxtreenodes = 10000;
6765 int maxzeroextensions = 1000;
6766 int backtrackfreq = 1000;
6784 tcliquedata = conshdlrdata->tcliquedata;
6788 tcliquedata->
ncuts = 0;
6813 conshdlrdata->nboundcuts = tcliquedata->
nboundcuts;
6827 SCIP_Bool strengthen,
6828 SCIP_Bool removable,
6848 nvars = consdata->nvars;
6906 for (
c = 0;
c < nconss; ++
c)
6929 if ( consdata->local )
6936 if ( consdata->rowub ==
NULL || consdata->rowlb ==
NULL )
6939 (consdata->rowlb ==
NULL) ? &consdata->rowlb :
NULL,
6940 (consdata->rowub ==
NULL) ? &consdata->rowub :
NULL) );
6942 rowub = consdata->rowub;
6943 rowlb = consdata->rowlb;
6974 if ( rowlb !=
NULL )
6978 if ( rowub !=
NULL )
6984 if ( *
cutoff || ( maxboundcuts >= 0 && cnt >= maxboundcuts ) )
7023 if ( conshdlrdata->conflictgraph ==
NULL )
7027 implgraph = conshdlrdata->implgraph;
7030 if ( implgraph ==
NULL )
7040 implgraph = conshdlrdata->implgraph;
7047 nimplnodes = conshdlrdata->nimplnodes;
7113 for (
k = 0;
k < 2; ++
k)
7181 SCIP_Bool infeasible;
7259 if ( conshdlrdata->boundcutsfreq >= 0 &&
7260 ( (conshdlrdata->boundcutsfreq == 0 &&
depth == 0) || (conshdlrdata->boundcutsfreq > 0 &&
depth % conshdlrdata->boundcutsfreq == 0)) )
7267 maxboundcuts = conshdlrdata->maxboundcutsroot;
7269 maxboundcuts = conshdlrdata->maxboundcuts;
7271 if ( maxboundcuts >= 1 )
7274 if( conshdlrdata->boundcutsfromsos1 || conshdlrdata->switchcutsfromsos1 )
7287 if( conshdlrdata->boundcutsfromgraph && ! conshdlrdata->switchcutsfromsos1 )
7306 if ( conshdlrdata->implcutsfreq >= 0 &&
7307 ( (conshdlrdata->implcutsfreq == 0 &&
depth == 0) || (conshdlrdata->implcutsfreq > 0 &&
depth % conshdlrdata->implcutsfreq == 0)) )
7314 maximplcuts = conshdlrdata->maximplcutsroot;
7316 maximplcuts = conshdlrdata->maximplcuts;
7319 if ( maximplcuts >= 1 )
7367 for (
i = 0;
i < nsos1vars; ++
i)
7402 val =
MIN(1
e6, val);
7443 for (
j = 0;
j <
nsucc && !(*cutoff); ++
j)
7567 SCIP_Real* weights =
NULL;
7585 for (
i = 0;
i < nsos1vars; ++
i)
7593 for (
i = 0;
i < nsos1vars; ++
i)
7604 else if (
nsucc == 0 )
7626 for (
i = 0;
k < nsos1vars; ++
i)
7687 assert( nsos1vars >= 0 );
7698 for (
j = 0;
j < nsos1vars; ++
j)
7743 for (
j = 0;
j < nsos1vars; ++
j)
7765 for (
c = 0;
c < nconss; ++
c)
7771 for (
j = 0;
j < consdata->nvars; ++
j)
7825 SCIP_Real maxval = 0.0;
7835 nvars = consdata->nvars;
7836 vars = consdata->vars;
7889 else if ( pos >= 0 )
7898 for (
c = 0;
c < nconss; ++
c)
7906 for (
j = 0;
j < consdata->nvars; ++
j)
7957 for (v = 0; v < nsos1vars; ++v)
8044 for (s = 0; s <
nsucc; ++s)
8097 for (
c = 0;
c < nconss; ++
c)
8107 nvars = consdata->nvars;
8108 vars = consdata->vars;
8111 for (
j = 0;
j <
nvars && cnt < 2; ++
j)
8214 nvars = consdata->nvars;
8215 vars = consdata->vars;
8349 concomp[(*nconcomp)++] = node;
8382 for (s = 0; s <
nsucc; ++s)
8416 for (
j = 0;
j < nsos1vars; ++
j)
8420 for (
j = 0;
j < nsos1vars; ++
j)
8448 for (s = 0; s <
nsucc; ++s)
8497 for (
c = 0;
c < nlinconss; ++
c)
8572 if ( conshdlrdata->nsos1vars > 0 )
8589 nvars = consdata->nvars;
8590 vars = consdata->vars;
8622 if ( conshdlrdata->autosos1branch )
8624 conshdlrdata->switchsos1branch =
TRUE;
8625 SCIPdebugMsg(
scip,
"Switched to SOS1 branching, since the SOS1 constraints do not overlap\n");
8628 if ( conshdlrdata->autocutsfromsos1 )
8630 conshdlrdata->switchcutsfromsos1 =
TRUE;
8631 SCIPdebugMsg(
scip,
"Switched to separating bound cuts from SOS1 constraints (and not from the conflict graph), since the SOS1 constraints do not overlap\n");
8652 if ( nsos1vars == 0 )
8708 for (
c = 0;
c < nconss; ++
c)
8721 nvars = consdata->nvars;
8722 vars = consdata->vars;
8752 conshdlrdata->nsos1vars = 0;
8768 for (
c = 0;
c < nconss; ++
c)
8781 nvars = consdata->nvars;
8782 vars = consdata->vars;
8852 conshdlrdata->nsos1vars =
cntsos;
8859 for (
j = 0;
j < conshdlrdata->nsos1vars; ++
j)
8880 if ( conshdlrdata->conflictgraph ==
NULL )
8882 assert( conshdlrdata->nsos1vars == 0 );
8887 assert( conshdlrdata->nsos1vars > 0 );
8888 for (
j = 0;
j < conshdlrdata->nsos1vars; ++
j)
8893 assert( conshdlrdata->conflictgraph !=
NULL );
8906 conshdlrdata->nsos1vars = 0;
8909 assert( conshdlrdata->conflictgraph ==
NULL );
8969 conshdlrdata->nsos1vars = 0;
8970 conshdlrdata->varhash =
NULL;
8980 if ( ( conshdlrdata->autosos1branch || conshdlrdata->autocutsfromsos1 )
8981 && ( ! conshdlrdata->switchsos1branch || ! conshdlrdata->switchcutsfromsos1 )
8992 if ( conshdlrdata->addcomps )
8998 if ( conshdlrdata->fixnonzerovars ==
NULL )
9000 conshdlrdata->maxnfixnonzerovars = conshdlrdata->nsos1vars;
9023 for (
c = 0;
c < nconss; ++
c)
9035 if ( consdata->rowub !=
NULL )
9040 if ( consdata->rowlb !=
NULL )
9047 if ( conshdlrdata->implgraph !=
NULL )
9054 if ( conshdlrdata->tcliquegraph !=
NULL )
9065 conshdlrdata->nfixnonzerovars = 0;
9066 conshdlrdata->maxnfixnonzerovars = 0;
9069 if ( conshdlrdata->localconflicts !=
NULL )
9071 assert( conshdlrdata->localconflicts ==
NULL );
9075 assert( conshdlrdata->conflictgraph ==
NULL );
9104 for (
j = 0;
j < (*consdata)->nvars; ++
j)
9112 if ( (*consdata)->weights !=
NULL )
9118 if ( (*consdata)->rowub !=
NULL )
9122 if ( (*consdata)->rowlb !=
NULL )
9165 if ( conshdlrdata->fixnonzerovars ==
NULL )
9176 consdata->rowub =
NULL;
9177 consdata->rowlb =
NULL;
9178 consdata->nfixednonzeros = 0;
9189 consdata->weights =
NULL;
9198 ++(consdata->nfixednonzeros);
9211 for (
j = 0;
j < consdata->nvars; ++
j)
9218 if ( consdata->nfixednonzeros > 0 )
9221 consdata->nfixednonzeros );
9275 conflictgraph = conshdlrdata->conflictgraph;
9276 nsos1vars = conshdlrdata->nsos1vars;
9277 if ( nsos1vars < 2 )
9288 for (
i = 0;
i < nsos1vars; ++
i)
9294 for (
i = 0;
i < nsos1vars; ++
i)
9296 for (
j = 0;
j <
i+1; ++
j)
9299 for (
i = 0;
i < nsos1vars; ++
i)
9316 SCIPdebugMsg(
scip,
"Adjacency matrix was not created since number of SOS1 variables (%d) is larger than %d.\n", nsos1vars, conshdlrdata->maxsosadjacency);
9320 SCIP_CALL(
presolRoundConssSOS1(
scip, eventhdlr, conshdlrdata, conflictgraph,
adjacencymatrix, conss, nconss, nsos1vars, naddconss, ndelconss, nupgdconss, nfixedvars, &
nremovedvars,
result) );
9331 for (
j = nsos1vars-1;
j >= 0; --
j)
9341 SCIPdebug(
SCIPdebugMsg(
scip,
"presolving fixed %d variables, changed %d bounds, removed %d variables, deleted %d constraints, and upgraded %d constraints.\n",
9361 *infeasible =
FALSE;
9364 if( conshdlrdata->boundcutsfromsos1 || conshdlrdata->switchcutsfromsos1 )
9484 for (
j = 0;
j < consdata->nvars; ++
j)
9508 for (
l = 0;
l < consdata->nvars; ++
l)
9557 conflictgraph = conshdlrdata->conflictgraph;
9560 implgraph = conshdlrdata->implgraph;
9561 if ( implgraph ==
NULL && conshdlrdata->implprop && conflictgraph !=
NULL )
9571 conshdlrdata->implprop =
FALSE;
9580 implgraph = conshdlrdata->implgraph;
9583 conshdlrdata->implprop =
FALSE;
9587 if ( conshdlrdata->conflictprop && conflictgraph !=
NULL )
9590 int nfixnonzerovars;
9596 nfixnonzerovars = conshdlrdata->nfixnonzerovars;
9597 fixnonzerovars = conshdlrdata->fixnonzerovars;
9601 for (
j = 0;
j < nfixnonzerovars; ++
j)
9605 var = fixnonzerovars[
j];
9633 conshdlrdata->nfixnonzerovars = 0;
9636 if ( conshdlrdata->sosconsprop || conflictgraph ==
NULL )
9641 for (
c = 0;
c < nconss; ++
c)
9691 if ( inferinfo < 0 )
9700 assert( conshdlrdata->conflictgraph !=
NULL );
9701 assert( inferinfo >= -conshdlrdata->maxnfixnonzerovars );
9702 assert( inferinfo >= -conshdlrdata->nsos1vars );
9703 assert( inferinfo <= -1 );
9716 var = consdata->vars[inferinfo];
9770 vars = consdata->vars;
9771 nvars = consdata->nvars;
9811 for (
j = 0;
j < consdata->nvars; ++
j)
9816 if ( consdata->weights ==
NULL )
9834 const char* consname;
9879 initial, separate, enforce, check,
propagate, local, dynamic, removable, stickingatnode) );
9909 SCIP_CALL(
SCIPcreateConsSOS1(
scip, cons, name, 0,
NULL,
NULL, initial, separate, enforce, check,
propagate, local, dynamic, removable, stickingatnode) );
10012 (*nvars) = consdata->nvars;
10034 SCIP_Real oldbound;
10035 SCIP_Real newbound;
10045 assert( 0 <= consdata->nfixednonzeros && consdata->nfixednonzeros <= consdata->nvars );
10051 switch ( eventtype )
10064 if ( conshdlrdata->nfixnonzerovars < conshdlrdata->maxnfixnonzerovars )
10066 assert( conshdlrdata->fixnonzerovars !=
NULL );
10071 ++(consdata->nfixednonzeros);
10086 if ( conshdlrdata->nfixnonzerovars < conshdlrdata->maxnfixnonzerovars )
10088 assert( conshdlrdata->fixnonzerovars !=
NULL );
10093 ++(consdata->nfixednonzeros);
10100 --(consdata->nfixednonzeros);
10106 --(consdata->nfixednonzeros);
10137 assert( 0 <= consdata->nfixednonzeros && consdata->nfixednonzeros <= consdata->nvars );
10140 oldbound, newbound, consdata->nfixednonzeros);
10159 *infeasible =
FALSE;
10173 if ( conshdlrdata->switchsos1branch )
10198 conshdlrdata->branchsos =
TRUE;
10199 conshdlrdata->switchsos1branch =
FALSE;
10200 conshdlrdata->switchcutsfromsos1 =
FALSE;
10201 conshdlrdata->eventhdlr =
NULL;
10202 conshdlrdata->fixnonzerovars =
NULL;
10203 conshdlrdata->maxnfixnonzerovars = 0;
10204 conshdlrdata->nfixnonzerovars = 0;
10205 conshdlrdata->conflictgraph =
NULL;
10206 conshdlrdata->localconflicts =
NULL;
10207 conshdlrdata->isconflocal =
FALSE;
10208 conshdlrdata->implgraph =
NULL;
10209 conshdlrdata->nimplnodes = 0;
10210 conshdlrdata->nboundcuts = 0;
10211 conshdlrdata->tcliquegraph =
NULL;
10212 conshdlrdata->tcliquedata =
NULL;
10213 conshdlrdata->cntextsos1 = -1;
10214 conshdlrdata->varhash =
NULL;
10218 if ( conshdlrdata->eventhdlr ==
NULL )
10253 "do not create an adjacency matrix if number of SOS1 variables is larger than predefined value (-1: no limit)",
10258 "maximal number of extensions that will be computed for each SOS1 constraint (-1: no limit)",
10262 "maximal number of bound tightening rounds per presolving round (-1: no limit)",
10266 "if TRUE then perform implication graph analysis (might add additional SOS1 constraints)",
10270 "number of recursive calls of implication graph analysis (-1: no limit)",
10275 "whether to use conflict graph propagation",
10279 "whether to use implication graph propagation",
10283 "whether to use SOS1 constraint propagation",
10288 "which branching rule should be applied ? ('n': neighborhood, 'b': bipartite, 's': SOS1/clique) (note: in some cases an automatic switching to SOS1 branching is possible)",
10292 "if TRUE then automatically switch to SOS1 branching if the SOS1 constraints do not overlap",
10296 "if neighborhood branching is used, then fix the branching variable (if positive in sign) to the value of the feasibility tolerance",
10300 "if TRUE then add complementarity constraints to the branching nodes (can be used in combination with neighborhood or bipartite branching)",
10304 "maximal number of complementarity constraints added per branching node (-1: no limit)",
10308 "minimal feasibility value for complementarity constraints in order to be added to the branching node",
10312 "minimal feasibility value for bound inequalities in order to be added to the branching node",
10316 "should added complementarity constraints be extended to SOS1 constraints to get tighter bound inequalities",
10320 "Use SOS1 branching in enforcing (otherwise leave decision to branching rules)? This value can only be set to false if all SOS1 variables are binary",
10324 "Branch on SOS constraint with most number of nonzeros?",
10328 "Branch on SOS cons. with highest nonzero-variable weight for branching (needs branchnonzeros = false)?",
10332 "only add complementarity constraints to branching nodes for predefined depth (-1: no limit)",
10337 "maximal number of strong branching rounds to perform for each node (-1: auto); only available for neighborhood and bipartite branching",
10341 "maximal number LP iterations to perform for each strong branching round (-2: auto, -1: no limit)",
10346 "if TRUE separate bound inequalities from initial SOS1 constraints",
10350 "if TRUE separate bound inequalities from the conflict graph",
10354 "if TRUE then automatically switch to separating initial SOS1 constraints if the SOS1 constraints do not overlap",
10358 "frequency for separating bound cuts; zero means to separate only in the root node",
10362 "node depth of separating bound cuts (-1: no limit)",
10366 "maximal number of bound cuts separated per branching node",
10370 "maximal number of bound cuts separated per iteration in the root node",
10374 "if TRUE then bound cuts are strengthened in case bound variables are available",
10378 "frequency for separating implied bound cuts; zero means to separate only in the root node",
10382 "node depth of separating implied bound cuts (-1: no limit)",
10386 "maximal number of implied bound cuts separated per branching node",
10390 "maximal number of implied bound cuts separated per iteration in the root node",
10410 SCIP_Real* weights,
10413 SCIP_Bool separate,
10426 SCIP_Bool removable,
10428 SCIP_Bool stickingatnode
10435 SCIP_Bool modifiable;
10436 SCIP_Bool transformed;
10439 modifiable =
FALSE;
10443 if ( conshdlr ==
NULL )
10454 consdata->vars =
NULL;
10455 consdata->nvars =
nvars;
10456 consdata->maxvars =
nvars;
10457 consdata->rowub =
NULL;
10458 consdata->rowlb =
NULL;
10459 consdata->nfixednonzeros = transformed ? 0 : -1;
10460 consdata->weights =
NULL;
10461 consdata->local = local;
10468 if ( weights !=
NULL )
10483 for (v = 0; v <
nvars; ++v)
10489 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
10490 local, modifiable, dynamic, removable, stickingatnode) );
10494 for (v =
nvars - 1; v >= 0; --v)
10534 SCIP_CALL(
SCIPcreateConsSOS1(
scip, cons, name,
nvars,
vars, weights,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
FALSE,
FALSE,
FALSE,
FALSE) );
10628 return consdata->nvars;
10653 return consdata->vars;
10678 return consdata->weights;
10703 return conshdlrdata->conflictgraph;
10725 return conshdlrdata->nsos1vars;
10773 if ( conshdlrdata->varhash ==
NULL )
10814 SCIP_Bool* changed,
10850 if ( conshdlrdata->switchsos1branch )
struct SCIP_NodeData SCIP_NODEDATA
static SCIP_RETCODE branchCons(SCIP *scip, SCIP_CONS *cons, SCIP_RESULT *result)
Constraint handler for linear constraints in their most general form, .
Constraint handler for the set partitioning / packing / covering constraints .
#define DEFAULT_MAXSOSADJACENCY
static SCIP_RETCODE lockVariableSOS1(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
#define DEFAULT_AUTOCUTSFROMSOS1
#define DEFAULT_MAXADDCOMPS
static SCIP_Bool isImpliedZero(SCIP_DIGRAPH *conflictgraph, SCIP_Bool *implnodes, int node)
#define CONSHDLR_NEEDSCONS
#define CONSHDLR_SEPAFREQ
static SCIP_RETCODE getDiveBdChgsSOS1constraints(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DIVESET *diveset, SCIP_SOL *sol, SCIP_Bool *success)
#define DEFAULT_BRANCHINGRULE
static SCIP_RETCODE updateWeightsTCliquegraph(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, TCLIQUE_DATA *tcliquedata, SCIP_DIGRAPH *conflictgraph, SCIP_SOL *sol, int nsos1vars)
static SCIP_RETCODE initTCliquegraph(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_DIGRAPH *conflictgraph, int nsos1vars)
#define DEFAULT_NSTRONGROUNDS
static SCIP_RETCODE consdataEnsurevarsSizeSOS1(SCIP *scip, SCIP_CONSDATA *consdata, int num, SCIP_Bool reserveWeights)
#define CONSHDLR_CHECKPRIORITY
#define DEFAULT_MAXBOUNDCUTS
#define DEFAULT_MAXBOUNDCUTSROOT
static SCIP_RETCODE getBranchingDecisionStrongbranchSOS1(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_DIGRAPH *conflictgraph, SCIP_SOL *sol, int nsos1vars, SCIP_Real lpobjval, SCIP_Bool bipbranch, int nstrongrounds, SCIP_Bool *verticesarefixed, int *fixingsnode1, int *fixingsnode2, int *vertexbestprior, SCIP_Real *bestobjval1, SCIP_Real *bestobjval2, SCIP_RESULT *result)
static SCIP_RETCODE appendVarSOS1(SCIP *scip, SCIP_CONS *cons, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_VAR *var)
static SCIP_RETCODE computeNodeDataSOS1(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, int nsos1vars)
#define DIVINGCUTOFFVALUE
static SCIP_RETCODE maxWeightIndSetHeuristic(SCIP *scip, SCIP_SOL *sol, SCIP_CONSHDLR *conshdlr, SCIP_DIGRAPH *conflictgraph, int nsos1vars, SCIP_Bool *indicatorzero, SCIP_Bool *indset)
#define CONSHDLR_PROP_TIMING
static SCIP_Bool varIsSOS1(SCIP_CONSHDLRDATA *conshdlrdata, SCIP_VAR *var)
#define DEFAULT_AUTOSOS1BRANCH
#define DEFAULT_ADDEXTENDEDBDS
#define DEFAULT_MAXTIGHTENBDS
static SCIP_RETCODE tightenVarsBoundsSOS1(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_DIGRAPH *conflictgraph, SCIP_DIGRAPH *implgraph, SCIP_HASHMAP *implhash, SCIP_Bool **adjacencymatrix, SCIP_VAR **totalvars, int ntotalvars, int nsos1vars, int *nchgbds, SCIP_Bool *implupdate, SCIP_Bool *cutoff)
static SCIP_Real nodeGetSolvalVarboundUbSOS1(SCIP *scip, SCIP_DIGRAPH *conflictgraph, SCIP_SOL *sol, int node)
static SCIP_RETCODE handleNewVariableSOS1(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_VAR *var, SCIP_Bool transformed)
#define DEFAULT_BOUNDCUTSDEPTH
#define DEFAULT_DEPTHIMPLANALYSIS
#define CONSHDLR_MAXPREROUNDS
static SCIP_RETCODE getVectorOfWeights(SCIP *scip, SCIP_SOL *sol, SCIP_DIGRAPH *conflictgraph, int nsos1vars, SCIP_Bool *indicatorzero, SCIP_Real *weights)
static SCIP_RETCODE getCoverVertices(SCIP_DIGRAPH *conflictgraph, SCIP_Bool *verticesarefixed, int vertex, int *neightocover, int nneightocover, int *coververtices, int *ncoververtices)
static SCIP_RETCODE getBoundConsFromVertices(SCIP *scip, SCIP_DIGRAPH *conflictgraph, SCIP_SOL *sol, int v1, int v2, SCIP_VAR *boundvar, SCIP_Bool extend, SCIP_CONS *cons, SCIP_Real *feas)
static SCIP_RETCODE updateImplicationGraphSOS1(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_DIGRAPH *conflictgraph, SCIP_Bool **adjacencymatrix, SCIP_DIGRAPH *implgraph, SCIP_HASHMAP *implhash, SCIP_Bool *implnodes, SCIP_VAR **totalvars, int **cliquecovers, int *cliquecoversizes, int *varincover, SCIP_VAR **vars, SCIP_Real *coefs, int nvars, SCIP_Real *bounds, SCIP_VAR *var, SCIP_Real bound, SCIP_Real boundnonzero, int ninftynonzero, SCIP_Bool lower, int *nchgbds, SCIP_Bool *update, SCIP_Bool *infeasible)
static SCIP_RETCODE checkSwitchNonoverlappingSOS1Methods(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_DIGRAPH *conflictgraph, SCIP_CONS **conss, int nconss)
static SCIP_RETCODE enforceConflictgraph(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_CONSHDLR *conshdlr, int nconss, SCIP_CONS **conss, SCIP_SOL *sol, SCIP_RESULT *result)
static SCIP_RETCODE makeSOS1conflictgraphFeasible(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_SOL *sol, SCIP_Bool *changed, SCIP_Bool *allroundable)
static SCIP_RETCODE getDiveBdChgsSOS1conflictgraph(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DIVESET *diveset, SCIP_SOL *sol, SCIP_Bool *success)
#define CONSHDLR_SEPAPRIORITY
static SCIP_RETCODE sepaImplBoundCutsSOS1(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_SOL *sol, int maxcuts, int *ngen, SCIP_Bool *cutoff)
static int varGetNodeSOS1(SCIP_CONSHDLRDATA *conshdlrdata, SCIP_VAR *var)
#define DEFAULT_STRTHENBOUNDCUTS
static SCIP_RETCODE passConComponentVarbound(SCIP *scip, SCIP_DIGRAPH *conflictgraph, int node, SCIP_VAR *boundvar, SCIP_Bool checklb, SCIP_Bool *processed, int *concomp, int *nconcomp, SCIP_Bool *unique)
#define DEFAULT_BRANCHSTRATEGIES
static SCIP_RETCODE detectVarboundSOS1(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_VAR *var0, SCIP_VAR *var1, SCIP_Real val0, SCIP_Real val1)
static SCIP_Bool isViolatedSOS1(SCIP *scip, SCIP_DIGRAPH *conflictgraph, int node, SCIP_SOL *sol)
#define DEFAULT_SOSCONSPROP
static SCIP_RETCODE propVariableNonzero(SCIP *scip, SCIP_DIGRAPH *conflictgraph, SCIP_DIGRAPH *implgraph, SCIP_CONS *cons, int node, SCIP_Bool implprop, SCIP_Bool *cutoff, int *ngen)
static SCIP_RETCODE presolRoundConsSOS1(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool *substituted, SCIP_Bool *cutoff, SCIP_Bool *success, int *ndelconss, int *nupgdconss, int *nfixedvars, int *nremovedvars)
static SCIP_RETCODE checkLinearConssVarboundSOS1(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_CONS **linconss, int nlinconss)
#define DEFAULT_MAXEXTENSIONS
#define DEFAULT_FIXNONZERO
static SCIP_RETCODE fixVariableZeroNode(SCIP *scip, SCIP_VAR *var, SCIP_NODE *node, SCIP_Bool *infeasible)
static SCIP_RETCODE makeSOS1constraintsFeasible(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_SOL *sol, SCIP_Bool *changed, SCIP_Bool *allroundable)
static SCIP_RETCODE freeConflictgraph(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata)
#define DEFAULT_ADDCOMPSFEAS
static SCIP_RETCODE updateArcData(SCIP *scip, SCIP_DIGRAPH *implgraph, SCIP_HASHMAP *implhash, SCIP_VAR **totalvars, SCIP_VAR *varv, SCIP_VAR *varw, SCIP_Real lb, SCIP_Real ub, SCIP_Real newbound, SCIP_Bool lower, int *nchgbds, SCIP_Bool *update, SCIP_Bool *infeasible)
#define DEFAULT_MAXIMPLCUTS
static SCIP_RETCODE inferVariableZero(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened, SCIP_Bool *success)
#define DEFAULT_BOUNDCUTSFROMSOS1
static SCIP_RETCODE getBranchingVerticesSOS1(SCIP *scip, SCIP_DIGRAPH *conflictgraph, SCIP_SOL *sol, SCIP_Bool *verticesarefixed, SCIP_Bool bipbranch, int branchvertex, int *fixingsnode1, int *nfixingsnode1, int *fixingsnode2, int *nfixingsnode2)
#define DEFAULT_ADDCOMPSDEPTH
static SCIP_RETCODE getBranchingPrioritiesSOS1(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_DIGRAPH *conflictgraph, SCIP_SOL *sol, int nsos1vars, SCIP_Bool *verticesarefixed, SCIP_Bool bipbranch, int *fixingsnode1, int *fixingsnode2, SCIP_Real *branchpriors, int *vertexbestprior, SCIP_Bool *relsolfeas)
static SCIP_RETCODE genConflictgraphLinearCons(SCIP_CONSHDLRDATA *conshdlrdata, SCIP_DIGRAPH *conflictgraphlin, SCIP_DIGRAPH *conflictgraphorig, SCIP_VAR **linvars, int nlinvars, int *posinlinvars)
static SCIP_RETCODE fixVariableZero(SCIP *scip, SCIP_VAR *var, SCIP_Bool *infeasible, SCIP_Bool *tightened)
static SCIP_Real nodeGetSolvalBinaryBigMSOS1(SCIP *scip, SCIP_DIGRAPH *conflictgraph, SCIP_SOL *sol, int node)
static SCIP_RETCODE initConflictgraph(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_CONS **conss, int nconss)
static SCIP_RETCODE initsepaBoundInequalityFromSOS1Cons(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_CONS **conss, int nconss, SCIP_SOL *sol, SCIP_Bool solvedinitlp, int maxboundcuts, int *ngen, SCIP_Bool *cutoff)
static SCIP_RETCODE generateBoundInequalityFromSOS1Nodes(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DIGRAPH *conflictgraph, int *nodes, int nnodes, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool global, SCIP_Bool strengthen, SCIP_Bool removable, const char *nameext, SCIP_ROW **rowlb, SCIP_ROW **rowub)
#define DEFAULT_NSTRONGITER
static SCIP_RETCODE enforceSOS1(SCIP *scip, SCIP_CONSHDLR *conshdlr, int nconss, SCIP_CONS **conss, SCIP_SOL *sol, SCIP_RESULT *result)
#define DEFAULT_BOUNDCUTSFREQ
static SCIP_RETCODE computeVarsCoverSOS1(SCIP *scip, SCIP_DIGRAPH *conflictgraphroot, SCIP_DIGRAPH *conflictgraphlin, SCIP_VAR **linvars, SCIP_Bool *coveredvars, int *clique, int *cliquesize, int v, SCIP_Bool considersolvals)
static SCIP_RETCODE enforceConssSOS1(SCIP *scip, SCIP_CONSHDLR *conshdlr, int nconss, SCIP_CONS **conss, SCIP_SOL *sol, SCIP_RESULT *result)
static SCIP_RETCODE checkConComponentsVarbound(SCIP *scip, SCIP_DIGRAPH *conflictgraph, int nsos1vars, SCIP_Bool checklb)
static SCIP_RETCODE unlockVariableSOS1(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
static SCIP_Bool isConnectedSOS1(SCIP_Bool **adjacencymatrix, SCIP_DIGRAPH *conflictgraph, int vertex1, int vertex2)
#define DEFAULT_BOUNDCUTSFROMGRAPH
static SCIP_RETCODE addBranchingComplementaritiesSOS1(SCIP *scip, SCIP_NODE *node, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_DIGRAPH *conflictgraph, SCIP_DIGRAPH *localconflicts, SCIP_SOL *sol, int nsos1vars, SCIP_Bool *verticesarefixed, int *fixingsnode1, int nfixingsnode1, int *fixingsnode2, int nfixingsnode2, int *naddedconss, SCIP_Bool onlyviolsos1)
#define CONSHDLR_PROPFREQ
static SCIP_RETCODE performStrongbranchSOS1(SCIP *scip, SCIP_DIGRAPH *conflictgraph, int *fixingsexec, int nfixingsexec, int *fixingsop, int nfixingsop, int inititer, SCIP_Bool fixnonzero, int *domainfixings, int *ndomainfixings, SCIP_Bool *infeasible, SCIP_Real *objval, SCIP_Bool *lperror)
#define DEFAULT_ADDBDSFEAS
static SCIP_RETCODE generateBoundInequalityFromSOS1Cons(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_Bool local, SCIP_Bool global, SCIP_Bool strengthen, SCIP_Bool removable, SCIP_ROW **rowlb, SCIP_ROW **rowub)
static SCIP_RETCODE getSOS1Implications(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_VAR **vars, SCIP_DIGRAPH *implgraph, SCIP_HASHMAP *implhash, SCIP_Bool *implnodes, int node)
static SCIP_RETCODE addVarSOS1(SCIP *scip, SCIP_CONS *cons, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_VAR *var, SCIP_Real weight)
static SCIP_RETCODE freeImplGraphSOS1(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata)
#define CONSHDLR_PRESOLTIMING
#define DEFAULT_IMPLCUTSDEPTH
#define DEFAULT_CONFLICTPROP
#define DEFAULT_MAXIMPLCUTSROOT
#define DEFAULT_IMPLCUTSFREQ
struct SCIP_SuccData SCIP_SUCCDATA
static SCIP_RETCODE presolRoundConssSOS1(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_DIGRAPH *conflictgraph, SCIP_Bool **adjacencymatrix, SCIP_CONS **conss, int nconss, int nsos1vars, int *naddconss, int *ndelconss, int *nupgdconss, int *nfixedvars, int *nremovedvars, SCIP_RESULT *result)
static SCIP_RETCODE resetConflictgraphSOS1(SCIP_DIGRAPH *conflictgraph, SCIP_DIGRAPH *localconflicts, int nsos1vars)
#define CONSHDLR_EAGERFREQ
static SCIP_RETCODE initImplGraphSOS1(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_DIGRAPH *conflictgraph, int nsos1vars, int maxrounds, int *nchgbds, SCIP_Bool *cutoff, SCIP_Bool *success)
#define EVENTHDLR_EVENT_TYPE
#define CONSHDLR_ENFOPRIORITY
#define DEFAULT_PERFIMPLANALYSIS
static SCIP_RETCODE markNeighborsMWISHeuristic(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DIGRAPH *conflictgraph, int node, SCIP_Bool *mark, SCIP_Bool *indset, int *cnt, SCIP_Bool *cutoff)
#define CONSHDLR_DELAYSEPA
static SCIP_RETCODE presolRoundVarsSOS1(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_DIGRAPH *conflictgraph, SCIP_Bool **adjacencymatrix, int nsos1vars, int *nfixedvars, int *nchgbds, int *naddconss, SCIP_RESULT *result)
static SCIP_RETCODE sepaBoundInequalitiesFromGraph(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_SOL *sol, int maxboundcuts, int *ngen, SCIP_Bool *cutoff)
static SCIP_RETCODE addBoundCutSepa(SCIP *scip, TCLIQUE_DATA *tcliquedata, SCIP_ROW *rowlb, SCIP_ROW *rowub, SCIP_Bool *success, SCIP_Bool *cutoff)
static SCIP_RETCODE propConsSOS1(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_Bool *cutoff, int *ngen)
static SCIP_RETCODE extensionOperatorSOS1(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_Bool **adjacencymatrix, SCIP_DIGRAPH *vertexcliquegraph, int nsos1vars, int nconss, SCIP_CONS *cons, SCIP_VAR **vars, SCIP_Real *weights, SCIP_Bool firstcall, SCIP_Bool usebacktrack, int **cliques, int *ncliques, int *cliquesizes, int *newclique, int *workingset, int nworkingset, int nexts, int pos, int *maxextensions, int *naddconss, SCIP_Bool *success)
static SCIP_RETCODE deleteVarSOS1(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr, int pos)
static SCIP_RETCODE performImplicationGraphAnalysis(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_DIGRAPH *conflictgraph, SCIP_VAR **totalvars, SCIP_DIGRAPH *implgraph, SCIP_HASHMAP *implhash, SCIP_Bool **adjacencymatrix, int givennode, int nonznode, SCIP_Real *impllbs, SCIP_Real *implubs, SCIP_Bool *implnodes, int *naddconss, int *probingdepth, SCIP_Bool *infeasible)
#define CONSHDLR_DELAYPROP
static SCIP_Real nodeGetSolvalVarboundLbSOS1(SCIP *scip, SCIP_DIGRAPH *conflictgraph, SCIP_SOL *sol, int node)
static SCIP_RETCODE cliqueGetCommonSuccessorsSOS1(SCIP_CONSHDLRDATA *conshdlrdata, SCIP_DIGRAPH *conflictgraph, int *clique, SCIP_VAR **vars, int nvars, int *comsucc, int *ncomsucc)
static SCIP_RETCODE separateSOS1(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_SOL *sol, int nconss, SCIP_CONS **conss, SCIP_RESULT *result)
constraint handler for SOS type 1 constraints
#define SCIP_MAXTREEDEPTH
static const NodeData nodedata[]
void SCIPcomputeArraysSetminusInt(int *array1, int narray1, int *array2, int narray2, int *setminusarray, int *nsetminusarray)
void SCIPcomputeArraysIntersectionInt(int *array1, int narray1, int *array2, int narray2, int *intersectarray, int *nintersectarray)
SCIP_Real SCIPgetRhsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_DIGRAPH * SCIPgetConflictgraphSOS1(SCIP_CONSHDLR *conshdlr)
SCIP_VAR ** SCIPgetVarsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPvarIsSOS1(SCIP_CONSHDLR *conshdlr, SCIP_VAR *var)
SCIP_RETCODE SCIPaddCoefLinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPmakeSOS1sFeasible(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_SOL *sol, SCIP_Bool *changed, SCIP_Bool *success)
SCIP_Real SCIPgetLhsLinear(SCIP *scip, SCIP_CONS *cons)
int SCIPgetNVarsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPaddVarSOS1(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real weight)
SCIP_Real * SCIPgetValsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsSOS1(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, 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 SCIPcreateConsBasicSOS1(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *weights)
SCIP_RETCODE SCIPcreateConsSetpack(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, 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_Real * SCIPgetWeightsSOS1(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPappendVarSOS1(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
int SCIPgetNSOS1Vars(SCIP_CONSHDLR *conshdlr)
int SCIPvarGetNodeSOS1(SCIP_CONSHDLR *conshdlr, SCIP_VAR *var)
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 ** SCIPgetVarsSOS1(SCIP *scip, SCIP_CONS *cons)
int SCIPgetNVarsSOS1(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR * SCIPnodeGetVarSOS1(SCIP_DIGRAPH *conflictgraph, int node)
SCIP_RETCODE SCIPincludeConshdlrSOS1(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)
void ** SCIPdigraphGetSuccessorsData(SCIP_DIGRAPH *digraph, int node)
int SCIPdigraphGetNSuccessors(SCIP_DIGRAPH *digraph, int node)
int SCIPdigraphGetNNodes(SCIP_DIGRAPH *digraph)
SCIP_RETCODE SCIPdigraphAddArc(SCIP_DIGRAPH *digraph, int startnode, int endnode, void *data)
SCIP_RETCODE SCIPdigraphAddArcSafe(SCIP_DIGRAPH *digraph, int startnode, int endnode, void *data)
void SCIPdigraphFree(SCIP_DIGRAPH **digraph)
int SCIPdigraphGetNArcs(SCIP_DIGRAPH *digraph)
void * SCIPdigraphGetNodeData(SCIP_DIGRAPH *digraph, int node)
void SCIPdigraphSetNodeData(SCIP_DIGRAPH *digraph, void *dataptr, int node)
SCIP_RETCODE SCIPdigraphSetNSuccessors(SCIP_DIGRAPH *digraph, int node, int nsuccessors)
int * SCIPdigraphGetSuccessors(SCIP_DIGRAPH *digraph, int node)
SCIP_RETCODE SCIPcreateDigraph(SCIP *scip, SCIP_DIGRAPH **digraph, int nnodes)
SCIP_Bool SCIPisTransformed(SCIP *scip)
SCIP_Bool SCIPisStopped(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
int SCIPgetNVars(SCIP *scip)
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR ** SCIPgetVars(SCIP *scip)
SCIP_OBJSENSE SCIPgetObjsense(SCIP *scip)
int SCIPgetNTotalVars(SCIP *scip)
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
int SCIPhashmapGetImageInt(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)
SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPhashmapInsertInt(SCIP_HASHMAP *hashmap, void *origin, int image)
SCIP_RETCODE SCIPupdateNodeLowerbound(SCIP *scip, SCIP_NODE *node, SCIP_Real newbound)
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 SCIPaddCharParam(SCIP *scip, const char *name, const char *desc, char *valueptr, SCIP_Bool isadvanced, char defaultvalue, const char *allowedvalues, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
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)
void SCIPswapInts(int *value1, int *value2)
void SCIPswapReals(SCIP_Real *value1, SCIP_Real *value2)
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 SCIPaddConflictLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
SCIP_RETCODE SCIPaddConflictUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
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 SCIPsetConshdlrGetDiveBdChgs(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrParse(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrGetVars(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrPrint(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
int SCIPconshdlrGetNConss(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_RETCODE SCIPsetConshdlrInitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONSHDLRDATA * SCIPconshdlrGetData(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrTrans(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrResprop(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrExitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONS ** SCIPconshdlrGetConss(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_Bool SCIPisEfficacious(SCIP *scip, SCIP_Real efficacy)
SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)
SCIP_Bool SCIPdivesetSupportsType(SCIP_DIVESET *diveset, SCIP_DIVETYPE divetype)
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)
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
SCIP_Real SCIPgetLPObjval(SCIP *scip)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
int SCIPcalcMemGrowSize(SCIP *scip, int num)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPreallocBufferArray(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 SCIPfreeBlockMemoryArrayNull(scip, ptr, num)
#define SCIPfreeBufferArrayNull(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)
SCIP_Longint SCIPnodeGetNumber(SCIP_NODE *node)
SCIP_RETCODE SCIPgetDivesetScore(SCIP *scip, SCIP_DIVESET *diveset, SCIP_DIVETYPE divetype, SCIP_VAR *divecand, SCIP_Real divecandsol, SCIP_Real divecandfrac, SCIP_Real *candscore, SCIP_Bool *roundup)
SCIP_RETCODE SCIPchgVarUbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPchgVarLbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPpropagateProbing(SCIP *scip, int maxproprounds, SCIP_Bool *cutoff, SCIP_Longint *ndomredsfound)
SCIP_RETCODE SCIPstartProbing(SCIP *scip)
SCIP_RETCODE SCIPaddDiveBoundChange(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Bool preferred)
SCIP_RETCODE SCIPsolveProbingLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
SCIP_RETCODE SCIPfixVarProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval)
SCIP_RETCODE SCIPcacheRowExtensions(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPflushRowExtensions(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPcreateEmptyRowConshdlr(SCIP *scip, SCIP_ROW **row, SCIP_CONSHDLR *conshdlr, 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)
void SCIPupdateSolConsViolation(SCIP *scip, SCIP_SOL *sol, SCIP_Real absviol, SCIP_Real relviol)
SCIP_Real SCIPgetSolOrigObj(SCIP *scip, SCIP_SOL *sol)
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_Real SCIPgetUpperbound(SCIP *scip)
SCIP_Longint SCIPgetNNodes(SCIP *scip)
SCIP_Longint SCIPgetNNodeInitLPs(SCIP *scip)
SCIP_Longint SCIPgetNDualResolveLPIterations(SCIP *scip)
SCIP_Longint SCIPgetNNodeInitLPIterations(SCIP *scip)
SCIP_Longint SCIPgetNDualResolveLPs(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 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_Real SCIPfeastol(SCIP *scip)
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPceil(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_Real SCIPsumepsilon(SCIP *scip)
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasPositive(SCIP *scip, SCIP_Real val)
int SCIPgetDepth(SCIP *scip)
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
SCIP_RETCODE SCIPgetProbvarLinearSum(SCIP *scip, SCIP_VAR **vars, SCIP_Real *scalars, int *nvars, int varssize, SCIP_Real *constant, int *requiredsize, SCIP_Bool mergemultiples)
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_Real SCIPvarGetNegationConstant(SCIP_VAR *var)
SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
SCIP_Bool SCIPvarMayRoundUp(SCIP_VAR *var)
SCIP_Real SCIPvarGetMultaggrConstant(SCIP_VAR *var)
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
SCIP_Real SCIPvarGetAggrConstant(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)
SCIP_RETCODE SCIPinferVarUbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_Bool SCIPvarMayRoundDown(SCIP_VAR *var)
SCIP_RETCODE SCIPchgVarUbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
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)
int SCIPvarGetIndex(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)
SCIP_Real SCIPgetVarUbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_Bool SCIPvarIsIntegral(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_VAR * SCIPvarGetNegationVar(SCIP_VAR *var)
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 SCIPinferVarLbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_Real SCIPgetVarLbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
int SCIPvarCompare(SCIP_VAR *var1, SCIP_VAR *var2)
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)
SCIP_VAR * SCIPvarGetAggrVar(SCIP_VAR *var)
void SCIPsortDownIntInt(int *intarray1, int *intarray2, int len)
void SCIPsortRealPtr(SCIP_Real *realarray, void **ptrarray, int len)
void SCIPsortRealInt(SCIP_Real *realarray, int *intarray, int len)
void SCIPsortDownRealInt(SCIP_Real *realarray, int *intarray, int len)
void SCIPsortInt(int *intarray, int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIP_RETCODE SCIPskipSpace(char **s)
static SCIP_DIVESET * diveset
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 primal heuristics
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 branch and bound tree
public methods for problem variables
public methods for branching rule plugins and branching
public methods for conflict handler plugins and conflict analysis
public methods for constraint handler plugins and constraints
public methods for problem copies
public methods for cuts and aggregation rows
public methods for data structures
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 the probing mode
public methods for solutions
public methods for querying solving statistics
public methods for the branch-and-bound tree
public methods for SCIP variables
SCIP_Bool strthenboundcuts
SCIP_DIGRAPH * conflictgraph
void tcliqueChangeWeight(TCLIQUE_GRAPH *tcliquegraph, int node, TCLIQUE_WEIGHT weight)
void tcliqueFree(TCLIQUE_GRAPH **tcliquegraph)
enum TCLIQUE_Status TCLIQUE_STATUS
void tcliqueMaxClique(TCLIQUE_GETNNODES((*getnnodes)), TCLIQUE_GETWEIGHTS((*getweights)), TCLIQUE_ISEDGE((*isedge)), TCLIQUE_SELECTADJNODES((*selectadjnodes)), TCLIQUE_GRAPH *tcliquegraph, TCLIQUE_NEWSOL((*newsol)), TCLIQUE_DATA *tcliquedata, int *maxcliquenodes, int *nmaxcliquenodes, TCLIQUE_WEIGHT *maxcliqueweight, TCLIQUE_WEIGHT maxfirstnodeweight, TCLIQUE_WEIGHT minweight, int maxntreenodes, int backtrackfreq, int maxnzeroextensions, int fixednode, int *ntreenodes, TCLIQUE_STATUS *status)
TCLIQUE_Bool tcliqueFlush(TCLIQUE_GRAPH *tcliquegraph)
struct TCLIQUE_Graph TCLIQUE_GRAPH
TCLIQUE_Bool tcliqueCreate(TCLIQUE_GRAPH **tcliquegraph)
TCLIQUE_Bool tcliqueAddNode(TCLIQUE_GRAPH *tcliquegraph, int node, TCLIQUE_WEIGHT weight)
#define TCLIQUE_NEWSOL(x)
TCLIQUE_Bool tcliqueAddEdge(TCLIQUE_GRAPH *tcliquegraph, int node1, int node2)
#define SCIP_DECL_CONSENFOLP(x)
#define SCIP_DECL_CONSDELETE(x)
#define SCIP_DECL_CONSGETVARS(x)
#define SCIP_DECL_CONSINITSOL(x)
#define SCIP_DECL_CONSPRINT(x)
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
#define SCIP_DECL_CONSSEPALP(x)
#define SCIP_DECL_CONSENFORELAX(x)
#define SCIP_DECL_CONSGETDIVEBDCHGS(x)
#define SCIP_DECL_CONSPROP(x)
#define SCIP_DECL_CONSGETNVARS(x)
#define SCIP_DECL_CONSRESPROP(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_GUBCHANGED
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
#define SCIP_EVENTTYPE_UBRELAXED
#define SCIP_DIVETYPE_SOS1VARIABLE
@ SCIP_BRANCHDIR_DOWNWARDS
enum SCIP_LPSolStat SCIP_LPSOLSTAT
@ SCIP_LPSOLSTAT_TIMELIMIT
@ SCIP_LPSOLSTAT_INFEASIBLE
@ SCIP_LPSOLSTAT_OBJLIMIT
@ SCIP_LPSOLSTAT_ITERLIMIT
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_VARSTATUS_MULTAGGR
@ SCIP_VARSTATUS_AGGREGATED
enum SCIP_Varstatus SCIP_VARSTATUS