68#define PROP_NAME "pseudoobj"
69#define PROP_DESC "pseudo objective function propagator"
70#define PROP_TIMING SCIP_PROPTIMING_BEFORELP | SCIP_PROPTIMING_DURINGLPLOOP | SCIP_PROPTIMING_AFTERLPLOOP
71#define PROP_PRIORITY 3000000
73#define PROP_DELAY FALSE
74#define PROP_PRESOL_PRIORITY +6000000
75#define PROP_PRESOL_MAXROUNDS -1
77#define PROP_PRESOLTIMING SCIP_PRESOLTIMING_FAST
79#define EVENTHDLR_NAME "pseudoobj"
80#define EVENTHDLR_DESC "bound change event handler for pseudo objective function propagator"
82#define DEFAULT_MINUSELESS 100
84#define DEFAULT_MAXVARSFRAC 0.1
86#define DEFAULT_PROPFULLINROOT TRUE
87#define DEFAULT_PROPCUTOFFBOUND TRUE
88#define DEFAULT_FORCE FALSE
92#define DEFAULT_MAXNEWVARS 1000
93#define DEFAULT_PROPUSEIMPLICS TRUE
94#define DEFAULT_RESPROPUSEIMPLICS TRUE
95#define DEFAULT_MAXIMPLVARS 50000
122 SCIP_Real* maxactchgs;
127 SCIP_Real lastlowerbound;
128 SCIP_Real cutoffbound;
129 SCIP_Real glbpseudoobjval;
130 SCIP_Real maxvarsfrac;
133 SCIP_Real maxpseudoobjact;
134 int maxpseudoobjactinf;
142 int glbfirstnonfixed;
143 int maxactfirstnonfixed;
151 SCIP_Bool glbpropagated;
152 SCIP_Bool propfullinroot;
153 SCIP_Bool propcutoffbound;
155 SCIP_Bool catchvaradded;
156 SCIP_Bool propuseimplics;
157 SCIP_Bool respropuseimplics;
158 SCIP_Bool initialized;
192 for( v = 0; v <
nvars; ++v )
222 for( v = 0; v < propdata->glbfirstnonfixed; ++v )
224 var = propdata->minactvars[v];
230 for( v = 0; v < propdata->maxactfirstnonfixed; ++v )
232 var = propdata->maxactvars[v];
302 if( locks1 < locks2 )
304 if( locks1 > locks2 )
318 if( locks1 < locks2 )
320 if( locks1 > locks2 )
363 SCIP_Bool* collectedlbvars,
364 SCIP_Bool* collectedubvars,
365 SCIP_Real maxlbobjchg,
366 SCIP_Real maxubobjchg,
380 if( nlbimpls + nubimpls == 0 )
384 (*objimplics)->objvars =
NULL;
385 (*objimplics)->maxobjchg = 0.0;
386 (*objimplics)->nlbimpls = 0;
387 (*objimplics)->nubimpls = 0;
388 (*objimplics)->size = 0;
403 (*objimplics)->size = nlbimpls + nubimpls;
407 for( v = 0; v < nlbimpls; ++v )
416 assert(collectedlbvars[pos]);
418 if( collectedubvars[pos] )
420 SCIP_Bool infeasible;
442 (*objimplics)->objvars[
nvars] =
var;
445 collectedlbvars[pos] =
FALSE;
447 (*objimplics)->nlbimpls =
nvars;
449 for( v = 0; v < nubimpls; ++v )
451 var = objvars[nlbimpls + v];
458 assert(collectedubvars[pos]);
469 (*objimplics)->objvars[
nvars] =
var;
472 collectedubvars[pos] =
FALSE;
474 (*objimplics)->nubimpls =
nvars - (*objimplics)->nlbimpls;
477 for( v = 0; v <
nvars; ++v )
485 (*objimplics)->maxobjchg =
MAX(maxlbobjchg, maxubobjchg);
504 for( v = 0; v < (*objimplics)->nlbimpls + (*objimplics)->nubimpls; ++v )
535 if( pos < objimplics->nlbimpls )
645 eventhdlr = propdata->eventhdlr;
649 for( k = 0; k < propdata->nminactvars; ++k )
651 var = propdata->minactvars[k];
665 for( k = 0; k < propdata->nmaxactvars; ++k )
667 var = propdata->maxactvars[k];
679 for( k = 0; k < propdata->nobjintvars; ++k )
681 var = propdata->objintvars[k];
700 propdata->minactvars =
NULL;
701 propdata->minactimpls =
NULL;
702 propdata->maxactvars =
NULL;
703 propdata->maxactchgs =
NULL;
704 propdata->objintvars =
NULL;
705 propdata->nminactvars = 0;
706 propdata->nmaxactvars = 0;
707 propdata->nobjintvars = 0;
709 propdata->maxpseudoobjactinf = 0;
710 propdata->lastvarnum = -1;
711 propdata->glbpropagated =
FALSE;
715 propdata->glbfirstnonfixed = 0;
716 propdata->maxactfirstnonfixed = 0;
717 propdata->firstnonfixed = 0;
718 propdata->nnewvars = 0;
719 propdata->minactsize = 0;
720 propdata->maxactsize = 0;
721 propdata->objintvarssize = 0;
722 propdata->catchvaradded =
FALSE;
723 propdata->initialized =
FALSE;
735 if( !propdata->initialized )
738 if( propdata->addedvars !=
NULL )
744 for( v = 0; v < propdata->nminactvars; ++v )
787 SCIP_Bool* collectedvars,
818 if( collectedvars[pos] )
822 assert(*ncontributors < nbinobjvars);
823 contributors[*ncontributors] =
var;
827 collectedvars[pos] =
TRUE;
833#define MAX_CLIQUELENGTH 50
855 SCIP_Bool* collectedvars,
881 assert(*ncontributors == 0);
890 if( uselesscliques ==
NULL )
895 for(
c = 0;
c < nbinobjvars; ++
c )
900 for(
c = 0;
c < ncliques; ++
c )
1015 implvar = objimplics->
objvars[v];
1067 SCIP_Bool* collectedvars,
1082 (*ncontributors) = 0;
1138 SCIP_Bool varfixing;
1163 SCIP_Bool* clqvalues;
1191 for(
c = ncliques - 1;
c >= 0; --
c )
1193 clique = cliques[
c];
1205 for( v = nclqvars - 1; v >= 0; --v )
1207 clqvar = clqvars[v];
1211 assert(-1 <= objmult && objmult <= 1);
1218 assert(0 < probindex && probindex < nentries);
1221 assert(entries[probindex] == 0 || entries[probindex] == objmult);
1222 if( entries[probindex] == 0 )
1225 ids[nids] = probindex;
1231 entries[probindex] = objmult;
1241 for( v = nids - 1; v >= 0; --v )
1244 assert(0 <
id &&
id < nentries);
1245 assert(entries[
id] != 0);
1247 clqvar = probvars[
id - 1];
1257 *objchg += entries[id] *
obj;
1265#ifdef SCIP_MORE_DEBUG
1267 varfixing, *objchg);
1288 for( v =
nvars - 1; v >= 0; --v )
1303 *objchg += (bounds[v] - lb)*
obj;
1305 *objchg += (bounds[v] - ub)*
obj;
1309#ifdef SCIP_MORE_DEBUG
1311 varfixing, *objchg);
1325 SCIP_Bool useimplics,
1352 SCIP_Bool* collectedvars,
1361 for(
c = 0;
c < ncontributors; ++
c )
1363 var = contributors[
c];
1369 collectedvars[pos] =
FALSE;
1379 SCIP_Bool useimplics,
1381 SCIP_Bool* collectedlbvars,
1382 SCIP_Bool* collectedubvars,
1398 (*objimplics) =
NULL;
1409 if( useimplics && nlbcliques + nubcliques > 0 )
1411 int nlbcontributors;
1412 int nubcontributors;
1419 contributors, uselesscliques, &nlbcontributors, &lbobjchg) );
1428 if( !(*collect) && nlbcontributors == 1 )
1431 resetContributors(binobjvarmap, collectedlbvars, contributors, nlbcontributors);
1434 nlbcontributors = 0;
1439 &contributors[nlbcontributors], uselesscliques, &nubcontributors, &ubobjchg) );
1448 if( !(*collect) && nubcontributors == 1 )
1451 resetContributors(binobjvarmap, collectedubvars, &contributors[nlbcontributors], nubcontributors);
1454 nubcontributors = 0;
1457 if( (*collect) || nlbcontributors > 1 || nubcontributors > 1 )
1462 SCIP_CALL(
objimplicsCreate(
scip, objimplics, contributors, binobjvarmap, collectedlbvars, collectedubvars, lbobjchg, ubobjchg, nlbcontributors, nubcontributors) );
1468 resetContributors(binobjvarmap, collectedlbvars, contributors, nlbcontributors);
1471 resetContributors(binobjvarmap, collectedubvars, &contributors[nlbcontributors], nubcontributors);
1474 else if( (*collect) )
1494 SCIP_Bool useimplics,
1496 SCIP_Bool* isnotzero
1515 (*objchg) =
MIN(lbobjchg, ubobjchg);
1562 for( v = 0; v <
nvars; ++v )
1593 SCIP_Bool* collectedlbvars;
1594 SCIP_Bool* collectedubvars;
1596 SCIP_Bool useimplics;
1600 eventhdlr = propdata->eventhdlr;
1603 useimplics = (propdata->propuseimplics && nbinobjvars < propdata->maximplvars);
1608 propdata->objintvarssize = nobjvars - nbinobjvars;
1632 cliqueGetHashkey, cliqueIsHashkeyEq, cliqueGetHashkeyVal,
NULL) );
1635 uselesscliques =
NULL;
1639 contributors =
NULL;
1640 collectedlbvars =
NULL;
1641 collectedubvars =
NULL;
1642 uselesscliques =
NULL;
1648 for( v = 0; v <
nvars && (nobjintvars == 0 || nobjintvars < propdata->objintvarssize); ++v )
1669 nbinobjvars, contributors, uselesscliques, &collect) );
1678 propdata->minactvars[nminactvars] =
var;
1679 propdata->minactimpls[nminactvars] = objimplics;
1685 SCIPdebugMsg(
scip,
"variable <%s>[obj: <%g>] implicit objective change %g\n",
1699 propdata->maxactvars[nmaxactvars] =
var;
1700 propdata->maxactchgs[nmaxactvars] = -objchg;
1718 assert(nobjintvars < propdata->objintvarssize);
1720 propdata->objintvars[nobjintvars] =
var;
1738 if( uselesscliques !=
NULL )
1746 if( nminactvars == 0 )
1750 propdata->minactsize = 0;
1751 propdata->minactvars =
NULL;
1752 propdata->minactimpls =
NULL;
1759 SCIPsortDownPtrPtr((
void**)propdata->minactimpls, (
void**)propdata->minactvars, objimplicsComp, nminactvars);
1761 SCIPdebugMsg(
scip,
"%d binary variables with non-zero objective contribution w.r.t. the minimum activity of the objective function\n", nminactvars);
1764 if( nmaxactvars == 0 )
1768 propdata->maxactsize = 0;
1769 propdata->maxactvars =
NULL;
1770 propdata->maxactchgs =
NULL;
1779 SCIPdebugMsg(
scip,
"%d binary variables with non-zero objective contribution w.r.t. the maximum activity of the objective function\n", nmaxactvars);
1782 if( nobjintvars == 0 )
1785 propdata->objintvarssize = 0;
1786 propdata->objintvars =
NULL;
1791 SCIPsortDownPtr((
void**)propdata->objintvars, varCompObj, nobjintvars - nobjcontvars);
1794 SCIPsortDownPtr((
void**)(&propdata->objintvars[nobjintvars - nobjcontvars]), varCompObj, nobjcontvars);
1796 SCIPdebugMsg(
scip,
"%d integer variables and %d continuous variables with non-zero objective contribution\n",
1797 nobjintvars - nobjcontvars, nobjcontvars);
1803 propdata->nminactvars = nminactvars;
1804 propdata->nmaxactvars = nmaxactvars;
1805 propdata->nobjintvars = nobjintvars;
1807 propdata->maxpseudoobjactinf = 0;
1808 propdata->lastvarnum = -1;
1809 propdata->glbfirstnonfixed = 0;
1810 propdata->maxactfirstnonfixed = 0;
1811 propdata->firstnonfixed = 0;
1812 propdata->nnewvars = 0;
1817 propdata->initialized =
TRUE;
1820 propdata->glbpropagated =
FALSE;
1826 if( nminactvars > 0 )
1829 SCIPvarGetHashkey, SCIPvarIsHashkeyEq, SCIPvarGetHashkeyVal,
NULL) );
1832 propdata->addedvars =
NULL;
1843 SCIP_Real* reqpseudoobjval
1869 (*reqpseudoobjval) -= (loclb - glblb) *
objval;
1890 (*reqpseudoobjval) -= (locub - glbub) *
objval;
1906 SCIP_Real* reqpseudoobjval,
1907 SCIP_Bool* foundimplics
1918 for( v = start; v < end; ++v )
1937 (*foundimplics) =
TRUE;
1952 SCIP_Bool respropuseimplics,
1953 SCIP_Real* reqpseudoobjval
1959 SCIP_Bool foundimplics;
1970 foundimplics =
FALSE;
1975 if( respropuseimplics )
1979 bdchgidx, addedvars, reqpseudoobjval, &foundimplics) );
1992 if( addedvars !=
NULL )
2001 if( respropuseimplics )
2005 bdchgidx, addedvars, reqpseudoobjval, &foundimplics) );
2018 if( addedvars !=
NULL )
2042 SCIP_Real* cutoffbound
2045 if( inferinfo != -1 )
2056 assert(inferinfo < propdata->nminactvars);
2060 objimplics = propdata->minactimpls[inferinfo];
2077 if( addedvars !=
NULL )
2079 SCIP_Bool foundimplics =
FALSE;
2119 (*cutoffbound) -=
objval * (newbound - glbbound);
2133 SCIP_Real cutoffbound,
2143 SCIP_Real glbpseudoobjval;
2144 SCIP_Real reqpseudoobjval;
2151 nvars = propdata->nminactvars;
2166 reqpseudoobjval = cutoffbound;
2175 addedvars = propdata->addedvars;
2179 if( infervar !=
NULL )
2184 reqpseudoobjval = cutoffbound - glbpseudoobjval;
2187 SCIPdebugMsg(
scip,
"resolve propagation global pseudo objective <%g>, cutoff bounda <%g>, required minactivity <%g>\n",
2188 glbpseudoobjval, cutoffbound, reqpseudoobjval);
2203 vars = propdata->minactvars;
2206 minactimpls = propdata->minactimpls;
2219 for( v = propdata->glbfirstnonfixed; v <
nvars; ++v )
2226 if(
var == infervar )
2243 if(
var == infervar )
2254 vars = propdata->objintvars;
2255 nvars = propdata->nobjintvars;
2265 if(
var == infervar )
2282 SCIP_Real cutoffbound,
2283 SCIP_Real pseudoobjval,
2285 SCIP_Bool* tightened
2291 SCIP_Bool infeasible;
2320 SCIP_Real
QUAD(newbdq);
2335 SCIPdebugMsg(
scip,
" -> new (local) upper bound of variable <%s>[%g,%g]: %g, objective change <%g>, pseudo objective <%g>, cutoff bound <%g>\n",
2346 SCIPdebugMsg(
scip,
" -> new (global) upper bound of variable <%s>[%g,%g]: %g, objective change <%g>, pseudo objective <%g>, cutoff bound <%g>\n",
2353 SCIP_Real
QUAD(newbdq);
2368 SCIPdebugMsg(
scip,
" -> new (local) lower bound of variable <%s>[%g,%g]: %g, objective change <%g>, pseudo objective <%g>, cutoff bound <%g>\n",
2379 SCIPdebugMsg(
scip,
" -> new (global) lower bound of variable <%s>[%g,%g]: %g, objective change <%g>, pseudo objective <%g>, cutoff bound <%g>\n",
2395 SCIP_Real cutoffbound,
2396 SCIP_Real pseudoobjval,
2397 SCIP_Bool* tightened,
2413 objimplics = propdata->minactimpls[pos];
2424 (*tightened) =
FALSE;
2459 if( lbobjchg > ubobjchg )
2485 SCIP_Bool tightened;
2486 SCIP_Real pseudoobjval;
2487 SCIP_Real cutoffbound;
2501 cutoffbound = propdata->cutoffbound;
2516 minactvars = propdata->minactvars;
2517 objintvars = propdata->objintvars;
2518 nminactvars = propdata->nminactvars;
2519 nobjintvars = propdata->nobjintvars;
2528 for( v = propdata->glbfirstnonfixed; v < nminactvars; ++v )
2530 var = minactvars[v];
2547 SCIPdebugMsg(
scip,
"interrupt global pseudo objective propagation w.r.t. cutoff bound <%.15g> for binary variables after %d from %d binary variables\n",
2548 cutoffbound, v, nminactvars);
2561 propdata->glbfirstnonfixed = v;
2562 propdata->firstnonfixed =
MAX(propdata->firstnonfixed, v);
2565 for( ; v < nminactvars && cutoffbound - pseudoobjval < propdata->minactimpls[v]->maxobjchg; ++v )
2567 var = minactvars[v];
2588 for( ; v < nminactvars; ++v )
2590 assert(cutoffbound - pseudoobjval >= propdata->minactimpls[v]->maxobjchg);
2592 var = minactvars[v];
2610 for( v = 0; v < nobjintvars; ++v )
2612 var = objintvars[v];
2624 propdata->glbpropagated =
TRUE;
2634 SCIP_Real cutoffbound,
2635 SCIP_Real pseudoobjval,
2643 SCIP_Bool tightened;
2650 minactvars = propdata->minactvars;
2651 nminactvars = propdata->nminactvars;
2652 assert(nminactvars == 0 || minactvars !=
NULL);
2663 for( v = propdata->glbfirstnonfixed; v < propdata->firstnonfixed; ++v )
2665 var = minactvars[v];
2674 for( v = propdata->firstnonfixed; v < nminactvars; ++v )
2676 var = minactvars[v];
2696 SCIPdebugMsg(
scip,
"interrupt local pseudo objective propagation w.r.t. cutoff bound <%.15g> for binary variables after %d from %d binary variables\n",
2697 cutoffbound, v, nminactvars);
2708 propdata->firstnonfixed = v;
2711 for( ; v < nminactvars && cutoffbound - pseudoobjval < propdata->minactimpls[v]->maxobjchg; ++v )
2713 var = minactvars[v];
2738 for( ; v < nminactvars; ++v )
2740 var = minactvars[v];
2743 assert(cutoffbound - pseudoobjval >= propdata->minactimpls[v]->maxobjchg);
2771 SCIP_Real pseudoobjval;
2772 SCIP_Real cutoffbound;
2774 SCIP_Bool tightened;
2800 if( cutoffbound < propdata->cutoffbound )
2802 propdata->glbpropagated =
FALSE;
2803 propdata->cutoffbound = cutoffbound;
2815 if( propdata->propcutoffbound && !propdata->glbpropagated &&
SCIPgetDepth(
scip) > 0 )
2842 SCIPdebugMsg(
scip,
"pseudo objective value <%g> exceeds cutoff bound <%g>\n", pseudoobjval, cutoffbound);
2863 SCIPdebugMsg(
scip,
"propagating pseudo objective function (pseudoobj: %g, cutoffbound: %g)\n", pseudoobjval, cutoffbound);
2885 objintvars = propdata->objintvars;
2886 nobjintvars = propdata->nobjintvars;
2887 assert(nobjintvars == 0 || objintvars !=
NULL);
2890 for( v = 0; v < nobjintvars; ++v )
2892 var = objintvars[v];
2917 objintvars = propdata->objintvars;
2918 nobjintvars = propdata->nobjintvars;
2919 assert(nobjintvars == 0 || objintvars !=
NULL);
2922 nmaxuseless =
MAX(propdata->minuseless, (
int)propdata->maxvarsfrac*(nobjintvars));
2925 v = propdata->lastvarnum;
2927 for(
c = 0;
c < nobjintvars && nuseless < nmaxuseless; ++
c )
2930 if( v >= nobjintvars )
2933 var = objintvars[v];
2948 propdata->lastvarnum = v;
2978 propdata->maxpseudoobjact = 0.0;
2979 propdata->maxpseudoobjactinf = 0;
2981 for( v = 0; v <
nvars; ++v )
3002 propdata->maxpseudoobjactinf++;
3004 propdata->maxpseudoobjact += contrib;
3042 assert(propdata->maxpseudoobjactinf >= 1);
3044 if( propdata->maxpseudoobjactinf == 1 )
3045 residual = propdata->maxpseudoobjact;
3052 if( propdata->maxpseudoobjactinf >= 1 )
3055 residual = propdata->maxpseudoobjact - contrib;
3109 SCIP_Real lowerbound,
3110 SCIP_Real maxpseudoobjact,
3111 SCIP_Bool useimplics,
3112 SCIP_Bool* infeasible,
3113 SCIP_Bool* tightened
3135 (*infeasible) =
FALSE;
3136 (*tightened) =
FALSE;
3146 (*infeasible) =
TRUE;
3168 SCIP_Real lowerbound,
3169 SCIP_Bool* infeasible,
3170 SCIP_Bool* tightened
3180 (*tightened) =
FALSE;
3189 newbd = (lowerbound - residual) /
objval;
3236 SCIP_Real lowerbound;
3237 SCIP_Real maxpseudoobjact;
3249 assert(propdata->nminactvars > 0 || propdata->nobjintvars > 0);
3268 if( propdata->maxpseudoobjactinf > 1 )
3286 SCIP_Bool tightened;
3295 maxactvars = propdata->maxactvars;
3296 nmaxactvars = propdata->nmaxactvars;
3297 assert(nmaxactvars == 0 || maxactvars !=
NULL);
3299 for( v = propdata->maxactfirstnonfixed; v < nmaxactvars; ++v )
3301 var = maxactvars[v];
3324 SCIPdebugMsg(
scip,
"interrupt pseudo objective propagation w.r.t. lower bound <%.15g> for binary variables after %d from %d binary variables\n",
3325 lowerbound, v, nmaxactvars);
3340 propdata->maxactfirstnonfixed = v;
3343 for( ; v < nmaxactvars && maxpseudoobjact - lowerbound < propdata->maxactchgs[v] && !
cutoff; ++v )
3345 var = maxactvars[v];
3369 for( ; v < nmaxactvars && !
cutoff; ++v )
3371 var = maxactvars[v];
3388 objintvars = propdata->objintvars;
3389 nobjintvars = propdata->nobjintvars;
3390 assert(nobjintvars == 0 || objintvars !=
NULL);
3393 for( v = 0; v < nobjintvars && !
cutoff; ++v )
3395 var = objintvars[v];
3414 else if( nchgbds > 0 )
3418 propdata->lastlowerbound = lowerbound;
3473 assert(!propdata->catchvaradded);
3475 propdata->catchvaradded =
TRUE;
3490 if( propdata->catchvaradded )
3494 propdata->catchvaradded =
FALSE;
3510 SCIP_Real cutoffbound;
3511 SCIP_Real pseudoobjval;
3546 if( cutoffbound < propdata->cutoffbound || pseudoobjval > propdata->glbpseudoobjval )
3549 SCIP_Bool tightened;
3552 oldnchgbds = *nchgbds;
3561 for( v =
nvars - 1; v >= 0; --v )
3575 if( *nchgbds > oldnchgbds )
3579 propdata->cutoffbound = cutoffbound;
3580 propdata->glbpseudoobjval = pseudoobjval;
3581 propdata->glbpropagated =
TRUE;
3613 if( !propdata->initialized || propdata->nnewvars > propdata->maxnewvars )
3623 if( propdata->nminactvars == 0 && propdata->nmaxactvars == 0 && propdata->nobjintvars == 0 )
3637 (*result) = dualresult;
3648 SCIP_Real cutoffbound;
3698 propdata->firstnonfixed = 0;
3701 propdata->nnewvars++;
3708 propdata->maxpseudoobjactinf = 0;
3733 propdata->eventhdlr =
NULL;
3736 eventExecPseudoobj,
NULL) );
3738 if( propdata->eventhdlr ==
NULL )
3740 SCIPerrorMessage(
"event handler for pseudo objective propagator not found\n");
3761 "minimal number of successive non-binary variable propagations without a bound reduction before aborted",
3765 "propagating/" PROP_NAME "/maxvarsfrac",
3766 "maximal fraction of non-binary variables with non-zero objective without a bound reduction before aborted",
3770 "propagating/" PROP_NAME "/propfullinroot",
3771 "whether to propagate all non-binary variables when we are propagating the root node",
3775 "propagating/" PROP_NAME "/propcutoffbound",
3776 "propagate new cutoff bound directly globally",
3781 "should the propagator be forced even if active pricer are present?",
3786 "number of variables added after the propagator is reinitialized?",
3790 "propagating/" PROP_NAME "/propuseimplics",
3791 "use implications to strengthen the propagation of binary variable (increasing the objective change)?",
3795 "propagating/" PROP_NAME "/respropuseimplics",
3796 "use implications to strengthen the resolve propagation of binary variable (increasing the objective change)?",
3800 "propagating/" PROP_NAME "/maximplvars",
3801 "maximum number of binary variables the implications are used if turned on (-1: unlimited)?",
3812 SCIP_Real cutoffbound,
3813 SCIP_Real pseudoobjval,
3814 SCIP_Bool* tightened
defines macros for basic operations in double-double arithmetic giving roughly twice the precision of...
#define SCIPquadprecDivQD(r, a, b)
#define SCIPquadprecSumQD(r, a, b)
#define SCIPquadprecSumDD(r, a, b)
SCIP_Bool SCIPisTransformed(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
int SCIPgetNObjVars(SCIP *scip)
int SCIPgetNContVars(SCIP *scip)
int SCIPgetNVars(SCIP *scip)
SCIP_VAR ** SCIPgetVars(SCIP *scip)
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
int SCIPhashmapGetImageInt(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)
SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPhashmapInsertInt(SCIP_HASHMAP *hashmap, void *origin, int image)
void SCIPhashtableFree(SCIP_HASHTABLE **hashtable)
SCIP_Bool SCIPhashtableExists(SCIP_HASHTABLE *hashtable, void *element)
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 SCIPhashtableRemoveAll(SCIP_HASHTABLE *hashtable)
SCIP_RETCODE SCIPhashtableInsert(SCIP_HASHTABLE *hashtable, void *element)
#define SCIPdebugMsgPrint
SCIP_RETCODE SCIPpropagateCutoffboundVar(SCIP *scip, SCIP_PROP *prop, SCIP_VAR *var, SCIP_Real cutoffbound, SCIP_Real pseudoobjval, SCIP_Bool *tightened)
SCIP_RETCODE SCIPaddIntParam(SCIP *scip, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPaddRealParam(SCIP *scip, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPaddBoolParam(SCIP *scip, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPincludePropPseudoobj(SCIP *scip)
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 SCIPanalyzeConflict(SCIP *scip, int validdepth, SCIP_Bool *success)
SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)
SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
const char * SCIPeventhdlrGetName(SCIP_EVENTHDLR *eventhdlr)
SCIP_EVENTTYPE SCIPeventGetType(SCIP_EVENT *event)
SCIP_RETCODE SCIPcatchVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
SCIP_RETCODE SCIPdropVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
SCIP_RETCODE SCIPcatchEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
SCIP_RETCODE SCIPdropEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
SCIP_Real SCIPgetPseudoObjval(SCIP *scip)
SCIP_Real SCIPgetGlobalPseudoObjval(SCIP *scip)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
#define SCIPallocClearBufferArray(scip, ptr, num)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPallocBlockMemoryArray(scip, ptr, num)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)
#define SCIPallocBlockMemory(scip, ptr)
int SCIPgetNActivePricers(SCIP *scip)
SCIP_Bool SCIPinProbing(SCIP *scip)
void SCIPpropSetData(SCIP_PROP *prop, SCIP_PROPDATA *propdata)
SCIP_RETCODE SCIPsetPropCopy(SCIP *scip, SCIP_PROP *prop,)
SCIP_PROPDATA * SCIPpropGetData(SCIP_PROP *prop)
SCIP_RETCODE SCIPsetPropPresol(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPPRESOL((*proppresol)), int presolpriority, int presolmaxrounds, SCIP_PRESOLTIMING presoltiming)
SCIP_RETCODE SCIPsetPropExitsol(SCIP *scip, SCIP_PROP *prop,)
const char * SCIPpropGetName(SCIP_PROP *prop)
SCIP_RETCODE SCIPsetPropResprop(SCIP *scip, SCIP_PROP *prop,)
SCIP_RETCODE SCIPsetPropFree(SCIP *scip, SCIP_PROP *prop,)
SCIP_RETCODE SCIPsetPropInitsol(SCIP *scip, SCIP_PROP *prop,)
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_Real SCIPgetLowerbound(SCIP *scip)
SCIP_Real SCIPgetCutoffbound(SCIP *scip)
SCIP_Bool SCIPisFeasGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisDualfeasLT(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 SCIPisFeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPfeastol(SCIP *scip)
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
SCIP_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_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisDualfeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
int SCIPgetCutoffdepth(SCIP *scip)
int SCIPgetDepth(SCIP *scip)
SCIP_RETCODE SCIPcutoffNode(SCIP *scip, SCIP_NODE *node)
SCIP_NODE * SCIPgetRootNode(SCIP *scip)
SCIP_BOUNDTYPE SCIPvarGetBestBoundType(SCIP_VAR *var)
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_RETCODE SCIPinferVarUbProp(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_RETCODE SCIPtightenVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
int SCIPvarGetNImpls(SCIP_VAR *var, SCIP_Bool varfixing)
int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
SCIP_VAR ** SCIPvarGetImplVars(SCIP_VAR *var, SCIP_Bool varfixing)
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_Bool SCIPvarIsIntegral(SCIP_VAR *var)
SCIP_Real * SCIPvarGetImplBounds(SCIP_VAR *var, SCIP_Bool varfixing)
int SCIPvarGetNCliques(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
int SCIPgetNCliques(SCIP *scip)
SCIP_CLIQUE ** SCIPvarGetCliques(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_Real SCIPgetVarLbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
int SCIPvarCompare(SCIP_VAR *var1, SCIP_VAR *var2)
SCIP_BOUNDTYPE SCIPvarGetWorstBoundType(SCIP_VAR *var)
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_Bool SCIPallowWeakDualReds(SCIP *scip)
SCIP_BOUNDTYPE * SCIPvarGetImplTypes(SCIP_VAR *var, SCIP_Bool varfixing)
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)
SCIP_RETCODE SCIPinferVarLbProp(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
void SCIPsortDownPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortDownRealPtr(SCIP_Real *realarray, void **ptrarray, int len)
void SCIPsortDownPtrPtr(void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
assert(minobj< SCIPgetCutoffbound(scip))
SCIP_VAR ** SCIPcliqueGetVars(SCIP_CLIQUE *clique)
int SCIPcliqueGetNVars(SCIP_CLIQUE *clique)
SCIP_Bool * SCIPcliqueGetValues(SCIP_CLIQUE *clique)
unsigned int SCIPcliqueGetId(SCIP_CLIQUE *clique)
memory allocation routines
#define BMSclearMemoryArray(ptr, num)
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
#define PROP_PRESOL_MAXROUNDS
#define PROP_PRESOLTIMING
static SCIP_RETCODE addConflictBinvar(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_OBJIMPLICS *objimplics, SCIP_HASHTABLE *addedvars, SCIP_Bool respropuseimplics, SCIP_Real *reqpseudoobjval)
static SCIP_RETCODE getConflictImplics(SCIP *scip, SCIP_VAR **vars, int start, int end, SCIP_BDCHGIDX *bdchgidx, SCIP_HASHTABLE *addedvars, SCIP_Real *reqpseudoobjval, SCIP_Bool *foundimplics)
static SCIP_RETCODE dropVarEvents(SCIP *scip, SCIP_PROPDATA *propdata)
#define DEFAULT_MAXNEWVARS
#define DEFAULT_PROPCUTOFFBOUND
static SCIP_RETCODE getMaxactObjchg(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE bound, SCIP_Bool useimplics, SCIP_Real *objchg)
static SCIP_RETCODE adjustCutoffbound(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_VAR *var, int inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_HASHTABLE *addedvars, SCIP_Real *cutoffbound)
static void resetContributors(SCIP_HASHMAP *binobjvarmap, SCIP_Bool *collectedvars, SCIP_VAR **contributors, int ncontributors)
static SCIP_RETCODE propagateLowerbound(SCIP *scip, SCIP_PROP *prop, SCIP_RESULT *result)
static void checkImplicsApplied(SCIP *scip, SCIP_VAR *var)
static SCIP_RETCODE collectMinactVar(SCIP *scip, SCIP_VAR *var, SCIP_OBJIMPLICS **objimplics, SCIP_Bool useimplics, SCIP_HASHMAP *binobjvarmap, SCIP_Bool *collectedlbvars, SCIP_Bool *collectedubvars, int nbinobjvars, SCIP_VAR **contributors, SCIP_HASHTABLE *uselesscliques, SCIP_Bool *collect)
#define DEFAULT_MAXIMPLVARS
static SCIP_RETCODE propagateLowerboundVar(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_VAR *var, SCIP_Real lowerbound, SCIP_Bool *infeasible, SCIP_Bool *tightened)
#define DEFAULT_MINUSELESS
#define DEFAULT_RESPROPUSEIMPLICS
static SCIP_RETCODE catchObjEvent(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_EVENTHDLR *eventhdlr, SCIP_VAR *var)
static void updateMaxObjPseudoactivity(SCIP *scip, SCIP_PROPDATA *propdata)
static SCIP_RETCODE collectMaxactVar(SCIP *scip, SCIP_VAR *var, SCIP_Bool useimplics, SCIP_Real *objchg, SCIP_Bool *isnotzero)
static SCIP_Real collectMinactImplicVar(SCIP *scip, SCIP_VAR *var, SCIP_HASHMAP *binobjvarmap, SCIP_Bool *collectedvars, int nbinobjvars, SCIP_VAR **contributors, int *ncontributors)
static SCIP_RETCODE getMinactImplicObjchg(SCIP *scip, SCIP_VAR *var, SCIP_OBJIMPLICS *objimplics, SCIP_BDCHGIDX *bdchgidx, SCIP_BOUNDTYPE bound, SCIP_Bool local, SCIP_Real *objchg)
static SCIP_Real getVarObjchg(SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BOUNDTYPE bound)
static SCIP_RETCODE propagateCutoffbound(SCIP *scip, SCIP_PROP *prop, SCIP_RESULT *result)
#define DEFAULT_MAXVARSFRAC
#define DEFAULT_PROPUSEIMPLICS
static SCIP_RETCODE propdataInit(SCIP *scip, SCIP_PROPDATA *propdata)
static void checkGlbfirstnonfixed(SCIP_PROPDATA *propdata)
static void calcMaxObjPseudoactivity(SCIP *scip, SCIP_PROPDATA *propdata)
#define DEFAULT_PROPFULLINROOT
static SCIP_Real getMaxObjPseudoactivityResidual(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_VAR *var)
static void propdataReset(SCIP_PROPDATA *propdata)
static SCIP_RETCODE objimplicsCreate(SCIP *scip, SCIP_OBJIMPLICS **objimplics, SCIP_VAR **objvars, SCIP_HASHMAP *binobjvarmap, SCIP_Bool *collectedlbvars, SCIP_Bool *collectedubvars, SCIP_Real maxlbobjchg, SCIP_Real maxubobjchg, int nlbimpls, int nubimpls)
static SCIP_RETCODE collectMinactImplicVars(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE bound, SCIP_HASHMAP *binobjvarmap, SCIP_Bool *collectedvars, int nbinobjvars, SCIP_VAR **contributors, SCIP_HASHTABLE *uselesscliques, int *ncontributors, SCIP_Real *objchg)
static SCIP_RETCODE collectMinactObjchg(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE bound, SCIP_HASHMAP *binobjvarmap, SCIP_Bool *collectedvars, int nbinobjvars, SCIP_VAR **contributors, SCIP_HASHTABLE *uselesscliques, int *ncontributors, SCIP_Real *objchg)
static SCIP_RETCODE propagateCutoffboundBinvars(SCIP *scip, SCIP_PROP *prop, SCIP_Real cutoffbound, SCIP_Real pseudoobjval, int *nfixedvars, SCIP_Bool *cutoff)
static SCIP_RETCODE propdataExit(SCIP *scip, SCIP_PROPDATA *propdata)
static SCIP_RETCODE propagateLowerboundBinvar(SCIP *scip, SCIP_VAR *var, SCIP_Real lowerbound, SCIP_Real maxpseudoobjact, SCIP_Bool useimplics, SCIP_Bool *infeasible, SCIP_Bool *tightened)
static SCIP_RETCODE objimplicsDelPos(SCIP *scip, SCIP_OBJIMPLICS *objimplics, int pos)
static SCIP_RETCODE addConflictBounds(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real *reqpseudoobjval)
static SCIP_Real getMaxObjPseudoactivityResidualValue(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_Real contrib)
static SCIP_RETCODE getMaxactImplicObjchg(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE bound, SCIP_Real *objchg)
static SCIP_RETCODE resolvePropagation(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_Real cutoffbound, SCIP_VAR *infervar, int inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx)
static SCIP_RETCODE propagateCutoffboundGlobally(SCIP *scip, SCIP_PROP *prop, int *nchgbds, SCIP_Bool *cutoff)
static SCIP_RETCODE propagateCutoffboundBinvar(SCIP *scip, SCIP_PROP *prop, SCIP_VAR *var, int pos, SCIP_Real cutoffbound, SCIP_Real pseudoobjval, SCIP_Bool *tightened, SCIP_Bool *cutoff, SCIP_Bool local)
static SCIP_RETCODE objimplicsFree(SCIP *scip, SCIP_OBJIMPLICS **objimplics)
static SCIP_RETCODE dropObjEvent(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_EVENTHDLR *eventhdlr, SCIP_VAR *var)
static SCIP_Real getMaxObjPseudoactivity(SCIP *scip, SCIP_PROPDATA *propdata)
static SCIP_RETCODE getMinactObjchg(SCIP *scip, SCIP_VAR *var, SCIP_OBJIMPLICS *objimplics, SCIP_BDCHGIDX *bdchgidx, SCIP_BOUNDTYPE bound, SCIP_Bool local, SCIP_Real *objchg)
#define PROP_PRESOL_PRIORITY
static SCIP_RETCODE propagateCutoffboundVar(SCIP *scip, SCIP_PROP *prop, SCIP_VAR *var, int inferinfo, SCIP_Real objchg, SCIP_Real cutoffbound, SCIP_Real pseudoobjval, SCIP_Bool local, SCIP_Bool *tightened)
Pseudo objective propagator.
public methods for managing events
public methods for implications, variable bounds, and cliques
public methods for message output
public data structures and miscellaneous methods
methods for sorting joint arrays of various types
public methods for propagators
public methods for problem variables
public methods for conflict handler plugins and conflict analysis
public methods for event handler plugins and event handlers
public methods for the LP relaxation, rows and columns
public methods for memory management
public methods for message handling
public methods for numerical tolerances
public methods for SCIP parameter handling
public methods for variable pricer plugins
public methods for global and local (sub)problems
public methods for the probing mode
public methods for propagator plugins
public methods for querying solving statistics
public methods for the branch-and-bound tree
public methods for SCIP variables
@ SCIP_CONFTYPE_PROPAGATION
#define SCIP_EVENTTYPE_GUBCHANGED
struct SCIP_EventData SCIP_EVENTDATA
#define SCIP_DECL_EVENTEXEC(x)
#define SCIP_EVENTTYPE_LBRELAXED
#define SCIP_EVENTTYPE_GLBCHANGED
#define SCIP_EVENTTYPE_BOUNDRELAXED
#define SCIP_EVENTTYPE_VARADDED
#define SCIP_EVENTTYPE_UBRELAXED
enum SCIP_BoundType SCIP_BOUNDTYPE
#define SCIP_DECL_SORTPTRCOMP(x)
#define SCIP_DECL_HASHKEYEQ(x)
#define SCIP_DECL_HASHGETKEY(x)
#define SCIP_DECL_HASHKEYVAL(x)
#define SCIP_DECL_PROPCOPY(x)
#define SCIP_DECL_PROPINITSOL(x)
#define SCIP_DECL_PROPFREE(x)
#define SCIP_DECL_PROPEXITSOL(x)
#define SCIP_DECL_PROPPRESOL(x)
#define SCIP_DECL_PROPRESPROP(x)
struct SCIP_PropData SCIP_PROPDATA
#define SCIP_DECL_PROPEXEC(x)
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
#define SCIP_PROPTIMING_DURINGLPLOOP