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 )
342 assert(scip != NULL);
343 assert(objimplics != NULL);
350 if( nlbimpls + nubimpls == 0 )
352 assert(nlbimpls == 0);
353 assert(nubimpls == 0);
354 (*objimplics)->objvars = NULL;
355 (*objimplics)->maxobjchg = 0.0;
356 (*objimplics)->nlbimpls = 0;
357 (*objimplics)->nubimpls = 0;
358 (*objimplics)->size = 0;
367 assert(objvars != NULL);
368 assert(binobjvarmap != NULL);
369 assert(collectedlbvars != NULL);
370 assert(collectedubvars != NULL);
373 (*objimplics)->size = nlbimpls +
nubimpls;
386 assert(collectedlbvars[pos]);
388 if( collectedubvars[pos] )
412 (*objimplics)->objvars[nvars] = var;
415 collectedlbvars[pos] =
FALSE;
417 (*objimplics)->nlbimpls = nvars;
421 var = objvars[nlbimpls + v];
428 assert(collectedubvars[pos]);
439 (*objimplics)->objvars[nvars] = var;
442 collectedubvars[pos] =
FALSE;
444 (*objimplics)->nubimpls = nvars - (*objimplics)->nlbimpls;
447 for( v = 0; v < nvars; ++v )
455 (*objimplics)->maxobjchg =
MAX(maxlbobjchg, maxubobjchg);
469 assert(scip != NULL);
470 assert(objimplics != NULL);
471 assert(*objimplics != NULL);
474 for( v = 0; v < (*objimplics)->nlbimpls + (*objimplics)->nubimpls; ++v )
550 assert(propdata != NULL);
551 assert(eventhdlr != NULL);
581 assert(propdata != NULL);
582 assert(eventhdlr != NULL);
612 assert(scip != NULL);
613 assert(propdata != NULL);
615 eventhdlr = propdata->eventhdlr;
616 assert(eventhdlr != NULL);
619 for( k = 0; k < propdata->nminactvars; ++k )
621 var = propdata->minactvars[k];
635 for( k = 0; k < propdata->nmaxactvars; ++k )
637 var = propdata->maxactvars[k];
649 for( k = 0; k < propdata->nobjintvars; ++k )
651 var = propdata->objintvars[k];
671 propdata->minactvars = NULL;
672 propdata->minactimpls = NULL;
673 propdata->maxactvars = NULL;
674 propdata->maxactchgs = NULL;
675 propdata->objintvars = NULL;
676 propdata->nminactvars = 0;
677 propdata->nmaxactvars = 0;
678 propdata->nobjintvars = 0;
680 propdata->maxpseudoobjactinf = 0;
681 propdata->lastvarnum = -1;
682 propdata->glbpropagated =
FALSE;
686 propdata->glbfirstnonfixed = 0;
687 propdata->maxactfirstnonfixed = 0;
688 propdata->firstnonfixed = 0;
689 propdata->nnewvars = 0;
690 propdata->minactsize = 0;
691 propdata->maxactsize = 0;
692 propdata->objintvarssize = 0;
693 propdata->catchvaradded =
FALSE;
694 propdata->initialized =
FALSE;
706 if( !propdata->initialized )
709 if( propdata->addedvars != NULL )
715 for( v = 0; v < propdata->nminactvars; ++v )
767 assert(scip != NULL);
769 assert(binobjvarmap != NULL);
770 assert(collectedvars != NULL);
771 assert(contributors != NULL);
772 assert(ncontributors != NULL);
789 if( collectedvars[pos] )
793 assert(*ncontributors < nbinobjvars);
794 contributors[*ncontributors] = var;
798 collectedvars[pos] =
TRUE;
804 #define MAX_CLIQUELENGTH 50 849 assert(objchg != NULL);
850 assert(contributors != NULL);
851 assert(ncontributors != NULL);
852 assert(*ncontributors == 0);
861 if( uselesscliques == NULL )
866 for( c = 0; c < nbinobjvars; ++c )
867 assert(collectedvars[c] ==
FALSE);
871 for( c = 0; c < ncliques; ++c )
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;
2049 if( addedvars != NULL )
2090 (*cutoffbound) -= objval * (newbound - glbbound);
2122 nvars = propdata->nminactvars;
2137 reqpseudoobjval = cutoffbound;
2146 addedvars = propdata->addedvars;
2150 if( infervar != NULL )
2155 reqpseudoobjval = cutoffbound - glbpseudoobjval;
2158 SCIPdebugMsg(scip,
"resolve propagation global pseudo objective <%g>, cutoff bounda <%g>, required minactivity <%g>\n",
2159 glbpseudoobjval, cutoffbound, reqpseudoobjval);
2174 vars = propdata->minactvars;
2175 assert(vars != NULL);
2177 minactimpls = propdata->minactimpls;
2178 assert(minactimpls != NULL);
2190 for( v = propdata->glbfirstnonfixed; v < nvars; ++v )
2193 assert(var != NULL);
2197 if( var == infervar )
2205 assert(addedvars != NULL);
2207 for( v = propdata->glbfirstnonfixed; v < nvars &&
SCIPisPositive(scip, reqpseudoobjval); ++v )
2210 assert(var != NULL);
2214 if( var == infervar )
2220 SCIP_CALL(
addConflictBinvar(scip, var, bdchgidx, minactimpls[v], addedvars, propdata->respropuseimplics, &reqpseudoobjval) );
2225 vars = propdata->objintvars;
2226 nvars = propdata->nobjintvars;
2227 assert(nvars == 0 || vars != NULL);
2230 for( v = 0; v < nvars && (infinity ||
SCIPisPositive(scip, reqpseudoobjval)); ++v )
2233 assert(var != NULL);
2236 if( var == infervar )
2267 assert(
SCIPisLT(scip, pseudoobjval, cutoffbound) );
2268 assert(tightened != NULL);
2275 assert(prop != NULL);
2291 newbd = lb + (cutoffbound - pseudoobjval) / objchg;
2296 assert(!infeasible);
2300 SCIPdebugMsg(scip,
" -> new (local) upper bound of variable <%s>[%g,%g]: %g, objective change <%g>, pseudo objective <%g>, cutoff bound <%g>\n",
2301 SCIPvarGetName(var), lb, ub, newbd, objchg, pseudoobjval, cutoffbound);
2307 assert(!infeasible);
2311 SCIPdebugMsg(scip,
" -> new (global) upper bound of variable <%s>[%g,%g]: %g, objective change <%g>, pseudo objective <%g>, cutoff bound <%g>\n",
2312 SCIPvarGetName(var), lb, ub, newbd, objchg, pseudoobjval, cutoffbound);
2318 newbd = ub + (cutoffbound - pseudoobjval) / objchg;
2323 assert(!infeasible);
2327 SCIPdebugMsg(scip,
" -> new (local) lower bound of variable <%s>[%g,%g]: %g, objective change <%g>, pseudo objective <%g>, cutoff bound <%g>\n",
2328 SCIPvarGetName(var), lb, ub, newbd, objchg, pseudoobjval, cutoffbound);
2334 assert(!infeasible);
2338 SCIPdebugMsg(scip,
" -> new (global) lower bound of variable <%s>[%g,%g]: %g, objective change <%g>, pseudo objective <%g>, cutoff bound <%g>\n",
2339 SCIPvarGetName(var), lb, ub, newbd, objchg, pseudoobjval, cutoffbound);
2370 assert(propdata != NULL);
2372 objimplics = propdata->minactimpls[pos];
2373 assert(objimplics != NULL);
2383 (*tightened) =
FALSE;
2396 if(
SCIPisFeasLT(scip, cutoffbound, pseudoobjval + ubobjchg) &&
SCIPisFeasLT(scip, cutoffbound, pseudoobjval + lbobjchg) )
2418 if( lbobjchg > ubobjchg )
2457 assert(propdata != NULL);
2460 cutoffbound = propdata->cutoffbound;
2469 if(
SCIPisGE(scip, pseudoobjval, cutoffbound) )
2475 minactvars = propdata->minactvars;
2476 objintvars = propdata->objintvars;
2477 nminactvars = propdata->nminactvars;
2478 nobjintvars = propdata->nobjintvars;
2487 for( v = propdata->glbfirstnonfixed; v < nminactvars; ++v )
2489 var = minactvars[v];
2490 assert(var != NULL);
2506 SCIPdebugMsg(scip,
"interrupt global pseudo objective propagation w.r.t. cutoff bound <%.15g> for binary variables after %d from %d binary variables\n",
2507 cutoffbound, v, nminactvars);
2520 propdata->glbfirstnonfixed = v;
2521 propdata->firstnonfixed =
MAX(propdata->firstnonfixed, v);
2524 for( ; v < nminactvars && cutoffbound - pseudoobjval < propdata->minactimpls[v]->maxobjchg; ++v )
2526 var = minactvars[v];
2527 assert(var != NULL);
2547 for( ; v < nminactvars; ++v )
2549 assert(cutoffbound - pseudoobjval >= propdata->minactimpls[v]->maxobjchg);
2551 var = minactvars[v];
2552 assert(var != NULL);
2569 for( v = 0; v < nobjintvars; ++v )
2571 var = objintvars[v];
2572 assert(var != NULL);
2583 propdata->glbpropagated =
TRUE;
2607 assert(propdata != NULL);
2609 minactvars = propdata->minactvars;
2610 nminactvars = propdata->nminactvars;
2611 assert(nminactvars == 0 || minactvars != NULL);
2622 for( v = propdata->glbfirstnonfixed; v < propdata->firstnonfixed; ++v )
2624 var = minactvars[v];
2625 assert(var != NULL);
2633 for( v = propdata->firstnonfixed; v < nminactvars; ++v )
2635 var = minactvars[v];
2636 assert(var != NULL);
2655 SCIPdebugMsg(scip,
"interrupt local pseudo objective propagation w.r.t. cutoff bound <%.15g> for binary variables after %d from %d binary variables\n",
2656 cutoffbound, v, nminactvars);
2667 propdata->firstnonfixed = v;
2670 for( ; v < nminactvars && cutoffbound - pseudoobjval < propdata->minactimpls[v]->maxobjchg; ++v )
2672 var = minactvars[v];
2673 assert(var != NULL);
2697 for( ; v < nminactvars; ++v )
2699 var = minactvars[v];
2700 assert(var != NULL);
2702 assert(cutoffbound - pseudoobjval >= propdata->minactimpls[v]->maxobjchg);
2736 assert(result != NULL);
2741 assert(propdata != NULL);
2759 if( cutoffbound < propdata->cutoffbound )
2761 propdata->glbpropagated =
FALSE;
2762 propdata->cutoffbound = cutoffbound;
2774 if( propdata->propcutoffbound && !propdata->glbpropagated &&
SCIPgetDepth(scip) > 0 )
2799 if(
SCIPisGE(scip, pseudoobjval, cutoffbound) )
2801 SCIPdebugMsg(scip,
"pseudo objective value <%g> exceeds cutoff bound <%g>\n", pseudoobjval, cutoffbound);
2822 SCIPdebugMsg(scip,
"propagating pseudo objective function (pseudoobj: %g, cutoffbound: %g)\n", pseudoobjval, cutoffbound);
2836 if( propdata->propfullinroot &&
SCIPgetDepth(scip) == 0 )
2844 objintvars = propdata->objintvars;
2845 nobjintvars = propdata->nobjintvars;
2846 assert(nobjintvars == 0 || objintvars != NULL);
2849 for( v = 0; v < nobjintvars; ++v )
2851 var = objintvars[v];
2852 assert(var != NULL);
2876 objintvars = propdata->objintvars;
2877 nobjintvars = propdata->nobjintvars;
2878 assert(nobjintvars == 0 || objintvars != NULL);
2881 nmaxuseless =
MAX(propdata->minuseless, (
int)propdata->maxvarsfrac*(nobjintvars));
2884 v = propdata->lastvarnum;
2886 for( c = 0; c < nobjintvars && nuseless < nmaxuseless; ++c )
2889 if( v >= nobjintvars )
2892 var = objintvars[v];
2893 assert(var != NULL);
2907 propdata->lastvarnum = v;
2930 assert(propdata != NULL);
2937 propdata->maxpseudoobjact = 0.0;
2938 propdata->maxpseudoobjactinf = 0;
2940 for( v = 0; v < nvars; ++v )
2961 propdata->maxpseudoobjactinf++;
2963 propdata->maxpseudoobjact += contrib;
2974 assert(propdata != NULL);
2992 assert(propdata != NULL);
3001 assert(propdata->maxpseudoobjactinf >= 1);
3003 if( propdata->maxpseudoobjactinf == 1 )
3004 residual = propdata->maxpseudoobjact;
3011 if( propdata->maxpseudoobjactinf >= 1 )
3014 residual = propdata->maxpseudoobjact - contrib;
3031 assert(propdata != NULL);
3094 (*infeasible) =
FALSE;
3095 (*tightened) =
FALSE;
3100 if(
SCIPisFeasLT(scip, maxpseudoobjact + lbobjchg, lowerbound) &&
SCIPisFeasLT(scip, maxpseudoobjact + ubobjchg, lowerbound) )
3105 (*infeasible) =
TRUE;
3107 else if(
SCIPisFeasLT(scip, maxpseudoobjact + lbobjchg, lowerbound) )
3111 else if(
SCIPisFeasLT(scip, maxpseudoobjact + ubobjchg, lowerbound) )
3139 (*tightened) =
FALSE;
3148 newbd = (lowerbound - residual) / objval;
3200 assert(result != NULL);
3207 assert(propdata != NULL);
3208 assert(propdata->nminactvars > 0 || propdata->nobjintvars > 0);
3219 if(
SCIPisLE(scip, lowerbound, propdata->lastlowerbound) && propdata->maxpseudoobjact <
SCIP_INVALID )
3227 if( propdata->maxpseudoobjactinf > 1 )
3249 if( propdata->maxpseudoobjactinf == 0 && !
SCIPisInfinity(scip, maxpseudoobjact) )
3254 maxactvars = propdata->maxactvars;
3255 nmaxactvars = propdata->nmaxactvars;
3256 assert(nmaxactvars == 0 || maxactvars != NULL);
3258 for( v = propdata->maxactfirstnonfixed; v < nmaxactvars; ++v )
3260 var = maxactvars[v];
3261 assert(var != NULL);
3283 SCIPdebugMsg(scip,
"interrupt pseudo objective propagation w.r.t. lower bound <%.15g> for binary variables after %d from %d binary variables\n",
3284 lowerbound, v, nmaxactvars);
3299 propdata->maxactfirstnonfixed = v;
3302 for( ; v < nmaxactvars && maxpseudoobjact - lowerbound < propdata->maxactchgs[v] && !cutoff; ++v )
3304 var = maxactvars[v];
3305 assert(var != NULL);
3328 for( ; v < nmaxactvars && !cutoff; ++v )
3330 var = maxactvars[v];
3331 assert(var != NULL);
3347 objintvars = propdata->objintvars;
3348 nobjintvars = propdata->nobjintvars;
3349 assert(nobjintvars == 0 || objintvars != NULL);
3352 for( v = 0; v < nobjintvars && !cutoff; ++v )
3354 var = objintvars[v];
3355 assert(var != NULL);
3373 else if( nchgbds > 0 )
3377 propdata->lastlowerbound = lowerbound;
3391 assert(scip != NULL);
3392 assert(prop != NULL);
3423 assert(propdata != NULL);
3432 assert(!propdata->catchvaradded);
3434 propdata->catchvaradded =
TRUE;
3447 assert(propdata != NULL);
3449 if( propdata->catchvaradded )
3453 propdata->catchvaradded =
FALSE;
3476 assert(result != NULL);
3479 assert(propdata != NULL);
3499 if(
SCIPisGE(scip, pseudoobjval, cutoffbound) )
3506 if( cutoffbound < propdata->cutoffbound || pseudoobjval > propdata->glbpseudoobjval )
3512 oldnchgbds = *nchgbds;
3521 for( v = nvars - 1; v >= 0; --v )
3535 if( *nchgbds > oldnchgbds )
3539 propdata->cutoffbound = cutoffbound;
3540 propdata->glbpseudoobjval = pseudoobjval;
3541 propdata->glbpropagated =
TRUE;
3554 assert(propdata != NULL);
3573 if( !propdata->initialized || propdata->nnewvars > propdata->maxnewvars )
3583 if( propdata->nminactvars == 0 && propdata->nmaxactvars == 0 && propdata->nobjintvars == 0 )
3597 (*result) = dualresult;
3613 assert(propdata != NULL);
3617 assert(infervar != NULL);
3644 assert(propdata != NULL);
3646 assert(eventhdlr != NULL);
3647 assert(eventdata != NULL);
3649 assert(event != NULL);
3658 propdata->firstnonfixed = 0;
3661 propdata->nnewvars++;
3668 propdata->maxpseudoobjactinf = 0;
3694 propdata->eventhdlr = NULL;
3697 eventExecPseudoobj, NULL) );
3699 if( propdata->eventhdlr == NULL )
3701 SCIPerrorMessage(
"event handler for pseudo objective propagator not found\n");
3709 assert(prop != NULL);
3722 "minimal number of successive non-binary variable propagator whithout a bound reduction before aborted",
3726 "propagating/" PROP_NAME "/maxvarsfrac",
3727 "maximal fraction of non-binary variables with non-zero objective without a bound reduction before aborted",
3731 "propagating/" PROP_NAME "/propfullinroot",
3732 "do we want to propagate all non-binary variables if we are propagating the root node",
3736 "propagating/" PROP_NAME "/propcutoffbound",
3737 "propagate new cutoff bound directly globally",
3742 "should the propagator be forced even if active pricer are present?",
3747 "number of variable added after the propgatore is reinitialized?",
3751 "propagating/" PROP_NAME "/propuseimplics",
3752 "use implications to strengthen the propagation of binary variable (increasing the objective change)?",
3756 "propagating/" PROP_NAME "/respropuseimplics",
3757 "use implications to strengthen the resolve propagation of binary variable (increasing the objective change)?",
3761 "propagating/" PROP_NAME "/maximplvars",
3762 "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_Bool SCIPisDualfeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_PROPDATA * SCIPpropGetData(SCIP_PROP *prop)
void SCIPpropSetData(SCIP_PROP *prop, SCIP_PROPDATA *propdata)
unsigned int SCIPcliqueGetId(SCIP_CLIQUE *clique)
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
SCIP_Bool SCIPisDualfeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
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)
#define SCIP_EVENTTYPE_BOUNDRELAXED