37 #define PROP_NAME "pseudoobj" 38 #define PROP_DESC "pseudo objective function propagator" 39 #define PROP_TIMING SCIP_PROPTIMING_BEFORELP | SCIP_PROPTIMING_DURINGLPLOOP | SCIP_PROPTIMING_AFTERLPLOOP 40 #define PROP_PRIORITY 3000000 42 #define PROP_DELAY FALSE 43 #define PROP_PRESOL_PRIORITY +6000000 44 #define PROP_PRESOL_MAXROUNDS -1 46 #define PROP_PRESOLTIMING SCIP_PRESOLTIMING_FAST 48 #define EVENTHDLR_NAME "pseudoobj" 49 #define EVENTHDLR_DESC "bound change event handler for pseudo objective function propagator" 51 #define DEFAULT_MINUSELESS 100 53 #define DEFAULT_MAXVARSFRAC 0.1 55 #define DEFAULT_PROPFULLINROOT TRUE 56 #define DEFAULT_PROPCUTOFFBOUND TRUE 57 #define DEFAULT_FORCE FALSE 61 #define DEFAULT_MAXNEWVARS 1000 62 #define DEFAULT_PROPUSEIMPLICS TRUE 63 #define DEFAULT_RESPROPUSEIMPLICS TRUE 64 #define DEFAULT_MAXIMPLVARS 50000 103 int maxpseudoobjactinf;
111 int glbfirstnonfixed;
112 int maxactfirstnonfixed;
161 for( v = 0; v < nvars; ++v )
168 assert(
SCIPisLE(scip, lb, bounds[v]));
177 assert(
SCIPisGE(scip, ub, bounds[v]));
192 for( v = 0; v < propdata->glbfirstnonfixed; ++v )
194 var = propdata->minactvars[v];
200 for( v = 0; v < propdata->maxactfirstnonfixed; ++v )
202 var = propdata->maxactvars[v];
272 if( locks1 < locks2 )
274 if( locks1 > locks2 )
288 if( locks1 < locks2 )
290 if( locks1 > locks2 )
343 assert(scip !=
NULL);
344 assert(objimplics !=
NULL);
351 if( nlbimpls + nubimpls == 0 )
353 assert(nlbimpls == 0);
354 assert(nubimpls == 0);
355 (*objimplics)->objvars =
NULL;
356 (*objimplics)->maxobjchg = 0.0;
357 (*objimplics)->nlbimpls = 0;
358 (*objimplics)->nubimpls = 0;
359 (*objimplics)->size = 0;
368 assert(objvars !=
NULL);
369 assert(binobjvarmap !=
NULL);
370 assert(collectedlbvars !=
NULL);
371 assert(collectedubvars !=
NULL);
374 (*objimplics)->size = nlbimpls +
nubimpls;
387 assert(collectedlbvars[pos]);
389 if( collectedubvars[pos] )
413 (*objimplics)->objvars[nvars] = var;
416 collectedlbvars[pos] =
FALSE;
418 (*objimplics)->nlbimpls = nvars;
422 var = objvars[nlbimpls + v];
429 assert(collectedubvars[pos]);
440 (*objimplics)->objvars[nvars] = var;
443 collectedubvars[pos] =
FALSE;
445 (*objimplics)->nubimpls = nvars - (*objimplics)->nlbimpls;
448 for( v = 0; v < nvars; ++v )
456 (*objimplics)->maxobjchg =
MAX(maxlbobjchg, maxubobjchg);
470 assert(scip !=
NULL);
471 assert(objimplics !=
NULL);
472 assert(*objimplics !=
NULL);
475 for( v = 0; v < (*objimplics)->nlbimpls + (*objimplics)->nubimpls; ++v )
551 assert(propdata !=
NULL);
552 assert(eventhdlr !=
NULL);
582 assert(propdata !=
NULL);
583 assert(eventhdlr !=
NULL);
613 assert(scip !=
NULL);
614 assert(propdata !=
NULL);
616 eventhdlr = propdata->eventhdlr;
617 assert(eventhdlr !=
NULL);
620 for( k = 0; k < propdata->nminactvars; ++k )
622 var = propdata->minactvars[k];
636 for( k = 0; k < propdata->nmaxactvars; ++k )
638 var = propdata->maxactvars[k];
650 for( k = 0; k < propdata->nobjintvars; ++k )
652 var = propdata->objintvars[k];
672 propdata->minactvars =
NULL;
674 propdata->maxactvars =
NULL;
675 propdata->maxactchgs =
NULL;
676 propdata->objintvars =
NULL;
677 propdata->nminactvars = 0;
678 propdata->nmaxactvars = 0;
679 propdata->nobjintvars = 0;
681 propdata->maxpseudoobjactinf = 0;
682 propdata->lastvarnum = -1;
683 propdata->glbpropagated =
FALSE;
687 propdata->glbfirstnonfixed = 0;
688 propdata->maxactfirstnonfixed = 0;
689 propdata->firstnonfixed = 0;
690 propdata->nnewvars = 0;
691 propdata->minactsize = 0;
692 propdata->maxactsize = 0;
693 propdata->objintvarssize = 0;
694 propdata->catchvaradded =
FALSE;
695 propdata->initialized =
FALSE;
707 if( !propdata->initialized )
710 if( propdata->addedvars !=
NULL )
716 for( v = 0; v < propdata->nminactvars; ++v )
768 assert(scip !=
NULL);
770 assert(binobjvarmap !=
NULL);
771 assert(collectedvars !=
NULL);
772 assert(contributors !=
NULL);
773 assert(ncontributors !=
NULL);
790 if( collectedvars[pos] )
794 assert(*ncontributors < nbinobjvars);
795 contributors[*ncontributors] = var;
799 collectedvars[pos] =
TRUE;
805 #define MAX_CLIQUELENGTH 50 850 assert(objchg !=
NULL);
851 assert(contributors !=
NULL);
852 assert(ncontributors !=
NULL);
853 assert(*ncontributors == 0);
864 for( c = 0; c < nbinobjvars; ++c )
865 assert(collectedvars[c] ==
FALSE);
869 for( c = 0; c < ncliques; ++c )
873 assert(uselesscliques !=
NULL);
876 assert(clique !=
NULL);
894 for( v = 0; v < nbinvars; ++v )
897 assert(implvar !=
NULL);
915 (*objchg) +=
collectMinactImplicVar(scip, implvar, binobjvarmap, collectedvars, nbinobjvars, contributors, ncontributors);
984 while( v < nbinvars )
986 implvar = objimplics->
objvars[v];
987 assert(implvar !=
NULL);
1047 assert(contributors !=
NULL);
1048 assert(ncontributors !=
NULL);
1053 (*ncontributors) = 0;
1113 assert(scip !=
NULL);
1118 assert(objchg !=
NULL);
1159 assert(cliques !=
NULL);
1162 for( c = ncliques - 1; c >= 0; --c )
1164 clique = cliques[c];
1168 assert(nclqvars > 0);
1169 assert(clqvars !=
NULL);
1170 assert(clqvalues !=
NULL);
1176 for( v = nclqvars - 1; v >= 0; --v )
1178 clqvar = clqvars[v];
1179 assert(clqvar !=
NULL);
1182 assert(-1 <= objmult && objmult <= 1);
1189 assert(0 < probindex && probindex < nentries);
1192 assert(entries[probindex] == 0 || entries[probindex] == objmult);
1193 if( entries[probindex] == 0 )
1196 ids[nids] = probindex;
1199 assert(ABS(objmult) == 1);
1202 entries[probindex] = objmult;
1209 assert(probvars !=
NULL);
1212 for( v = nids - 1; v >= 0; --v )
1215 assert(0 <
id &&
id < nentries);
1216 assert(entries[
id] != 0);
1218 clqvar = probvars[
id - 1];
1219 assert(clqvar !=
NULL);
1228 *objchg += entries[id] * obj;
1236 #ifdef SCIP_MORE_DEBUG 1238 varfixing, *objchg);
1259 for( v = nvars - 1; v >= 0; --v )
1262 assert(implvar !=
NULL);
1274 *objchg += (bounds[v] - lb)*obj;
1276 *objchg += (bounds[v] - ub)*obj;
1280 #ifdef SCIP_MORE_DEBUG 1281 SCIPdebugMsg(scip,
"objective contribution when variable <%s> fixed to %u using cliques and implications is %g\n",
SCIPvarGetName(var),
1282 varfixing, *objchg);
1300 assert(scip !=
NULL);
1302 assert(objchg !=
NULL);
1332 for( c = 0; c < ncontributors; ++c )
1334 var = contributors[c];
1335 assert(var !=
NULL);
1340 collectedvars[pos] =
FALSE;
1366 assert(objimplics !=
NULL);
1369 (*objimplics) =
NULL;
1380 if( useimplics && nlbcliques + nubcliques > 0 )
1382 int nlbcontributors;
1383 int nubcontributors;
1390 contributors, uselesscliques, &nlbcontributors, &lbobjchg) );
1399 if( !(*collect) && nlbcontributors == 1 )
1402 resetContributors(binobjvarmap, collectedlbvars, contributors, nlbcontributors);
1405 nlbcontributors = 0;
1410 &contributors[nlbcontributors], uselesscliques, &nubcontributors, &ubobjchg) );
1419 if( !(*collect) && nubcontributors == 1 )
1422 resetContributors(binobjvarmap, collectedubvars, &contributors[nlbcontributors], nubcontributors);
1425 nubcontributors = 0;
1428 if( (*collect) || nlbcontributors > 1 || nubcontributors > 1 )
1433 SCIP_CALL(
objimplicsCreate(scip, objimplics, contributors, binobjvarmap, collectedlbvars, collectedubvars, lbobjchg, ubobjchg, nlbcontributors, nubcontributors) );
1439 resetContributors(binobjvarmap, collectedlbvars, contributors, nlbcontributors);
1442 resetContributors(binobjvarmap, collectedubvars, &contributors[nlbcontributors], nubcontributors);
1445 else if( (*collect) )
1473 assert(scip !=
NULL);
1475 assert(objchg !=
NULL);
1476 assert(isnotzero !=
NULL);
1486 (*objchg) =
MIN(lbobjchg, ubobjchg);
1518 assert(scip !=
NULL);
1519 assert(propdata !=
NULL);
1533 for( v = 0; v < nvars; ++v )
1536 assert(var !=
NULL);
1571 eventhdlr = propdata->eventhdlr;
1572 assert(eventhdlr !=
NULL);
1574 useimplics = (propdata->propuseimplics && nbinobjvars < propdata->maximplvars);
1577 propdata->minactsize = nbinvars;
1578 propdata->maxactsize = nbinvars;
1579 propdata->objintvarssize = nobjvars - nbinobjvars;
1603 cliqueGetHashkey, cliqueIsHashkeyEq, cliqueGetHashkeyVal,
NULL) );
1606 uselesscliques =
NULL;
1610 contributors =
NULL;
1611 collectedlbvars =
NULL;
1612 collectedubvars =
NULL;
1613 uselesscliques =
NULL;
1619 for( v = 0; v < nvars && (nobjintvars == 0 || nobjintvars < propdata->objintvarssize); ++v )
1622 assert(var !=
NULL);
1640 nbinobjvars, contributors, uselesscliques, &collect) );
1644 assert(nminactvars < nbinvars);
1645 assert(objimplics !=
NULL);
1649 propdata->minactvars[nminactvars] = var;
1650 propdata->minactimpls[nminactvars] = objimplics;
1656 SCIPdebugMsg(scip,
"variable <%s>[obj: <%g>] implicit objective change %g\n",
1667 assert(nmaxactvars < nbinvars);
1670 propdata->maxactvars[nmaxactvars] = var;
1671 propdata->maxactchgs[nmaxactvars] = -objchg;
1689 assert(nobjintvars < propdata->objintvarssize);
1691 propdata->objintvars[nobjintvars] = var;
1709 if( uselesscliques !=
NULL )
1717 if( nminactvars == 0 )
1721 propdata->minactsize = 0;
1722 propdata->minactvars =
NULL;
1723 propdata->minactimpls =
NULL;
1730 SCIPsortDownPtrPtr((
void**)propdata->minactimpls, (
void**)propdata->minactvars, objimplicsComp, nminactvars);
1732 SCIPdebugMsg(scip,
"%d binary variables with non-zero objective contribution w.r.t. the minimum activity of the objective function\n", nminactvars);
1735 if( nmaxactvars == 0 )
1739 propdata->maxactsize = 0;
1740 propdata->maxactvars =
NULL;
1741 propdata->maxactchgs =
NULL;
1750 SCIPdebugMsg(scip,
"%d binary variables with non-zero objective contribution w.r.t. the maximum activity of the objective function\n", nmaxactvars);
1753 if( nobjintvars == 0 )
1756 propdata->objintvarssize = 0;
1757 propdata->objintvars =
NULL;
1762 SCIPsortDownPtr((
void**)propdata->objintvars, varCompObj, nobjintvars - nobjcontvars);
1765 SCIPsortDownPtr((
void**)(&propdata->objintvars[nobjintvars - nobjcontvars]), varCompObj, nobjcontvars);
1767 SCIPdebugMsg(scip,
"%d integer variables and %d continuous variables with non-zero objective contribution\n",
1768 nobjintvars - nobjcontvars, nobjcontvars);
1774 propdata->nminactvars = nminactvars;
1775 propdata->nmaxactvars = nmaxactvars;
1776 propdata->nobjintvars = nobjintvars;
1778 propdata->maxpseudoobjactinf = 0;
1779 propdata->lastvarnum = -1;
1780 propdata->glbfirstnonfixed = 0;
1781 propdata->maxactfirstnonfixed = 0;
1782 propdata->firstnonfixed = 0;
1783 propdata->nnewvars = 0;
1788 propdata->initialized =
TRUE;
1791 propdata->glbpropagated =
FALSE;
1797 if( nminactvars > 0 )
1800 SCIPvarGetHashkey, SCIPvarIsHashkeyEq, SCIPvarGetHashkeyVal,
NULL) );
1803 propdata->addedvars =
NULL;
1839 assert((loclb - glblb) * objval > 0.0);
1841 (*reqpseudoobjval) -= (loclb - glblb) * objval;
1860 assert((locub - glbub) * objval > 0.0);
1862 (*reqpseudoobjval) -= (locub - glbub) * objval;
1887 assert(foundimplics !=
NULL);
1888 assert(*foundimplics ==
FALSE);
1890 for( v = start; v < end; ++v )
1893 assert(var !=
NULL);
1909 (*foundimplics) =
TRUE;
1942 foundimplics =
FALSE;
1947 if( respropuseimplics )
1950 bdchgidx, addedvars, reqpseudoobjval, &foundimplics) );
1961 (*reqpseudoobjval) -=
MAX(0.0, objval);
1963 if( addedvars !=
NULL )
1972 if( respropuseimplics )
1975 bdchgidx, addedvars, reqpseudoobjval, &foundimplics) );
1986 (*reqpseudoobjval) +=
MIN(0.0, objval);
1988 if( addedvars !=
NULL )
2015 if( inferinfo != -1 )
2022 assert(var !=
NULL);
2024 assert(bdchgidx !=
NULL);
2026 assert(inferinfo >= 0);
2027 assert(inferinfo < propdata->nminactvars);
2031 objimplics = propdata->minactimpls[inferinfo];
2032 assert(objimplics !=
NULL);
2036 foundimplics =
FALSE;
2087 (*cutoffbound) -= objval * (newbound - glbbound);
2119 nvars = propdata->nminactvars;
2134 reqpseudoobjval = cutoffbound;
2143 addedvars = propdata->addedvars;
2147 if( infervar !=
NULL )
2152 reqpseudoobjval = cutoffbound - glbpseudoobjval;
2155 SCIPdebugMsg(scip,
"resolve propagation global pseudo objective <%g>, cutoff bounda <%g>, required minactivity <%g>\n",
2156 glbpseudoobjval, cutoffbound, reqpseudoobjval);
2171 vars = propdata->minactvars;
2172 assert(vars !=
NULL);
2174 minactimpls = propdata->minactimpls;
2175 assert(minactimpls !=
NULL);
2187 for( v = propdata->glbfirstnonfixed; v < nvars; ++v )
2190 assert(var !=
NULL);
2194 if( var == infervar )
2202 assert(addedvars !=
NULL);
2204 for( v = propdata->glbfirstnonfixed; v < nvars &&
SCIPisPositive(scip, reqpseudoobjval); ++v )
2207 assert(var !=
NULL);
2211 if( var == infervar )
2217 SCIP_CALL(
addConflictBinvar(scip, var, bdchgidx, minactimpls[v], addedvars, propdata->respropuseimplics, &reqpseudoobjval) );
2222 vars = propdata->objintvars;
2223 nvars = propdata->nobjintvars;
2224 assert(nvars == 0 || vars !=
NULL);
2227 for( v = 0; v < nvars && (infinity ||
SCIPisPositive(scip, reqpseudoobjval)); ++v )
2230 assert(var !=
NULL);
2233 if( var == infervar )
2264 assert(
SCIPisLT(scip, pseudoobjval, cutoffbound) );
2265 assert(tightened !=
NULL);
2272 assert(prop !=
NULL);
2288 newbd = lb + (cutoffbound - pseudoobjval) / objchg;
2293 assert(!infeasible);
2297 SCIPdebugMsg(scip,
" -> new (local) upper bound of variable <%s>[%g,%g]: %g, objective change <%g>, pseudo objective <%g>, cutoff bound <%g>\n",
2298 SCIPvarGetName(var), lb, ub, newbd, objchg, pseudoobjval, cutoffbound);
2304 assert(!infeasible);
2308 SCIPdebugMsg(scip,
" -> new (global) upper bound of variable <%s>[%g,%g]: %g, objective change <%g>, pseudo objective <%g>, cutoff bound <%g>\n",
2309 SCIPvarGetName(var), lb, ub, newbd, objchg, pseudoobjval, cutoffbound);
2315 newbd = ub + (cutoffbound - pseudoobjval) / objchg;
2320 assert(!infeasible);
2324 SCIPdebugMsg(scip,
" -> new (local) lower bound of variable <%s>[%g,%g]: %g, objective change <%g>, pseudo objective <%g>, cutoff bound <%g>\n",
2325 SCIPvarGetName(var), lb, ub, newbd, objchg, pseudoobjval, cutoffbound);
2331 assert(!infeasible);
2335 SCIPdebugMsg(scip,
" -> new (global) lower bound of variable <%s>[%g,%g]: %g, objective change <%g>, pseudo objective <%g>, cutoff bound <%g>\n",
2336 SCIPvarGetName(var), lb, ub, newbd, objchg, pseudoobjval, cutoffbound);
2367 assert(propdata !=
NULL);
2369 objimplics = propdata->minactimpls[pos];
2370 assert(objimplics !=
NULL);
2380 (*tightened) =
FALSE;
2393 if(
SCIPisFeasLT(scip, cutoffbound, pseudoobjval + ubobjchg) &&
SCIPisFeasLT(scip, cutoffbound, pseudoobjval + lbobjchg) )
2415 if( lbobjchg > ubobjchg )
2454 assert(propdata !=
NULL);
2457 cutoffbound = propdata->cutoffbound;
2466 if(
SCIPisGE(scip, pseudoobjval, cutoffbound) )
2472 minactvars = propdata->minactvars;
2473 objintvars = propdata->objintvars;
2474 nminactvars = propdata->nminactvars;
2475 nobjintvars = propdata->nobjintvars;
2484 for( v = propdata->glbfirstnonfixed; v < nminactvars; ++v )
2486 var = minactvars[v];
2487 assert(var !=
NULL);
2503 SCIPdebugMsg(scip,
"interrupt global pseudo objective propagation w.r.t. cutoff bound <%.15g> for binary variables after %d from %d binary variables\n",
2504 cutoffbound, v, nminactvars);
2517 propdata->glbfirstnonfixed = v;
2518 propdata->firstnonfixed =
MAX(propdata->firstnonfixed, v);
2521 for( ; v < nminactvars && cutoffbound - pseudoobjval < propdata->minactimpls[v]->maxobjchg; ++v )
2523 var = minactvars[v];
2524 assert(var !=
NULL);
2544 for( ; v < nminactvars; ++v )
2546 assert(cutoffbound - pseudoobjval >= propdata->minactimpls[v]->maxobjchg);
2548 var = minactvars[v];
2549 assert(var !=
NULL);
2566 for( v = 0; v < nobjintvars; ++v )
2568 var = objintvars[v];
2569 assert(var !=
NULL);
2580 propdata->glbpropagated =
TRUE;
2604 assert(propdata !=
NULL);
2606 minactvars = propdata->minactvars;
2607 nminactvars = propdata->nminactvars;
2608 assert(nminactvars == 0 || minactvars !=
NULL);
2619 for( v = propdata->glbfirstnonfixed; v < propdata->firstnonfixed; ++v )
2621 var = minactvars[v];
2622 assert(var !=
NULL);
2630 for( v = propdata->firstnonfixed; v < nminactvars; ++v )
2632 var = minactvars[v];
2633 assert(var !=
NULL);
2652 SCIPdebugMsg(scip,
"interrupt local pseudo objective propagation w.r.t. cutoff bound <%.15g> for binary variables after %d from %d binary variables\n",
2653 cutoffbound, v, nminactvars);
2664 propdata->firstnonfixed = v;
2667 for( ; v < nminactvars && cutoffbound - pseudoobjval < propdata->minactimpls[v]->maxobjchg; ++v )
2669 var = minactvars[v];
2670 assert(var !=
NULL);
2694 for( ; v < nminactvars; ++v )
2696 var = minactvars[v];
2697 assert(var !=
NULL);
2699 assert(cutoffbound - pseudoobjval >= propdata->minactimpls[v]->maxobjchg);
2733 assert(result !=
NULL);
2738 assert(propdata !=
NULL);
2756 if( cutoffbound < propdata->cutoffbound )
2758 propdata->glbpropagated =
FALSE;
2759 propdata->cutoffbound = cutoffbound;
2771 if( propdata->propcutoffbound && !propdata->glbpropagated &&
SCIPgetDepth(scip) > 0 )
2796 if(
SCIPisGE(scip, pseudoobjval, cutoffbound) )
2798 SCIPdebugMsg(scip,
"pseudo objective value <%g> exceeds cutoff bound <%g>\n", pseudoobjval, cutoffbound);
2819 SCIPdebugMsg(scip,
"propagating pseudo objective function (pseudoobj: %g, cutoffbound: %g)\n", pseudoobjval, cutoffbound);
2833 if( propdata->propfullinroot &&
SCIPgetDepth(scip) == 0 )
2841 objintvars = propdata->objintvars;
2842 nobjintvars = propdata->nobjintvars;
2843 assert(nobjintvars == 0 || objintvars !=
NULL);
2846 for( v = 0; v < nobjintvars; ++v )
2848 var = objintvars[v];
2849 assert(var !=
NULL);
2873 objintvars = propdata->objintvars;
2874 nobjintvars = propdata->nobjintvars;
2875 assert(nobjintvars == 0 || objintvars !=
NULL);
2878 nmaxuseless =
MAX(propdata->minuseless, (
int)propdata->maxvarsfrac*(nobjintvars));
2881 v = propdata->lastvarnum;
2883 for( c = 0; c < nobjintvars && nuseless < nmaxuseless; ++c )
2886 if( v >= nobjintvars )
2889 var = objintvars[v];
2890 assert(var !=
NULL);
2904 propdata->lastvarnum = v;
2927 assert(propdata !=
NULL);
2934 propdata->maxpseudoobjact = 0.0;
2935 propdata->maxpseudoobjactinf = 0;
2937 for( v = 0; v < nvars; ++v )
2958 propdata->maxpseudoobjactinf++;
2960 propdata->maxpseudoobjact += contrib;
2971 assert(propdata !=
NULL);
2989 assert(propdata !=
NULL);
2998 assert(propdata->maxpseudoobjactinf >= 1);
3000 if( propdata->maxpseudoobjactinf == 1 )
3001 residual = propdata->maxpseudoobjact;
3008 if( propdata->maxpseudoobjactinf >= 1 )
3011 residual = propdata->maxpseudoobjact - contrib;
3028 assert(propdata !=
NULL);
3076 assert(
SCIPisLE(scip, lowerbound, maxpseudoobjact));
3091 (*infeasible) =
FALSE;
3092 (*tightened) =
FALSE;
3097 if(
SCIPisFeasLT(scip, maxpseudoobjact + lbobjchg, lowerbound) &&
SCIPisFeasLT(scip, maxpseudoobjact + ubobjchg, lowerbound) )
3102 (*infeasible) =
TRUE;
3104 else if(
SCIPisFeasLT(scip, maxpseudoobjact + lbobjchg, lowerbound) )
3108 else if(
SCIPisFeasLT(scip, maxpseudoobjact + ubobjchg, lowerbound) )
3136 (*tightened) =
FALSE;
3145 newbd = (lowerbound - residual) / objval;
3197 assert(result !=
NULL);
3204 assert(propdata !=
NULL);
3205 assert(propdata->nminactvars > 0 || propdata->nobjintvars > 0);
3216 if(
SCIPisLE(scip, lowerbound, propdata->lastlowerbound) && propdata->maxpseudoobjact <
SCIP_INVALID )
3224 if( propdata->maxpseudoobjactinf > 1 )
3236 if(
SCIPisLT(scip, maxpseudoobjact, lowerbound) )
3246 if( propdata->maxpseudoobjactinf == 0 && !
SCIPisInfinity(scip, maxpseudoobjact) )
3251 maxactvars = propdata->maxactvars;
3252 nmaxactvars = propdata->nmaxactvars;
3253 assert(nmaxactvars == 0 || maxactvars !=
NULL);
3255 for( v = propdata->maxactfirstnonfixed; v < nmaxactvars; ++v )
3257 var = maxactvars[v];
3258 assert(var !=
NULL);
3280 SCIPdebugMsg(scip,
"interrupt pseudo objective propagation w.r.t. lower bound <%.15g> for binary variables after %d from %d binary variables\n",
3281 lowerbound, v, nmaxactvars);
3296 propdata->maxactfirstnonfixed = v;
3299 for( ; v < nmaxactvars && maxpseudoobjact - lowerbound < propdata->maxactchgs[v] && !cutoff; ++v )
3301 var = maxactvars[v];
3302 assert(var !=
NULL);
3325 for( ; v < nmaxactvars && !cutoff; ++v )
3327 var = maxactvars[v];
3328 assert(var !=
NULL);
3344 objintvars = propdata->objintvars;
3345 nobjintvars = propdata->nobjintvars;
3346 assert(nobjintvars == 0 || objintvars !=
NULL);
3349 for( v = 0; v < nobjintvars && !cutoff; ++v )
3351 var = objintvars[v];
3352 assert(var !=
NULL);
3370 else if( nchgbds > 0 )
3374 propdata->lastlowerbound = lowerbound;
3388 assert(scip !=
NULL);
3389 assert(prop !=
NULL);
3420 assert(propdata !=
NULL);
3429 assert(!propdata->catchvaradded);
3431 propdata->catchvaradded =
TRUE;
3444 assert(propdata !=
NULL);
3446 if( propdata->catchvaradded )
3450 propdata->catchvaradded =
FALSE;
3473 assert(result !=
NULL);
3476 assert(propdata !=
NULL);
3496 if(
SCIPisGE(scip, pseudoobjval, cutoffbound) )
3503 if( cutoffbound < propdata->cutoffbound || pseudoobjval > propdata->glbpseudoobjval )
3509 oldnchgbds = *nchgbds;
3518 for( v = nvars - 1; v >= 0; --v )
3532 if( *nchgbds > oldnchgbds )
3536 propdata->cutoffbound = cutoffbound;
3537 propdata->glbpseudoobjval = pseudoobjval;
3538 propdata->glbpropagated =
TRUE;
3551 assert(propdata !=
NULL);
3570 if( !propdata->initialized || propdata->nnewvars > propdata->maxnewvars )
3580 if( propdata->nminactvars == 0 && propdata->nmaxactvars == 0 && propdata->nobjintvars == 0 )
3594 (*result) = dualresult;
3610 assert(propdata !=
NULL);
3614 assert(infervar !=
NULL);
3643 assert(eventhdlr !=
NULL);
3644 assert(eventdata !=
NULL);
3646 assert(event !=
NULL);
3655 propdata->firstnonfixed = 0;
3658 propdata->nnewvars++;
3665 propdata->maxpseudoobjactinf = 0;
3691 propdata->eventhdlr =
NULL;
3694 eventExecPseudoobj,
NULL) );
3696 if( propdata->eventhdlr ==
NULL )
3698 SCIPerrorMessage(
"event handler for pseudo objective propagator not found\n");
3706 assert(prop !=
NULL);
3719 "minimal number of successive non-binary variable propagator whithout a bound reduction before aborted",
3723 "propagating/" PROP_NAME "/maxvarsfrac",
3724 "maximal fraction of non-binary variables with non-zero objective without a bound reduction before aborted",
3728 "propagating/" PROP_NAME "/propfullinroot",
3729 "do we want to propagate all non-binary variables if we are propagating the root node",
3733 "propagating/" PROP_NAME "/propcutoffbound",
3734 "propagate new cutoff bound directly globally",
3739 "should the propagator be forced even if active pricer are present?",
3744 "number of variable added after the propgatore is reinitialized?",
3748 "propagating/" PROP_NAME "/propuseimplics",
3749 "use implications to strengthen the propagation of binary variable (increasing the objective change)?",
3753 "propagating/" PROP_NAME "/respropuseimplics",
3754 "use implications to strengthen the resolve propagation of binary variable (increasing the objective change)?",
3758 "propagating/" PROP_NAME "/maximplvars",
3759 "maximum number of binary variables the implications are used if turned on (-1: unlimited)?",
enum SCIP_Result SCIP_RESULT
SCIP_RETCODE SCIPsetPropPresol(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPPRESOL((*proppresol)), int presolpriority, int presolmaxrounds, SCIP_PRESOLTIMING presoltiming)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
enum SCIP_BoundType SCIP_BOUNDTYPE
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 SCIP_RETCODE getMinactImplicObjchg(SCIP *scip, SCIP_VAR *var, SCIP_OBJIMPLICS *objimplics, SCIP_BDCHGIDX *bdchgidx, SCIP_BOUNDTYPE bound, SCIP_Bool local, SCIP_Real *objchg)
SCIP_BOUNDTYPE SCIPvarGetWorstBoundType(SCIP_VAR *var)
SCIP_Real SCIPfeastol(SCIP *scip)
SCIP_Bool SCIPvarsHaveCommonClique(SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)
SCIP_VAR ** SCIPcliqueGetVars(SCIP_CLIQUE *clique)
#define SCIPallocBlockMemoryArray(scip, ptr, num)
SCIP_Real SCIPgetVarUbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_STAGE SCIPgetStage(SCIP *scip)
SCIP_Bool SCIPisFeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPgetVarLbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_RETCODE SCIPhashtableInsert(SCIP_HASHTABLE *hashtable, void *element)
SCIP_RETCODE SCIPcatchVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
SCIP_Real SCIPgetCutoffbound(SCIP *scip)
#define SCIPallocClearBufferArray(scip, ptr, num)
Pseudo objective propagator.
static SCIP_RETCODE propagateLowerbound(SCIP *scip, SCIP_PROP *prop, SCIP_RESULT *result)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
static SCIP_RETCODE propdataExit(SCIP *scip, SCIP_PROPDATA *propdata)
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)
SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)
static SCIP_DECL_PROPINITSOL(propInitsolPseudoobj)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_Bool SCIPisGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_CLIQUE ** SCIPvarGetCliques(SCIP_VAR *var, SCIP_Bool varfixing)
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)
SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
#define DEFAULT_MAXNEWVARS
void SCIPsortDownRealPtr(SCIP_Real *realarray, void **ptrarray, int len)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
#define DEFAULT_PROPCUTOFFBOUND
static void updateMaxObjPseudoactivity(SCIP *scip, SCIP_PROPDATA *propdata)
SCIP_Bool SCIPisFeasGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
#define SCIP_PROPTIMING_DURINGLPLOOP
SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)
const char * SCIPeventhdlrGetName(SCIP_EVENTHDLR *eventhdlr)
int SCIPgetNActivePricers(SCIP *scip)
#define DEFAULT_MINUSELESS
static SCIP_DECL_SORTPTRCOMP(objimplicsComp)
SCIP_RETCODE SCIPcutoffNode(SCIP *scip, SCIP_NODE *node)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
enum SCIP_Retcode SCIP_RETCODE
SCIP_RETCODE SCIPaddConflictUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
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 getMaxactObjchg(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE bound, SCIP_Bool useimplics, SCIP_Real *objchg)
int SCIPvarGetProbindex(SCIP_VAR *var)
#define SCIP_EVENTTYPE_GLBCHANGED
SCIP_RETCODE SCIPinitConflictAnalysis(SCIP *scip, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
#define SCIPfreeBlockMemory(scip, ptr)
void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
#define SCIPfreeBufferArray(scip, ptr)
static SCIP_RETCODE propagateCutoffbound(SCIP *scip, SCIP_PROP *prop, SCIP_RESULT *result)
#define SCIPallocBlockMemory(scip, ptr)
SCIP_Bool SCIPisTransformed(SCIP *scip)
SCIP_NODE * SCIPgetRootNode(SCIP *scip)
static void resetContributors(SCIP_HASHMAP *binobjvarmap, SCIP_Bool *collectedvars, SCIP_VAR **contributors, int ncontributors)
static SCIP_Real getMaxObjPseudoactivityResidual(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_VAR *var)
#define SCIPdebugMsgPrint
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 SCIPpropagateCutoffboundVar(SCIP *scip, SCIP_PROP *prop, SCIP_VAR *var, SCIP_Real cutoffbound, SCIP_Real pseudoobjval, SCIP_Bool *tightened)
int SCIPvarGetNCliques(SCIP_VAR *var, SCIP_Bool varfixing)
int SCIPgetNContVars(SCIP *scip)
SCIP_RETCODE SCIPaddConflictLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
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)
SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)
#define SCIP_EVENTTYPE_LBRELAXED
#define PROP_PRESOLTIMING
SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)
static SCIP_RETCODE addConflictBounds(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real *reqpseudoobjval)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
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 objimplicsDelPos(SCIP *scip, SCIP_OBJIMPLICS *objimplics, int pos)
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)
int SCIPgetCutoffdepth(SCIP *scip)
static SCIP_RETCODE getMaxactImplicObjchg(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE bound, SCIP_Real *objchg)
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
void SCIPsortDownPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
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)
struct SCIP_EventData SCIP_EVENTDATA
const char * SCIPvarGetName(SCIP_VAR *var)
static SCIP_DECL_PROPPRESOL(propPresolPseudoobj)
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
SCIP_RETCODE SCIPtightenVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
#define PROP_PRESOL_MAXROUNDS
void SCIPsortDownPtrPtr(void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
#define SCIP_EVENTTYPE_UBRELAXED
#define DEFAULT_PROPUSEIMPLICS
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 dropObjEvent(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_EVENTHDLR *eventhdlr, SCIP_VAR *var)
SCIP_Real SCIPgetLowerbound(SCIP *scip)
SCIP_Bool SCIPisFeasGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
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)
static SCIP_DECL_PROPCOPY(propCopyPseudoobj)
void SCIPhashtableRemoveAll(SCIP_HASHTABLE *hashtable)
SCIP_Bool SCIPisFeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
static SCIP_RETCODE objimplicsFree(SCIP *scip, SCIP_OBJIMPLICS **objimplics)
static SCIP_DECL_PROPFREE(propFreePseudoobj)
static SCIP_RETCODE propagateCutoffboundGlobally(SCIP *scip, SCIP_PROP *prop, int *nchgbds, SCIP_Bool *cutoff)
#define SCIPallocBufferArray(scip, ptr, num)
SCIP_BOUNDTYPE * SCIPvarGetImplTypes(SCIP_VAR *var, SCIP_Bool varfixing)
static SCIP_DECL_PROPEXITSOL(propExitsolPseudoobj)
SCIP_RETCODE SCIPcatchEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
static SCIP_DECL_PROPRESPROP(propRespropPseudoobj)
static SCIP_RETCODE getMinactObjchg(SCIP *scip, SCIP_VAR *var, SCIP_OBJIMPLICS *objimplics, SCIP_BDCHGIDX *bdchgidx, SCIP_BOUNDTYPE bound, SCIP_Bool local, SCIP_Real *objchg)
SCIP_EVENTTYPE SCIPeventGetType(SCIP_EVENT *event)
static SCIP_Real getMaxObjPseudoactivityResidualValue(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_Real contrib)
#define DEFAULT_PROPFULLINROOT
static void calcMaxObjPseudoactivity(SCIP *scip, SCIP_PROPDATA *propdata)
static SCIP_RETCODE propdataInit(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_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 propagateCutoffboundBinvars(SCIP *scip, SCIP_PROP *prop, SCIP_Real cutoffbound, SCIP_Real pseudoobjval, int *nfixedvars, SCIP_Bool *cutoff)
int SCIPgetDepth(SCIP *scip)
int SCIPvarGetNImpls(SCIP_VAR *var, SCIP_Bool varfixing)
int SCIPvarGetNLocksUp(SCIP_VAR *var)
static SCIP_Real getVarObjchg(SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BOUNDTYPE bound)
int SCIPvarCompare(SCIP_VAR *var1, SCIP_VAR *var2)
SCIP_Bool * SCIPcliqueGetValues(SCIP_CLIQUE *clique)
SCIP_RETCODE SCIPdropEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
static SCIP_DECL_HASHKEYEQ(cliqueIsHashkeyEq)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_RETCODE SCIPsetPropCopy(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPCOPY((*propcopy)))
SCIP_RETCODE SCIPdropVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
int SCIPgetNObjVars(SCIP *scip)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
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)
SCIP_Real * SCIPvarGetImplBounds(SCIP_VAR *var, SCIP_Bool varfixing)
static void checkImplicsApplied(SCIP *scip, SCIP_VAR *var)
static SCIP_RETCODE catchObjEvent(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_EVENTHDLR *eventhdlr, SCIP_VAR *var)
SCIP_RETCODE SCIPsetPropExitsol(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPEXITSOL((*propexitsol)))
SCIP_Bool SCIPinProbing(SCIP *scip)
const char * SCIPpropGetName(SCIP_PROP *prop)
#define DEFAULT_RESPROPUSEIMPLICS
void SCIPhashtableFree(SCIP_HASHTABLE **hashtable)
int SCIPgetNVars(SCIP *scip)
static SCIP_Real collectMinactImplicVar(SCIP *scip, SCIP_VAR *var, SCIP_HASHMAP *binobjvarmap, SCIP_Bool *collectedvars, int nbinobjvars, SCIP_VAR **contributors, int *ncontributors)
SCIP_VAR ** SCIPvarGetImplVars(SCIP_VAR *var, SCIP_Bool varfixing)
int SCIPvarGetNLocksDown(SCIP_VAR *var)
SCIP_RETCODE SCIPsetPropResprop(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPRESPROP((*propresprop)))
#define DEFAULT_MAXVARSFRAC
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
#define PROP_PRESOL_PRIORITY
SCIP_RETCODE SCIPincludePropPseudoobj(SCIP *scip)
int SCIPgetNCliques(SCIP *scip)
SCIP_VAR ** SCIPgetVars(SCIP *scip)
SCIP_RETCODE SCIPsetPropInitsol(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPINITSOL((*propinitsol)))
static SCIP_DECL_HASHKEYVAL(cliqueGetHashkeyVal)
static void propdataReset(SCIP *scip, SCIP_PROPDATA *propdata)
SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
struct SCIP_PropData SCIP_PROPDATA
SCIP_Real SCIPgetGlobalPseudoObjval(SCIP *scip)
static SCIP_RETCODE propagateLowerboundVar(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_VAR *var, SCIP_Real lowerbound, SCIP_Bool *infeasible, SCIP_Bool *tightened)
static SCIP_DECL_HASHGETKEY(cliqueGetHashkey)
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)
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)
SCIP_BOUNDTYPE SCIPvarGetBestBoundType(SCIP_VAR *var)
SCIP_Bool SCIPhashtableExists(SCIP_HASHTABLE *hashtable, void *element)
static SCIP_DECL_EVENTEXEC(eventExecPseudoobj)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
static void checkGlbfirstnonfixed(SCIP *scip, SCIP_PROPDATA *propdata)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)
int SCIPcliqueGetNVars(SCIP_CLIQUE *clique)
SCIP_RETCODE SCIPtightenVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
static SCIP_RETCODE dropVarEvents(SCIP *scip, SCIP_PROPDATA *propdata)
SCIP_RETCODE SCIPhashmapInsert(SCIP_HASHMAP *hashmap, void *origin, void *image)
#define BMSclearMemoryArray(ptr, num)
SCIP_Real SCIPgetPseudoObjval(SCIP *scip)
#define SCIP_EVENTTYPE_GUBCHANGED
static SCIP_DECL_PROPEXEC(propExecPseudoobj)
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
#define SCIP_EVENTTYPE_VARADDED
#define DEFAULT_MAXIMPLVARS
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 SCIPanalyzeConflict(SCIP *scip, int validdepth, SCIP_Bool *success)
SCIP_Bool SCIPallowObjProp(SCIP *scip)
static SCIP_Real getMaxObjPseudoactivity(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)
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_Bool SCIPvarIsActive(SCIP_VAR *var)
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)
int SCIPcliqueGetId(SCIP_CLIQUE *clique)
#define SCIP_EVENTTYPE_BOUNDRELAXED