49 #define PROP_NAME "obbt" 50 #define PROP_DESC "optimization-based bound tightening propagator" 51 #define PROP_TIMING SCIP_PROPTIMING_AFTERLPLOOP 52 #define PROP_PRIORITY -1000000 54 #define PROP_DELAY TRUE 57 #define DEFAULT_CREATE_GENVBOUNDS TRUE 58 #define DEFAULT_FILTERING_NORM TRUE 60 #define DEFAULT_APPLY_FILTERROUNDS FALSE 62 #define DEFAULT_APPLY_TRIVIALFITLERING TRUE 63 #define DEFAULT_GENVBDSDURINGFILTER TRUE 64 #define DEFAULT_DUALFEASTOL 1e-9 66 #define DEFAULT_CONDITIONLIMIT -1.0 67 #define DEFAULT_BOUNDSTREPS 0.001 68 #define DEFAULT_FILTERING_MIN 2 70 #define DEFAULT_ITLIMITFACTOR 10.0 72 #define DEFAULT_MINITLIMIT 5000L 73 #define DEFAULT_ONLYNONCONVEXVARS FALSE 74 #define DEFAULT_TIGHTINTBOUNDSPROBING TRUE 76 #define DEFAULT_TIGHTCONTBOUNDSPROBING FALSE 78 #define DEFAULT_ORDERINGALGO 1 80 #define OBBT_SCOREBASE 5 81 #define GENVBOUND_PROP_NAME "genvbounds" 82 #define INTERVALINFTY 1E+43 84 #define DEFAULT_SEPARATESOL FALSE 87 #define DEFAULT_SEPAMINITER 0 88 #define DEFAULT_SEPAMAXITER 10 89 #define DEFAULT_GENVBDSDURINGSEPA TRUE 90 #define DEFAULT_PROPAGATEFREQ 0 92 #define DEFAULT_CREATE_BILININEQS TRUE 93 #define DEFAULT_ITLIMITFAC_BILININEQS 3.0 94 #define DEFAULT_MINNONCONVEXITY 1e-1 95 #define DEFAULT_RANDSEED 149 102 #define infty2infty(infty1, infty2, val) ((val) >= (infty1) ? (infty2) : (val)) 116 unsigned int found:1;
195 int ntrivialfiltered;
197 int ngenvboundsprobing;
198 int ngenvboundsaggrfil;
199 int ngenvboundstrivfil;
206 int propagatecounter;
226 assert(scip != NULL);
227 assert(itlimit == -1 || itlimit >= 0);
228 assert(error != NULL);
229 assert(optimal != NULL);
241 SCIPwarningMessage(scip,
" error while solving LP in obbt propagator; LP solve terminated with code <%d>\n", retcode);
242 SCIPwarningMessage(scip,
" this does not affect the remaining solution procedure --> continue\n");
263 SCIPdebugMsg(scip,
" reached time limit while solving lp\n");
272 SCIPdebugMsg(scip,
" an error occured during solving lp\n");
278 SCIPdebugMsg(scip,
" received an unexpected solstat during solving lp: %d\n", lpsolstat);
300 assert(scip != NULL);
302 assert(propdata != NULL);
303 assert(propdata->cutoffrow == NULL);
307 SCIPdebugMsg(scip,
"no objective cutoff since there is no cutoff bound\n");
311 SCIPdebugMsg(scip,
"create objective cutoff and add it to the LP\n");
321 for( i = 0; i < nvars; i++ )
330 propdata->cutoffrow = row;
362 assert( scip != NULL );
363 assert( propdata != NULL );
364 assert( bound != NULL );
381 for( i = 0; i < nvars; ++i )
387 assert((counter == 0 && coef == 0.0) || (counter == 1 && coef != 0.0));
402 assert(scip != NULL);
430 assert(scip != NULL);
431 assert(nolditerations >= 0);
432 assert(itlimit == -1 || itlimit >= 0);
442 itsleft =
MAX(itsleft, 0);
443 itsleft = MIN(itsleft, INT_MAX);
445 SCIPdebugMsg(scip,
"iterations left: %d\n", (
int) itsleft);
446 return (
int) itsleft;
462 assert(scip != NULL);
463 assert(propdata != NULL);
478 if( propdata->normalize )
533 assert(scip != NULL);
534 assert(bound != NULL);
535 assert(propdata != NULL);
536 assert(propdata->genvboundprop != NULL);
537 assert(found != NULL);
578 for( k = 0; k < nvars; k++ )
582 assert(vars[k] != xi);
588 if( propdata->cutoffrow == NULL )
604 if( ncoefs > 0 || !
SCIPisZero(scip, gamma_dual) )
628 for( k = 0; k < nvars; k++ )
647 addgenvbound =
FALSE;
652 assert(idx < ncoefs);
653 genvboundvars[idx] = xk;
654 genvboundcoefs[idx] = redcost;
664 assert(!addgenvbound || idx == ncoefs);
687 SCIPdebugMsg(scip,
" found multiplier for <%s>: %g, skipping\n",
703 assert(i >= 0 && i < propdata->nbounds);
704 assert(propdata->lastidx >= 0 && propdata->lastidx < propdata->nbounds);
707 if( propdata->lastidx != i )
711 tmp = propdata->bounds[i];
712 propdata->bounds[i] = propdata->bounds[propdata->lastidx];
713 propdata->bounds[propdata->lastidx] = tmp;
716 propdata->lastidx -= 1;
810 assert(scip != NULL);
811 assert(propdata != NULL);
812 assert(nfiltered != NULL);
819 SCIPdebugMsg(scip,
"can't filter using existing lp solution since it was not solved to optimality\n");
824 for( i = propdata->nbounds - 1; i >= 0; --i )
831 bound = propdata->bounds[i];
856 if( propdata->genvbdsduringfilter && currbound != NULL && basestat ==
SCIP_BASESTAT_BASIC )
883 assert(propdata->nprobingiterations >= 0);
886 if( optimal && propdata->genvboundprop != NULL
896 propdata->ngenvboundstrivfil += 1;
897 SCIPdebugMsg(scip,
"found genvbound during trivial filtering\n");
907 if( propdata->lastidx >= 0 )
916 for( i = propdata->lastbilinidx; i < propdata->nbilinbounds; ++i )
919 BILINBOUND* bilinbound = propdata->bilinbounds[i];
945 for( j = 0; j < 4; ++j )
950 getCorner(bilinbound->
x, bilinbound->
y, corners[j], &xt, &yt);
958 if( oldfiltered != bilinbound->
filtered )
962 SCIPdebugMessage(
"filtered corners %d for (%s,%s) = (%g,%g) in [%g,%g]x[%g,%g]\n",
992 assert(scip != NULL);
994 assert(propdata != NULL);
995 assert(itlimit == -1 || itlimit >= 0);
996 assert(nfiltered != NULL);
997 assert(objcoefs != NULL);
998 assert(objcoefsinds != NULL);
999 assert(nobjcoefs >= 0);
1010 assert(propdata->nfilterlpiters >= 0);
1014 SCIPdebugMsg(scip,
"skipping filter round since the LP was not solved to optimality\n");
1021 for( i = 0; i < propdata->nbounds; i++ )
1028 bound = propdata->bounds[i];
1060 for( j = 0; j < nobjcoefs; ++j )
1064 filterbound = propdata->bounds[ objcoefsinds[j] ];
1065 assert(filterbound != NULL);
1071 for( j = 0; j < nvars; ++j )
1082 assert(propdata->nfilterlpiters >= 0);
1085 if( optimal && propdata->genvboundprop != NULL
1095 propdata->ngenvboundsaggrfil += 1;
1096 SCIPdebugMsg(scip,
"found genvbound during aggressive filtering\n");
1102 for( j = 0; j < nobjcoefs; ++j )
1106 filterbound = propdata->bounds[ objcoefsinds[j] ];
1107 assert(filterbound != NULL);
1147 int nleftiterations;
1153 assert(scip != NULL);
1155 assert(propdata != NULL);
1156 assert(itlimit == -1 || itlimit >= 0);
1175 for( i = 0; i < nvars; i++ )
1180 for( i = 0; i < propdata->nbounds; i++ )
1183 && !propdata->bounds[i]->done )
1194 objcoefs[nobjcoefs] = objcoef;
1195 objcoefsinds[nobjcoefs] = i;
1204 SCIP_CALL(
filterRound(scip, propdata, nleftiterations, &nfiltered, objcoefs, objcoefsinds, nobjcoefs) );
1205 ntotalfiltered += nfiltered;
1206 SCIPdebugMsg(scip,
"filtered %d more bounds in lower bounds round\n", nfiltered);
1211 while( nfiltered >= propdata->nminfilter && ( nleftiterations == -1 || nleftiterations > 0 ) );
1218 for( i = 0; i < nobjcoefs; i++ )
1222 assert(objcoefsinds[i] >= 0 && objcoefsinds[i] < propdata->nbounds);
1223 bound = propdata->bounds[ objcoefsinds[i] ];
1224 assert(bound != NULL);
1232 for( i = 0; i < nvars; ++i )
1236 for( i = 0; i < propdata->nbounds; i++ )
1249 objcoefs[nobjcoefs] = objcoef;
1250 objcoefsinds[nobjcoefs] = i;
1259 SCIP_CALL(
filterRound(scip, propdata, nleftiterations, &nfiltered, objcoefs, objcoefsinds, nobjcoefs) );
1260 SCIPdebugMsg(scip,
"filtered %d more bounds in upper bounds round\n", nfiltered);
1261 ntotalfiltered += nfiltered;
1265 while( nfiltered >= propdata->nminfilter && ( nleftiterations == -1 || nleftiterations > 0 ) );
1267 SCIPdebugMsg(scip,
"filtered %d this round\n", ntotalfiltered);
1268 propdata->nfiltered += ntotalfiltered;
1290 assert(scip != NULL);
1292 assert(propdata != NULL);
1293 assert(result != NULL);
1298 for( i = 0; i < propdata->nbounds; i++ )
1304 bound = propdata->bounds[i];
1310 : SCIPvarGetUbLocal(bound->
var) );
1356 assert(scip != NULL);
1358 assert(bound != NULL);
1359 assert(tightened != NULL);
1434 diff = (!bound1->
done ? 1 : 0) - (!bound2->
done ? 1 : 0);
1458 assert(scip != NULL);
1459 assert(propdata != NULL);
1462 SCIPsortDownPtr((
void**) propdata->bounds, compBoundsBoundtype, propdata->nbounds);
1474 assert(scip != NULL);
1475 assert(bound != NULL);
1495 assert(scip != NULL);
1496 assert(propdata != NULL);
1501 for( k = 0; k <= propdata->lastidx; ++k )
1504 tmpbound = propdata->bounds[k];
1506 assert(tmpbound != NULL);
1513 if( propdata->orderingalgo == 0 )
1519 boundval = (propdata->orderingalgo == 2) ? -1.0 * boundval : boundval;
1521 if( bestidx == -1 || boundval < bestval )
1548 assert(nleftiterations != NULL);
1549 assert(success != NULL);
1557 for( i = 0; i <= propdata->sepamaxiter; ++i )
1583 SCIPdebugMsg(scip,
"applySeparation() - optimal=%u error=%u lpiter=%" SCIP_LONGINT_FORMAT
"\n", optimal, error, nlpiter);
1587 if( error || !optimal )
1591 if( inroot && propdata->genvboundprop != NULL && propdata->genvbdsduringsepa )
1595 propdata->ngenvboundsprobing += found ? 1 : 0;
1603 SCIPdebugMsg(scip,
"apply separation - tightened=%u oldval=%e newval=%e\n", tightened, oldval,
1606 *success |= tightened;
1610 if( !tightened && i >= propdata->sepaminiter )
1632 assert(scip != NULL);
1633 assert(propdata != NULL);
1634 assert(nleftiterations != NULL);
1638 itlimit = *nleftiterations;
1640 iterationsleft = (*nleftiterations == -1) || (*nleftiterations > 0);
1652 if( propdata->bounds[0]->done || propdata->bounds[0]->filtered )
1654 SCIPdebugMsg(scip,
"no unprocessed/unfiltered bound left\n");
1659 propdata->lastidx = 0;
1660 while( propdata->lastidx < propdata->nbounds - 1 && !propdata->bounds[propdata->lastidx]->done &&
1661 !propdata->bounds[propdata->lastidx]->filtered )
1662 ++propdata->lastidx;
1664 SCIPdebugMsg(scip,
"lastidx = %d\n", propdata->lastidx);
1668 nextboundidx =
nextBound(scip, propdata, convexphase);
1671 if( nextboundidx == -1 )
1673 SCIPdebugMsg(scip,
"no unprocessed/unfiltered bound left\n");
1677 currbound = propdata->bounds[nextboundidx];
1687 assert(currbound != NULL);
1698 SCIPdebugMsg(scip,
"before solving Boundtype: %d , LB: %e , UB: %e\n",
1700 SCIPvarGetUbLocal(currbound->
var) );
1701 SCIPdebugMsg(scip,
"before solving var <%s>, LP value: %f\n",
1712 propdata->nsolvedbounds++;
1715 SCIPdebugMsg(scip,
"OPT: %u ERROR: %u\n" , optimal, error);
1716 SCIPdebugMsg(scip,
"after solving Boundtype: %d , LB: %e , UB: %e\n",
1718 SCIPvarGetUbLocal(currbound->
var) );
1719 SCIPdebugMsg(scip,
"after solving var <%s>, LP value: %f\n",
1724 iterationsleft = (*nleftiterations == -1) || (*nleftiterations > 0);
1747 && propdata->genvboundprop != NULL )
1754 propdata->ngenvboundsprobing += 1;
1764 SCIPdebugMsg(scip,
"tightening bound %s\n", success ?
"successful" :
"not successful");
1771 SCIPdebugMsg(scip,
"tightening bound %s\n", success ?
"successful" :
"not successful");
1775 if( iterationsleft && propdata->separatesol )
1803 if( propdata->applytrivialfilter )
1806 SCIPdebugMsg(scip,
"filtered %d bounds via inspecting present LP solution\n", nfiltered);
1807 propdata->ntrivialfiltered += nfiltered;
1810 propdata->propagatecounter += success ? 1 : 0;
1813 if( propdata->propagatefreq != 0 && propdata->propagatecounter >= propdata->propagatefreq )
1819 SCIPdebugMsg(scip,
"propagation - cutoff %u ndomreds %" SCIP_LONGINT_FORMAT
"\n", cutoff, ndomredsfound);
1821 propdata->npropagatedomreds += ndomredsfound;
1822 propdata->propagatecounter = 0;
1830 nextboundidx =
nextBound(scip, propdata, convexphase);
1833 if( nextboundidx == -1 )
1835 SCIPdebugMsg(scip,
"NO unvisited/unfiltered bound left!\n");
1839 currbound = propdata->bounds[nextboundidx];
1843 if( iterationsleft )
1845 SCIPdebugMsg(scip,
"still iterations left: %" SCIP_LONGINT_FORMAT
"\n", *nleftiterations);
1881 assert(scip != NULL);
1882 assert(propdata != NULL);
1883 assert(itlimit == -1 || itlimit >= 0);
1889 lastnpropagatedomreds = propdata->npropagatedomreds;
1890 nleftiterations = itlimit;
1892 propdata->lastidx = -1;
1897 if( propdata->propagatefreq > 0 )
1904 for( i = 0; i < propdata->nbounds; i++ )
1906 BOUND* bound = propdata->bounds[i];
1910 if( oldlbs != NULL && oldubs != NULL )
1936 if( propdata->applytrivialfilter && !continuenode )
1939 SCIPdebugMsg(scip,
"filtered %d bounds via inspecting present LP solution\n", nfiltered);
1940 propdata->ntrivialfiltered += nfiltered;
1951 if( propdata->dualfeastol < olddualfeastol )
1958 if( !hasconditionlimit )
1960 SCIPwarningMessage(scip,
"obbt propagator could not set condition limit in LP solver - running without\n");
1962 else if( propdata->conditionlimit > 0.0 && (oldconditionlimit < 0.0 || propdata->conditionlimit < oldconditionlimit) )
1969 if( !
SCIPisEQ(scip, oldboundstreps, propdata->boundstreps) )
1982 if( propdata->applyfilterrounds )
1990 for( i = 0; i < nvars; ++i )
2004 if( nleftiterations > 0 || itlimit < 0 )
2011 if( hasconditionlimit )
2017 if( oldlbs != NULL && oldubs != NULL && propdata->npropagatedomreds - lastnpropagatedomreds > 0 )
2019 assert(propdata->propagatefreq > 0);
2020 for( i = 0; i < propdata->nbounds; ++i )
2022 BOUND* bound = propdata->bounds[i];
2039 oldlb = oldlbs[bound->
index];
2040 oldub = oldubs[bound->
index];
2070 if( propdata->cutoffrow != NULL )
2132 assert(xcoef != NULL);
2133 assert(ycoef != NULL);
2134 assert(constant != NULL);
2149 SCIPdebugMsg(scip,
" -> skip: bounds are too close/large\n");
2157 signx = (xs > xt) ? 1.0 : -1.0;
2164 side = scale * (xs/(xt-xs) - ys/(yt-ys));
2177 SCIPwarningMessage(scip,
"Error while solving LP in quadratic constraint handler; LP solve terminated with" \
2178 "code <%d>\n", retstat);
2194 SCIPdebugMsg(scip,
" primal=(%g,%g) dual=%g\n", xval, yval, mu);
2197 *xcoef = -signx - (mu * scale) / (xt - xs);
2198 *ycoef = (mu * scale) / (yt - ys);
2199 *constant = (*xcoef) * xval + (*ycoef) * yval;
2256 assert(scip != NULL);
2257 assert(propdata != NULL);
2258 assert(itlimit == -1 || itlimit >= 0);
2259 assert(result != NULL);
2261 if( propdata->nbilinbounds <= 0 ||
SCIPgetDepth(scip) != 0 || propdata->lastbilinidx >= propdata->nbilinbounds )
2264 SCIPdebugMsg(scip,
"call applyObbtBilinear starting from %d\n", propdata->lastbilinidx);
2271 SCIPdebugMsg(scip,
"iteration limit: %lld\n", nleftiterations);
2280 for( i = 0; i < nvars; ++i )
2292 for( i = propdata->lastbilinidx; i < propdata->nbilinbounds
2293 && (nleftiterations > 0 || nleftiterations == -1)
2294 && (propdata->itlimitbilin < 0 || propdata->itlimitbilin > propdata->itusedbilin )
2301 bilinbound = propdata->bilinbounds[i];
2302 assert(bilinbound != NULL);
2304 SCIPdebugMsg(scip,
"process %d: %s %s done=%u filtered=%d nunderest=%d noverest=%d\n", i,
2319 for( k = 0; k < 4; ++k )
2321 CORNER corner = corners[k];
2331 if( ((corner ==
LEFTTOP || corner == RIGHTBOTTOM) && bilinbound->
nunderest == 0)
2336 if( (bilinbound->
filtered & corner) != 0 )
2340 getCorners(bilinbound->
x, bilinbound->
y, corner, &xs, &ys, &xt, &yt);
2348 SCIP_CALL(
solveBilinearLP(scip, bilinbound->
x, bilinbound->
y, xs, ys, xt, yt, &xcoef, &ycoef, &constant, -1L) );
2353 SCIPdebugMsg(scip,
"LP iterations left: %lld\n", nleftiterations);
2358 &&
SCIPisFeasGT(scip, (xcoef*xt - ycoef*yt - constant) / SQRT(SQR(xcoef) + SQR(ycoef) + SQR(constant)), 1e-2) )
2363 ycoef, constant, &success) );
2369 SCIPdebugMsg(scip,
" found %g x <= %g y + %g with violation %g\n", xcoef, ycoef, constant,
2370 (xcoef*xt - ycoef*yt - constant) / SQRT(SQR(xcoef) + SQR(ycoef) + SQR(constant)));
2380 propdata->lastbilinidx = i;
2387 if( propdata->cutoffrow != NULL )
2410 assert(scip != NULL);
2411 assert(bound != NULL);
2412 assert(nlcount >= 0);
2413 assert(maxnlcount >= nlcount);
2457 assert(scip != NULL);
2458 assert(randnumgen != NULL);
2459 assert(bilinbound != NULL);
2465 if( ubx - lbx < 0.5 )
2467 if( uby - lby < 0.5 )
2478 score += interiorityx + interiorityy;
2501 assert(scip != NULL);
2502 assert(nlcounts != NULL);
2503 assert(nlrow != NULL);
2519 assert(bilinvar1 != NULL);
2520 assert(bilinvar2 != NULL);
2530 if( bilinvar1 != bilinvar2 )
2538 if( exprtree != NULL )
2544 for( t = 0; t < nexprtreevars; ++t)
2547 var = exprtreevars[t];
2548 assert(var != NULL);
2571 assert(scip != NULL);
2572 assert(nlcounts != NULL);
2579 if( conshdlr != NULL )
2586 SCIPdebugMsg(scip,
"nconss(quadratic) = %d\n", nconss);
2588 for( i = 0; i < nconss; ++i )
2600 assert(nlrow != NULL);
2609 if( conshdlr != NULL )
2614 SCIPdebugMsg(scip,
"nconss(nonlinear) = %d\n", nconss);
2616 for( i = 0; i < nconss; ++i )
2631 assert(nlrow != NULL);
2640 if( conshdlr != NULL )
2645 SCIPdebugMsg(scip,
"nconss(bivariate) = %d\n", nconss);
2647 for( i = 0; i < nconss; ++i )
2655 if( exprtree != NULL )
2693 if( conshdlr != NULL )
2700 for( i = 0; i < nconss; ++i )
2705 assert(nlrow != NULL);
2747 assert(scip != NULL);
2748 assert(propdata != NULL);
2766 for( i = 0; i < nvars; i++ )
2768 if( maxnlcount < nlcount[i] )
2769 maxnlcount = nlcount[i];
2773 propdata->boundssize = 2 * nvars;
2778 for( i = 0; i < nvars; i++ )
2780 if(
varIsInteresting(scip, vars[i], (propdata->onlynonconvexvars ? nccount[i] : nlcount[i])) )
2785 bdaddress = &(propdata->bounds[bdidx]);
2788 propdata->bounds[bdidx]->var = vars[i];
2789 propdata->bounds[bdidx]->found =
FALSE;
2790 propdata->bounds[bdidx]->filtered =
FALSE;
2791 propdata->bounds[bdidx]->newval = 0.0;
2792 propdata->bounds[bdidx]->score =
getScore(scip, propdata->bounds[bdidx], nlcount[i], maxnlcount);
2793 propdata->bounds[bdidx]->done =
FALSE;
2794 propdata->bounds[bdidx]->nonconvex = (nccount[i] > 0);
2795 propdata->bounds[bdidx]->index = bdidx;
2799 bdaddress = &(propdata->bounds[bdidx]);
2802 propdata->bounds[bdidx]->var = vars[i];
2803 propdata->bounds[bdidx]->found =
FALSE;
2804 propdata->bounds[bdidx]->filtered =
FALSE;
2805 propdata->bounds[bdidx]->newval = 0.0;
2806 propdata->bounds[bdidx]->score =
getScore(scip, propdata->bounds[bdidx], nlcount[i], maxnlcount);
2807 propdata->bounds[bdidx]->done =
FALSE;
2808 propdata->bounds[bdidx]->nonconvex = (nccount[i] > 0);
2809 propdata->bounds[bdidx]->index = bdidx;
2815 propdata->nbounds = bdidx;
2845 propdata->nbilinbounds = 0;
2846 for( i = 0; i < nbilins; ++i )
2847 if( nunderest[i] + noverest[i] > 0 && propdata->minnonconvexity <= maxnonconvexity[i]
2849 ++(propdata->nbilinbounds);
2851 if( propdata->nbilinbounds == 0 )
2857 for( i = 0; i < nbilins; ++i )
2859 if( nunderest[i] + noverest[i] > 0 && propdata->minnonconvexity <= maxnonconvexity[i]
2865 propdata->bilinbounds[bilinidx]->x = x[i];
2866 propdata->bilinbounds[bilinidx]->y = y[i];
2867 propdata->bilinbounds[bilinidx]->nunderest = nunderest[i];
2868 propdata->bilinbounds[bilinidx]->noverest = noverest[i];
2869 propdata->bilinbounds[bilinidx]->
index = i;
2873 nbilinterms += nunderest[i] + noverest[i];
2876 assert(propdata->nbilinbounds == bilinidx);
2879 for( i = 0; i < propdata->nbilinbounds; ++i )
2881 propdata->bilinbounds[i]->score =
getScoreBilinBound(scip, propdata->randnumgen, propdata->bilinbounds[i],
2883 SCIPdebugMsg(scip,
"score of %i = %g\n", i, propdata->bilinbounds[i]->score);
2887 if( propdata->nbilinbounds > 1 )
2889 SCIPsortDownPtr((
void**) propdata->bilinbounds, compBilinboundsScore, propdata->nbilinbounds);
2902 assert(nlcount != NULL);
2903 assert(nccount != NULL);
2908 if( propdata->nbounds <= 0 )
2910 assert(propdata->nbounds == 0);
2911 assert(propdata->boundssize >= 0 );
2915 SCIPdebugMsg(scip,
"problem has %d/%d interesting bounds\n", propdata->nbounds, 2 * nvars);
2917 if( propdata->nbounds > 0 )
2923 SCIPsortDownPtr((
void**) propdata->bounds, compBoundsScore, propdata->nbounds);
2941 assert(scip != NULL);
2942 assert(prop != NULL);
2957 assert(scip != NULL);
2958 assert(prop != NULL);
2963 assert(propdata != NULL);
2965 propdata->bounds = NULL;
2966 propdata->nbounds = -1;
2967 propdata->boundssize = 0;
2968 propdata->cutoffrow = NULL;
2969 propdata->lastnode = -1;
2974 SCIPdebugMsg(scip,
"creating genvbounds: %s\n", propdata->genvboundprop != NULL ?
"true" :
"false");
2989 assert(scip != NULL);
2990 assert(prop != NULL);
3006 SCIPdebugMsg(scip,
"NLP not constructed, skipping obbt\n");
3015 SCIPdebugMsg(scip,
"not all columns in LP, skipping obbt\n");
3024 assert(propdata != NULL);
3027 if( propdata->nbounds == -1 )
3040 assert(propdata->nbounds >= 0);
3044 if( propdata->nbounds <= 0 )
3046 SCIPdebugMsg(scip,
"there are no interesting bounds\n");
3063 SCIPdebugMsg(scip,
"aborting since no optimal LP solution is at hand\n");
3068 if( propdata->itlimitfactor > 0.0 )
3070 propdata->minitlimit);
3079 if( propdata->createbilinineqs )
3082 if( propdata->itlimitbilin == 0L )
3085 propdata->itlimitbilin = (itlimit < 0 || propdata->itlimitfactorbilin < 0)
3086 ? -1L : (
SCIP_Longint)(itlimit * propdata->itlimitfactorbilin);
3114 assert(scip != NULL);
3115 assert(prop != NULL);
3120 assert(propdata != NULL);
3124 propdata->randnumgen = NULL;
3129 SCIPstatisticMessage(
"DIVE-LP: %" SCIP_LONGINT_FORMAT
" NFILTERED: %d NTRIVIALFILTERED: %d NSOLVED: %d " 3130 "FILTER-LP: %" SCIP_LONGINT_FORMAT
" NGENVB(dive): %d NGENVB(aggr.): %d NGENVB(triv.) %d\n",
3131 propdata->nprobingiterations, propdata->nfiltered, propdata->ntrivialfiltered, propdata->nsolvedbounds,
3132 propdata->nfilterlpiters, propdata->ngenvboundsprobing, propdata->ngenvboundsaggrfil, propdata->ngenvboundstrivfil);
3135 if( propdata->nbilinbounds > 0 )
3137 for( i = propdata->nbilinbounds - 1; i >= 0; --i )
3142 propdata->nbilinbounds = 0;
3146 if( propdata->nbounds > 0 )
3149 for( i = propdata->nbounds - 1; i >= 0; i-- )
3156 propdata->nbounds = -1;
3157 propdata->itlimitbilin = 0;
3158 propdata->itusedbilin = 0;
3173 assert(propdata != NULL);
3200 propdata->nprobingiterations = 0;
3201 propdata->nfiltered = 0;
3202 propdata->ntrivialfiltered = 0;
3203 propdata->nsolvedbounds = 0;
3204 propdata->ngenvboundsprobing = 0;
3205 propdata->ngenvboundsaggrfil = 0;
3206 propdata->ngenvboundstrivfil = 0;
3207 propdata->nfilterlpiters = 0;
3208 propdata->lastidx = -1;
3209 propdata->propagatecounter = 0;
3210 propdata->npropagatedomreds = 0;
3214 propExecObbt, propdata) );
3223 "should obbt try to provide genvbounds if possible?",
3227 "should coefficients in filtering be normalized w.r.t. the domains sizes?",
3231 "try to filter bounds in so-called filter rounds by solving auxiliary LPs?",
3235 "try to filter bounds with the LP solution after each solve?",
3239 "should we try to generate genvbounds during trivial and aggressive filtering?",
3243 "try to create genvbounds during separation process?",
3247 "minimal number of filtered bounds to apply another filter round",
3251 "multiple of root node LP iterations used as total LP iteration limit for obbt (<= 0: no limit )",
3255 "multiple of OBBT LP limit used as total LP iteration limit for solving bilinear inequality LPs (< 0 for no limit)",
3259 "minimum absolute value of nonconvex eigenvalues for a bilinear term",
3263 "minimum LP iteration limit",
3267 "feasibility tolerance for reduced costs used in obbt; this value is used if SCIP's dual feastol is greater",
3271 "maximum condition limit used in LP solver (-1.0: no limit)",
3275 "minimal relative improve for strengthening bounds",
3279 "only apply obbt on non-convex variables",
3283 "should integral bounds be tightened during the probing mode?",
3287 "should continuous bounds be tightened during the probing mode?",
3291 "solve auxiliary LPs in order to find valid inequalities for bilinear terms?",
3295 "select the type of ordering algorithm which should be used (0: no special ordering, 1: greedy, 2: greedy reverse)",
3299 "should the obbt LP solution be separated?",
3303 "minimum number of iteration spend to separate an obbt LP solution",
3307 "maximum number of iteration spend to separate an obbt LP solution",
3311 "trigger a propagation round after that many bound tightenings (0: no propagation)",
enum SCIP_Result SCIP_RESULT
static SCIP_RETCODE countNLRowVarsNonConvexity(SCIP *scip, int *nlcounts, SCIP_NLROW *nlrow)
void SCIPfreeRandom(SCIP *scip, SCIP_RANDNUMGEN **randnumgen)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
#define DEFAULT_APPLY_FILTERROUNDS
#define DEFAULT_GENVBDSDURINGFILTER
enum SCIP_BoundType SCIP_BOUNDTYPE
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPinRepropagation(SCIP *scip)
SCIP_Longint SCIPgetNRootLPIterations(SCIP *scip)
SCIP_Real SCIPfeastol(SCIP *scip)
#define SCIPallocBlockMemoryArray(scip, ptr, num)
SCIP_Bool SCIPisNLPConstructed(SCIP *scip)
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_RETCODE SCIPcacheRowExtensions(SCIP *scip, SCIP_ROW *row)
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
static SCIP_DECL_SORTPTRCOMP(compBoundsScore)
SCIP_STAGE SCIPgetStage(SCIP *scip)
static SCIP_RETCODE filterExistingLP(SCIP *scip, SCIP_PROPDATA *propdata, int *nfiltered, BOUND *currbound)
SCIP_RETCODE SCIPbacktrackProbing(SCIP *scip, int probingdepth)
#define DEFAULT_MINITLIMIT
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
static SCIP_RETCODE sortBounds(SCIP *scip, SCIP_PROPDATA *propdata)
SCIP_RETCODE SCIPcreateEmptyRowUnspec(SCIP *scip, SCIP_ROW **row, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
static void exchangeBounds(SCIP_PROPDATA *propdata, int i)
int SCIPgetNAllBilinearTermsQuadratic(SCIP *scip)
SCIP_Real SCIPgetRhsBivariate(SCIP *scip, SCIP_CONS *cons)
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
SCIP_Real SCIPgetCutoffbound(SCIP *scip)
SCIP_RETCODE SCIPflushRowExtensions(SCIP *scip, SCIP_ROW *row)
SCIP_Bool SCIPisUbBetter(SCIP *scip, SCIP_Real newub, SCIP_Real oldlb, SCIP_Real oldub)
enum SCIP_BaseStat SCIP_BASESTAT
SCIP_RETCODE SCIPapplyCutsProbing(SCIP *scip, SCIP_Bool *cutoff)
#define DEFAULT_BOUNDSTREPS
SCIP_PROP * SCIPfindProp(SCIP *scip, const char *name)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
#define infty2infty(infty1, infty2, val)
SCIP_RETCODE SCIPgetRealParam(SCIP *scip, const char *name, SCIP_Real *value)
#define DEFAULT_SEPAMAXITER
SCIP_BASESTAT SCIPcolGetBasisStatus(SCIP_COL *col)
static SCIP_RETCODE solveBilinearLP(SCIP *scip, SCIP_VAR *x, SCIP_VAR *y, SCIP_Real xs, SCIP_Real ys, SCIP_Real xt, SCIP_Real yt, SCIP_Real *xcoef, SCIP_Real *ycoef, SCIP_Real *constant, SCIP_Longint iterlim)
SCIP_RETCODE SCIPcreateRandom(SCIP *scip, SCIP_RANDNUMGEN **randnumgen, unsigned int initialseed)
#define DEFAULT_MINNONCONVEXITY
static SCIP_DECL_PROPEXITSOL(propExitsolObbt)
SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)
#define DEFAULT_ITLIMITFACTOR
SCIP_Real SCIPgetVarRedcost(SCIP *scip, SCIP_VAR *var)
SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
static SCIP_RETCODE filterRound(SCIP *scip, SCIP_PROPDATA *propdata, int itlimit, int *nfiltered, SCIP_Real *objcoefs, int *objcoefsinds, int nobjcoefs)
SCIP_RETCODE SCIPincludePropObbt(SCIP *scip)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_Real SCIPdualfeastol(SCIP *scip)
SCIP_Bool SCIPisFeasGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPgetVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
static int nextBound(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_Bool convexphase)
SCIP_CONS ** SCIPconshdlrGetConss(SCIP_CONSHDLR *conshdlr)
#define DEFAULT_SEPAMINITER
SCIP_RETCODE SCIPaddLongintParam(SCIP *scip, const char *name, const char *desc, SCIP_Longint *valueptr, SCIP_Bool isadvanced, SCIP_Longint defaultvalue, SCIP_Longint minvalue, SCIP_Longint maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
int SCIPgetSubscipDepth(SCIP *scip)
SCIP_Real SCIPinfinity(SCIP *scip)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
#define DEFAULT_APPLY_TRIVIALFITLERING
SCIP_RETCODE SCIPgetNlRowNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_NLROW **nlrow)
enum SCIP_Retcode SCIP_RETCODE
#define SCIPstatisticMessage
static SCIP_Real getFilterCoef(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype)
int SCIPvarGetProbindex(SCIP_VAR *var)
SCIP_Real SCIPnlrowGetRhs(SCIP_NLROW *nlrow)
SCIP_RETCODE SCIPgetCurvatureNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_Bool checkcurv, SCIP_EXPRCURV *curvature)
void SCIPintervalSetBounds(SCIP_INTERVAL *resultant, SCIP_Real inf, SCIP_Real sup)
SCIP_Real SCIPgetRhsNonlinear(SCIP *scip, SCIP_CONS *cons)
#define DEFAULT_CREATE_BILININEQS
SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
#define SCIPfreeBlockMemory(scip, ptr)
#define DEFAULT_ITLIMITFAC_BILININEQS
SCIP_RETCODE SCIPchgVarLbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPgetNLPVarsNonlinearity(SCIP *scip, int *nlcount)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
#define GENVBOUND_PROP_NAME
#define SCIPfreeBufferArray(scip, ptr)
enum SCIP_LPSolStat SCIP_LPSOLSTAT
static void getCorner(SCIP_VAR *x, SCIP_VAR *y, CORNER corner, SCIP_Real *px, SCIP_Real *py)
#define SCIPallocBlockMemory(scip, ptr)
SCIP_RETCODE SCIPsetRealParam(SCIP *scip, const char *name, SCIP_Real value)
SCIP_Real SCIProwGetDualsol(SCIP_ROW *row)
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
SCIP_RETCODE SCIPaddIntParam(SCIP *scip, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_Real SCIPgetLhsQuadratic(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR ** SCIPexprtreeGetVars(SCIP_EXPRTREE *tree)
SCIP_Real SCIPepsilon(SCIP *scip)
static SCIP_RETCODE tightenBoundProbing(SCIP *scip, BOUND *bound, SCIP_Real newval, SCIP_Bool *tightened)
int SCIPnlrowGetNQuadElems(SCIP_NLROW *nlrow)
#define DEFAULT_ORDERINGALGO
static unsigned int getScore(SCIP *scip, BOUND *bound, int nlcount, int maxnlcount)
const char * SCIPgetProbName(SCIP *scip)
SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)
SCIP_EXPRTREE * SCIPgetExprtreeBivariate(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPaddBilinearIneqQuadratic(SCIP *scip, SCIP_VAR *x, SCIP_VAR *y, int idx, SCIP_Real xcoef, SCIP_Real ycoef, SCIP_Real constant, SCIP_Bool *success)
SCIP_RETCODE SCIPexprtreeCheckCurvature(SCIP_EXPRTREE *tree, SCIP_Real infinity, SCIP_INTERVAL *varbounds, SCIP_EXPRCURV *curv, SCIP_INTERVAL *bounds)
SCIP_Bool SCIPisLbBetter(SCIP *scip, SCIP_Real newlb, SCIP_Real oldlb, SCIP_Real oldub)
SCIP_Longint SCIPnodeGetNumber(SCIP_NODE *node)
static SCIP_RETCODE createGenVBound(SCIP *scip, SCIP_PROPDATA *propdata, BOUND *bound, SCIP_Bool *found)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
#define DEFAULT_DUALFEASTOL
SCIP_Bool SCIPisConcaveQuadratic(SCIP *scip, SCIP_CONS *cons)
#define DEFAULT_FILTERING_NORM
int SCIPgetNNLPVars(SCIP *scip)
static SCIP_RETCODE applyBoundChgs(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_RESULT *result)
SCIP_VAR ** SCIPnlrowGetQuadVars(SCIP_NLROW *nlrow)
static SCIP_Bool includeVarGenVBound(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPgetAllBilinearTermsQuadratic(SCIP *scip, SCIP_VAR **RESTRICT x, SCIP_VAR **RESTRICT y, int *RESTRICT nbilinterms, int *RESTRICT nunderests, int *RESTRICT noverests, SCIP_Real *maxnonconvexity)
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPpropagateProbing(SCIP *scip, int maxproprounds, SCIP_Bool *cutoff, SCIP_Longint *ndomredsfound)
static SCIP_DECL_PROPRESPROP(propRespropObbt)
void SCIPsortDownPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
SCIP_RETCODE SCIPgenVBoundAdd(SCIP *scip, SCIP_PROP *genvboundprop, SCIP_VAR **vars, SCIP_VAR *var, SCIP_Real *coefs, int ncoefs, SCIP_Real coefcutoffbound, SCIP_Real constant, SCIP_BOUNDTYPE boundtype)
#define SCIPfreeBufferArrayNull(scip, ptr)
SCIP_RETCODE SCIPendProbing(SCIP *scip)
const char * SCIPvarGetName(SCIP_VAR *var)
constraint handler for quadratic constraints
#define DEFAULT_GENVBDSDURINGSEPA
SCIP_RETCODE SCIPseparateSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool pretendroot, SCIP_Bool allowlocal, SCIP_Bool onlydelayed, SCIP_Bool *delayed, SCIP_Bool *cutoff)
SCIP_RETCODE SCIPchgDualfeastol(SCIP *scip, SCIP_Real dualfeastol)
SCIP_RETCODE SCIPgetIntParam(SCIP *scip, const char *name, int *value)
SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)
int SCIPexprtreeGetNVars(SCIP_EXPRTREE *tree)
SCIP_RETCODE SCIPgetNlRowQuadratic(SCIP *scip, SCIP_CONS *cons, SCIP_NLROW **nlrow)
static SCIP_Bool varIsInteresting(SCIP *scip, SCIP_VAR *var, int nlcount)
SCIP_QUADELEM * SCIPnlrowGetQuadElems(SCIP_NLROW *nlrow)
SCIP_Real SCIPgetVarObjProbing(SCIP *scip, SCIP_VAR *var)
#define DEFAULT_PROPAGATEFREQ
SCIP_Bool SCIPisFeasGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPsolveProbingLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
static SCIP_RETCODE getNLPVarsNonConvexity(SCIP *scip, int *nlcounts)
SCIP_Bool SCIPisFeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
static int getIterationsLeft(SCIP *scip, SCIP_Longint nolditerations, SCIP_Longint itlimit)
SCIP_Bool SCIPisHugeValue(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPgetRhsQuadratic(SCIP *scip, SCIP_CONS *cons)
#define SCIPallocBufferArray(scip, ptr, num)
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
SCIP_Real SCIPgetLhsBivariate(SCIP *scip, SCIP_CONS *cons)
SCIP_Real SCIPgetLhsNonlinear(SCIP *scip, SCIP_CONS *cons)
int SCIPgetDepth(SCIP *scip)
constraint handler for nonlinear constraints
optimization-based bound tightening propagator
SCIP_RETCODE SCIPgetNlRowAbspower(SCIP *scip, SCIP_CONS *cons, SCIP_NLROW **nlrow)
SCIP_RETCODE SCIPsetIntParam(SCIP *scip, const char *name, int value)
#define DEFAULT_CREATE_GENVBOUNDS
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_RETCODE SCIPsetPropCopy(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPCOPY((*propcopy)))
static SCIP_DECL_PROPFREE(propFreeObbt)
SCIPInterval log(const SCIPInterval &x)
SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)
constraint handler for bivariate nonlinear constraints
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
static SCIP_RETCODE applySeparation(SCIP *scip, SCIP_PROPDATA *propdata, BOUND *currbound, SCIP_Longint *nleftiterations, SCIP_Bool *success)
#define BMSclearMemory(ptr)
Constraint handler for absolute power constraints .
static SCIP_RETCODE setObjProbing(SCIP *scip, SCIP_PROPDATA *propdata, BOUND *bound, SCIP_Real coef)
SCIP_RETCODE SCIPsetPropExitsol(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPEXITSOL((*propexitsol)))
int SCIPconshdlrGetNActiveConss(SCIP_CONSHDLR *conshdlr)
static SCIP_DECL_PROPCOPY(propCopyObbt)
SCIP_Real SCIPrandomGetReal(SCIP_RANDNUMGEN *randnumgen, SCIP_Real minrandval, SCIP_Real maxrandval)
SCIP_Bool SCIPinProbing(SCIP *scip)
const char * SCIPpropGetName(SCIP_PROP *prop)
int SCIPgetNVars(SCIP *scip)
SCIP_EXPRTREE * SCIPnlrowGetExprtree(SCIP_NLROW *nlrow)
static SCIP_RETCODE solveLP(SCIP *scip, int itlimit, SCIP_Bool *error, SCIP_Bool *optimal)
enum SCIP_ExprCurv SCIP_EXPRCURV
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
SCIP_RETCODE SCIPsetPropResprop(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPRESPROP((*propresprop)))
SCIP_Real SCIPgetLPObjval(SCIP *scip)
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
#define DEFAULT_SEPARATESOL
int SCIPgetNCuts(SCIP *scip)
SCIP_RETCODE SCIPaddRowProbing(SCIP *scip, SCIP_ROW *row)
static SCIP_RETCODE findNewBounds(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_Longint *nleftiterations, SCIP_Bool convexphase)
#define DEFAULT_ONLYNONCONVEXVARS
SCIP_VAR ** SCIPgetVars(SCIP *scip)
SCIP_RETCODE SCIPsetPropInitsol(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPINITSOL((*propinitsol)))
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
struct SCIP_PropData SCIP_PROPDATA
SCIP_Bool SCIPisStopped(SCIP *scip)
static SCIP_Real evalBound(SCIP *scip, BOUND *bound)
SCIP_RETCODE SCIPsetPropFree(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPFREE((*propfree)))
SCIP_PROPDATA * SCIPpropGetData(SCIP_PROP *prop)
void SCIPpropSetData(SCIP_PROP *prop, SCIP_PROPDATA *propdata)
static SCIP_RETCODE filterBounds(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_Longint itlimit)
SCIP_Bool SCIPallColsInLP(SCIP *scip)
SCIP_Real SCIPchgRelaxfeastol(SCIP *scip, SCIP_Real relaxfeastol)
#define DEFAULT_TIGHTCONTBOUNDSPROBING
static SCIP_RETCODE addObjCutoff(SCIP *scip, SCIP_PROPDATA *propdata)
static SCIP_Bool varIsFixedLocal(SCIP *scip, SCIP_VAR *var)
static SCIP_DECL_PROPINITSOL(propInitsolObbt)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
#define DEFAULT_CONDITIONLIMIT
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_RETCODE SCIPnewProbingNode(SCIP *scip)
#define DEFAULT_TIGHTINTBOUNDSPROBING
SCIP_RETCODE SCIPstartProbing(SCIP *scip)
#define BMSclearMemoryArray(ptr, num)
static SCIP_RETCODE initBounds(SCIP *scip, SCIP_PROPDATA *propdata)
SCIP_Real SCIPceil(SCIP *scip, SCIP_Real val)
static SCIP_Real getScoreBilinBound(SCIP *scip, SCIP_RANDNUMGEN *randnumgen, BILINBOUND *bilinbound, int nbilinterms)
static SCIP_DECL_PROPEXEC(propExecObbt)
SCIP_Real SCIPnlrowGetLhs(SCIP_NLROW *nlrow)
static SCIP_RETCODE applyObbt(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_Longint itlimit, SCIP_RESULT *result)
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
SCIP_RETCODE SCIPchgVarUbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
#define DEFAULT_FILTERING_MIN
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_Real SCIPfloor(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisConvexQuadratic(SCIP *scip, SCIP_CONS *cons)
static SCIP_RETCODE applyObbtBilinear(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_Longint itlimit, SCIP_RESULT *result)
SCIP_Bool SCIPallowObjProp(SCIP *scip)
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)
static void getCorners(SCIP_VAR *x, SCIP_VAR *y, CORNER corner, SCIP_Real *xs, SCIP_Real *ys, SCIP_Real *xt, SCIP_Real *yt)
generalized variable bounds propagator
SCIP_RETCODE SCIPincludePropBasic(SCIP *scip, SCIP_PROP **propptr, const char *name, const char *desc, int priority, int freq, SCIP_Bool delay, SCIP_PROPTIMING timingmask, SCIP_DECL_PROPEXEC((*propexec)), SCIP_PROPDATA *propdata)
SCIP_RETCODE SCIPchgVarObjProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)