/** 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;
}
/** 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(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;
}
