85#define CONSHDLR_NAME "and"
86#define CONSHDLR_DESC "constraint handler for AND-constraints: r = and(x1, ..., xn)"
87#define CONSHDLR_SEPAPRIORITY +850100
88#define CONSHDLR_ENFOPRIORITY -850100
89#define CONSHDLR_CHECKPRIORITY -850100
90#define CONSHDLR_SEPAFREQ 1
91#define CONSHDLR_PROPFREQ 1
92#define CONSHDLR_EAGERFREQ 100
94#define CONSHDLR_MAXPREROUNDS -1
95#define CONSHDLR_DELAYSEPA FALSE
96#define CONSHDLR_DELAYPROP FALSE
97#define CONSHDLR_NEEDSCONS TRUE
99#define CONSHDLR_PRESOLTIMING (SCIP_PRESOLTIMING_FAST | SCIP_PRESOLTIMING_EXHAUSTIVE)
100#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP
102#define EVENTHDLR_NAME "and"
103#define EVENTHDLR_DESC "bound change event handler for AND-constraints"
105#define DEFAULT_PRESOLPAIRWISE TRUE
106#define DEFAULT_LINEARIZE FALSE
107#define DEFAULT_ENFORCECUTS TRUE
108#define DEFAULT_AGGRLINEARIZATION FALSE
109#define DEFAULT_UPGRRESULTANT TRUE
110#define DEFAULT_DUALPRESOLVING TRUE
112#define HASHSIZE_ANDCONS 500
113#define DEFAULT_PRESOLUSEHASHING TRUE
114#define NMINCOMPARISONS 200000
115#define MINGAINPERNMINCOMPARISONS 1e-06
138 unsigned int propagated:1;
139 unsigned int nofixedzero:1;
140 unsigned int impladded:1;
141 unsigned int opimpladded:1;
142 unsigned int sorted:1;
143 unsigned int changed:1;
144 unsigned int merged:1;
145 unsigned int checkwhenupgr:1;
148 unsigned int notremovablewhenupgr:1;
154struct SCIP_ConshdlrData
157 SCIP_Bool presolpairwise;
158 SCIP_Bool presolusehashing;
160 SCIP_Bool enforcecuts;
161 SCIP_Bool aggrlinearization;
162 SCIP_Bool upgrresultant;
163 SCIP_Bool dualpresolving;
229 (*conshdlrdata)->eventhdlr = eventhdlr;
311 for(
i = 0;
i < consdata->nvars; ++
i )
337 for(
i = 0;
i < consdata->nvars; ++
i )
357 assert(watchedvar1 == -1 || watchedvar1 != watchedvar2);
358 assert(watchedvar1 != -1 || watchedvar2 == -1);
359 assert(watchedvar1 == -1 || (0 <= watchedvar1 && watchedvar1 < consdata->
nvars));
360 assert(watchedvar2 == -1 || (0 <= watchedvar2 && watchedvar2 < consdata->
nvars));
363 if( watchedvar1 == consdata->watchedvar2 || watchedvar2 == consdata->watchedvar1 )
367 tmp = consdata->watchedvar1;
368 consdata->watchedvar1 = consdata->watchedvar2;
369 consdata->watchedvar2 = tmp;
370 tmp = consdata->filterpos1;
371 consdata->filterpos1 = consdata->filterpos2;
372 consdata->filterpos2 = tmp;
374 assert(watchedvar1 == -1 || watchedvar1 != consdata->watchedvar2);
375 assert(watchedvar2 == -1 || watchedvar2 != consdata->watchedvar1);
378 if( consdata->watchedvar1 != -1 && consdata->watchedvar1 != watchedvar1 )
380 assert(consdata->filterpos1 != -1);
383 if( consdata->watchedvar2 != -1 && consdata->watchedvar2 != watchedvar2 )
385 assert(consdata->filterpos2 != -1);
390 if( watchedvar1 != -1 && watchedvar1 != consdata->watchedvar1 )
394 if( watchedvar2 != -1 && watchedvar2 != consdata->watchedvar2 )
400 consdata->watchedvar1 = watchedvar1;
401 consdata->watchedvar2 = watchedvar2;
415 assert(consdata->nvars <= consdata->varssize);
417 if( num > consdata->varssize )
423 consdata->varssize = newsize;
425 assert(num <= consdata->varssize);
439 SCIP_Bool checkwhenupgr,
442 SCIP_Bool notremovablewhenupgr
455 (*consdata)->resvar = resvar;
456 (*consdata)->rows =
NULL;
457 (*consdata)->aggrrow =
NULL;
458 (*consdata)->nlrow =
NULL;
459 (*consdata)->nvars =
nvars;
460 (*consdata)->varssize =
nvars;
461 (*consdata)->nrows = 0;
462 (*consdata)->watchedvar1 = -1;
463 (*consdata)->watchedvar2 = -1;
464 (*consdata)->filterpos1 = -1;
465 (*consdata)->filterpos2 = -1;
466 (*consdata)->propagated =
FALSE;
467 (*consdata)->nofixedzero =
FALSE;
468 (*consdata)->impladded =
FALSE;
469 (*consdata)->opimpladded =
FALSE;
470 (*consdata)->sorted =
FALSE;
471 (*consdata)->changed =
TRUE;
472 (*consdata)->merged =
FALSE;
473 (*consdata)->checkwhenupgr = checkwhenupgr;
474 (*consdata)->notremovablewhenupgr = notremovablewhenupgr;
493 for( v = 0; v < (*consdata)->nvars; ++v )
503 for( v = 0; v < (*consdata)->nvars; v++ )
524 if( consdata->rows !=
NULL )
526 for(
r = 0;
r < consdata->nrows; ++
r )
535 if( consdata->aggrrow !=
NULL )
538 consdata->aggrrow =
NULL;
567 assert((*consdata)->watchedvar1 == -1);
568 assert((*consdata)->watchedvar2 == -1);
575 if( (*consdata)->nlrow !=
NULL )
581 for( v = 0; v < (*consdata)->nvars; v++ )
629 SCIP_Bool transformed;
649 consdata->vars[consdata->nvars] =
var;
651 consdata->sorted = (consdata->nvars == 1);
652 consdata->changed =
TRUE;
653 consdata->merged =
FALSE;
670 if( consdata->rows !=
NULL )
672 SCIPerrorMessage(
"cannot add coefficients to AND-constraint after LP relaxation was created\n");
710 if( consdata->watchedvar1 == pos )
714 if( consdata->watchedvar2 == pos )
719 assert(pos != consdata->watchedvar1);
720 assert(pos != consdata->watchedvar2);
726 consdata->vars[pos] = consdata->vars[consdata->nvars-1];
730 if( consdata->watchedvar1 == consdata->nvars )
731 consdata->watchedvar1 = pos;
732 if( consdata->watchedvar2 == consdata->nvars )
733 consdata->watchedvar2 = pos;
735 consdata->propagated =
FALSE;
736 consdata->sorted =
FALSE;
737 consdata->changed =
TRUE;
750 if( !consdata->sorted )
752 if( consdata->nvars <= 1 )
753 consdata->sorted =
TRUE;
760 if( consdata->watchedvar1 != -1 )
762 var1 = consdata->vars[consdata->watchedvar1];
764 consdata->watchedvar1 = -1;
765 if( consdata->watchedvar2 != -1 )
767 var2 = consdata->vars[consdata->watchedvar2];
769 consdata->watchedvar2 = -1;
772 assert(consdata->watchedvar1 == -1);
773 assert(consdata->watchedvar2 == -1);
777 SCIPsortPtr((
void**)consdata->vars, SCIPvarComp, consdata->nvars);
778 consdata->sorted =
TRUE;
787 found =
SCIPsortedvecFindPtr((
void**)consdata->vars, SCIPvarComp, (
void*)var1, consdata->nvars, &pos);
790 (void)
SCIPsortedvecFindPtr((
void**)consdata->vars, SCIPvarComp, (
void*)var1, consdata->nvars, &pos);
793 consdata->watchedvar1 = pos;
798 found =
SCIPsortedvecFindPtr((
void**)consdata->vars, SCIPvarComp, (
void*)var2, consdata->nvars, &pos);
801 (void)
SCIPsortedvecFindPtr((
void**)consdata->vars, SCIPvarComp, (
void*)var2, consdata->nvars, &pos);
804 consdata->watchedvar2 = pos;
815 for( v = 0; v < consdata->nvars; ++v )
843 assert(consdata->nvars == 0 || consdata->vars !=
NULL);
846 while( v < consdata->
nvars )
848 var = consdata->vars[v];
879#ifdef SCIP_DISABLED_CODE
891 if( repvar != consdata->resvar )
910 consdata->resvar = repvar;
911 consdata->changed =
TRUE;
939 nvars = consdata->nvars;
942 consdata->nrows =
nvars + 1;
975 SCIP_Bool* infeasible
993 if( consdata->aggrrow ==
NULL )
1010 if( !(*infeasible) )
1012 if( consdata->rows ==
NULL )
1049 if( consdata->nlrow ==
NULL )
1053 SCIP_Real minusone = -1.0;
1057 for(
i = 0;
i < consdata->nvars; ++
i )
1068 for(
i = 0;
i < consdata->nvars; ++
i )
1089 SCIP_Bool checklprows,
1090 SCIP_Bool printreason,
1095 SCIP_Bool mustcheck;
1106 mustcheck = checklprows;
1107 mustcheck = mustcheck || (consdata->rows ==
NULL);
1112 for(
r = 0;
r < consdata->nrows; ++
r )
1123 SCIP_Real minsolval = 1.0;
1124 SCIP_Real sumsolval = 0.0;
1139 for(
i = 0;
i < consdata->nvars; ++
i )
1143 if( minsolval > solval )
1149 sumsolval += solval;
1156 viol =
MAX3(0.0, solval - minsolval, sumsolval - (consdata->nvars - 1.0 + solval));
1201 SCIP_Bool* separated,
1206 SCIP_Real feasibility;
1219 if( consdata->rows ==
NULL )
1226 for(
r = 0;
r < consdata->nrows; ++
r )
1261 assert(0 <= falsepos && falsepos < consdata->
nvars);
1300 for( v = 0; v < consdata->nvars; ++v )
1323 SCIP_Bool infeasible;
1324 SCIP_Bool tightened;
1326 SCIPdebugMsg(
scip,
"constraint <%s>: operator %d fixed to 0.0 -> fix resultant <%s> to 0.0\n",
1362 SCIP_Bool infeasible;
1363 SCIP_Bool tightened;
1366 for( v = 0; v <
nvars && !(*cutoff); ++v )
1368 SCIPdebugMsg(
scip,
"constraint <%s>: resultant fixed to 1.0 -> fix operator var <%s> to 1.0\n",
1380 else if( tightened )
1418 SCIP_Bool conscreated;
1427 nvars = consdata->nvars;
1428 conscreated =
FALSE;
1437 SCIP_Bool infeasible;
1438 SCIP_Bool tightened;
1452 else if( tightened )
1461 else if( tightened )
1481 for( v = 0; v <
nvars; ++v )
1533 if( watchedvar2 == -1 )
1535 SCIP_Bool infeasible;
1536 SCIP_Bool tightened;
1538 assert(watchedvar1 != -1);
1545 for( v = consdata->nvars - 1; v >= 0; --v )
1546 if( v != watchedvar1 )
1551 SCIPdebugMsg(
scip,
"constraint <%s>: resultant <%s> fixed to 0.0, only one unfixed operand -> fix operand <%s> to 0.0\n",
1583 unsigned char** entries,
1615 if( consdata->merged )
1619 if( consdata->nvars <= 1 )
1621 consdata->merged =
TRUE;
1625 vars = consdata->vars;
1626 nvars = consdata->nvars;
1639 for( v =
nvars - 1; v >= 0; --v )
1659 (*entries)[probidx] = 0;
1666 for( v =
nvars - 1; v >= 0; --v )
1676 assert(0 <= probidx && probidx < *nentries);
1679 if( (*entries)[probidx] == 0 )
1692 SCIP_Bool infeasible;
1697 SCIPdebugMsg(
scip,
"AND-constraint <%s> is redundant: variable <%s> and its negation are present -> fix resultant <%s> = 0\n",
1720 consdata->merged =
TRUE;
1752 SCIP_Bool infeasible;
1753 SCIP_Bool tightened;
1761 resvar = consdata->resvar;
1762 vars = consdata->vars;
1763 nvars = consdata->nvars;
1768 if( consdata->propagated )
1770 assert(consdata->nofixedzero);
1782 if( !consdata->nofixedzero )
1792 consdata->nofixedzero =
TRUE;
1833 watchedvar1 = consdata->watchedvar1;
1834 watchedvar2 = consdata->watchedvar2;
1837 if( watchedvar1 != -1 )
1843 if( watchedvar2 != -1 )
1851 if( watchedvar1 == -1 )
1853 watchedvar1 = watchedvar2;
1856 assert(watchedvar1 != -1 || watchedvar2 == -1);
1859 if( watchedvar2 == -1 )
1866 if( watchedvar1 == -1 )
1868 assert(watchedvar2 == -1);
1871 else if( watchedvar1 !=
i )
1879 assert(watchedvar1 != -1 || watchedvar2 == -1);
1882 if( watchedvar1 == -1 )
1884 assert(watchedvar2 == -1);
1886 SCIPdebugMsg(
scip,
"constraint <%s>: all operator vars fixed to 1.0 -> fix resultant <%s> to 1.0\n",
1915 assert(watchedvar1 != -1);
1959 vars = consdata->vars;
1960 nvars = consdata->nvars;
1967 assert(infervar == consdata->resvar);
1991 assert(infervar == consdata->resvar);
2007 if(
vars[
i] != infervar )
2032 unsigned char** entries,
2054 SCIP_Bool infeasible;
2079 for(
c = nconss - 1;
c >= 0 && !(*cutoff); --
c )
2107 vars = consdata->vars;
2108 nvars = consdata->nvars;
2116 resvar = consdata->resvar;
2128 SCIP_Real posobjsum = 0;
2131 int oldnfixedvars = *nfixedvars;
2132 int oldnaggrvars = *naggrvars;
2137 for( v =
nvars - 1; v >= 0; --v )
2147 impoperands[nimpoperands] =
var;
2160 maxpos = nimpoperands - 1;
2165 assert(nimpoperands >= 0 && nimpoperands <=
nvars);
2168 if( nimpoperands == 0 )
2182 if( nimpoperands ==
nvars && poscontissmall )
2192 for( v =
nvars - 1; v >= 0 && !(*cutoff); --v )
2208 SCIP_Bool aggregationperformed =
FALSE;
2209 SCIP_Bool zerofix =
FALSE;
2211 assert(nimpoperands > 0);
2213 SCIPdebugMsg(
scip,
"dual-fixing all variables in constraint <%s> with positive contribution (when together exceeding the negative contribution of the resultant) to 0 and with negative contribution to 1\n",
SCIPconsGetName(cons));
2215 for( v = nimpoperands - 1; v >= 0 && !(*cutoff); --v )
2228 else if( !poscontissmall )
2239 SCIP_Bool redundant;
2240 SCIP_Bool aggregated;
2244 &infeasible, &redundant, &aggregated) );
2252 aggregationperformed =
TRUE;
2258 assert(*nfixedvars - oldnfixedvars + *naggrvars - oldnaggrvars <= nimpoperands);
2263 if( aggregationperformed || zerofix )
2278 if( fixval < 0.5 || *nfixedvars - oldnfixedvars + *naggrvars - oldnaggrvars ==
nvars )
2299 SCIP_Bool zerofix =
FALSE;
2303 assert(nimpoperands > 0);
2317 SCIPdebugMsg(
scip,
"dual-fixing variable <%s> in constraint <%s> to %g, because the contribution is%s " \
2318 "enough to nullify/exceed the contribution of the resultant \n",
2322 zerofix = (fixval < 0.5);
2329 SCIPdebugMsg(
scip,
"dual-fixing all variables, except the variable with the highest contribution to " \
2330 "the objective, in constraint <%s> with positive contribution to 0 and with negative contribution to 1\n",
2333 for( v = nimpoperands - 1; v >= 0 && !(*cutoff); --v )
2355 assert(*nfixedvars - oldnfixedvars <= nimpoperands);
2359 if( *nfixedvars - oldnfixedvars ==
nvars )
2382 SCIP_Bool redundant;
2383 SCIP_Bool aggregated;
2384 SCIP_Bool resobjispos;
2385 SCIP_Bool linearize =
FALSE;
2386 SCIP_Bool zerofix =
FALSE;
2388 int oldnchgcoefs = *nchgcoefs;
2389 int oldnfixedvars = *nfixedvars;
2400 SCIP_Bool goodvarsfound =
FALSE;
2402 for( v =
nvars - 1; v >= 0; --v )
2435 "dual aggregating operand <%s> with 1 up- and downlock to the resultant <%s> in constraint <%s>\n",
2442 goodvarsfound =
TRUE;
2457 if( !*
cutoff && goodvarsfound && linearize )
2460 for( v = consdata->nvars - 1; v >= 0; --v )
2474 "dual-fixing variable <%s> in constraint <%s> to 1, because the contribution is negative\n",
2484 assert(*nfixedvars - oldnfixedvars <= consdata->
nvars);
2486 assert(*nchgcoefs - oldnchgcoefs + *nfixedvars - oldnfixedvars <=
nvars);
2493 SCIP_Bool locksareone =
TRUE;
2496 for( v =
nvars - 1; v >= 0; --v )
2588 consvars[0] = consdata->resvar;
2593 for( v = consdata->nvars - 1; v >= 0; --v )
2596 consvars[1] = consdata->vars[v];
2608 (*naddconss) += consdata->nvars;
2616 else if( consdata->nvars == 1 )
2622 &infeasible, &redundant, &aggregated) );
2703 SCIP_Bool infeasible;
2705 SCIP_Bool allnegoperandsexist;
2723 vars = consdata->vars;
2724 nvars = consdata->nvars;
2732 for( v =
nvars - 1; v >= 0; --v )
2738 SCIPdebugMsg(
scip,
"In constraint <%s> the operand <%s> is fixed to 1 so remove it from the constraint\n",
2751 SCIPdebugMsg(
scip,
"constraint <%s> redundant: because operand <%s> is fixed to zero so we can fix the resultant <%s> to 0\n",
2767 if( consdata->nvars <
nvars )
2774 if( consdata->nvars == 0 )
2776 SCIPdebugMsg(
scip,
"All operand in constraint <%s> were deleted, so the resultant needs to be fixed to 1\n",
2790 else if( consdata->nvars == 1 )
2792 SCIP_Bool redundant;
2793 SCIP_Bool aggregated;
2797 &infeasible, &redundant, &aggregated) );
2810 nvars = consdata->nvars;
2818 for( v =
nvars - 1; v > 0; --v )
2836 for( v2 = v - 1; v2 >= 0; --v2 )
2865 SCIPdebugMsg(
scip,
"constraint <%s> redundant: because variable <%s> and variable <%s> are in a clique, the resultant <%s> can be fixed to 0\n",
2909 var1 = consdata->resvar;
2922 SCIPdebugMsg(
scip,
"In constraint <%s> the resultant <%s> is fixed to 1 so fix all operands to 1\n",
2926 for( v =
nvars - 1; v >= 0 && !(*cutoff); --v )
2956 for( v =
nvars - 1; v >= 0; --v )
2978 if( value1 != value2 )
2980 SCIPdebugMsg(
scip,
"In constraint <%s> the resultant <%s> can be fixed to 0 because the negation of it is an operand.\n",
2998 assert(value1 == value2);
3000 consvars[0] = consdata->resvar;
3002 for( v2 =
nvars - 1; v2 >= 0; --v2 )
3020 if( value1 == negated )
3022 SCIPdebugMsg(
scip,
"In constraint <%s> the resultant <%s> can be fixed to 0 because the negation of it is an operand.\n",
3065 if( var1 == var2 && value1 == value2 )
3073 SCIPdebugMsg(
scip,
"in constraint <%s> the resultant <%s> can be fixed to 0 because it is in a clique with operand <%s>\n",
3090 for( v =
nvars - 1; v >= 0; --v )
3109 allnegoperandsexist =
FALSE;
3114 allnegoperandsexist =
TRUE;
3119 else if( v2 >= 0 && v == -1 )
3133 for( v = vstart; v >= vend; --v )
3149 for( v2 =
nvars - 1; v2 >= 0; --v2 )
3174 if( var1 == var2 && value1 == value2 )
3176 SCIPdebugMsg(
scip,
"in constraint <%s> the resultant <%s> can be fixed to 0 because two operands are negated of each other\n",
3190 if( var1 == var2 && value1 != value2 )
3199 SCIP_Bool redundant;
3200 SCIP_Bool aggregated;
3202 SCIPdebugMsg(
scip,
"In constraint <%s> the operand <%s> is in a negated clique with all other operands, so we can aggregated this operand to the resultant <%s>.\n",
3206 &infeasible, &redundant, &aggregated) );
3223 SCIP_Bool* negations;
3230 var1 = consdata->resvar;
3235 newvars[
nvars] = var1;
3238 for( v =
nvars - 1; v >= 0; --v )
3257 for( v =
nvars - 1; v >= 0 && upgrade; --v )
3259 for( v2 = v - 1; v2 >= 0; --v2 )
3277 if( negations[
nvars] )
3287 for( v =
nvars - 1; v >= 0; --v )
3339 SCIP_Bool coefsequal;
3352 if( consdata1->nvars != consdata2->nvars )
3358 assert(consdata1->sorted);
3359 assert(consdata2->sorted);
3363 for(
i = 0;
i < consdata1->nvars ; ++
i )
3366 if( consdata1->vars[
i] != consdata2->vars[
i] )
3390 assert(consdata->sorted);
3391 assert(consdata->nvars > 0);
3396 assert(minidx >= 0 && minidx <= maxidx);
3398 return SCIPhashFour(consdata->nvars, minidx, mididx, maxidx);
3424 hashtablesize = nconss;
3427 hashGetKeyAndcons, hashKeyEqAndcons, hashKeyValAndcons, (
void*)
scip) );
3432 for(
c = 0;
c < nconss; ++
c )
3447 assert(consdata0->sorted);
3455 SCIP_Bool redundant;
3463 assert(consdata0->nvars >= 1 && consdata0->nvars == consdata1->nvars);
3465 assert(consdata0->sorted && consdata1->sorted);
3466 assert(consdata0->vars[0] == consdata1->vars[0]);
3470 if( consdata0->resvar != consdata1->resvar )
3472 SCIP_Bool aggregated;
3478 cutoff, &redundant, &aggregated) );
3497 consdata1->checkwhenupgr = consdata1->checkwhenupgr || consdata0->checkwhenupgr;
3498 consdata1->notremovablewhenupgr = consdata1->notremovablewhenupgr || consdata0->notremovablewhenupgr;
3535 SCIP_Bool separated;
3546 for(
i = 0;
i < nconss;
i++ )
3552 if( !conshdlrdata->enforcecuts )
3564 else if( separated )
3595 SCIP_Bool cons0changed;
3599 assert(firstchange <= chkind);
3606 cons0 = conss[chkind];
3615 assert(consdata0->nvars >= 1);
3616 assert(consdata0->sorted);
3619 cons0changed = consdata0->changed;
3623 for(
c = (cons0changed ? 0 : firstchange);
c < chkind && !(*cutoff); ++
c )
3627 SCIP_Bool cons0superset;
3628 SCIP_Bool cons1superset;
3644#ifdef SCIP_DISABLED_CODE
3645 SCIPdebugMsg(
scip,
"preprocess AND-constraint pair <%s>[chg:%d] and <%s>[chg:%d]\n",
3650 if( !cons0changed && !consdata1->changed )
3653 assert(consdata1->nvars >= 1);
3657 assert(consdata1->sorted);
3665 cons0superset =
TRUE;
3666 cons1superset =
TRUE;
3667 while( (v0 < consdata0->
nvars || v1 < consdata1->
nvars) && (cons0superset || cons1superset) )
3672 if( v0 < consdata0->
nvars && v1 < consdata1->
nvars )
3673 varcmp =
SCIPvarCompare(consdata0->vars[v0], consdata1->vars[v1]);
3674 else if( v0 < consdata0->
nvars )
3683 cons1superset =
FALSE;
3689 cons0superset =
FALSE;
3707 if( cons0superset && cons1superset )
3709 SCIP_Bool infeasible;
3710 SCIP_Bool redundant;
3711 SCIP_Bool aggregated;
3714 SCIPdebugMsg(
scip,
"equivalent AND-constraints <%s> and <%s>: aggregate resultants <%s> == <%s>\n",
3720 &infeasible, &redundant, &aggregated) );
3735 consdata0->checkwhenupgr = consdata1->checkwhenupgr || consdata0->checkwhenupgr;
3736 consdata0->notremovablewhenupgr = consdata1->notremovablewhenupgr || consdata0->notremovablewhenupgr;
3745 else if( cons0superset )
3747 SCIP_Bool infeasible;
3751 SCIPdebugMsg(
scip,
"AND-constraint <%s> is superset of <%s>: add implication <%s> = 1 -> <%s> = 1\n",
3757 &infeasible, &nboundchgs) );
3759 (*nbdchgs) += nboundchgs;
3761 else if( cons1superset )
3763 SCIP_Bool infeasible;
3767 SCIPdebugMsg(
scip,
"AND-constraint <%s> is superset of <%s>: add implication <%s> = 1 -> <%s> = 1\n",
3773 &infeasible, &nboundchgs) );
3775 (*nbdchgs) += nboundchgs;
3779 consdata0->changed =
FALSE;
3798 SCIP_Real constant = 0.0;
3819 for(
i = 0;
i < consdata->nvars; ++
i )
3827 vals[nlocvars++] = 2.0;
3833 nlocvars, cons, constant, constant, success) );
3892 if( conshdlrdata->linearize )
3910 for(
c = 0;
c < nconss; ++
c )
3923 nvars = consdata->nvars;
3925 if( !conshdlrdata->aggrlinearization )
3927 vars[0] = consdata->resvar;
3932 for( v = 0; v <
nvars; ++v )
3935 vars[1] = consdata->vars[v];
3953 for( v = 0; v <
nvars; ++v )
3955 vars[v] = consdata->vars[v];
3961 if( conshdlrdata->aggrlinearization )
4007#ifdef GMLGATEPRINTING
4049 gmlfile = fopen(fname,
"w");
4051 if( gmlfile ==
NULL )
4065 for(
c = nconss - 1;
c >= 0; --
c )
4077 if( consdata->nvars == 0 )
4106 for( v = consdata->nvars - 1; v >= 0; --v )
4128#ifdef SCIP_DISABLED_CODE
4129 for( v =
nvars - 1; v >= 0; --v )
4170 for(
c = 0;
c < nconss; ++
c )
4187 for(
c = 0;
c < nconss; ++
c )
4194 if( consdata->nlrow !=
NULL )
4235 sourcedata->nvars, sourcedata->vars, sourcedata->resvar, sourcedata->checkwhenupgr,
4236 sourcedata->notremovablewhenupgr) );
4255 *infeasible =
FALSE;
4257 for(
i = 0;
i < nconss && !(*infeasible);
i++ )
4271 SCIP_Bool separated;
4278 for(
c = 0;
c < nusefulconss; ++
c )
4283 else if ( separated )
4298 SCIP_Bool separated;
4305 for(
c = 0;
c < nusefulconss; ++
c )
4310 else if ( separated )
4347 for(
i = 0;
i < nconss;
i++ )
4398 for(
c = 0;
c < nusefulconss && !
cutoff; ++
c )
4406 else if( nfixedvars > 0 || nupgdconss > 0 )
4422 unsigned char* entries;
4435 oldnfixedvars = *nfixedvars;
4436 oldnaggrvars = *naggrvars;
4437 oldnchgbds = *nchgbds;
4438 oldndelconss = *ndelconss;
4439 oldnupgdconss = *nupgdconss;
4449 firstchange = INT_MAX;
4459 consdata->propagated =
FALSE;
4462 if( firstchange == INT_MAX && consdata->changed )
4481 assert(consdata->nvars >= 1);
4484 if( consdata->nvars == 1 )
4486 SCIP_Bool redundant;
4487 SCIP_Bool aggregated;
4497 &
cutoff, &redundant, &aggregated) );
4513 else if( !consdata->impladded )
4518 for(
i = 0;
i < consdata->nvars && !
cutoff; ++
i )
4524 (*nchgbds) += nimplbdchgs;
4526 consdata->impladded =
TRUE;
4537 (*nchgbds) += nimplbdchgs;
4538 consdata->opimpladded =
TRUE;
4546 SCIP_CALL(
dualPresolve(
scip, conss, nconss, conshdlrdata->eventhdlr, &entries, &nentries, &
cutoff, nfixedvars, naggrvars, nchgcoefs, ndelconss, nupgdconss, naddconss) );
4586 if( *nfixedvars == oldnfixedvars && *naggrvars == oldnaggrvars )
4588 if( firstchange < nconss )
4592 oldnaggrvars = *naggrvars;
4599 if( *nfixedvars == oldnfixedvars && *naggrvars == oldnaggrvars )
4601 SCIP_Longint npaircomparisons;
4602 npaircomparisons = 0;
4603 oldndelconss = *ndelconss;
4616 if( ((*ndelconss - oldndelconss) + (*naggrvars - oldnaggrvars) + (*nchgbds - oldnchgbds)/2.0) / ((SCIP_Real) npaircomparisons) <
MINGAINPERNMINCOMPARISONS )
4618 oldndelconss = *ndelconss;
4619 oldnaggrvars = *naggrvars;
4620 oldnchgbds = *nchgbds;
4622 npaircomparisons = 0;
4634 else if( *nfixedvars > oldnfixedvars || *naggrvars > oldnaggrvars || *nchgbds > oldnchgbds
4635 || *ndelconss > oldndelconss || *nupgdconss > oldnupgdconss )
4670 for(
i = 0;
i < consdata->nvars; ++
i )
4733 const char* consname;
4760 for( v = 0; v <
nvars; ++v )
4777 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
4804 if( resvar ==
NULL )
4810 char* strcopy =
NULL;
4816 startptr = strchr((
char*)str,
'(');
4818 if( startptr ==
NULL )
4820 SCIPerrorMessage(
"missing starting character '(' parsing AND-constraint\n");
4828 endptr = strrchr(startptr,
')');
4830 if( endptr ==
NULL )
4835 assert(endptr >= startptr);
4837 if( endptr > startptr )
4841 strcopy[endptr-startptr] =
'\0';
4854 if( varssize < requiredsize )
4857 varssize = requiredsize;
4865 assert(varssize >= requiredsize);
4869 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
4886 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
4904 if( varssize < consdata->
nvars + 1 )
4909 vars[consdata->nvars] = consdata->resvar;
4927 (*nvars) = consdata->nvars + 1;
4969 consdata->nofixedzero =
FALSE;
4971 consdata->propagated =
FALSE;
4992 eventExecAnd,
NULL) );
5000 consEnfolpAnd, consEnfopsAnd, consCheckAnd, consLockAnd,
5010#ifdef GMLGATEPRINTING
5036 "should pairwise constraint comparison be performed in presolving?",
5039 "constraints/and/presolusehashing",
5040 "should hash table be used for detecting redundant constraints in advance",
5044 "should the AND-constraint get linearized and removed (in presolving)?",
5048 "should cuts be separated during LP enforcing?",
5052 "should an aggregated linearization be used?",
5056 "should all binary resultant variables be upgraded to implicit binary variables?",
5060 "should dual presolving be performed?",
5089 SCIP_Bool modifiable,
5095 SCIP_Bool removable,
5097 SCIP_Bool stickingatnode
5105 SCIP_Bool infeasible;
5109 if( conshdlr ==
NULL )
5137 activeresvar = resvar;
5142 for( v =
nvars - 1; v >= 0; --v )
5147 activevar =
vars[v];
5166 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
5167 local, modifiable, dynamic, removable, stickingatnode) );
5219 return consdata->nvars;
5243 return consdata->vars;
5267 return consdata->resvar;
5291 return consdata->sorted;
5316 assert(consdata->sorted);
5347 consdata->checkwhenupgr = flag;
5379 consdata->notremovablewhenupgr = flag;
static SCIP_RETCODE addRelaxation(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible)
static SCIP_RETCODE consdataFreeRows(SCIP *scip, SCIP_CONSDATA *consdata)
static SCIP_RETCODE consdataPrint(SCIP *scip, SCIP_CONSDATA *consdata, FILE *file)
static SCIP_RETCODE consdataCatchWatchedEvents(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr, int pos, int *filterpos)
static SCIP_RETCODE consdataDropEvents(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr)
#define DEFAULT_DUALPRESOLVING
static SCIP_RETCODE dualPresolve(SCIP *scip, SCIP_CONS **conss, int nconss, SCIP_EVENTHDLR *eventhdlr, unsigned char **entries, int *nentries, SCIP_Bool *cutoff, int *nfixedvars, int *naggrvars, int *nchgcoefs, int *ndelconss, int *nupgdconss, int *naddconss)
static SCIP_RETCODE consdataSwitchWatchedvars(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr, int watchedvar1, int watchedvar2)
#define CONSHDLR_NEEDSCONS
#define CONSHDLR_SEPAFREQ
static SCIP_RETCODE delCoefPos(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, int pos)
#define CONSHDLR_CHECKPRIORITY
static SCIP_RETCODE consdataFixOperandsOne(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **vars, int nvars, SCIP_Bool *cutoff, int *nfixedvars)
static SCIP_RETCODE separateCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool *separated, SCIP_Bool *cutoff)
static SCIP_RETCODE addCoef(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, SCIP_VAR *var)
static SCIP_RETCODE createRelaxation(SCIP *scip, SCIP_CONS *cons)
#define CONSHDLR_PROP_TIMING
static void conshdlrdataFree(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata)
static SCIP_RETCODE unlockRounding(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
static SCIP_RETCODE analyzeZeroResultant(SCIP *scip, SCIP_CONS *cons, int watchedvar1, int watchedvar2, SCIP_Bool *cutoff, int *nfixedvars)
static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_CONSDATA **consdata, SCIP_EVENTHDLR *eventhdlr, int nvars, SCIP_VAR **vars, SCIP_VAR *resvar, SCIP_Bool checkwhenupgr, SCIP_Bool notremovablewhenupgr)
#define DEFAULT_UPGRRESULTANT
#define CONSHDLR_MAXPREROUNDS
static SCIP_RETCODE consdataFixResultantZero(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *resvar, int pos, SCIP_Bool *cutoff, int *nfixedvars)
#define DEFAULT_PRESOLPAIRWISE
#define CONSHDLR_SEPAPRIORITY
static SCIP_RETCODE analyzeConflictOne(SCIP *scip, SCIP_CONS *cons, int falsepos)
static SCIP_RETCODE detectRedundantConstraints(SCIP *scip, BMS_BLKMEM *blkmem, SCIP_CONS **conss, int nconss, int *firstchange, SCIP_Bool *cutoff, int *naggrvars, int *ndelconss)
#define DEFAULT_LINEARIZE
static SCIP_RETCODE cliquePresolve(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool *cutoff, int *nfixedvars, int *naggrvars, int *nchgcoefs, int *ndelconss, int *naddconss)
static SCIP_RETCODE preprocessConstraintPairs(SCIP *scip, SCIP_CONS **conss, int firstchange, int chkind, SCIP_Bool *cutoff, int *naggrvars, int *nbdchgs, int *ndelconss)
static SCIP_RETCODE consdataLinearize(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff, int *nfixedvars, int *nupgdconss)
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 consdataEnsureVarsSize(SCIP *scip, SCIP_CONSDATA *consdata, int num)
static SCIP_RETCODE checkCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_Bool *violated)
#define DEFAULT_PRESOLUSEHASHING
static SCIP_RETCODE consdataFree(SCIP *scip, SCIP_CONSDATA **consdata, SCIP_EVENTHDLR *eventhdlr)
static SCIP_RETCODE consdataDropWatchedEvents(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr, int pos, int filterpos)
#define MINGAINPERNMINCOMPARISONS
static SCIP_RETCODE analyzeConflictZero(SCIP *scip, SCIP_CONS *cons)
#define CONSHDLR_PROPFREQ
#define DEFAULT_ENFORCECUTS
#define CONSHDLR_PRESOLTIMING
static void consdataSort(SCIP_CONSDATA *consdata)
static SCIP_RETCODE addNlrow(SCIP *scip, SCIP_CONS *cons)
#define CONSHDLR_EAGERFREQ
static SCIP_RETCODE conshdlrdataCreate(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata, SCIP_EVENTHDLR *eventhdlr)
#define CONSHDLR_ENFOPRIORITY
static SCIP_RETCODE applyFixings(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, int *nchgcoefs)
static SCIP_RETCODE resolvePropagation(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *infervar, PROPRULE proprule, SCIP_BDCHGIDX *bdchgidx, SCIP_RESULT *result)
#define CONSHDLR_DELAYSEPA
static SCIP_RETCODE mergeMultiples(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, unsigned char **entries, int *nentries, int *nfixedvars, int *nchgcoefs, int *ndelconss)
static SCIP_RETCODE enforceConstraint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_SOL *sol, SCIP_RESULT *result)
#define DEFAULT_AGGRLINEARIZATION
static SCIP_RETCODE propagateCons(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool *cutoff, int *nfixedvars, int *nupgdconss)
#define CONSHDLR_DELAYPROP
static SCIP_RETCODE consdataCatchEvents(SCIP *scip, SCIP_CONSDATA *consdata, SCIP_EVENTHDLR *eventhdlr)
Constraint handler for AND constraints, .
Constraint handler for linear constraints in their most general form, .
Constraint handler for logicor constraints (equivalent to set covering, but algorithms are suited fo...
constraint handler for pseudoboolean constraints
#define ARTIFICIALVARNAMEPREFIX
Constraint handler for the set partitioning / packing / covering constraints .
#define SCIP_CALL_FINALLY(x, y)
product expression handler
variable expression handler
SCIP_RETCODE SCIPcreateConsAnd(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *resvar, 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 SCIPchgAndConsCheckFlagWhenUpgr(SCIP *scip, SCIP_CONS *cons, SCIP_Bool flag)
SCIP_VAR * SCIPgetResultantAnd(SCIP *scip, SCIP_CONS *cons)
int SCIPgetNVarsAnd(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPchgAndConsRemovableFlagWhenUpgr(SCIP *scip, SCIP_CONS *cons, SCIP_Bool flag)
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 SCIPsortAndCons(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPisAndConsSorted(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_RETCODE SCIPcreateConsSetpart(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_VAR ** SCIPgetVarsAnd(SCIP *scip, SCIP_CONS *cons)
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_RETCODE SCIPcreateConsBasicAnd(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *resvar, int nvars, SCIP_VAR **vars)
SCIP_RETCODE SCIPincludeConshdlrAnd(SCIP *scip)
SCIP_RETCODE SCIPgetVarCopy(SCIP *sourcescip, SCIP *targetscip, SCIP_VAR *sourcevar, SCIP_VAR **targetvar, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool *success)
SCIP_RETCODE SCIPcreateExprVar(SCIP *scip, SCIP_EXPR **expr, SCIP_VAR *var, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_RETCODE SCIPcreateExprProduct(SCIP *scip, SCIP_EXPR **expr, int nchildren, SCIP_EXPR **children, SCIP_Real coefficient, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
void SCIPgmlWriteNode(FILE *file, unsigned int id, const char *label, const char *nodetype, const char *fillcolor, const char *bordercolor)
void SCIPgmlWriteClosing(FILE *file)
void SCIPgmlWriteOpening(FILE *file, SCIP_Bool directed)
void SCIPgmlWriteArc(FILE *file, unsigned int source, unsigned int target, const char *label, const char *color)
SCIP_Bool SCIPisTransformed(SCIP *scip)
SCIP_Bool SCIPisStopped(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
int SCIPgetNIntVars(SCIP *scip)
int SCIPgetNImplVars(SCIP *scip)
int SCIPgetNContVars(SCIP *scip)
SCIP_RETCODE SCIPgetVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
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_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 SCIPdelConsLocal(SCIP *scip, SCIP_CONS *cons)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
#define SCIPdebugMsgPrint
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)
SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)
SCIP_RETCODE SCIPaddConflictBinvar(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPanalyzeConflictCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)
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_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)
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_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_Bool SCIPconsIsInitial(SCIP_CONS *cons)
SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)
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)
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 SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)
SCIP_RETCODE SCIPincConsAge(SCIP *scip, 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)
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_RETCODE SCIPreleaseExpr(SCIP *scip, SCIP_EXPR **expr)
#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 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_Real SCIPgetRowSolFeasibility(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)
void SCIPupdateSolConsViolation(SCIP *scip, SCIP_SOL *sol, SCIP_Real absviol, SCIP_Real relviol)
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
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 SCIPisPositive(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasNegative(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasPositive(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPinRepropagation(SCIP *scip)
int SCIPgetDepth(SCIP *scip)
SCIP_RETCODE SCIPcutoffNode(SCIP *scip, SCIP_NODE *node)
SCIP_NODE * SCIPgetRootNode(SCIP *scip)
SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
void SCIPvarsGetProbvar(SCIP_VAR **vars, int nvars)
SCIP_VAR * SCIPvarGetNegatedVar(SCIP_VAR *var)
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_RETCODE SCIPgetTransformedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_Bool SCIPdoNotAggr(SCIP *scip)
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_VAR * SCIPvarGetProbvar(SCIP_VAR *var)
SCIP_RETCODE SCIPparseVarName(SCIP *scip, const char *str, SCIP_VAR **var, char **endptr)
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_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_RETCODE SCIPchgVarType(SCIP *scip, SCIP_VAR *var, SCIP_VARTYPE vartype, SCIP_Bool *infeasible)
SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)
SCIP_RETCODE SCIPaddVarImplication(SCIP *scip, SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool *infeasible, int *nbdchgs)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsNegated(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_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_RETCODE SCIPinferBinvarCons(SCIP *scip, SCIP_VAR *var, SCIP_Bool fixedval, SCIP_CONS *infercons, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_RETCODE SCIPwriteVarName(SCIP *scip, FILE *file, SCIP_VAR *var, SCIP_Bool type)
SCIP_RETCODE SCIPgetBinvarRepresentative(SCIP *scip, SCIP_VAR *var, SCIP_VAR **repvar, SCIP_Bool *negated)
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)
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,...)
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)
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)
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 problem copies
public methods for cuts and aggregation rows
public methods for event handler plugins and event handlers
public functions to work with algebraic expressions
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 the branch-and-bound tree
public methods for SCIP variables
structs for symmetry computations
methods for dealing with symmetry detection graphs
@ 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)
#define SCIP_EVENTTYPE_BOUNDCHANGED
struct SCIP_EventData SCIP_EVENTDATA
#define SCIP_EVENTTYPE_UBTIGHTENED
#define SCIP_DECL_EVENTEXEC(x)
#define SCIP_EVENTTYPE_LBRELAXED
#define SCIP_EVENTTYPE_LBTIGHTENED
#define SCIP_EVENTTYPE_UBRELAXED
#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_EXITPRESOLVE
enum SYM_Symtype SYM_SYMTYPE
#define SCIP_PRESOLTIMING_EXHAUSTIVE