/** returns the fractionality of a value x, which is calculated as zivalue(x) = min(x-floor(x), ceil(x)-x) */
static
SCIP_Real getZiValue(
SCIP* scip, /**< pointer to current SCIP data structure */
SCIP_Real val /**< the value for which the fractionality should be computed */
)
{
SCIP_Real upgap; /* the gap between val and ceil(val) */
SCIP_Real downgap; /* the gap between val and floor(val) */
assert(scip != NULL);
upgap = SCIPfeasCeil(scip, val) - val;
downgap = val - SCIPfeasFloor(scip, val);
return MIN(upgap, downgap);
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecObjpscostdiving) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_LPSOLSTAT lpsolstat;
SCIP_VAR* var;
SCIP_VAR** lpcands;
SCIP_Real* lpcandssol;
SCIP_Real* lpcandsfrac;
SCIP_Real primsol;
SCIP_Real frac;
SCIP_Real pscostquot;
SCIP_Real bestpscostquot;
SCIP_Real oldobj;
SCIP_Real newobj;
SCIP_Real objscale;
SCIP_Bool bestcandmayrounddown;
SCIP_Bool bestcandmayroundup;
SCIP_Bool bestcandroundup;
SCIP_Bool mayrounddown;
SCIP_Bool mayroundup;
SCIP_Bool roundup;
SCIP_Bool lperror;
SCIP_Longint ncalls;
SCIP_Longint nsolsfound;
SCIP_Longint nlpiterations;
SCIP_Longint maxnlpiterations;
int* roundings;
int nvars;
int varidx;
int nlpcands;
int startnlpcands;
int depth;
int maxdepth;
int maxdivedepth;
int divedepth;
int bestcand;
int c;
assert(heur != NULL);
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
assert(scip != NULL);
assert(result != NULL);
assert(SCIPhasCurrentNodeLP(scip));
*result = SCIP_DELAYED;
/* do not call heuristic of node was already detected to be infeasible */
if( nodeinfeasible )
return SCIP_OKAY;
/* only call heuristic, if an optimal LP solution is at hand */
if( SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
return SCIP_OKAY;
/* only call heuristic, if the LP objective value is smaller than the cutoff bound */
if( SCIPisGE(scip, SCIPgetLPObjval(scip), SCIPgetCutoffbound(scip)) )
return SCIP_OKAY;
/* only call heuristic, if the LP solution is basic (which allows fast resolve in diving) */
if( !SCIPisLPSolBasic(scip) )
return SCIP_OKAY;
/* don't dive two times at the same node */
if( SCIPgetLastDivenode(scip) == SCIPgetNNodes(scip) && SCIPgetDepth(scip) > 0 )
return SCIP_OKAY;
*result = SCIP_DIDNOTRUN;
/* get heuristic's data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* only apply heuristic, if only a few solutions have been found */
if( heurdata->maxsols >= 0 && SCIPgetNSolsFound(scip) >= heurdata->maxsols )
return SCIP_OKAY;
/* only try to dive, if we are in the correct part of the tree, given by minreldepth and maxreldepth */
depth = SCIPgetDepth(scip);
maxdepth = SCIPgetMaxDepth(scip);
maxdepth = MAX(maxdepth, 30);
if( depth < heurdata->minreldepth*maxdepth || depth > heurdata->maxreldepth*maxdepth )
return SCIP_OKAY;
/* calculate the maximal number of LP iterations until heuristic is aborted */
nlpiterations = SCIPgetNNodeLPIterations(scip);
ncalls = SCIPheurGetNCalls(heur);
nsolsfound = 10*SCIPheurGetNBestSolsFound(heur) + heurdata->nsuccess;
maxnlpiterations = (SCIP_Longint)((1.0 + 10.0*(nsolsfound+1.0)/(ncalls+1.0)) * heurdata->maxlpiterquot * nlpiterations);
maxnlpiterations += heurdata->maxlpiterofs;
/* don't try to dive, if we took too many LP iterations during diving */
if( heurdata->nlpiterations >= maxnlpiterations )
return SCIP_OKAY;
/* allow at least a certain number of LP iterations in this dive */
maxnlpiterations = MAX(maxnlpiterations, heurdata->nlpiterations + MINLPITER);
/* get fractional variables that should be integral */
SCIP_CALL( SCIPgetLPBranchCands(scip, &lpcands, &lpcandssol, &lpcandsfrac, &nlpcands, NULL, NULL) );
/* don't try to dive, if there are no fractional variables */
if( nlpcands == 0 )
return SCIP_OKAY;
/* calculate the maximal diving depth */
nvars = SCIPgetNBinVars(scip) + SCIPgetNIntVars(scip);
if( SCIPgetNSolsFound(scip) == 0 )
maxdivedepth = (int)(heurdata->depthfacnosol * nvars);
else
maxdivedepth = (int)(heurdata->depthfac * nvars);
maxdivedepth = MIN(maxdivedepth, 10*maxdepth);
*result = SCIP_DIDNOTFIND;
/* get temporary memory for remembering the current soft roundings */
SCIP_CALL( SCIPallocBufferArray(scip, &roundings, nvars) );
BMSclearMemoryArray(roundings, nvars);
/* start diving */
SCIP_CALL( SCIPstartDive(scip) );
SCIPdebugMessage("(node %"SCIP_LONGINT_FORMAT") executing objpscostdiving heuristic: depth=%d, %d fractionals, dualbound=%g, maxnlpiterations=%"SCIP_LONGINT_FORMAT", maxdivedepth=%d\n",
SCIPgetNNodes(scip), SCIPgetDepth(scip), nlpcands, SCIPgetDualbound(scip), maxnlpiterations, maxdivedepth);
/* dive as long we are in the given diving depth and iteration limits and fractional variables exist, but
* - if the last objective change was in a direction, that corresponds to a feasible rounding, we continue in any case
* - if possible, we dive at least with the depth 10
* - if the number of fractional variables decreased at least with 1 variable per 2 dive depths, we continue diving
*/
lperror = FALSE;
lpsolstat = SCIP_LPSOLSTAT_OPTIMAL;
divedepth = 0;
bestcandmayrounddown = FALSE;
bestcandmayroundup = FALSE;
startnlpcands = nlpcands;
while( !lperror && lpsolstat == SCIP_LPSOLSTAT_OPTIMAL && nlpcands > 0
&& (divedepth < 10
|| nlpcands <= startnlpcands - divedepth/2
|| (divedepth < maxdivedepth && nlpcands <= startnlpcands - divedepth/10
&& heurdata->nlpiterations < maxnlpiterations)) && !SCIPisStopped(scip) )
{
SCIP_RETCODE retcode;
divedepth++;
/* choose variable for objective change:
* - prefer variables that may not be rounded without destroying LP feasibility:
* - of these variables, change objective value of variable with largest rel. difference of pseudo cost values
* - if all remaining fractional variables may be rounded without destroying LP feasibility:
* - change objective value of variable with largest rel. difference of pseudo cost values
*/
bestcand = -1;
bestpscostquot = -1.0;
bestcandmayrounddown = TRUE;
bestcandmayroundup = TRUE;
bestcandroundup = FALSE;
for( c = 0; c < nlpcands; ++c )
{
var = lpcands[c];
mayrounddown = SCIPvarMayRoundDown(var);
mayroundup = SCIPvarMayRoundUp(var);
primsol = lpcandssol[c];
frac = lpcandsfrac[c];
if( mayrounddown || mayroundup )
{
/* the candidate may be rounded: choose this candidate only, if the best candidate may also be rounded */
if( bestcandmayrounddown || bestcandmayroundup )
{
/* choose rounding direction:
* - if variable may be rounded in both directions, round corresponding to the pseudo cost values
* - otherwise, round in the infeasible direction, because feasible direction is tried by rounding
* the current fractional solution
*/
roundup = FALSE;
if( mayrounddown && mayroundup )
calcPscostQuot(scip, var, primsol, frac, 0, &pscostquot, &roundup);
else if( mayrounddown )
calcPscostQuot(scip, var, primsol, frac, +1, &pscostquot, &roundup);
else
calcPscostQuot(scip, var, primsol, frac, -1, &pscostquot, &roundup);
/* prefer variables, that have already been soft rounded but failed to get integral */
varidx = SCIPvarGetProbindex(var);
assert(0 <= varidx && varidx < nvars);
if( roundings[varidx] != 0 )
pscostquot *= 1000.0;
/* check, if candidate is new best candidate */
if( pscostquot > bestpscostquot )
{
bestcand = c;
bestpscostquot = pscostquot;
bestcandmayrounddown = mayrounddown;
bestcandmayroundup = mayroundup;
bestcandroundup = roundup;
}
}
}
else
{
/* the candidate may not be rounded: calculate pseudo cost quotient and preferred direction */
calcPscostQuot(scip, var, primsol, frac, 0, &pscostquot, &roundup);
/* prefer variables, that have already been soft rounded but failed to get integral */
varidx = SCIPvarGetProbindex(var);
assert(0 <= varidx && varidx < nvars);
if( roundings[varidx] != 0 )
pscostquot *= 1000.0;
/* check, if candidate is new best candidate: prefer unroundable candidates in any case */
if( bestcandmayrounddown || bestcandmayroundup || pscostquot > bestpscostquot )
{
bestcand = c;
bestpscostquot = pscostquot;
bestcandmayrounddown = FALSE;
bestcandmayroundup = FALSE;
bestcandroundup = roundup;
}
}
}
assert(bestcand != -1);
/* if all candidates are roundable, try to round the solution */
if( bestcandmayrounddown || bestcandmayroundup )
{
SCIP_Bool success;
/* create solution from diving LP and try to round it */
SCIP_CALL( SCIPlinkLPSol(scip, heurdata->sol) );
SCIP_CALL( SCIProundSol(scip, heurdata->sol, &success) );
if( success )
{
SCIPdebugMessage("objpscostdiving found roundable primal solution: obj=%g\n",
SCIPgetSolOrigObj(scip, heurdata->sol));
/* try to add solution to SCIP */
SCIP_CALL( SCIPtrySol(scip, heurdata->sol, FALSE, FALSE, FALSE, FALSE, &success) );
/* check, if solution was feasible and good enough */
if( success )
{
SCIPdebugMessage(" -> solution was feasible and good enough\n");
*result = SCIP_FOUNDSOL;
}
}
}
var = lpcands[bestcand];
/* check, if the best candidate was already subject to soft rounding */
varidx = SCIPvarGetProbindex(var);
assert(0 <= varidx && varidx < nvars);
if( roundings[varidx] == +1 )
{
/* variable was already soft rounded upwards: hard round it downwards */
SCIP_CALL( SCIPchgVarUbDive(scip, var, SCIPfeasFloor(scip, lpcandssol[bestcand])) );
SCIPdebugMessage(" dive %d/%d: var <%s>, round=%u/%u, sol=%g, was already soft rounded upwards -> bounds=[%g,%g]\n",
divedepth, maxdivedepth, SCIPvarGetName(var), bestcandmayrounddown, bestcandmayroundup,
lpcandssol[bestcand], SCIPgetVarLbDive(scip, var), SCIPgetVarUbDive(scip, var));
}
else if( roundings[varidx] == -1 )
{
/* variable was already soft rounded downwards: hard round it upwards */
SCIP_CALL( SCIPchgVarLbDive(scip, var, SCIPfeasCeil(scip, lpcandssol[bestcand])) );
SCIPdebugMessage(" dive %d/%d: var <%s>, round=%u/%u, sol=%g, was already soft rounded downwards -> bounds=[%g,%g]\n",
divedepth, maxdivedepth, SCIPvarGetName(var), bestcandmayrounddown, bestcandmayroundup,
lpcandssol[bestcand], SCIPgetVarLbDive(scip, var), SCIPgetVarUbDive(scip, var));
}
else
{
assert(roundings[varidx] == 0);
/* apply soft rounding of best candidate via a change in the objective value */
objscale = divedepth * 1000.0;
oldobj = SCIPgetVarObjDive(scip, var);
if( bestcandroundup )
{
/* soft round variable up: make objective value (more) negative */
if( oldobj < 0.0 )
newobj = objscale * oldobj;
else
newobj = -objscale * oldobj;
newobj = MIN(newobj, -objscale);
/* remember, that this variable was soft rounded upwards */
roundings[varidx] = +1;
}
else
{
/* soft round variable down: make objective value (more) positive */
if( oldobj > 0.0 )
newobj = objscale * oldobj;
else
newobj = -objscale * oldobj;
newobj = MAX(newobj, objscale);
/* remember, that this variable was soft rounded downwards */
roundings[varidx] = -1;
}
SCIP_CALL( SCIPchgVarObjDive(scip, var, newobj) );
SCIPdebugMessage(" dive %d/%d, LP iter %"SCIP_LONGINT_FORMAT"/%"SCIP_LONGINT_FORMAT": var <%s>, round=%u/%u, sol=%g, bounds=[%g,%g], obj=%g, newobj=%g\n",
divedepth, maxdivedepth, heurdata->nlpiterations, maxnlpiterations,
SCIPvarGetName(var), bestcandmayrounddown, bestcandmayroundup,
lpcandssol[bestcand], SCIPgetVarLbDive(scip, var), SCIPgetVarUbDive(scip, var), oldobj, newobj);
}
/* resolve the diving LP */
nlpiterations = SCIPgetNLPIterations(scip);
retcode = SCIPsolveDiveLP(scip, MAX((int)(maxnlpiterations - heurdata->nlpiterations), MINLPITER), &lperror, NULL);
lpsolstat = SCIPgetLPSolstat(scip);
/* Errors in the LP solver should not kill the overall solving process, if the LP is just needed for a heuristic.
* Hence in optimized mode, the return code is caught and a warning is printed, only in debug mode, SCIP will stop.
*/
if( retcode != SCIP_OKAY )
{
#ifndef NDEBUG
if( lpsolstat != SCIP_LPSOLSTAT_UNBOUNDEDRAY )
{
SCIP_CALL( retcode );
}
#endif
SCIPwarningMessage(scip, "Error while solving LP in Objpscostdiving heuristic; LP solve terminated with code <%d>\n", retcode);
SCIPwarningMessage(scip, "This does not affect the remaining solution procedure --> continue\n");
}
if( lperror )
break;
/* update iteration count */
heurdata->nlpiterations += SCIPgetNLPIterations(scip) - nlpiterations;
/* get LP solution status and fractional variables, that should be integral */
if( lpsolstat == SCIP_LPSOLSTAT_OPTIMAL )
{
/* get new fractional variables */
SCIP_CALL( SCIPgetLPBranchCands(scip, &lpcands, &lpcandssol, &lpcandsfrac, &nlpcands, NULL, NULL) );
}
SCIPdebugMessage(" -> lpsolstat=%d, nfrac=%d\n", lpsolstat, nlpcands);
}
/* check if a solution has been found */
if( nlpcands == 0 && !lperror && lpsolstat == SCIP_LPSOLSTAT_OPTIMAL )
{
SCIP_Bool success;
/* create solution from diving LP */
SCIP_CALL( SCIPlinkLPSol(scip, heurdata->sol) );
SCIPdebugMessage("objpscostdiving found primal solution: obj=%g\n", SCIPgetSolOrigObj(scip, heurdata->sol));
/* try to add solution to SCIP */
SCIP_CALL( SCIPtrySol(scip, heurdata->sol, FALSE, FALSE, FALSE, FALSE, &success) );
/* check, if solution was feasible and good enough */
if( success )
{
SCIPdebugMessage(" -> solution was feasible and good enough\n");
*result = SCIP_FOUNDSOL;
}
}
/* end diving */
SCIP_CALL( SCIPendDive(scip) );
if( *result == SCIP_FOUNDSOL )
heurdata->nsuccess++;
/* free temporary memory for remembering the current soft roundings */
SCIPfreeBufferArray(scip, &roundings);
SCIPdebugMessage("objpscostdiving heuristic finished\n");
return SCIP_OKAY;
}
/** presolving execution method */
static
SCIP_DECL_PRESOLEXEC(presolExecTrivial)
{ /*lint --e{715}*/
SCIP_VAR** vars;
int nvars;
int v;
assert(result != NULL);
*result = SCIP_DIDNOTFIND;
/* get the problem variables */
vars = SCIPgetVars(scip);
nvars = SCIPgetNVars(scip);
/* scan the variables for trivial bound reductions
* (loop backwards, since a variable fixing can change the current and the subsequent slots in the vars array)
*/
for( v = nvars-1; v >= 0; --v )
{
SCIP_Real lb;
SCIP_Real ub;
SCIP_Bool infeasible;
SCIP_Bool fixed;
/* get variable's bounds */
lb = SCIPvarGetLbGlobal(vars[v]);
ub = SCIPvarGetUbGlobal(vars[v]);
/* is variable integral? */
if( SCIPvarGetType(vars[v]) != SCIP_VARTYPE_CONTINUOUS )
{
SCIP_Real newlb;
SCIP_Real newub;
/* round fractional bounds on integer variables */
newlb = SCIPfeasCeil(scip, lb);
newub = SCIPfeasFloor(scip, ub);
/* check bounds on variable for infeasibility */
if( newlb > newub + 0.5 )
{
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL,
"problem infeasible: integral variable <%s> has bounds [%.17f,%.17f] rounded to [%.17f,%.17f]\n",
SCIPvarGetName(vars[v]), lb, ub, newlb, newub);
*result = SCIP_CUTOFF;
return SCIP_OKAY;
}
/* fix variables with equal bounds */
if( newlb > newub - 0.5 )
{
SCIPdebugMessage("fixing integral variable <%s>: [%.17f,%.17f] -> [%.17f,%.17f]\n",
SCIPvarGetName(vars[v]), lb, ub, newlb, newub);
SCIP_CALL( SCIPfixVar(scip, vars[v], newlb, &infeasible, &fixed) );
if( infeasible )
{
SCIPdebugMessage(" -> infeasible fixing\n");
*result = SCIP_CUTOFF;
return SCIP_OKAY;
}
assert(fixed);
(*nfixedvars)++;
}
else
{
/* round fractional bounds */
if( !SCIPisFeasEQ(scip, lb, newlb) )
{
SCIPdebugMessage("rounding lower bound of integral variable <%s>: [%.17f,%.17f] -> [%.17f,%.17f]\n",
SCIPvarGetName(vars[v]), lb, ub, newlb, ub);
SCIP_CALL( SCIPchgVarLb(scip, vars[v], newlb) );
(*nchgbds)++;
}
if( !SCIPisFeasEQ(scip, ub, newub) )
{
SCIPdebugMessage("rounding upper bound of integral variable <%s>: [%.17f,%.17f] -> [%.17f,%.17f]\n",
SCIPvarGetName(vars[v]), newlb, ub, newlb, newub);
SCIP_CALL( SCIPchgVarUb(scip, vars[v], newub) );
(*nchgbds)++;
}
}
}
else
{
/* check bounds on continuous variable for infeasibility */
if( SCIPisFeasGT(scip, lb, ub) )
{
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL,
"problem infeasible: continuous variable <%s> has bounds [%.17f,%.17f]\n",
SCIPvarGetName(vars[v]), lb, ub);
*result = SCIP_CUTOFF;
return SCIP_OKAY;
}
/* fix variables with equal bounds */
if( SCIPisEQ(scip, lb, ub) )
{
SCIP_Real fixval;
#ifdef FIXSIMPLEVALUE
fixval = SCIPselectSimpleValue(lb - 0.9 * SCIPepsilon(scip), ub + 0.9 * SCIPepsilon(scip), MAXDNOM);
#else
fixval = (lb + ub)/2;
#endif
SCIPdebugMessage("fixing continuous variable <%s>[%.17f,%.17f] to %.17f\n",
SCIPvarGetName(vars[v]), lb, ub, fixval);
SCIP_CALL( SCIPfixVar(scip, vars[v], fixval, &infeasible, &fixed) );
if( infeasible )
{
SCIPdebugMessage(" -> infeasible fixing\n");
*result = SCIP_CUTOFF;
return SCIP_OKAY;
}
assert(fixed);
(*nfixedvars)++;
}
}
}
return SCIP_OKAY;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecZirounding)
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_SOL* sol;
SCIP_VAR** lpcands;
SCIP_VAR** zilpcands;
SCIP_VAR** slackvars;
SCIP_Real* upslacks;
SCIP_Real* downslacks;
SCIP_Real* activities;
SCIP_Real* slackvarcoeffs;
SCIP_Bool* rowneedsslackvar;
SCIP_ROW** rows;
SCIP_Real* lpcandssol;
SCIP_Real* solarray;
SCIP_Longint nlps;
int currentlpcands;
int nlpcands;
int nimplfracs;
int i;
int c;
int nslacks;
int nroundings;
SCIP_RETCODE retcode;
SCIP_Bool improvementfound;
SCIP_Bool numericalerror;
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
assert(result != NULL);
assert(SCIPhasCurrentNodeLP(scip));
*result = SCIP_DIDNOTRUN;
/* do not call heuristic of node was already detected to be infeasible */
if( nodeinfeasible )
return SCIP_OKAY;
/* only call heuristic if an optimal LP-solution is at hand */
if( SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
return SCIP_OKAY;
/* only call heuristic, if the LP objective value is smaller than the cutoff bound */
if( SCIPisGE(scip, SCIPgetLPObjval(scip), SCIPgetCutoffbound(scip)) )
return SCIP_OKAY;
/* get heuristic data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* Do not call heuristic if deactivation check is enabled and percentage of found solutions in relation
* to number of calls falls below heurdata->stoppercentage */
if( heurdata->stopziround && SCIPheurGetNCalls(heur) >= heurdata->minstopncalls
&& SCIPheurGetNSolsFound(heur)/(SCIP_Real)SCIPheurGetNCalls(heur) < heurdata->stoppercentage )
return SCIP_OKAY;
/* assure that heuristic has not already been called after the last LP had been solved */
nlps = SCIPgetNLPs(scip);
if( nlps == heurdata->lastlp )
return SCIP_OKAY;
heurdata->lastlp = nlps;
/* get fractional variables */
SCIP_CALL( SCIPgetLPBranchCands(scip, &lpcands, &lpcandssol, NULL, &nlpcands, NULL, &nimplfracs) );
nlpcands = nlpcands + nimplfracs;
/* make sure that there is at least one fractional variable that should be integral */
if( nlpcands == 0 )
return SCIP_OKAY;
assert(nlpcands > 0);
assert(lpcands != NULL);
assert(lpcandssol != NULL);
/* get LP rows data */
rows = SCIPgetLPRows(scip);
nslacks = SCIPgetNLPRows(scip);
/* cannot do anything if LP is empty */
if( nslacks == 0 )
return SCIP_OKAY;
assert(rows != NULL);
assert(nslacks > 0);
/* get the working solution from heuristic's local data */
sol = heurdata->sol;
assert(sol != NULL);
*result = SCIP_DIDNOTFIND;
solarray = NULL;
zilpcands = NULL;
retcode = SCIP_OKAY;
/* copy the current LP solution to the working solution and allocate memory for local data */
SCIP_CALL( SCIPlinkLPSol(scip, sol) );
SCIP_CALL_TERMINATE(retcode, SCIPallocBufferArray(scip, &solarray, nlpcands), TERMINATE);
SCIP_CALL_TERMINATE(retcode, SCIPallocBufferArray(scip, &zilpcands, nlpcands), TERMINATE);
/* copy necessary data to local arrays */
BMScopyMemoryArray(solarray, lpcandssol, nlpcands);
BMScopyMemoryArray(zilpcands, lpcands, nlpcands);
/* allocate buffer data arrays */
SCIP_CALL_TERMINATE(retcode, SCIPallocBufferArray(scip, &slackvars, nslacks), TERMINATE);
SCIP_CALL_TERMINATE(retcode, SCIPallocBufferArray(scip, &upslacks, nslacks), TERMINATE);
SCIP_CALL_TERMINATE(retcode, SCIPallocBufferArray(scip, &downslacks, nslacks), TERMINATE);
SCIP_CALL_TERMINATE(retcode, SCIPallocBufferArray(scip, &slackvarcoeffs, nslacks), TERMINATE);
SCIP_CALL_TERMINATE(retcode, SCIPallocBufferArray(scip, &rowneedsslackvar, nslacks), TERMINATE);
SCIP_CALL_TERMINATE(retcode, SCIPallocBufferArray(scip, &activities, nslacks), TERMINATE);
BMSclearMemoryArray(slackvars, nslacks);
BMSclearMemoryArray(slackvarcoeffs, nslacks);
BMSclearMemoryArray(rowneedsslackvar, nslacks);
numericalerror = FALSE;
nroundings = 0;
/* loop over fractional variables and involved LP rows to find all rows which require a slack variable */
for( c = 0; c < nlpcands; ++c )
{
SCIP_VAR* cand;
SCIP_ROW** candrows;
int r;
int ncandrows;
cand = zilpcands[c];
assert(cand != NULL);
assert(SCIPcolGetLPPos(SCIPvarGetCol(cand)) >= 0);
candrows = SCIPcolGetRows(SCIPvarGetCol(cand));
ncandrows = SCIPcolGetNLPNonz(SCIPvarGetCol(cand));
assert(candrows == NULL || ncandrows > 0);
for( r = 0; r < ncandrows; ++r )
{
int rowpos;
assert(candrows != NULL); /* to please flexelint */
assert(candrows[r] != NULL);
rowpos = SCIProwGetLPPos(candrows[r]);
if( rowpos >= 0 && SCIPisFeasEQ(scip, SCIProwGetLhs(candrows[r]), SCIProwGetRhs(candrows[r])) )
{
rowneedsslackvar[rowpos] = TRUE;
SCIPdebugMessage(" Row %s needs slack variable for variable %s\n", SCIProwGetName(candrows[r]), SCIPvarGetName(cand));
}
}
}
/* calculate row slacks for every every row that belongs to the current LP and ensure, that the current solution
* has no violated constraint -- if any constraint is violated, i.e. a slack is significantly smaller than zero,
* this will cause the termination of the heuristic because Zirounding does not provide feasibility recovering
*/
for( i = 0; i < nslacks; ++i )
{
SCIP_ROW* row;
SCIP_Real lhs;
SCIP_Real rhs;
row = rows[i];
assert(row != NULL);
lhs = SCIProwGetLhs(row);
rhs = SCIProwGetRhs(row);
/* get row activity */
activities[i] = SCIPgetRowActivity(scip, row);
assert(SCIPisFeasLE(scip, lhs, activities[i]) && SCIPisFeasLE(scip, activities[i], rhs));
/* in special case if LHS or RHS is (-)infinity slacks have to be initialized as infinity */
if( SCIPisInfinity(scip, -lhs) )
downslacks[i] = SCIPinfinity(scip);
else
downslacks[i] = activities[i] - lhs;
if( SCIPisInfinity(scip, rhs) )
upslacks[i] = SCIPinfinity(scip);
else
upslacks[i] = rhs - activities[i];
SCIPdebugMessage("lhs:%5.2f <= act:%5.2g <= rhs:%5.2g --> down: %5.2g, up:%5.2g\n", lhs, activities[i], rhs, downslacks[i], upslacks[i]);
/* row is an equation. Try to find a slack variable in the row, i.e.,
* a continuous variable which occurs only in this row. If no such variable exists,
* there is no hope for an IP-feasible solution in this round
*/
if( SCIPisFeasEQ(scip, lhs, rhs) && rowneedsslackvar[i] )
{
/* @todo: This is only necessary for rows containing fractional variables. */
rowFindSlackVar(scip, row, &(slackvars[i]), &(slackvarcoeffs[i]));
if( slackvars[i] == NULL )
{
SCIPdebugMessage("No slack variable found for equation %s, terminating ZI Round heuristic\n", SCIProwGetName(row));
goto TERMINATE;
}
else
{
SCIP_Real ubslackvar;
SCIP_Real lbslackvar;
SCIP_Real solvalslackvar;
SCIP_Real coeffslackvar;
SCIP_Real ubgap;
SCIP_Real lbgap;
assert(SCIPvarGetType(slackvars[i]) == SCIP_VARTYPE_CONTINUOUS);
solvalslackvar = SCIPgetSolVal(scip, sol, slackvars[i]);
ubslackvar = SCIPvarGetUbGlobal(slackvars[i]);
lbslackvar = SCIPvarGetLbGlobal(slackvars[i]);
coeffslackvar = slackvarcoeffs[i];
assert(!SCIPisFeasZero(scip, coeffslackvar));
ubgap = ubslackvar - solvalslackvar;
lbgap = solvalslackvar - lbslackvar;
if( SCIPisFeasZero(scip, ubgap) )
ubgap = 0.0;
if( SCIPisFeasZero(scip, lbgap) )
lbgap = 0.0;
if( SCIPisFeasPositive(scip, coeffslackvar) )
{
if( !SCIPisInfinity(scip, lbslackvar) )
upslacks[i] += coeffslackvar * lbgap;
else
upslacks[i] = SCIPinfinity(scip);
if( !SCIPisInfinity(scip, ubslackvar) )
downslacks[i] += coeffslackvar * ubgap;
else
downslacks[i] = SCIPinfinity(scip);
}
else
{
if( !SCIPisInfinity(scip, ubslackvar) )
upslacks[i] -= coeffslackvar * ubgap;
else
upslacks[i] = SCIPinfinity(scip);
if( !SCIPisInfinity(scip, lbslackvar) )
downslacks[i] -= coeffslackvar * lbgap;
else
downslacks[i] = SCIPinfinity(scip);
}
SCIPdebugMessage(" Slack variable for row %s at pos %d: %g <= %s = %g <= %g; Coeff %g, upslack = %g, downslack = %g \n",
SCIProwGetName(row), SCIProwGetLPPos(row), lbslackvar, SCIPvarGetName(slackvars[i]), solvalslackvar, ubslackvar, coeffslackvar,
upslacks[i], downslacks[i]);
}
}
/* due to numerical inaccuracies, the rows might be feasible, even if the slacks are
* significantly smaller than zero -> terminate
*/
if( SCIPisFeasLT(scip, upslacks[i], 0.0) || SCIPisFeasLT(scip, downslacks[i], 0.0) )
goto TERMINATE;
}
assert(nslacks == 0 || (upslacks != NULL && downslacks != NULL && activities != NULL));
/* initialize number of remaining variables and flag to enter the main loop */
currentlpcands = nlpcands;
improvementfound = TRUE;
/* iterate over variables as long as there are fractional variables left */
while( currentlpcands > 0 && improvementfound && (heurdata->maxroundingloops == -1 || nroundings < heurdata->maxroundingloops) )
{ /*lint --e{850}*/
improvementfound = FALSE;
nroundings++;
SCIPdebugMessage("zirounding enters while loop for %d time with %d candidates left. \n", nroundings, currentlpcands);
/* check for every remaining fractional variable if a shifting decreases ZI-value of the variable */
for( c = 0; c < currentlpcands; ++c )
{
SCIP_VAR* var;
SCIP_Real oldsolval;
SCIP_Real upperbound;
SCIP_Real lowerbound;
SCIP_Real up;
SCIP_Real down;
SCIP_Real ziup;
SCIP_Real zidown;
SCIP_Real zicurrent;
SCIP_Real shiftval;
DIRECTION direction;
/* get values from local data */
oldsolval = solarray[c];
var = zilpcands[c];
assert(!SCIPisFeasIntegral(scip, oldsolval));
assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_COLUMN);
/* calculate bounds for variable and make sure that there are no numerical inconsistencies */
upperbound = SCIPinfinity(scip);
lowerbound = SCIPinfinity(scip);
calculateBounds(scip, var, oldsolval, &upperbound, &lowerbound, upslacks, downslacks, nslacks, &numericalerror);
if( numericalerror )
goto TERMINATE;
/* calculate the possible values after shifting */
up = oldsolval + upperbound;
down = oldsolval - lowerbound;
/* if the variable is integer or implicit binary, do not shift further than the nearest integer */
if( SCIPvarGetType(var) != SCIP_VARTYPE_BINARY)
{
SCIP_Real ceilx;
SCIP_Real floorx;
ceilx = SCIPfeasCeil(scip, oldsolval);
floorx = SCIPfeasFloor(scip, oldsolval);
up = MIN(up, ceilx);
down = MAX(down, floorx);
}
/* calculate necessary values */
ziup = getZiValue(scip, up);
zidown = getZiValue(scip, down);
zicurrent = getZiValue(scip, oldsolval);
/* calculate the shifting direction that reduces ZI-value the most,
* if both directions improve ZI-value equally, take the direction which improves the objective
*/
if( SCIPisFeasLT(scip, zidown, zicurrent) || SCIPisFeasLT(scip, ziup, zicurrent) )
{
if( SCIPisFeasEQ(scip,ziup, zidown) )
direction = SCIPisFeasGE(scip, SCIPvarGetObj(var), 0.0) ? DIRECTION_DOWN : DIRECTION_UP;
else if( SCIPisFeasLT(scip, zidown, ziup) )
direction = DIRECTION_DOWN;
else
direction = DIRECTION_UP;
/* once a possible shifting direction and value have been found, variable value is updated */
shiftval = (direction == DIRECTION_UP ? up - oldsolval : down - oldsolval);
/* this improves numerical stability in some cases */
if( direction == DIRECTION_UP )
shiftval = MIN(shiftval, upperbound);
else
shiftval = MIN(shiftval, lowerbound);
/* update the solution */
solarray[c] = direction == DIRECTION_UP ? up : down;
SCIP_CALL( SCIPsetSolVal(scip, sol, var, solarray[c]) );
/* update the rows activities and slacks */
SCIP_CALL( updateSlacks(scip, sol, var, shiftval, upslacks,
downslacks, activities, slackvars, slackvarcoeffs, nslacks) );
SCIPdebugMessage("zirounding update step : %d var index, oldsolval=%g, shiftval=%g\n",
SCIPvarGetIndex(var), oldsolval, shiftval);
/* since at least one improvement has been found, heuristic will enter main loop for another time because the improvement
* might affect many LP rows and their current slacks and thus make further rounding steps possible */
improvementfound = TRUE;
}
/* if solution value of variable has become feasibly integral due to rounding step,
* variable is put at the end of remaining candidates array so as not to be considered in future loops
*/
if( SCIPisFeasIntegral(scip, solarray[c]) )
{
zilpcands[c] = zilpcands[currentlpcands - 1];
solarray[c] = solarray[currentlpcands - 1];
currentlpcands--;
/* counter is decreased if end of candidates array has not been reached yet */
if( c < currentlpcands )
c--;
}
else if( nroundings == heurdata->maxroundingloops - 1 )
goto TERMINATE;
}
}
/* in case that no candidate is left for rounding after the final main loop
* the found solution has to be checked for feasibility in the original problem
*/
if( currentlpcands == 0 )
{
SCIP_Bool stored;
SCIP_CALL(SCIPtrySol(scip, sol, FALSE, FALSE, TRUE, FALSE, &stored));
if( stored )
{
#ifdef SCIP_DEBUG
SCIPdebugMessage("found feasible rounded solution:\n");
SCIP_CALL( SCIPprintSol(scip, sol, NULL, FALSE) );
#endif
SCIPstatisticMessage(" ZI Round solution value: %g \n", SCIPgetSolOrigObj(scip, sol));
*result = SCIP_FOUNDSOL;
}
}
/* free memory for all locally allocated data */
TERMINATE:
SCIPfreeBufferArrayNull(scip, &activities);
SCIPfreeBufferArrayNull(scip, &rowneedsslackvar);
SCIPfreeBufferArrayNull(scip, &slackvarcoeffs);
SCIPfreeBufferArrayNull(scip, &downslacks);
SCIPfreeBufferArrayNull(scip, &upslacks);
SCIPfreeBufferArrayNull(scip, &slackvars);
SCIPfreeBufferArrayNull(scip, &zilpcands);
SCIPfreeBufferArrayNull(scip, &solarray);
return retcode;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecSimplerounding) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_SOL* sol;
SCIP_VAR** lpcands;
SCIP_Real* lpcandssol;
SCIP_Longint nlps;
int nlpcands;
int c;
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
assert(result != NULL);
assert(SCIPhasCurrentNodeLP(scip));
*result = SCIP_DIDNOTRUN;
/* only call heuristic, if an optimal LP solution is at hand */
if( SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
return SCIP_OKAY;
/* get heuristic data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* on our first call or after each pricing round, calculate the number of roundable variables */
if( heurdata->nroundablevars == -1 || heurtiming == SCIP_HEURTIMING_DURINGPRICINGLOOP )
{
SCIP_VAR** vars;
int nvars;
int nroundablevars;
int i;
vars = SCIPgetVars(scip);
nvars = SCIPgetNBinVars(scip) + SCIPgetNIntVars(scip);
nroundablevars = 0;
for( i = 0; i < nvars; ++i )
{
if( SCIPvarMayRoundDown(vars[i]) || SCIPvarMayRoundUp(vars[i]) )
nroundablevars++;
}
heurdata->nroundablevars = nroundablevars;
}
/* don't call heuristic if there are no roundable variables; except we are called during pricing, in this case we
* want to detect a (mixed) integer (LP) solution which is primal feasible */
if( heurdata->nroundablevars == 0 && heurtiming != SCIP_HEURTIMING_DURINGPRICINGLOOP )
return SCIP_OKAY;
/* don't call heuristic, if we have already processed the current LP solution */
nlps = SCIPgetNLPs(scip);
if( nlps == heurdata->lastlp )
return SCIP_OKAY;
heurdata->lastlp = nlps;
/* get fractional variables, that should be integral */
SCIP_CALL( SCIPgetLPBranchCands(scip, &lpcands, &lpcandssol, NULL, &nlpcands, NULL) );
/* only call heuristic, if LP solution is fractional; except we are called during pricing, in this case we
* want to detect a (mixed) integer (LP) solution which is primal feasible */
if( nlpcands == 0 && heurtiming != SCIP_HEURTIMING_DURINGPRICINGLOOP )
return SCIP_OKAY;
/* don't call heuristic, if there are more fractional variables than roundable ones */
if( nlpcands > heurdata->nroundablevars )
return SCIP_OKAY;
*result = SCIP_DIDNOTFIND;
SCIPdebugMessage("executing simple rounding heuristic: %d fractionals\n", nlpcands);
/* get the working solution from heuristic's local data */
sol = heurdata->sol;
assert(sol != NULL);
/* copy the current LP solution to the working solution */
SCIP_CALL( SCIPlinkLPSol(scip, sol) );
/* round all roundable fractional columns in the corresponding direction as long as no unroundable column was found */
for( c = 0; c < nlpcands; ++c )
{
SCIP_VAR* var;
SCIP_Real oldsolval;
SCIP_Real newsolval;
SCIP_Bool mayrounddown;
SCIP_Bool mayroundup;
oldsolval = lpcandssol[c];
assert(!SCIPisFeasIntegral(scip, oldsolval));
var = lpcands[c];
assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_COLUMN);
mayrounddown = SCIPvarMayRoundDown(var);
mayroundup = SCIPvarMayRoundUp(var);
SCIPdebugMessage("simple rounding heuristic: var <%s>, val=%g, rounddown=%u, roundup=%u\n",
SCIPvarGetName(var), oldsolval, mayrounddown, mayroundup);
/* choose rounding direction */
if( mayrounddown && mayroundup )
{
/* we can round in both directions: round in objective function direction */
if( SCIPvarGetObj(var) >= 0.0 )
newsolval = SCIPfeasFloor(scip, oldsolval);
else
newsolval = SCIPfeasCeil(scip, oldsolval);
}
else if( mayrounddown )
newsolval = SCIPfeasFloor(scip, oldsolval);
else if( mayroundup )
newsolval = SCIPfeasCeil(scip, oldsolval);
else
break;
/* store new solution value */
SCIP_CALL( SCIPsetSolVal(scip, sol, var, newsolval) );
}
/* check, if rounding was successful */
if( c == nlpcands )
{
SCIP_Bool stored;
/* check solution for feasibility, and add it to solution store if possible
* neither integrality nor feasibility of LP rows has to be checked, because all fractional
* variables were already moved in feasible direction to the next integer
*/
SCIP_CALL( SCIPtrySol(scip, sol, FALSE, FALSE, FALSE, FALSE, &stored) );
if( stored )
{
#ifdef SCIP_DEBUG
SCIPdebugMessage("found feasible rounded solution:\n");
SCIPprintSol(scip, sol, NULL, FALSE);
#endif
*result = SCIP_FOUNDSOL;
}
}
return SCIP_OKAY;
}
/** creates a subproblem for subscip by fixing a number of variables */
static
SCIP_RETCODE createSubproblem(
SCIP* scip, /**< original SCIP data structure */
SCIP* subscip, /**< SCIP data structure for the subproblem */
SCIP_VAR** subvars, /**< the variables of the subproblem */
SCIP_Real minfixingrate, /**< percentage of integer variables that have to be fixed */
SCIP_Bool binarybounds, /**< should general integers get binary bounds [floor(.),ceil(.)] ? */
SCIP_Bool uselprows, /**< should subproblem be created out of the rows in the LP rows? */
SCIP_Bool* success /**< pointer to store whether the problem was created successfully */
)
{
SCIP_VAR** vars; /* original SCIP variables */
SCIP_Real fixingrate;
int nvars;
int nbinvars;
int nintvars;
int i;
int fixingcounter;
assert(scip != NULL);
assert(subscip != NULL);
assert(subvars != NULL);
assert(0.0 <= minfixingrate && minfixingrate <= 1.0);
/* get required variable data */
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, &nbinvars, &nintvars, NULL, NULL) );
fixingcounter = 0;
/* change bounds of variables of the subproblem */
for( i = 0; i < nbinvars + nintvars; i++ )
{
SCIP_Real lpsolval;
SCIP_Real lb;
SCIP_Real ub;
/* get the current LP solution for each variable */
lpsolval = SCIPgetRelaxSolVal(scip, vars[i]);
if( SCIPisFeasIntegral(scip, lpsolval) )
{
/* fix variables to current LP solution if it is integral,
* use exact integral value, if the variable is only integral within numerical tolerances
*/
lb = SCIPfloor(scip, lpsolval+0.5);
ub = lb;
fixingcounter++;
}
else if( binarybounds )
{
/* if the sub problem should be a binary problem, change the bounds to nearest integers */
lb = SCIPfeasFloor(scip,lpsolval);
ub = SCIPfeasCeil(scip,lpsolval);
}
else
{
/* otherwise just copy bounds */
lb = SCIPvarGetLbGlobal(vars[i]);
ub = SCIPvarGetUbGlobal(vars[i]);
}
/* perform the bound change */
SCIP_CALL( SCIPchgVarLbGlobal(subscip, subvars[i], lb) );
SCIP_CALL( SCIPchgVarUbGlobal(subscip, subvars[i], ub) );
}
/* abort, if all integer variables were fixed (which should not happen for MIP) */
if( fixingcounter == nbinvars + nintvars )
{
*success = FALSE;
return SCIP_OKAY;
}
else
fixingrate = fixingcounter / (SCIP_Real)(MAX(nbinvars + nintvars, 1));
SCIPdebugMessage("fixing rate: %g = %d of %d\n", fixingrate, fixingcounter, nbinvars + nintvars);
/* abort, if the amount of fixed variables is insufficient */
if( fixingrate < minfixingrate )
{
*success = FALSE;
return SCIP_OKAY;
}
if( uselprows )
{
SCIP_ROW** rows; /* original scip rows */
int nrows;
/* get the rows and their number */
SCIP_CALL( SCIPgetLPRowsData(scip, &rows, &nrows) );
/* copy all rows to linear constraints */
for( i = 0; i < nrows; i++ )
{
SCIP_CONS* cons;
SCIP_VAR** consvars;
SCIP_COL** cols;
SCIP_Real constant;
SCIP_Real lhs;
SCIP_Real rhs;
SCIP_Real* vals;
int nnonz;
int j;
/* ignore rows that are only locally valid */
if( SCIProwIsLocal(rows[i]) )
continue;
/* get the row's data */
constant = SCIProwGetConstant(rows[i]);
lhs = SCIProwGetLhs(rows[i]) - constant;
rhs = SCIProwGetRhs(rows[i]) - constant;
vals = SCIProwGetVals(rows[i]);
nnonz = SCIProwGetNNonz(rows[i]);
cols = SCIProwGetCols(rows[i]);
assert( lhs <= rhs );
/* allocate memory array to be filled with the corresponding subproblem variables */
SCIP_CALL( SCIPallocBufferArray(subscip, &consvars, nnonz) );
for( j = 0; j < nnonz; j++ )
consvars[j] = subvars[SCIPvarGetProbindex(SCIPcolGetVar(cols[j]))];
/* create a new linear constraint and add it to the subproblem */
SCIP_CALL( SCIPcreateConsLinear(subscip, &cons, SCIProwGetName(rows[i]), nnonz, consvars, vals, lhs, rhs,
TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, TRUE, FALSE) );
SCIP_CALL( SCIPaddCons(subscip, cons) );
SCIP_CALL( SCIPreleaseCons(subscip, &cons) );
/* free temporary memory */
SCIPfreeBufferArray(subscip, &consvars);
}
}
*success = TRUE;
return SCIP_OKAY;
}
/** ensure that maxindex + 1 rows can be represented in data arrays; memory gets reallocated with 10% extra space
* to save some time for future allocations */
static
SCIP_RETCODE heurdataEnsureArraySize(
SCIP* scip, /**< SCIP data structure */
SCIP_HEURDATA* heurdata, /**< heuristic data */
int maxindex /**< row index at hand (size must be at least this large) */
)
{
int newsize;
int r;
/* maxindex fits in current array -> nothing to do */
if( maxindex < heurdata->memsize )
return SCIP_OKAY;
/* new memory size is the max index + 1 plus 10% additional space */
newsize = (int)SCIPfeasCeil(scip, (maxindex + 1) * 1.1);
assert(newsize > heurdata->memsize);
assert(heurdata->memsize >= 0);
/* alloc memory arrays for row information */
if( heurdata->memsize == 0 )
{
SCIP_VAR** vars;
int v;
int nvars;
SCIP_CALL( SCIPallocBufferArray(scip, &heurdata->rowinfinitiesdown, newsize) );
SCIP_CALL( SCIPallocBufferArray(scip, &heurdata->rowinfinitiesup, newsize) );
SCIP_CALL( SCIPallocBufferArray(scip, &heurdata->rowmeans, newsize) );
SCIP_CALL( SCIPallocBufferArray(scip, &heurdata->rowvariances, newsize) );
assert(SCIPgetStage(scip) == SCIP_STAGE_SOLVING);
vars = SCIPgetVars(scip);
nvars = SCIPgetNVars(scip);
assert(nvars > 0);
/* allocate variable update event processing array storage */
SCIP_CALL( SCIPallocBufferArray(scip, &heurdata->varfilterposs, nvars) );
SCIP_CALL( SCIPallocBufferArray(scip, &heurdata->varposs, nvars) );
SCIP_CALL( SCIPallocBufferArray(scip, &heurdata->updatedvars, nvars) );
SCIP_CALL( SCIPallocBufferArray(scip, &heurdata->currentubs, nvars) );
SCIP_CALL( SCIPallocBufferArray(scip, &heurdata->currentlbs, nvars) );
heurdata->varpossmemsize = nvars;
heurdata->nupdatedvars = 0;
/* init variable event processing data */
for( v = 0; v < nvars; ++v )
{
assert(SCIPvarIsActive(vars[v]));
assert(SCIPvarGetProbindex(vars[v]) == v);
/* set up variable events to catch bound changes */
SCIP_CALL( SCIPcatchVarEvent(scip, vars[v], EVENT_DISTRIBUTION, heurdata->eventhdlr, NULL, &(heurdata->varfilterposs[v])) );
assert(heurdata->varfilterposs[v] >= 0);
heurdata->varposs[v] = -1;
heurdata->updatedvars[v] = NULL;
heurdata->currentlbs[v] = SCIP_INVALID;
heurdata->currentubs[v] = SCIP_INVALID;
}
}
else
{
SCIP_CALL( SCIPreallocBufferArray(scip, &heurdata->rowinfinitiesdown, newsize) );
SCIP_CALL( SCIPreallocBufferArray(scip, &heurdata->rowinfinitiesup, newsize) );
SCIP_CALL( SCIPreallocBufferArray(scip, &heurdata->rowmeans, newsize) );
SCIP_CALL( SCIPreallocBufferArray(scip, &heurdata->rowvariances, newsize) );
}
/* loop over extended arrays and invalidate data to trigger initialization of this row when necessary */
for( r = heurdata->memsize; r < newsize; ++r )
{
heurdata->rowmeans[r] = SCIP_INVALID;
heurdata->rowvariances[r] = SCIP_INVALID;
heurdata->rowinfinitiesdown[r] = 0;
heurdata->rowinfinitiesup[r] = 0;
}
/* adjust memsize */
heurdata->memsize = newsize;
return SCIP_OKAY;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecRootsoldiving) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_VAR** vars;
SCIP_Real* rootsol;
SCIP_Real* objchgvals;
int* softroundings;
int* intvalrounds;
int nvars;
int nbinvars;
int nintvars;
int nlpcands;
SCIP_LPSOLSTAT lpsolstat;
SCIP_Real absstartobjval;
SCIP_Real objstep;
SCIP_Real alpha;
SCIP_Real oldobj;
SCIP_Real newobj;
SCIP_Bool lperror;
SCIP_Bool lpsolchanged;
SCIP_Longint nsolsfound;
SCIP_Longint ncalls;
SCIP_Longint nlpiterations;
SCIP_Longint maxnlpiterations;
int depth;
int maxdepth;
int maxdivedepth;
int divedepth;
int startnlpcands;
int ncycles;
int i;
assert(heur != NULL);
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
assert(scip != NULL);
assert(result != NULL);
assert(SCIPhasCurrentNodeLP(scip));
*result = SCIP_DELAYED;
/* only call heuristic, if an optimal LP solution is at hand */
if( SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
return SCIP_OKAY;
/* only call heuristic, if the LP solution is basic (which allows fast resolve in diving) */
if( !SCIPisLPSolBasic(scip) )
return SCIP_OKAY;
/* don't dive two times at the same node */
if( SCIPgetLastDivenode(scip) == SCIPgetNNodes(scip) && SCIPgetDepth(scip) > 0 )
return SCIP_OKAY;
*result = SCIP_DIDNOTRUN;
/* get heuristic's data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* only apply heuristic, if only a few solutions have been found */
if( heurdata->maxsols >= 0 && SCIPgetNSolsFound(scip) >= heurdata->maxsols )
return SCIP_OKAY;
/* only try to dive, if we are in the correct part of the tree, given by minreldepth and maxreldepth */
depth = SCIPgetDepth(scip);
maxdepth = SCIPgetMaxDepth(scip);
maxdepth = MAX(maxdepth, 30);
if( depth < heurdata->minreldepth*maxdepth || depth > heurdata->maxreldepth*maxdepth )
return SCIP_OKAY;
/* calculate the maximal number of LP iterations until heuristic is aborted */
nlpiterations = SCIPgetNNodeLPIterations(scip);
ncalls = SCIPheurGetNCalls(heur);
nsolsfound = 10*SCIPheurGetNBestSolsFound(heur) + heurdata->nsuccess;
maxnlpiterations = (SCIP_Longint)((1.0 + 10.0*(nsolsfound+1.0)/(ncalls+1.0)) * heurdata->maxlpiterquot * nlpiterations);
maxnlpiterations += heurdata->maxlpiterofs;
/* don't try to dive, if we took too many LP iterations during diving */
if( heurdata->nlpiterations >= maxnlpiterations )
return SCIP_OKAY;
/* allow at least a certain number of LP iterations in this dive */
maxnlpiterations = MAX(maxnlpiterations, heurdata->nlpiterations + MINLPITER);
/* get number of fractional variables, that should be integral */
nlpcands = SCIPgetNLPBranchCands(scip);
/* don't try to dive, if there are no fractional variables */
if( nlpcands == 0 )
return SCIP_OKAY;
/* calculate the maximal diving depth */
nvars = SCIPgetNBinVars(scip) + SCIPgetNIntVars(scip);
if( SCIPgetNSolsFound(scip) == 0 )
maxdivedepth = (int)(heurdata->depthfacnosol * nvars);
else
maxdivedepth = (int)(heurdata->depthfac * nvars);
maxdivedepth = MAX(maxdivedepth, 10);
*result = SCIP_DIDNOTFIND;
/* get all variables of LP */
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, &nbinvars, &nintvars, NULL, NULL) );
/* get root solution value of all binary and integer variables */
SCIP_CALL( SCIPallocBufferArray(scip, &rootsol, nbinvars + nintvars) );
for( i = 0; i < nbinvars + nintvars; i++ )
rootsol[i] = SCIPvarGetRootSol(vars[i]);
/* get current LP objective value, and calculate length of a single step in an objective coefficient */
absstartobjval = SCIPgetLPObjval(scip);
absstartobjval = ABS(absstartobjval);
absstartobjval = MAX(absstartobjval, 1.0);
objstep = absstartobjval / 10.0;
/* initialize array storing the preferred soft rounding directions and counting the integral value rounds */
SCIP_CALL( SCIPallocBufferArray(scip, &softroundings, nbinvars + nintvars) );
BMSclearMemoryArray(softroundings, nbinvars + nintvars);
SCIP_CALL( SCIPallocBufferArray(scip, &intvalrounds, nbinvars + nintvars) );
BMSclearMemoryArray(intvalrounds, nbinvars + nintvars);
/* allocate temporary memory for buffering objective changes */
SCIP_CALL( SCIPallocBufferArray(scip, &objchgvals, nbinvars + nintvars) );
/* start diving */
SCIP_CALL( SCIPstartDive(scip) );
SCIPdebugMessage("(node %"SCIP_LONGINT_FORMAT") executing rootsoldiving heuristic: depth=%d, %d fractionals, dualbound=%g, maxnlpiterations=%"SCIP_LONGINT_FORMAT", maxdivedepth=%d, LPobj=%g, objstep=%g\n",
SCIPgetNNodes(scip), SCIPgetDepth(scip), nlpcands, SCIPgetDualbound(scip), maxnlpiterations, maxdivedepth,
SCIPgetLPObjval(scip), objstep);
lperror = FALSE;
divedepth = 0;
lpsolstat = SCIP_LPSOLSTAT_OPTIMAL;
alpha = heurdata->alpha;
ncycles = 0;
lpsolchanged = TRUE;
startnlpcands = nlpcands;
while( !lperror && lpsolstat == SCIP_LPSOLSTAT_OPTIMAL && nlpcands > 0 && ncycles < 10
&& (divedepth < 10
|| nlpcands <= startnlpcands - divedepth/2
|| (divedepth < maxdivedepth && heurdata->nlpiterations < maxnlpiterations))
&& !SCIPisStopped(scip) )
{
SCIP_Bool success;
int hardroundingidx;
int hardroundingdir;
SCIP_Real hardroundingoldbd;
SCIP_Real hardroundingnewbd;
SCIP_Bool boundschanged;
SCIP_RETCODE retcode;
/* create solution from diving LP and try to round it */
SCIP_CALL( SCIPlinkLPSol(scip, heurdata->sol) );
SCIP_CALL( SCIProundSol(scip, heurdata->sol, &success) );
if( success )
{
SCIPdebugMessage("rootsoldiving found roundable primal solution: obj=%g\n", SCIPgetSolOrigObj(scip, heurdata->sol));
/* try to add solution to SCIP */
SCIP_CALL( SCIPtrySol(scip, heurdata->sol, FALSE, FALSE, FALSE, FALSE, &success) );
/* check, if solution was feasible and good enough */
if( success )
{
SCIPdebugMessage(" -> solution was feasible and good enough\n");
*result = SCIP_FOUNDSOL;
}
}
divedepth++;
hardroundingidx = -1;
hardroundingdir = 0;
hardroundingoldbd = 0.0;
hardroundingnewbd = 0.0;
boundschanged = FALSE;
SCIPdebugMessage("dive %d/%d, LP iter %"SCIP_LONGINT_FORMAT"/%"SCIP_LONGINT_FORMAT":\n", divedepth, maxdivedepth, heurdata->nlpiterations, maxnlpiterations);
/* round solution x* from diving LP:
* - x~_j = down(x*_j) if x*_j is integer or binary variable and x*_j <= root solution_j
* - x~_j = up(x*_j) if x*_j is integer or binary variable and x*_j > root solution_j
* - x~_j = x*_j if x*_j is continuous variable
* change objective function in diving LP:
* - if x*_j is integral, or j is a continuous variable, set obj'_j = alpha * obj_j
* - otherwise, set obj'_j = alpha * obj_j + sign(x*_j - x~_j)
*/
for( i = 0; i < nbinvars + nintvars; i++ )
{
SCIP_VAR* var;
SCIP_Real solval;
var = vars[i];
oldobj = SCIPgetVarObjDive(scip, var);
newobj = oldobj;
solval = SCIPvarGetLPSol(var);
if( SCIPisFeasIntegral(scip, solval) )
{
/* if the variable became integral after a soft rounding, count the rounds; after a while, fix it to its
* current integral value;
* otherwise, fade out the objective value
*/
if( softroundings[i] != 0 && lpsolchanged )
{
intvalrounds[i]++;
if( intvalrounds[i] == 5 && SCIPgetVarLbDive(scip, var) < SCIPgetVarUbDive(scip, var) - 0.5 )
{
/* use exact integral value, if the variable is only integral within numerical tolerances */
solval = SCIPfloor(scip, solval+0.5);
SCIPdebugMessage(" -> fixing <%s> = %g\n", SCIPvarGetName(var), solval);
SCIP_CALL( SCIPchgVarLbDive(scip, var, solval) );
SCIP_CALL( SCIPchgVarUbDive(scip, var, solval) );
boundschanged = TRUE;
}
}
else
newobj = alpha * oldobj;
}
else if( solval <= rootsol[i] )
{
/* if the variable was soft rounded most of the time downwards, round it downwards by changing the bounds;
* otherwise, apply soft rounding by changing the objective value
*/
softroundings[i]--;
if( softroundings[i] <= -10 && hardroundingidx == -1 )
{
SCIPdebugMessage(" -> hard rounding <%s>[%g] <= %g\n",
SCIPvarGetName(var), solval, SCIPfeasFloor(scip, solval));
hardroundingidx = i;
hardroundingdir = -1;
hardroundingoldbd = SCIPgetVarUbDive(scip, var);
hardroundingnewbd = SCIPfeasFloor(scip, solval);
SCIP_CALL( SCIPchgVarUbDive(scip, var, hardroundingnewbd) );
boundschanged = TRUE;
}
else
newobj = alpha * oldobj + objstep;
}
else
{
/* if the variable was soft rounded most of the time upwards, round it upwards by changing the bounds;
* otherwise, apply soft rounding by changing the objective value
*/
softroundings[i]++;
if( softroundings[i] >= +10 && hardroundingidx == -1 )
{
SCIPdebugMessage(" -> hard rounding <%s>[%g] >= %g\n",
SCIPvarGetName(var), solval, SCIPfeasCeil(scip, solval));
hardroundingidx = i;
hardroundingdir = +1;
hardroundingoldbd = SCIPgetVarLbDive(scip, var);
hardroundingnewbd = SCIPfeasCeil(scip, solval);
SCIP_CALL( SCIPchgVarLbDive(scip, var, hardroundingnewbd) );
boundschanged = TRUE;
}
else
newobj = alpha * oldobj - objstep;
}
/* remember the objective change */
objchgvals[i] = newobj;
}
/* apply objective changes if there was no bound change */
if( !boundschanged )
{
/* apply cached changes on integer variables */
for( i = 0; i < nbinvars + nintvars; ++i )
{
SCIP_VAR* var;
var = vars[i];
SCIPdebugMessage(" -> i=%d var <%s>, solval=%g, rootsol=%g, oldobj=%g, newobj=%g\n",
i, SCIPvarGetName(var), SCIPvarGetLPSol(var), rootsol[i], SCIPgetVarObjDive(scip, var), objchgvals[i]);
SCIP_CALL( SCIPchgVarObjDive(scip, var, objchgvals[i]) );
}
/* fade out the objective values of the continuous variables */
for( i = nbinvars + nintvars; i < nvars; i++ )
{
SCIP_VAR* var;
var = vars[i];
oldobj = SCIPgetVarObjDive(scip, var);
newobj = alpha * oldobj;
SCIPdebugMessage(" -> i=%d var <%s>, solval=%g, oldobj=%g, newobj=%g\n",
i, SCIPvarGetName(var), SCIPvarGetLPSol(var), oldobj, newobj);
SCIP_CALL( SCIPchgVarObjDive(scip, var, newobj) );
}
}
SOLVEAGAIN:
/* resolve the diving LP */
nlpiterations = SCIPgetNLPIterations(scip);
retcode = SCIPsolveDiveLP(scip, MAX((int)(maxnlpiterations - heurdata->nlpiterations), MINLPITER), &lperror);
lpsolstat = SCIPgetLPSolstat(scip);
/* Errors in the LP solver should not kill the overall solving process, if the LP is just needed for a heuristic.
* Hence in optimized mode, the return code is caught and a warning is printed, only in debug mode, SCIP will stop.
*/
if( retcode != SCIP_OKAY )
{
#ifndef NDEBUG
if( lpsolstat != SCIP_LPSOLSTAT_UNBOUNDEDRAY )
{
SCIP_CALL( retcode );
}
#endif
SCIPwarningMessage(scip, "Error while solving LP in Rootsoldiving heuristic; LP solve terminated with code <%d>\n", retcode);
SCIPwarningMessage(scip, "This does not affect the remaining solution procedure --> continue\n");
}
if( lperror )
break;
/* update iteration count */
heurdata->nlpiterations += SCIPgetNLPIterations(scip) - nlpiterations;
/* if no LP iterations were performed, we stayed at the same solution -> count this cycling */
lpsolchanged = (SCIPgetNLPIterations(scip) != nlpiterations);
if( lpsolchanged )
ncycles = 0;
else if( !boundschanged ) /* do not count if integral variables have been fixed */
ncycles++;
/* get LP solution status and number of fractional variables, that should be integral */
if( lpsolstat == SCIP_LPSOLSTAT_INFEASIBLE && hardroundingidx != -1 )
{
SCIP_VAR* var;
var = vars[hardroundingidx];
/* round the hard rounded variable to the opposite direction and resolve the LP */
if( hardroundingdir == -1 )
{
SCIPdebugMessage(" -> opposite hard rounding <%s> >= %g\n", SCIPvarGetName(var), hardroundingnewbd + 1.0);
SCIP_CALL( SCIPchgVarUbDive(scip, var, hardroundingoldbd) );
SCIP_CALL( SCIPchgVarLbDive(scip, var, hardroundingnewbd + 1.0) );
}
else
{
SCIPdebugMessage(" -> opposite hard rounding <%s> <= %g\n", SCIPvarGetName(var), hardroundingnewbd - 1.0);
SCIP_CALL( SCIPchgVarLbDive(scip, var, hardroundingoldbd) );
SCIP_CALL( SCIPchgVarUbDive(scip, var, hardroundingnewbd - 1.0) );
}
hardroundingidx = -1;
goto SOLVEAGAIN;
}
if( lpsolstat == SCIP_LPSOLSTAT_OPTIMAL )
nlpcands = SCIPgetNLPBranchCands(scip);
SCIPdebugMessage(" -> lpsolstat=%d, nfrac=%d\n", lpsolstat, nlpcands);
}
SCIPdebugMessage("---> diving finished: lpsolstat = %d, depth %d/%d, LP iter %"SCIP_LONGINT_FORMAT"/%"SCIP_LONGINT_FORMAT"\n",
lpsolstat, divedepth, maxdivedepth, heurdata->nlpiterations, maxnlpiterations);
/* check if a solution has been found */
if( nlpcands == 0 && !lperror && lpsolstat == SCIP_LPSOLSTAT_OPTIMAL )
{
SCIP_Bool success;
/* create solution from diving LP */
SCIP_CALL( SCIPlinkLPSol(scip, heurdata->sol) );
SCIPdebugMessage("rootsoldiving found primal solution: obj=%g\n", SCIPgetSolOrigObj(scip, heurdata->sol));
/* try to add solution to SCIP */
SCIP_CALL( SCIPtrySol(scip, heurdata->sol, FALSE, FALSE, FALSE, FALSE, &success) );
/* check, if solution was feasible and good enough */
if( success )
{
SCIPdebugMessage(" -> solution was feasible and good enough\n");
*result = SCIP_FOUNDSOL;
}
}
/* end diving */
SCIP_CALL( SCIPendDive(scip) );
if( *result == SCIP_FOUNDSOL )
heurdata->nsuccess++;
/* free temporary memory */
SCIPfreeBufferArray(scip, &objchgvals);
SCIPfreeBufferArray(scip, &intvalrounds);
SCIPfreeBufferArray(scip, &softroundings);
SCIPfreeBufferArray(scip, &rootsol);
SCIPdebugMessage("rootsoldiving heuristic finished\n");
return SCIP_OKAY;
}
/** returns a variable, that pushes activity of the row in the given direction with minimal negative impact on other rows;
* if variables have equal impact, chooses the one with best objective value improvement in corresponding direction;
* rounding in a direction is forbidden, if this forces the objective value over the upper bound
*/
static
SCIP_RETCODE selectRounding(
SCIP* scip, /**< SCIP data structure */
SCIP_SOL* sol, /**< primal solution */
SCIP_Real minobj, /**< minimal objective value possible after rounding remaining fractional vars */
SCIP_ROW* row, /**< LP row */
int direction, /**< should the activity be increased (+1) or decreased (-1)? */
SCIP_VAR** roundvar, /**< pointer to store the rounding variable, returns NULL if impossible */
SCIP_Real* oldsolval, /**< pointer to store old (fractional) solution value of rounding variable */
SCIP_Real* newsolval /**< pointer to store new (rounded) solution value of rounding variable */
)
{
SCIP_COL* col;
SCIP_VAR* var;
SCIP_Real val;
SCIP_COL** rowcols;
SCIP_Real* rowvals;
SCIP_Real solval;
SCIP_Real roundval;
SCIP_Real obj;
SCIP_Real deltaobj;
SCIP_Real bestdeltaobj;
SCIP_VARTYPE vartype;
int nrowcols;
int nlocks;
int minnlocks;
int c;
assert(direction == +1 || direction == -1);
assert(roundvar != NULL);
assert(oldsolval != NULL);
assert(newsolval != NULL);
/* get row entries */
rowcols = SCIProwGetCols(row);
rowvals = SCIProwGetVals(row);
nrowcols = SCIProwGetNLPNonz(row);
/* select rounding variable */
minnlocks = INT_MAX;
bestdeltaobj = SCIPinfinity(scip);
*roundvar = NULL;
for( c = 0; c < nrowcols; ++c )
{
col = rowcols[c];
var = SCIPcolGetVar(col);
vartype = SCIPvarGetType(var);
if( vartype == SCIP_VARTYPE_BINARY || vartype == SCIP_VARTYPE_INTEGER )
{
solval = SCIPgetSolVal(scip, sol, var);
if( !SCIPisFeasIntegral(scip, solval) )
{
val = rowvals[c];
obj = SCIPvarGetObj(var);
if( direction * val < 0.0 )
{
/* rounding down */
nlocks = SCIPvarGetNLocksDown(var);
if( nlocks <= minnlocks )
{
roundval = SCIPfeasFloor(scip, solval);
deltaobj = obj * (roundval - solval);
if( (nlocks < minnlocks || deltaobj < bestdeltaobj) && minobj - obj < SCIPgetCutoffbound(scip) )
{
minnlocks = nlocks;
bestdeltaobj = deltaobj;
*roundvar = var;
*oldsolval = solval;
*newsolval = roundval;
}
}
}
else
{
/* rounding up */
assert(direction * val > 0.0);
nlocks = SCIPvarGetNLocksUp(var);
if( nlocks <= minnlocks )
{
roundval = SCIPfeasCeil(scip, solval);
deltaobj = obj * (roundval - solval);
if( (nlocks < minnlocks || deltaobj < bestdeltaobj) && minobj + obj < SCIPgetCutoffbound(scip) )
{
minnlocks = nlocks;
bestdeltaobj = deltaobj;
*roundvar = var;
*oldsolval = solval;
*newsolval = roundval;
}
}
}
}
}
}
return SCIP_OKAY;
}
/** returns a fractional variable, that has most impact on rows in opposite direction, i.e. that is most crucial to
* fix in the other direction;
* if variables have equal impact, chooses the one with best objective value improvement in corresponding direction;
* rounding in a direction is forbidden, if this forces the objective value over the upper bound
*/
static
SCIP_RETCODE selectEssentialRounding(
SCIP* scip, /**< SCIP data structure */
SCIP_SOL* sol, /**< primal solution */
SCIP_Real minobj, /**< minimal objective value possible after rounding remaining fractional vars */
SCIP_VAR** lpcands, /**< fractional variables in LP */
int nlpcands, /**< number of fractional variables in LP */
SCIP_VAR** roundvar, /**< pointer to store the rounding variable, returns NULL if impossible */
SCIP_Real* oldsolval, /**< old (fractional) solution value of rounding variable */
SCIP_Real* newsolval /**< new (rounded) solution value of rounding variable */
)
{
SCIP_VAR* var;
SCIP_Real solval;
SCIP_Real roundval;
SCIP_Real obj;
SCIP_Real deltaobj;
SCIP_Real bestdeltaobj;
int maxnlocks;
int nlocks;
int v;
assert(roundvar != NULL);
assert(oldsolval != NULL);
assert(newsolval != NULL);
/* select rounding variable */
maxnlocks = -1;
bestdeltaobj = SCIPinfinity(scip);
*roundvar = NULL;
for( v = 0; v < nlpcands; ++v )
{
var = lpcands[v];
assert(SCIPvarGetType(var) == SCIP_VARTYPE_BINARY || SCIPvarGetType(var) == SCIP_VARTYPE_INTEGER);
solval = SCIPgetSolVal(scip, sol, var);
if( !SCIPisFeasIntegral(scip, solval) )
{
obj = SCIPvarGetObj(var);
/* rounding down */
nlocks = SCIPvarGetNLocksUp(var);
if( nlocks >= maxnlocks )
{
roundval = SCIPfeasFloor(scip, solval);
deltaobj = obj * (roundval - solval);
if( (nlocks > maxnlocks || deltaobj < bestdeltaobj) && minobj - obj < SCIPgetCutoffbound(scip) )
{
maxnlocks = nlocks;
bestdeltaobj = deltaobj;
*roundvar = var;
*oldsolval = solval;
*newsolval = roundval;
}
}
/* rounding up */
nlocks = SCIPvarGetNLocksDown(var);
if( nlocks >= maxnlocks )
{
roundval = SCIPfeasCeil(scip, solval);
deltaobj = obj * (roundval - solval);
if( (nlocks > maxnlocks || deltaobj < bestdeltaobj) && minobj + obj < SCIPgetCutoffbound(scip) )
{
maxnlocks = nlocks;
bestdeltaobj = deltaobj;
*roundvar = var;
*oldsolval = solval;
*newsolval = roundval;
}
}
}
}
return SCIP_OKAY;
}
/**
* Selects a variable from a set of candidates by strong branching
*
* @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
* SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
*
* @note The variables in the lpcands array must have a fractional value in the current LP solution
*/
SCIP_RETCODE SCIPselectVarPseudoStrongBranching(
SCIP* scip, /**< original SCIP data structure */
SCIP_VAR** pseudocands, /**< branching candidates */
SCIP_Bool* skipdown, /**< should down branchings be skipped? */
SCIP_Bool* skipup, /**< should up branchings be skipped? */
int npseudocands, /**< number of branching candidates */
int npriopseudocands, /**< number of priority branching candidates */
SCIP_Bool allowaddcons, /**< is the branching rule allowed to add constraints? */
int* bestpseudocand, /**< best candidate for branching */
SCIP_Real* bestdown, /**< objective value of the down branch for bestcand */
SCIP_Real* bestup, /**< objective value of the up branch for bestcand */
SCIP_Real* bestscore, /**< score for bestcand */
SCIP_Bool* bestdownvalid, /**< is bestdown a valid dual bound for the down branch? */
SCIP_Bool* bestupvalid, /**< is bestup a valid dual bound for the up branch? */
SCIP_Real* provedbound, /**< proved dual bound for current subtree */
SCIP_RESULT* result /**< result pointer */
)
{
SCIP_Real lpobjval;
SCIP_Bool allcolsinlp;
SCIP_Bool exactsolve;
#ifndef NDEBUG
SCIP_Real cutoffbound;
cutoffbound = SCIPgetCutoffbound(scip);
#endif
assert(scip != NULL);
assert(pseudocands != NULL);
assert(bestpseudocand != NULL);
assert(skipdown != NULL);
assert(skipup != NULL);
assert(bestdown != NULL);
assert(bestup != NULL);
assert(bestscore != NULL);
assert(bestdownvalid != NULL);
assert(bestupvalid != NULL);
assert(provedbound != NULL);
assert(result != NULL);
assert(SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL);
/* get current LP objective bound of the local sub problem and global cutoff bound */
lpobjval = SCIPgetLPObjval(scip);
/* check, if we want to solve the problem exactly, meaning that strong branching information is not useful
* for cutting off sub problems and improving lower bounds of children
*/
exactsolve = SCIPisExactSolve(scip);
/* check, if all existing columns are in LP, and thus the strong branching results give lower bounds */
allcolsinlp = SCIPallColsInLP(scip);
/* if only one candidate exists, choose this one without applying strong branching */
*bestpseudocand = 0;
*bestdown = lpobjval;
*bestup = lpobjval;
*bestdownvalid = TRUE;
*bestupvalid = TRUE;
*bestscore = -SCIPinfinity(scip);
*provedbound = lpobjval;
if( npseudocands > 1 )
{
SCIP_BRANCHRULE* branchrule;
SCIP_BRANCHRULEDATA* branchruledata;
SCIP_Real solval;
SCIP_Real down;
SCIP_Real up;
SCIP_Real downgain;
SCIP_Real upgain;
SCIP_Real score;
SCIP_Bool integral;
SCIP_Bool lperror;
SCIP_Bool downvalid;
SCIP_Bool upvalid;
SCIP_Bool downinf;
SCIP_Bool upinf;
SCIP_Bool downconflict;
SCIP_Bool upconflict;
int nsbcalls;
int i;
int c;
branchrule = SCIPfindBranchrule(scip, BRANCHRULE_NAME);
assert(branchrule != NULL);
/* get branching rule data */
branchruledata = SCIPbranchruleGetData(branchrule);
assert(branchruledata != NULL);
/* initialize strong branching */
SCIP_CALL( SCIPstartStrongbranch(scip, FALSE) );
/* search the full strong candidate:
* cycle through the candidates, starting with the position evaluated in the last run
*/
nsbcalls = 0;
for( i = 0, c = branchruledata->lastcand; i < npseudocands; ++i, ++c )
{
c = c % npseudocands;
assert(pseudocands[c] != NULL);
/* we can only apply strong branching on COLUMN variables that are in the current LP */
if( !SCIPvarIsInLP(pseudocands[c]) )
continue;
solval = SCIPvarGetLPSol(pseudocands[c]);
integral = SCIPisFeasIntegral(scip, solval);
SCIPdebugMessage("applying strong branching on %s variable <%s>[%g,%g] with solution %g\n",
integral ? "integral" : "fractional", SCIPvarGetName(pseudocands[c]), SCIPvarGetLbLocal(pseudocands[c]),
SCIPvarGetUbLocal(pseudocands[c]), solval);
up = -SCIPinfinity(scip);
down = -SCIPinfinity(scip);
if( integral )
{
SCIP_CALL( SCIPgetVarStrongbranchInt(scip, pseudocands[c], INT_MAX,
skipdown[c] ? NULL : &down, skipup[c] ? NULL : &up, &downvalid, &upvalid, &downinf, &upinf, &downconflict, &upconflict, &lperror) );
}
else
{
SCIP_CALL( SCIPgetVarStrongbranchFrac(scip, pseudocands[c], INT_MAX,
skipdown[c] ? NULL : &down, skipup[c] ? NULL : &up, &downvalid, &upvalid, &downinf, &upinf, &downconflict, &upconflict, &lperror) );
}
nsbcalls++;
/* display node information line in root node */
if( SCIPgetDepth(scip) == 0 && nsbcalls % 100 == 0 )
{
SCIP_CALL( SCIPprintDisplayLine(scip, NULL, SCIP_VERBLEVEL_HIGH, TRUE) );
}
/* check for an error in strong branching */
if( lperror )
{
SCIPverbMessage(scip, SCIP_VERBLEVEL_HIGH, NULL,
"(node %"SCIP_LONGINT_FORMAT") error in strong branching call for variable <%s> with solution %g\n",
SCIPgetNNodes(scip), SCIPvarGetName(pseudocands[c]), solval);
break;
}
/* evaluate strong branching */
down = MAX(down, lpobjval);
up = MAX(up, lpobjval);
downgain = down - lpobjval;
upgain = up - lpobjval;
assert(!allcolsinlp || exactsolve || !downvalid || downinf == SCIPisGE(scip, down, cutoffbound));
assert(!allcolsinlp || exactsolve || !upvalid || upinf == SCIPisGE(scip, up, cutoffbound));
assert(downinf || !downconflict);
assert(upinf || !upconflict);
/* check if there are infeasible roundings */
if( downinf || upinf )
{
assert(allcolsinlp);
assert(!exactsolve);
/* if for both infeasibilities, a conflict constraint was created, we don't need to fix the variable by hand,
* but better wait for the next propagation round to fix them as an inference, and potentially produce a
* cutoff that can be analyzed
*/
if( allowaddcons && downinf == downconflict && upinf == upconflict )
{
*result = SCIP_CONSADDED;
break; /* terminate initialization loop, because constraint was added */
}
else if( downinf && upinf )
{
if( integral )
{
SCIP_Bool infeasible;
SCIP_Bool fixed;
/* both bound changes are infeasible: variable can be fixed to its current value */
SCIP_CALL( SCIPfixVar(scip, pseudocands[c], solval, &infeasible, &fixed) );
assert(!infeasible);
assert(fixed);
*result = SCIP_REDUCEDDOM;
SCIPdebugMessage(" -> integral variable <%s> is infeasible in both directions\n",
SCIPvarGetName(pseudocands[c]));
break; /* terminate initialization loop, because LP was changed */
}
else
{
/* both roundings are infeasible: the node is infeasible */
*result = SCIP_CUTOFF;
SCIPdebugMessage(" -> fractional variable <%s> is infeasible in both directions\n",
SCIPvarGetName(pseudocands[c]));
break; /* terminate initialization loop, because node is infeasible */
}
}
else if( downinf )
{
SCIP_Real newlb;
/* downwards rounding is infeasible -> change lower bound of variable to upward rounding */
newlb = SCIPfeasCeil(scip, solval);
if( SCIPvarGetLbLocal(pseudocands[c]) < newlb - 0.5 )
{
SCIP_CALL( SCIPchgVarLb(scip, pseudocands[c], newlb) );
*result = SCIP_REDUCEDDOM;
SCIPdebugMessage(" -> variable <%s> is infeasible in downward branch\n", SCIPvarGetName(pseudocands[c]));
break; /* terminate initialization loop, because LP was changed */
}
}
else
{
SCIP_Real newub;
/* upwards rounding is infeasible -> change upper bound of variable to downward rounding */
assert(upinf);
newub = SCIPfeasFloor(scip, solval);
if( SCIPvarGetUbLocal(pseudocands[c]) > newub + 0.5 )
{
SCIP_CALL( SCIPchgVarUb(scip, pseudocands[c], newub) );
*result = SCIP_REDUCEDDOM;
SCIPdebugMessage(" -> variable <%s> is infeasible in upward branch\n", SCIPvarGetName(pseudocands[c]));
break; /* terminate initialization loop, because LP was changed */
}
}
}
else if( allcolsinlp && !exactsolve && downvalid && upvalid )
{
SCIP_Real minbound;
/* the minimal lower bound of both children is a proved lower bound of the current subtree */
minbound = MIN(down, up);
*provedbound = MAX(*provedbound, minbound);
}
/* check for a better score, if we are within the maximum priority candidates */
if( c < npriopseudocands )
{
if( integral )
{
if( skipdown[c] )
{
downgain = 0.0;
score = SCIPgetBranchScore(scip, pseudocands[c], downgain, upgain);
}
else if( skipup[c] )
{
upgain = 0.0;
score = SCIPgetBranchScore(scip, pseudocands[c], downgain, upgain);
}
else
{
SCIP_Real gains[3];
gains[0] = downgain;
gains[1] = 0.0;
gains[2] = upgain;
score = SCIPgetBranchScoreMultiple(scip, pseudocands[c], 3, gains);
}
}
else
score = SCIPgetBranchScore(scip, pseudocands[c], downgain, upgain);
if( score > *bestscore )
{
*bestpseudocand = c;
*bestdown = down;
*bestup = up;
*bestdownvalid = downvalid;
*bestupvalid = upvalid;
*bestscore = score;
}
}
else
score = 0.0;
/* update pseudo cost values */
if( !downinf )
{
SCIP_CALL( SCIPupdateVarPseudocost(scip, pseudocands[c],
solval-SCIPfeasCeil(scip, solval-1.0), downgain, 1.0) );
}
if( !upinf )
{
SCIP_CALL( SCIPupdateVarPseudocost(scip, pseudocands[c],
solval-SCIPfeasFloor(scip, solval+1.0), upgain, 1.0) );
}
SCIPdebugMessage(" -> var <%s> (solval=%g, downgain=%g, upgain=%g, score=%g) -- best: <%s> (%g)\n",
SCIPvarGetName(pseudocands[c]), solval, downgain, upgain, score,
SCIPvarGetName(pseudocands[*bestpseudocand]), *bestscore);
}
/* remember last evaluated candidate */
branchruledata->lastcand = c;
/* end strong branching */
SCIP_CALL( SCIPendStrongbranch(scip) );
}
return SCIP_OKAY;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecShifting) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_SOL* sol;
SCIP_VAR** lpcands;
SCIP_Real* lpcandssol;
SCIP_ROW** lprows;
SCIP_Real* activities;
SCIP_ROW** violrows;
SCIP_Real* nincreases;
SCIP_Real* ndecreases;
int* violrowpos;
int* nfracsinrow;
SCIP_Real increaseweight;
SCIP_Real obj;
SCIP_Real bestshiftval;
SCIP_Real minobj;
int nlpcands;
int nlprows;
int nvars;
int nfrac;
int nviolrows;
int nprevviolrows;
int minnviolrows;
int nnonimprovingshifts;
int c;
int r;
SCIP_Longint nlps;
SCIP_Longint ncalls;
SCIP_Longint nsolsfound;
SCIP_Longint nnodes;
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
assert(scip != NULL);
assert(result != NULL);
assert(SCIPhasCurrentNodeLP(scip));
*result = SCIP_DIDNOTRUN;
/* only call heuristic, if an optimal LP solution is at hand */
if( SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
return SCIP_OKAY;
/* only call heuristic, if the LP objective value is smaller than the cutoff bound */
if( SCIPisGE(scip, SCIPgetLPObjval(scip), SCIPgetCutoffbound(scip)) )
return SCIP_OKAY;
/* get heuristic data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* don't call heuristic, if we have already processed the current LP solution */
nlps = SCIPgetNLPs(scip);
if( nlps == heurdata->lastlp )
return SCIP_OKAY;
heurdata->lastlp = nlps;
/* don't call heuristic, if it was not successful enough in the past */
ncalls = SCIPheurGetNCalls(heur);
nsolsfound = 10*SCIPheurGetNBestSolsFound(heur) + SCIPheurGetNSolsFound(heur);
nnodes = SCIPgetNNodes(scip);
if( nnodes % ((ncalls/100)/(nsolsfound+1)+1) != 0 )
return SCIP_OKAY;
/* get fractional variables, that should be integral */
/* todo check if heuristic should include implicit integer variables for its calculations */
SCIP_CALL( SCIPgetLPBranchCands(scip, &lpcands, &lpcandssol, NULL, &nlpcands, NULL, NULL) );
nfrac = nlpcands;
/* only call heuristic, if LP solution is fractional */
if( nfrac == 0 )
return SCIP_OKAY;
*result = SCIP_DIDNOTFIND;
/* get LP rows */
SCIP_CALL( SCIPgetLPRowsData(scip, &lprows, &nlprows) );
SCIPdebugMessage("executing shifting heuristic: %d LP rows, %d fractionals\n", nlprows, nfrac);
/* get memory for activities, violated rows, and row violation positions */
nvars = SCIPgetNVars(scip);
SCIP_CALL( SCIPallocBufferArray(scip, &activities, nlprows) );
SCIP_CALL( SCIPallocBufferArray(scip, &violrows, nlprows) );
SCIP_CALL( SCIPallocBufferArray(scip, &violrowpos, nlprows) );
SCIP_CALL( SCIPallocBufferArray(scip, &nfracsinrow, nlprows) );
SCIP_CALL( SCIPallocBufferArray(scip, &nincreases, nvars) );
SCIP_CALL( SCIPallocBufferArray(scip, &ndecreases, nvars) );
BMSclearMemoryArray(nfracsinrow, nlprows);
BMSclearMemoryArray(nincreases, nvars);
BMSclearMemoryArray(ndecreases, nvars);
/* get the activities for all globally valid rows;
* the rows should be feasible, but due to numerical inaccuracies in the LP solver, they can be violated
*/
nviolrows = 0;
for( r = 0; r < nlprows; ++r )
{
SCIP_ROW* row;
row = lprows[r];
assert(SCIProwGetLPPos(row) == r);
if( !SCIProwIsLocal(row) )
{
activities[r] = SCIPgetRowActivity(scip, row);
if( SCIPisFeasLT(scip, activities[r], SCIProwGetLhs(row))
|| SCIPisFeasGT(scip, activities[r], SCIProwGetRhs(row)) )
{
violrows[nviolrows] = row;
violrowpos[r] = nviolrows;
nviolrows++;
}
else
violrowpos[r] = -1;
}
}
/* calc the current number of fractional variables in rows */
for( c = 0; c < nlpcands; ++c )
addFracCounter(nfracsinrow, nlprows, lpcands[c], +1);
/* get the working solution from heuristic's local data */
sol = heurdata->sol;
assert(sol != NULL);
/* copy the current LP solution to the working solution */
SCIP_CALL( SCIPlinkLPSol(scip, sol) );
/* calculate the minimal objective value possible after rounding fractional variables */
minobj = SCIPgetSolTransObj(scip, sol);
assert(minobj < SCIPgetCutoffbound(scip));
for( c = 0; c < nlpcands; ++c )
{
obj = SCIPvarGetObj(lpcands[c]);
bestshiftval = obj > 0.0 ? SCIPfeasFloor(scip, lpcandssol[c]) : SCIPfeasCeil(scip, lpcandssol[c]);
minobj += obj * (bestshiftval - lpcandssol[c]);
}
/* try to shift remaining variables in order to become/stay feasible */
nnonimprovingshifts = 0;
minnviolrows = INT_MAX;
increaseweight = 1.0;
while( (nfrac > 0 || nviolrows > 0) && nnonimprovingshifts < MAXSHIFTINGS )
{
SCIP_VAR* shiftvar;
SCIP_Real oldsolval;
SCIP_Real newsolval;
SCIP_Bool oldsolvalisfrac;
int probindex;
SCIPdebugMessage("shifting heuristic: nfrac=%d, nviolrows=%d, obj=%g (best possible obj: %g), cutoff=%g\n",
nfrac, nviolrows, SCIPgetSolOrigObj(scip, sol), SCIPretransformObj(scip, minobj),
SCIPretransformObj(scip, SCIPgetCutoffbound(scip)));
nprevviolrows = nviolrows;
/* choose next variable to process:
* - if a violated row exists, shift a variable decreasing the violation, that has least impact on other rows
* - otherwise, shift a variable, that has strongest devastating impact on rows in opposite direction
*/
shiftvar = NULL;
oldsolval = 0.0;
newsolval = 0.0;
if( nviolrows > 0 && (nfrac == 0 || nnonimprovingshifts < MAXSHIFTINGS-1) )
{
SCIP_ROW* row;
int rowidx;
int rowpos;
int direction;
rowidx = -1;
rowpos = -1;
row = NULL;
if( nfrac > 0 )
{
for( rowidx = nviolrows-1; rowidx >= 0; --rowidx )
{
row = violrows[rowidx];
rowpos = SCIProwGetLPPos(row);
assert(violrowpos[rowpos] == rowidx);
if( nfracsinrow[rowpos] > 0 )
break;
}
}
if( rowidx == -1 )
{
rowidx = SCIPgetRandomInt(0, nviolrows-1, &heurdata->randseed);
row = violrows[rowidx];
rowpos = SCIProwGetLPPos(row);
assert(0 <= rowpos && rowpos < nlprows);
assert(violrowpos[rowpos] == rowidx);
assert(nfracsinrow[rowpos] == 0);
}
assert(violrowpos[rowpos] == rowidx);
SCIPdebugMessage("shifting heuristic: try to fix violated row <%s>: %g <= %g <= %g\n",
SCIProwGetName(row), SCIProwGetLhs(row), activities[rowpos], SCIProwGetRhs(row));
SCIPdebug( SCIP_CALL( SCIPprintRow(scip, row, NULL) ) );
/* get direction in which activity must be shifted */
assert(SCIPisFeasLT(scip, activities[rowpos], SCIProwGetLhs(row))
|| SCIPisFeasGT(scip, activities[rowpos], SCIProwGetRhs(row)));
direction = SCIPisFeasLT(scip, activities[rowpos], SCIProwGetLhs(row)) ? +1 : -1;
/* search a variable that can shift the activity in the necessary direction */
SCIP_CALL( selectShifting(scip, sol, row, activities[rowpos], direction,
nincreases, ndecreases, increaseweight, &shiftvar, &oldsolval, &newsolval) );
}
if( shiftvar == NULL && nfrac > 0 )
{
SCIPdebugMessage("shifting heuristic: search rounding variable and try to stay feasible\n");
SCIP_CALL( selectEssentialRounding(scip, sol, minobj, lpcands, nlpcands, &shiftvar, &oldsolval, &newsolval) );
}
/* check, whether shifting was possible */
if( shiftvar == NULL || SCIPisEQ(scip, oldsolval, newsolval) )
{
SCIPdebugMessage("shifting heuristic: -> didn't find a shifting variable\n");
break;
}
SCIPdebugMessage("shifting heuristic: -> shift var <%s>[%g,%g], type=%d, oldval=%g, newval=%g, obj=%g\n",
SCIPvarGetName(shiftvar), SCIPvarGetLbGlobal(shiftvar), SCIPvarGetUbGlobal(shiftvar), SCIPvarGetType(shiftvar),
oldsolval, newsolval, SCIPvarGetObj(shiftvar));
/* update row activities of globally valid rows */
SCIP_CALL( updateActivities(scip, activities, violrows, violrowpos, &nviolrows, nlprows,
shiftvar, oldsolval, newsolval) );
if( nviolrows >= nprevviolrows )
nnonimprovingshifts++;
else if( nviolrows < minnviolrows )
{
minnviolrows = nviolrows;
nnonimprovingshifts = 0;
}
/* store new solution value and decrease fractionality counter */
SCIP_CALL( SCIPsetSolVal(scip, sol, shiftvar, newsolval) );
/* update fractionality counter and minimal objective value possible after shifting remaining variables */
oldsolvalisfrac = !SCIPisFeasIntegral(scip, oldsolval)
&& (SCIPvarGetType(shiftvar) == SCIP_VARTYPE_BINARY || SCIPvarGetType(shiftvar) == SCIP_VARTYPE_INTEGER);
obj = SCIPvarGetObj(shiftvar);
if( (SCIPvarGetType(shiftvar) == SCIP_VARTYPE_BINARY || SCIPvarGetType(shiftvar) == SCIP_VARTYPE_INTEGER)
&& oldsolvalisfrac )
{
assert(SCIPisFeasIntegral(scip, newsolval));
nfrac--;
nnonimprovingshifts = 0;
minnviolrows = INT_MAX;
addFracCounter(nfracsinrow, nlprows, shiftvar, -1);
/* the rounding was already calculated into the minobj -> update only if rounding in "wrong" direction */
if( obj > 0.0 && newsolval > oldsolval )
minobj += obj;
else if( obj < 0.0 && newsolval < oldsolval )
minobj -= obj;
}
else
{
/* update minimal possible objective value */
minobj += obj * (newsolval - oldsolval);
}
/* update increase/decrease arrays */
if( !oldsolvalisfrac )
{
probindex = SCIPvarGetProbindex(shiftvar);
assert(0 <= probindex && probindex < nvars);
increaseweight *= WEIGHTFACTOR;
if( newsolval < oldsolval )
ndecreases[probindex] += increaseweight;
else
nincreases[probindex] += increaseweight;
if( increaseweight >= 1e+09 )
{
int i;
for( i = 0; i < nvars; ++i )
{
nincreases[i] /= increaseweight;
ndecreases[i] /= increaseweight;
}
increaseweight = 1.0;
}
}
SCIPdebugMessage("shifting heuristic: -> nfrac=%d, nviolrows=%d, obj=%g (best possible obj: %g)\n",
nfrac, nviolrows, SCIPgetSolOrigObj(scip, sol), SCIPretransformObj(scip, minobj));
}
/* check, if the new solution is feasible */
if( nfrac == 0 && nviolrows == 0 )
{
SCIP_Bool stored;
/* check solution for feasibility, and add it to solution store if possible
* neither integrality nor feasibility of LP rows has to be checked, because this is already
* done in the shifting heuristic itself; however, we better check feasibility of LP rows,
* because of numerical problems with activity updating
*/
SCIP_CALL( SCIPtrySol(scip, sol, FALSE, FALSE, FALSE, TRUE, &stored) );
if( stored )
{
SCIPdebugMessage("found feasible shifted solution:\n");
SCIPdebug( SCIP_CALL( SCIPprintSol(scip, sol, NULL, FALSE) ) );
*result = SCIP_FOUNDSOL;
}
}
/* free memory buffers */
SCIPfreeBufferArray(scip, &ndecreases);
SCIPfreeBufferArray(scip, &nincreases);
SCIPfreeBufferArray(scip, &nfracsinrow);
SCIPfreeBufferArray(scip, &violrowpos);
SCIPfreeBufferArray(scip, &violrows);
SCIPfreeBufferArray(scip, &activities);
return SCIP_OKAY;
}
/** returns a variable, that pushes activity of the row in the given direction with minimal negative impact on other rows;
* if variables have equal impact, chooses the one with best objective value improvement in corresponding direction;
* prefer fractional integers over other variables in order to become integral during the process;
* shifting in a direction is forbidden, if this forces the objective value over the upper bound, or if the variable
* was already shifted in the opposite direction
*/
static
SCIP_RETCODE selectShifting(
SCIP* scip, /**< SCIP data structure */
SCIP_SOL* sol, /**< primal solution */
SCIP_ROW* row, /**< LP row */
SCIP_Real rowactivity, /**< activity of LP row */
int direction, /**< should the activity be increased (+1) or decreased (-1)? */
SCIP_Real* nincreases, /**< array with weighted number of increasings per variables */
SCIP_Real* ndecreases, /**< array with weighted number of decreasings per variables */
SCIP_Real increaseweight, /**< current weight of increase/decrease updates */
SCIP_VAR** shiftvar, /**< pointer to store the shifting variable, returns NULL if impossible */
SCIP_Real* oldsolval, /**< pointer to store old solution value of shifting variable */
SCIP_Real* newsolval /**< pointer to store new (shifted) solution value of shifting variable */
)
{
SCIP_COL** rowcols;
SCIP_Real* rowvals;
int nrowcols;
SCIP_Real activitydelta;
SCIP_Real bestshiftscore;
SCIP_Real bestdeltaobj;
int c;
assert(direction == +1 || direction == -1);
assert(nincreases != NULL);
assert(ndecreases != NULL);
assert(shiftvar != NULL);
assert(oldsolval != NULL);
assert(newsolval != NULL);
/* get row entries */
rowcols = SCIProwGetCols(row);
rowvals = SCIProwGetVals(row);
nrowcols = SCIProwGetNLPNonz(row);
/* calculate how much the activity must be shifted in order to become feasible */
activitydelta = (direction == +1 ? SCIProwGetLhs(row) - rowactivity : SCIProwGetRhs(row) - rowactivity);
assert((direction == +1 && SCIPisPositive(scip, activitydelta))
|| (direction == -1 && SCIPisNegative(scip, activitydelta)));
/* select shifting variable */
bestshiftscore = SCIP_REAL_MAX;
bestdeltaobj = SCIPinfinity(scip);
*shiftvar = NULL;
*newsolval = 0.0;
*oldsolval = 0.0;
for( c = 0; c < nrowcols; ++c )
{
SCIP_COL* col;
SCIP_VAR* var;
SCIP_Real val;
SCIP_Real solval;
SCIP_Real shiftval;
SCIP_Real shiftscore;
SCIP_Bool isinteger;
SCIP_Bool isfrac;
SCIP_Bool increase;
col = rowcols[c];
var = SCIPcolGetVar(col);
val = rowvals[c];
assert(!SCIPisZero(scip, val));
solval = SCIPgetSolVal(scip, sol, var);
isinteger = (SCIPvarGetType(var) == SCIP_VARTYPE_BINARY || SCIPvarGetType(var) == SCIP_VARTYPE_INTEGER);
isfrac = isinteger && !SCIPisFeasIntegral(scip, solval);
increase = (direction * val > 0.0);
/* calculate the score of the shifting (prefer smaller values) */
if( isfrac )
shiftscore = increase ? -1.0 / (SCIPvarGetNLocksUp(var) + 1.0) :
-1.0 / (SCIPvarGetNLocksDown(var) + 1.0);
else
{
int probindex;
probindex = SCIPvarGetProbindex(var);
if( increase )
shiftscore = ndecreases[probindex]/increaseweight;
else
shiftscore = nincreases[probindex]/increaseweight;
if( isinteger )
shiftscore += 1.0;
}
if( shiftscore <= bestshiftscore )
{
SCIP_Real deltaobj;
if( !increase )
{
/* shifting down */
assert(direction * val < 0.0);
if( isfrac )
shiftval = SCIPfeasFloor(scip, solval);
else
{
SCIP_Real lb;
assert(activitydelta/val < 0.0);
shiftval = solval + activitydelta/val;
assert(shiftval <= solval); /* may be equal due to numerical digit erasement in the subtraction */
if( SCIPvarIsIntegral(var) )
shiftval = SCIPfeasFloor(scip, shiftval);
lb = SCIPvarGetLbGlobal(var);
shiftval = MAX(shiftval, lb);
}
}
else
{
/* shifting up */
assert(direction * val > 0.0);
if( isfrac )
shiftval = SCIPfeasCeil(scip, solval);
else
{
SCIP_Real ub;
assert(activitydelta/val > 0.0);
shiftval = solval + activitydelta/val;
assert(shiftval >= solval); /* may be equal due to numerical digit erasement in the subtraction */
if( SCIPvarIsIntegral(var) )
shiftval = SCIPfeasCeil(scip, shiftval);
ub = SCIPvarGetUbGlobal(var);
shiftval = MIN(shiftval, ub);
}
}
if( SCIPisEQ(scip, shiftval, solval) )
continue;
deltaobj = SCIPvarGetObj(var) * (shiftval - solval);
if( shiftscore < bestshiftscore || deltaobj < bestdeltaobj )
{
bestshiftscore = shiftscore;
bestdeltaobj = deltaobj;
*shiftvar = var;
*oldsolval = solval;
*newsolval = shiftval;
}
}
}
return SCIP_OKAY;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecActconsdiving) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_LPSOLSTAT lpsolstat;
SCIP_VAR* var;
SCIP_VAR** lpcands;
SCIP_Real* lpcandssol;
SCIP_Real* lpcandsfrac;
SCIP_Real searchubbound;
SCIP_Real searchavgbound;
SCIP_Real searchbound;
SCIP_Real objval;
SCIP_Real oldobjval;
SCIP_Real frac;
SCIP_Real bestfrac;
SCIP_Bool bestcandmayrounddown;
SCIP_Bool bestcandmayroundup;
SCIP_Bool bestcandroundup;
SCIP_Bool mayrounddown;
SCIP_Bool mayroundup;
SCIP_Bool roundup;
SCIP_Bool lperror;
SCIP_Bool cutoff;
SCIP_Bool backtracked;
SCIP_Longint ncalls;
SCIP_Longint nsolsfound;
SCIP_Longint nlpiterations;
SCIP_Longint maxnlpiterations;
int nlpcands;
int startnlpcands;
int depth;
int maxdepth;
int maxdivedepth;
int divedepth;
SCIP_Real actscore;
SCIP_Real downscore;
SCIP_Real upscore;
SCIP_Real bestactscore;
int bestcand;
int c;
assert(heur != NULL);
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
assert(scip != NULL);
assert(result != NULL);
assert(SCIPhasCurrentNodeLP(scip));
*result = SCIP_DELAYED;
/* do not call heuristic of node was already detected to be infeasible */
if( nodeinfeasible )
return SCIP_OKAY;
/* only call heuristic, if an optimal LP solution is at hand */
if( SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
return SCIP_OKAY;
/* only call heuristic, if the LP objective value is smaller than the cutoff bound */
if( SCIPisGE(scip, SCIPgetLPObjval(scip), SCIPgetCutoffbound(scip)) )
return SCIP_OKAY;
/* only call heuristic, if the LP solution is basic (which allows fast resolve in diving) */
if( !SCIPisLPSolBasic(scip) )
return SCIP_OKAY;
/* don't dive two times at the same node */
if( SCIPgetLastDivenode(scip) == SCIPgetNNodes(scip) && SCIPgetDepth(scip) > 0 )
return SCIP_OKAY;
*result = SCIP_DIDNOTRUN;
/* get heuristic's data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* only try to dive, if we are in the correct part of the tree, given by minreldepth and maxreldepth */
depth = SCIPgetDepth(scip);
maxdepth = SCIPgetMaxDepth(scip);
maxdepth = MAX(maxdepth, 30);
if( depth < heurdata->minreldepth*maxdepth || depth > heurdata->maxreldepth*maxdepth )
return SCIP_OKAY;
/* calculate the maximal number of LP iterations until heuristic is aborted */
nlpiterations = SCIPgetNNodeLPIterations(scip);
ncalls = SCIPheurGetNCalls(heur);
nsolsfound = 10*SCIPheurGetNBestSolsFound(heur) + heurdata->nsuccess;
maxnlpiterations = (SCIP_Longint)((1.0 + 10.0*(nsolsfound+1.0)/(ncalls+1.0)) * heurdata->maxlpiterquot * nlpiterations);
maxnlpiterations += heurdata->maxlpiterofs;
/* don't try to dive, if we took too many LP iterations during diving */
if( heurdata->nlpiterations >= maxnlpiterations )
return SCIP_OKAY;
/* allow at least a certain number of LP iterations in this dive */
maxnlpiterations = MAX(maxnlpiterations, heurdata->nlpiterations + MINLPITER);
/* get fractional variables that should be integral */
SCIP_CALL( SCIPgetLPBranchCands(scip, &lpcands, &lpcandssol, &lpcandsfrac, &nlpcands, NULL, NULL) );
/* don't try to dive, if there are no fractional variables */
if( nlpcands == 0 )
return SCIP_OKAY;
/* calculate the objective search bound */
if( SCIPgetNSolsFound(scip) == 0 )
{
if( heurdata->maxdiveubquotnosol > 0.0 )
searchubbound = SCIPgetLowerbound(scip)
+ heurdata->maxdiveubquotnosol * (SCIPgetCutoffbound(scip) - SCIPgetLowerbound(scip));
else
searchubbound = SCIPinfinity(scip);
if( heurdata->maxdiveavgquotnosol > 0.0 )
searchavgbound = SCIPgetLowerbound(scip)
+ heurdata->maxdiveavgquotnosol * (SCIPgetAvgLowerbound(scip) - SCIPgetLowerbound(scip));
else
searchavgbound = SCIPinfinity(scip);
}
else
{
if( heurdata->maxdiveubquot > 0.0 )
searchubbound = SCIPgetLowerbound(scip)
+ heurdata->maxdiveubquot * (SCIPgetCutoffbound(scip) - SCIPgetLowerbound(scip));
else
searchubbound = SCIPinfinity(scip);
if( heurdata->maxdiveavgquot > 0.0 )
searchavgbound = SCIPgetLowerbound(scip)
+ heurdata->maxdiveavgquot * (SCIPgetAvgLowerbound(scip) - SCIPgetLowerbound(scip));
else
searchavgbound = SCIPinfinity(scip);
}
searchbound = MIN(searchubbound, searchavgbound);
if( SCIPisObjIntegral(scip) )
searchbound = SCIPceil(scip, searchbound);
/* calculate the maximal diving depth: 10 * min{number of integer variables, max depth} */
maxdivedepth = SCIPgetNBinVars(scip) + SCIPgetNIntVars(scip);
maxdivedepth = MIN(maxdivedepth, maxdepth);
maxdivedepth *= 10;
*result = SCIP_DIDNOTFIND;
/* start diving */
SCIP_CALL( SCIPstartProbing(scip) );
/* enables collection of variable statistics during probing */
SCIPenableVarHistory(scip);
/* get LP objective value */
lpsolstat = SCIP_LPSOLSTAT_OPTIMAL;
objval = SCIPgetLPObjval(scip);
SCIPdebugMessage("(node %"SCIP_LONGINT_FORMAT") executing actconsdiving heuristic: depth=%d, %d fractionals, dualbound=%g, avgbound=%g, cutoffbound=%g, searchbound=%g\n",
SCIPgetNNodes(scip), SCIPgetDepth(scip), nlpcands, SCIPgetDualbound(scip), SCIPgetAvgDualbound(scip),
SCIPretransformObj(scip, SCIPgetCutoffbound(scip)), SCIPretransformObj(scip, searchbound));
/* dive as long we are in the given objective, depth and iteration limits and fractional variables exist, but
* - if possible, we dive at least with the depth 10
* - if the number of fractional variables decreased at least with 1 variable per 2 dive depths, we continue diving
*/
lperror = FALSE;
cutoff = FALSE;
divedepth = 0;
bestcandmayrounddown = FALSE;
bestcandmayroundup = FALSE;
startnlpcands = nlpcands;
while( !lperror && !cutoff && lpsolstat == SCIP_LPSOLSTAT_OPTIMAL && nlpcands > 0
&& (divedepth < 10
|| nlpcands <= startnlpcands - divedepth/2
|| (divedepth < maxdivedepth && heurdata->nlpiterations < maxnlpiterations && objval < searchbound))
&& !SCIPisStopped(scip) )
{
divedepth++;
SCIP_CALL( SCIPnewProbingNode(scip) );
/* choose variable fixing:
* - prefer variables that may not be rounded without destroying LP feasibility:
* - of these variables, round variable with least number of locks in corresponding direction
* - if all remaining fractional variables may be rounded without destroying LP feasibility:
* - round variable with least number of locks in opposite of its feasible rounding direction
*/
bestcand = -1;
bestactscore = -1.0;
bestfrac = SCIP_INVALID;
bestcandmayrounddown = TRUE;
bestcandmayroundup = TRUE;
bestcandroundup = FALSE;
for( c = 0; c < nlpcands; ++c )
{
var = lpcands[c];
mayrounddown = SCIPvarMayRoundDown(var);
mayroundup = SCIPvarMayRoundUp(var);
frac = lpcandsfrac[c];
if( mayrounddown || mayroundup )
{
/* the candidate may be rounded: choose this candidate only, if the best candidate may also be rounded */
if( bestcandmayrounddown || bestcandmayroundup )
{
/* choose rounding direction:
* - if variable may be rounded in both directions, round corresponding to the fractionality
* - otherwise, round in the infeasible direction, because feasible direction is tried by rounding
* the current fractional solution
*/
if( mayrounddown && mayroundup )
roundup = (frac > 0.5);
else
roundup = mayrounddown;
if( roundup )
frac = 1.0 - frac;
actscore = getNActiveConsScore(scip, var, &downscore, &upscore);
/* penalize too small fractions */
if( frac < 0.01 )
actscore *= 0.01;
/* prefer decisions on binary variables */
if( !SCIPvarIsBinary(var) )
actscore *= 0.01;
/* check, if candidate is new best candidate */
assert(0.0 < frac && frac < 1.0);
if( SCIPisGT(scip, actscore, bestactscore) || (SCIPisGE(scip, actscore, bestactscore) && frac < bestfrac) )
{
bestcand = c;
bestactscore = actscore;
bestfrac = frac;
bestcandmayrounddown = mayrounddown;
bestcandmayroundup = mayroundup;
bestcandroundup = roundup;
}
}
}
else
{
/* the candidate may not be rounded */
actscore = getNActiveConsScore(scip, var, &downscore, &upscore);
roundup = (downscore < upscore);
if( roundup )
frac = 1.0 - frac;
/* penalize too small fractions */
if( frac < 0.01 )
actscore *= 0.01;
/* prefer decisions on binary variables */
if( !SCIPvarIsBinary(var) )
actscore *= 0.01;
/* check, if candidate is new best candidate: prefer unroundable candidates in any case */
assert(0.0 < frac && frac < 1.0);
if( bestcandmayrounddown || bestcandmayroundup || SCIPisGT(scip, actscore, bestactscore) ||
(SCIPisGE(scip, actscore, bestactscore) && frac < bestfrac) )
{
bestcand = c;
bestactscore = actscore;
bestfrac = frac;
bestcandmayrounddown = FALSE;
bestcandmayroundup = FALSE;
bestcandroundup = roundup;
}
assert(bestfrac < SCIP_INVALID);
}
}
assert(bestcand != -1);
/* if all candidates are roundable, try to round the solution */
if( bestcandmayrounddown || bestcandmayroundup )
{
SCIP_Bool success;
/* create solution from diving LP and try to round it */
SCIP_CALL( SCIPlinkLPSol(scip, heurdata->sol) );
SCIP_CALL( SCIProundSol(scip, heurdata->sol, &success) );
if( success )
{
SCIPdebugMessage("actconsdiving found roundable primal solution: obj=%g\n", SCIPgetSolOrigObj(scip, heurdata->sol));
/* try to add solution to SCIP */
SCIP_CALL( SCIPtrySol(scip, heurdata->sol, FALSE, FALSE, FALSE, FALSE, &success) );
/* check, if solution was feasible and good enough */
if( success )
{
SCIPdebugMessage(" -> solution was feasible and good enough\n");
*result = SCIP_FOUNDSOL;
}
}
}
assert(bestcand != -1);
var = lpcands[bestcand];
backtracked = FALSE;
do
{
/* if the variable is already fixed or if the solution value is outside the domain, numerical troubles may have
* occured or variable was fixed by propagation while backtracking => Abort diving!
*/
if( SCIPvarGetLbLocal(var) >= SCIPvarGetUbLocal(var) - 0.5 )
{
SCIPdebugMessage("Selected variable <%s> already fixed to [%g,%g] (solval: %.9f), diving aborted \n",
SCIPvarGetName(var), SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var), lpcandssol[bestcand]);
cutoff = TRUE;
break;
}
if( SCIPisFeasLT(scip, lpcandssol[bestcand], SCIPvarGetLbLocal(var)) || SCIPisFeasGT(scip, lpcandssol[bestcand], SCIPvarGetUbLocal(var)) )
{
SCIPdebugMessage("selected variable's <%s> solution value is outside the domain [%g,%g] (solval: %.9f), diving aborted\n",
SCIPvarGetName(var), SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var), lpcandssol[bestcand]);
assert(backtracked);
break;
}
/* apply rounding of best candidate */
if( bestcandroundup == !backtracked )
{
/* round variable up */
SCIPdebugMessage(" dive %d/%d, LP iter %"SCIP_LONGINT_FORMAT"/%"SCIP_LONGINT_FORMAT": var <%s>, round=%u/%u, sol=%g, oldbounds=[%g,%g], newbounds=[%g,%g]\n",
divedepth, maxdivedepth, heurdata->nlpiterations, maxnlpiterations,
SCIPvarGetName(var), bestcandmayrounddown, bestcandmayroundup,
lpcandssol[bestcand], SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var),
SCIPfeasCeil(scip, lpcandssol[bestcand]), SCIPvarGetUbLocal(var));
SCIP_CALL( SCIPchgVarLbProbing(scip, var, SCIPfeasCeil(scip, lpcandssol[bestcand])) );
}
else
{
/* round variable down */
SCIPdebugMessage(" dive %d/%d, LP iter %"SCIP_LONGINT_FORMAT"/%"SCIP_LONGINT_FORMAT": var <%s>, round=%u/%u, sol=%g, oldbounds=[%g,%g], newbounds=[%g,%g]\n",
divedepth, maxdivedepth, heurdata->nlpiterations, maxnlpiterations,
SCIPvarGetName(var), bestcandmayrounddown, bestcandmayroundup,
lpcandssol[bestcand], SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var),
SCIPvarGetLbLocal(var), SCIPfeasFloor(scip, lpcandssol[bestcand]));
SCIP_CALL( SCIPchgVarUbProbing(scip, lpcands[bestcand], SCIPfeasFloor(scip, lpcandssol[bestcand])) );
}
/* apply domain propagation */
SCIP_CALL( SCIPpropagateProbing(scip, 0, &cutoff, NULL) );
if( !cutoff )
{
/* resolve the diving LP */
/* Errors in the LP solver should not kill the overall solving process, if the LP is just needed for a heuristic.
* Hence in optimized mode, the return code is caught and a warning is printed, only in debug mode, SCIP will stop.
*/
#ifdef NDEBUG
SCIP_RETCODE retstat;
nlpiterations = SCIPgetNLPIterations(scip);
retstat = SCIPsolveProbingLP(scip, MAX((int)(maxnlpiterations - heurdata->nlpiterations), MINLPITER), &lperror, &cutoff);
if( retstat != SCIP_OKAY )
{
SCIPwarningMessage(scip, "Error while solving LP in Actconsdiving heuristic; LP solve terminated with code <%d>\n",retstat);
}
#else
nlpiterations = SCIPgetNLPIterations(scip);
SCIP_CALL( SCIPsolveProbingLP(scip, MAX((int)(maxnlpiterations - heurdata->nlpiterations), MINLPITER), &lperror, &cutoff) );
#endif
if( lperror )
break;
/* update iteration count */
heurdata->nlpiterations += SCIPgetNLPIterations(scip) - nlpiterations;
/* get LP solution status, objective value, and fractional variables, that should be integral */
lpsolstat = SCIPgetLPSolstat(scip);
assert(cutoff || (lpsolstat != SCIP_LPSOLSTAT_OBJLIMIT && lpsolstat != SCIP_LPSOLSTAT_INFEASIBLE &&
(lpsolstat != SCIP_LPSOLSTAT_OPTIMAL || SCIPisLT(scip, SCIPgetLPObjval(scip), SCIPgetCutoffbound(scip)))));
}
/* perform backtracking if a cutoff was detected */
if( cutoff && !backtracked && heurdata->backtrack )
{
SCIPdebugMessage(" *** cutoff detected at level %d - backtracking\n", SCIPgetProbingDepth(scip));
SCIP_CALL( SCIPbacktrackProbing(scip, SCIPgetProbingDepth(scip)-1) );
SCIP_CALL( SCIPnewProbingNode(scip) );
backtracked = TRUE;
}
else
backtracked = FALSE;
}
while( backtracked );
if( !lperror && !cutoff && lpsolstat == SCIP_LPSOLSTAT_OPTIMAL )
{
/* get new objective value */
oldobjval = objval;
objval = SCIPgetLPObjval(scip);
/* update pseudo cost values */
if( SCIPisGT(scip, objval, oldobjval) )
{
if( bestcandroundup )
{
SCIP_CALL( SCIPupdateVarPseudocost(scip, lpcands[bestcand], 1.0-lpcandsfrac[bestcand],
objval - oldobjval, 1.0) );
}
else
{
SCIP_CALL( SCIPupdateVarPseudocost(scip, lpcands[bestcand], 0.0-lpcandsfrac[bestcand],
objval - oldobjval, 1.0) );
}
}
/* get new fractional variables */
SCIP_CALL( SCIPgetLPBranchCands(scip, &lpcands, &lpcandssol, &lpcandsfrac, &nlpcands, NULL, NULL) );
}
SCIPdebugMessage(" -> lpsolstat=%d, objval=%g/%g, nfrac=%d\n", lpsolstat, objval, searchbound, nlpcands);
}
/* check if a solution has been found */
if( nlpcands == 0 && !lperror && !cutoff && lpsolstat == SCIP_LPSOLSTAT_OPTIMAL )
{
SCIP_Bool success;
/* create solution from diving LP */
SCIP_CALL( SCIPlinkLPSol(scip, heurdata->sol) );
SCIPdebugMessage("actconsdiving found primal solution: obj=%g\n", SCIPgetSolOrigObj(scip, heurdata->sol));
/* try to add solution to SCIP */
SCIP_CALL( SCIPtrySol(scip, heurdata->sol, FALSE, FALSE, FALSE, FALSE, &success) );
/* check, if solution was feasible and good enough */
if( success )
{
SCIPdebugMessage(" -> solution was feasible and good enough\n");
*result = SCIP_FOUNDSOL;
}
}
/* end diving */
SCIP_CALL( SCIPendProbing(scip) );
if( *result == SCIP_FOUNDSOL )
heurdata->nsuccess++;
SCIPdebugMessage("(node %"SCIP_LONGINT_FORMAT") finished actconsdiving heuristic: %d fractionals, dive %d/%d, LP iter %"SCIP_LONGINT_FORMAT"/%"SCIP_LONGINT_FORMAT", objval=%g/%g, lpsolstat=%d, cutoff=%u\n",
SCIPgetNNodes(scip), nlpcands, divedepth, maxdivedepth, heurdata->nlpiterations, maxnlpiterations,
SCIPretransformObj(scip, objval), SCIPretransformObj(scip, searchbound), lpsolstat, cutoff);
return SCIP_OKAY;
}
/** calculate the branching score of a variable, depending on the chosen score parameter */
static
SCIP_RETCODE calcBranchScore(
SCIP* scip, /**< current SCIP */
SCIP_HEURDATA* heurdata, /**< branch rule data */
SCIP_VAR* var, /**< candidate variable */
SCIP_Real lpsolval, /**< current fractional LP-relaxation solution value */
SCIP_Real* upscore, /**< pointer to store the variable score when branching on it in upward direction */
SCIP_Real* downscore, /**< pointer to store the variable score when branching on it in downward direction */
char scoreparam /**< the score parameter of this heuristic */
)
{
SCIP_COL* varcol;
SCIP_ROW** colrows;
SCIP_Real* rowvals;
SCIP_Real varlb;
SCIP_Real varub;
SCIP_Real squaredbounddiff; /* current squared difference of variable bounds (ub - lb)^2 */
SCIP_Real newub; /* new upper bound if branching downwards */
SCIP_Real newlb; /* new lower bound if branching upwards */
SCIP_Real squaredbounddiffup; /* squared difference after branching upwards (ub - lb')^2 */
SCIP_Real squaredbounddiffdown; /* squared difference after branching downwards (ub' - lb)^2 */
SCIP_Real currentmean; /* current mean value of variable uniform distribution */
SCIP_Real meanup; /* mean value of variable uniform distribution after branching up */
SCIP_Real meandown; /* mean value of variable uniform distribution after branching down*/
SCIP_VARTYPE vartype;
int ncolrows;
int i;
SCIP_Bool onlyactiverows; /* should only rows which are active at the current node be considered? */
assert(scip != NULL);
assert(var != NULL);
assert(upscore != NULL);
assert(downscore != NULL);
assert(!SCIPisIntegral(scip, lpsolval) || SCIPvarIsBinary(var));
assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_COLUMN);
varcol = SCIPvarGetCol(var);
assert(varcol != NULL);
colrows = SCIPcolGetRows(varcol);
rowvals = SCIPcolGetVals(varcol);
ncolrows = SCIPcolGetNNonz(varcol);
varlb = SCIPvarGetLbLocal(var);
varub = SCIPvarGetUbLocal(var);
assert(SCIPisFeasLT(scip, varlb, varub));
vartype = SCIPvarGetType(var);
/* calculate mean and variance of variable uniform distribution before and after branching */
currentmean = 0.0;
squaredbounddiff = 0.0;
SCIPvarCalcDistributionParameters(scip, varlb, varub, vartype, ¤tmean, &squaredbounddiff);
/* unfixed binary variables may have an integer solution value in the LP solution, eg, at the presence of indicator constraints */
if( !SCIPvarIsBinary(var) )
{
newlb = SCIPfeasCeil(scip, lpsolval);
newub = SCIPfeasFloor(scip, lpsolval);
}
else
{
newlb = 1.0;
newub = 0.0;
}
/* calculate the variable's uniform distribution after branching up and down, respectively. */
squaredbounddiffup = 0.0;
meanup = 0.0;
SCIPvarCalcDistributionParameters(scip, newlb, varub, vartype, &meanup, &squaredbounddiffup);
/* calculate the distribution mean and variance for a variable with finite lower bound */
squaredbounddiffdown = 0.0;
meandown = 0.0;
SCIPvarCalcDistributionParameters(scip, varlb, newub, vartype, &meandown, &squaredbounddiffdown);
/* initialize the variable's up and down score */
*upscore = 0.0;
*downscore = 0.0;
onlyactiverows = FALSE;
/* loop over the variable rows and calculate the up and down score */
for( i = 0; i < ncolrows; ++i )
{
SCIP_ROW* row;
SCIP_Real changedrowmean;
SCIP_Real rowmean;
SCIP_Real rowvariance;
SCIP_Real changedrowvariance;
SCIP_Real currentrowprob;
SCIP_Real newrowprobup;
SCIP_Real newrowprobdown;
SCIP_Real squaredcoeff;
SCIP_Real rowval;
int rowinfinitiesdown;
int rowinfinitiesup;
int rowpos;
row = colrows[i];
rowval = rowvals[i];
assert(row != NULL);
/* we access the rows by their index */
rowpos = SCIProwGetIndex(row);
/* skip non-active rows if the user parameter was set this way */
if( onlyactiverows && SCIPisSumPositive(scip, SCIPgetRowLPFeasibility(scip, row)) )
continue;
/* call method to ensure sufficient data capacity */
SCIP_CALL( heurdataEnsureArraySize(scip, heurdata, rowpos) );
/* calculate row activity distribution if this is the first candidate to appear in this row */
if( heurdata->rowmeans[rowpos] == SCIP_INVALID ) /*lint !e777 doesn't like comparing floats for equality */
{
rowCalculateGauss(scip, heurdata, row, &heurdata->rowmeans[rowpos], &heurdata->rowvariances[rowpos],
&heurdata->rowinfinitiesdown[rowpos], &heurdata->rowinfinitiesup[rowpos]);
}
/* retrieve the row distribution parameters from the branch rule data */
rowmean = heurdata->rowmeans[rowpos];
rowvariance = heurdata->rowvariances[rowpos];
rowinfinitiesdown = heurdata->rowinfinitiesdown[rowpos];
rowinfinitiesup = heurdata->rowinfinitiesup[rowpos];
assert(!SCIPisNegative(scip, rowvariance));
currentrowprob = SCIProwCalcProbability(scip, row, rowmean, rowvariance,
rowinfinitiesdown, rowinfinitiesup);
/* get variable's current expected contribution to row activity */
squaredcoeff = SQUARED(rowval);
/* first, get the probability change for the row if the variable is branched on upwards. The probability
* can only be affected if the variable upper bound is finite
*/
if( !SCIPisInfinity(scip, varub) )
{
int rowinftiesdownafterbranch;
int rowinftiesupafterbranch;
/* calculate how branching would affect the row parameters */
changedrowmean = rowmean + rowval * (meanup - currentmean);
changedrowvariance = rowvariance + squaredcoeff * (squaredbounddiffup - squaredbounddiff);
changedrowvariance = MAX(0.0, changedrowvariance);
rowinftiesdownafterbranch = rowinfinitiesdown;
rowinftiesupafterbranch = rowinfinitiesup;
/* account for changes of the row's infinite bound contributions */
if( SCIPisInfinity(scip, -varlb) && rowval < 0.0 )
rowinftiesupafterbranch--;
if( SCIPisInfinity(scip, -varlb) && rowval > 0.0 )
rowinftiesdownafterbranch--;
assert(rowinftiesupafterbranch >= 0);
assert(rowinftiesdownafterbranch >= 0);
newrowprobup = SCIProwCalcProbability(scip, row, changedrowmean, changedrowvariance, rowinftiesdownafterbranch,
rowinftiesupafterbranch);
}
else
newrowprobup = currentrowprob;
/* do the same for the other branching direction */
if( !SCIPisInfinity(scip, varlb) )
{
int rowinftiesdownafterbranch;
int rowinftiesupafterbranch;
changedrowmean = rowmean + rowval * (meandown - currentmean);
changedrowvariance = rowvariance + squaredcoeff * (squaredbounddiffdown - squaredbounddiff);
changedrowvariance = MAX(0.0, changedrowvariance);
rowinftiesdownafterbranch = rowinfinitiesdown;
rowinftiesupafterbranch = rowinfinitiesup;
/* account for changes of the row's infinite bound contributions */
if( SCIPisInfinity(scip, varub) && rowval > 0.0 )
rowinftiesupafterbranch -= 1;
if( SCIPisInfinity(scip, varub) && rowval < 0.0 )
rowinftiesdownafterbranch -= 1;
assert(rowinftiesdownafterbranch >= 0);
assert(rowinftiesupafterbranch >= 0);
newrowprobdown = SCIProwCalcProbability(scip, row, changedrowmean, changedrowvariance, rowinftiesdownafterbranch,
rowinftiesupafterbranch);
}
else
newrowprobdown = currentrowprob;
/* update the up and down score depending on the chosen scoring parameter */
SCIP_CALL( SCIPupdateDistributionScore(scip, currentrowprob, newrowprobup, newrowprobdown, upscore, downscore, scoreparam) );
SCIPdebugMessage(" Variable %s changes probability of row %s from %g to %g (branch up) or %g;\n",
SCIPvarGetName(var), SCIProwGetName(row), currentrowprob, newrowprobup, newrowprobdown);
SCIPdebugMessage(" --> new variable score: %g (for branching up), %g (for branching down)\n",
*upscore, *downscore);
}
return SCIP_OKAY;
}
/** perform randomized rounding of the given solution. Domain propagation is optionally applied after every rounding
* step
*/
static
SCIP_RETCODE performRandRounding(
SCIP* scip, /**< SCIP main data structure */
SCIP_HEURDATA* heurdata, /**< heuristic data */
SCIP_SOL* sol, /**< solution to round */
SCIP_VAR** cands, /**< candidate variables */
int ncands, /**< number of candidates */
SCIP_Bool propagate, /**< should the rounding be propagated? */
SCIP_RESULT* result /**< pointer to store the result of the heuristic call */
)
{
int c;
SCIP_Bool stored;
SCIP_VAR** permutedcands;
SCIP_Bool cutoff;
assert(heurdata != NULL);
/* start probing tree before rounding begins */
if( propagate )
{
SCIP_CALL( SCIPstartProbing(scip) );
SCIPenableVarHistory(scip);
}
/* copy and permute the candidate array */
SCIP_CALL( SCIPduplicateBufferArray(scip, &permutedcands, cands, ncands) );
assert(permutedcands != NULL);
SCIPpermuteArray((void **)permutedcands, 0, ncands, &heurdata->randseed);
cutoff = FALSE;
/* loop over candidates and perform randomized rounding and optionally probing. */
for (c = 0; c < ncands && !cutoff; ++c)
{
SCIP_VAR* var;
SCIP_Real oldsolval;
SCIP_Real newsolval;
SCIP_Bool mayrounddown;
SCIP_Bool mayroundup;
SCIP_Longint ndomreds;
SCIP_Real lb;
SCIP_Real ub;
SCIP_Real ceilval;
SCIP_Real floorval;
/* get next variable from permuted candidate array */
var = permutedcands[c];
oldsolval = SCIPgetSolVal(scip, sol, var);
lb = SCIPvarGetLbLocal(var);
ub = SCIPvarGetUbLocal(var);
assert( ! SCIPisFeasIntegral(scip, oldsolval) );
assert( SCIPvarGetStatus(var) == SCIP_VARSTATUS_COLUMN );
mayrounddown = SCIPvarMayRoundDown(var);
mayroundup = SCIPvarMayRoundUp(var);
ceilval = SCIPfeasCeil(scip, oldsolval);
floorval = SCIPfeasFloor(scip, oldsolval);
SCIPdebugMessage("rand rounding heuristic: var <%s>, val=%g, rounddown=%u, roundup=%u\n",
SCIPvarGetName(var), oldsolval, mayrounddown, mayroundup);
/* abort if rounded ceil and floor value lie outside the variable domain. Otherwise, check if
* bounds allow only one rounding direction, anyway */
if( lb > ceilval + 0.5 || ub < floorval - 0.5 )
{
cutoff = TRUE;
break;
}
else if( SCIPisFeasEQ(scip, lb, ceilval) )
{
/* only rounding up possible */
assert(SCIPisFeasGE(scip, ub, ceilval));
newsolval = ceilval;
}
else if( SCIPisFeasEQ(scip, ub, floorval) )
{
/* only rounding down possible */
assert(SCIPisFeasLE(scip,lb, floorval));
newsolval = floorval;
}
else if( !heurdata->usesimplerounding || !(mayroundup || mayrounddown) )
{
/* the standard randomized rounding */
SCIP_Real randnumber;
randnumber = SCIPgetRandomReal(0.0, 1.0, &heurdata->randseed);
if( randnumber <= oldsolval - floorval )
newsolval = ceilval;
else
newsolval = floorval;
}
/* choose rounding direction, if possible, or use the only direction guaranteed to be feasible */
else if( mayrounddown && mayroundup )
{
/* we can round in both directions: round in objective function direction */
if ( SCIPvarGetObj(var) >= 0.0 )
newsolval = floorval;
else
newsolval = ceilval;
}
else if( mayrounddown )
newsolval = floorval;
else
{
assert(mayroundup);
newsolval = ceilval;
}
assert(SCIPisFeasLE(scip, lb, newsolval));
assert(SCIPisFeasGE(scip, ub, newsolval));
/* if propagation is enabled, fix the candidate variable to its rounded value and propagate the solution */
if( propagate )
{
SCIP_Bool lbadjust;
SCIP_Bool ubadjust;
lbadjust = SCIPisGT(scip, newsolval, lb);
ubadjust = SCIPisLT(scip, newsolval, ub);
assert( lbadjust || ubadjust || SCIPisFeasEQ(scip, lb, ub));
/* enter a new probing node if the variable was not already fixed before */
if( lbadjust || ubadjust )
{
SCIP_RETCODE retcode;
if( SCIPisStopped(scip) )
break;
retcode = SCIPnewProbingNode(scip);
if( retcode == SCIP_MAXDEPTHLEVEL )
break;
SCIP_CALL( retcode );
/* tighten the bounds to fix the variable for the probing node */
if( lbadjust )
{
SCIP_CALL( SCIPchgVarLbProbing(scip, var, newsolval) );
}
if( ubadjust )
{
SCIP_CALL( SCIPchgVarUbProbing(scip, var, newsolval) );
}
/* call propagation routines for the reduced problem */
SCIP_CALL( SCIPpropagateProbing(scip, heurdata->maxproprounds, &cutoff, &ndomreds) );
}
}
/* store new solution value */
SCIP_CALL( SCIPsetSolVal(scip, sol, var, newsolval) );
}
/* if no cutoff was detected, the solution is a candidate to be checked for feasibility */
if( !cutoff && ! SCIPisStopped(scip) )
{
if( SCIPallColsInLP(scip) )
{
/* check solution for feasibility, and add it to solution store if possible
* neither integrality nor feasibility of LP rows has to be checked, because all fractional
* variables were already moved in feasible direction to the next integer
*/
SCIP_CALL( SCIPtrySol(scip, sol, FALSE, FALSE, FALSE, TRUE, &stored) );
}
else
{
/* if there are variables which are not present in the LP, e.g., for
* column generation, we need to check their bounds
*/
SCIP_CALL( SCIPtrySol(scip, sol, FALSE, TRUE, FALSE, TRUE, &stored) );
}
if( stored )
{
#ifdef SCIP_DEBUG
SCIPdebugMessage("found feasible rounded solution:\n");
SCIP_CALL( SCIPprintSol(scip, sol, NULL, FALSE) );
#endif
*result = SCIP_FOUNDSOL;
}
}
assert( !propagate || SCIPinProbing(scip) );
/* exit probing mode and free locally allocated memory */
if( propagate )
{
SCIP_CALL( SCIPendProbing(scip) );
}
SCIPfreeBufferArray(scip, &permutedcands);
return SCIP_OKAY;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecRounding) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_SOL* sol;
SCIP_VAR** lpcands;
SCIP_Real* lpcandssol;
SCIP_ROW** lprows;
SCIP_Real* activities;
SCIP_ROW** violrows;
int* violrowpos;
SCIP_Real obj;
SCIP_Real bestroundval;
SCIP_Real minobj;
int nlpcands;
int nlprows;
int nfrac;
int nviolrows;
int c;
int r;
SCIP_Longint nlps;
SCIP_Longint ncalls;
SCIP_Longint nsolsfound;
SCIP_Longint nnodes;
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
assert(scip != NULL);
assert(result != NULL);
assert(SCIPhasCurrentNodeLP(scip));
*result = SCIP_DIDNOTRUN;
/* only call heuristic, if an optimal LP solution is at hand */
if( SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
return SCIP_OKAY;
/* only call heuristic, if the LP objective value is smaller than the cutoff bound */
if( SCIPisGE(scip, SCIPgetLPObjval(scip), SCIPgetCutoffbound(scip)) )
return SCIP_OKAY;
/* get heuristic data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* don't call heuristic, if we have already processed the current LP solution */
nlps = SCIPgetNLPs(scip);
if( nlps == heurdata->lastlp )
return SCIP_OKAY;
heurdata->lastlp = nlps;
/* don't call heuristic, if it was not successful enough in the past */
ncalls = SCIPheurGetNCalls(heur);
nsolsfound = 10*SCIPheurGetNBestSolsFound(heur) + SCIPheurGetNSolsFound(heur);
nnodes = SCIPgetNNodes(scip);
if( nnodes % ((ncalls/heurdata->successfactor)/(nsolsfound+1)+1) != 0 )
return SCIP_OKAY;
/* get fractional variables, that should be integral */
SCIP_CALL( SCIPgetLPBranchCands(scip, &lpcands, &lpcandssol, NULL, &nlpcands, NULL, NULL) );
nfrac = nlpcands;
/* only call heuristic, if LP solution is fractional */
if( nfrac == 0 )
return SCIP_OKAY;
*result = SCIP_DIDNOTFIND;
/* get LP rows */
SCIP_CALL( SCIPgetLPRowsData(scip, &lprows, &nlprows) );
SCIPdebugMessage("executing rounding heuristic: %d LP rows, %d fractionals\n", nlprows, nfrac);
/* get memory for activities, violated rows, and row violation positions */
SCIP_CALL( SCIPallocBufferArray(scip, &activities, nlprows) );
SCIP_CALL( SCIPallocBufferArray(scip, &violrows, nlprows) );
SCIP_CALL( SCIPallocBufferArray(scip, &violrowpos, nlprows) );
/* get the activities for all globally valid rows;
* the rows should be feasible, but due to numerical inaccuracies in the LP solver, they can be violated
*/
nviolrows = 0;
for( r = 0; r < nlprows; ++r )
{
SCIP_ROW* row;
row = lprows[r];
assert(SCIProwGetLPPos(row) == r);
if( !SCIProwIsLocal(row) )
{
activities[r] = SCIPgetRowActivity(scip, row);
if( SCIPisFeasLT(scip, activities[r], SCIProwGetLhs(row))
|| SCIPisFeasGT(scip, activities[r], SCIProwGetRhs(row)) )
{
violrows[nviolrows] = row;
violrowpos[r] = nviolrows;
nviolrows++;
}
else
violrowpos[r] = -1;
}
}
/* get the working solution from heuristic's local data */
sol = heurdata->sol;
assert(sol != NULL);
/* copy the current LP solution to the working solution */
SCIP_CALL( SCIPlinkLPSol(scip, sol) );
/* calculate the minimal objective value possible after rounding fractional variables */
minobj = SCIPgetSolTransObj(scip, sol);
assert(minobj < SCIPgetCutoffbound(scip));
for( c = 0; c < nlpcands; ++c )
{
obj = SCIPvarGetObj(lpcands[c]);
bestroundval = obj > 0.0 ? SCIPfeasFloor(scip, lpcandssol[c]) : SCIPfeasCeil(scip, lpcandssol[c]);
minobj += obj * (bestroundval - lpcandssol[c]);
}
/* try to round remaining variables in order to become/stay feasible */
while( nfrac > 0 )
{
SCIP_VAR* roundvar;
SCIP_Real oldsolval;
SCIP_Real newsolval;
SCIPdebugMessage("rounding heuristic: nfrac=%d, nviolrows=%d, obj=%g (best possible obj: %g)\n",
nfrac, nviolrows, SCIPgetSolOrigObj(scip, sol), SCIPretransformObj(scip, minobj));
/* minobj < SCIPgetCutoffbound(scip) should be true, otherwise the rounding variable selection
* should have returned NULL. Due to possible cancellation we use SCIPisLE. */
assert( SCIPisLE(scip, minobj, SCIPgetCutoffbound(scip)) );
/* choose next variable to process:
* - if a violated row exists, round a variable decreasing the violation, that has least impact on other rows
* - otherwise, round a variable, that has strongest devastating impact on rows in opposite direction
*/
if( nviolrows > 0 )
{
SCIP_ROW* row;
int rowpos;
row = violrows[nviolrows-1];
rowpos = SCIProwGetLPPos(row);
assert(0 <= rowpos && rowpos < nlprows);
assert(violrowpos[rowpos] == nviolrows-1);
SCIPdebugMessage("rounding heuristic: try to fix violated row <%s>: %g <= %g <= %g\n",
SCIProwGetName(row), SCIProwGetLhs(row), activities[rowpos], SCIProwGetRhs(row));
if( SCIPisFeasLT(scip, activities[rowpos], SCIProwGetLhs(row)) )
{
/* lhs is violated: select a variable rounding, that increases the activity */
SCIP_CALL( selectIncreaseRounding(scip, sol, minobj, row, &roundvar, &oldsolval, &newsolval) );
}
else
{
assert(SCIPisFeasGT(scip, activities[rowpos], SCIProwGetRhs(row)));
/* rhs is violated: select a variable rounding, that decreases the activity */
SCIP_CALL( selectDecreaseRounding(scip, sol, minobj, row, &roundvar, &oldsolval, &newsolval) );
}
}
else
{
SCIPdebugMessage("rounding heuristic: search rounding variable and try to stay feasible\n");
SCIP_CALL( selectEssentialRounding(scip, sol, minobj, lpcands, nlpcands, &roundvar, &oldsolval, &newsolval) );
}
/* check, whether rounding was possible */
if( roundvar == NULL )
{
SCIPdebugMessage("rounding heuristic: -> didn't find a rounding variable\n");
break;
}
SCIPdebugMessage("rounding heuristic: -> round var <%s>, oldval=%g, newval=%g, obj=%g\n",
SCIPvarGetName(roundvar), oldsolval, newsolval, SCIPvarGetObj(roundvar));
/* update row activities of globally valid rows */
SCIP_CALL( updateActivities(scip, activities, violrows, violrowpos, &nviolrows, nlprows,
roundvar, oldsolval, newsolval) );
/* store new solution value and decrease fractionality counter */
SCIP_CALL( SCIPsetSolVal(scip, sol, roundvar, newsolval) );
nfrac--;
/* update minimal objective value possible after rounding remaining variables */
obj = SCIPvarGetObj(roundvar);
if( obj > 0.0 && newsolval > oldsolval )
minobj += obj;
else if( obj < 0.0 && newsolval < oldsolval )
minobj -= obj;
SCIPdebugMessage("rounding heuristic: -> nfrac=%d, nviolrows=%d, obj=%g (best possible obj: %g)\n",
nfrac, nviolrows, SCIPgetSolOrigObj(scip, sol), SCIPretransformObj(scip, minobj));
}
/* check, if the new solution is feasible */
if( nfrac == 0 && nviolrows == 0 )
{
SCIP_Bool stored;
/* check solution for feasibility, and add it to solution store if possible
* neither integrality nor feasibility of LP rows has to be checked, because this is already
* done in the rounding heuristic itself; however, be better check feasibility of LP rows,
* because of numerical problems with activity updating
*/
SCIP_CALL( SCIPtrySol(scip, sol, FALSE, FALSE, FALSE, TRUE, &stored) );
if( stored )
{
#ifdef SCIP_DEBUG
SCIPdebugMessage("found feasible rounded solution:\n");
SCIP_CALL( SCIPprintSol(scip, sol, NULL, FALSE) );
#endif
*result = SCIP_FOUNDSOL;
}
}
/* free memory buffers */
SCIPfreeBufferArray(scip, &violrowpos);
SCIPfreeBufferArray(scip, &violrows);
SCIPfreeBufferArray(scip, &activities);
return SCIP_OKAY;
}
