88#define CONSHDLR_NAME "varbound"
89#define CONSHDLR_DESC "variable bounds lhs <= x + c*y <= rhs, x non-binary, y non-continuous"
90#define CONSHDLR_SEPAPRIORITY +900000
91#define CONSHDLR_ENFOPRIORITY -500000
92#define CONSHDLR_CHECKPRIORITY -500000
93#define CONSHDLR_SEPAFREQ 0
94#define CONSHDLR_PROPFREQ 1
95#define CONSHDLR_EAGERFREQ 100
97#define CONSHDLR_MAXPREROUNDS -1
98#define CONSHDLR_DELAYSEPA FALSE
99#define CONSHDLR_DELAYPROP FALSE
100#define CONSHDLR_NEEDSCONS TRUE
102#define CONSHDLR_PRESOLTIMING (SCIP_PRESOLTIMING_FAST | SCIP_PRESOLTIMING_MEDIUM)
103#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP
105#define EVENTHDLR_NAME "varbound"
106#define EVENTHDLR_DESC "bound change event handler for variable bound constraints"
108#define LINCONSUPGD_PRIORITY +50000
117#define DEFAULT_PRESOLPAIRWISE TRUE
118#define DEFAULT_MAXLPCOEF 1e+09
119#define DEFAULT_USEBDWIDENING TRUE
122#define MAXSCALEDCOEF 1000LL
136 unsigned int presolved:1;
137 unsigned int varboundsadded:1;
138 unsigned int changed:1;
139 unsigned int tightened:1;
143struct SCIP_ConshdlrData
146 SCIP_Bool presolpairwise;
148 SCIP_Bool usebdwidening;
204 && !consdata1->changed && consdata2->changed) )
208 && (consdata1->changed == consdata2->changed) )
228 (*conshdlrdata)->eventhdlr = eventhdlr;
319 SCIPerrorMessage(
"left hand side of varbound constraint greater than right hand side\n");
335 (*consdata)->var =
var;
336 (*consdata)->vbdvar = vbdvar;
337 (*consdata)->vbdcoef = vbdcoef;
338 (*consdata)->lhs = lhs;
339 (*consdata)->rhs = rhs;
340 (*consdata)->row =
NULL;
341 (*consdata)->nlrow =
NULL;
342 (*consdata)->presolved =
FALSE;
343 (*consdata)->varboundsadded =
FALSE;
344 (*consdata)->changed =
TRUE;
345 (*consdata)->tightened =
FALSE;
377 if( (*consdata)->row !=
NULL )
383 if( (*consdata)->nlrow !=
NULL )
423 SCIP_Bool* infeasible
435 if( conshdlr ==
NULL )
450 if( consdata->row ==
NULL )
484 if( consdata->nlrow ==
NULL )
489 assert(consdata->lhs <= consdata->rhs);
491 vars[0] = consdata->var;
492 vars[1] = consdata->vbdvar;
495 coefs[1] = consdata->vbdcoef;
517 SCIP_Bool checklprows
527 SCIPdebugMsg(
scip,
"checking variable bound constraint <%s> for feasibility of solution %p (lprows=%u)\n",
533 SCIP_Real lhsrelviol;
534 SCIP_Real rhsrelviol;
539 absviol =
MAX(consdata->lhs - sum, sum - consdata->rhs);
542 relviol =
MAX(lhsrelviol, rhsrelviol);
570 SCIP_Bool usebdwidening
585 vbdvar = consdata->vbdvar;
588 vbdcoef = consdata->vbdcoef;
601 SCIP_Real
QUAD(relaxedbd);
674 assert(infervar == vbdvar);
680 SCIP_Real
QUAD(relaxedub);
789 SCIP_Real
QUAD(relaxedbd);
861 assert(infervar == vbdvar);
867 SCIP_Real
QUAD(relaxedlb);
988 SCIP_Bool usebdwidening
1003 SCIP_Real relaxedub;
1010 relaxedub = inferbd - 1.0;
1020 assert(infervar == consdata->var);
1022 abscoef =
REALABS(consdata->vbdcoef);
1042 inferbd = inferbd + 1.0;
1052 assert(infervar == consdata->var);
1054 abscoef =
REALABS(consdata->vbdcoef);
1071 SCIP_Real relaxedlb;
1080 relaxedlb = inferbd + 1.0;
1090 assert(infervar == consdata->var);
1092 abscoef =
REALABS(consdata->vbdcoef);
1112 inferbd = inferbd - 1.0;
1122 assert(infervar == consdata->var);
1124 abscoef =
REALABS(consdata->vbdcoef);
1152 SCIP_Bool usebdwidening,
1162 SCIP_Real feasibility;
1172 if( conshdlr ==
NULL )
1180 var = consdata->var;
1181 vbdvar = consdata->vbdvar;
1182 vbdcoef = consdata->vbdcoef;
1193 SCIP_Real
QUAD(tmp);
1195 SCIP_Bool tightened;
1215 else if( tightened )
1224 SCIP_Real
QUAD(tmp);
1226 SCIP_Bool tightened;
1246 else if( tightened )
1261 if( consdata->row ==
NULL )
1273 SCIP_Bool infeasible;
1318 consdata->rhs = lhs;
1327 if( consdata->vbdcoef > 0.0 )
1341 if( consdata->vbdcoef > 0.0 )
1354 consdata->varboundsadded =
FALSE;
1355 consdata->tightened =
FALSE;
1360 consdata->presolved =
FALSE;
1361 consdata->lhs = lhs;
1362 consdata->changed =
TRUE;
1398 consdata->lhs = rhs;
1408 if( consdata->vbdcoef > 0.0 )
1422 if( consdata->vbdcoef > 0.0 )
1435 consdata->varboundsadded =
FALSE;
1436 consdata->tightened =
FALSE;
1441 consdata->presolved =
FALSE;
1442 consdata->rhs = rhs;
1443 consdata->changed =
TRUE;
1453 SCIP_Bool usebdwidening,
1467 SCIP_Bool tightened;
1468 SCIP_Bool tightenedround;
1476 SCIPdebugMsg(
scip,
"propagating variable bound constraint <%s>: %.15g <= <%s>[%.9g, %.9g] + %.15g<%s>[%.9g, %.9g] <= %.15g\n",
1498 SCIP_Bool infeasible;
1514 tightenedround =
FALSE;
1526 if( consdata->vbdcoef > 0.0 )
1530 SCIP_Real
QUAD(tmp);
1546 SCIP_Real
QUAD(tmp);
1576 tightenedround =
TRUE;
1590 if( consdata->vbdcoef > 0.0 )
1592 SCIP_Real
QUAD(tmp);
1598 if( newlb > ylb + 0.5 )
1615 tightenedround =
TRUE;
1623 SCIP_Real
QUAD(tmp);
1630 if( newub < yub - 0.5 )
1649 tightenedround =
TRUE;
1669 if( consdata->vbdcoef > 0.0 )
1673 SCIP_Real
QUAD(tmp);
1689 SCIP_Real
QUAD(tmp);
1719 tightenedround =
TRUE;
1733 if( consdata->vbdcoef > 0.0 )
1735 SCIP_Real
QUAD(tmp);
1741 if( newub < yub - 0.5 )
1760 tightenedround =
TRUE;
1769 SCIP_Real
QUAD(tmp);
1775 if( newlb > ylb + 0.5 )
1794 tightenedround =
TRUE;
1805 while( tightenedround );
1812 ((consdata->vbdcoef > 0.0 &&
SCIPisGE(
scip, xlb + consdata->vbdcoef * ylb, consdata->lhs))
1813 || (consdata->vbdcoef < 0.0 &&
SCIPisGE(
scip, xlb + consdata->vbdcoef * yub, consdata->lhs))) )
1823 ((consdata->vbdcoef > 0.0 &&
SCIPisLE(
scip, xub + consdata->vbdcoef * yub, consdata->rhs))
1824 || (consdata->vbdcoef < 0.0 &&
SCIPisLE(
scip, xub + consdata->vbdcoef * ylb, consdata->rhs))) )
1834 || (consdata->vbdcoef > 0.0 &&
SCIPisGE(
scip, xlb + consdata->vbdcoef * ylb, consdata->lhs))
1835 || (consdata->vbdcoef < 0.0 &&
SCIPisGE(
scip, xlb + consdata->vbdcoef * yub, consdata->lhs)))
1837 || (consdata->vbdcoef > 0.0 &&
SCIPisLE(
scip, xub + consdata->vbdcoef * yub, consdata->rhs))
1838 || (consdata->vbdcoef < 0.0 &&
SCIPisLE(
scip, xub + consdata->vbdcoef * ylb, consdata->rhs))) )
1840 SCIPdebugMsg(
scip,
"variable bound constraint <%s> is redundant: <%s>[%.15g,%.15g], <%s>[%.15g,%.15g]\n",
1847#ifdef SCIP_DISABLED_CODE
1892 if( ndelconss !=
NULL )
1913 SCIP_Bool* sideequal,
1915 SCIP_Bool* cons0sidered,
1916 SCIP_Bool* cons1sidered,
1924 SCIP_Real boundxlb1;
1925 SCIP_Real boundxlb2;
1926 SCIP_Real boundylb1;
1927 SCIP_Real boundylb2;
1928 SCIP_Real boundxub1;
1929 SCIP_Real boundxub2;
1930 SCIP_Real boundyub1;
1931 SCIP_Real boundyub2;
1932 SCIP_Real boundvaluex1;
1933 SCIP_Real boundvaluex2;
1934 SCIP_Real boundvaluey1;
1935 SCIP_Real boundvaluey2;
1940 SCIP_Bool* redundant0;
1941 SCIP_Bool* redundant1;
1957 redundant0 = cons1sidered;
1958 redundant1 = cons0sidered;
1962 redundant0 = cons0sidered;
1963 redundant1 = cons1sidered;
1972 if( !*redundant0 && !*redundant1 )
1975 boundxlb1 = side0 - lbvbdvar*coef0;
1976 boundxlb2 = side1 - lbvbdvar*coef1;
1977 boundylb1 = (side0 - lbvar)/coef0;
1978 boundylb2 = (side1 - lbvar)/coef1;
1980 boundxub1 = side0 - ubvbdvar*coef0;
1981 boundxub2 = side1 - ubvbdvar*coef1;
1982 boundyub1 = (side0 - ubvar)/coef0;
1983 boundyub2 = (side1 - ubvar)/coef1;
1987 boundvaluex1 =
MAX(boundxlb1, boundxlb2);
1988 boundvaluex2 =
MAX(boundxub1, boundxub2);
1992 boundvaluex1 =
MIN(boundxlb1, boundxlb2);
1993 boundvaluex2 =
MIN(boundxub1, boundxub2);
1999 valuex1 =
MIN(boundvaluex1, ubvar);
2000 valuex1 =
MAX(valuex1, lbvar);
2001 valuex2 =
MAX(boundvaluex2, lbvar);
2002 valuex2 =
MIN(valuex2, ubvar);
2015 valuex1 =
MAX(boundvaluex1, lbvar);
2016 valuex1 =
MIN(valuex1, ubvar);
2017 valuex2 =
MIN(boundvaluex2, ubvar);
2018 valuex2 =
MAX(valuex2, lbvar);
2031 valuey1 = (side0 - valuex1)/coef0;
2032 valuey2 = (side1 - valuex1)/coef1;
2035 if( valuey1 - valuey2 <=
eps )
2039 if( valuey1 < valuey2 )
2046 if( valuey1 < valuey2 )
2053 valuey1 = (side0 - valuex2)/coef0;
2054 valuey2 = (side1 - valuex2)/coef1;
2060 if( (*redundant1 && valuey1 > valuey2) || (*redundant0 && valuey1 < valuey2) )
2063 *redundant0 =
FALSE;
2064 *redundant1 =
FALSE;
2067 else if( *sideequal )
2069 if( valuey1 +
eps < valuey2 )
2074 else if( valuey1 +
eps > valuey2 )
2084 if( (*redundant1 && valuey1 < valuey2) || (*redundant0 && valuey1 > valuey2) )
2087 *redundant0 =
FALSE;
2088 *redundant1 =
FALSE;
2091 else if( *sideequal )
2093 if( valuey1 +
eps < valuey2 )
2098 else if( valuey1 +
eps > valuey2 )
2105 assert(*sideequal || *redundant0 || *redundant1);
2112 boundvaluey1 =
MAX(boundylb1, boundylb2);
2113 boundvaluey2 =
MAX(boundyub1, boundyub2);
2117 boundvaluey1 =
MIN(boundylb1, boundylb2);
2118 boundvaluey2 =
MIN(boundyub1, boundyub2);
2121 valuey1 =
MIN(boundvaluey1, ubvbdvar);
2122 valuey1 =
MAX(valuey1, lbvbdvar);
2123 valuey2 =
MAX(boundvaluey2, lbvbdvar);
2124 valuey2 =
MIN(valuey2, ubvbdvar);
2135 boundvaluey1 =
MIN(boundylb1, boundylb2);
2136 boundvaluey2 =
MIN(boundyub1, boundyub2);
2140 boundvaluey1 =
MAX(boundylb1, boundylb2);
2141 boundvaluey2 =
MAX(boundyub1, boundyub2);
2144 valuey1 =
MAX(boundvaluey1, lbvbdvar);
2145 valuey1 =
MIN(valuey1, ubvbdvar);
2146 valuey2 =
MIN(boundvaluey2, ubvbdvar);
2147 valuey2 =
MAX(valuey2, lbvbdvar);
2157 valuex1 = side0 - valuey1*coef0;
2158 valuex2 = side1 - valuey1*coef1;
2161 if( (*redundant1 && valuex1 > valuex2) || (*redundant0 && valuex1 < valuex2) )
2164 *redundant0 =
FALSE;
2165 *redundant1 =
FALSE;
2170 if( valuex1 +
eps < valuex2 )
2175 else if( valuex1 +
eps > valuex2 )
2183 valuex1 = side0 - valuey2*coef0;
2184 valuex2 = side1 - valuey2*coef1;
2187 if( (*redundant1 && valuex1 > valuex2) || (*redundant0 && valuex1 < valuex2) )
2190 *redundant0 =
FALSE;
2191 *redundant1 =
FALSE;
2196 if( valuex1 +
eps < valuex2 )
2201 else if( valuex1 +
eps > valuex2 )
2207 assert(*redundant0 || *redundant1 || *sideequal);
2280 SCIPsortPtr((
void**)sortedconss, consVarboundComp, nconss);
2283 for(
c = nconss - 1;
c > 0 && !(*cutoff); --
c )
2288 cons0 = sortedconss[
c];
2302 if( !consdata0->changed )
2305 consdata0->changed =
FALSE;
2307 for( s =
c - 1; s >= 0; --s )
2314 SCIP_Bool deletecons1;
2316 cons1 = sortedconss[s];
2330 lhs = consdata0->lhs;
2331 rhs = consdata0->rhs;
2332 coef = consdata0->vbdcoef;
2335 if ( consdata0->var == consdata1->vbdvar && consdata0->vbdvar == consdata1->var &&
2338 SCIP_Bool tightened =
FALSE;
2343 scalar = (1.0 - coef * consdata1->vbdcoef);
2355 bnd = (lhs - coef * consdata1->rhs)/scalar;
2361 bnd = (lhs - coef * consdata1->lhs)/scalar;
2398 bnd = (rhs - coef * consdata1->lhs)/scalar;
2404 bnd = (rhs - coef * consdata1->rhs)/scalar;
2441 bnd = (consdata1->lhs - consdata1->vbdcoef * rhs)/scalar;
2447 bnd = (consdata1->lhs - consdata1->vbdcoef * lhs)/scalar;
2484 bnd = (consdata1->rhs - consdata1->vbdcoef * lhs)/scalar;
2490 bnd = (consdata1->rhs - consdata1->vbdcoef * rhs)/scalar;
2522 if( consdata0->var != consdata1->var || consdata0->vbdvar != consdata1->vbdvar )
2531 lhs =
MAX(consdata1->lhs, lhs);
2532 rhs =
MIN(consdata1->rhs, rhs);
2545 lhs =
MAX(consdata1->lhs, lhs);
2546 coef = lhs -
MAX(consdata1->lhs - consdata1->vbdcoef, consdata0->lhs - coef);
2551 rhs =
MIN(consdata1->rhs, rhs);
2552 coef = rhs -
MIN(consdata1->rhs - consdata1->vbdcoef, consdata0->rhs - coef);
2561 SCIP_Bool cons0lhsred;
2562 SCIP_Bool cons0rhsred;
2563 SCIP_Bool cons1lhsred;
2564 SCIP_Bool cons1rhsred;
2574 checkRedundancySide(
scip, consdata0->var, consdata0->vbdvar, coef, consdata1->vbdcoef, lhs, consdata1->lhs, &lhsequal, &cons0lhsred, &cons1lhsred,
TRUE);
2577 checkRedundancySide(
scip, consdata0->var, consdata0->vbdvar, coef, consdata1->vbdcoef, rhs, consdata1->rhs, &rhsequal, &cons0rhsred, &cons1rhsred,
FALSE);
2580 if( (lhsequal || cons0lhsred) && (rhsequal || cons0rhsred) )
2597 else if( cons1lhsred && cons1rhsred )
2637 deletecons1 =
FALSE;
2663 deletecons1 =
FALSE;
2716 rhs = (lhs + rhs)/2;
2727 SCIP_Bool infeasible;
2728 SCIP_Bool tightened;
2780 if( consdata0->vbdcoef * coef < 0.0 )
2787 if( consdata0->vbdcoef > 0.0 )
2809 consdata0->varboundsadded =
FALSE;
2810 consdata0->tightened =
FALSE;
2811 consdata0->presolved =
FALSE;
2812 consdata0->changed =
FALSE;
2814 consdata0->vbdcoef = coef;
2877 for(
c = nconss - 1;
c >= 0; --
c )
2897 SCIP_Longint nominator;
2898 SCIP_Longint denominator;
2899 SCIP_Longint maxmult;
2909 success =
SCIPrealToRational(consdata->vbdcoef, -epsilon, epsilon , maxmult, &nominator, &denominator);
2916 denominator /= nominator;
2920 success = success && (denominator <= maxmult);
2923 if( success &&
ABS(denominator) > 1 && nominator == 1 )
2933 if( consdata->vbdcoef < 0 )
2942 consdata->lhs = consdata->rhs * denominator;
2950 consdata->rhs = consdata->lhs * denominator;
2960 tmp = consdata->lhs;
2961 consdata->lhs = consdata->rhs * denominator;
2962 consdata->rhs = tmp * denominator;
2963 consdata->tightened =
FALSE;
2978 consdata->lhs *= denominator;
2986 consdata->rhs *= denominator;
2995 swapvar = consdata->var;
2996 consdata->var = consdata->vbdvar;
2997 consdata->vbdvar = swapvar;
3000 consdata->vbdcoef = (
SCIP_Real)denominator;
3004 consdata->varboundsadded =
FALSE;
3005 consdata->tightened =
FALSE;
3030 SCIP_Real varscalar;
3031 SCIP_Real varconstant;
3033 SCIP_Real vbdvarscalar;
3034 SCIP_Real vbdvarconstant;
3035 SCIP_Bool varschanged;
3036 SCIP_Bool redundant;
3053 var = consdata->var;
3057 vbdvar = consdata->vbdvar;
3059 vbdvarconstant = 0.0;
3061 varschanged = (
var != consdata->var || vbdvar != consdata->vbdvar);
3069 SCIPdebugMsg(
scip,
"variable bound constraint <%s> has equal variable and vbd variable <%s>\n",
3075 scalar = varscalar + consdata->vbdcoef * vbdvarscalar;
3076 constant = varconstant + consdata->vbdcoef * vbdvarconstant;
3083 else if( scalar > 0.0 )
3087 SCIP_Bool tightened;
3098 SCIP_Bool tightened;
3112 SCIP_Bool tightened;
3123 SCIP_Bool tightened;
3149 SCIPdebugMsg(
scip,
"variable bound constraint <%s>: variable <%s> is fixed to %.15g\n",
3161 assert( consdata->vbdcoef != 0.0 );
3162 assert( vbdvarscalar != 0.0 );
3167 if( consdata->vbdcoef > 0.0 )
3169 SCIP_Bool tightened;
3181 SCIP_Bool tightened;
3194 if( consdata->vbdcoef > 0.0 )
3196 SCIP_Bool tightened;
3208 SCIP_Bool tightened;
3222 else if(
var != consdata->var )
3230 if( consdata->vbdcoef > 0.0 )
3242 if( varscalar > 0.0 )
3249 consdata->lhs = (consdata->lhs - varconstant)/varscalar;
3251 consdata->rhs = (consdata->rhs - varconstant)/varscalar;
3252 consdata->vbdcoef /= varscalar;
3258 consdata->tightened =
FALSE;
3264 assert(varscalar != 0.0);
3270 lhs = consdata->lhs;
3271 consdata->lhs = -consdata->rhs;
3272 consdata->rhs = -lhs;
3274 consdata->lhs = (consdata->lhs + varconstant)/(-varscalar);
3276 consdata->rhs = (consdata->rhs + varconstant)/(-varscalar);
3277 consdata->vbdcoef /= varscalar;
3283 consdata->tightened =
FALSE;
3286 consdata->var =
var;
3294 if( consdata->vbdcoef > 0.0 )
3309 SCIPdebugMsg(
scip,
"variable bound constraint <%s>: vbd variable <%s> is fixed to %.15g\n",
3321 SCIP_Bool tightened;
3333 SCIP_Bool tightened;
3346 else if( vbdvar != consdata->vbdvar )
3349 if( consdata->vbdcoef > 0.0 )
3371 consdata->lhs -= consdata->vbdcoef * vbdvarconstant;
3373 consdata->rhs -= consdata->vbdcoef * vbdvarconstant;
3375 consdata->tightened =
FALSE;
3376 consdata->vbdcoef *= vbdvarscalar;
3377 consdata->vbdvar = vbdvar;
3381 if( consdata->vbdcoef > 0.0 )
3405 consdata->changed =
TRUE;
3415 lhs = consdata->lhs;
3416 rhs = consdata->rhs;
3426 if(
var != consdata->var )
3452 if( vbdvar != consdata->vbdvar )
3472 assert(vbdvar == consdata->vbdvar);
3489 if( !(*
cutoff) && redundant )
3528 if( consdata->tightened )
3533 consdata->tightened =
TRUE;
3544 consdata->changed =
TRUE;
3550 consdata->changed =
TRUE;
3558 oldnchgcoefs = *nchgcoefs;
3559 oldnchgsides = *nchgsides;
3560 oldcoef = consdata->vbdcoef;
3646 else if( (
SCIPisInfinity(
scip, -consdata->lhs) ||
SCIPisFeasGE(
scip, consdata->vbdcoef -
SCIPfeasFloor(
scip, consdata->vbdcoef), consdata->lhs -
SCIPfeasFloor(
scip, consdata->lhs))) && (
SCIPisInfinity(
scip, consdata->rhs) ||
SCIPisFeasGT(
scip, consdata->vbdcoef -
SCIPfeasFloor(
scip, consdata->vbdcoef), consdata->rhs -
SCIPfeasFloor(
scip, consdata->rhs))) )
3667 else if( (
SCIPisInfinity(
scip, -consdata->lhs) ||
SCIPisFeasLT(
scip, consdata->vbdcoef -
SCIPfeasFloor(
scip, consdata->vbdcoef), consdata->lhs -
SCIPfeasFloor(
scip, consdata->lhs))) && (
SCIPisInfinity(
scip, consdata->rhs) ||
SCIPisFeasLE(
scip, consdata->vbdcoef -
SCIPfeasFloor(
scip, consdata->vbdcoef), consdata->rhs -
SCIPfeasFloor(
scip, consdata->rhs))) )
3727 SCIP_Bool tightened;
3740 SCIP_Bool tightened;
3757 consdata->vbdcoef = oldcoef;
3785 oldrhs = consdata->rhs;
3791 newcoef =
MAX(consdata->vbdcoef - consdata->rhs + xub, consdata->lhs - xlb);
3805 newrhs = consdata->rhs - consdata->vbdcoef + newcoef;
3808 "tighten varbound %.15g <= <%s>[%.15g,%.15g] %+.15g<%s> <= %.15g to %.15g <= <%s> %+.15g<%s> <= %.15g\n",
3809 consdata->lhs,
SCIPvarGetName(consdata->var), xlb, xub, consdata->vbdcoef,
3815 assert(consdata->vbdcoef * newcoef > 0);
3817 consdata->vbdcoef = newcoef;
3818 consdata->rhs =
MAX(newrhs, consdata->lhs);
3828 consdata->tightened =
FALSE;
3830 assert(consdata->tightened);
3842 oldlhs = consdata->lhs;
3848 newcoef =
MIN(consdata->vbdcoef - consdata->lhs + xlb, consdata->rhs - xub);
3862 newlhs = consdata->lhs - consdata->vbdcoef + newcoef;
3865 "tighten varbound %.15g <= <%s>[%.15g,%.15g] %+.15g<%s> <= %.15g to %.15g <= <%s> %+.15g<%s> <= %.15g\n",
3866 consdata->lhs,
SCIPvarGetName(consdata->var), xlb, xub, consdata->vbdcoef,
3872 assert(consdata->vbdcoef * newcoef > 0);
3874 consdata->vbdcoef = newcoef;
3875 consdata->lhs =
MIN(newlhs, consdata->rhs);
3885 consdata->tightened =
FALSE;
3887 assert(consdata->tightened);
3897 if( consdata->vbdcoef > 0.0 &&
SCIPisFeasGT(
scip, xlb, consdata->lhs - consdata->vbdcoef) )
3905 newcoef = consdata->lhs - xlb;
3918 SCIPdebugMsg(
scip,
"tighten binary VLB <%s>[%.15g,%.15g] %+.15g<%s> >= %.15g to <%s> %+.15g<%s> >= %.15g\n",
3925 assert(consdata->vbdcoef * newcoef > 0);
3927 consdata->vbdcoef = newcoef;
3931 else if( consdata->vbdcoef < 0.0 &&
SCIPisFeasGT(
scip, xlb, consdata->lhs) )
3939 newcoef = consdata->vbdcoef - consdata->lhs + xlb;
3952 SCIPdebugMsg(
scip,
"tighten binary VLB <%s>[%.15g,%.15g] %+.15g<%s> >= %.15g to <%s> %+.15g<%s> >= %.15g\n",
3955 SCIPvarGetName(consdata->var), consdata->vbdcoef - consdata->lhs + xlb,
3959 assert(consdata->vbdcoef * newcoef > 0);
3961 consdata->vbdcoef = newcoef;
3962 consdata->lhs = xlb;
3979 newcoef = consdata->vbdcoef - consdata->rhs + xub;
3992 SCIPdebugMsg(
scip,
"tighten binary VUB <%s>[%.15g,%.15g] %+.15g<%s> <= %.15g to <%s> %+.15g<%s> <= %.15g\n",
3995 SCIPvarGetName(consdata->var), consdata->vbdcoef - consdata->rhs + xub,
3999 assert(consdata->vbdcoef * newcoef > 0);
4001 consdata->vbdcoef = newcoef;
4002 consdata->rhs = xub;
4007 else if( consdata->vbdcoef < 0.0 &&
SCIPisFeasLT(
scip, xub, consdata->rhs - consdata->vbdcoef) )
4015 newcoef = consdata->rhs - xub;
4028 SCIPdebugMsg(
scip,
"tighten binary VUB <%s>[%.15g,%.15g] %+.15g<%s> <= %.15g to <%s> %+.15g<%s> <= %.15g\n",
4033 assert(consdata->vbdcoef * newcoef > 0);
4035 consdata->vbdcoef = newcoef;
4044 if( *nchgcoefs > oldnchgcoefs || *nchgsides > oldnchgsides )
4046 consdata->varboundsadded =
FALSE;
4047 consdata->changed =
TRUE;
4097 for(
c = nconss - 1;
c >= 0; --
c )
4109 if( !consdata->presolved )
4131 if( !consdata->tightened )
4154 if( consdata->vbdcoef > 0.0 )
4161 SCIP_Bool infeasible;
4162 SCIP_Bool redundant;
4163 SCIP_Bool aggregated;
4165 SCIPdebugMsg(
scip,
"varbound constraint <%s>: aggregate <%s> + <%s> == 1\n",
4178 assert(consdata->lhs < 0.5);
4180 vars[0] = consdata->var;
4181 vars[1] = consdata->vbdvar;
4200 SCIP_Bool infeasible;
4201 SCIP_Bool redundant;
4202 SCIP_Bool aggregated;
4204 SCIPdebugMsg(
scip,
"varbound constraint <%s>: aggregate <%s> - <%s> == 0\n",
4217 assert(consdata->lhs < -0.5);
4219 vars[0] = consdata->var;
4228 vars[1] = consdata->vbdvar;
4274 upgrade = (
nvars == 2) && (nposbin + nnegbin <= 1) && (nposcont + nnegcont <= 1);
4306 vbdvar =
vars[vbdind];
4309 vbdcoef = vals[vbdind]/vals[1-vbdind];
4311 if( vals[1-vbdind] > 0.0 )
4346 SCIP_Real constant = 0.0;
4374 cons, lhs, rhs, success) );
4435 for(
c = 0;
c < nconss; ++
c )
4452 for(
c = 0;
c < nconss; ++
c )
4457 if( consdata->row !=
NULL )
4462 if( consdata->nlrow !=
NULL )
4511 sourcedata->var, sourcedata->vbdvar, sourcedata->vbdcoef, sourcedata->lhs, sourcedata->rhs) );
4533 *infeasible =
FALSE;
4535 for(
i = 0;
i < nconss && !(*infeasible);
i++ )
4560 for(
i = 0;
i < nusefulconss; ++
i )
4590 for(
i = 0;
i < nusefulconss; ++
i )
4619 for(
i = 0;
i < nconss;
i++ )
4659 for(
i = 0;
i < nconss;
i++ )
4691 for(
i = 0;
i < nconss;
i++ )
4772 SCIPdebugMsg(
scip,
"propagating %d variable bound constraints\n", nmarkedconss);
4775 for(
i = 0;
i < nmarkedconss && !
cutoff;
i++ )
4782 else if( nchgbds > 0 )
4817 oldnchgbds = *nchgbds;
4818 oldndelconss = *ndelconss;
4819 oldnaddconss = *naddconss;
4820 oldnchgcoefs = *nchgcoefs;
4821 oldnchgsides = *nchgsides;
4822 oldnaggrvars = *naggrvars;
4824 for(
i = 0;
i < nconss;
i++ )
4839 consdata->presolved =
FALSE;
4841 if( consdata->presolved )
4843 consdata->presolved =
TRUE;
4869 if( !consdata->varboundsadded )
4871 SCIP_Bool infeasible;
4873 int localoldnchgbds;
4875 localoldnchgbds = *nchgbds;
4880 SCIPdebugMsg(
scip,
"adding variable lower bound <%s> >= %g<%s> + %g (and potentially also <%s> %s %g<%s> + %g)\n",
4882 SCIPvarGetName(consdata->vbdvar), (consdata->vbdcoef > 0 ?
">=" :
"<="), 1.0/-consdata->vbdcoef,
4886 &infeasible, &nlocalchgbds) );
4889 *nchgbds += nlocalchgbds;
4895 SCIPdebugMsg(
scip,
"adding variable upper bound <%s> <= %g<%s> + %g (and potentially also <%s> %s %g<%s> + %g)\n",
4897 SCIPvarGetName(consdata->vbdvar), (consdata->vbdcoef > 0 ?
"<=" :
">="), 1.0/-consdata->vbdcoef,
4901 &infeasible, &nlocalchgbds) );
4904 *nchgbds += nlocalchgbds;
4906 consdata->varboundsadded =
TRUE;
4908 if( *nchgbds > localoldnchgbds )
4924 SCIP_CALL(
upgradeConss(
scip, conshdlrdata, conss, nconss, &
cutoff, naggrvars, nchgbds, nchgcoefs, nchgsides, ndelconss, naddconss) );
4936 else if( *nchgbds > oldnchgbds || *ndelconss > oldndelconss || *naddconss > oldnaddconss
4937 || *nchgcoefs > oldnchgcoefs || *nchgsides > oldnchgsides || *naggrvars > oldnaggrvars )
4977 if( consdata->vbdcoef > 0.0 )
4990 if( consdata->vbdcoef > 0.0 )
5085 const char* consname;
5104 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode, global,
valid) );
5143 if( isdigit(str[0]) || ((str[0] ==
'-' || str[0] ==
'+') && isdigit(str[1])) )
5154 if( endstr[0] !=
'<' || endstr[1] !=
'=' )
5156 SCIPerrorMessage(
"missing \"<=\" after left hand side(, found %c%c)\n", endstr[0], endstr[1]);
5173 if( requiredsize == 2 && *success )
5187 if( *str !=
'\0' && *(str+1) !=
'\0' &&
SCIPparseReal(
scip, str+2, &value, &endstr) )
5212 else if( strncmp(str,
"[free]", 6) != 0 )
5219 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
5246 vars[0] = consdata->var;
5247 vars[1] = consdata->vbdvar;
5301 consdata->presolved =
FALSE;
5307 consdata->presolved =
FALSE;
5308 consdata->tightened =
FALSE;
5330 eventExecVarbound,
NULL) );
5338 consEnfolpVarbound, consEnfopsVarbound, consCheckVarbound, consLockVarbound,
5375 "should pairwise constraint comparison be performed in presolving?",
5379 "maximum coefficient in varbound constraint to be added as a row into LP",
5382 "constraints/" CONSHDLR_NAME "/usebdwidening",
"should bound widening be used in conflict analysis?",
5413 SCIP_Bool modifiable,
5419 SCIP_Bool removable,
5421 SCIP_Bool stickingatnode
5432 if( conshdlr ==
NULL )
5445 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
5446 local, modifiable, dynamic, removable, stickingatnode) );
5499 return consdata->lhs;
5522 return consdata->rhs;
5545 return consdata->var;
5568 return consdata->vbdvar;
5591 return consdata->vbdcoef;
5614 if( consdata->row !=
NULL )
5640 if( consdata->row !=
NULL )
5668 return consdata->row;
5674 SCIP_Bool onlychecked,
5675 SCIP_Bool* infeasible,
5689 if( conshdlr ==
NULL )
5693 *infeasible =
FALSE;
5702 eventhdlr = conshdlrdata->eventhdlr;
5707 for(
i = nconss - 1;
i >= 0; --
i )
Constraint handler for linear constraints in their most general form, .
Constraint handler for the set partitioning / packing / covering constraints .
static SCIP_RETCODE addRelaxation(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible)
static SCIP_RETCODE dropEvents(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr)
#define DEFAULT_USEBDWIDENING
#define CONSHDLR_NEEDSCONS
#define CONSHDLR_SEPAFREQ
#define CONSHDLR_CHECKPRIORITY
static SCIP_RETCODE upgradeConss(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_CONS **conss, int nconss, SCIP_Bool *cutoff, int *naggrvars, int *nchgbds, int *nchgcoefs, int *nchgsides, int *ndelconss, int *naddconss)
static SCIP_RETCODE applyFixings(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool *cutoff, int *nchgbds, int *ndelconss, int *naddconss)
static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_CONSDATA **consdata, SCIP_VAR *var, SCIP_VAR *vbdvar, SCIP_Real vbdcoef, SCIP_Real lhs, SCIP_Real rhs)
static SCIP_RETCODE tightenCoefs(SCIP *scip, SCIP_CONS *cons, int *nchgcoefs, int *nchgsides, int *ndelconss, SCIP_Bool *cutoff, int *nchgbds)
static SCIP_RETCODE createRelaxation(SCIP *scip, SCIP_CONS *cons)
#define CONSHDLR_PROP_TIMING
static void checkRedundancySide(SCIP *scip, SCIP_VAR *var, SCIP_VAR *vbdvar, SCIP_Real coef0, SCIP_Real coef1, SCIP_Real side0, SCIP_Real side1, SCIP_Bool *sideequal, SCIP_Bool *cons0sidered, SCIP_Bool *cons1sidered, SCIP_Bool islhs)
static void conshdlrdataFree(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata)
#define CONSHDLR_MAXPREROUNDS
static SCIP_Bool checkCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool checklprows)
#define DEFAULT_PRESOLPAIRWISE
#define CONSHDLR_SEPAPRIORITY
#define DEFAULT_MAXLPCOEF
static void prettifyConss(SCIP *scip, SCIP_CONS **conss, int nconss, int *nchgcoefs, int *nchgsides)
static SCIP_RETCODE addSymmetryInformation(SCIP *scip, SYM_SYMTYPE symtype, SCIP_CONS *cons, SYM_GRAPH *graph, SCIP_Bool *success)
static SCIP_RETCODE preprocessConstraintPairs(SCIP *scip, SCIP_CONS **conss, int nconss, SCIP_Bool *cutoff, int *nchgbds, int *ndelconss, int *nchgcoefs, int *nchgsides)
static SCIP_RETCODE chgLhs(SCIP *scip, SCIP_CONS *cons, SCIP_Real lhs)
static SCIP_RETCODE analyzeConflict(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *infervar, SCIP_Real inferbd, PROPRULE proprule, SCIP_BOUNDTYPE boundtype, SCIP_Bool usebdwidening)
static SCIP_RETCODE chgRhs(SCIP *scip, SCIP_CONS *cons, SCIP_Real rhs)
#define CONSHDLR_PROPFREQ
static SCIP_RETCODE resolvePropagation(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *infervar, PROPRULE proprule, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real inferbd, SCIP_Bool usebdwidening)
static SCIP_RETCODE propagateCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool usebdwidening, SCIP_Bool *cutoff, int *nchgbds, int *nchgsides, int *ndelconss)
#define CONSHDLR_PRESOLTIMING
static SCIP_RETCODE consdataFree(SCIP *scip, 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 catchEvents(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr)
#define LINCONSUPGD_PRIORITY
static SCIP_RETCODE separateCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool usebdwidening, SCIP_SOL *sol, SCIP_RESULT *result)
#define CONSHDLR_DELAYSEPA
#define CONSHDLR_DELAYPROP
Constraint handler for variable bound constraints .
defines macros for basic operations in double-double arithmetic giving roughly twice the precision of...
#define SCIPquadprecDivQD(r, a, b)
#define SCIPquadprecProdDD(r, a, b)
#define SCIPquadprecProdQD(r, a, b)
#define SCIPquadprecSumQD(r, a, b)
#define QUAD_ASSIGN(a, constant)
#define SCIPquadprecSumDD(r, a, b)
#define SCIPquadprecSumQQ(r, a, b)
#define SCIP_VARTYPE_INTEGER_CHAR
#define SCIP_VARTYPE_IMPLINT_CHAR
#define SCIP_VARTYPE_BINARY_CHAR
#define SCIP_VARTYPE_CONTINUOUS_CHAR
SCIP_RETCODE SCIPincludeLinconsUpgrade(SCIP *scip, SCIP_DECL_LINCONSUPGD((*linconsupgd)), int priority, const char *conshdlrname)
SCIP_Real SCIPgetVbdcoefVarbound(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPchgRhsLinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real rhs)
SCIP_Real SCIPgetDualfarkasVarbound(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPaddCoefLinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPcreateConsBasicVarbound(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *var, SCIP_VAR *vbdvar, SCIP_Real vbdcoef, SCIP_Real lhs, SCIP_Real rhs)
SCIP_ROW * SCIPgetRowVarbound(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR * SCIPgetVbdvarVarbound(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 SCIPcleanupConssVarbound(SCIP *scip, SCIP_Bool onlychecked, SCIP_Bool *infeasible, int *naddconss, int *ndelconss, int *nchgbds)
SCIP_VAR * SCIPgetVarVarbound(SCIP *scip, SCIP_CONS *cons)
#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_Real SCIPgetLhsVarbound(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_Real SCIPgetRhsVarbound(SCIP *scip, SCIP_CONS *cons)
SCIP_Real SCIPgetDualsolVarbound(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsVarbound(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *var, SCIP_VAR *vbdvar, SCIP_Real vbdcoef, 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 SCIPchgLhsLinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real lhs)
SCIP_RETCODE SCIPincludeConshdlrVarbound(SCIP *scip)
SCIP_Bool SCIPisTransformed(SCIP *scip)
SCIP_Bool SCIPisStopped(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
int SCIPgetNIntVars(SCIP *scip)
int SCIPgetNImplVars(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)
SCIP_RETCODE SCIPdelConsLocal(SCIP *scip, SCIP_CONS *cons)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
SCIP_Bool SCIPrealToRational(SCIP_Real val, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Longint *nominator, SCIP_Longint *denominator)
SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPaddRealParam(SCIP *scip, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPaddBoolParam(SCIP *scip, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPaddConflictLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
SCIP_RETCODE SCIPinitConflictAnalysis(SCIP *scip, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
SCIP_RETCODE SCIPaddConflictUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
SCIP_RETCODE SCIPaddConflictRelaxedLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedlb)
SCIP_RETCODE SCIPaddConflictRelaxedUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedub)
SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)
SCIP_Real SCIPgetConflictVarUb(SCIP *scip, SCIP_VAR *var)
SCIP_Real SCIPgetConflictVarLb(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPanalyzeConflictCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)
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 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 SCIPsetConshdlrExitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONS ** SCIPconshdlrGetConss(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrInitlp(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrGetNVars(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONSDATA * SCIPconsGetData(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)
SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)
SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)
SCIP_Bool SCIPconsIsMarkedPropagate(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_RETCODE SCIPunmarkConsPropagate(SCIP *scip, 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_RETCODE SCIPmarkConsPropagate(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPconsIsModifiable(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)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPduplicateBufferArray(scip, ptr, source, num)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
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 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 SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)
SCIP_Real SCIPgetRowSolFeasibility(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
SCIP_Real SCIProwGetDualfarkas(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)
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 SCIPisIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfeasCeil(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfeasFloor(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPround(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 SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfeastol(SCIP *scip)
SCIP_Real SCIPgetHugeValue(SCIP *scip)
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPepsilon(SCIP *scip)
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasPositive(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPparseReal(SCIP *scip, const char *str, SCIP_Real *value, char **endptr)
SCIP_Bool SCIPinRepropagation(SCIP *scip)
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_RETCODE SCIPtightenVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_RETCODE SCIPchgVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
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_RETCODE SCIPinferVarUbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_RETCODE SCIPchgVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetProbvar(SCIP_VAR *var)
SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
SCIP_RETCODE SCIPgetProbvarSum(SCIP *scip, SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPaddVarVub(SCIP *scip, SCIP_VAR *var, SCIP_VAR *vubvar, SCIP_Real vubcoef, SCIP_Real vubconstant, SCIP_Bool *infeasible, int *nbdchgs)
int SCIPvarGetIndex(SCIP_VAR *var)
SCIP_RETCODE SCIPaddVarLocksType(SCIP *scip, SCIP_VAR *var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)
SCIP_RETCODE SCIPaddVarVlb(SCIP *scip, SCIP_VAR *var, SCIP_VAR *vlbvar, SCIP_Real vlbcoef, SCIP_Real vlbconstant, SCIP_Bool *infeasible, int *nbdchgs)
SCIP_RETCODE SCIPunlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_Real SCIPadjustedVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real ub)
SCIP_RETCODE SCIPparseVarsLinearsum(SCIP *scip, const char *str, SCIP_VAR **vars, SCIP_Real *vals, int *nvars, int varssize, int *requiredsize, char **endptr, SCIP_Bool *success)
SCIP_Real SCIPadjustedVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real lb)
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
SCIP_RETCODE SCIPinferVarLbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
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_RETCODE SCIPtightenVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
SCIP_RETCODE SCIPskipSpace(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
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 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_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_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_VARFIXED
#define SCIP_DECL_EVENTEXEC(x)
#define SCIP_EVENTTYPE_BOUNDTIGHTENED
enum SCIP_BoundType SCIP_BOUNDTYPE
#define SCIP_DECL_SORTPTRCOMP(x)
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
enum SYM_Symtype SYM_SYMTYPE
#define SCIP_PRESOLTIMING_MEDIUM
@ SCIP_VARTYPE_CONTINUOUS
@ SCIP_VARSTATUS_MULTAGGR