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
251struct SCIP_ConshdlrData
271 int maxnfixnonzerovars;
278 int depthimplanalysis;
312 int maxboundcutsroot;
339 if ( vertex1 == vertex2 )
343 if ( adjacencymatrix ==
NULL )
354 if ( nsucc1 < 1 || nsucc2 < 1 )
357 if ( nsucc1 > nsucc2 )
366 for (j = 0; j < nsucc1; ++j)
368 succvertex = succ[j];
369 if ( succvertex == vertex2 )
371 else if ( succvertex > vertex2 )
377 if ( vertex1 < vertex2 )
378 return adjacencymatrix[vertex2][vertex1];
380 return adjacencymatrix[vertex1][vertex2];
418 for (s = 0; s < nsucc; ++s)
603 SCIP_CALL(
SCIPcreateConsLinear(
scip, &cons,
"branch", 1, &
var, &val, 0.0, 0.0,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
666 for (
i = 0;
i < naggrvars; ++
i)
671 allnonnegative =
FALSE;
676 if ( allnonnegative )
679 for (
i = 0;
i < naggrvars; ++
i)
685 *tightened = *tightened || fixed;
733 *tightened = *tightened || tighten;
737 *tightened = *tightened || tighten;
796 assert( consdata->nvars <= consdata->maxvars );
798 if ( num > consdata->maxvars )
804 if ( reserveWeights )
806 consdata->maxvars = newsize;
808 assert( num <= consdata->maxvars );
844 assert( consdata->nfixednonzeros >= 0 );
846 ++consdata->nfixednonzeros;
868 conflictgraph = conshdlrdata->conflictgraph;
869 if ( conflictgraph ==
NULL )
874 assert( node < conshdlrdata->nsos1vars );
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)
906 assert( nodev < conshdlrdata->nsos1vars );
938 SCIPdebugMsg(
scip,
"Switched to SOS1 branching rule, since conflict graph could be infeasible.\n");
939 conshdlrdata->switchsos1branch =
TRUE;
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;
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];
1144 int* workingsetnew =
NULL;
1171 mincands = nworkingset;
1179 for (
i = 0;
i < nexts; ++
i)
1181 for (j = nexts; j < nworkingset; ++j)
1189 for (
i = 0;
i < nworkingset; ++
i)
1194 vertex = workingset[
i];
1197 for (j = nexts; j < nworkingset && cnt < mincands; ++j)
1199 if ( vertex != workingset[j] && !
isConnectedSOS1(adjacencymatrix,
NULL, vertex, workingset[j]) )
1209 if ( cnt < mincands )
1231 for (btriter = mincands + btriter; btriter >= 1; --btriter)
1237 selvertex = workingset[selpos];
1238 workingset[selpos] = workingset[nexts];
1239 workingset[nexts] = selvertex;
1243 for (j = 0 ; j < nexts; ++j)
1246 workingsetnew[nextsnew++] = workingset[j];
1248 nworkingsetnew = nextsnew;
1249 for (j = nexts + 1; j < nworkingset; ++j)
1252 workingsetnew[nworkingsetnew++] = workingset[j];
1255 newclique[cliquesizes[*ncliques]++] = selvertex;
1258 if ( nworkingsetnew == 0 )
1265 cliqueind = nsos1vars + *ncliques;
1268 assert( cliquesizes[*ncliques] >= 0 && cliquesizes[*ncliques] <= nsos1vars );
1269 assert( *ncliques <
MAX(1, conshdlrdata->maxextensions) * nconss );
1271 for (j = 0 ; j < cliquesizes[*ncliques]; ++j)
1275 cliques[*ncliques][j] = newclique[j];
1278 SCIPsortInt(cliques[*ncliques], cliquesizes[*ncliques]);
1293 for (j = 0; j < consdata->nvars; ++j)
1303 ++(conshdlrdata->cntextsos1);
1305 cliquesizes[*ncliques] = cliquesizes[*ncliques-1];
1311 if ( *maxextensions <= 0 )
1317 else if ( nextsnew < nworkingsetnew )
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 )
1334 assert( nworkingset >= nworkingsetnew );
1335 for (
w = 0;
w < nworkingsetnew; ++
w)
1336 workingset[
w] = workingsetnew[
w];
1337 nworkingset = nworkingsetnew;
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 );
1351 --cliquesizes[*ncliques];
1359 for (j = nexts; j < nworkingset; ++j)
1361 assert( fixvertex != workingset[j] );
1401 for (v = 1; v < nlinvars; ++v)
1406 if ( indexinsosvars >= 0 )
1411 for (s = 0; s < nsucc; ++s)
1414 indexinlinvars = posinlinvars[succ[s]];
1415 assert( indexinlinvars < nlinvars );
1417 if ( indexinlinvars >= 0 && indexinlinvars < v )
1471 for (j = 0; j <
nvars; ++j)
1473 for (
i = k;
i < nsucc; ++
i)
1475 if ( succ[
i] > clique[j] )
1480 else if ( succ[
i] == clique[j] )
1486 comsucc[(*ncomsucc)++] = succ[
i];
1491 for (v = 1; v <
nvars; ++v)
1493 int ncomsuccsave = 0;
1506 for (j = 0; j < *ncomsucc; ++j)
1508 for (
i = k;
i < nsucc; ++
i)
1510 if ( succ[
i] > comsucc[j] )
1515 else if ( succ[
i] == comsucc[j] )
1517 comsucc[ncomsuccsave++] = succ[
i];
1523 *ncomsucc = ncomsuccsave;
1565 for (s = 0; s < nsucc; ++s)
1570 data = succdatas[s];
1577 assert( sos1node == succnode );
1578 implnodes[sos1node] =
TRUE;
1618 int lastFixedNonzero;
1631 *substituted =
FALSE;
1639 lastFixedNonzero = -1;
1640 allvarsbinary =
TRUE;
1641 vars = consdata->vars;
1644 while ( j < consdata->
nvars )
1673 *substituted =
TRUE;
1677 for (l = j+1; l < consdata->nvars; ++l)
1703 lastFixedNonzero = j;
1717 allvarsbinary =
FALSE;
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");
1740 assert( lastFixedNonzero >= 0 );
1746 if ( nfixednonzeros == 1 )
1748 assert( lastFixedNonzero >= 0 );
1751 for (j = 0; j < consdata->nvars; ++j)
1753 if ( j != lastFixedNonzero )
1845 int** cliques =
NULL;
1847 int* cliquesizes =
NULL;
1848 int* newclique =
NULL;
1849 int* indconss =
NULL;
1850 int* lengthconss =
NULL;
1851 int* comsucc =
NULL;
1869 csize =
MAX(1, conshdlrdata->maxextensions) * nconss;
1885 for (
c = 0;
c < nconss; ++
c)
1893 lengthconss[
c] = consdata->nvars;
1898 for (iter = 0; iter < nconss; ++iter)
1905 int savennupgdconss;
1919 assert( consdata->nvars >= 0 );
1920 assert( consdata->nvars <= consdata->maxvars );
1922 assert( ncliques < csize );
1924 savendelconss = *ndelconss;
1925 savennupgdconss = *nupgdconss;
1928 SCIP_CALL(
presolRoundConsSOS1(
scip, cons, consdata, eventhdlr, &substituted, &
cutoff, &success, ndelconss, nupgdconss, nfixedvars, nremovedvars) );
1936 if ( *ndelconss > savendelconss || *nupgdconss > savennupgdconss || substituted )
1946 nvars = consdata->nvars;
1949 vars = consdata->vars;
1951 if (
nvars > 1 && conshdlrdata->maxextensions != 0 )
1960 for (j = 0; j <
nvars; ++j)
1964 if ( varprobind >= 0 )
1965 newclique[cliquesize++] = varprobind;
1968 if ( cliquesize > 1 )
1970 cliquesizes[ncliques] = cliquesize;
1982 varprobind = newclique[0];
1987 for (j = 0; j < ncomsucc; ++j)
1990 assert( j == 0 || succ[j] > succ[j-1] );
1991 comsucc[j] = succ[j];
1995 for (v = 1; v < cliquesize && ncomsucc > 0; ++v)
1997 varprobind = newclique[v];
2025 if ( conshdlrdata->maxextensions != 0 && adjacencymatrix !=
NULL )
2034 maxextensions = conshdlrdata->maxextensions;
2037 TRUE, (maxextensions <= 1) ?
FALSE :
TRUE, cliques, &ncliques, cliquesizes, newclique, comsucc, ncomsucc, 0, -1, &maxextensions,
2038 naddconss, &extended) );
2053 cliqueind = nsos1vars + ncliques;
2056 assert( cliquesize >= 0 && cliquesize <= nsos1vars );
2057 assert( ncliques < csize );
2059 for (j = 0; j < cliquesize; ++j)
2061 cliques[ncliques][j] = newclique[j];
2073 for (
c = ncliques-1;
c >= 0; --
c)
2124 if ( conshdlrdata->depthimplanalysis >= 0 && *probingdepth >= conshdlrdata->depthimplanalysis )
2133 for (s = 0; s < nsucc; ++s)
2152 impllbs[succnode] = 0;
2153 implubs[succnode] = 0;
2164 if ( givennode > succnode )
2165 adjacencymatrix[givennode][succnode] = 1;
2167 adjacencymatrix[succnode][givennode] = 1;
2175 SCIP_CALL(
SCIPcreateConsSOS1(
scip, &soscons, namesos, 0,
NULL,
NULL,
TRUE,
TRUE,
TRUE,
FALSE,
TRUE,
2199 for (s = 0; s < nsucc; ++s)
2202 int oldprobingdepth;
2205 data = succdatas[s];
2206 oldprobingdepth = *probingdepth;
2211 impllbs[succnode] = data->lbimpl;
2218 implnodes[succnode] =
TRUE;
2219 SCIP_CALL(
performImplicationGraphAnalysis(
scip, conshdlrdata, conflictgraph, totalvars, implgraph, implhash, adjacencymatrix, givennode, succnode, impllbs, implubs, implnodes, naddconss, probingdepth, infeasible) );
2220 *probingdepth = oldprobingdepth;
2231 implubs[succnode] = data->ubimpl;
2238 implnodes[succnode] =
TRUE;
2239 SCIP_CALL(
performImplicationGraphAnalysis(
scip, conshdlrdata, conflictgraph, totalvars, implgraph, implhash, adjacencymatrix, givennode, succnode, impllbs, implubs, implnodes, naddconss, probingdepth, infeasible) );
2240 *probingdepth = oldprobingdepth;
2272 for (s = 0; s < nsucc; ++s)
2274 if ( implnodes[succ[s]] )
2326 if ( infeasible1 || infeasible2 )
2332 if ( tightened1 || tightened2 )
2349 for (s = 0; s < nsucc; ++s)
2351 if ( succ[s] == indw )
2353 data = succdatas[s];
2360 data->lbimpl = newbound;
2370 data->ubimpl = newbound;
2386 data->lbimpl = newbound;
2393 data->ubimpl = newbound;
2420 int* cliquecoversizes,
2443 *infeasible =
FALSE;
2453 int newninftynonzero;
2460 newninftynonzero = ninftynonzero;
2474 implbound = boundnonzero -
bound;
2475 ind = varincover[
w];
2476 assert( cliquecoversizes[ind] > 0 );
2479 for (j = 0; j < cliquecoversizes[ind]; ++j)
2481 indcliq = cliquecovers[ind][j];
2492 implbound += bounds[
w];
2497 else if ( implcoverw )
2502 implbound -= bounds[indcliq];
2515 if ( ! implinfty && newninftynonzero == 0 )
2529 newbound = implbound / coef;
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) );
2593 assert( ! coveredvars[v] );
2603 int nextensions = 0;
2614 for (s = 0; s < nsucc; ++s)
2617 if ( ! coveredvars[succnode] )
2618 extensions[nextensions++] = succ[s];
2622 while ( nextensions > 0 )
2626 if ( considersolvals )
2634 for (s = 0; s < nextensions; ++s)
2639 bestbigMval = bigMval;
2640 bestindex = extensions[s];
2645 bestindex = extensions[0];
2647 assert( bestindex != -1 );
2650 clique[(*cliquesize)++] = bestindex;
2654 for (s = 0; s < nextensions; ++s)
2656 if ( s != bestindex &&
isConnectedSOS1(
NULL, conflictgraphlin, bestindex, extensions[s]) )
2657 extensions[nextensionsnew++] = extensions[s];
2659 nextensions = nextensionsnew;
2667 for (s = 0; s < *cliquesize; ++s)
2673 assert( ! coveredvars[ind] );
2674 coveredvars[ind] =
TRUE;
2704 int* varindincons =
NULL;
2707 int ntrafolinvars = 0;
2725 *implupdate =
FALSE;
2729 if ( conshdlrlinear ==
NULL )
2745 for (
c = 0;
c < nlinearconss + nsos1vars && ! (*cutoff); ++
c)
2748 int** cliquecovers =
NULL;
2749 int* cliquecoversizes =
NULL;
2753 int* varincover =
NULL;
2762 if (
c < nlinearconss )
2769 if ( ntrafolinvars < 1 )
2798 trafolinvars[0] = sosvar;
2799 trafolinvals[0] = 1.0;
2804 assert( ntrafolinvars >= 1 );
2809 if( requiredsize > ntrafolinvars )
2815 assert( requiredsize <= ntrafolinvars );
2818 trafolhs -= constant;
2820 traforhs -= constant;
2822 if ( ntrafolinvars == 0 )
2830 if ( sosvar !=
NULL )
2832 trafolinvals[ntrafolinvars] = -1.0;
2833 trafolinvars[ntrafolinvars] = sosvar;
2838 for (v = 0; v < ntrafolinvars; ++v)
2846 if ( trafolinvals[v] < 0.0 )
2854 trafolbs[v] = lb * trafolinvals[v];
2859 trafoubs[v] = ub * trafolinvals[v];
2863 for (v = 0; v < nsos1vars; ++v)
2864 varindincons[v] = -1;
2867 for (v = 0; v < ntrafolinvars; ++v)
2874 varindincons[node] = v;
2882 for (
i = 0;
i < ntrafolinvars; ++
i)
2892 for (v = 0; v < ntrafolinvars; ++v)
2895 if ( ! coveredvars[v] )
2908 for (v = 0; v < ntrafolinvars; ++v)
2925 for (s = 0; s < nsucc; ++s)
2930 if ( varindincons[succnode] == -1 )
2933 varindincons[succnode] = -2;
2944 for (
i = 0;
i < ncliquecovers; ++
i)
2946 for (j = 0; j < cliquecoversizes[
i]; ++j)
2948 int ind = cliquecovers[
i][j];
2950 varincover[ind] =
i;
2951 cliquecovervals[j] = trafoubs[ind];
2957 for (v = 0; v < ntrafolinvars + nsos1linvars; ++v)
2971 int ninftynonzero = 0;
2975 if ( v < ntrafolinvars )
2977 var = trafolinvars[v];
2978 trafoubv = trafoubs[v];
2982 assert( v >= ntrafolinvars );
2983 var = sos1linvars[v-ntrafolinvars];
2993 newboundnonzero = trafolhs;
2994 newboundnores = trafolhs;
2996 assert( nodev < nsos1vars );
2999 for (
w = 0;
w < nsos1vars; ++
w)
3004 for (
i = 0;
i < ncliquecovers; ++
i)
3009 assert( cliquecoversizes[
i] > 0 );
3011 indcliq = cliquecovers[
i][0];
3012 assert( 0 <= indcliq && indcliq < ntrafolinvars );
3020 newboundnores -= trafoubs[indcliq];
3022 else if ( cliquecoversizes[
i] > 1 )
3024 assert( 0 <= cliquecovers[
i][1] && cliquecovers[
i][1] < ntrafolinvars );
3028 newboundnores -= trafoubs[cliquecovers[
i][1]];
3032 for (j = 0; j < cliquecoversizes[
i]; ++j)
3034 indcliq = cliquecovers[
i][j];
3035 assert( 0 <= indcliq && indcliq < ntrafolinvars );
3038 assert( nodecliq < nsos1vars );
3048 newboundnonzero -= trafoubs[indcliq];
3055 assert( ninftynonzero == 0 || inftynores );
3058 if ( ninftynonzero == 0 && v < ntrafolinvars )
3060 linval = trafolinvals[v];
3067 newbound = newboundnonzero;
3069 newbound =
MIN(0, newboundnonzero);
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) );
3132 for (j = ncliquecovers-1; j >= 0; --j)
3145 for (
i = 0;
i < ncliquecovers; ++
i)
3147 for (j = 0; j < cliquecoversizes[
i]; ++j)
3149 int ind = cliquecovers[
i][j];
3151 varincover[ind] =
i;
3152 cliquecovervals[j] = trafolbs[ind];
3159 for (v = 0; v < ntrafolinvars + nsos1linvars; ++v)
3173 int ninftynonzero = 0;
3177 if ( v < ntrafolinvars )
3179 var = trafolinvars[v];
3180 trafolbv = trafolbs[v];
3184 assert( v-ntrafolinvars >= 0 );
3185 var = sos1linvars[v-ntrafolinvars];
3193 newboundnonzero = traforhs;
3194 newboundnores = traforhs;
3196 assert( nodev < nsos1vars );
3199 for (
w = 0;
w < nsos1vars; ++
w)
3204 for (
i = 0;
i < ncliquecovers; ++
i)
3209 assert( cliquecoversizes[
i] > 0 );
3211 indcliq = cliquecovers[
i][0];
3212 assert( 0 <= indcliq && indcliq < ntrafolinvars );
3221 newboundnores -= trafolbs[indcliq];
3223 else if ( cliquecoversizes[
i] > 1 )
3225 assert( 0 <= cliquecovers[
i][1] && cliquecovers[
i][1] < ntrafolinvars );
3229 newboundnores -= trafolbs[cliquecovers[
i][1]];
3233 for (j = 0; j < cliquecoversizes[
i]; ++j)
3235 indcliq = cliquecovers[
i][j];
3236 assert( 0 <= indcliq && indcliq < ntrafolinvars );
3239 assert( nodecliq < nsos1vars );
3250 newboundnonzero -= trafolbs[indcliq];
3257 assert( ninftynonzero == 0 || inftynores );
3260 if ( ninftynonzero == 0 && v < ntrafolinvars )
3262 linval = trafolinvals[v];
3269 newbound = newboundnonzero;
3271 newbound =
MAX(0, newboundnonzero);
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) );
3333 for (j = ncliquecovers-1; j >= 0; --j)
3395 for (
i = 0;
i < nsos1vars; ++
i)
3404 totalvars[ntotalvars++] =
var;
3407 for (
i = 0;
i < nprobvars; ++
i)
3417 totalvars[ntotalvars++] =
var;
3425 updateconfl =
FALSE;
3426 for (j = 0; (j < conshdlrdata->maxtightenbds || conshdlrdata->maxtightenbds == -1 ) && !
cutoff; ++j)
3431 nchgbdssave = *nchgbds;
3433 assert( ntotalvars > 0 );
3434 SCIP_CALL(
tightenVarsBoundsSOS1(
scip, conshdlrdata, conflictgraph, implgraph, implhash, adjacencymatrix, totalvars, ntotalvars, nsos1vars, nchgbds, &implupdate, &
cutoff) );
3435 if ( *nchgbds > nchgbdssave )
3441 else if ( implupdate )
3448 if ( updateconfl && conshdlrdata->perfimplanalysis && !
cutoff )
3463 naddconsssave = *naddconss;
3464 for (
i = 0;
i < nsos1vars; ++
i)
3469 for (j = 0; j < nsos1vars; ++j)
3470 implnodes[j] =
FALSE;
3471 for (j = 0; j < ntotalvars; ++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",
3497 if ( *naddconss > naddconsssave )
3514 for (j = ntotalvars-1; j >= 0; --j)
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 )
3571 int firstFixedNonzero;
3575 firstFixedNonzero = -1;
3576 nvars = consdata->nvars;
3577 vars = consdata->vars;
3581 for (j = 0; j <
nvars; ++j)
3585 firstFixedNonzero = j;
3589 assert( firstFixedNonzero >= 0 );
3595 for (j = 0; j < firstFixedNonzero; ++j)
3600 allVarFixed = allVarFixed && success;
3606 for (j = firstFixedNonzero+1; j <
nvars; ++j)
3611 allVarFixed = allVarFixed && success;
3659 inferinfo = -node - 1;
3667 for (s = 0; s < nsucc; ++s)
3699 if ( implprop && implgraph !=
NULL )
3712 if ( succdatas !=
NULL )
3716 for (s = 0; s < nsucc; ++s)
3724 succdata = succdatas[s];
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)
3847 implvars[nimplnodes++] =
var;
3850 for (
i = 0;
i < nprobvars; ++
i)
3860 implvars[nimplnodes++] =
var;
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)
3889 adjacencymatrix[
i][j] = 0;
3892 for (
i = 0;
i < nsos1vars; ++
i)
3899 for (j = 0; j < nsucc; ++j)
3902 adjacencymatrix[
i][succ[j]] = 1;
3909 for (j = 0; (j < maxrounds || maxrounds == -1 ); ++j)
3914 nchgbdssave = *nchgbds;
3916 assert( nimplnodes > 0 );
3917 SCIP_CALL(
tightenVarsBoundsSOS1(
scip, conshdlrdata, conflictgraph, conshdlrdata->implgraph, implhash, adjacencymatrix, implvars, nimplnodes, nsos1vars, nchgbds, &implupdate,
cutoff) );
3918 if ( *
cutoff || ( ! implupdate && ! ( *nchgbds > nchgbdssave ) ) )
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;
4028 *ncoververtices = 0;
4031 if ( neightocover ==
NULL )
4033 assert( nneightocover == 0 );
4039 nsucc1 = nneightocover;
4040 succ1 = neightocover;
4044 for (s = 0; s < nsucc1; ++s)
4046 int succvertex1 = succ1[s];
4048 if ( ! verticesarefixed[succvertex1] )
4059 if ( *ncoververtices == 0 )
4061 for (j = 0; j < nsucc2; ++j)
4063 succvertex2 = succ2[j];
4064 if ( ! verticesarefixed[succvertex2] )
4065 coververtices[(*ncoververtices)++] = succvertex2;
4075 for (v = 0; v < *ncoververtices; ++v)
4078 for (j = k; j < nsucc2; ++j)
4080 succvertex2 = succ2[j];
4081 if ( succvertex2 > coververtices[v] )
4087 else if ( succvertex2 == coververtices[v] )
4090 coververtices[vv++] = succvertex2;
4097 *ncoververtices = vv;
4104 for (s = 0; s < *ncoververtices; ++s)
4106 assert( *ncoververtices <= 1 || coververtices[*ncoververtices - 1] > coververtices[*ncoververtices - 2] );
4137 assert( ! verticesarefixed[branchvertex] );
4158 for (j = 0; j < nsucc; ++j)
4162 assert( ! verticesarefixed[succ[j]] );
4163 fixingsnode1[(*nfixingsnode1)++] = succ[j];
4168 if ( *nfixingsnode1 > 0 )
4171 SCIP_CALL(
getCoverVertices(conflictgraph, verticesarefixed, branchvertex, fixingsnode1, *nfixingsnode1, fixingsnode2, nfixingsnode2) );
4174 SCIP_CALL(
getCoverVertices(conflictgraph, verticesarefixed, branchvertex, fixingsnode2, *nfixingsnode2, fixingsnode1, nfixingsnode1) );
4176 for (j = 0; j < *nfixingsnode2; ++j)
4187 for (j = 0; j < *nfixingsnode1; ++j)
4195 takeallsucc =
FALSE;
4204 for (j = 0; j < nsucc; ++j)
4206 if ( ! verticesarefixed[succ[j]] )
4207 fixingsnode1[(*nfixingsnode1)++] = succ[j];
4213 SCIP_CALL(
getCoverVertices(conflictgraph, verticesarefixed, branchvertex, fixingsnode1, *nfixingsnode1, fixingsnode2, nfixingsnode2) );
4218 fixingsnode2[0] = branchvertex;
4240 int* vertexbestprior,
4258 if ( vertexbestprior !=
NULL )
4259 *vertexbestprior = -1;
4261 for (
i = 0;
i < nsos1vars; ++
i)
4282 assert( ! verticesarefixed[
i] );
4285 for (j = 0; j < nfixingsnode1; ++j)
4295 for (j = 0; j < nfixingsnode2; ++j)
4305 if ( iszero1 || iszero2 )
4308 prior = sum1 * sum2;
4311 if ( branchpriors !=
NULL )
4312 branchpriors[
i] = prior;
4313 if ( bestprior < prior )
4317 if ( vertexbestprior !=
NULL )
4318 *vertexbestprior =
i;
4325 *relsolfeas =
FALSE;
4344 int* ndomainfixings,
4356 assert( nfixingsop > 0 );
4358 assert( nfixingsop > 0 );
4359 assert( inititer >= -1 );
4362 assert( *ndomainfixings >= 0 );
4369 *infeasible =
FALSE;
4375 if ( fixnonzero && nfixingsop == 1 )
4415 for (
i = 0;
i < nfixingsexec && ! *infeasible; ++
i)
4429 if ( ! *infeasible )
4455 for (
i = 0;
i < nfixingsop; ++
i)
4456 domainfixings[(*ndomainfixings)++] = fixingsop[
i];
4487 int* vertexbestprior,
4494 int* indsos1vars =
NULL;
4495 int* domainfixings =
NULL;
4502 int lastscorechange;
4525 bipbranch, fixingsnode1, fixingsnode2, branchpriors,
NULL, &relsolfeas) );
4531 *vertexbestprior = -1;
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;
4580 lastscorechange = -1;
4582 *vertexbestprior = indsos1vars[0];
4586 maxfailures = nstrongrounds;
4589 for (j = 0; j < nstrongrounds; ++j)
4594 testvertex = indsos1vars[j];
4607 assert( ! verticesarefixed[testvertex] );
4609 fixingsnode1, &nfixingsnode1, fixingsnode2, &nfixingsnode2) );
4613 inititer, conshdlrdata->fixnonzero, domainfixings, &ndomainfixings, &infeasible1, &objval1, &
lperror) );
4619 inititer,
FALSE, domainfixings, &ndomainfixings, &infeasible2, &objval2, &
lperror) );
4624 if ( infeasible1 && infeasible2 )
4638 else if ( ! infeasible1 && ! infeasible2 )
4641 if ( ndomainfixings == 0 )
4648 *vertexbestprior = testvertex;
4649 *bestobjval1 = objval1;
4650 *bestobjval2 = objval2;
4652 lastscorechange = j;
4654 else if ( j - lastscorechange > maxfailures )
4662 if ( ndomainfixings > 0 )
4667 for (
i = 0;
i < ndomainfixings; ++
i)
4712 int* extensions =
NULL;
4713 int nextensions = 0;
4731 if ( boundvar ==
NULL )
4751 else if ( boundvar ==
nodedata->ubboundvar )
4775 *feas += coef * solval;
4791 for (s = 0; s < nsucc; ++s)
4792 extensions[s] = succ[s];
4793 nextensions = nsucc;
4799 while ( nextensions > 0 )
4817 for (s = 0; s < nextensions; ++s)
4819 ext = extensions[s];
4823 bestbigMval = bigMval;
4828 assert( bestindex != -1 );
4835 if ( boundvar ==
NULL )
4855 else if ( boundvar ==
nodedata->ubboundvar )
4878 *feas += coef * solval;
4887 for (s = 0; s < nextensions; ++s)
4890 extensions[nextensionsnew++] = extensions[s];
4892 nextensions = nextensionsnew;
4903 if ( boundvar ==
NULL )
4948 if ( nfixingsnode2 > 1 )
4974 for (
i = 0;
i < nsos1vars; ++
i)
4975 mark[
i] = (verticesarefixed[
i]);
4978 for (
i = 0;
i < nfixingsnode1; ++
i)
4980 assert( nfixingsnode1 <= 1 || (fixingsnode1[nfixingsnode1 - 1] > fixingsnode1[nfixingsnode1 - 2]) );
4981 mark[fixingsnode1[
i]] =
TRUE;
4985 for (
i = 0;
i < nfixingsnode2; ++
i)
4987 assert( nfixingsnode2 <= 1 || (fixingsnode2[nfixingsnode2 - 1] > fixingsnode2[nfixingsnode2 - 2]) );
4988 mark[fixingsnode2[
i]] =
TRUE;
4993 for (
i = 0;
i < nfixingsnode2; ++
i)
4998 for (s = 0; s < nsucc; ++s)
5000 int succnode = succ[s];
5002 if ( ! mark[succnode] )
5004 mark[succnode] =
TRUE;
5005 succarray[nsuccarray++] = succnode;
5014 for (
i = 0;
i < nsos1vars; ++
i)
5018 for (
i = 0;
i < nfixingsnode2; ++
i)
5019 mark[fixingsnode2[
i]] =
TRUE;
5022 for (
i = 0;
i < nsuccarray; ++
i)
5029 vertex1 = succarray[
i];
5041 for (s = 0; s < nsucc; ++s)
5043 if ( mark[succ[s]] )
5045 fixingsnode21[nfixingsnode21++] = succ[s];
5046 assert( nfixingsnode21 == 1 || (fixingsnode21[nfixingsnode21 - 1] > fixingsnode21[nfixingsnode21 - 2]) );
5051 if ( nfixingsnode21 == nfixingsnode2 )
5062 assert ( nfixingsnode22 + nfixingsnode21 == nfixingsnode2 );
5065 SCIP_CALL(
getCoverVertices(conflictgraph, verticesarefixed, -1, fixingsnode22, nfixingsnode22, coverarray, &ncoverarray) );
5069 for (j = 0; j < ncoverarray; ++j)
5073 vertex2 = coverarray[j];
5074 assert( vertex2 != vertex1 );
5077 if ( vertex2 < vertex1 )
5107 lbboundcoef1 =
nodedata->lbboundcoef;
5108 ubboundcoef1 =
nodedata->ubboundcoef;
5112 lbboundcoef2 =
nodedata->lbboundcoef;
5113 ubboundcoef2 =
nodedata->ubboundcoef;
5119 if ( conshdlrdata->addextendedbds )
5121 if ( localconflicts ==
NULL )
5124 localconflicts = conshdlrdata->localconflicts;
5138 conshdlrdata->isconflocal =
TRUE;
5178 feas += solval1/ubboundcoef1;
5184 feas += solval1/lbboundcoef1;
5191 feas += solval2/ubboundcoef2;
5197 feas += solval2/lbboundcoef2;
5202 if (
SCIPisGT(
scip, feas, conshdlrdata->addcompsfeas) )
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)
5354 int* fixingsnode1 =
NULL;
5355 int* fixingsnode2 =
NULL;
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;
5459 for (j =
i+1; j <
nvars; ++j)
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)
5525 verticesarefixed[j] =
TRUE;
5527 verticesarefixed[j] =
FALSE;
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 )
5563 bipbranch, fixingsnode1, fixingsnode2,
NULL, &branchvertex, &relsolfeas) );
5574 if ( conshdlrdata->isconflocal )
5577 conshdlrdata->isconflocal =
FALSE;
5592 bipbranch, nstrongrounds, verticesarefixed, fixingsnode1, fixingsnode2, &branchvertex, &bestobjval1,
5598 if ( conshdlrdata->isconflocal )
5601 conshdlrdata->isconflocal =
FALSE;
5614 if ( ! conshdlrdata->branchsos )
5617 if ( conshdlrdata->isconflocal )
5620 conshdlrdata->isconflocal =
FALSE;
5628 assert( branchvertex >= 0 && branchvertex < nsos1vars );
5636 SCIPerrorMessage(
"Incompatible parameter setting: branchsos can only be set to false if all SOS1 variables are binary.\n");
5644 assert( branchvertex >= 0 && branchvertex < nsos1vars );
5645 assert( ! verticesarefixed[branchvertex] );
5647 fixingsnode1, &nfixingsnode1, fixingsnode2, &nfixingsnode2) );
5652 for (j = 0; j < nfixingsnode1; ++j)
5666 if ( conshdlrdata->fixnonzero && nfixingsnode2 == 1 )
5706 for (j = 0; j < nfixingsnode1; ++j)
5716 for (j = 0; j < nfixingsnode2; ++j)
5730 for (j = 0; j < nfixingsnode2; ++j)
5737 if ( conshdlrdata->addcomps && ( conshdlrdata->addcompsdepth == -1 || conshdlrdata->addcompsdepth >=
SCIPgetDepth(
scip) ) )
5741 assert( ! conshdlrdata->fixnonzero );
5745 nsos1vars, verticesarefixed, fixingsnode1, nfixingsnode1, fixingsnode2, nfixingsnode2, &naddedconss,
TRUE) );
5747 if ( naddedconss == 0 )
5751 nsos1vars, verticesarefixed, fixingsnode2, nfixingsnode2, fixingsnode1, nfixingsnode1, &naddedconss,
TRUE) );
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;
5887 for (j = 0; j <
nvars; ++j)
5893 if ( conshdlrdata->branchnonzeros )
5897 if ( conshdlrdata->branchweight && consdata->weights !=
NULL )
5900 if ( consdata->weights[j] > weight )
5901 weight = consdata->weights[j];
5910 if ( cnt > 1 && weight > maxWeight )
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;
5991 for (j = 0; j <
nvars; ++j)
6005 w = weight1/weight2;
6016 for (j = 0; j <= ind; ++j)
6025 for (j = 0; j <= ind; ++j)
6034 for (j = ind+1; j <
nvars; ++j)
6043 for (j = ind+1; j <
nvars; ++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)
6154 for (
i = 0;
i < nsucc; ++
i)
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 )
6279 ++tcliquedata->
ncuts;
6285 if ( rowub !=
NULL )
6296 ++tcliquedata->
ncuts;
6335 const char* nameext,
6351 assert( ! local || ! global );
6359 if ( rowub !=
NULL )
6368 useboundvar = strengthen;
6369 for (j = 0; j <
nnodes; ++j)
6383 useboundvar =
FALSE;
6404 if ( ubboundvar ==
NULL )
6410 else if ( ubboundvar ==
nodedata->ubboundvar )
6414 useboundvar =
FALSE;
6436 vals[cnt++] = 1.0/val;
6441 if ( j ==
nnodes && cnt >= 2 )
6451 rhs = rhs * vals[0] * vals[1];
6452 assert( (! useboundvar && cnt == 2 ) || (useboundvar && cnt == 3 ) );
6458 vars[cnt] = ubboundvar;
6480 if ( rowlb !=
NULL )
6489 useboundvar = strengthen;
6490 for (j = 0; j <
nnodes; ++j)
6504 useboundvar =
FALSE;
6525 if ( lbboundvar ==
NULL )
6537 useboundvar =
FALSE;
6559 vals[cnt++] = 1.0/val;
6564 if ( j ==
nnodes && cnt >= 2 )
6574 rhs = rhs * vals[0] * vals[1];
6575 assert( (! useboundvar && cnt == 2 ) || (useboundvar && cnt == 3 ) );
6581 vars[cnt] = lbboundvar;
6624 *stopsolving =
FALSE;
6627 minweightinc = (cliqueweight - *minweight)/10;
6628 minweightinc =
MAX(minweightinc, 1);
6629 *minweight += minweightinc;
6632 if( cliqueweight > tcliquedata->scaleval )
6643 scip = tcliquedata->scip;
6644 sol = tcliquedata->sol;
6648 unscaledweight = 0.0;
6649 for(
i = 0;
i < ncliquenodes;
i++ )
6651 node = cliquenodes[
i];
6657 if ( tcliquedata->strthenboundcuts )
6664 if ( tcliquedata->strthenboundcuts )
6690 cliquenodes, ncliquenodes, 1.0,
FALSE,
FALSE, tcliquedata->strthenboundcuts,
FALSE, nameext, &rowlb, &rowub) !=
SCIP_OKAY )
6705 if ( rowlb !=
NULL )
6714 if ( rowub !=
NULL )
6727 SCIPdebugMsg(
scip,
" -> found bound cut corresponding to clique (act=%g)\n", unscaledweight);
6732 if( tcliquedata->maxboundcuts >= 0 )
6734 if ( tcliquedata->ncuts > tcliquedata->maxboundcuts/2 )
6736 if ( tcliquedata->ncuts >= tcliquedata->maxboundcuts )
6737 *stopsolving =
TRUE;
6741 *stopsolving =
TRUE;
6766 int maxtreenodes = 10000;
6767 int maxzeroextensions = 1000;
6768 int backtrackfreq = 1000;
6786 tcliquedata = conshdlrdata->tcliquedata;
6790 tcliquedata->
ncuts = 0;
6800 tcliqueMaxClique(tcliqueGetNNodes, tcliqueGetWeights, tcliqueIsEdge, tcliqueSelectAdjnodes,
6801 conshdlrdata->tcliquegraph, tcliqueNewsolClique, tcliquedata,
6802 cliquenodes, &ncliquenodes, &cliqueweight, (
int)scaleval-1, (
int)scaleval+1,
6803 maxtreenodes, backtrackfreq, maxzeroextensions, -1, &ntreenodes, &tcliquestatus);
6809 *ngen = tcliquedata->
ncuts;
6815 conshdlrdata->nboundcuts = tcliquedata->
nboundcuts;
6850 nvars = consdata->nvars;
6861 for (j = 0; j <
nvars; ++j)
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 )
7040 if ( *
cutoff || ! success )
7042 implgraph = conshdlrdata->implgraph;
7049 nimplnodes = conshdlrdata->nimplnodes;
7059 for (
i = 0;
i < nimplnodes && ! genbreak; ++
i)
7081 for (s = 0; s < nsucc && ! genbreak; ++s)
7096 succdata = succdatas[s];
7110 bound1lower =
FALSE;
7115 for (k = 0; k < 2; ++k)
7123 impl = succdata->lbimpl;
7135 impl = succdata->ubimpl;
7149 bound2lower =
FALSE;
7152 lhsrhs = bound1 * bound2;
7155 if ( bound1lower == bound2lower )
7157 if (
SCIPisFeasGT(
scip, solval * (bound2-impl) + solvalsucc * bound1, lhsrhs) )
7166 if (
SCIPisFeasLT(
scip, solval * (bound2-impl) + solvalsucc * bound1, lhsrhs) )
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)
7373 if( nsucc == 0 || indicatorzero[
i] )
7387 for (j = 0; j < nsucc; ++j)
7394 sum +=
MIN(10E05, valsucc);
7404 val =
MIN(1e6, val);
7445 for (j = 0; j < nsucc && !(*cutoff); ++j)
7450 assert( indset[succj] == 0 );
7472 if ( aggrnode >= 0 )
7477 if ( ! mark[aggrnode] )
7479 mark[aggrnode] =
TRUE;
7482 else if ( indset[aggrnode] == 1 )
7491 if ( indset[aggrnode] == 0 )
7494 if ( mark[aggrnode] )
7501 indset[aggrnode] = 1;
7502 mark[aggrnode] =
TRUE;
7523 if ( indset[negnode] == 1 )
7528 else if ( ! mark[negnode] )
7530 mark[negnode] =
TRUE;
7570 int* indscipvars =
NULL;
7587 for (
i = 0;
i < nsos1vars; ++
i)
7595 for (
i = 0;
i < nsos1vars; ++
i)
7599 if ( indset[
i] == 0 )
7601 if( indicatorzero[
i] )
7606 else if ( nsucc == 0 )
7628 for (
i = 0; k < nsos1vars; ++
i)
7632 ind = indscipvars[
i];
7648 assert( k == nsos1vars );
7684 *allroundable =
TRUE;
7689 assert( nsos1vars >= 0 );
7700 for (j = 0; j < nsos1vars; ++j)
7713 indicatorzero[j] =
TRUE;
7716 indicatorzero[j] =
FALSE;
7721 *allroundable =
FALSE;
7727 indicatorzero[j] =
TRUE;
7734 if ( ! (*allroundable) )
7745 for (j = 0; j < nsos1vars; ++j)
7747 if ( indset[j] == 0 )
7767 for (
c = 0;
c < nconss; ++
c)
7773 for (j = 0; j < consdata->nvars; ++j)
7813 *allroundable =
TRUE;
7822 for (
c = 0;
c < nconss && *allroundable; ++
c)
7837 nvars = consdata->nvars;
7838 vars = consdata->vars;
7841 for (j = 0; j <
nvars; ++j)
7858 *allroundable =
FALSE;
7889 if ( ! (*allroundable) )
7891 else if ( pos >= 0 )
7898 if ( *allroundable )
7900 for (
c = 0;
c < nconss; ++
c)
7908 for (j = 0; j < consdata->nvars; ++j)
7959 for (v = 0; v < nsos1vars; ++v)
8005 fixneigh = !fixneigh;
8017 if ( score > bestscore )
8024 bestvarfixneigh = fixneigh;
8036 assert( bestnode >= 0 && bestnode < nsos1vars );
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)
8130 for (j = 0; j <
nvars; ++j)
8193 if ( score > bestscore )
8200 bestvarfixcomp = fixcomp;
8216 nvars = consdata->nvars;
8217 vars = consdata->vars;
8219 assert( bestcons >= 0 && bestcons < nconss );
8227 for (j = 0; j <
nvars; ++j)
8350 processed[node] =
TRUE;
8351 concomp[(*nconcomp)++] = node;
8367 if ( boundvar ==
NULL )
8369 if ( comparevar !=
NULL )
8374 if ( comparevar ==
NULL )
8384 for (s = 0; s < nsucc; ++s)
8386 if ( ! processed[succ[s]] )
8418 for (j = 0; j < nsos1vars; ++j)
8419 processed[j] =
FALSE;
8422 for (j = 0; j < nsos1vars; ++j)
8425 if ( ! processed[j] )
8443 processed[j] =
TRUE;
8450 for (s = 0; s < nsucc; ++s)
8452 if ( ! processed[succ[s]] )
8459 if ( unique && boundvar !=
NULL )
8461 for (s = 0; s < nconcomp; ++s)
8472 SCIPdebugMsg(
scip,
"Found a connected component of size <%i> with unique bound variable.\n", nconcomp);
8499 for (
c = 0;
c < nlinconss; ++
c)
8504 lincons = linconss[
c];
8574 if ( conshdlrdata->nsos1vars > 0 )
8576 for (
c = 0;
c < nconss && nonoverlap; ++
c)
8591 nvars = consdata->nvars;
8592 vars = consdata->vars;
8610 assert( node < conshdlrdata->nsos1vars );
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 )
8659 if ( linconshdlr ==
NULL )
8705 for (
i = 0;
i < ntotalvars; ++
i)
8710 for (
c = 0;
c < nconss; ++
c)
8723 nvars = consdata->nvars;
8724 vars = consdata->vars;
8739 assert( ind >= 0 && ind < ntotalvars );
8740 if ( ! nodecreated[ind] )
8742 nodecreated[ind] =
TRUE;
8743 nodeorig[ind] = cntsos;
8754 conshdlrdata->nsos1vars = 0;
8759 for (
i = 0;
i < ntotalvars; ++
i)
8770 for (
c = 0;
c < nconss; ++
c)
8783 nvars = consdata->nvars;
8784 vars = consdata->vars;
8800 if ( ! nodecreated[indi] )
8824 nodecreated[indi] =
TRUE;
8829 for (j =
i+1; j <
nvars; ++j)
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 )
9163 assert( sourcedata->nvars > 0 );
9164 assert( sourcedata->nvars <= sourcedata->maxvars );
9167 if ( conshdlrdata->fixnonzerovars ==
NULL )
9176 consdata->nvars = sourcedata->nvars;
9177 consdata->maxvars = sourcedata->nvars;
9178 consdata->rowub =
NULL;
9179 consdata->rowlb =
NULL;
9180 consdata->nfixednonzeros = 0;
9181 consdata->local = sourcedata->local;
9186 if ( sourcedata->weights !=
NULL )
9191 consdata->weights =
NULL;
9193 for (j = 0; j < sourcedata->nvars; ++j)
9195 assert( sourcedata->vars[j] != 0 );
9200 ++(consdata->nfixednonzeros);
9213 for (j = 0; j < consdata->nvars; ++j)
9220 if ( consdata->nfixednonzeros > 0 )
9223 consdata->nfixednonzeros );
9236 SCIPdebug(
int oldnfixedvars = *nfixedvars; )
9238 SCIPdebug(
int oldndelconss = *ndelconss; )
9239 SCIPdebug(
int oldnupgdconss = *nupgdconss; )
9257 if( nconss > 0 && ( nrounds == 0 || nnewfixedvars > 0 || nnewaggrvars > 0 || nnewchgbds > 0 ) )
9277 conflictgraph = conshdlrdata->conflictgraph;
9278 nsos1vars = conshdlrdata->nsos1vars;
9279 if ( nsos1vars < 2 )
9286 if ( conshdlrdata->maxsosadjacency == -1 || nsos1vars <= conshdlrdata->maxsosadjacency )
9290 for (
i = 0;
i < nsos1vars; ++
i)
9296 for (
i = 0;
i < nsos1vars; ++
i)
9298 for (j = 0; j <
i+1; ++j)
9299 adjacencymatrix[
i][j] = 0;
9301 for (
i = 0;
i < nsos1vars; ++
i)
9309 for (j = 0; j < nsucc; ++j)
9312 adjacencymatrix[
i][succ[j]] = 1;
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) );
9324 if ( adjacencymatrix !=
NULL )
9333 for (j = nsos1vars-1; j >= 0; --j)
9341 (*nchgcoefs) += nremovedvars;
9343 SCIPdebug(
SCIPdebugMsg(
scip,
"presolving fixed %d variables, changed %d bounds, removed %d variables, deleted %d constraints, and upgraded %d constraints.\n",
9344 *nfixedvars - oldnfixedvars, *nchgbds - oldnchgbds, nremovedvars, *ndelconss - oldndelconss, *nupgdconss - oldnupgdconss); )
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;
9580 else if ( nchbds > 0 )
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;
9776 for (j = 0; j <
nvars; ++j)
9813 for (j = 0; j < consdata->nvars; ++j)
9818 if ( consdata->weights ==
NULL )
9836 const char* consname;
9859 nvars = sourceconsdata->nvars;
9863 if ( sourceconsdata->weights !=
NULL )
9869 sourcevars = sourceconsdata->vars;
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) );
9938 weight = strtod(s, &t);
9991 if( varssize < consdata->
nvars )
10014 (*nvars) = consdata->nvars;
10047 assert( 0 <= consdata->nfixednonzeros && consdata->nfixednonzeros <= consdata->nvars );
10053 switch ( eventtype )
10066 if ( conshdlrdata->nfixnonzerovars < conshdlrdata->maxnfixnonzerovars )
10068 assert( conshdlrdata->fixnonzerovars !=
NULL );
10070 conshdlrdata->fixnonzerovars[conshdlrdata->nfixnonzerovars++] =
SCIPeventGetVar(event);
10073 ++(consdata->nfixednonzeros);
10088 if ( conshdlrdata->nfixnonzerovars < conshdlrdata->maxnfixnonzerovars )
10090 assert( conshdlrdata->fixnonzerovars !=
NULL );
10092 conshdlrdata->fixnonzerovars[conshdlrdata->nfixnonzerovars++] =
SCIPeventGetVar(event);
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 )
10209 nconsvars = consdata->nvars;
10220 for(
i = 0;
i < nconsvars; ++
i )
10222 locvars[0] = consvars[
i];
10275 nconsvars = consdata->nvars;
10286 for(
i = 0;
i < nconsvars; ++
i )
10288 locvars[0] = consvars[
i];
10308 allownegation =
TRUE;
10314 if( allownegation )
10334 for( j = 0; j < nlocvars; ++j )
10371 conshdlrdata->branchsos =
TRUE;
10372 conshdlrdata->switchsos1branch =
FALSE;
10373 conshdlrdata->switchcutsfromsos1 =
FALSE;
10374 conshdlrdata->eventhdlr =
NULL;
10375 conshdlrdata->fixnonzerovars =
NULL;
10376 conshdlrdata->maxnfixnonzerovars = 0;
10377 conshdlrdata->nfixnonzerovars = 0;
10378 conshdlrdata->conflictgraph =
NULL;
10379 conshdlrdata->localconflicts =
NULL;
10380 conshdlrdata->isconflocal =
FALSE;
10381 conshdlrdata->implgraph =
NULL;
10382 conshdlrdata->nimplnodes = 0;
10383 conshdlrdata->nboundcuts = 0;
10384 conshdlrdata->tcliquegraph =
NULL;
10385 conshdlrdata->tcliquedata =
NULL;
10386 conshdlrdata->cntextsos1 = -1;
10387 conshdlrdata->varhash =
NULL;
10391 if ( conshdlrdata->eventhdlr ==
NULL )
10400 consEnfolpSOS1, consEnfopsSOS1, consCheckSOS1, consLockSOS1, conshdlrdata) );
10428 "do not create an adjacency matrix if number of SOS1 variables is larger than predefined value (-1: no limit)",
10433 "maximal number of extensions that will be computed for each SOS1 constraint (-1: no limit)",
10437 "maximal number of bound tightening rounds per presolving round (-1: no limit)",
10441 "if TRUE then perform implication graph analysis (might add additional SOS1 constraints)",
10445 "number of recursive calls of implication graph analysis (-1: no limit)",
10450 "whether to use conflict graph propagation",
10454 "whether to use implication graph propagation",
10458 "whether to use SOS1 constraint propagation",
10463 "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)",
10467 "if TRUE then automatically switch to SOS1 branching if the SOS1 constraints do not overlap",
10471 "if neighborhood branching is used, then fix the branching variable (if positive in sign) to the value of the feasibility tolerance",
10475 "if TRUE then add complementarity constraints to the branching nodes (can be used in combination with neighborhood or bipartite branching)",
10479 "maximal number of complementarity constraints added per branching node (-1: no limit)",
10483 "minimal feasibility value for complementarity constraints in order to be added to the branching node",
10487 "minimal feasibility value for bound inequalities in order to be added to the branching node",
10491 "should added complementarity constraints be extended to SOS1 constraints to get tighter bound inequalities",
10495 "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",
10499 "Branch on SOS constraint with most number of nonzeros?",
10503 "Branch on SOS cons. with highest nonzero-variable weight for branching (needs branchnonzeros = false)?",
10507 "only add complementarity constraints to branching nodes for predefined depth (-1: no limit)",
10512 "maximal number of strong branching rounds to perform for each node (-1: auto); only available for neighborhood and bipartite branching",
10516 "maximal number LP iterations to perform for each strong branching round (-2: auto, -1: no limit)",
10521 "if TRUE separate bound inequalities from initial SOS1 constraints",
10525 "if TRUE separate bound inequalities from the conflict graph",
10529 "if TRUE then automatically switch to separating initial SOS1 constraints if the SOS1 constraints do not overlap",
10533 "frequency for separating bound cuts; zero means to separate only in the root node",
10537 "node depth of separating bound cuts (-1: no limit)",
10541 "maximal number of bound cuts separated per branching node",
10545 "maximal number of bound cuts separated per iteration in the root node",
10549 "if TRUE then bound cuts are strengthened in case bound variables are available",
10553 "frequency for separating implied bound cuts; zero means to separate only in the root node",
10557 "node depth of separating implied bound cuts (-1: no limit)",
10561 "maximal number of implied bound cuts separated per branching node",
10565 "maximal number of implied bound cuts separated per iteration in the root node",
10614 modifiable =
FALSE;
10618 if ( conshdlr ==
NULL )
10629 consdata->vars =
NULL;
10630 consdata->nvars =
nvars;
10631 consdata->maxvars =
nvars;
10632 consdata->rowub =
NULL;
10633 consdata->rowlb =
NULL;
10634 consdata->nfixednonzeros = transformed ? 0 : -1;
10635 consdata->weights =
NULL;
10636 consdata->local = local;
10643 if ( weights !=
NULL )
10658 for (v = 0; v <
nvars; ++v)
10664 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
10665 local, modifiable, dynamic, removable, stickingatnode) );
10669 for (v =
nvars - 1; v >= 0; --v)
10709 SCIP_CALL(
SCIPcreateConsSOS1(
scip, cons, name,
nvars,
vars, weights,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
FALSE,
FALSE,
FALSE,
FALSE) );
10803 return consdata->nvars;
10828 return consdata->vars;
10853 return consdata->weights;
10878 return conshdlrdata->conflictgraph;
10900 return conshdlrdata->nsos1vars;
10948 if ( conshdlrdata->varhash ==
NULL )
11014 allroundable =
FALSE;
11025 if ( conshdlrdata->switchsos1branch )
11034 if ( ! allroundable )
#define CONSHDLR_NEEDSCONS
#define CONSHDLR_SEPAFREQ
#define CONSHDLR_CHECKPRIORITY
#define CONSHDLR_PROP_TIMING
#define CONSHDLR_MAXPREROUNDS
#define CONSHDLR_SEPAPRIORITY
#define CONSHDLR_PROPFREQ
#define CONSHDLR_PRESOLTIMING
#define CONSHDLR_EAGERFREQ
#define CONSHDLR_ENFOPRIORITY
#define CONSHDLR_DELAYSEPA
#define CONSHDLR_DELAYPROP
#define EVENTHDLR_EVENT_TYPE
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)
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 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)
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
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)
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)
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 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)
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 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)
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)
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_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)
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)
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)
struct TCLIQUE_Data TCLIQUE_DATA
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)
struct SCIP_Cons SCIP_CONS
#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)
struct SCIP_Conshdlr SCIP_CONSHDLR
#define SCIP_DECL_CONSCOPY(x)
struct SCIP_ConsData SCIP_CONSDATA
#define SCIP_DECL_CONSCHECK(x)
#define SCIP_DECL_CONSHDLRCOPY(x)
#define SCIP_DECL_CONSEXITSOL(x)
#define SCIP_DECL_CONSFREE(x)
#define SCIP_DECL_CONSSEPASOL(x)
struct SCIP_Eventhdlr SCIP_EVENTHDLR
#define SCIP_EVENTTYPE_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
struct SCIP_Diveset SCIP_DIVESET
#define SCIP_DIVETYPE_SOS1VARIABLE
@ SCIP_BRANCHDIR_DOWNWARDS
enum SCIP_LPSolStat SCIP_LPSOLSTAT
@ SCIP_LPSOLSTAT_TIMELIMIT
@ SCIP_LPSOLSTAT_INFEASIBLE
@ SCIP_LPSOLSTAT_OBJLIMIT
@ SCIP_LPSOLSTAT_ITERLIMIT
struct SCIP_HashMap SCIP_HASHMAP
struct SCIP_Digraph SCIP_DIGRAPH
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
struct SCIP_Node SCIP_NODE
@ SCIP_VARSTATUS_MULTAGGR
@ SCIP_VARSTATUS_AGGREGATED
enum SCIP_Varstatus SCIP_VARSTATUS