/** adds a given value to the fractionality counters of the rows in which the given variable appears */
static
void addFracCounter(
int* nfracsinrow, /**< array to store number of fractional variables per row */
int nlprows, /**< number of rows in LP */
SCIP_VAR* var, /**< variable for which the counting should be updated */
int incval /**< value that should be added to the corresponding array entries */
)
{
SCIP_COL* col;
SCIP_ROW** rows;
int nrows;
int r;
col = SCIPvarGetCol(var);
rows = SCIPcolGetRows(col);
nrows = SCIPcolGetNLPNonz(col);
for( r = 0; r < nrows; ++r )
{
int rowidx;
rowidx = SCIProwGetLPPos(rows[r]);
assert(0 <= rowidx && rowidx < nlprows);
nfracsinrow[rowidx] += incval;
assert(nfracsinrow[rowidx] >= 0);
}
}
/** update row activities after a variable's solution value changed */
static
SCIP_RETCODE updateRowActivities(
SCIP* scip, /**< SCIP data structure */
SCIP_Real* activities, /**< LP row activities */
SCIP_VAR* var, /**< variable that has been changed */
SCIP_Real shiftval /**< value that is added to variable */
)
{
SCIP_Real* colvals;
SCIP_ROW** colrows;
SCIP_COL* col;
int ncolrows;
int i;
assert(activities != NULL);
/* get data of column associated to variable */
col = SCIPvarGetCol(var);
colrows = SCIPcolGetRows(col);
colvals = SCIPcolGetVals(col);
ncolrows = SCIPcolGetNLPNonz(col);
assert(ncolrows == 0 || (colrows != NULL && colvals != NULL));
/* enumerate all rows with nonzero entry in this column */
for( i = 0; i < ncolrows; ++i )
{
SCIP_ROW* row;
int rowpos;
row = colrows[i];
rowpos = SCIProwGetLPPos(row);
assert(-1 <= rowpos && rowpos < SCIPgetNLPRows(scip) );
/* update row activity, only regard global rows in the LP */
if( rowpos >= 0 && !SCIProwIsLocal(row) )
{
activities[rowpos] += shiftval * colvals[i];
if( SCIPisInfinity(scip, activities[rowpos]) )
activities[rowpos] = SCIPinfinity(scip);
else if( SCIPisInfinity(scip, -activities[rowpos]) )
activities[rowpos] = -SCIPinfinity(scip);
}
}
return SCIP_OKAY;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecIntdiving) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_LPSOLSTAT lpsolstat;
SCIP_VAR** pseudocands;
SCIP_VAR** fixcands;
SCIP_Real* fixcandscores;
SCIP_Real searchubbound;
SCIP_Real searchavgbound;
SCIP_Real searchbound;
SCIP_Real objval;
SCIP_Bool lperror;
SCIP_Bool cutoff;
SCIP_Bool backtracked;
SCIP_Longint ncalls;
SCIP_Longint nsolsfound;
SCIP_Longint nlpiterations;
SCIP_Longint maxnlpiterations;
int nfixcands;
int nbinfixcands;
int depth;
int maxdepth;
int maxdivedepth;
int divedepth;
int nextcand;
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, 100);
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 unfixed integer variables */
SCIP_CALL( SCIPgetPseudoBranchCands(scip, &pseudocands, &nfixcands, NULL) );
/* don't try to dive, if there are no fractional variables */
if( nfixcands == 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);
SCIPdebugMessage("(node %" SCIP_LONGINT_FORMAT ") executing intdiving heuristic: depth=%d, %d non-fixed, dualbound=%g, searchbound=%g\n",
SCIPgetNNodes(scip), SCIPgetDepth(scip), nfixcands, SCIPgetDualbound(scip), SCIPretransformObj(scip, searchbound));
/* copy the pseudo candidates into own array, because we want to reorder them */
SCIP_CALL( SCIPduplicateBufferArray(scip, &fixcands, pseudocands, nfixcands) );
/* sort non-fixed variables by non-increasing inference score, but prefer binaries over integers in any case */
SCIP_CALL( SCIPallocBufferArray(scip, &fixcandscores, nfixcands) );
nbinfixcands = 0;
for( c = 0; c < nfixcands; ++c )
{
SCIP_VAR* var;
SCIP_Real score;
int colveclen;
int left;
int right;
int i;
assert(c >= nbinfixcands);
var = fixcands[c];
assert(SCIPvarIsIntegral(var));
colveclen = (SCIPvarGetStatus(var) == SCIP_VARSTATUS_COLUMN ? SCIPcolGetNNonz(SCIPvarGetCol(var)) : 0);
if( SCIPvarIsBinary(var) )
{
score = 500.0 * SCIPvarGetNCliques(var, TRUE) + 100.0 * SCIPvarGetNImpls(var, TRUE)
+ SCIPgetVarAvgInferenceScore(scip, var) + (SCIP_Real)colveclen/100.0;
/* shift the non-binary variables one slot to the right */
for( i = c; i > nbinfixcands; --i )
{
fixcands[i] = fixcands[i-1];
fixcandscores[i] = fixcandscores[i-1];
}
/* put the new candidate into the first nbinfixcands slot */
left = 0;
right = nbinfixcands;
nbinfixcands++;
}
else
{
score = 5.0 * (SCIPvarGetNCliques(var, FALSE) + SCIPvarGetNCliques(var, TRUE))
+ SCIPvarGetNImpls(var, FALSE) + SCIPvarGetNImpls(var, TRUE) + SCIPgetVarAvgInferenceScore(scip, var)
+ (SCIP_Real)colveclen/10000.0;
/* put the new candidate in the slots after the binary candidates */
left = nbinfixcands;
right = c;
}
for( i = right; i > left && score > fixcandscores[i-1]; --i )
{
fixcands[i] = fixcands[i-1];
fixcandscores[i] = fixcandscores[i-1];
}
fixcands[i] = var;
fixcandscores[i] = score;
SCIPdebugMessage(" <%s>: ncliques=%d/%d, nimpls=%d/%d, inferencescore=%g, colveclen=%d -> score=%g\n",
SCIPvarGetName(var), SCIPvarGetNCliques(var, FALSE), SCIPvarGetNCliques(var, TRUE),
SCIPvarGetNImpls(var, FALSE), SCIPvarGetNImpls(var, TRUE), SCIPgetVarAvgInferenceScore(scip, var),
colveclen, score);
}
SCIPfreeBufferArray(scip, &fixcandscores);
/* get LP objective value */
lpsolstat = SCIP_LPSOLSTAT_OPTIMAL;
objval = SCIPgetLPObjval(scip);
/* dive as long we are in the given objective, depth and iteration limits, but if possible, we dive at least with
* the depth 10
*/
lperror = FALSE;
cutoff = FALSE;
divedepth = 0;
nextcand = 0;
while( !lperror && !cutoff && lpsolstat == SCIP_LPSOLSTAT_OPTIMAL
&& (divedepth < 10
|| (divedepth < maxdivedepth && heurdata->nlpiterations < maxnlpiterations && objval < searchbound))
&& !SCIPisStopped(scip) )
{
SCIP_VAR* var;
SCIP_Real bestsolval;
SCIP_Real bestfixval;
int bestcand;
SCIP_Longint nnewlpiterations;
SCIP_Longint nnewdomreds;
/* open a new probing node if this will not exceed the maximal tree depth, otherwise stop here */
if( SCIPgetDepth(scip) < SCIPgetDepthLimit(scip) )
{
SCIP_CALL( SCIPnewProbingNode(scip) );
divedepth++;
}
else
break;
nnewlpiterations = 0;
nnewdomreds = 0;
/* fix binary variable that is closest to 1 in the LP solution to 1;
* if all binary variables are fixed, fix integer variable with least fractionality in LP solution
*/
bestcand = -1;
bestsolval = -1.0;
bestfixval = 1.0;
/* look in the binary variables for fixing candidates */
for( c = nextcand; c < nbinfixcands; ++c )
{
SCIP_Real solval;
var = fixcands[c];
/* ignore already fixed variables */
if( var == NULL )
continue;
if( SCIPvarGetLbLocal(var) > 0.5 || SCIPvarGetUbLocal(var) < 0.5 )
{
fixcands[c] = NULL;
continue;
}
/* get the LP solution value */
solval = SCIPvarGetLPSol(var);
if( solval > bestsolval )
{
bestcand = c;
bestfixval = 1.0;
bestsolval = solval;
if( SCIPisGE(scip, bestsolval, 1.0) )
{
/* we found an unfixed binary variable with LP solution value of 1.0 - there cannot be a better candidate */
break;
}
else if( SCIPisLE(scip, bestsolval, 0.0) )
{
/* the variable is currently at 0.0 - this is the only situation where we want to fix it to 0.0 */
bestfixval = 0.0;
}
}
}
/* if all binary variables are fixed, look in the integer variables for a fixing candidate */
if( bestcand == -1 )
{
SCIP_Real bestfrac;
bestfrac = SCIP_INVALID;
for( c = MAX(nextcand, nbinfixcands); c < nfixcands; ++c )
{
SCIP_Real solval;
SCIP_Real frac;
var = fixcands[c];
/* ignore already fixed variables */
if( var == NULL )
continue;
if( SCIPvarGetUbLocal(var) - SCIPvarGetLbLocal(var) < 0.5 )
{
fixcands[c] = NULL;
continue;
}
/* get the LP solution value */
solval = SCIPvarGetLPSol(var);
frac = SCIPfrac(scip, solval);
/* ignore integer variables that are currently integral */
if( SCIPisFeasFracIntegral(scip, frac) )
continue;
if( frac < bestfrac )
{
bestcand = c;
bestsolval = solval;
bestfrac = frac;
bestfixval = SCIPfloor(scip, bestsolval + 0.5);
if( SCIPisZero(scip, bestfrac) )
{
/* we found an unfixed integer variable with integral LP solution value */
break;
}
}
}
}
assert(-1 <= bestcand && bestcand < nfixcands);
/* if there is no unfixed candidate left, we are done */
if( bestcand == -1 )
break;
var = fixcands[bestcand];
assert(var != NULL);
assert(SCIPvarIsIntegral(var));
assert(SCIPvarGetUbLocal(var) - SCIPvarGetLbLocal(var) > 0.5);
assert(SCIPisGE(scip, bestfixval, SCIPvarGetLbLocal(var)));
assert(SCIPisLE(scip, bestfixval, SCIPvarGetUbLocal(var)));
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], diving aborted \n",
SCIPvarGetName(var), SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var));
cutoff = TRUE;
break;
}
if( SCIPisFeasLT(scip, bestfixval, SCIPvarGetLbLocal(var)) || SCIPisFeasGT(scip, bestfixval, 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), bestfixval);
assert(backtracked);
break;
}
/* apply fixing of best candidate */
SCIPdebugMessage(" dive %d/%d, LP iter %" SCIP_LONGINT_FORMAT "/%" SCIP_LONGINT_FORMAT ", %d unfixed: var <%s>, sol=%g, oldbounds=[%g,%g], fixed to %g\n",
divedepth, maxdivedepth, heurdata->nlpiterations, maxnlpiterations, SCIPgetNPseudoBranchCands(scip),
SCIPvarGetName(var), bestsolval, SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var), bestfixval);
SCIP_CALL( SCIPfixVarProbing(scip, var, bestfixval) );
/* apply domain propagation */
SCIP_CALL( SCIPpropagateProbing(scip, 0, &cutoff, &nnewdomreds) );
if( !cutoff )
{
/* if the best candidate was just fixed to its LP value and no domain reduction was found, the LP solution
* stays valid, and the LP does not need to be resolved
*/
if( nnewdomreds > 0 || !SCIPisEQ(scip, bestsolval, bestfixval) )
{
/* 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 Intdiving 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 */
nnewlpiterations = SCIPgetNLPIterations(scip) - nlpiterations;
heurdata->nlpiterations += nnewlpiterations;
/* get LP solution status */
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) );
/* after backtracking there has to be at least one open node without exceeding the maximal tree depth */
assert(SCIPgetDepthLimit(scip) > SCIPgetDepth(scip));
SCIP_CALL( SCIPnewProbingNode(scip) );
bestfixval = SCIPvarIsBinary(var)
? 1.0 - bestfixval
: (SCIPisGT(scip, bestsolval, bestfixval) && SCIPisFeasLE(scip, bestfixval + 1, SCIPvarGetUbLocal(var)) ? bestfixval + 1 : bestfixval - 1);
backtracked = TRUE;
}
else
backtracked = FALSE;
}
while( backtracked );
if( !lperror && !cutoff && lpsolstat == SCIP_LPSOLSTAT_OPTIMAL )
{
SCIP_Bool success;
/* get new objective value */
objval = SCIPgetLPObjval(scip);
if( nnewlpiterations > 0 || !SCIPisEQ(scip, bestsolval, bestfixval) )
{
/* we must start again with the first candidate, since the LP solution changed */
nextcand = 0;
/* 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("intdiving 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;
}
}
}
else
nextcand = bestcand+1; /* continue with the next candidate in the following loop */
}
SCIPdebugMessage(" -> lpsolstat=%d, objval=%g/%g\n", lpsolstat, objval, searchbound);
}
/* free temporary memory */
SCIPfreeBufferArray(scip, &fixcands);
/* end diving */
SCIP_CALL( SCIPendProbing(scip) );
if( *result == SCIP_FOUNDSOL )
heurdata->nsuccess++;
SCIPdebugMessage("intdiving heuristic finished\n");
return SCIP_OKAY;
}
/** returns a score value for the given variable based on the active constraints that the variable appears in */
static
SCIP_Real getNActiveConsScore(
SCIP* scip, /**< SCIP data structure */
SCIP_VAR* var, /**< variable to get the score value for */
SCIP_Real* downscore, /**< pointer to store the score for branching downwards */
SCIP_Real* upscore /**< pointer to store the score for branching upwards */
)
{
SCIP_COL* col;
SCIP_ROW** rows;
SCIP_Real* vals;
int nrows;
int r;
int nactrows;
SCIP_Real downcoefsum;
SCIP_Real upcoefsum;
SCIP_Real score;
assert(downscore != NULL);
assert(upscore != NULL);
*downscore = 0.0;
*upscore = 0.0;
if( SCIPvarGetStatus(var) != SCIP_VARSTATUS_COLUMN )
return 0.0;
col = SCIPvarGetCol(var);
assert(col != NULL);
rows = SCIPcolGetRows(col);
vals = SCIPcolGetVals(col);
nrows = SCIPcolGetNLPNonz(col);
nactrows = 0;
downcoefsum = 0.0;
upcoefsum = 0.0;
for( r = 0; r < nrows; ++r )
{
SCIP_Real activity;
SCIP_Real lhs;
SCIP_Real rhs;
SCIP_Real dualsol;
/* calculate number of active constraint sides, i.e., count equations as two */
lhs = SCIProwGetLhs(rows[r]);
rhs = SCIProwGetRhs(rows[r]);
activity = SCIPgetRowLPActivity(scip, rows[r]);
dualsol = SCIProwGetDualsol(rows[r]);
if( SCIPisFeasEQ(scip, activity, lhs) )
{
SCIP_Real coef;
nactrows++;
coef = vals[r] / SCIProwGetNorm(rows[r]);
if( SCIPisFeasPositive(scip, dualsol) )
{
if( coef > 0.0 )
downcoefsum += coef;
else
upcoefsum -= coef;
}
}
else if( SCIPisFeasEQ(scip, activity, rhs) )
{
SCIP_Real coef;
nactrows++;
coef = vals[r] / SCIProwGetNorm(rows[r]);
if( SCIPisFeasNegative(scip, dualsol) )
{
if( coef > 0.0 )
upcoefsum += coef;
else
downcoefsum -= coef;
}
}
}
score = 1e-3*nactrows + (downcoefsum + 1e-6) * (upcoefsum + 1e-6);
*downscore = -downcoefsum;
*upscore = -upcoefsum;
return score;
}
/** determines shifting bounds for variable */
static
void calculateBounds(
SCIP* scip, /**< pointer to current SCIP data structure */
SCIP_VAR* var, /**< the variable for which lb and ub have to be calculated */
SCIP_Real currentvalue, /**< the current value of var in the working solution */
SCIP_Real* upperbound, /**< pointer to store the calculated upper bound on the variable shift */
SCIP_Real* lowerbound, /**< pointer to store the calculated lower bound on the variable shift */
SCIP_Real* upslacks, /**< array that contains the slacks between row activities and the right hand sides of the rows */
SCIP_Real* downslacks, /**< array that contains lhs slacks */
int nslacks, /**< current number of slacks */
SCIP_Bool* numericalerror /**< flag to determine whether a numerical error occurred */
)
{
SCIP_COL* col;
SCIP_ROW** colrows;
SCIP_Real* colvals;
int ncolvals;
int i;
assert(scip != NULL);
assert(var != NULL);
assert(upslacks != NULL);
assert(downslacks != NULL);
assert(upperbound != NULL);
assert(lowerbound != NULL);
/* get the column associated to the variable, the nonzero rows and the nonzero coefficients */
col = SCIPvarGetCol(var);
colrows = SCIPcolGetRows(col);
colvals = SCIPcolGetVals(col);
ncolvals = SCIPcolGetNLPNonz(col);
/* only proceed, when variable has nonzero coefficients */
if( ncolvals == 0 )
return;
assert(colvals != NULL);
assert(colrows != NULL);
/* initialize the bounds on the shift to be the gap of the current solution value to the bounds of the variable */
if( SCIPisInfinity(scip, SCIPvarGetUbGlobal(var)) )
*upperbound = SCIPinfinity(scip);
else
*upperbound = SCIPvarGetUbGlobal(var) - currentvalue;
if( SCIPisInfinity(scip, -SCIPvarGetLbGlobal(var)) )
*lowerbound = SCIPinfinity(scip);
else
*lowerbound = currentvalue - SCIPvarGetLbGlobal(var);
/* go through every nonzero row coefficient corresponding to var to determine bounds for shifting
* in such a way that shifting maintains feasibility in every LP row.
* a lower or upper bound as it is calculated in zirounding always has to be >= 0.0.
* if one of these values is significantly < 0.0, this will cause the abort of execution of the heuristic so that
* infeasible solutions are avoided
*/
for( i = 0; i < ncolvals && (*lowerbound > 0.0 || *upperbound > 0.0); ++i )
{
SCIP_ROW* row;
int rowpos;
row = colrows[i];
rowpos = SCIProwGetLPPos(row);
/* the row might currently not be in the LP, ignore it! */
if( rowpos == -1 )
continue;
assert(0 <= rowpos && rowpos < nslacks);
/* all bounds and slacks as they are calculated in zirounding always have to be greater equal zero.
* It might however be due to numerical issues, e.g. with scaling, that they are not. Better abort in this case.
*/
if( SCIPisFeasLT(scip, *lowerbound, 0.0) || SCIPisFeasLT(scip, *upperbound, 0.0)
|| SCIPisFeasLT(scip, upslacks[rowpos], 0.0) || SCIPisFeasLT(scip, downslacks[rowpos] , 0.0) )
{
*numericalerror = TRUE;
return;
}
SCIPdebugMessage("colval: %15.8g, downslack: %15.8g, upslack: %5.2g, lb: %5.2g, ub: %5.2g\n", colvals[i], downslacks[rowpos], upslacks[rowpos],
*lowerbound, *upperbound);
/* if coefficient > 0, rounding up might violate up slack and rounding down might violate down slack
* thus search for the minimum so that no constraint is violated; vice versa for coefficient < 0
*/
if( colvals[i] > 0 )
{
if( !SCIPisInfinity(scip, upslacks[rowpos]) )
{
SCIP_Real upslack;
upslack = MAX(upslacks[rowpos], 0.0); /* avoid errors due to numerically slightly infeasible rows */
*upperbound = MIN(*upperbound, upslack/colvals[i]);
}
if( !SCIPisInfinity(scip, downslacks[rowpos]) )
{
SCIP_Real downslack;
downslack = MAX(downslacks[rowpos], 0.0); /* avoid errors due to numerically slightly infeasible rows */
*lowerbound = MIN(*lowerbound, downslack/colvals[i]);
}
}
else
{
assert(colvals[i] != 0.0);
if( !SCIPisInfinity(scip, upslacks[rowpos]) )
{
SCIP_Real upslack;
upslack = MAX(upslacks[rowpos], 0.0); /* avoid errors due to numerically slightly infeasible rows */
*lowerbound = MIN(*lowerbound, -upslack/colvals[i]);
}
if( !SCIPisInfinity(scip, downslacks[rowpos]) )
{
SCIP_Real downslack;
downslack = MAX(downslacks[rowpos], 0.0); /* avoid errors due to numerically slightly infeasible rows */
*upperbound = MIN(*upperbound, -downslack/colvals[i]);
}
}
}
}
/** 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;
}
/** when a variable is shifted, the activities and slacks of all rows it appears in have to be updated */
static
SCIP_RETCODE updateSlacks(
SCIP* scip, /**< pointer to current SCIP data structure */
SCIP_SOL* sol, /**< working solution */
SCIP_VAR* var, /**< pointer to variable to be modified */
SCIP_Real shiftvalue, /**< the value by which the variable is shifted */
SCIP_Real* upslacks, /**< upslacks of all rows the variable appears in */
SCIP_Real* downslacks, /**< downslacks of all rows the variable appears in */
SCIP_Real* activities, /**< activities of the LP rows */
SCIP_VAR** slackvars, /**< the slack variables for equality rows */
SCIP_Real* slackcoeffs, /**< the slack variable coefficients */
int nslacks /**< size of the arrays */
)
{
SCIP_COL* col; /* the corresponding column of variable var */
SCIP_ROW** rows; /* pointer to the nonzero coefficient rows for variable var */
int nrows; /* the number of nonzeros */
SCIP_Real* colvals; /* array to store the nonzero coefficients */
int i;
assert(scip != NULL);
assert(sol != NULL);
assert(var != NULL);
assert(upslacks != NULL);
assert(downslacks != NULL);
assert(activities != NULL);
assert(nslacks >= 0);
col = SCIPvarGetCol(var);
assert(col != NULL);
rows = SCIPcolGetRows(col);
nrows = SCIPcolGetNLPNonz(col);
colvals = SCIPcolGetVals(col);
assert(nrows == 0 || (rows != NULL && colvals != NULL));
/* go through all rows the shifted variable appears in */
for( i = 0; i < nrows; ++i )
{
int rowpos;
rowpos = SCIProwGetLPPos(rows[i]);
assert(-1 <= rowpos && rowpos < nslacks);
/* if the row is in the LP, update its activity, up and down slack */
if( rowpos >= 0 )
{
SCIP_Real val;
val = colvals[i] * shiftvalue;
/* if the row is an equation, we update its slack variable instead of its activities */
if( SCIPisFeasEQ(scip, SCIProwGetLhs(rows[i]), SCIProwGetRhs(rows[i])) )
{
SCIP_Real slackvarshiftval;
SCIP_Real slackvarsolval;
assert(slackvars[rowpos] != NULL);
assert(!SCIPisFeasZero(scip, slackcoeffs[rowpos]));
slackvarsolval = SCIPgetSolVal(scip, sol, slackvars[rowpos]);
slackvarshiftval = -val / slackcoeffs[rowpos];
assert(SCIPisFeasGE(scip, slackvarsolval + slackvarshiftval, SCIPvarGetLbGlobal(slackvars[rowpos])));
assert(SCIPisFeasLE(scip, slackvarsolval + slackvarshiftval, SCIPvarGetUbGlobal(slackvars[rowpos])));
SCIP_CALL( SCIPsetSolVal(scip, sol, slackvars[rowpos], slackvarsolval + slackvarshiftval) );
}
else if( !SCIPisInfinity(scip, -activities[rowpos]) && !SCIPisInfinity(scip, activities[rowpos]) )
activities[rowpos] += val;
/* the slacks of the row now can be updated independently of its type */
if( !SCIPisInfinity(scip, upslacks[rowpos]) )
upslacks[rowpos] -= val;
if( !SCIPisInfinity(scip, -downslacks[rowpos]) )
downslacks[rowpos] += val;
assert(!SCIPisFeasNegative(scip, upslacks[rowpos]));
assert(!SCIPisFeasNegative(scip, downslacks[rowpos]));
}
}
return SCIP_OKAY;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecOctane)
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_SOL* sol;
SCIP_SOL** first_sols; /* stores the first ffirst sols in order to check for common violation of a row */
SCIP_VAR** vars; /* the variables of the problem */
SCIP_VAR** fracvars; /* variables, that are fractional in current LP solution */
SCIP_VAR** subspacevars; /* the variables on which the search is performed. Either coinciding with vars or with the
* space of all fractional variables of the current LP solution */
SCIP_Real p; /* n/2 - <delta,x> ( for some facet delta ) */
SCIP_Real q; /* <delta,a> */
SCIP_Real* rayorigin; /* origin of the ray, vector x in paper */
SCIP_Real* raydirection; /* direction of the ray, vector a in paper */
SCIP_Real* negquotient; /* negated quotient of rayorigin and raydirection, vector v in paper */
SCIP_Real* lambda; /* stores the distance of the facets (s.b.) to the origin of the ray */
SCIP_Bool usefracspace; /* determines whether the search concentrates on fractional variables and fixes integer ones */
SCIP_Bool cons_viol; /* used for checking whether a linear constraint is violated by one of the possible solutions */
SCIP_Bool success;
SCIP_Bool* sign; /* signature of the direction of the ray */
SCIP_Bool** facets; /* list of extended facets */
int nvars; /* number of variables */
int nbinvars; /* number of 0-1-variables */
int nfracvars; /* number of fractional variables in current LP solution */
int nsubspacevars; /* dimension of the subspace on which the search is performed */
int nfacets; /* number of facets hidden by the ray that where already found */
int i; /* counter */
int j; /* counter */
int f_max; /* {0,1}-points to be checked */
int f_first; /* {0,1}-points to be generated at first in order to check whether a restart is necessary */
int r; /* counter */
int firstrule;
int* perm; /* stores the way in which the coordinates were permuted */
int* fracspace; /* maps the variables of the subspace to the original variables */
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;
*result = SCIP_DIDNOTRUN;
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, &nbinvars, NULL, NULL, NULL) );
/* OCTANE is for use in 0-1 programs only */
if( nvars != nbinvars )
return SCIP_OKAY;
/* get heuristic's data */
heurdata = SCIPheurGetData(heur);
assert( heurdata != NULL );
/* don't call heuristic, if it was not successful enough in the past */
/*lint --e{647}*/
if( SCIPgetNNodes(scip) % (SCIPheurGetNCalls(heur) / (100 * SCIPheurGetNBestSolsFound(heur) + 10*heurdata->nsuccess + 1) + 1) != 0 )
return SCIP_OKAY;
SCIP_CALL( SCIPgetLPBranchCands(scip, &fracvars, NULL, NULL, &nfracvars, NULL) );
/* don't use integral starting points */
if( nfracvars == 0 )
return SCIP_OKAY;
/* get working pointers from heurdata */
sol = heurdata->sol;
assert( sol != NULL );
f_max = heurdata->f_max;
f_first = heurdata->f_first;
usefracspace = heurdata->usefracspace;
SCIP_CALL( SCIPallocBufferArray(scip, &fracspace, nvars) );
/* determine the space one which OCTANE should work either as the whole space or as the space of fractional variables */
if( usefracspace )
{
nsubspacevars = nfracvars;
SCIP_CALL( SCIPallocBufferArray(scip, &subspacevars, nsubspacevars) );
BMScopyMemoryArray(subspacevars, fracvars, nsubspacevars);
for( i = nvars - 1; i >= 0; --i )
fracspace[i] = -1;
for( i = nsubspacevars - 1; i >= 0; --i )
fracspace[SCIPvarGetProbindex(subspacevars[i])] = i;
}
else
{
int currentindex;
nsubspacevars = nvars;
SCIP_CALL( SCIPallocBufferArray(scip, &subspacevars, nsubspacevars) );
/* only copy the variables which are in the current LP */
currentindex = 0;
for( i = 0; i < nvars; ++i )
{
if( SCIPcolGetLPPos(SCIPvarGetCol(vars[i])) >= 0 )
{
subspacevars[currentindex] = vars[i];
fracspace[i] = currentindex;
++currentindex;
}
else
{
fracspace[i] = -1;
--nsubspacevars;
}
}
}
/* nothing to do for empty search space */
if( nsubspacevars == 0 )
return SCIP_OKAY;
assert(0 < nsubspacevars && nsubspacevars <= nvars);
for( i = 0; i < nsubspacevars; i++)
assert(fracspace[SCIPvarGetProbindex(subspacevars[i])] == i);
/* at most 2^(n-1) facets can be hit */
if( nsubspacevars < 30 )
{
/*lint --e{701}*/
assert(f_max > 0);
f_max = MIN(f_max, 1 << (nsubspacevars - 1) );
}
f_first = MIN(f_first, f_max);
/* memory allocation */
SCIP_CALL( SCIPallocBufferArray(scip, &rayorigin, nsubspacevars) );
SCIP_CALL( SCIPallocBufferArray(scip, &raydirection, nsubspacevars) );
SCIP_CALL( SCIPallocBufferArray(scip, &negquotient, nsubspacevars) );
SCIP_CALL( SCIPallocBufferArray(scip, &sign, nsubspacevars) );
SCIP_CALL( SCIPallocBufferArray(scip, &perm, nsubspacevars) );
SCIP_CALL( SCIPallocBufferArray(scip, &lambda, f_max + 1) );
SCIP_CALL( SCIPallocBufferArray(scip, &facets, f_max + 1) );
for( i = f_max; i >= 0; --i )
{
/*lint --e{866}*/
SCIP_CALL( SCIPallocBufferArray(scip, &facets[i], nsubspacevars) );
}
SCIP_CALL( SCIPallocBufferArray(scip, &first_sols, f_first) );
*result = SCIP_DIDNOTFIND;
/* starting OCTANE */
SCIPdebugMessage("run Octane heuristic on %s variables, which are %d vars, generate at most %d facets, using rule number %d\n",
usefracspace ? "fractional" : "all", nsubspacevars, f_max, (heurdata->lastrule+1)%5);
/* generate starting point in original coordinates */
SCIP_CALL( generateStartingPoint(scip, rayorigin, subspacevars, nsubspacevars) );
for( i = nsubspacevars - 1; i >= 0; --i )
rayorigin[i] -= 0.5;
firstrule = heurdata->lastrule;
++firstrule;
for( r = firstrule; r <= firstrule + 10 && !SCIPisStopped(scip); r++ )
{
SCIP_ROW** rows;
int nrows;
/* generate shooting ray in original coordinates by certain rules */
switch(r % 5)
{
case 1:
if( heurdata->useavgnbray )
{
SCIP_CALL( generateAverageNBRay(scip, raydirection, fracspace, subspacevars, nsubspacevars) );
}
break;
case 2:
if( heurdata->useobjray )
{
SCIP_CALL( generateObjectiveRay(scip, raydirection, subspacevars, nsubspacevars) );
}
break;
case 3:
if( heurdata->usediffray )
{
SCIP_CALL( generateDifferenceRay(scip, raydirection, subspacevars, nsubspacevars) );
}
break;
case 4:
if( heurdata->useavgwgtray && SCIPisLPSolBasic(scip) )
{
SCIP_CALL( generateAverageRay(scip, raydirection, subspacevars, nsubspacevars, TRUE) );
}
break;
case 0:
if( heurdata->useavgray && SCIPisLPSolBasic(scip) )
{
SCIP_CALL( generateAverageRay(scip, raydirection, subspacevars, nsubspacevars, FALSE) );
}
break;
default:
SCIPerrorMessage("invalid ray rule identifier\n");
SCIPABORT();
}
/* there must be a feasible direction for the shooting ray */
if( isZero(scip, raydirection, nsubspacevars) )
continue;
/* transform coordinates such that raydirection >= 0 */
flipCoords(rayorigin, raydirection, sign, nsubspacevars);
for( i = f_max - 1; i >= 0; --i)
lambda[i] = SCIPinfinity(scip);
/* calculate negquotient, initialize perm, facets[0], p, and q */
p = 0.5 * nsubspacevars;
q = 0.0;
for( i = nsubspacevars - 1; i >= 0; --i )
{
/* calculate negquotient, the ratio of rayorigin and raydirection, paying special attention to the case raydirection[i] == 0 */
if( SCIPisFeasZero(scip, raydirection[i]) )
{
if( rayorigin[i] < 0 )
negquotient[i] = SCIPinfinity(scip);
else
negquotient[i] = -SCIPinfinity(scip);
}
else
negquotient[i] = - (rayorigin[i] / raydirection[i]);
perm[i] = i;
/* initialization of facets[0] to the all-one facet with p and q its characteristic values */
facets[0][i] = TRUE;
p -= rayorigin[i];
q += raydirection[i];
}
assert(SCIPisPositive(scip, q));
/* resort the coordinates in nonincreasing order of negquotient */
SCIPsortDownRealRealRealBoolPtr( negquotient, raydirection, rayorigin, sign, (void**) subspacevars, nsubspacevars);
#ifndef NDEBUG
for( i = 0; i < nsubspacevars; i++ )
assert( raydirection[i] >= 0 );
for( i = 1; i < nsubspacevars; i++ )
assert( negquotient[i - 1] >= negquotient[i] );
#endif
/* finished initialization */
/* find the first facet of the octahedron hit by a ray shot from rayorigin into direction raydirection */
for( i = 0; i < nsubspacevars && negquotient[i] * q > p; ++i )
{
facets[0][i] = FALSE;
p += 2 * rayorigin[i];
q -= 2 * raydirection[i];
assert(SCIPisPositive(scip, p));
assert(SCIPisPositive(scip, q));
}
/* avoid dividing by values close to 0.0 */
if( !SCIPisFeasPositive(scip, q) )
continue;
/* assert necessary for flexelint */
assert(q > 0);
lambda[0] = p / q;
nfacets = 1;
/* find the first facets hit by the ray */
for( i = 0; i < nfacets && i < f_first; ++i)
generateNeighborFacets(scip, facets, lambda, rayorigin, raydirection, negquotient, nsubspacevars, f_max, i, &nfacets);
/* construct the first ffirst possible solutions */
for( i = 0; i < nfacets && i < f_first; ++i )
{
SCIP_CALL( SCIPcreateSol(scip, &first_sols[i], heur) );
SCIP_CALL( getSolFromFacet(scip, facets[i], first_sols[i], sign, subspacevars, nsubspacevars) );
assert( first_sols[i] != NULL );
}
/* try, whether there is a row violated by all of the first ffirst solutions */
cons_viol = FALSE;
SCIP_CALL( SCIPgetLPRowsData(scip, &rows, &nrows) );
for( i = nrows - 1; i >= 0; --i )
{
if( !SCIProwIsLocal(rows[i]) )
{
SCIP_COL** cols;
SCIP_Real constant;
SCIP_Real lhs;
SCIP_Real rhs;
SCIP_Real rowval;
SCIP_Real* coeffs;
int nnonzerovars;
int k;
/* get the row's data */
constant = SCIProwGetConstant(rows[i]);
lhs = SCIProwGetLhs(rows[i]);
rhs = SCIProwGetRhs(rows[i]);
coeffs = SCIProwGetVals(rows[i]);
nnonzerovars = SCIProwGetNNonz(rows[i]);
cols = SCIProwGetCols(rows[i]);
rowval = constant;
for( j = nnonzerovars - 1; j >= 0; --j )
rowval += coeffs[j] * SCIPgetSolVal(scip, first_sols[0], SCIPcolGetVar(cols[j]));
/* if the row's lhs is violated by the first sol, test, whether it is violated by the next ones, too */
if( lhs > rowval )
{
cons_viol = TRUE;
for( k = MIN(f_first, nfacets) - 1; k > 0; --k )
{
rowval = constant;
for( j = nnonzerovars - 1; j >= 0; --j )
rowval += coeffs[j] * SCIPgetSolVal(scip, first_sols[k], SCIPcolGetVar(cols[j]));
if( lhs <= rowval )
{
cons_viol = FALSE;
break;
}
}
}
/* dito for the right hand side */
else if( rhs < rowval )
{
cons_viol = TRUE;
for( k = MIN(f_first, nfacets) - 1; k > 0; --k )
{
rowval = constant;
for( j = nnonzerovars - 1; j >= 0; --j )
rowval += coeffs[j] * SCIPgetSolVal(scip, first_sols[k], SCIPcolGetVar(cols[j]));
if( rhs >= rowval )
{
cons_viol = FALSE;
break;
}
}
}
/* break as soon as one row is violated by all of the ffirst solutions */
if( cons_viol )
break;
}
}
if( !cons_viol )
{
/* if there was no row violated by all solutions, try whether one or more of them are feasible */
for( i = MIN(f_first, nfacets) - 1; i >= 0; --i )
{
assert(first_sols[i] != NULL);
SCIP_CALL( SCIPtrySol(scip, first_sols[i], FALSE, TRUE, FALSE, TRUE, &success) );
if( success )
*result = SCIP_FOUNDSOL;
}
/* search for further facets and construct and try solutions out of facets fixed as closest ones */
for( i = f_first; i < f_max; ++i)
{
if( i >= nfacets )
break;
generateNeighborFacets(scip, facets, lambda, rayorigin, raydirection, negquotient, nsubspacevars, f_max, i, &nfacets);
SCIP_CALL( getSolFromFacet(scip, facets[i], sol, sign, subspacevars, nsubspacevars) );
SCIP_CALL( SCIPtrySol(scip, sol, FALSE, TRUE, FALSE, TRUE, &success) );
if( success )
*result = SCIP_FOUNDSOL;
}
}
/* finished OCTANE */
for( i = MIN(f_first, nfacets) - 1; i >= 0; --i )
{
SCIP_CALL( SCIPfreeSol(scip, &first_sols[i]) );
}
}
heurdata->lastrule = r;
if( *result == SCIP_FOUNDSOL )
++(heurdata->nsuccess);
/* free temporary memory */
SCIPfreeBufferArray(scip, &first_sols);
for( i = f_max; i >= 0; --i )
SCIPfreeBufferArray(scip, &facets[i]);
SCIPfreeBufferArray(scip, &facets);
SCIPfreeBufferArray(scip, &lambda);
SCIPfreeBufferArray(scip, &perm);
SCIPfreeBufferArray(scip, &sign);
SCIPfreeBufferArray(scip, &negquotient);
SCIPfreeBufferArray(scip, &raydirection);
SCIPfreeBufferArray(scip, &rayorigin);
SCIPfreeBufferArray(scip, &subspacevars);
SCIPfreeBufferArray(scip, &fracspace);
return SCIP_OKAY;
}
/** returns a score value for the given variable based on the active constraints that the variable appears in */
static
SCIP_Real getNActiveConsScore(
SCIP* scip, /**< SCIP data structure */
SCIP_SOL* sol, /**< working solution */
SCIP_VAR* var, /**< variable to get the score value for */
SCIP_Real* downscore, /**< pointer to store the score for branching downwards */
SCIP_Real* upscore /**< pointer to store the score for branching upwards */
)
{
SCIP_COL* col;
SCIP_ROW** rows;
SCIP_Real* vals;
int nrows;
int r;
int nactrows;
SCIP_Real nlprows;
SCIP_Real downcoefsum;
SCIP_Real upcoefsum;
SCIP_Real score;
assert(downscore != NULL);
assert(upscore != NULL);
*downscore = 0.0;
*upscore = 0.0;
if( SCIPvarGetStatus(var) != SCIP_VARSTATUS_COLUMN )
return 0.0;
col = SCIPvarGetCol(var);
assert(col != NULL);
rows = SCIPcolGetRows(col);
vals = SCIPcolGetVals(col);
nrows = SCIPcolGetNLPNonz(col);
nactrows = 0;
downcoefsum = 0.0;
upcoefsum = 0.0;
for( r = 0; r < nrows; ++r )
{
SCIP_ROW* row;
SCIP_Real activity;
SCIP_Real lhs;
SCIP_Real rhs;
SCIP_Real dualsol;
row = rows[r];
/* calculate number of active constraint sides, i.e., count equations as two */
lhs = SCIProwGetLhs(row);
rhs = SCIProwGetRhs(row);
/* @todo this is suboptimal because activity is calculated by looping over all nonzeros of this row, need to
* store LP activities instead (which cannot be retrieved if no LP was solved at this node)
*/
activity = SCIPgetRowSolActivity(scip, row, sol);
dualsol = SCIProwGetDualsol(row);
if( SCIPisFeasEQ(scip, activity, lhs) )
{
SCIP_Real coef;
nactrows++;
coef = vals[r] / SCIProwGetNorm(row);
if( SCIPisFeasPositive(scip, dualsol) )
{
if( coef > 0.0 )
downcoefsum += coef;
else
upcoefsum -= coef;
}
}
else if( SCIPisFeasEQ(scip, activity, rhs) )
{
SCIP_Real coef;
nactrows++;
coef = vals[r] / SCIProwGetNorm(row);
if( SCIPisFeasNegative(scip, dualsol) )
{
if( coef > 0.0 )
upcoefsum += coef;
else
downcoefsum -= coef;
}
}
}
/* use the number of LP rows for normalization */
nlprows = (SCIP_Real)SCIPgetNLPRows(scip);
upcoefsum /= nlprows;
downcoefsum /= nlprows;
/* calculate the score using SCIP's branch score. Pass NULL as variable to not have the var branch factor influence
* the result
*/
score = nactrows / nlprows + SCIPgetBranchScore(scip, NULL, downcoefsum, upcoefsum);
assert(score <= 3.0);
assert(score >= 0.0);
*downscore = downcoefsum;
*upscore = upcoefsum;
return score;
}
/** process a variable from the queue of changed variables */
static
SCIP_RETCODE varProcessBoundChanges(
SCIP* scip, /**< SCIP data structure */
SCIP_HEURDATA* heurdata, /**< heuristic data */
SCIP_VAR* var /**< the variable whose bound changes need to be processed */
)
{
SCIP_ROW** colrows;
SCIP_COL* varcol;
SCIP_Real* colvals;
SCIP_Real oldmean;
SCIP_Real newmean;
SCIP_Real oldvariance;
SCIP_Real newvariance;
SCIP_Real oldlb;
SCIP_Real newlb;
SCIP_Real oldub;
SCIP_Real newub;
SCIP_VARTYPE vartype;
int ncolrows;
int r;
int varindex;
/* ensure that this is a probing bound change */
assert(SCIPinProbing(scip));
assert(var != NULL);
varcol = SCIPvarGetCol(var);
assert(varcol != NULL);
colrows = SCIPcolGetRows(varcol);
colvals = SCIPcolGetVals(varcol);
ncolrows = SCIPcolGetNNonz(varcol);
varindex = SCIPvarGetProbindex(var);
oldlb = heurdata->currentlbs[varindex];
oldub = heurdata->currentubs[varindex];
/* skip update if the variable has never been subject of previously calculated row activities */
assert((oldlb == SCIP_INVALID) == (oldub == SCIP_INVALID)); /*lint !e777 doesn't like comparing floats for equality */
if( oldlb == SCIP_INVALID ) /*lint !e777 */
return SCIP_OKAY;
newlb = SCIPvarGetLbLocal(var);
newub = SCIPvarGetUbLocal(var);
/* skip update if the bound change events have cancelled out */
if( SCIPisFeasEQ(scip, oldlb, newlb) && SCIPisFeasEQ(scip, oldub, newub) )
return SCIP_OKAY;
/* calculate old and new variable distribution mean and variance */
oldvariance = 0.0;
newvariance = 0.0;
oldmean = 0.0;
newmean = 0.0;
vartype = SCIPvarGetType(var);
SCIPvarCalcDistributionParameters(scip, oldlb, oldub, vartype, &oldmean, &oldvariance);
SCIPvarCalcDistributionParameters(scip, newlb, newub, vartype, &newmean, &newvariance);
/* loop over all rows of this variable and update activity distribution */
for( r = 0; r < ncolrows; ++r )
{
int rowpos;
assert(colrows[r] != NULL);
rowpos = SCIProwGetIndex(colrows[r]);
assert(rowpos >= 0);
SCIP_CALL( heurdataEnsureArraySize(scip, heurdata, rowpos) );
/* only consider rows for which activity distribution was already calculated */
if( heurdata->rowmeans[rowpos] != SCIP_INVALID ) /*lint !e777 doesn't like comparing floats for equality */
{
SCIP_Real coeff;
SCIP_Real coeffsquared;
assert(heurdata->rowvariances[rowpos] != SCIP_INVALID
&& SCIPisFeasGE(scip, heurdata->rowvariances[rowpos], 0.0)); /*lint !e777 */
coeff = colvals[r];
coeffsquared = SQUARED(coeff);
/* update variable contribution to row activity distribution */
heurdata->rowmeans[rowpos] += coeff * (newmean - oldmean);
heurdata->rowvariances[rowpos] += coeffsquared * (newvariance - oldvariance);
heurdata->rowvariances[rowpos] = MAX(0.0, heurdata->rowvariances[rowpos]);
/* account for changes of the infinite contributions to row activities */
if( coeff > 0.0 )
{
/* if the coefficient is positive, upper bounds affect activity up */
if( SCIPisInfinity(scip, newub) && !SCIPisInfinity(scip, oldub) )
++heurdata->rowinfinitiesup[rowpos];
else if( !SCIPisInfinity(scip, newub) && SCIPisInfinity(scip, oldub) )
--heurdata->rowinfinitiesup[rowpos];
if( SCIPisInfinity(scip, newlb) && !SCIPisInfinity(scip, oldlb) )
++heurdata->rowinfinitiesdown[rowpos];
else if( !SCIPisInfinity(scip, newlb) && SCIPisInfinity(scip, oldlb) )
--heurdata->rowinfinitiesdown[rowpos];
}
else if( coeff < 0.0 )
{
if( SCIPisInfinity(scip, newub) && !SCIPisInfinity(scip, oldub) )
++heurdata->rowinfinitiesdown[rowpos];
else if( !SCIPisInfinity(scip, newub) && SCIPisInfinity(scip, oldub) )
--heurdata->rowinfinitiesdown[rowpos];
if( SCIPisInfinity(scip, newlb) && !SCIPisInfinity(scip, oldlb) )
++heurdata->rowinfinitiesup[rowpos];
else if( !SCIPisInfinity(scip, newlb) && SCIPisInfinity(scip, oldlb) )
--heurdata->rowinfinitiesup[rowpos];
}
assert(heurdata->rowinfinitiesdown[rowpos] >= 0);
assert(heurdata->rowinfinitiesup[rowpos] >= 0);
}
}
/* store the new local bounds in the data */
heurdataUpdateCurrentBounds(scip, heurdata, var);
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;
}
/** LP solution separation method for disjunctive cuts */
static
SCIP_DECL_SEPAEXECLP(sepaExeclpDisjunctive)
{
SCIP_SEPADATA* sepadata;
SCIP_CONSHDLR* conshdlr;
SCIP_DIGRAPH* conflictgraph;
SCIP_ROW** rows;
SCIP_COL** cols;
SCIP_Real* cutcoefs = NULL;
SCIP_Real* simplexcoefs1 = NULL;
SCIP_Real* simplexcoefs2 = NULL;
SCIP_Real* coef = NULL;
SCIP_Real* binvrow = NULL;
SCIP_Real* rowsmaxval = NULL;
SCIP_Real* violationarray = NULL;
int* fixings1 = NULL;
int* fixings2 = NULL;
int* basisind = NULL;
int* basisrow = NULL;
int* varrank = NULL;
int* edgearray = NULL;
int nedges;
int ndisjcuts;
int nrelevantedges;
int nsos1vars;
int nconss;
int maxcuts;
int ncalls;
int depth;
int ncols;
int nrows;
int ind;
int j;
int i;
assert( sepa != NULL );
assert( strcmp(SCIPsepaGetName(sepa), SEPA_NAME) == 0 );
assert( scip != NULL );
assert( result != NULL );
*result = SCIP_DIDNOTRUN;
/* only generate disjunctive cuts if we are not close to terminating */
if ( SCIPisStopped(scip) )
return SCIP_OKAY;
/* only generate disjunctive cuts if an optimal LP solution is at hand */
if ( SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
return SCIP_OKAY;
/* only generate disjunctive cuts if the LP solution is basic */
if ( ! SCIPisLPSolBasic(scip) )
return SCIP_OKAY;
/* get LP data */
SCIP_CALL( SCIPgetLPColsData(scip, &cols, &ncols) );
SCIP_CALL( SCIPgetLPRowsData(scip, &rows, &nrows) );
/* return if LP has no columns or no rows */
if ( ncols == 0 || nrows == 0 )
return SCIP_OKAY;
assert( cols != NULL );
assert( rows != NULL );
/* get sepa data */
sepadata = SCIPsepaGetData(sepa);
assert( sepadata != NULL );
/* get constraint handler */
conshdlr = sepadata->conshdlr;
if ( conshdlr == NULL )
return SCIP_OKAY;
/* get number of constraints */
nconss = SCIPconshdlrGetNConss(conshdlr);
if ( nconss == 0 )
return SCIP_OKAY;
/* check for maxdepth < depth, maxinvcutsroot = 0 and maxinvcuts = 0 */
depth = SCIPgetDepth(scip);
if ( ( sepadata->maxdepth >= 0 && sepadata->maxdepth < depth )
|| ( depth == 0 && sepadata->maxinvcutsroot == 0 )
|| ( depth > 0 && sepadata->maxinvcuts == 0 ) )
return SCIP_OKAY;
/* only call the cut separator a given number of times at each node */
ncalls = SCIPsepaGetNCallsAtNode(sepa);
if ( (depth == 0 && sepadata->maxroundsroot >= 0 && ncalls >= sepadata->maxroundsroot)
|| (depth > 0 && sepadata->maxrounds >= 0 && ncalls >= sepadata->maxrounds) )
return SCIP_OKAY;
/* get conflict graph and number of conflict graph edges (note that the digraph arcs were added in both directions) */
conflictgraph = SCIPgetConflictgraphSOS1(conshdlr);
nedges = (int)SCIPceil(scip, (SCIP_Real)SCIPdigraphGetNArcs(conflictgraph)/2);
/* if too many conflict graph edges, the separator can be slow: delay it until no other cuts have been found */
if ( sepadata->maxconfsdelay >= 0 && nedges >= sepadata->maxconfsdelay )
{
int ncutsfound;
ncutsfound = SCIPgetNCutsFound(scip);
if ( ncutsfound > sepadata->lastncutsfound || ! SCIPsepaWasLPDelayed(sepa) )
{
sepadata->lastncutsfound = ncutsfound;
*result = SCIP_DELAYED;
return SCIP_OKAY;
}
}
/* check basis status */
for (j = 0; j < ncols; ++j)
{
if ( SCIPcolGetBasisStatus(cols[j]) == SCIP_BASESTAT_ZERO )
return SCIP_OKAY;
}
/* get number of SOS1 variables */
nsos1vars = SCIPgetNSOS1Vars(conshdlr);
/* allocate buffer arrays */
SCIP_CALL( SCIPallocBufferArray(scip, &edgearray, nedges) );
SCIP_CALL( SCIPallocBufferArray(scip, &fixings1, nedges) );
SCIP_CALL( SCIPallocBufferArray(scip, &fixings2, nedges) );
SCIP_CALL( SCIPallocBufferArray(scip, &violationarray, nedges) );
/* get all violated conflicts {i, j} in the conflict graph and sort them based on the degree of a violation value */
nrelevantedges = 0;
for (j = 0; j < nsos1vars; ++j)
{
SCIP_VAR* var;
var = SCIPnodeGetVarSOS1(conflictgraph, j);
if ( SCIPvarIsActive(var) && ! SCIPisFeasZero(scip, SCIPcolGetPrimsol(SCIPvarGetCol(var))) && SCIPcolGetBasisStatus(SCIPvarGetCol(var)) == SCIP_BASESTAT_BASIC )
{
int* succ;
int nsucc;
/* get successors and number of successors */
nsucc = SCIPdigraphGetNSuccessors(conflictgraph, j);
succ = SCIPdigraphGetSuccessors(conflictgraph, j);
for (i = 0; i < nsucc; ++i)
{
SCIP_VAR* varsucc;
int succind;
succind = succ[i];
varsucc = SCIPnodeGetVarSOS1(conflictgraph, succind);
if ( SCIPvarIsActive(varsucc) && succind < j && ! SCIPisFeasZero(scip, SCIPgetSolVal(scip, NULL, varsucc) ) &&
SCIPcolGetBasisStatus(SCIPvarGetCol(varsucc)) == SCIP_BASESTAT_BASIC )
{
fixings1[nrelevantedges] = j;
fixings2[nrelevantedges] = succind;
edgearray[nrelevantedges] = nrelevantedges;
violationarray[nrelevantedges++] = SCIPgetSolVal(scip, NULL, var) * SCIPgetSolVal(scip, NULL, varsucc);
}
}
}
}
/* sort violation score values */
if ( nrelevantedges > 0)
SCIPsortDownRealInt(violationarray, edgearray, nrelevantedges);
else
{
SCIPfreeBufferArrayNull(scip, &violationarray);
SCIPfreeBufferArrayNull(scip, &fixings2);
SCIPfreeBufferArrayNull(scip, &fixings1);
SCIPfreeBufferArrayNull(scip, &edgearray);
return SCIP_OKAY;
}
SCIPfreeBufferArrayNull(scip, &violationarray);
/* compute maximal number of cuts */
if ( SCIPgetDepth(scip) == 0 )
maxcuts = MIN(sepadata->maxinvcutsroot, nrelevantedges);
else
maxcuts = MIN(sepadata->maxinvcuts, nrelevantedges);
assert( maxcuts > 0 );
/* allocate buffer arrays */
SCIP_CALL( SCIPallocBufferArray(scip, &varrank, ncols) );
SCIP_CALL( SCIPallocBufferArray(scip, &rowsmaxval, nrows) );
SCIP_CALL( SCIPallocBufferArray(scip, &basisrow, ncols) );
SCIP_CALL( SCIPallocBufferArray(scip, &binvrow, nrows) );
SCIP_CALL( SCIPallocBufferArray(scip, &coef, ncols) );
SCIP_CALL( SCIPallocBufferArray(scip, &simplexcoefs1, ncols) );
SCIP_CALL( SCIPallocBufferArray(scip, &simplexcoefs2, ncols) );
SCIP_CALL( SCIPallocBufferArray(scip, &cutcoefs, ncols) );
SCIP_CALL( SCIPallocBufferArray(scip, &basisind, nrows) );
/* get basis indices */
SCIP_CALL( SCIPgetLPBasisInd(scip, basisind) );
/* create vector "basisrow" with basisrow[column of non-slack basis variable] = corresponding row of B^-1;
* compute maximum absolute value of nonbasic row coefficients */
for (j = 0; j < nrows; ++j)
{
SCIP_COL** rowcols;
SCIP_Real* rowvals;
SCIP_ROW* row;
SCIP_Real val;
SCIP_Real max = 0.0;
int nnonz;
/* fill basisrow vector */
ind = basisind[j];
if ( ind >= 0 )
basisrow[ind] = j;
/* compute maximum absolute value of nonbasic row coefficients */
row = rows[j];
assert( row != NULL );
rowvals = SCIProwGetVals(row);
nnonz = SCIProwGetNNonz(row);
rowcols = SCIProwGetCols(row);
for (i = 0; i < nnonz; ++i)
{
if ( SCIPcolGetBasisStatus(rowcols[i]) == SCIP_BASESTAT_LOWER || SCIPcolGetBasisStatus(rowcols[i]) == SCIP_BASESTAT_UPPER )
{
val = REALABS(rowvals[i]);
if ( SCIPisFeasGT(scip, val, max) )
max = REALABS(val);
}
}
/* handle slack variable coefficient and save maximum value */
rowsmaxval[j] = MAX(max, 1.0);
}
/* initialize variable ranks with -1 */
for (j = 0; j < ncols; ++j)
varrank[j] = -1;
/* free buffer array */
SCIPfreeBufferArrayNull(scip, &basisind);
/* for the most promising disjunctions: try to generate disjunctive cuts */
ndisjcuts = 0;
for (i = 0; i < maxcuts; ++i)
{
SCIP_Bool madeintegral;
SCIP_Real cutlhs1;
SCIP_Real cutlhs2;
SCIP_Real bound1;
SCIP_Real bound2;
SCIP_ROW* row = NULL;
SCIP_VAR* var;
SCIP_COL* col;
int nonbasicnumber;
int cutrank = 0;
int edgenumber;
int rownnonz;
edgenumber = edgearray[i];
/* determine first simplex row */
var = SCIPnodeGetVarSOS1(conflictgraph, fixings1[edgenumber]);
col = SCIPvarGetCol(var);
ind = SCIPcolGetLPPos(col);
assert( ind >= 0 );
assert( SCIPcolGetBasisStatus(col) == SCIP_BASESTAT_BASIC );
/* get the 'ind'th row of B^-1 and B^-1 \cdot A */
SCIP_CALL( SCIPgetLPBInvRow(scip, basisrow[ind], binvrow, NULL, NULL) );
SCIP_CALL( SCIPgetLPBInvARow(scip, basisrow[ind], binvrow, coef, NULL, NULL) );
/* get the simplex-coefficients of the non-basic variables */
SCIP_CALL( getSimplexCoefficients(scip, rows, nrows, cols, ncols, coef, binvrow, simplexcoefs1, &nonbasicnumber) );
/* get rank of variable if not known already */
if ( varrank[ind] < 0 )
varrank[ind] = getVarRank(scip, binvrow, rowsmaxval, sepadata->maxweightrange, rows, nrows);
cutrank = MAX(cutrank, varrank[ind]);
/* get right hand side and bound of simplex talbeau row */
cutlhs1 = SCIPcolGetPrimsol(col);
if ( SCIPisFeasPositive(scip, cutlhs1) )
bound1 = SCIPcolGetUb(col);
else
bound1 = SCIPcolGetLb(col);
/* determine second simplex row */
var = SCIPnodeGetVarSOS1(conflictgraph, fixings2[edgenumber]);
col = SCIPvarGetCol(var);
ind = SCIPcolGetLPPos(col);
assert( ind >= 0 );
assert( SCIPcolGetBasisStatus(col) == SCIP_BASESTAT_BASIC );
/* get the 'ind'th row of B^-1 and B^-1 \cdot A */
SCIP_CALL( SCIPgetLPBInvRow(scip, basisrow[ind], binvrow, NULL, NULL) );
SCIP_CALL( SCIPgetLPBInvARow(scip, basisrow[ind], binvrow, coef, NULL, NULL) );
/* get the simplex-coefficients of the non-basic variables */
SCIP_CALL( getSimplexCoefficients(scip, rows, nrows, cols, ncols, coef, binvrow, simplexcoefs2, &nonbasicnumber) );
/* get rank of variable if not known already */
if ( varrank[ind] < 0 )
varrank[ind] = getVarRank(scip, binvrow, rowsmaxval, sepadata->maxweightrange, rows, nrows);
cutrank = MAX(cutrank, varrank[ind]);
/* get right hand side and bound of simplex talbeau row */
cutlhs2 = SCIPcolGetPrimsol(col);
if ( SCIPisFeasPositive(scip, cutlhs2) )
bound2 = SCIPcolGetUb(col);
else
bound2 = SCIPcolGetLb(col);
/* add coefficients to cut */
SCIP_CALL( generateDisjCutSOS1(scip, sepa, rows, nrows, cols, ncols, ndisjcuts, TRUE, sepadata->strengthen, cutlhs1, cutlhs2, bound1, bound2, simplexcoefs1, simplexcoefs2, cutcoefs, &row, &madeintegral) );
if ( row == NULL )
continue;
/* raise cutrank for present cut */
++cutrank;
/* check if there are numerical evidences */
if ( ( madeintegral && ( sepadata->maxrankintegral == -1 || cutrank <= sepadata->maxrankintegral ) )
|| ( ! madeintegral && ( sepadata->maxrank == -1 || cutrank <= sepadata->maxrank ) ) )
{
/* possibly add cut to LP if it is useful; in case the lhs of the cut is minus infinity (due to scaling) the cut is useless */
rownnonz = SCIProwGetNNonz(row);
if ( rownnonz > 0 && ! SCIPisInfinity(scip, -SCIProwGetLhs(row)) && ! SCIProwIsInLP(row) && SCIPisCutEfficacious(scip, NULL, row) )
{
SCIP_Bool infeasible;
/* set cut rank */
SCIProwChgRank(row, cutrank);
/* add cut */
SCIP_CALL( SCIPaddCut(scip, NULL, row, FALSE, &infeasible) );
SCIPdebug( SCIP_CALL( SCIPprintRow(scip, row, NULL) ) );
if ( infeasible )
{
*result = SCIP_CUTOFF;
break;
}
++ndisjcuts;
}
}
/* release row */
SCIP_CALL( SCIPreleaseRow(scip, &row) );
}
/* save total number of cuts found so far */
sepadata->lastncutsfound = SCIPgetNCutsFound(scip);
/* evaluate the result of the separation */
if ( *result != SCIP_CUTOFF )
{
if ( ndisjcuts > 0 )
*result = SCIP_SEPARATED;
else
*result = SCIP_DIDNOTFIND;
}
SCIPdebugMessage("Number of found disjunctive cuts: %d.\n", ndisjcuts);
/* free buffer arrays */
SCIPfreeBufferArrayNull(scip, &cutcoefs);
SCIPfreeBufferArrayNull(scip, &simplexcoefs2);
SCIPfreeBufferArrayNull(scip, &simplexcoefs1);
SCIPfreeBufferArrayNull(scip, &coef);
SCIPfreeBufferArrayNull(scip, &binvrow);
SCIPfreeBufferArrayNull(scip, &basisrow);
SCIPfreeBufferArrayNull(scip, &fixings2);
SCIPfreeBufferArrayNull(scip, &fixings1);
SCIPfreeBufferArrayNull(scip, &edgearray);
SCIPfreeBufferArrayNull(scip, &rowsmaxval);
SCIPfreeBufferArrayNull(scip, &varrank);
return SCIP_OKAY;
}
/** update row activities after a variable's solution value changed */
static
SCIP_RETCODE updateActivities(
SCIP* scip, /**< SCIP data structure */
SCIP_Real* activities, /**< LP row activities */
SCIP_ROW** violrows, /**< array with currently violated rows */
int* violrowpos, /**< position of LP rows in violrows array */
int* nviolrows, /**< pointer to the number of currently violated rows */
int nlprows, /**< number of rows in current LP */
SCIP_VAR* var, /**< variable that has been changed */
SCIP_Real oldsolval, /**< old solution value of variable */
SCIP_Real newsolval /**< new solution value of variable */
)
{
SCIP_COL* col;
SCIP_ROW** colrows;
SCIP_Real* colvals;
SCIP_Real delta;
int ncolrows;
int r;
assert(activities != NULL);
assert(nviolrows != NULL);
assert(0 <= *nviolrows && *nviolrows <= nlprows);
delta = newsolval - oldsolval;
col = SCIPvarGetCol(var);
colrows = SCIPcolGetRows(col);
colvals = SCIPcolGetVals(col);
ncolrows = SCIPcolGetNLPNonz(col);
assert(ncolrows == 0 || (colrows != NULL && colvals != NULL));
for( r = 0; r < ncolrows; ++r )
{
SCIP_ROW* row;
int rowpos;
row = colrows[r];
rowpos = SCIProwGetLPPos(row);
assert(-1 <= rowpos && rowpos < nlprows);
if( rowpos >= 0 && !SCIProwIsLocal(row) )
{
SCIP_Real oldactivity;
SCIP_Real newactivity;
assert(SCIProwIsInLP(row));
/* update row activity */
oldactivity = activities[rowpos];
if( !SCIPisInfinity(scip, -oldactivity) && !SCIPisInfinity(scip, oldactivity) )
{
newactivity = oldactivity + delta * colvals[r];
if( SCIPisInfinity(scip, newactivity) )
newactivity = SCIPinfinity(scip);
else if( SCIPisInfinity(scip, -newactivity) )
newactivity = -SCIPinfinity(scip);
activities[rowpos] = newactivity;
/* update row violation arrays */
updateViolations(scip, row, violrows, violrowpos, nviolrows, oldactivity, newactivity);
}
}
}
return SCIP_OKAY;
}
/** adds problem variables with negative reduced costs to pricing storage */
SCIP_RETCODE SCIPpricestoreAddProbVars(
SCIP_PRICESTORE* pricestore, /**< pricing storage */
BMS_BLKMEM* blkmem, /**< block memory buffers */
SCIP_SET* set, /**< global SCIP settings */
SCIP_STAT* stat, /**< dynamic problem statistics */
SCIP_PROB* prob, /**< transformed problem after presolve */
SCIP_TREE* tree, /**< branch and bound tree */
SCIP_LP* lp, /**< LP data */
SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
SCIP_EVENTQUEUE* eventqueue /**< event queue */
)
{
SCIP_VAR* var;
SCIP_COL* col;
SCIP_Bool root;
SCIP_Bool added;
int v;
int abortpricevars;
int maxpricevars;
int nfoundvars;
assert(pricestore != NULL);
assert(set != NULL);
assert(stat != NULL);
assert(prob != NULL);
assert(lp != NULL);
assert(lp->solved);
assert(tree != NULL);
assert(SCIPtreeHasCurrentNodeLP(tree));
assert(prob->nvars >= SCIPlpGetNCols(lp));
/* if all problem variables of status COLUMN are already in the LP, nothing has to be done */
if( prob->ncolvars == SCIPlpGetNCols(lp) )
return SCIP_OKAY;
root = (SCIPtreeGetCurrentDepth(tree) == 0);
maxpricevars = SCIPsetGetPriceMaxvars(set, root);
assert(maxpricevars >= 1);
abortpricevars = (int)(set->price_abortfac * maxpricevars);
assert(abortpricevars >= maxpricevars);
/**@todo test pricing: is abortpricevars a good idea? -> like strong branching, lookahead, ... */
pricestore->nprobpricings++;
/* start timing */
SCIPclockStart(pricestore->probpricingtime, set);
/* price already existing problem variables */
nfoundvars = 0;
for( v = 0; v < prob->nvars && nfoundvars < abortpricevars; ++v )
{
var = prob->vars[v];
if( SCIPvarGetStatus(var) == SCIP_VARSTATUS_COLUMN )
{
col = SCIPvarGetCol(var);
assert(col != NULL);
assert(col->var == var);
assert(col->len >= 0);
assert(col->lppos >= -1);
assert(col->lpipos >= -1);
assert(SCIPcolIsInLP(col) == (col->lpipos >= 0));
if( !SCIPcolIsInLP(col) )
{
SCIPdebugMessage("price column variable <%s> in bounds [%g,%g]\n",
SCIPvarGetName(var), SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var));
/* add variable to pricing storage, if zero is not best bound w.r.t. objective function */
SCIP_CALL( addBoundViolated(pricestore, blkmem, set, stat, tree, lp, branchcand, eventqueue, var, &added) );
if( added )
{
pricestore->nprobvarsfound++;
nfoundvars++;
}
else if( SCIPcolGetNNonz(col) > 0 )
{
SCIP_Real feasibility;
/* a column not in LP that doesn't have zero in its bounds was added by bound checking above */
assert(!SCIPsetIsPositive(set, SCIPvarGetLbLocal(col->var)));
assert(!SCIPsetIsNegative(set, SCIPvarGetUbLocal(col->var)));
if( SCIPlpGetSolstat(lp) == SCIP_LPSOLSTAT_INFEASIBLE )
{
/* The LP was proven infeasible, so we have an infeasibility proof by the dual Farkas multipliers y.
* The valid inequality y^T A x >= y^T b is violated by all x, especially by the (for this
* inequality most feasible solution) x' defined by
* x'_i = ub_i, if y^T A_i > 0
* x'_i = lb_i, if y^T A_i <= 0.
* Pricing in this case means to add variables i with positive Farkas value, i.e. y^T A_i x'_i > 0
*/
feasibility = -SCIPcolGetFarkasValue(col, stat, lp);
SCIPdebugMessage(" <%s> Farkas feasibility: %e\n", SCIPvarGetName(col->var), feasibility);
}
else
{
/* The dual LP is feasible, and we have a feasible dual solution. Pricing in this case means to
* add variables with negative feasibility, that is
* - positive reduced costs for variables with negative lower bound
* - negative reduced costs for variables with positive upper bound
*/
feasibility = SCIPcolGetFeasibility(col, set, stat, lp);
SCIPdebugMessage(" <%s> reduced cost feasibility: %e\n", SCIPvarGetName(col->var), feasibility);
}
/* the score is -feasibility / (#nonzeros in column + 1) to prefer short columns
* we must add variables with negative feasibility, but in order to not get a too large lower bound
* due to missing columns, we better also add variables, that have a very small feasibility
*/
if( !SCIPsetIsPositive(set, feasibility) )
{
SCIP_CALL( SCIPpricestoreAddVar(pricestore, blkmem, set, eventqueue, lp, var, -feasibility / (col->len+1), root) );
pricestore->nprobvarsfound++;
nfoundvars++;
}
}
}
}
}
/* stop timing */
SCIPclockStop(pricestore->probpricingtime, set);
return SCIP_OKAY;
}
/** compute value by which the solution of variable @p var can be shifted */
static
SCIP_Real calcShiftVal(
SCIP* scip, /**< SCIP data structure */
SCIP_VAR* var, /**< variable that should be shifted */
SCIP_Real solval, /**< current solution value */
SCIP_Real* activities /**< LP row activities */
)
{
SCIP_Real lb;
SCIP_Real ub;
SCIP_Real obj;
SCIP_Real shiftval;
SCIP_COL* col;
SCIP_ROW** colrows;
SCIP_Real* colvals;
SCIP_Bool shiftdown;
int ncolrows;
int i;
/* get variable's solution value, global bounds and objective coefficient */
lb = SCIPvarGetLbGlobal(var);
ub = SCIPvarGetUbGlobal(var);
obj = SCIPvarGetObj(var);
shiftval = 0.0;
shiftdown = TRUE;
/* determine shifting direction and maximal possible shifting w.r.t. corresponding bound */
if( obj > 0.0 && SCIPisFeasGE(scip, solval - 1.0, lb) )
shiftval = SCIPfeasFloor(scip, solval - lb);
else if( obj < 0.0 && SCIPisFeasLE(scip, solval + 1.0, ub) )
{
shiftval = SCIPfeasFloor(scip, ub - solval);
shiftdown = FALSE;
}
else
return 0.0;
SCIPdebugMessage("Try to shift %s variable <%s> with\n", shiftdown ? "down" : "up", SCIPvarGetName(var) );
SCIPdebugMessage(" lb:<%g> <= val:<%g> <= ub:<%g> and obj:<%g> by at most: <%g>\n", lb, solval, ub, obj, shiftval);
/* get data of LP column */
col = SCIPvarGetCol(var);
colrows = SCIPcolGetRows(col);
colvals = SCIPcolGetVals(col);
ncolrows = SCIPcolGetNLPNonz(col);
assert(ncolrows == 0 || (colrows != NULL && colvals != NULL));
/* find minimal shift value, st. all rows stay valid */
for( i = 0; i < ncolrows && shiftval > 0.0; ++i )
{
SCIP_ROW* row;
int rowpos;
row = colrows[i];
rowpos = SCIProwGetLPPos(row);
assert(-1 <= rowpos && rowpos < SCIPgetNLPRows(scip) );
/* only global rows need to be valid */
if( rowpos >= 0 && !SCIProwIsLocal(row) )
{
SCIP_Real shiftvalrow;
assert(SCIProwIsInLP(row));
if( shiftdown == (colvals[i] > 0) )
shiftvalrow = SCIPfeasFloor(scip, (activities[rowpos] - SCIProwGetLhs(row)) / ABS(colvals[i]));
else
shiftvalrow = SCIPfeasFloor(scip, (SCIProwGetRhs(row) - activities[rowpos]) / ABS(colvals[i]));
#ifdef SCIP_DEBUG
if( shiftvalrow < shiftval )
{
SCIPdebugMessage(" -> The shift value had to be reduced to <%g>, because of row <%s>.\n",
shiftvalrow, SCIProwGetName(row));
SCIPdebugMessage(" lhs:<%g> <= act:<%g> <= rhs:<%g>, colval:<%g>\n",
SCIProwGetLhs(row), activities[rowpos], SCIProwGetRhs(row), colvals[i]);
}
#endif
shiftval = MIN(shiftval, shiftvalrow);
/* shiftvalrow might be negative, if we detected infeasibility -> make sure that shiftval is >= 0 */
shiftval = MAX(shiftval, 0.0);
}
}
if( shiftdown )
shiftval *= -1.0;
/* we must not shift variables to infinity */
if( SCIPisInfinity(scip, solval + shiftval) )
shiftval = 0.0;
return shiftval;
}
/** adds priced variables to the LP */
SCIP_RETCODE SCIPpricestoreApplyVars(
SCIP_PRICESTORE* pricestore, /**< pricing storage */
BMS_BLKMEM* blkmem, /**< block memory buffers */
SCIP_SET* set, /**< global SCIP settings */
SCIP_STAT* stat, /**< dynamic problem statistics */
SCIP_EVENTQUEUE* eventqueue, /**< event queue */
SCIP_PROB* prob, /**< transformed problem after presolve */
SCIP_TREE* tree, /**< branch and bound tree */
SCIP_LP* lp /**< LP data */
)
{
SCIP_VAR* var;
SCIP_COL* col;
int v;
assert(pricestore != NULL);
assert(pricestore->naddedbdviolvars <= pricestore->nbdviolvars);
assert(set != NULL);
assert(prob != NULL);
assert(lp != NULL);
assert(tree != NULL);
assert(SCIPtreeIsFocusNodeLPConstructed(tree));
SCIPdebugMessage("adding %d variables (%d bound violated and %d priced vars) to %d LP columns\n",
SCIPpricestoreGetNVars(pricestore), pricestore->nbdviolvars - pricestore->naddedbdviolvars,
pricestore->nvars, SCIPlpGetNCols(lp));
/* add the variables with violated bounds to LP */
for( v = pricestore->naddedbdviolvars; v < pricestore->nbdviolvars; ++v )
{
var = pricestore->bdviolvars[v];
assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_LOOSE || SCIPvarGetStatus(var) == SCIP_VARSTATUS_COLUMN);
assert(SCIPvarGetProbindex(var) >= 0);
assert(var->nuses >= 2); /* at least used in pricing storage and in problem */
if( SCIPvarGetStatus(var) == SCIP_VARSTATUS_LOOSE )
{
/* transform loose variable into column variable */
SCIP_CALL( SCIPvarColumn(var, blkmem, set, stat, prob, lp) );
}
assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_COLUMN);
col = SCIPvarGetCol(var);
assert(col != NULL);
assert(col->lppos == -1);
SCIPdebugMessage("adding bound violated variable <%s> (lb=%g, ub=%g)\n", SCIPvarGetName(var),
pricestore->bdviolvarslb[v], pricestore->bdviolvarsub[v]);
SCIP_CALL( SCIPlpAddCol(lp, set, col, SCIPtreeGetCurrentDepth(tree)) );
if( !pricestore->initiallp )
pricestore->nvarsapplied++;
}
pricestore->naddedbdviolvars = pricestore->nbdviolvars;
/* add the selected pricing variables to LP */
for( v = 0; v < pricestore->nvars; ++v )
{
var = pricestore->vars[v];
assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_LOOSE || SCIPvarGetStatus(var) == SCIP_VARSTATUS_COLUMN);
assert(SCIPvarGetProbindex(var) >= 0);
assert(var->nuses >= 2); /* at least used in pricing storage and in problem */
/* transform variable into column variable, if needed */
if( SCIPvarGetStatus(var) == SCIP_VARSTATUS_LOOSE )
{
SCIP_CALL( SCIPvarColumn(var, blkmem, set, stat, prob, lp) );
}
assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_COLUMN);
col = SCIPvarGetCol(var);
assert(col != NULL);
assert(col->lppos == -1);
SCIPdebugMessage("adding priced variable <%s> (score=%g)\n", SCIPvarGetName(var), pricestore->scores[v]);
SCIP_CALL( SCIPlpAddCol(lp, set, col, SCIPtreeGetCurrentDepth(tree)) );
/* release the variable */
SCIP_CALL( SCIPvarRelease(&pricestore->vars[v], blkmem, set, eventqueue, lp) );
if( !pricestore->initiallp )
pricestore->nvarsapplied++;
}
/* clear the pricing storage */
pricestore->nvars = 0;
return SCIP_OKAY;
}
/** generates the direction of the shooting ray as the average of the extreme rays of the basic cone */
static
SCIP_RETCODE generateAverageRay(
SCIP* scip, /**< SCIP data structure */
SCIP_Real* raydirection, /**< shooting ray */
SCIP_VAR** subspacevars, /**< pointer to fractional space variables */
int nsubspacevars, /**< dimension of fractional space */
SCIP_Bool weighted /**< should the rays be weighted? */
)
{
SCIP_ROW** rows;
SCIP_Real** tableaurows;
SCIP_Real* rownorm;
SCIP_Real rowweight;
int nrows;
int i;
int j;
assert(scip != NULL);
assert(raydirection != NULL);
assert(subspacevars != NULL);
/* get data */
SCIP_CALL( SCIPgetLPRowsData(scip, &rows, &nrows) );
/* allocate memory */
SCIP_CALL( SCIPallocBufferArray(scip, &tableaurows, nsubspacevars) );
for( j = nsubspacevars - 1; j >= 0; --j )
{
/*lint --e{866}*/
SCIP_CALL( SCIPallocBufferArray(scip, &tableaurows[j], nrows) );
}
SCIP_CALL( SCIPallocBufferArray(scip, &rownorm, nrows) );
for( i = nrows - 1; i >= 0; --i )
rownorm[i] = 0;
/* get the relevant columns of the simplex tableau */
for( j = nsubspacevars-1; j >= 0; --j )
{
assert(SCIPcolGetLPPos(SCIPvarGetCol(subspacevars[j])) >= 0);
SCIP_CALL( SCIPgetLPBInvACol(scip, SCIPcolGetLPPos(SCIPvarGetCol(subspacevars[j])), tableaurows[j]) );
for( i = nrows - 1; i >= 0; --i )
rownorm[i] += tableaurows[j][i] * tableaurows[j][i];
}
/* take average over all rows of the tableau */
for( i = nrows - 1; i >= 0; --i )
{
if( SCIPisFeasZero(scip, rownorm[i]) )
continue;
else
rownorm[i] = SQRT(rownorm[i]);
rowweight = 0.0;
if( weighted )
{
rowweight = SCIProwGetDualsol(rows[i]);
if( SCIPisFeasZero(scip, rowweight) )
continue;
}
else
rowweight = 1.0;
for( j = nsubspacevars - 1; j >= 0; --j )
{
raydirection[j] += tableaurows[j][i] / (rownorm[i] * rowweight);
assert(SCIP_REAL_MIN <= raydirection[j] && raydirection[j] <= SCIP_REAL_MAX);
}
}
/* free memory */
SCIPfreeBufferArray(scip, &rownorm);
for( j = nsubspacevars - 1; j >= 0; --j )
{
SCIPfreeBufferArray(scip, &tableaurows[j]);
}
SCIPfreeBufferArray(scip, &tableaurows);
return SCIP_OKAY;
}
