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
134 int maxpseudoobjactinf;
142 int glbfirstnonfixed;
143 int maxactfirstnonfixed;
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 )
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] )
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 )
818 if( collectedvars[pos] )
822 assert(*ncontributors < nbinobjvars);
823 contributors[*ncontributors] =
var;
827 collectedvars[pos] =
TRUE;
833#define MAX_CLIQUELENGTH 50
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];
1082 (*ncontributors) = 0;
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);
1361 for(
c = 0;
c < ncontributors; ++
c )
1363 var = contributors[
c];
1369 collectedvars[pos] =
FALSE;
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) )
1515 (*objchg) =
MIN(lbobjchg, ubobjchg);
1562 for( v = 0; v <
nvars; ++v )
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;
1869 (*reqpseudoobjval) -= (loclb - glblb) *
objval;
1890 (*reqpseudoobjval) -= (locub - glbub) *
objval;
1918 for( v = start; v < end; ++v )
1937 (*foundimplics) =
TRUE;
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 )
2045 if( inferinfo != -1 )
2056 assert(inferinfo < propdata->nminactvars);
2060 objimplics = propdata->minactimpls[inferinfo];
2077 if( addedvars !=
NULL )
2119 (*cutoffbound) -=
objval * (newbound - glbbound);
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 )
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",
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",
2413 objimplics = propdata->minactimpls[pos];
2424 (*tightened) =
FALSE;
2459 if( lbobjchg > ubobjchg )
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];
2585#ifdef SCIP_DISABLED_CODE
2589 for( ; v < nminactvars; ++v )
2591 assert(cutoffbound - pseudoobjval >= propdata->minactimpls[v]->maxobjchg);
2593 var = minactvars[v];
2611 for( v = 0; v < nobjintvars; ++v )
2613 var = objintvars[v];
2625 propdata->glbpropagated =
TRUE;
2651 minactvars = propdata->minactvars;
2652 nminactvars = propdata->nminactvars;
2653 assert(nminactvars == 0 || minactvars !=
NULL);
2664 for( v = propdata->glbfirstnonfixed; v < propdata->firstnonfixed; ++v )
2666 var = minactvars[v];
2675 for( v = propdata->firstnonfixed; v < nminactvars; ++v )
2677 var = minactvars[v];
2697 SCIPdebugMsg(
scip,
"interrupt local pseudo objective propagation w.r.t. cutoff bound <%.15g> for binary variables after %d from %d binary variables\n",
2698 cutoffbound, v, nminactvars);
2709 propdata->firstnonfixed = v;
2712 for( ; v < nminactvars && cutoffbound - pseudoobjval < propdata->minactimpls[v]->maxobjchg; ++v )
2714 var = minactvars[v];
2736#ifdef SCIP_DISABLED_CODE
2740 for( ; v < nminactvars; ++v )
2742 var = minactvars[v];
2745 assert(cutoffbound - pseudoobjval >= propdata->minactimpls[v]->maxobjchg);
2802 if( cutoffbound < propdata->cutoffbound )
2804 propdata->glbpropagated =
FALSE;
2805 propdata->cutoffbound = cutoffbound;
2817 if( propdata->propcutoffbound && !propdata->glbpropagated &&
SCIPgetDepth(
scip) > 0 )
2844 SCIPdebugMsg(
scip,
"pseudo objective value <%g> exceeds cutoff bound <%g>\n", pseudoobjval, cutoffbound);
2865 SCIPdebugMsg(
scip,
"propagating pseudo objective function (pseudoobj: %g, cutoffbound: %g)\n", pseudoobjval, cutoffbound);
2887 objintvars = propdata->objintvars;
2888 nobjintvars = propdata->nobjintvars;
2889 assert(nobjintvars == 0 || objintvars !=
NULL);
2892 for( v = 0; v < nobjintvars; ++v )
2894 var = objintvars[v];
2919 objintvars = propdata->objintvars;
2920 nobjintvars = propdata->nobjintvars;
2921 assert(nobjintvars == 0 || objintvars !=
NULL);
2924 nmaxuseless =
MAX(propdata->minuseless, (
int)propdata->maxvarsfrac*(nobjintvars));
2927 v = propdata->lastvarnum;
2929 for(
c = 0;
c < nobjintvars && nuseless < nmaxuseless; ++
c )
2932 if( v >= nobjintvars )
2935 var = objintvars[v];
2950 propdata->lastvarnum = v;
2980 propdata->maxpseudoobjact = 0.0;
2981 propdata->maxpseudoobjactinf = 0;
2983 for( v = 0; v <
nvars; ++v )
3004 propdata->maxpseudoobjactinf++;
3006 propdata->maxpseudoobjact += contrib;
3044 assert(propdata->maxpseudoobjactinf >= 1);
3046 if( propdata->maxpseudoobjactinf == 1 )
3047 residual = propdata->maxpseudoobjact;
3054 if( propdata->maxpseudoobjactinf >= 1 )
3057 residual = propdata->maxpseudoobjact - contrib;
3137 (*infeasible) =
FALSE;
3138 (*tightened) =
FALSE;
3148 (*infeasible) =
TRUE;
3182 (*tightened) =
FALSE;
3191 newbd = (lowerbound - residual) /
objval;
3251 assert(propdata->nminactvars > 0 || propdata->nobjintvars > 0);
3270 if( propdata->maxpseudoobjactinf > 1 )
3297 maxactvars = propdata->maxactvars;
3298 nmaxactvars = propdata->nmaxactvars;
3299 assert(nmaxactvars == 0 || maxactvars !=
NULL);
3301 for( v = propdata->maxactfirstnonfixed; v < nmaxactvars; ++v )
3303 var = maxactvars[v];
3326 SCIPdebugMsg(
scip,
"interrupt pseudo objective propagation w.r.t. lower bound <%.15g> for binary variables after %d from %d binary variables\n",
3327 lowerbound, v, nmaxactvars);
3342 propdata->maxactfirstnonfixed = v;
3345 for( ; v < nmaxactvars && maxpseudoobjact - lowerbound < propdata->maxactchgs[v] && !
cutoff; ++v )
3347 var = maxactvars[v];
3368#ifdef SCIP_DISABLED_CODE
3372 for( ; v < nmaxactvars && !
cutoff; ++v )
3374 var = maxactvars[v];
3391 objintvars = propdata->objintvars;
3392 nobjintvars = propdata->nobjintvars;
3393 assert(nobjintvars == 0 || objintvars !=
NULL);
3396 for( v = 0; v < nobjintvars && !
cutoff; ++v )
3398 var = objintvars[v];
3417 else if( nchgbds > 0 )
3421 propdata->lastlowerbound = lowerbound;
3476 assert(!propdata->catchvaradded);
3478 propdata->catchvaradded =
TRUE;
3493 if( propdata->catchvaradded )
3497 propdata->catchvaradded =
FALSE;
3549 if( cutoffbound < propdata->cutoffbound || pseudoobjval > propdata->glbpseudoobjval )
3555 oldnchgbds = *nchgbds;
3564 for( v =
nvars - 1; v >= 0; --v )
3578 if( *nchgbds > oldnchgbds )
3582 propdata->cutoffbound = cutoffbound;
3583 propdata->glbpseudoobjval = pseudoobjval;
3584 propdata->glbpropagated =
TRUE;
3616 if( !propdata->initialized || propdata->nnewvars > propdata->maxnewvars )
3626 if( propdata->nminactvars == 0 && propdata->nmaxactvars == 0 && propdata->nobjintvars == 0 )
3640 (*result) = dualresult;
3701 propdata->firstnonfixed = 0;
3704 propdata->nnewvars++;
3711 propdata->maxpseudoobjactinf = 0;
3736 propdata->eventhdlr =
NULL;
3739 eventExecPseudoobj,
NULL) );
3741 if( propdata->eventhdlr ==
NULL )
3743 SCIPerrorMessage(
"event handler for pseudo objective propagator not found\n");
3764 "minimal number of successive non-binary variable propagations without a bound reduction before aborted",
3768 "propagating/" PROP_NAME "/maxvarsfrac",
3769 "maximal fraction of non-binary variables with non-zero objective without a bound reduction before aborted",
3773 "propagating/" PROP_NAME "/propfullinroot",
3774 "whether to propagate all non-binary variables when we are propagating the root node",
3778 "propagating/" PROP_NAME "/propcutoffbound",
3779 "propagate new cutoff bound directly globally",
3784 "should the propagator be forced even if active pricer are present?",
3789 "number of variables added after the propagator is reinitialized?",
3793 "propagating/" PROP_NAME "/propuseimplics",
3794 "use implications to strengthen the propagation of binary variable (increasing the objective change)?",
3798 "propagating/" PROP_NAME "/respropuseimplics",
3799 "use implications to strengthen the resolve propagation of binary variable (increasing the objective change)?",
3803 "propagating/" PROP_NAME "/maximplvars",
3804 "maximum number of binary variables the implications are used if turned on (-1: unlimited)?",
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 SCIPisRelEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
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
#define PROP_PRESOL_PRIORITY
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)
struct SCIP_ObjImplics SCIP_OBJIMPLICS
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)
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
struct SCIP_Eventhdlr SCIP_EVENTHDLR
#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
struct SCIP_Clique SCIP_CLIQUE
enum SCIP_BoundType SCIP_BOUNDTYPE
struct SCIP_HashMap SCIP_HASHMAP
#define SCIP_DECL_SORTPTRCOMP(x)
#define SCIP_DECL_HASHKEYEQ(x)
#define SCIP_DECL_HASHGETKEY(x)
#define SCIP_DECL_HASHKEYVAL(x)
struct SCIP_HashTable SCIP_HASHTABLE
#define SCIP_DECL_PROPCOPY(x)
#define SCIP_DECL_PROPINITSOL(x)
#define SCIP_DECL_PROPFREE(x)
#define SCIP_DECL_PROPEXITSOL(x)
struct SCIP_Prop SCIP_PROP
#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
struct SCIP_BdChgIdx SCIP_BDCHGIDX