70#define CONSHDLR_NAME "logicor"
71#define CONSHDLR_DESC "logic or constraints"
72#define CONSHDLR_SEPAPRIORITY +10000
73#define CONSHDLR_ENFOPRIORITY -2000000
74#define CONSHDLR_CHECKPRIORITY -2000000
75#define CONSHDLR_SEPAFREQ 0
76#define CONSHDLR_PROPFREQ 1
77#define CONSHDLR_EAGERFREQ 100
79#define CONSHDLR_MAXPREROUNDS -1
80#define CONSHDLR_DELAYSEPA FALSE
81#define CONSHDLR_DELAYPROP FALSE
82#define CONSHDLR_NEEDSCONS TRUE
84#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_ALWAYS
85#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP
87#define LINCONSUPGD_PRIORITY +800000
89#define EVENTHDLR_NAME "logicor"
90#define EVENTHDLR_DESC "event handler for logic or constraints"
92#define CONFLICTHDLR_NAME "logicor"
93#define CONFLICTHDLR_DESC "conflict handler creating logic or constraints"
94#define CONFLICTHDLR_PRIORITY LINCONSUPGD_PRIORITY
96#define DEFAULT_PRESOLPAIRWISE TRUE
97#define DEFAULT_STRENGTHEN TRUE
99#define HASHSIZE_LOGICORCONS 500
100#define DEFAULT_PRESOLUSEHASHING TRUE
101#define DEFAULT_DUALPRESOLVING TRUE
102#define DEFAULT_NEGATEDCLIQUE TRUE
103#define DEFAULT_IMPLICATIONS TRUE
108#define AGEINCREASE(n) (1.0 + 0.2 * (n))
110#define AGEINCREASE(n) (0.1 * (n))
121struct SCIP_ConshdlrData
126 SCIP_Bool presolpairwise;
127 SCIP_Bool presolusehashing;
129 SCIP_Bool dualpresolving;
130 SCIP_Bool usenegatedclique;
131 SCIP_Bool useimplications;
133 SCIP_Bool usestrengthening;
137 int nlastcliquesshorten;
138 int nlastimplsshorten;
158 unsigned int signature;
159 unsigned int presolved:1;
162 unsigned int impladded:1;
163 unsigned int sorted:1;
164 unsigned int changed:1;
165 unsigned int merged:1;
166 unsigned int existmultaggr:1;
167 unsigned int validsignature:1;
215 (*conshdlrdata)->nlastcliquesneg = 0;
216 (*conshdlrdata)->nlastimplsneg = 0;
217 (*conshdlrdata)->nlastcliquesshorten = 0;
218 (*conshdlrdata)->nlastimplsshorten = 0;
221 (*conshdlrdata)->eventhdlr = eventhdlr;
248 assert(consdata->nvars <= consdata->varssize);
250 if( num > consdata->varssize )
256 consdata->varssize = newsize;
258 assert(num <= consdata->varssize);
279 (*consdata)->row =
NULL;
280 (*consdata)->nlrow =
NULL;
284 (*consdata)->varssize =
nvars;
285 (*consdata)->nvars =
nvars;
289 (*consdata)->vars =
NULL;
290 (*consdata)->varssize = 0;
291 (*consdata)->nvars = 0;
293 (*consdata)->watchedvar1 = -1;
294 (*consdata)->watchedvar2 = -1;
295 (*consdata)->filterpos1 = -1;
296 (*consdata)->filterpos2 = -1;
297 (*consdata)->presolved =
FALSE;
298 (*consdata)->impladded =
FALSE;
299 (*consdata)->changed =
TRUE;
300 (*consdata)->sorted = (
nvars <= 1);
301 (*consdata)->merged = (
nvars <= 1);
302 (*consdata)->existmultaggr =
FALSE;
303 (*consdata)->validsignature =
FALSE;
311 for( v = 0; v < (*consdata)->nvars; v++ )
322 for( v = 0; v < (*consdata)->nvars; v++ )
345 if( (*consdata)->row !=
NULL )
351 if( (*consdata)->nlrow !=
NULL )
357 for( v = 0; v < (*consdata)->nvars; v++ )
409 assert(watchedvar1 == -1 || watchedvar1 != watchedvar2);
410 assert(watchedvar1 != -1 || watchedvar2 == -1);
411 assert(watchedvar1 == -1 || (0 <= watchedvar1 && watchedvar1 < consdata->
nvars));
412 assert(watchedvar2 == -1 || (0 <= watchedvar2 && watchedvar2 < consdata->
nvars));
415 if( watchedvar1 == consdata->watchedvar2 || watchedvar2 == consdata->watchedvar1 )
419 tmp = consdata->watchedvar1;
420 consdata->watchedvar1 = consdata->watchedvar2;
421 consdata->watchedvar2 = tmp;
422 tmp = consdata->filterpos1;
423 consdata->filterpos1 = consdata->filterpos2;
424 consdata->filterpos2 = tmp;
426 assert(watchedvar1 == -1 || watchedvar1 != consdata->watchedvar2);
427 assert(watchedvar2 == -1 || watchedvar2 != consdata->watchedvar1);
430 if( consdata->watchedvar1 != -1 && consdata->watchedvar1 != watchedvar1 )
432 assert(consdata->filterpos1 != -1);
435 consdata->filterpos1) );
437 if( consdata->watchedvar2 != -1 && consdata->watchedvar2 != watchedvar2 )
439 assert(consdata->filterpos2 != -1);
442 consdata->filterpos2) );
446 if( watchedvar1 != -1 && watchedvar1 != consdata->watchedvar1 )
450 &consdata->filterpos1) );
452 if( watchedvar2 != -1 && watchedvar2 != consdata->watchedvar2 )
456 &consdata->filterpos2) );
460 consdata->watchedvar1 = watchedvar1;
461 consdata->watchedvar2 = watchedvar2;
475 SCIP_Bool transformed;
491 consdata->existmultaggr =
TRUE;
493 consdata->presolved =
FALSE;
499 consdata->vars[consdata->nvars] =
var;
518 consdata->sorted = (consdata->nvars == 1);
519 consdata->changed =
TRUE;
520 consdata->validsignature =
FALSE;
526 if( consdata->row !=
NULL )
531 consdata->merged =
FALSE;
567 if( consdata->watchedvar1 == pos )
571 if( consdata->watchedvar2 == pos )
576 assert(pos != consdata->watchedvar1);
577 assert(pos != consdata->watchedvar2);
583 if( pos != consdata->nvars - 1 )
585 consdata->vars[pos] = consdata->vars[consdata->nvars-1];
586 consdata->sorted =
FALSE;
591 if( consdata->watchedvar1 == consdata->nvars )
592 consdata->watchedvar1 = pos;
593 if( consdata->watchedvar2 == consdata->nvars )
594 consdata->watchedvar2 = pos;
596 consdata->changed =
TRUE;
597 consdata->validsignature =
FALSE;
637 SCIP_Real bestobjval;
638 SCIP_Real bestobjvalnouplocks;
641 SCIP_Bool infeasible;
671 nvars = consdata->nvars;
679 vars = consdata->vars;
690 for( v =
nvars - 1; v >= 0; --v )
701 if( idx == consdata->nvars - 1 )
704 bestvar = consdata->vars[idx];
709 if( idxnouplocks == consdata->nvars - 1 )
712 if( indepidx == consdata->nvars - 1 )
718 assert(bestvar ==
NULL || bestvar == consdata->vars[v]);
741 bestobjvalnouplocks =
objval;
775 nvars = consdata->nvars;
779 if(
nvars == 2 && indepidx >= 0 )
782 SCIP_Bool aggregated;
786 assert(0 <= idx2 && idx2 < 2);
804 if( nfixables == 1 && idxnouplocks >= 0 )
808 for( v =
nvars - 1; v >= 0; --v )
817 assert(idxnouplocks != v);
839 nvars = consdata->nvars;
849 for( v = 0; v <
nvars; ++v )
918 SCIP_Bool* redundant,
940 assert(consdata->nvars == 0 || consdata->vars !=
NULL);
946 consdata->existmultaggr =
FALSE;
947 consdata->presolved =
TRUE;
950 while( v < consdata->
nvars )
952 var = consdata->vars[v];
972 if( consdata->nvars == 0 )
975 nvars = consdata->nvars;
985 for( v =
nvars - 1; v >= 0; --v )
994 SCIP_Real constant = 0.0;
1009 if( requiredsize > nconsvars )
1015 assert(requiredsize <= nconsvars);
1023 for( v2 = nconsvars - 1; v2 >= 0; --v2 )
1044 for( v2 = nconsvars - 1; v2 >= 0; --v2 )
1065 size =
MAX(nconsvars, 1) +
nvars - 1;
1074 for( k =
nvars - 1; k >= 0; --k )
1076 consvars[k] =
vars[k];
1086 if( requiredsize > nconsvars )
1092 assert(requiredsize <= nconsvars);
1095 lhs = 1.0 - constant;
1116 if( ndelconss !=
NULL && naddconss !=
NULL )
1128 if(
var != consdata->vars[v] )
1140 else if(
var != consdata->vars[v] )
1178 consdata->presolved =
TRUE;
1203 for( v = 0; v < consdata->nvars; ++v )
1244 unsigned char** entries,
1246 SCIP_Bool* redundant,
1253 SCIP_Bool* negarray;
1274 nvars = consdata->nvars;
1278 if( consdata->merged )
1281 if( consdata->nvars <= 1 )
1283 consdata->merged =
TRUE;
1298 assert(consdata->presolved);
1304 vars = consdata->vars;
1307 for( v =
nvars - 1; v >= 0; --v )
1328 (*entries)[pos] = 0;
1332 for( v =
nvars - 1; v >= 0; --v )
1340 if( (*entries)[pos] == 0 )
1341 (*entries)[pos] = negarray[v] ? 2 : 1;
1343 else if( (*entries)[pos] == 1 )
1347 SCIPdebugMsg(
scip,
"logicor constraint <%s> redundant: variable <%s> and its negation are present\n",
1364 SCIPdebugMsg(
scip,
"logicor constraint <%s> redundant: variable <%s> and its negation are present\n",
1382 consdata->merged =
TRUE;
1394 SCIP_Bool* reduceddom,
1396 SCIP_Bool* mustcheck
1401 SCIP_Longint nbranchings1;
1402 SCIP_Longint nbranchings2;
1417 assert(consdata->watchedvar1 == -1 || consdata->watchedvar1 != consdata->watchedvar2);
1424 vars = consdata->vars;
1425 nvars = consdata->nvars;
1451 watchedvar1 = consdata->watchedvar1;
1456 if( watchedvar1 == -1 )
1458 watchedvar1 = consdata->watchedvar2;
1463 watchedvar2 = consdata->watchedvar2;
1467 assert(watchedvar1 >= 0 || watchedvar2 == -1);
1468 assert(nbranchings1 <= nbranchings2);
1471 if( watchedvar2 == -1 )
1475 for( v = 0; v <
nvars; ++v )
1477 SCIP_Longint nbranchings;
1480 if( v == consdata->watchedvar1 || v == consdata->watchedvar2 )
1490 assert(v != consdata->watchedvar1);
1491 assert(v != consdata->watchedvar2);
1496 SCIPdebugMsg(
scip,
" -> disabling constraint <%s> (variable <%s> fixed to 1.0)\n",
1498 if( consdata->watchedvar1 != -1 )
1512 assert(nbranchings >= 0);
1513 if( nbranchings < nbranchings2 )
1515 if( nbranchings < nbranchings1 )
1517 watchedvar2 = watchedvar1;
1518 nbranchings2 = nbranchings1;
1520 nbranchings1 = nbranchings;
1525 nbranchings2 = nbranchings;
1530 assert(nbranchings1 <= nbranchings2);
1531 assert(watchedvar1 >= 0 || watchedvar2 == -1);
1533 if( watchedvar1 == -1 )
1539 assert(watchedvar2 == -1);
1555 else if( watchedvar2 == -1 )
1571 SCIPdebugMsg(
scip,
" -> single-literal constraint <%s> (fix <%s> to 1.0) at depth %d\n",
1576 if( watchedvar1 != consdata->watchedvar1 )
1586 SCIPdebugMsg(
scip,
" -> new watched variables <%s> and <%s> of constraint <%s> are still unfixed\n",
1623 vars = consdata->vars;
1624 nvars = consdata->nvars;
1628 for( v = 0; v <
nvars && sum < 1.0; ++v )
1640 SCIP_Real absviol = 1.0 - sum;
1687 if( consdata->nlrow ==
NULL )
1693 for(
i = 0;
i < consdata->nvars; ++
i )
1727 if( consdata->row ==
NULL )
1752 SCIP_Bool* separated,
1753 SCIP_Bool* reduceddom
1757 SCIP_Bool mustcheck;
1797 SCIP_Real feasibility;
1828 SCIP_Bool* infeasible,
1829 SCIP_Bool* reduceddom,
1834 SCIP_Bool mustcheck;
1885 if( !consdata->sorted )
1887 if( consdata->nvars <= 1 )
1888 consdata->sorted =
TRUE;
1895 if( consdata->watchedvar1 != -1 )
1897 var1 = consdata->vars[consdata->watchedvar1];
1899 consdata->watchedvar1 = -1;
1900 if( consdata->watchedvar2 != -1 )
1902 var2 = consdata->vars[consdata->watchedvar2];
1904 consdata->watchedvar2 = -1;
1907 assert(consdata->watchedvar1 == -1);
1908 assert(consdata->watchedvar2 == -1);
1912 SCIPsortPtr((
void**)consdata->vars, SCIPvarComp, consdata->nvars);
1913 consdata->sorted =
TRUE;
1922 found =
SCIPsortedvecFindPtr((
void**)consdata->vars, SCIPvarComp, (
void*)var1, consdata->nvars, &pos);
1925 (void)
SCIPsortedvecFindPtr((
void**)consdata->vars, SCIPvarComp, (
void*)var1, consdata->nvars, &pos);
1928 consdata->watchedvar1 = pos;
1933 found =
SCIPsortedvecFindPtr((
void**)consdata->vars, SCIPvarComp, (
void*)var2, consdata->nvars, &pos);
1936 (void)
SCIPsortedvecFindPtr((
void**)consdata->vars, SCIPvarComp, (
void*)var2, consdata->nvars, &pos);
1939 consdata->watchedvar2 = pos;
1950 for( v = consdata->nvars - 1; v > 0; --v )
1972 SCIP_Bool coefsequal;
1985 if( consdata1->nvars != consdata2->nvars )
1991 assert(consdata1->sorted);
1992 assert(consdata2->sorted);
1996 for(
i = 0;
i < consdata1->nvars ; ++
i )
1999 if( consdata1->vars[
i] != consdata2->vars[
i] )
2023 assert(consdata->sorted);
2024 assert(consdata->nvars > 0);
2029 assert(minidx >= 0 && minidx <= maxidx);
2031 return SCIPhashFour(consdata->nvars, minidx, mididx, maxidx);
2055 hashtablesize = nconss;
2058 hashGetKeyLogicorcons, hashKeyEqLogicorcons, hashKeyValLogicorcons, (
void*)
scip) );
2061 for(
c = 0;
c < nconss; ++
c )
2075 assert(consdata0->sorted);
2093 assert(consdata0->nvars >= 1 && consdata0->nvars == consdata1->nvars);
2095 assert(consdata0->sorted && consdata1->sorted);
2096 assert(consdata0->vars[0] == consdata1->vars[0]);
2136 SCIPdebugMsg(
scip,
" -> removing logicor constraint <%s> which is redundant to <%s>\n",
2159 unsigned int signature = 0;
2165 for( v =
nvars - 1; v >= 0; --v )
2167 signature |= ((
unsigned int)1 << ((
unsigned int)
SCIPvarGetIndex(
vars[v]) % (
sizeof(
unsigned int) * 8)));
2181 if( consdata->validsignature )
2184 consdata->signature =
calcSignature(consdata->vars, consdata->nvars);
2185 consdata->validsignature =
TRUE;
2194 int* noccurlistentries,
2215 nvars = consdata->nvars;
2217 vars = consdata->vars;
2221 for( v =
nvars - 1; v >= 0; --v )
2228 assert(0 < pos && pos <= occurlistlength);
2233 for( l = noccurlistentries[pos] - 1; l >= 0; --l )
2235 if( occurlist[pos][l] == cons )
2237 --noccurlistentries[pos];
2238 assert(noccurlistentries[pos] >= 0);
2240 occurlist[pos][l] = occurlist[pos][noccurlistentries[pos]];
2255 int* noccurlistentries,
2256 int occurlistlength,
2273 *nentries = INT_MAX;
2274 *shortestlist =
NULL;
2277 for( v =
nvars - 1; v >= 0; --v )
2290 assert(0 < pos && pos <= occurlistlength);
2295 if( noccurlistentries[pos] < *nentries )
2297 *nentries = noccurlistentries[pos];
2298 *shortestlist = occurlist[pos];
2310 int* noccurlistentries,
2311 int occurlistlength,
2335 assert(consdata->nvars > 1);
2336 assert(consdata->validsignature);
2337 assert(consdata->sorted);
2339 vars = consdata->vars;
2343 findShortestOccurlist(
vars, consdata->nvars, varstopos, occurlist, noccurlistentries, occurlistlength, &nentries, &shortestlist);
2353 for(
c = nentries - 1;
c >= 0; --
c )
2355 cons1 = shortestlist[
c];
2364 assert(consdata1->nvars >= consdata->nvars);
2369 if( consdata1->nvars == consdata->nvars )
2372 assert(consdata->validsignature);
2373 assert(consdata->sorted);
2374 assert(consdata1->validsignature);
2375 assert(consdata1->sorted);
2377 if( (consdata->signature & (~consdata1->signature)) == 0 )
2385 while( v < consdata->
nvars && v1 < consdata1->
nvars )
2390 var1 = consdata1->vars[v1];
2406 if( v == consdata->nvars )
2437 return consdata1->nvars - consdata2->nvars;
2447 int* noccurlistentries,
2448 int* occurlistsizes,
2449 int* occurlistlength,
2467 assert(*occurlistlength <= occurlistsize);
2471 assert(consdata->nvars > 1);
2473 vars = consdata->vars;
2476 for( v = consdata->nvars - 1; v >= 0; --v )
2485 pos = *occurlistlength;
2486 assert(pos <= occurlistsize);
2490 assert(noccurlistentries[pos] == 0);
2491 assert(occurlistsizes[pos] == 0);
2499 occurlist[pos][noccurlistentries[pos]] = cons;
2500 ++(noccurlistentries[pos]);
2505 ++(*occurlistlength);
2510 assert(0 < pos && pos <= *occurlistlength);
2515 assert(occurlistsizes[pos] > 0);
2518 if( noccurlistentries[pos] == occurlistsizes[pos] )
2521 assert(occurlistsizes[pos] > noccurlistentries[pos] && occurlistsizes[pos] < INT_MAX);
2526 assert(noccurlistentries[pos] < occurlistsizes[pos]);
2529 occurlist[pos][noccurlistentries[pos]] = cons;
2530 ++(noccurlistentries[pos]);
2548 int* noccurlistentries,
2549 int occurlistlength,
2561 unsigned int signature;
2582 assert(consdata->sorted);
2584 nvars = consdata->nvars;
2588 vars = consdata->vars;
2594 oldvar =
vars[artpos];
2596 vars[artpos] = artvar;
2602 vars[artpos] = oldvar;
2612 oldvar =
vars[artpos];
2613 vars[artpos] = artvar;
2617 vars[artpos] = oldvar;
2620 for(
c = nentries - 1;
c >= 0; --
c )
2622 cons1 = shortestlist[
c];
2635 if( consdata1->nvars <
nvars )
2640 assert(consdata->sorted);
2641 assert(consdata->merged);
2642 assert(consdata1->validsignature);
2643 assert(consdata1->sorted);
2644 assert(consdata1->merged);
2646 if( (signature & (~consdata1->signature)) == 0 )
2665 var1 = consdata1->vars[v1];
2668 if( artvar == var1 )
2703 while( v1 < consdata1->
nvars )
2705 if( artvar == consdata1->vars[v1] )
2720 assert(artvar == consdata1->vars[pos]);
2723 SCIPdebugMsg(
scip,
"variable %s in logicor constraint <%s> is redundant and will be removed (used constraint %s)\n",
2728 if( consdata1->nvars >
nvars )
2731 assert(0 < pos && pos <= occurlistlength);
2736 for( l = noccurlistentries[pos] - 1; l >= 0; --l )
2738 if( occurlist[pos][l] == cons1 )
2740 --noccurlistentries[pos];
2741 assert(noccurlistentries[pos] >= 0);
2743 occurlist[pos][l] = occurlist[pos][noccurlistentries[pos]];
2754 SCIPdebugMsg(
scip,
"logicor constraint <%s> is redundant due to constraint <%s> after removing variable <%s>\n",
2792 int* noccurlistentries,
2793 int occurlistlength,
2821 for(
c = 0;
c < nconss; ++
c )
2833 nvars = consdata->nvars;
2839 vars = consdata->vars;
2842 for( v =
nvars - 1; v >= 0; --v )
2857 occurlistlength, eventhdlr, nchgcoefs, &deleted) );
2881 unsigned char** entries,
2883 SCIP_Bool* redundant,
2906 assert(consdata->nvars > 0);
2911 if( !consdata->presolved )
2931 if( consdata->nvars == 0 )
2935 else if( consdata->nvars == 1 )
2937 SCIP_Bool infeasible;
2940 SCIPdebugMsg(
scip,
" -> fix last remaining variable and delete constraint\n");
2952 consdata->presolved =
TRUE;
2977 unsigned char** entries,
2981 SCIP_Bool usestrengthening,
2995 int* noccurlistentries;
2996 int* occurlistsizes;
2997 SCIP_Bool redundant;
2998 SCIP_Bool conschanged;
3001 int occurlistlength;
3014 assert(0 <= *firstchange);
3019 if( *firstchange > nconss || nconss < 2 )
3022 SCIPdebugMsg(
scip,
"starting removeRedundantConssAndNonzeros(), pairwise comparison to detect covered logicor constraints\n");
3028 lastnfixedvars = -1;
3029 while( *nfixedvars != lastnfixedvars )
3031 lastnfixedvars = *nfixedvars;
3032 for(
c = nconss - 1;
c >= 0; --
c )
3039 myconss[
c] = myconss[nmyconss - 1];
3053 myconss[
c] = myconss[nmyconss - 1];
3071 assert(consdata->nvars >= 2);
3075 SCIPsortPtr((
void**)myconss, conssLogicorComp, nmyconss);
3115 nmaxvars = consdata->nvars;
3117 occurlistlength = 0;
3118 conschanged =
FALSE;
3125 assert(consdata->validsignature);
3126 conschanged = conschanged || consdata->changed;
3127 consdata->changed =
FALSE;
3142 while( consdata->nvars == nmaxvars );
3155 assert(consdata->validsignature);
3158 if( conschanged || consdata->changed )
3170 consdata->changed =
FALSE;
3195 SCIP_CALL(
strengthenConss(
scip, myconss, nmyconss, varstopos, occurlist, noccurlistentries, occurlistlength, eventhdlr, ndelconss, nchgcoefs) );
3198 for( --occurlistsize ; occurlistsize >= 0; --occurlistsize )
3200 assert((occurlistsizes[occurlistsize] == 0) == (occurlist[occurlistsize] ==
NULL));
3214#define MAX_CONSLENGTH 200
3226 unsigned char** entries,
3238 SCIP_Bool* boundtypes;
3239 SCIP_Bool* redundants;
3275 for(
c = nconss - 1;
c >= 0; --
c )
3277 SCIP_Bool redundant =
FALSE;
3291 consdata->presolved =
FALSE;
3303 assert(consdata->nvars >= 2);
3310 for( v = consdata->nvars - 1; v >= 0; --v)
3312 var = consdata->vars[v];
3320 boundtypes[v] =
FALSE;
3326 boundtypes[v] =
TRUE;
3360 for( v = consdata->nvars - 1; v >= 0; --v )
3367 redundants[v] =
FALSE;
3370 *nchgcoefs += nredvars;
3373 if( consdata->nvars == 1 )
3375 SCIP_Bool infeasible;
3378 SCIPdebugMsg(
scip,
" -> fix last remaining variable and delete constraint\n");
3394 for(
c = nconss - 1;
c >= 0; --
c )
3404 consdata->presolved =
FALSE;
3417#define MAXCOMPARISONS 1000000
3430 unsigned char** entries,
3446 SCIP_Bool redundant;
3487 for(
c = nconss - 1;
c >= 0; --
c )
3513 assert(consdata->nvars >= 2);
3514 assert(consdata->nvars <= size);
3515 assert(consdata->presolved);
3531 for( v = consdata->nvars - 1; v >= 0; --v )
3537 for( v = consdata->nvars - 1; v > 0; --v )
3539 SCIP_Bool breakloop;
3565 comppercons += (v - 1);
3569 for(
w = v - 1;
w >= 0; --
w )
3600 SCIPdebugMsg(
scip,
"logicor constraint <%s> is redundant, because variable <%s> and its negation <%s> exist\n",
3610 SCIP_VAR* lastvar = consdata->vars[consdata->nvars - 1];
3612 SCIPdebugMsg(
scip,
"in logicor constraint <%s>, active variable of <%s> and active variable of <%s> are the same, removing the first\n",
3617 if( v < consdata->
nvars )
3622 assert(consdata->vars[v] == lastvar);
3623 negated[v] = negated[consdata->nvars];
3662 SCIPdebugMsg(
scip,
"logicor constraint <%s> is redundant due to negated clique information and will be replaced by a setppc constraint \n",
3677 if( comppercons > maxcomppercons )
3713 SCIP_Bool infeasible;
3738 if( consdata->nvars == 2 )
3741 if( !consdata->impladded )
3743 SCIP_Bool implinfeasible;
3745 SCIP_Bool values[2];
3753 *nchgbds += nimplbdchgs;
3754 if( implinfeasible )
3761 if ( nimplbdchgs > 0 )
3763 SCIP_Bool redundant;
3779 consdata->impladded =
TRUE;
3783 if( consdata->nvars == 2 && conshdlrsetppc !=
NULL )
3813 if( consdata->nvars == 0 )
3819 else if( consdata->nvars == 1 )
3821 SCIPdebugMsg(
scip,
"logic or constraint <%s> has only one variable not fixed to 0.0\n",
3845 else if( conshdlrlinear !=
NULL )
3851 SCIPdebugMsg(
scip,
" -> variable is multi-aggregated, upgrade to linear constraint <%s> == 1 \n",
3902 SCIP_Bool modifiable,
3908 SCIP_Bool removable,
3910 SCIP_Bool stickingatnode
3920 assert(mult == +1 || mult == -1);
3926 for( v = 0; v <
nvars; ++v )
3928 if( mult * vals[v] > 0.0 )
3929 transvars[v] =
vars[v];
3939 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
3963 if(
nvars > 2 && nposbin + nnegbin + nposimplbin + nnegimplbin ==
nvars && ncoeffspone + ncoeffsnone ==
nvars
4000 SCIP_Bool separated;
4001 SCIP_Bool reduceddom;
4009 SCIPdebugMsg(
scip,
"Enforcing %d logic or constraints for %s solution\n", nconss,
sol ==
NULL ?
"LP" :
"relaxation");
4021 for(
c = 0;
c < nusefulconss && !
cutoff && !reduceddom; ++
c )
4027 for(
c = nusefulconss;
c < nconss && !
cutoff && !separated && !reduceddom; ++
c )
4035 else if( separated )
4037 else if( reduceddom )
4057 SCIP_Real constant = 0.0;
4078 for(
i = 0;
i < consdata->nvars; ++
i )
4080 vars[
i] = logicorvars[
i];
4150 conshdlrdata->nlastcliquesneg = 0;
4151 conshdlrdata->nlastimplsneg = 0;
4152 conshdlrdata->nlastcliquesshorten = 0;
4153 conshdlrdata->nlastimplsshorten = 0;
4156 for(
c = nconss - 1;
c >= 0; --
c )
4161 for( v = consdata->nvars - 1; v >= 0; --v )
4185 for(
c = 0;
c < nconss; ++
c )
4190 for( v = 0; v < consdata->nvars; ++v )
4198 SCIP_Bool redundant;
4217 consdata->presolved =
FALSE;
4234 for(
c = 0;
c < nconss; ++
c )
4251 for(
c = 0;
c < nconss; ++
c )
4256 if( consdata->row !=
NULL )
4261 if( consdata->nlrow !=
NULL )
4288 for( v = (*consdata)->nvars - 1; v >= 0; --v )
4341 *infeasible =
FALSE;
4343 for(
c = 0;
c < nconss && !(*infeasible); ++
c )
4359 SCIP_Bool separated;
4360 SCIP_Bool reduceddom;
4368 SCIPdebugMsg(
scip,
"separating %d/%d logic or constraints\n", nusefulconss, nconss);
4378 for(
c = 0;
c < nusefulconss && !
cutoff; ++
c )
4389 else if( reduceddom )
4391 else if( separated )
4406 SCIP_Bool separated;
4407 SCIP_Bool reduceddom;
4415 SCIPdebugMsg(
scip,
"separating %d/%d logic or constraints\n", nusefulconss, nconss);
4425 for(
c = 0;
c < nusefulconss && !
cutoff; ++
c )
4436 else if( reduceddom )
4438 else if( separated )
4473 SCIP_Bool infeasible;
4474 SCIP_Bool reduceddom;
4496 for(
c = 0;
c < nconss && !
cutoff && !reduceddom && !solvelp; ++
c )
4503 else if( reduceddom )
4507 else if( infeasible )
4546 for( v = 0; v < consdata->nvars; ++v )
4571 SCIP_Bool reduceddom;
4573 SCIP_Bool mustcheck;
4591 for(
c = 0;
c < nusefulconss && !
cutoff; ++
c )
4602 else if( reduceddom )
4617 unsigned char* entries;
4618 SCIP_Bool redundant;
4640 oldnfixedvars = *nfixedvars;
4641 oldnchgbds = *nchgbds;
4642 oldndelconss = *ndelconss;
4643 oldnupgdconss = *nupgdconss;
4644 oldnchgcoefs = *nchgcoefs;
4646 firstchange = INT_MAX;
4667 if( !consdata->presolved )
4693 if( consdata->nvars <= 2 )
4699 conshdlrdata->conshdlrsetppc, nfixedvars, nchgbds, nchgcoefs, ndelconss, naddconss, nupgdconss, &
cutoff) );
4706 else if( *nfixedvars > oldnfixedvars || *nchgbds > oldnchgbds || *nchgcoefs > oldnchgcoefs
4707 || *ndelconss > oldndelconss || *nupgdconss > oldnupgdconss )
4725 if( consdata->nvars <= 2 )
4731 conshdlrdata->conshdlrsetppc, nfixedvars, nchgbds, nchgcoefs, ndelconss, naddconss, nupgdconss, &
cutoff) );
4738 else if( *nfixedvars > oldnfixedvars || *nchgbds > oldnchgbds || *nchgcoefs > oldnchgcoefs
4739 || *ndelconss > oldndelconss || *nupgdconss > oldnupgdconss )
4748 if( firstchange == INT_MAX && consdata->changed )
4757 if( firstchange < nconss && conshdlrdata->presolusehashing )
4772 conshdlrdata->usestrengthening, &firstchange, nfixedvars, ndelconss, nchgcoefs, &
cutoff) );
4789 &entries, &nentries, nfixedvars, ndelconss, nchgcoefs, &
cutoff) );
4802 conshdlrdata->eventhdlr, conss, nconss, &entries, &nentries, nfixedvars, ndelconss,
4803 nupgdconss, nchgcoefs, &
cutoff) );
4828 SCIP_Bool infervarfound;
4841 SCIPdebugMsg(
scip,
"conflict resolving method of logic or constraint handler\n");
4849 infervarfound =
FALSE;
4851 for( v = 0; v < consdata->nvars; ++v )
4853 if( consdata->vars[v] != infervar )
4863 infervarfound =
TRUE;
4886 for(
i = 0;
i < consdata->nvars; ++
i )
4911 assert(consdata->watchedvar1 == -1 || consdata->watchedvar1 != consdata->watchedvar2);
4917 if( consdata->watchedvar1 != -1 )
4921 &consdata->filterpos1) );
4923 if( consdata->watchedvar2 != -1 )
4927 &consdata->filterpos2) );
4955 assert(consdata->watchedvar1 == -1 || consdata->watchedvar1 != consdata->watchedvar2);
4961 if( consdata->watchedvar1 != -1 )
4963 assert(consdata->filterpos1 != -1);
4966 consdata->filterpos1) );
4967 consdata->watchedvar1 = -1;
4968 consdata->filterpos1 = -1;
4970 if( consdata->watchedvar2 != -1 )
4972 assert(consdata->filterpos2 != -1);
4975 consdata->filterpos2) );
4976 consdata->watchedvar2 = -1;
4977 consdata->filterpos2 = -1;
5010 const char* consname;
5025 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode, global,
valid) );
5048 startptr = strchr((
char*)str,
'(');
5050 if( startptr ==
NULL )
5060 endptr = strrchr(startptr,
')');
5062 if( endptr ==
NULL )
5067 assert(endptr >= startptr);
5069 if( endptr > startptr )
5073 strcopy[endptr-startptr] =
'\0';
5086 if( varssize < requiredsize )
5089 varssize = requiredsize;
5097 assert(varssize >= requiredsize);
5101 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
5118 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
5135 if( varssize < consdata->
nvars )
5157 (*nvars) = consdata->nvars;
5193 SCIPdebugMsg(
scip,
"exec method of event handler for logic or constraints\n");
5221 consdata->presolved =
FALSE;
5228 consdata->merged =
FALSE;
5230 if( !consdata->existmultaggr )
5233 consdata->existmultaggr =
TRUE;
5256 assert(bdchginfos !=
NULL || nbdchginfos == 0);
5266 if( nbdchginfos == 2 )
5273 for(
i = 0;
i < nbdchginfos; ++
i )
5291 if(
i == nbdchginfos )
5330 eventExecLogicor,
NULL) );
5334 conflictExecLogicor,
NULL) );
5342 consEnfolpLogicor, consEnfopsLogicor, consCheckLogicor, consLockLogicor,
5375 if( conshdlrdata->conshdlrlinear !=
NULL )
5383 "constraints/logicor/presolpairwise",
5384 "should pairwise constraint comparison be performed in presolving?",
5387 "constraints/logicor/presolusehashing",
5388 "should hash table be used for detecting redundant constraints in advance",
5391 "constraints/logicor/dualpresolving",
5392 "should dual presolving steps be performed?",
5395 "constraints/logicor/negatedclique",
5396 "should negated clique information be used in presolving",
5399 "constraints/logicor/implications",
5400 "should implications/cliques be used in presolving",
5403 "constraints/logicor/strengthen",
5404 "should pairwise constraint comparison try to strengthen constraints by removing superflous non-zeros?",
5433 SCIP_Bool modifiable,
5439 SCIP_Bool removable,
5441 SCIP_Bool stickingatnode
5453 if( conshdlr ==
NULL )
5463 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
5464 local, modifiable, dynamic, removable, stickingatnode) );
5474 for( v = consdata->nvars - 1; v >= 0; --v )
5551 return consdata->nvars;
5574 return consdata->vars;
5597 if( consdata->row !=
NULL )
5623 if( consdata->row !=
NULL )
5651 return consdata->row;
5657 SCIP_Bool onlychecked,
5666 unsigned char* entries;
5672 if( conshdlr ==
NULL )
5687 for(
i = nconss - 1;
i >= 0; --
i )
5690 SCIP_Bool redundant;
Constraint handler for linear constraints in their most general form, .
static SCIP_Bool isConsViolated(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol)
static SCIP_RETCODE addCoef(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
#define DEFAULT_DUALPRESOLVING
#define DEFAULT_IMPLICATIONS
#define CONSHDLR_NEEDSCONS
#define CONSHDLR_SEPAFREQ
#define CONFLICTHDLR_PRIORITY
static void consdataCalcSignature(SCIP_CONSDATA *consdata)
#define CONFLICTHDLR_NAME
static SCIP_RETCODE addCut(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff)
static SCIP_RETCODE delCoefPos(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, int pos)
#define CONSHDLR_CHECKPRIORITY
static SCIP_RETCODE createRow(SCIP *scip, SCIP_CONS *cons)
static SCIP_RETCODE processWatchedVars(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool *cutoff, SCIP_Bool *reduceddom, SCIP_Bool *addcut, SCIP_Bool *mustcheck)
static SCIP_RETCODE analyzeConflict(SCIP *scip, SCIP_CONS *cons)
#define CONSHDLR_PROP_TIMING
static SCIP_RETCODE addConsToOccurList(SCIP *scip, SCIP_CONS *cons, SCIP_HASHMAP *varstopos, SCIP_CONS ***occurlist, int *noccurlistentries, int *occurlistsizes, int *occurlistlength, int occurlistsize)
#define CONFLICTHDLR_DESC
static void conshdlrdataFree(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata)
static SCIP_RETCODE removeConstraintsDueToNegCliques(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLR *conshdlrsetppc, SCIP_EVENTHDLR *eventhdlr, SCIP_CONS **conss, int nconss, unsigned char **entries, int *nentries, int *nfixedvars, int *ndelconss, int *nupgdconss, int *nchgcoefs, SCIP_Bool *cutoff)
static SCIP_RETCODE unlockRounding(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
#define DEFAULT_STRENGTHEN
static SCIP_RETCODE removeRedundantConss(SCIP *scip, SCIP_CONS *cons, SCIP_HASHMAP *varstopos, SCIP_CONS ***occurlist, int *noccurlistentries, int occurlistlength, int *ndelconss)
#define CONSHDLR_MAXPREROUNDS
static void findShortestOccurlist(SCIP_VAR **vars, int nvars, SCIP_HASHMAP *varstopos, SCIP_CONS ***occurlist, int *noccurlistentries, int occurlistlength, int *nentries, SCIP_CONS ***shortestlist)
static SCIP_RETCODE removeRedundantConssAndNonzeros(SCIP *scip, SCIP_CONS **conss, int nconss, unsigned char **entries, int *nentries, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool usestrengthening, int *firstchange, int *nfixedvars, int *ndelconss, int *nchgcoefs, SCIP_Bool *cutoff)
static SCIP_RETCODE prepareCons(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, unsigned char **entries, int *nentries, SCIP_Bool *redundant, int *nfixedvars, int *nchgcoefs, int *ndelconss, SCIP_Bool *cutoff)
#define DEFAULT_PRESOLPAIRWISE
#define CONSHDLR_SEPAPRIORITY
static SCIP_RETCODE enforcePseudo(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool *cutoff, SCIP_Bool *infeasible, SCIP_Bool *reduceddom, SCIP_Bool *solvelp)
#define DEFAULT_NEGATEDCLIQUE
static SCIP_RETCODE createNormalizedLogicor(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, int mult, 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)
static SCIP_RETCODE dualPresolving(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, int *nfixedvars, int *ndelconss, int *nchgcoefs, int *naggrvars, SCIP_RESULT *result)
static SCIP_RETCODE addSymmetryInformation(SCIP *scip, SYM_SYMTYPE symtype, SCIP_CONS *cons, SYM_GRAPH *graph, SCIP_Bool *success)
static SCIP_RETCODE lockRounding(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
static SCIP_RETCODE shortenConss(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_EVENTHDLR *eventhdlr, SCIP_CONS **conss, int nconss, unsigned char **entries, int *nentries, int *nfixedvars, int *ndelconss, int *nchgcoefs, SCIP_Bool *cutoff)
static SCIP_RETCODE consdataEnsureVarsSize(SCIP *scip, SCIP_CONSDATA *consdata, int num)
#define DEFAULT_PRESOLUSEHASHING
static SCIP_RETCODE switchWatchedvars(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, int watchedvar1, int watchedvar2)
static SCIP_RETCODE fixDeleteOrUpgradeCons(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, SCIP_CONSHDLR *conshdlrlinear, SCIP_CONSHDLR *conshdlrsetppc, int *nfixedvars, int *nchgbds, int *nchgcoefs, int *ndelconss, int *naddconss, int *nupgdconss, SCIP_Bool *cutoff)
#define HASHSIZE_LOGICORCONS
static unsigned int calcSignature(SCIP_VAR **vars, int nvars)
#define CONSHDLR_PROPFREQ
static SCIP_RETCODE detectRedundantConstraints(SCIP *scip, BMS_BLKMEM *blkmem, SCIP_CONS **conss, int nconss, int *firstchange, int *ndelconss)
static SCIP_RETCODE separateCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool *cutoff, SCIP_Bool *separated, SCIP_Bool *reduceddom)
#define CONSHDLR_PRESOLTIMING
static SCIP_RETCODE enforceConstraint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int nusefulconss, SCIP_SOL *sol, SCIP_RESULT *result)
static SCIP_RETCODE consdataFree(SCIP *scip, SCIP_CONSDATA **consdata)
static void consdataSort(SCIP_CONSDATA *consdata)
static SCIP_RETCODE addNlrow(SCIP *scip, SCIP_CONS *cons)
static SCIP_RETCODE strengthenConss(SCIP *scip, SCIP_CONS **conss, int nconss, SCIP_HASHMAP *varstopos, SCIP_CONS ***occurlist, int *noccurlistentries, int occurlistlength, SCIP_EVENTHDLR *eventhdlr, int *ndelconss, int *nchgcoefs)
#define CONSHDLR_EAGERFREQ
static SCIP_RETCODE conshdlrdataCreate(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata, SCIP_EVENTHDLR *eventhdlr)
static SCIP_RETCODE mergeMultiples(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, unsigned char **entries, int *nentries, SCIP_Bool *redundant, int *nchgcoefs)
#define CONSHDLR_ENFOPRIORITY
#define LINCONSUPGD_PRIORITY
#define CONSHDLR_DELAYSEPA
static void removeConsFromOccurList(SCIP_CONS *cons, SCIP_HASHMAP *varstopos, SCIP_CONS ***occurlist, int *noccurlistentries, int occurlistlength)
static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_CONSDATA **consdata, int nvars, SCIP_VAR **vars)
static SCIP_RETCODE applyFixings(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool *redundant, int *nchgcoefs, int *naddconss, int *ndelconss)
static SCIP_RETCODE disableCons(SCIP *scip, SCIP_CONS *cons)
static SCIP_RETCODE removeRedundantCons(SCIP *scip, SCIP_CONS *cons0, SCIP_CONS *cons1, int *ndelconss)
#define CONSHDLR_DELAYPROP
static SCIP_RETCODE removeRedundantNonZeros(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *artvar, int artpos, SCIP_HASHMAP *varstopos, SCIP_CONS ***occurlist, int *noccurlistentries, int occurlistlength, SCIP_EVENTHDLR *eventhdlr, int *nchgcoefs, SCIP_Bool *deleted)
static SCIP_RETCODE consdataPrint(SCIP *scip, SCIP_CONSDATA *consdata, FILE *file, SCIP_Bool endline)
Constraint handler for logicor constraints (equivalent to set covering, but algorithms are suited fo...
Constraint handler for the set partitioning / packing / covering constraints .
#define SCIP_LONGINT_FORMAT
SCIP_RETCODE SCIPincludeLinconsUpgrade(SCIP *scip, SCIP_DECL_LINCONSUPGD((*linconsupgd)), int priority, const char *conshdlrname)
int SCIPgetNVarsLogicor(SCIP *scip, SCIP_CONS *cons)
SCIP_Real SCIPgetDualsolLogicor(SCIP *scip, SCIP_CONS *cons)
SCIP_ROW * SCIPgetRowLogicor(SCIP *scip, SCIP_CONS *cons)
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_RETCODE SCIPcleanupConssLogicor(SCIP *scip, SCIP_Bool onlychecked, int *naddconss, int *ndelconss, int *nchgcoefs)
#define SCIP_DECL_LINCONSUPGD(x)
SCIP_RETCODE SCIPcopyConsLinear(SCIP *scip, SCIP_CONS **cons, SCIP *sourcescip, const char *name, int nvars, SCIP_VAR **sourcevars, SCIP_Real *sourcecoefs, SCIP_Real lhs, SCIP_Real rhs, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, 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 global, SCIP_Bool *valid)
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 ** SCIPgetVarsLogicor(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsBasicLogicor(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars)
SCIP_RETCODE SCIPcreateConsLogicor(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 SCIPgetDualfarkasLogicor(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPaddCoefLogicor(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
SCIP_RETCODE SCIPincludeConshdlrLogicor(SCIP *scip)
SCIP_Bool SCIPisTransformed(SCIP *scip)
SCIP_Bool SCIPisPresolveFinished(SCIP *scip)
SCIP_Bool SCIPisStopped(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
int SCIPgetNIntVars(SCIP *scip)
int SCIPgetNImplVars(SCIP *scip)
int SCIPgetNContVars(SCIP *scip)
int SCIPgetNVars(SCIP *scip)
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)
int SCIPgetNBinVars(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)
void SCIPhashtableFree(SCIP_HASHTABLE **hashtable)
#define SCIPhashFour(a, b, c, d)
SCIP_RETCODE SCIPhashtableCreate(SCIP_HASHTABLE **hashtable, BMS_BLKMEM *blkmem, int tablesize, SCIP_DECL_HASHGETKEY((*hashgetkey)), SCIP_DECL_HASHKEYEQ((*hashkeyeq)), SCIP_DECL_HASHKEYVAL((*hashkeyval)), void *userptr)
void * SCIPhashtableRetrieve(SCIP_HASHTABLE *hashtable, void *key)
SCIP_RETCODE SCIPhashtableInsert(SCIP_HASHTABLE *hashtable, void *element)
SCIP_RETCODE SCIPaddConflict(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPaddBoolParam(SCIP *scip, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPinitConflictAnalysis(SCIP *scip, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
const char * SCIPconflicthdlrGetName(SCIP_CONFLICTHDLR *conflicthdlr)
SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)
SCIP_RETCODE SCIPaddConflictBinvar(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPanalyzeConflictCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)
SCIP_RETCODE SCIPincludeConflicthdlrBasic(SCIP *scip, SCIP_CONFLICTHDLR **conflicthdlrptr, const char *name, const char *desc, int priority, SCIP_DECL_CONFLICTEXEC((*conflictexec)), SCIP_CONFLICTHDLRDATA *conflicthdlrdata)
int SCIPconshdlrGetNCheckConss(SCIP_CONSHDLR *conshdlr)
void SCIPconshdlrSetData(SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata)
SCIP_RETCODE SCIPsetConshdlrFree(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrActive(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONS ** SCIPconshdlrGetCheckConss(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrPresol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)
SCIP_RETCODE SCIPsetConshdlrInitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrSepa(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), int sepafreq, int sepapriority, SCIP_Bool delaysepa)
SCIP_RETCODE SCIPsetConshdlrProp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPROP((*consprop)), int propfreq, SCIP_Bool delayprop, SCIP_PROPTIMING proptiming)
SCIP_RETCODE SCIPsetConshdlrEnforelax(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPincludeConshdlrBasic(SCIP *scip, SCIP_CONSHDLR **conshdlrptr, const char *name, const char *desc, int enfopriority, int chckpriority, int eagerfreq, SCIP_Bool needscons, SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_CONSHDLRDATA *conshdlrdata)
SCIP_RETCODE SCIPsetConshdlrParse(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrGetVars(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrPrint(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrGetSignedPermsymGraph(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrCopy(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)),)
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
SCIP_RETCODE SCIPsetConshdlrGetPermsymGraph(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrDelete(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrInitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrDeactive(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONSHDLRDATA * SCIPconshdlrGetData(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNActiveConss(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrTrans(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrResprop(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrExitpre(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)
int SCIPconsGetPos(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)
SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)
SCIP_RETCODE SCIPenableCons(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPconsIsPropagationEnabled(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)
SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)
SCIP_RETCODE SCIPenableConsPropagation(SCIP *scip, SCIP_CONS *cons)
int SCIPconsGetValidDepth(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsTransformed(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsActive(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)
SCIP_RETCODE SCIPdisableCons(SCIP *scip, 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 SCIPconsIsAdded(SCIP_CONS *cons)
SCIP_RETCODE SCIPupdateConsFlags(SCIP *scip, SCIP_CONS *cons0, SCIP_CONS *cons1)
SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)
SCIP_RETCODE SCIPdisableConsPropagation(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPaddConsAge(SCIP *scip, SCIP_CONS *cons, SCIP_Real deltaage)
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)
SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)
SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
const char * SCIPeventhdlrGetName(SCIP_EVENTHDLR *eventhdlr)
SCIP_EVENTTYPE SCIPeventGetType(SCIP_EVENT *event)
SCIP_RETCODE SCIPcatchVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
SCIP_RETCODE SCIPdropVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
SCIP_VAR * SCIPeventGetVar(SCIP_EVENT *event)
SCIP_Bool SCIPhasCurrentNodeLP(SCIP *scip)
#define SCIPfreeCleanBufferArray(scip, ptr)
#define SCIPallocCleanBufferArray(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 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_RETCODE SCIPdelNlRow(SCIP *scip, SCIP_NLROW *nlrow)
SCIP_RETCODE SCIPaddNlRow(SCIP *scip, SCIP_NLROW *nlrow)
SCIP_Bool SCIPisNLPConstructed(SCIP *scip)
SCIP_RETCODE SCIPreleaseNlRow(SCIP *scip, SCIP_NLROW **nlrow)
SCIP_Bool SCIPnlrowIsInNLP(SCIP_NLROW *nlrow)
SCIP_RETCODE SCIPcreateNlRow(SCIP *scip, SCIP_NLROW **nlrow, const char *name, SCIP_Real constant, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, SCIP_EXPR *expr, SCIP_Real lhs, SCIP_Real rhs, SCIP_EXPRCURV curvature)
SCIP_Bool SCIPinProbing(SCIP *scip)
SCIP_RETCODE SCIPaddVarsToRowSameCoef(SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real val)
SCIP_RETCODE SCIPcreateEmptyRowCons(SCIP *scip, SCIP_ROW **row, SCIP_CONS *cons, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
SCIP_Real SCIProwGetDualfarkas(SCIP_ROW *row)
SCIP_Real SCIPgetRowLPFeasibility(SCIP *scip, SCIP_ROW *row)
SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)
SCIP_Real SCIProwGetDualsol(SCIP_ROW *row)
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
void SCIPupdateSolLPConsViolation(SCIP *scip, SCIP_SOL *sol, SCIP_Real absviol, SCIP_Real relviol)
int SCIPgetNImplications(SCIP *scip)
int SCIPgetNRuns(SCIP *scip)
SCIP_Longint SCIPgetNConflictConssApplied(SCIP *scip)
SCIP_RETCODE SCIPshrinkDisjunctiveVarSet(SCIP *scip, SCIP_VAR **vars, SCIP_Real *bounds, SCIP_Bool *boundtypes, SCIP_Bool *redundants, int nvars, int *nredvars, int *nglobalred, SCIP_Bool *setredundant, SCIP_Bool *glbinfeas, SCIP_Bool fullshortening)
SCIP_RETCODE SCIPgetSymActiveVariables(SCIP *scip, SYM_SYMTYPE symtype, SCIP_VAR ***vars, SCIP_Real **scalars, int *nvars, SCIP_Real *constant, SCIP_Bool transformed)
SCIP_RETCODE SCIPextendPermsymDetectionGraphLinear(SCIP *scip, SYM_GRAPH *graph, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_CONS *cons, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool *success)
SCIP_Bool SCIPisFeasGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasNegative(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
int SCIPgetDepth(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 SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
SCIP_VAR * SCIPvarGetNegatedVar(SCIP_VAR *var)
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_RETCODE SCIPaddClique(SCIP *scip, SCIP_VAR **vars, SCIP_Bool *values, int nvars, SCIP_Bool isequation, SCIP_Bool *infeasible, int *nbdchgs)
SCIP_RETCODE SCIPgetTransformedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
int SCIPvarGetNImpls(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_RETCODE SCIPvarGetAggregatedObj(SCIP_VAR *var, SCIP_Real *aggrobj)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_RETCODE SCIPgetBinvarRepresentatives(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **repvars, SCIP_Bool *negated)
SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)
SCIP_RETCODE SCIPparseVarsList(SCIP *scip, const char *str, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize, char **endptr, char delimiter, SCIP_Bool *success)
SCIP_RETCODE SCIPaggregateVars(SCIP *scip, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_Real scalarx, SCIP_Real scalary, SCIP_Real rhs, SCIP_Bool *infeasible, SCIP_Bool *redundant, SCIP_Bool *aggregated)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetProbvar(SCIP_VAR *var)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
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)
int SCIPvarGetProbindex(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_VAR * SCIPbdchginfoGetVar(SCIP_BDCHGINFO *bdchginfo)
SCIP_RETCODE SCIPcleanupCliques(SCIP *scip, SCIP_Bool *infeasible)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)
int SCIPvarGetNCliques(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsNegated(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetNegationVar(SCIP_VAR *var)
int SCIPgetNCliques(SCIP *scip)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
SCIP_Real SCIPgetVarLbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
int SCIPvarCompare(SCIP_VAR *var1, SCIP_VAR *var2)
SCIP_RETCODE SCIPvarGetProbvarBinary(SCIP_VAR **var, SCIP_Bool *negated)
SCIP_Longint SCIPvarGetNBranchingsCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPinferBinvarCons(SCIP *scip, SCIP_VAR *var, SCIP_Bool fixedval, SCIP_CONS *infercons, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_RETCODE SCIPwriteVarsList(SCIP *scip, FILE *file, SCIP_VAR **vars, int nvars, SCIP_Bool type, char delimiter)
SCIP_Bool SCIPvarsHaveCommonClique(SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)
SCIP_Real SCIPbdchginfoGetNewbound(SCIP_BDCHGINFO *bdchginfo)
int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_RETCODE SCIPgetTransformedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
SCIP_Bool SCIPallowStrongDualReds(SCIP *scip)
SCIP_Bool SCIPsortedvecFindPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *val, int len, int *pos)
void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Bool propagate
memory allocation routines
#define BMScopyMemoryArray(ptr, source, num)
#define BMSclearMemoryArray(ptr, num)
struct BMS_BlkMem BMS_BLKMEM
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
methods commonly used for presolving
public methods for conflict analysis handlers
public methods for managing constraints
public methods for managing events
public methods for LP management
public methods for message output
#define SCIPdebugPrintCons(x, y, z)
public data structures and miscellaneous methods
methods for sorting joint arrays of various types
public methods for problem variables
public methods for conflict handler plugins and conflict analysis
public methods for constraint handler plugins and constraints
public methods for cuts and aggregation rows
public methods for event handler plugins and event handlers
public methods for the LP relaxation, rows and columns
public methods for memory management
public methods for message handling
public methods for nonlinear relaxation
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
structs for symmetry computations
methods for dealing with symmetry detection graphs
#define SCIP_DECL_CONFLICTEXEC(x)
@ SCIP_CONFTYPE_PROPAGATION
#define SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(x)
#define SCIP_DECL_CONSGETPERMSYMGRAPH(x)
#define SCIP_DECL_CONSENFOLP(x)
#define SCIP_DECL_CONSINITPRE(x)
#define SCIP_DECL_CONSDELETE(x)
#define SCIP_DECL_CONSGETVARS(x)
#define SCIP_DECL_CONSINITSOL(x)
#define SCIP_DECL_CONSPRINT(x)
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
#define SCIP_DECL_CONSSEPALP(x)
#define SCIP_DECL_CONSENFORELAX(x)
#define SCIP_DECL_CONSPROP(x)
#define SCIP_DECL_CONSGETNVARS(x)
#define SCIP_DECL_CONSRESPROP(x)
#define SCIP_DECL_CONSACTIVE(x)
#define SCIP_DECL_CONSENFOPS(x)
#define SCIP_DECL_CONSPARSE(x)
#define SCIP_DECL_CONSTRANS(x)
#define SCIP_DECL_CONSDEACTIVE(x)
#define SCIP_DECL_CONSPRESOL(x)
#define SCIP_DECL_CONSINITLP(x)
#define SCIP_DECL_CONSEXITPRE(x)
#define SCIP_DECL_CONSLOCK(x)
#define SCIP_DECL_CONSCOPY(x)
struct SCIP_ConsData SCIP_CONSDATA
#define SCIP_DECL_CONSCHECK(x)
#define SCIP_DECL_CONSHDLRCOPY(x)
#define SCIP_DECL_CONSEXITSOL(x)
#define SCIP_DECL_CONSFREE(x)
#define SCIP_DECL_CONSSEPASOL(x)
struct SCIP_EventData SCIP_EVENTDATA
#define SCIP_EVENTTYPE_UBTIGHTENED
#define SCIP_EVENTTYPE_VARFIXED
#define SCIP_DECL_EVENTEXEC(x)
#define SCIP_EVENTTYPE_LBRELAXED
@ SCIP_BRANCHDIR_DOWNWARDS
#define SCIP_DECL_SORTPTRCOMP(x)
#define SCIP_DECL_HASHKEYEQ(x)
#define SCIP_DECL_HASHGETKEY(x)
#define SCIP_DECL_HASHKEYVAL(x)
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_STAGE_INITPRESOLVE
@ SCIP_STAGE_TRANSFORMING
enum SYM_Symtype SYM_SYMTYPE
#define SCIP_PRESOLTIMING_MEDIUM
#define SCIP_PRESOLTIMING_EXHAUSTIVE
@ SCIP_VARSTATUS_MULTAGGR