120#define CONSHDLR_NAME "SOS1"
121#define CONSHDLR_DESC "SOS1 constraint handler"
122#define CONSHDLR_SEPAPRIORITY 1000
123#define CONSHDLR_ENFOPRIORITY 100
124#define CONSHDLR_CHECKPRIORITY -10
125#define CONSHDLR_SEPAFREQ 10
126#define CONSHDLR_PROPFREQ 1
127#define CONSHDLR_EAGERFREQ 100
129#define CONSHDLR_MAXPREROUNDS -1
130#define CONSHDLR_DELAYSEPA FALSE
131#define CONSHDLR_DELAYPROP FALSE
132#define CONSHDLR_NEEDSCONS TRUE
133#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP
134#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_MEDIUM
137#define DEFAULT_MAXSOSADJACENCY 10000
141#define DEFAULT_MAXEXTENSIONS 1
142#define DEFAULT_MAXTIGHTENBDS 5
143#define DEFAULT_PERFIMPLANALYSIS FALSE
144#define DEFAULT_DEPTHIMPLANALYSIS -1
147#define DEFAULT_CONFLICTPROP TRUE
148#define DEFAULT_IMPLPROP TRUE
149#define DEFAULT_SOSCONSPROP FALSE
152#define DEFAULT_BRANCHSTRATEGIES "nbs"
153#define DEFAULT_BRANCHINGRULE 'n'
155#define DEFAULT_AUTOSOS1BRANCH TRUE
156#define DEFAULT_FIXNONZERO FALSE
158#define DEFAULT_ADDCOMPS FALSE
160#define DEFAULT_MAXADDCOMPS -1
161#define DEFAULT_ADDCOMPSDEPTH 30
162#define DEFAULT_ADDCOMPSFEAS -0.6
163#define DEFAULT_ADDBDSFEAS 1.0
164#define DEFAULT_ADDEXTENDEDBDS TRUE
167#define DEFAULT_NSTRONGROUNDS 0
169#define DEFAULT_NSTRONGITER 10000
172#define DEFAULT_BOUNDCUTSFROMSOS1 FALSE
173#define DEFAULT_BOUNDCUTSFROMGRAPH TRUE
174#define DEFAULT_AUTOCUTSFROMSOS1 TRUE
175#define DEFAULT_BOUNDCUTSFREQ 10
176#define DEFAULT_BOUNDCUTSDEPTH 40
177#define DEFAULT_MAXBOUNDCUTS 50
178#define DEFAULT_MAXBOUNDCUTSROOT 150
179#define DEFAULT_STRTHENBOUNDCUTS TRUE
180#define DEFAULT_IMPLCUTSFREQ 0
181#define DEFAULT_IMPLCUTSDEPTH 40
182#define DEFAULT_MAXIMPLCUTS 50
183#define DEFAULT_MAXIMPLCUTSROOT 150
186#define EVENTHDLR_NAME "SOS1"
187#define EVENTHDLR_DESC "bound change event handler for SOS1 constraints"
189#define EVENTHDLR_EVENT_TYPE (SCIP_EVENTTYPE_BOUNDCHANGED | SCIP_EVENTTYPE_GBDCHANGED)
192#define DIVINGCUTOFFVALUE 1e6
215 SCIP_Real lbboundcoef;
216 SCIP_Real ubboundcoef;
217 SCIP_Bool lbboundcomp;
219 SCIP_Bool ubboundcomp;
251struct SCIP_ConshdlrData
256 SCIP_Bool isconflocal;
271 int maxnfixnonzerovars;
277 SCIP_Bool perfimplanalysis;
278 int depthimplanalysis;
280 SCIP_Bool conflictprop;
282 SCIP_Bool sosconsprop;
286 SCIP_Bool autosos1branch;
287 SCIP_Bool fixnonzero;
293 SCIP_Real addcompsfeas;
294 SCIP_Real addbdsfeas;
295 SCIP_Bool addextendedbds;
297 SCIP_Bool branchnonzeros;
298 SCIP_Bool branchweight;
299 SCIP_Bool switchsos1branch;
305 SCIP_Bool boundcutsfromsos1;
306 SCIP_Bool boundcutsfromgraph;
307 SCIP_Bool autocutsfromsos1;
308 SCIP_Bool switchcutsfromsos1;
312 int maxboundcutsroot;
314 SCIP_Bool strthenboundcuts;
418 for (s = 0; s <
nsucc; ++s)
580 SCIP_Bool* infeasible
603 SCIP_CALL(
SCIPcreateConsLinear(
scip, &cons,
"branch", 1, &
var, &val, 0.0, 0.0,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
634 SCIP_Bool* infeasible,
666 for (
i = 0;
i < naggrvars; ++
i)
679 for (
i = 0;
i < naggrvars; ++
i)
685 *tightened = *tightened ||
fixed;
710 SCIP_Bool* infeasible,
711 SCIP_Bool* tightened,
733 *tightened = *tightened ||
tighten;
737 *tightened = *tightened ||
tighten;
796 assert( consdata->nvars <= consdata->maxvars );
798 if ( num > consdata->maxvars )
822 SCIP_Bool transformed
844 assert( consdata->nfixednonzeros >= 0 );
846 ++consdata->nfixednonzeros;
868 conflictgraph = conshdlrdata->conflictgraph;
869 if ( conflictgraph ==
NULL )
881 SCIPdebugMsg(
scip,
"Switched to SOS1 branching rule, since conflict graph could be infeasible.\n");
882 conshdlrdata->switchsos1branch =
TRUE;
888 if ( ! consdata->local )
894 vars = consdata->vars;
895 nvars = consdata->nvars;
897 for (v = 0; v <
nvars; ++v)
938 SCIPdebugMsg(
scip,
"Switched to SOS1 branching rule, since conflict graph could be infeasible.\n");
939 conshdlrdata->switchsos1branch =
TRUE;
960 SCIP_Bool transformed;
971 if ( consdata->weights ==
NULL && consdata->maxvars > 0 )
990 assert( consdata->maxvars >= consdata->nvars+1 );
993 for (pos = 0; pos < consdata->nvars; ++pos)
995 if ( consdata->weights[pos] > weight )
1001 for (
j = consdata->nvars;
j > pos; --
j)
1003 consdata->vars[
j] = consdata->vars[
j-1];
1004 consdata->weights[
j] = consdata->weights[
j-1];
1008 consdata->vars[pos] =
var;
1009 consdata->weights[pos] = weight;
1029 SCIP_Bool transformed;
1037 assert( consdata->nvars >= 0 );
1050 if ( consdata->weights !=
NULL )
1060 consdata->vars[consdata->nvars] =
var;
1061 if ( consdata->weights !=
NULL )
1063 if ( consdata->nvars > 0 )
1064 consdata->weights[consdata->nvars] = consdata->weights[consdata->nvars-1] + 1.0;
1066 consdata->weights[consdata->nvars] = 0.0;
1098 for (
j = pos;
j < consdata->nvars-1; ++
j)
1100 consdata->vars[
j] = consdata->vars[
j+1];
1101 if ( consdata->weights !=
NULL )
1102 consdata->weights[
j] = consdata->weights[
j+1];
1269 assert( *ncliques <
MAX(1, conshdlrdata->maxextensions) * nconss );
1293 for (
j = 0;
j < consdata->nvars; ++
j)
1303 ++(conshdlrdata->cntextsos1);
1311 if ( *maxextensions <= 0 )
1322 SCIP_CALL(
extensionOperatorSOS1(
scip, conshdlrdata,
adjacencymatrix,
vertexcliquegraph, nsos1vars, nconss, cons,
vars, weights,
FALSE,
usebacktrack,
1323 cliques, ncliques,
cliquesizes,
newclique,
workingsetnew,
nworkingsetnew,
nextsnew, pos, maxextensions, naddconss,
success) );
1324 if ( *maxextensions <= 0 )
1341 SCIP_CALL(
extensionOperatorSOS1(
scip, conshdlrdata,
adjacencymatrix,
vertexcliquegraph, nsos1vars, nconss, cons,
vars, weights,
FALSE,
usebacktrack,
1342 cliques, ncliques,
cliquesizes,
newclique,
workingset,
nworkingset,
nextsnew, pos, maxextensions, naddconss,
success) );
1343 assert( *maxextensions <= 0 );
1401 for (v = 1; v < nlinvars; ++v)
1411 for (s = 0; s <
nsucc; ++s)
1475 if (
succ[
i] > clique[
j] )
1480 else if (
succ[
i] == clique[
j] )
1491 for (v = 1; v <
nvars; ++v)
1565 for (s = 0; s <
nsucc; ++s)
1615 SCIP_Bool infeasible;
1641 vars = consdata->vars;
1677 for (
l =
j+1;
l < consdata->nvars; ++
l)
1724 if ( consdata->nvars < 2 )
1737 if ( nfixednonzeros > 1 )
1739 SCIPdebugMsg(
scip,
"The problem is infeasible: more than one variable has bounds that keep it from being 0.\n");
1746 if ( nfixednonzeros == 1 )
1751 for (
j = 0;
j < consdata->nvars; ++
j)
1845 int** cliques =
NULL;
1849 int* indconss =
NULL;
1869 csize =
MAX(1, conshdlrdata->maxextensions) * nconss;
1885 for (
c = 0;
c < nconss; ++
c)
1898 for (iter = 0; iter < nconss; ++iter)
1919 assert( consdata->nvars >= 0 );
1920 assert( consdata->nvars <= consdata->maxvars );
1928 SCIP_CALL(
presolRoundConsSOS1(
scip, cons, consdata, eventhdlr, &
substituted, &
cutoff, &
success, ndelconss, nupgdconss, nfixedvars,
nremovedvars) );
1946 nvars = consdata->nvars;
1949 vars = consdata->vars;
1951 if (
nvars > 1 && conshdlrdata->maxextensions != 0 )
2034 maxextensions = conshdlrdata->maxextensions;
2037 TRUE, (maxextensions <= 1) ?
FALSE :
TRUE, cliques, &ncliques,
cliquesizes,
newclique,
comsucc,
ncomsucc, 0, -1, &maxextensions,
2073 for (
c = ncliques-1;
c >= 0; --
c)
2112 SCIP_Bool* infeasible
2124 if ( conshdlrdata->depthimplanalysis >= 0 && *probingdepth >= conshdlrdata->depthimplanalysis )
2133 for (s = 0; s <
nsucc; ++s)
2175 SCIP_CALL(
SCIPcreateConsSOS1(
scip, &
soscons,
namesos, 0,
NULL,
NULL,
TRUE,
TRUE,
TRUE,
FALSE,
TRUE,
2199 for (s = 0; s <
nsucc; ++s)
2219 SCIP_CALL(
performImplicationGraphAnalysis(
scip, conshdlrdata, conflictgraph,
totalvars, implgraph,
implhash,
adjacencymatrix,
givennode,
succnode,
impllbs,
implubs,
implnodes, naddconss, probingdepth, infeasible) );
2239 SCIP_CALL(
performImplicationGraphAnalysis(
scip, conshdlrdata, conflictgraph,
totalvars, implgraph,
implhash,
adjacencymatrix,
givennode,
succnode,
impllbs,
implubs,
implnodes, naddconss, probingdepth, infeasible) );
2272 for (s = 0; s <
nsucc; ++s)
2297 SCIP_Bool* infeasible
2349 for (s = 0; s <
nsucc; ++s)
2360 data->lbimpl = newbound;
2370 data->ubimpl = newbound;
2386 data->lbimpl = newbound;
2393 data->ubimpl = newbound;
2433 SCIP_Bool* infeasible
2443 *infeasible =
FALSE;
2539 SCIP_CALL(
updateArcData(
scip, implgraph,
implhash,
totalvars,
var,
vars[
w], lb, ub, newbound,
TRUE, nchgbds, update, infeasible) );
2543 SCIP_CALL(
updateArcData(
scip, implgraph,
implhash,
totalvars,
var,
vars[
w], lb, ub, newbound,
FALSE, nchgbds, update, infeasible) );
2550 SCIP_CALL(
updateArcData(
scip, implgraph,
implhash,
totalvars,
var,
vars[
w], lb, ub, newbound,
FALSE, nchgbds, update, infeasible) );
2554 SCIP_CALL(
updateArcData(
scip, implgraph,
implhash,
totalvars,
var,
vars[
w], lb, ub, newbound,
TRUE, nchgbds, update, infeasible) );
2614 for (s = 0; s <
nsucc; ++s)
2729 if ( conshdlrlinear ==
NULL )
2863 for (v = 0; v < nsos1vars; ++v)
2925 for (s = 0; s <
nsucc; ++s)
2967 SCIP_Bool tightened;
2968 SCIP_Bool infeasible;
2999 for (
w = 0;
w < nsos1vars; ++
w)
3120 SCIP_CALL(
updateImplicationGraphSOS1(
scip, conshdlrdata, conflictgraph,
adjacencymatrix, implgraph,
implhash,
implnodes,
totalvars,
cliquecovers,
cliquecoversizes,
varincover,
3121 trafolinvars,
trafolinvals,
ntrafolinvars,
trafoubs,
var,
trafoubv,
newboundnonzero,
ninftynonzero,
TRUE, nchgbds, &update, &infeasible) );
3169 SCIP_Bool tightened;
3170 SCIP_Bool infeasible;
3199 for (
w = 0;
w < nsos1vars; ++
w)
3323 SCIP_CALL(
updateImplicationGraphSOS1(
scip, conshdlrdata, conflictgraph,
adjacencymatrix, implgraph,
implhash,
implnodes,
totalvars,
cliquecovers,
cliquecoversizes,
varincover,
3324 trafolinvars,
trafolinvals,
ntrafolinvars,
trafolbs,
var,
trafolbv,
newboundnonzero,
ninftynonzero,
FALSE, nchgbds, &update, &infeasible) );
3395 for (
i = 0;
i < nsos1vars; ++
i)
3426 for (
j = 0; (
j < conshdlrdata->maxtightenbds || conshdlrdata->maxtightenbds == -1 ) && !
cutoff; ++
j)
3434 SCIP_CALL(
tightenVarsBoundsSOS1(
scip, conshdlrdata, conflictgraph, implgraph,
implhash,
adjacencymatrix,
totalvars,
ntotalvars, nsos1vars, nchgbds, &
implupdate, &
cutoff) );
3453 SCIP_Bool infeasible;
3464 for (
i = 0;
i < nsos1vars; ++
i)
3469 for (
j = 0;
j < nsos1vars; ++
j)
3478 SCIP_CALL(
performImplicationGraphAnalysis(
scip, conshdlrdata, conflictgraph,
totalvars, implgraph,
implhash,
adjacencymatrix,
i,
i,
impllbs,
implubs,
implnodes, naddconss, &probingdepth, &infeasible) );
3487 SCIPdebugMsg(
scip,
"fixed variable %s with lower bound %f and upper bound %f to zero\n",
3523 for (s =
nsucc-1; s >= 0; --s)
3555 if ( consdata->nfixednonzeros > 1 )
3557 SCIPdebugMsg(
scip,
"the node is infeasible, more than 1 variable is fixed to be nonzero.\n");
3564 if ( consdata->nfixednonzeros == 1 )
3567 SCIP_Bool infeasible;
3568 SCIP_Bool tightened;
3576 nvars = consdata->nvars;
3577 vars = consdata->vars;
3659 inferinfo = -node - 1;
3667 for (s = 0; s <
nsucc; ++s)
3679 SCIP_Bool infeasible;
3680 SCIP_Bool tightened;
3699 if ( implprop && implgraph !=
NULL )
3716 for (s = 0; s <
nsucc; ++s)
3735 SCIP_Bool infeasible;
3736 SCIP_Bool tightened;
3751 SCIP_Bool infeasible;
3752 SCIP_Bool tightened;
3804 assert( conshdlrdata->nimplnodes == 0 );
3812 if ( conshdlrdata->maxsosadjacency != -1 && nsos1vars > conshdlrdata->maxsosadjacency )
3815 SCIPdebugMsg(
scip,
"Implication graph was not created since number of SOS1 variables (%d) is larger than %d.\n", nsos1vars, conshdlrdata->maxsosadjacency);
3838 for (
i = 0;
i < nsos1vars; ++
i)
3863 conshdlrdata->nimplnodes = nimplnodes;
3866 for (
i = 0;
i < nimplnodes; ++
i)
3882 for (
i = 0;
i < nsos1vars; ++
i)
3886 for (
i = 0;
i < nsos1vars; ++
i)
3888 for (
j = 0;
j <
i+1; ++
j)
3892 for (
i = 0;
i < nsos1vars; ++
i)
3909 for (
j = 0; (
j < maxrounds || maxrounds == -1 ); ++
j)
3916 assert( nimplnodes > 0 );
3917 SCIP_CALL(
tightenVarsBoundsSOS1(
scip, conshdlrdata, conflictgraph, conshdlrdata->implgraph,
implhash,
adjacencymatrix,
implvars, nimplnodes, nsos1vars, nchgbds, &
implupdate,
cutoff) );
3923 for (
i = nsos1vars-1;
i >= 0; --
i)
3936 else if ( *nchgbds > 0 )
3961 if ( conshdlrdata->implgraph ==
NULL )
3963 assert( conshdlrdata->nimplnodes == 0 );
3968 for (
j = conshdlrdata->nimplnodes-1;
j >= 0; --
j)
3977 for (s =
nsucc-1; s >= 0; --s)
3985 for (
j = conshdlrdata->nimplnodes-1;
j >= 0; --
j)
3996 conshdlrdata->nimplnodes = 0;
4044 for (s = 0; s <
nsucc1; ++s)
4261 for (
i = 0;
i < nsos1vars; ++
i)
4278 SCIP_Real
sum1 = 0.0;
4279 SCIP_Real
sum2 = 0.0;
4341 SCIP_Bool fixnonzero,
4345 SCIP_Bool* infeasible,
4359 assert( inititer >= -1 );
4369 *infeasible =
FALSE;
4429 if ( ! *infeasible )
4545 for (
j = 0;
j < nsos1vars; ++
j)
4565 if ( conshdlrdata->nstrongiter == -2 )
4569 inititer =
MAX(inititer, 10);
4570 inititer =
MIN(inititer, 500);
4573 inititer = conshdlrdata->nstrongiter;
4589 for (
j = 0;
j < nstrongrounds; ++
j)
4665 SCIP_Bool infeasible;
4708 SCIP_Real coef = 0.0;
4775 *
feas += coef * solval;
4791 for (s = 0; s <
nsucc; ++s)
4878 *
feas += coef * solval;
4974 for (
i = 0;
i < nsos1vars; ++
i)
4998 for (s = 0; s <
nsucc; ++s)
5014 for (
i = 0;
i < nsos1vars; ++
i)
5041 for (s = 0; s <
nsucc; ++s)
5053 SCIP_Bool infeasible;
5119 if ( conshdlrdata->addextendedbds )
5121 if ( localconflicts ==
NULL )
5124 localconflicts = conshdlrdata->localconflicts;
5138 conshdlrdata->isconflocal =
TRUE;
5206 SCIP_CALL(
SCIPcreateConsSOS1(
scip, &
conssos1, name, 0,
NULL,
NULL,
TRUE,
TRUE,
TRUE,
FALSE,
TRUE,
5230 SCIP_CALL(
SCIPcreateConsLinear(
scip, &
conssos1, name, 0,
NULL,
NULL, -
SCIPinfinity(
scip), 0.0,
TRUE,
FALSE,
TRUE,
FALSE,
FALSE,
5239 SCIP_CALL(
SCIPcreateConsLinear(
scip, &
conssos1, name, 0,
NULL,
NULL, -
SCIPinfinity(
scip), 1.0,
TRUE,
FALSE,
TRUE,
FALSE,
FALSE,
5258 if ( conshdlrdata->maxaddcomps >= 0 && *naddedconss > conshdlrdata->maxaddcomps )
5266 if ( conshdlrdata->maxaddcomps >= 0 && *naddedconss > conshdlrdata->maxaddcomps )
5292 for (
j = 0;
j < nsos1vars; ++
j)
5363 SCIP_Bool infeasible;
5387 nsos1vars = conshdlrdata->nsos1vars;
5390 if ( nsos1vars == 0 || nconss == 0 )
5397 conflictgraph = conshdlrdata->conflictgraph;
5398 assert( ! conshdlrdata->isconflocal );
5401 for (
c = 0;
c < nconss; ++
c)
5414 if ( consdata->nvars < 2 )
5433 if ( consdata->local )
5440 if ( conshdlrdata->localconflicts ==
NULL )
5445 vars = consdata->vars;
5446 nvars = consdata->nvars;
5477 conshdlrdata->isconflocal =
TRUE;
5487 if ( conshdlrdata->isconflocal )
5489 for (
j = 0;
j < nsos1vars; ++
j)
5505 if ( conshdlrdata->isconflocal )
5508 conshdlrdata->isconflocal =
FALSE;
5515 for (
j = 0;
j < nsos1vars; ++
j)
5531 if ( conshdlrdata->branchingrule ==
'b' )
5535 if ( conshdlrdata->nstrongrounds >= 0 )
5536 nstrongrounds =
MIN(conshdlrdata->nstrongrounds, nsos1vars);
5546 nstrongrounds =
MIN(nsos1vars, nstrongrounds);
5557 if ( nstrongrounds == 0 )
5574 if ( conshdlrdata->isconflocal )
5577 conshdlrdata->isconflocal =
FALSE;
5598 if ( conshdlrdata->isconflocal )
5601 conshdlrdata->isconflocal =
FALSE;
5614 if ( ! conshdlrdata->branchsos )
5617 if ( conshdlrdata->isconflocal )
5620 conshdlrdata->isconflocal =
FALSE;
5636 SCIPerrorMessage(
"Incompatible parameter setting: branchsos can only be set to false if all SOS1 variables are binary.\n");
5737 if ( conshdlrdata->addcomps && ( conshdlrdata->addcompsdepth == -1 || conshdlrdata->addcompsdepth >=
SCIPgetDepth(
scip) ) )
5741 assert( ! conshdlrdata->fixnonzero );
5747 if ( naddedconss == 0 )
5756 if ( nstrongrounds > 0 )
5763 if ( conshdlrdata->isconflocal )
5766 conshdlrdata->isconflocal =
FALSE;
5847 for (
c = 0;
c < nconss; ++
c)
5863 nvars = consdata->nvars;
5864 vars = consdata->vars;
5893 if ( conshdlrdata->branchnonzeros )
5897 if ( conshdlrdata->branchweight && consdata->weights !=
NULL )
5900 if ( consdata->weights[
j] > weight )
5901 weight = consdata->weights[
j];
5925 if ( ! conshdlrdata->branchsos )
5930 for (
j = 0;
j < consdata->nvars; ++
j)
5936 if (
j == consdata->nvars )
5943 SCIPerrorMessage(
"Incompatible parameter setting: branchsos can only be set to false if all SOS1 variables are binary.\n");
5952 nvars = consdata->nvars;
5953 vars = consdata->vars;
5957 SCIP_Bool infeasible;
5975 SCIP_Bool infeasible;
6016 for (
j = 0;
j <=
ind; ++
j)
6025 for (
j = 0;
j <=
ind; ++
j)
6078 if ( conshdlrdata->addcomps && conshdlrdata->fixnonzero )
6080 SCIPerrorMessage(
"Incompatible parameter setting: addcomps = TRUE and fixnonzero = TRUE.\n");
6084 if ( conshdlrdata->fixnonzero && ( conshdlrdata->branchingrule ==
'b' || conshdlrdata->branchingrule ==
's' ) )
6086 SCIPerrorMessage(
"Incompatible parameter setting: nonzero fixing is not compatible with bipartite or sos1 branching.\n");
6090 if ( conshdlrdata->branchingrule ==
's' && conshdlrdata->nstrongrounds != 0 )
6092 SCIPerrorMessage(
"Strong branching is not available for SOS1 branching.\n");
6096 if ( conshdlrdata->branchingrule ==
's' || conshdlrdata->switchsos1branch )
6103 if ( conshdlrdata->branchingrule !=
'n' && conshdlrdata->branchingrule !=
'b' )
6105 SCIPerrorMessage(
"branching rule %c unknown\n", conshdlrdata->branchingrule);
6137 for (
j = 0;
j < nsos1vars; ++
j)
6144 for (
j = 0;
j < nsos1vars; ++
j)
6171 tcliquedata = conshdlrdata->tcliquedata;
6179 tcliquedata->
ncuts = 0;
6180 tcliquedata->
nboundcuts = conshdlrdata->nboundcuts;
6182 tcliquedata->
maxboundcuts = conshdlrdata->maxboundcutsroot;
6204 for (
j = 0;
j < nsos1vars; ++
j)
6215 if ( conshdlrdata->strthenboundcuts )
6222 if ( conshdlrdata->strthenboundcuts )
6268 if ( rowlb !=
NULL )
6272 SCIP_Bool infeasible;
6279 ++tcliquedata->
ncuts;
6285 if ( rowub !=
NULL )
6289 SCIP_Bool infeasible;
6296 ++tcliquedata->
ncuts;
6333 SCIP_Bool strengthen,
6334 SCIP_Bool removable,
6351 assert( ! local || ! global );
6359 if ( rowub !=
NULL )
6404 if ( ubboundvar ==
NULL )
6410 else if ( ubboundvar ==
nodedata->ubboundvar )
6436 vals[cnt++] = 1.0/val;
6441 if (
j ==
nnodes && cnt >= 2 )
6451 rhs = rhs * vals[0] * vals[1];
6458 vars[cnt] = ubboundvar;
6480 if ( rowlb !=
NULL )
6525 if ( lbboundvar ==
NULL )
6559 vals[cnt++] = 1.0/val;
6564 if (
j ==
nnodes && cnt >= 2 )
6574 rhs = rhs * vals[0] * vals[1];
6581 vars[cnt] = lbboundvar;
6643 scip = tcliquedata->scip;
6644 sol = tcliquedata->sol;
6657 if ( tcliquedata->strthenboundcuts )
6664 if ( tcliquedata->strthenboundcuts )
6705 if ( rowlb !=
NULL )
6714 if ( rowub !=
NULL )
6732 if( tcliquedata->maxboundcuts >= 0 )
6734 if ( tcliquedata->ncuts > tcliquedata->maxboundcuts/2 )
6736 if ( tcliquedata->ncuts >= tcliquedata->maxboundcuts )
6765 SCIP_Real scaleval = 1000.0;
6766 int maxtreenodes = 10000;
6767 int maxzeroextensions = 1000;
6768 int backtrackfreq = 1000;
6786 tcliquedata = conshdlrdata->tcliquedata;
6790 tcliquedata->
ncuts = 0;
6815 conshdlrdata->nboundcuts = tcliquedata->
nboundcuts;
6829 SCIP_Bool strengthen,
6830 SCIP_Bool removable,
6850 nvars = consdata->nvars;
6908 for (
c = 0;
c < nconss; ++
c)
6931 if ( consdata->local )
6938 if ( consdata->rowub ==
NULL || consdata->rowlb ==
NULL )
6941 (consdata->rowlb ==
NULL) ? &consdata->rowlb :
NULL,
6942 (consdata->rowub ==
NULL) ? &consdata->rowub :
NULL) );
6944 rowub = consdata->rowub;
6945 rowlb = consdata->rowlb;
6976 if ( rowlb !=
NULL )
6980 if ( rowub !=
NULL )
6986 if ( *
cutoff || ( maxboundcuts >= 0 && cnt >= maxboundcuts ) )
7025 if ( conshdlrdata->conflictgraph ==
NULL )
7029 implgraph = conshdlrdata->implgraph;
7032 if ( implgraph ==
NULL )
7042 implgraph = conshdlrdata->implgraph;
7049 nimplnodes = conshdlrdata->nimplnodes;
7115 for (
k = 0;
k < 2; ++
k)
7183 SCIP_Bool infeasible;
7206 if ( maxcuts >= 0 && *
ngen > maxcuts )
7261 if ( conshdlrdata->boundcutsfreq >= 0 &&
7262 ( (conshdlrdata->boundcutsfreq == 0 &&
depth == 0) || (conshdlrdata->boundcutsfreq > 0 &&
depth % conshdlrdata->boundcutsfreq == 0)) )
7269 maxboundcuts = conshdlrdata->maxboundcutsroot;
7271 maxboundcuts = conshdlrdata->maxboundcuts;
7273 if ( maxboundcuts >= 1 )
7276 if( conshdlrdata->boundcutsfromsos1 || conshdlrdata->switchcutsfromsos1 )
7289 if( conshdlrdata->boundcutsfromgraph && ! conshdlrdata->switchcutsfromsos1 )
7308 if ( conshdlrdata->implcutsfreq >= 0 &&
7309 ( (conshdlrdata->implcutsfreq == 0 &&
depth == 0) || (conshdlrdata->implcutsfreq > 0 &&
depth % conshdlrdata->implcutsfreq == 0)) )
7316 maximplcuts = conshdlrdata->maximplcutsroot;
7318 maximplcuts = conshdlrdata->maximplcuts;
7321 if ( maximplcuts >= 1 )
7369 for (
i = 0;
i < nsos1vars; ++
i)
7404 val =
MIN(1
e6, val);
7445 for (
j = 0;
j <
nsucc && !(*cutoff); ++
j)
7569 SCIP_Real* weights =
NULL;
7587 for (
i = 0;
i < nsos1vars; ++
i)
7595 for (
i = 0;
i < nsos1vars; ++
i)
7606 else if (
nsucc == 0 )
7628 for (
i = 0;
k < nsos1vars; ++
i)
7689 assert( nsos1vars >= 0 );
7700 for (
j = 0;
j < nsos1vars; ++
j)
7745 for (
j = 0;
j < nsos1vars; ++
j)
7767 for (
c = 0;
c < nconss; ++
c)
7773 for (
j = 0;
j < consdata->nvars; ++
j)
7827 SCIP_Real maxval = 0.0;
7837 nvars = consdata->nvars;
7838 vars = consdata->vars;
7891 else if ( pos >= 0 )
7900 for (
c = 0;
c < nconss; ++
c)
7908 for (
j = 0;
j < consdata->nvars; ++
j)
7959 for (v = 0; v < nsos1vars; ++v)
8046 for (s = 0; s <
nsucc; ++s)
8099 for (
c = 0;
c < nconss; ++
c)
8109 nvars = consdata->nvars;
8110 vars = consdata->vars;
8113 for (
j = 0;
j <
nvars && cnt < 2; ++
j)
8216 nvars = consdata->nvars;
8217 vars = consdata->vars;
8351 concomp[(*nconcomp)++] = node;
8384 for (s = 0; s <
nsucc; ++s)
8418 for (
j = 0;
j < nsos1vars; ++
j)
8422 for (
j = 0;
j < nsos1vars; ++
j)
8450 for (s = 0; s <
nsucc; ++s)
8499 for (
c = 0;
c < nlinconss; ++
c)
8574 if ( conshdlrdata->nsos1vars > 0 )
8591 nvars = consdata->nvars;
8592 vars = consdata->vars;
8624 if ( conshdlrdata->autosos1branch )
8626 conshdlrdata->switchsos1branch =
TRUE;
8627 SCIPdebugMsg(
scip,
"Switched to SOS1 branching, since the SOS1 constraints do not overlap\n");
8630 if ( conshdlrdata->autocutsfromsos1 )
8632 conshdlrdata->switchcutsfromsos1 =
TRUE;
8633 SCIPdebugMsg(
scip,
"Switched to separating bound cuts from SOS1 constraints (and not from the conflict graph), since the SOS1 constraints do not overlap\n");
8654 if ( nsos1vars == 0 )
8710 for (
c = 0;
c < nconss; ++
c)
8723 nvars = consdata->nvars;
8724 vars = consdata->vars;
8754 conshdlrdata->nsos1vars = 0;
8770 for (
c = 0;
c < nconss; ++
c)
8783 nvars = consdata->nvars;
8784 vars = consdata->vars;
8854 conshdlrdata->nsos1vars =
cntsos;
8861 for (
j = 0;
j < conshdlrdata->nsos1vars; ++
j)
8882 if ( conshdlrdata->conflictgraph ==
NULL )
8884 assert( conshdlrdata->nsos1vars == 0 );
8889 assert( conshdlrdata->nsos1vars > 0 );
8890 for (
j = 0;
j < conshdlrdata->nsos1vars; ++
j)
8895 assert( conshdlrdata->conflictgraph !=
NULL );
8908 conshdlrdata->nsos1vars = 0;
8911 assert( conshdlrdata->conflictgraph ==
NULL );
8971 conshdlrdata->nsos1vars = 0;
8972 conshdlrdata->varhash =
NULL;
8982 if ( ( conshdlrdata->autosos1branch || conshdlrdata->autocutsfromsos1 )
8983 && ( ! conshdlrdata->switchsos1branch || ! conshdlrdata->switchcutsfromsos1 )
8994 if ( conshdlrdata->addcomps )
9000 if ( conshdlrdata->fixnonzerovars ==
NULL )
9002 conshdlrdata->maxnfixnonzerovars = conshdlrdata->nsos1vars;
9025 for (
c = 0;
c < nconss; ++
c)
9037 if ( consdata->rowub !=
NULL )
9042 if ( consdata->rowlb !=
NULL )
9049 if ( conshdlrdata->implgraph !=
NULL )
9056 if ( conshdlrdata->tcliquegraph !=
NULL )
9067 conshdlrdata->nfixnonzerovars = 0;
9068 conshdlrdata->maxnfixnonzerovars = 0;
9071 if ( conshdlrdata->localconflicts !=
NULL )
9073 assert( conshdlrdata->localconflicts ==
NULL );
9077 assert( conshdlrdata->conflictgraph ==
NULL );
9106 for (
j = 0;
j < (*consdata)->nvars; ++
j)
9114 if ( (*consdata)->weights !=
NULL )
9120 if ( (*consdata)->rowub !=
NULL )
9124 if ( (*consdata)->rowlb !=
NULL )
9167 if ( conshdlrdata->fixnonzerovars ==
NULL )
9178 consdata->rowub =
NULL;
9179 consdata->rowlb =
NULL;
9180 consdata->nfixednonzeros = 0;
9191 consdata->weights =
NULL;
9200 ++(consdata->nfixednonzeros);
9213 for (
j = 0;
j < consdata->nvars; ++
j)
9220 if ( consdata->nfixednonzeros > 0 )
9223 consdata->nfixednonzeros );
9277 conflictgraph = conshdlrdata->conflictgraph;
9278 nsos1vars = conshdlrdata->nsos1vars;
9279 if ( nsos1vars < 2 )
9290 for (
i = 0;
i < nsos1vars; ++
i)
9296 for (
i = 0;
i < nsos1vars; ++
i)
9298 for (
j = 0;
j <
i+1; ++
j)
9301 for (
i = 0;
i < nsos1vars; ++
i)
9318 SCIPdebugMsg(
scip,
"Adjacency matrix was not created since number of SOS1 variables (%d) is larger than %d.\n", nsos1vars, conshdlrdata->maxsosadjacency);
9322 SCIP_CALL(
presolRoundConssSOS1(
scip, eventhdlr, conshdlrdata, conflictgraph,
adjacencymatrix, conss, nconss, nsos1vars, naddconss, ndelconss, nupgdconss, nfixedvars, &
nremovedvars,
result) );
9333 for (
j = nsos1vars-1;
j >= 0; --
j)
9343 SCIPdebug(
SCIPdebugMsg(
scip,
"presolving fixed %d variables, changed %d bounds, removed %d variables, deleted %d constraints, and upgraded %d constraints.\n",
9363 *infeasible =
FALSE;
9366 if( conshdlrdata->boundcutsfromsos1 || conshdlrdata->switchcutsfromsos1 )
9486 for (
j = 0;
j < consdata->nvars; ++
j)
9510 for (
l = 0;
l < consdata->nvars; ++
l)
9559 conflictgraph = conshdlrdata->conflictgraph;
9562 implgraph = conshdlrdata->implgraph;
9563 if ( implgraph ==
NULL && conshdlrdata->implprop && conflictgraph !=
NULL )
9573 conshdlrdata->implprop =
FALSE;
9582 implgraph = conshdlrdata->implgraph;
9585 conshdlrdata->implprop =
FALSE;
9589 if ( conshdlrdata->conflictprop && conflictgraph !=
NULL )
9592 int nfixnonzerovars;
9598 nfixnonzerovars = conshdlrdata->nfixnonzerovars;
9599 fixnonzerovars = conshdlrdata->fixnonzerovars;
9603 for (
j = 0;
j < nfixnonzerovars; ++
j)
9607 var = fixnonzerovars[
j];
9635 conshdlrdata->nfixnonzerovars = 0;
9638 if ( conshdlrdata->sosconsprop || conflictgraph ==
NULL )
9643 for (
c = 0;
c < nconss; ++
c)
9693 if ( inferinfo < 0 )
9702 assert( conshdlrdata->conflictgraph !=
NULL );
9703 assert( inferinfo >= -conshdlrdata->maxnfixnonzerovars );
9704 assert( inferinfo >= -conshdlrdata->nsos1vars );
9705 assert( inferinfo <= -1 );
9718 var = consdata->vars[inferinfo];
9772 vars = consdata->vars;
9773 nvars = consdata->nvars;
9813 for (
j = 0;
j < consdata->nvars; ++
j)
9818 if ( consdata->weights ==
NULL )
9836 const char* consname;
9881 initial, separate, enforce, check,
propagate, local, dynamic, removable, stickingatnode) );
9911 SCIP_CALL(
SCIPcreateConsSOS1(
scip, cons, name, 0,
NULL,
NULL, initial, separate, enforce, check,
propagate, local, dynamic, removable, stickingatnode) );
10014 (*nvars) = consdata->nvars;
10036 SCIP_Real oldbound;
10037 SCIP_Real newbound;
10047 assert( 0 <= consdata->nfixednonzeros && consdata->nfixednonzeros <= consdata->nvars );
10053 switch ( eventtype )
10066 if ( conshdlrdata->nfixnonzerovars < conshdlrdata->maxnfixnonzerovars )
10068 assert( conshdlrdata->fixnonzerovars !=
NULL );
10073 ++(consdata->nfixednonzeros);
10088 if ( conshdlrdata->nfixnonzerovars < conshdlrdata->maxnfixnonzerovars )
10090 assert( conshdlrdata->fixnonzerovars !=
NULL );
10095 ++(consdata->nfixednonzeros);
10102 --(consdata->nfixednonzeros);
10108 --(consdata->nfixednonzeros);
10139 assert( 0 <= consdata->nfixednonzeros && consdata->nfixednonzeros <= consdata->nvars );
10142 oldbound, newbound, consdata->nfixednonzeros);
10161 *infeasible =
FALSE;
10175 if ( conshdlrdata->switchsos1branch )
10196 SCIP_Real constant = 0.0;
10209 nconsvars = consdata->nvars;
10220 for(
i = 0;
i < nconsvars; ++
i )
10259 SCIP_Real constant = 0.0;
10272 nconsvars = consdata->nvars;
10283 for(
i = 0;
i < nconsvars; ++
i )
10365 conshdlrdata->branchsos =
TRUE;
10366 conshdlrdata->switchsos1branch =
FALSE;
10367 conshdlrdata->switchcutsfromsos1 =
FALSE;
10368 conshdlrdata->eventhdlr =
NULL;
10369 conshdlrdata->fixnonzerovars =
NULL;
10370 conshdlrdata->maxnfixnonzerovars = 0;
10371 conshdlrdata->nfixnonzerovars = 0;
10372 conshdlrdata->conflictgraph =
NULL;
10373 conshdlrdata->localconflicts =
NULL;
10374 conshdlrdata->isconflocal =
FALSE;
10375 conshdlrdata->implgraph =
NULL;
10376 conshdlrdata->nimplnodes = 0;
10377 conshdlrdata->nboundcuts = 0;
10378 conshdlrdata->tcliquegraph =
NULL;
10379 conshdlrdata->tcliquedata =
NULL;
10380 conshdlrdata->cntextsos1 = -1;
10381 conshdlrdata->varhash =
NULL;
10385 if ( conshdlrdata->eventhdlr ==
NULL )
10422 "do not create an adjacency matrix if number of SOS1 variables is larger than predefined value (-1: no limit)",
10427 "maximal number of extensions that will be computed for each SOS1 constraint (-1: no limit)",
10431 "maximal number of bound tightening rounds per presolving round (-1: no limit)",
10435 "if TRUE then perform implication graph analysis (might add additional SOS1 constraints)",
10439 "number of recursive calls of implication graph analysis (-1: no limit)",
10444 "whether to use conflict graph propagation",
10448 "whether to use implication graph propagation",
10452 "whether to use SOS1 constraint propagation",
10457 "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)",
10461 "if TRUE then automatically switch to SOS1 branching if the SOS1 constraints do not overlap",
10465 "if neighborhood branching is used, then fix the branching variable (if positive in sign) to the value of the feasibility tolerance",
10469 "if TRUE then add complementarity constraints to the branching nodes (can be used in combination with neighborhood or bipartite branching)",
10473 "maximal number of complementarity constraints added per branching node (-1: no limit)",
10477 "minimal feasibility value for complementarity constraints in order to be added to the branching node",
10481 "minimal feasibility value for bound inequalities in order to be added to the branching node",
10485 "should added complementarity constraints be extended to SOS1 constraints to get tighter bound inequalities",
10489 "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",
10493 "Branch on SOS constraint with most number of nonzeros?",
10497 "Branch on SOS cons. with highest nonzero-variable weight for branching (needs branchnonzeros = false)?",
10501 "only add complementarity constraints to branching nodes for predefined depth (-1: no limit)",
10506 "maximal number of strong branching rounds to perform for each node (-1: auto); only available for neighborhood and bipartite branching",
10510 "maximal number LP iterations to perform for each strong branching round (-2: auto, -1: no limit)",
10515 "if TRUE separate bound inequalities from initial SOS1 constraints",
10519 "if TRUE separate bound inequalities from the conflict graph",
10523 "if TRUE then automatically switch to separating initial SOS1 constraints if the SOS1 constraints do not overlap",
10527 "frequency for separating bound cuts; zero means to separate only in the root node",
10531 "node depth of separating bound cuts (-1: no limit)",
10535 "maximal number of bound cuts separated per branching node",
10539 "maximal number of bound cuts separated per iteration in the root node",
10543 "if TRUE then bound cuts are strengthened in case bound variables are available",
10547 "frequency for separating implied bound cuts; zero means to separate only in the root node",
10551 "node depth of separating implied bound cuts (-1: no limit)",
10555 "maximal number of implied bound cuts separated per branching node",
10559 "maximal number of implied bound cuts separated per iteration in the root node",
10579 SCIP_Real* weights,
10582 SCIP_Bool separate,
10595 SCIP_Bool removable,
10597 SCIP_Bool stickingatnode
10604 SCIP_Bool modifiable;
10605 SCIP_Bool transformed;
10608 modifiable =
FALSE;
10612 if ( conshdlr ==
NULL )
10623 consdata->vars =
NULL;
10624 consdata->nvars =
nvars;
10625 consdata->maxvars =
nvars;
10626 consdata->rowub =
NULL;
10627 consdata->rowlb =
NULL;
10628 consdata->nfixednonzeros = transformed ? 0 : -1;
10629 consdata->weights =
NULL;
10630 consdata->local = local;
10637 if ( weights !=
NULL )
10652 for (v = 0; v <
nvars; ++v)
10658 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
10659 local, modifiable, dynamic, removable, stickingatnode) );
10663 for (v =
nvars - 1; v >= 0; --v)
10703 SCIP_CALL(
SCIPcreateConsSOS1(
scip, cons, name,
nvars,
vars, weights,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
FALSE,
FALSE,
FALSE,
FALSE) );
10797 return consdata->nvars;
10822 return consdata->vars;
10847 return consdata->weights;
10872 return conshdlrdata->conflictgraph;
10894 return conshdlrdata->nsos1vars;
10942 if ( conshdlrdata->varhash ==
NULL )
10983 SCIP_Bool* changed,
11019 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
#define SCIP_LONGINT_FORMAT
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,)
SCIP_RETCODE SCIPsetConshdlrGetSignedPermsymGraph(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 SCIPsetConshdlrGetPermsymGraph(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
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_RETCODE SCIPaddSymgraphEdge(SCIP *scip, SYM_GRAPH *graph, int first, int second, SCIP_Bool hasval, SCIP_Real val)
SCIP_RETCODE SCIPaddSymgraphOpnode(SCIP *scip, SYM_GRAPH *graph, int op, int *nodeidx)
SCIP_RETCODE SCIPgetSymActiveVariables(SCIP *scip, SYM_SYMTYPE symtype, SCIP_VAR ***vars, SCIP_Real **scalars, int *nvars, SCIP_Real *constant, SCIP_Bool transformed)
SCIP_RETCODE SCIPaddSymgraphValnode(SCIP *scip, SYM_GRAPH *graph, SCIP_Real val, int *nodeidx)
int SCIPgetSymgraphVarnodeidx(SCIP *scip, SYM_GRAPH *graph, SCIP_VAR *var)
SCIP_RETCODE SCIPaddSymgraphConsnode(SCIP *scip, SYM_GRAPH *graph, SCIP_CONS *cons, SCIP_Real lhs, SCIP_Real rhs, int *nodeidx)
SCIP_RETCODE SCIPaddSymgraphVarAggregation(SCIP *scip, SYM_GRAPH *graph, int rootidx, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Real constant)
int SCIPgetSymgraphNegatedVarnodeidx(SCIP *scip, SYM_GRAPH *graph, SCIP_VAR *var)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)
SCIP_Bool 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
structs for symmetry computations
methods for dealing with symmetry detection graphs
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_CONSGETSIGNEDPERMSYMGRAPH(x)
#define SCIP_DECL_CONSGETPERMSYMGRAPH(x)
#define SCIP_DECL_CONSENFOLP(x)
#define SCIP_DECL_CONSDELETE(x)
#define SCIP_DECL_CONSGETVARS(x)
#define SCIP_DECL_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