/** changes the color of the node to the color of nodes with a primal solution */
void SCIPvisualFoundSolution(
SCIP_VISUAL* visual, /**< visualization information */
SCIP_SET* set, /**< global SCIP settings */
SCIP_STAT* stat, /**< problem statistics */
SCIP_NODE* node, /**< node where the solution was found, or NULL */
SCIP_Bool bettersol, /**< the solution was better than the previous ones */
SCIP_SOL* sol /**< solution that has been found */
)
{
if ( visual->vbcfile != NULL )
{
if ( node != NULL && set->visual_dispsols )
{
if ( SCIPnodeGetType(node) != SCIP_NODETYPE_PROBINGNODE )
vbcSetColor(visual, stat, node, SCIP_VBCCOLOR_SOLUTION);
}
}
if ( visual->bakfile != NULL && bettersol )
{
SCIP_Real obj;
if ( set->visual_objextern )
obj = SCIPgetSolOrigObj(set->scip, sol);
else
obj = SCIPgetSolTransObj(set->scip, sol);
if ( SCIPsolGetHeur(sol) == NULL && node != NULL )
{
/* if LP solution was feasible ... */
SCIP_VAR* branchvar;
SCIP_BOUNDTYPE branchtype;
SCIP_Real branchbound;
SCIP_NODE *pnode;
size_t parentnodenum;
size_t nodenum;
char t = 'M';
/* find first parent that is not a probing node */
pnode = node;
while ( pnode != NULL && SCIPnodeGetType(pnode) == SCIP_NODETYPE_PROBINGNODE )
pnode = pnode->parent;
if ( pnode != NULL )
{
/* get node num from hash map */
nodenum = (size_t)SCIPhashmapGetImage(visual->nodenum, pnode);
/* get nodenum of parent node from hash map */
parentnodenum = (pnode->parent != NULL ? (size_t)SCIPhashmapGetImage(visual->nodenum, pnode->parent) : 0);
assert( pnode->parent == NULL || parentnodenum > 0 );
/* get branching information */
getBranchInfo(pnode, &branchvar, &branchtype, &branchbound);
/* determine branching type */
if ( branchvar != NULL )
t = (branchtype == SCIP_BOUNDTYPE_LOWER ? 'R' : 'L');
printTime(visual, stat, FALSE);
SCIPmessageFPrintInfo(visual->messagehdlr, visual->bakfile, "integer %d %d %c %f\n", (int)nodenum, (int)parentnodenum, t, obj);
}
}
else
{
printTime(visual, stat, FALSE);
SCIPmessageFPrintInfo(visual->messagehdlr, visual->bakfile, "heuristic %f\n", obj);
}
}
}
/** method for either Farkas or Redcost pricing */
static
SCIP_RETCODE pricing(
SCIP* scip, /**< SCIP data structure */
SCIP_PRICER* pricer, /**< pricer */
SCIP_Real* lowerbound, /**< lowerbound pointer */
SCIP_Bool farkas /**< TRUE: Farkas pricing; FALSE: Redcost pricing */
)
{
SCIP_PRICERDATA* pricerdata; /* the data of the pricer */
SCIP_PROBDATA* probdata;
GRAPH* graph;
SCIP_VAR* var;
PATH* path;
SCIP_Real* edgecosts; /* edgecosts of the current subproblem */
char varname[SCIP_MAXSTRLEN];
SCIP_Real newlowerbound = -SCIPinfinity(scip);
SCIP_Real redcost; /* reduced cost */
int tail;
int e;
int t;
int i;
assert(scip != NULL);
assert(pricer != NULL);
/* get pricer data */
pricerdata = SCIPpricerGetData(pricer);
assert(pricerdata != NULL);
/* get problem data */
probdata = SCIPgetProbData(scip);
assert(probdata != NULL);
SCIPdebugMessage("solstat=%d\n", SCIPgetLPSolstat(scip));
if( !farkas && SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL )
newlowerbound = SCIPgetSolTransObj(scip, NULL);
SCIPdebug( SCIP_CALL( SCIPprintSol(scip, NULL, NULL, FALSE) ) );
# if 0
if ( pricerdata->lowerbound <= 4 )
{
char label[SCIP_MAXSTRLEN];
(void)SCIPsnprintf(label, SCIP_MAXSTRLEN, "X%g.gml", pricerdata->lowerbound);
SCIP_CALL( SCIPprobdataPrintGraph(scip, label , NULL, TRUE) );
pricerdata->lowerbound++;
}
#endif
/* get the graph*/
graph = SCIPprobdataGetGraph(probdata);
/* get dual solutions and save them in mi and pi */
for( t = 0; t < pricerdata->realnterms; ++t )
{
if( farkas )
{
pricerdata->mi[t] = SCIPgetDualfarkasLinear(scip, pricerdata->pathcons[t]);
}
else
{
pricerdata->mi[t] = SCIPgetDualsolLinear(scip, pricerdata->pathcons[t]);
assert(!SCIPisNegative(scip, pricerdata->mi[t]));
}
}
for( e = 0; e < pricerdata->nedges; ++e )
{
if( !pricerdata->bigt )
{
for( t = 0; t < pricerdata->realnterms; ++t )
{
if( farkas )
{
pricerdata->pi[t * pricerdata->nedges + e] = SCIPgetDualfarkasLinear(
scip, pricerdata->edgecons[t * pricerdata->nedges + e]);
}
else
{
pricerdata->pi[t * pricerdata->nedges + e] = SCIPgetDualsolLinear(
scip, pricerdata->edgecons[t * pricerdata->nedges + e]);
}
}
}
else
{
if( farkas )
{
pricerdata->pi[e] = SCIPgetDualfarkasLinear(
scip, pricerdata->edgecons[e]);
}
else
{
pricerdata->pi[e] = SCIPgetDualsolLinear(
scip, pricerdata->edgecons[e]);
}
}
}
SCIP_CALL( SCIPallocMemoryArray(scip, &path, graph->knots) );
SCIP_CALL( SCIPallocMemoryArray(scip, &edgecosts, pricerdata->nedges) );
if( pricerdata->bigt )
{
for( e = 0; e < pricerdata->nedges; ++e )
{
edgecosts[e] = (-pricerdata->pi[e]);
}
}
/* find shortest r-t (r root, t terminal) paths and create corresponding variables iff reduced cost < 0 */
for( t = 0; t < pricerdata->realnterms; ++t )
{
for( e = 0; e < pricerdata->nedges; ++e )
{
if( !pricerdata->bigt )
{
edgecosts[e] = (-pricerdata->pi[t * pricerdata->nedges + e]);
}
assert(!SCIPisNegative(scip, edgecosts[e]));
}
for( i = 0; i < graph->knots; i++ )
graph->mark[i] = 1;
graph_path_exec(scip, graph, FSP_MODE, pricerdata->root, edgecosts, path);
/* compute reduced cost of shortest path to terminal t */
redcost = 0.0;
tail = pricerdata->realterms[t];
while( tail != pricerdata->root )
{
redcost += edgecosts[path[tail].edge];
tail = graph->tail[path[tail].edge];
}
redcost -= pricerdata->mi[t];
if( !farkas && SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL )
{
newlowerbound += redcost;
}
/* check if reduced cost < 0 */
if( SCIPisNegative(scip, redcost) )
{
/* create variable to the shortest path (having reduced cost < 0) */
var = NULL;
sprintf(varname, "PathVar%d_%d", t, pricerdata->ncreatedvars[t]);
++(pricerdata->ncreatedvars[t]);
SCIP_CALL( SCIPcreateVarBasic(scip, &var, varname, 0.0, SCIPinfinity(scip), 0.0, SCIP_VARTYPE_CONTINUOUS) );
SCIP_CALL( SCIPaddPricedVar(scip, var, -redcost) );
tail = pricerdata->realterms[t];
while( tail != pricerdata->root )
{
/* add variable to constraints */
if( !pricerdata->bigt )
{
SCIP_CALL( SCIPaddCoefLinear(scip, pricerdata->edgecons[t * pricerdata->nedges + path[tail].edge], var, 1.0) );
}
else
{
SCIP_CALL( SCIPaddCoefLinear(scip, pricerdata->edgecons[path[tail].edge], var, 1.0) );
}
tail = graph->tail[path[tail].edge];
}
SCIP_CALL( SCIPaddCoefLinear(scip, pricerdata->pathcons[t], var, 1.0) );
}
}
if( !farkas && SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL )
*lowerbound = newlowerbound;
SCIPfreeMemoryArray(scip, &edgecosts);
SCIPfreeMemoryArray(scip, &path);
return SCIP_OKAY;
}
/** try one-opt on given solution */
static
SCIP_RETCODE tryOneOpt(
SCIP* scip, /**< SCIP data structure */
SCIP_HEUR* heur, /**< indicator heuristic */
SCIP_HEURDATA* heurdata, /**< heuristic data */
int nindconss, /**< number of indicator constraints */
SCIP_CONS** indconss, /**< indicator constraints */
SCIP_Bool* solcand, /**< values for indicator variables in partial solution */
int* nfoundsols /**< number of solutions found */
)
{
SCIP_Bool cutoff;
SCIP_Bool lperror;
SCIP_Bool stored;
SCIP_SOL* sol;
int cnt = 0;
int i;
int c;
assert( scip != NULL );
assert( heur != NULL );
assert( heurdata != NULL );
assert( nindconss == 0 || indconss != NULL );
assert( solcand != NULL );
assert( nfoundsols != NULL );
SCIPdebugMessage("Performing one-opt ...\n");
*nfoundsols = 0;
SCIP_CALL( SCIPstartProbing(scip) );
for (i = 0; i < nindconss; ++i)
{
SCIP_VAR* binvar;
/* skip nonactive constraints */
if ( ! SCIPconsIsActive(indconss[i]) )
continue;
binvar = SCIPgetBinaryVarIndicator(indconss[i]);
assert( binvar != NULL );
/* skip constraints with fixed variables */
if ( SCIPvarGetUbLocal(binvar) < 0.5 || SCIPvarGetLbLocal(binvar) > 0.5 )
continue;
/* return if the we would exceed the depth limit of the tree */
if( SCIPgetDepthLimit(scip) <= SCIPgetDepth(scip) )
break;
/* get rid of all bound changes */
SCIP_CALL( SCIPnewProbingNode(scip) );
++cnt;
/* fix variables */
for (c = 0; c < nindconss; ++c)
{
SCIP_Bool s;
/* skip nonactive constraints */
if ( ! SCIPconsIsActive(indconss[c]) )
continue;
binvar = SCIPgetBinaryVarIndicator(indconss[c]);
assert( binvar != NULL );
/* fix variables according to solution candidate, except constraint i */
if ( c == i )
s = ! solcand[c];
else
s = solcand[c];
if ( ! s )
{
if ( SCIPvarGetLbLocal(binvar) < 0.5 && SCIPvarGetUbLocal(binvar) > 0.5 )
{
SCIP_CALL( SCIPchgVarLbProbing(scip, binvar, 1.0) );
}
}
else
{
if ( SCIPvarGetUbLocal(binvar) > 0.5 && SCIPvarGetLbLocal(binvar) < 0.5 )
{
SCIP_CALL( SCIPchgVarUbProbing(scip, binvar, 0.0) );
}
}
}
/* propagate variables */
SCIP_CALL( SCIPpropagateProbing(scip, -1, &cutoff, NULL) );
if ( cutoff )
{
SCIP_CALL( SCIPbacktrackProbing(scip, 0) );
continue;
}
/* solve LP to move continuous variables */
SCIP_CALL( SCIPsolveProbingLP(scip, -1, &lperror, &cutoff) );
/* the LP often reaches the objective limit - we currently do not use such solutions */
if ( lperror || cutoff || SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
{
#ifdef SCIP_DEBUG
if ( lperror )
SCIPdebugMessage("An LP error occured.\n");
#endif
SCIP_CALL( SCIPbacktrackProbing(scip, 0) );
continue;
}
/* create solution */
SCIP_CALL( SCIPcreateSol(scip, &sol, heur) );
/* copy the current LP solution to the working solution */
SCIP_CALL( SCIPlinkLPSol(scip, sol) );
/* check solution for feasibility */
SCIPdebugMessage("One-opt found solution candidate with value %g.\n", SCIPgetSolTransObj(scip, sol));
/* only check integrality, because we solved an LP */
SCIP_CALL( SCIPtrySolFree(scip, &sol, FALSE, FALSE, TRUE, FALSE, &stored) );
if ( stored )
++(*nfoundsols);
SCIP_CALL( SCIPbacktrackProbing(scip, 0) );
}
SCIP_CALL( SCIPendProbing(scip) );
SCIPdebugMessage("Finished one-opt (tried variables: %d, found sols: %d).\n", cnt, *nfoundsols);
return SCIP_OKAY;
}
/** try given solution */
static
SCIP_RETCODE trySolCandidate(
SCIP* scip, /**< SCIP data structure */
SCIP_HEUR* heur, /**< indicator heuristic */
SCIP_HEURDATA* heurdata, /**< heuristic data */
int nindconss, /**< number of indicator constraints */
SCIP_CONS** indconss, /**< indicator constraints */
SCIP_Bool* solcand, /**< values for indicator variables in partial solution */
int* nfoundsols /**< number of solutions found */
)
{
SCIP_Bool cutoff;
SCIP_Bool lperror;
SCIP_Bool stored;
SCIP_SOL* sol;
int c;
assert( scip != NULL );
assert( heur != NULL );
assert( heurdata != NULL );
assert( nindconss == 0 || indconss != NULL );
assert( solcand != NULL );
assert( nfoundsols != NULL );
SCIPdebugMessage("Trying to generate feasible solution with indicators from solution candidate ...\n");
*nfoundsols = 0;
SCIP_CALL( SCIPstartProbing(scip) );
/* we can stop here if we have already reached the maximal depth */
if( SCIPgetDepthLimit(scip) <= SCIPgetDepth(scip) )
{
SCIP_CALL( SCIPendProbing(scip) );
return SCIP_OKAY;
}
SCIP_CALL( SCIPnewProbingNode(scip) );
/* fix variables */
for (c = 0; c < nindconss; ++c)
{
SCIP_VAR* binvar;
/* skip nonactive constraints */
if ( ! SCIPconsIsActive(indconss[c]) )
continue;
binvar = SCIPgetBinaryVarIndicator(indconss[c]);
assert( binvar != NULL );
/* Fix binary variables not in cover to 1 and corresponding slack variables to 0. The other binary variables are fixed to 0. */
if ( ! solcand[c] )
{
/* to be sure, check for non-fixed variables */
if ( SCIPvarGetLbLocal(binvar) < 0.5 && SCIPvarGetUbLocal(binvar) > 0.5 )
{
SCIP_CALL( SCIPchgVarLbProbing(scip, binvar, 1.0) );
}
}
else
{
if ( SCIPvarGetUbLocal(binvar) > 0.5 && SCIPvarGetLbLocal(binvar) < 0.5 )
{
SCIP_CALL( SCIPchgVarUbProbing(scip, binvar, 0.0) );
}
}
}
/* propagate variables */
SCIP_CALL( SCIPpropagateProbing(scip, -1, &cutoff, NULL) );
if ( cutoff )
{
SCIPdebugMessage("Solution candidate reaches cutoff (in propagation).\n");
SCIP_CALL( SCIPendProbing(scip) );
return SCIP_OKAY;
}
/* solve LP to move continuous variables */
SCIP_CALL( SCIPsolveProbingLP(scip, -1, &lperror, &cutoff) );
/* the LP often reaches the objective limit - we currently do not use such solutions */
if ( lperror || cutoff || SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
{
#ifdef SCIP_DEBUG
if ( lperror )
SCIPdebugMessage("An LP error occured.\n");
else
SCIPdebugMessage("Solution candidate reaches cutoff (in LP solving).\n");
#endif
SCIP_CALL( SCIPendProbing(scip) );
return SCIP_OKAY;
}
/* create solution */
SCIP_CALL( SCIPcreateSol(scip, &sol, heur) );
/* copy the current LP solution to the working solution */
SCIP_CALL( SCIPlinkLPSol(scip, sol) );
/* check solution for feasibility */
#ifdef SCIP_DEBUG
SCIPdebugMessage("Found solution candidate with value %g.\n", SCIPgetSolTransObj(scip, sol));
#ifdef SCIP_MORE_DEBUG
SCIP_CALL( SCIPprintSol(scip, sol, NULL, FALSE) );
#endif
SCIP_CALL( SCIPtrySolFree(scip, &sol, TRUE, TRUE, TRUE, TRUE, &stored) );
if ( stored )
{
++(*nfoundsols);
SCIPdebugMessage("Solution is feasible and stored.\n");
}
else
SCIPdebugMessage("Solution was not stored.\n");
#else
/* only check integrality, because we solved an LP */
SCIP_CALL( SCIPtrySolFree(scip, &sol, FALSE, FALSE, TRUE, FALSE, &stored) );
if ( stored )
++(*nfoundsols);
#endif
SCIP_CALL( SCIPendProbing(scip) );
/* possibly perform one-opt */
if ( stored && heurdata->oneopt )
{
int nfound = 0;
assert( *nfoundsols > 0 );
SCIP_CALL( tryOneOpt(scip, heur, heurdata, nindconss, indconss, solcand, &nfound) );
}
return SCIP_OKAY;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecShifting) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_SOL* sol;
SCIP_VAR** lpcands;
SCIP_Real* lpcandssol;
SCIP_ROW** lprows;
SCIP_Real* activities;
SCIP_ROW** violrows;
SCIP_Real* nincreases;
SCIP_Real* ndecreases;
int* violrowpos;
int* nfracsinrow;
SCIP_Real increaseweight;
SCIP_Real obj;
SCIP_Real bestshiftval;
SCIP_Real minobj;
int nlpcands;
int nlprows;
int nvars;
int nfrac;
int nviolrows;
int nprevviolrows;
int minnviolrows;
int nnonimprovingshifts;
int c;
int r;
SCIP_Longint nlps;
SCIP_Longint ncalls;
SCIP_Longint nsolsfound;
SCIP_Longint nnodes;
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
assert(scip != NULL);
assert(result != NULL);
assert(SCIPhasCurrentNodeLP(scip));
*result = SCIP_DIDNOTRUN;
/* only call heuristic, if an optimal LP solution is at hand */
if( SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
return SCIP_OKAY;
/* only call heuristic, if the LP objective value is smaller than the cutoff bound */
if( SCIPisGE(scip, SCIPgetLPObjval(scip), SCIPgetCutoffbound(scip)) )
return SCIP_OKAY;
/* get heuristic data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* don't call heuristic, if we have already processed the current LP solution */
nlps = SCIPgetNLPs(scip);
if( nlps == heurdata->lastlp )
return SCIP_OKAY;
heurdata->lastlp = nlps;
/* don't call heuristic, if it was not successful enough in the past */
ncalls = SCIPheurGetNCalls(heur);
nsolsfound = 10*SCIPheurGetNBestSolsFound(heur) + SCIPheurGetNSolsFound(heur);
nnodes = SCIPgetNNodes(scip);
if( nnodes % ((ncalls/100)/(nsolsfound+1)+1) != 0 )
return SCIP_OKAY;
/* get fractional variables, that should be integral */
/* todo check if heuristic should include implicit integer variables for its calculations */
SCIP_CALL( SCIPgetLPBranchCands(scip, &lpcands, &lpcandssol, NULL, &nlpcands, NULL, NULL) );
nfrac = nlpcands;
/* only call heuristic, if LP solution is fractional */
if( nfrac == 0 )
return SCIP_OKAY;
*result = SCIP_DIDNOTFIND;
/* get LP rows */
SCIP_CALL( SCIPgetLPRowsData(scip, &lprows, &nlprows) );
SCIPdebugMessage("executing shifting heuristic: %d LP rows, %d fractionals\n", nlprows, nfrac);
/* get memory for activities, violated rows, and row violation positions */
nvars = SCIPgetNVars(scip);
SCIP_CALL( SCIPallocBufferArray(scip, &activities, nlprows) );
SCIP_CALL( SCIPallocBufferArray(scip, &violrows, nlprows) );
SCIP_CALL( SCIPallocBufferArray(scip, &violrowpos, nlprows) );
SCIP_CALL( SCIPallocBufferArray(scip, &nfracsinrow, nlprows) );
SCIP_CALL( SCIPallocBufferArray(scip, &nincreases, nvars) );
SCIP_CALL( SCIPallocBufferArray(scip, &ndecreases, nvars) );
BMSclearMemoryArray(nfracsinrow, nlprows);
BMSclearMemoryArray(nincreases, nvars);
BMSclearMemoryArray(ndecreases, nvars);
/* get the activities for all globally valid rows;
* the rows should be feasible, but due to numerical inaccuracies in the LP solver, they can be violated
*/
nviolrows = 0;
for( r = 0; r < nlprows; ++r )
{
SCIP_ROW* row;
row = lprows[r];
assert(SCIProwGetLPPos(row) == r);
if( !SCIProwIsLocal(row) )
{
activities[r] = SCIPgetRowActivity(scip, row);
if( SCIPisFeasLT(scip, activities[r], SCIProwGetLhs(row))
|| SCIPisFeasGT(scip, activities[r], SCIProwGetRhs(row)) )
{
violrows[nviolrows] = row;
violrowpos[r] = nviolrows;
nviolrows++;
}
else
violrowpos[r] = -1;
}
}
/* calc the current number of fractional variables in rows */
for( c = 0; c < nlpcands; ++c )
addFracCounter(nfracsinrow, nlprows, lpcands[c], +1);
/* get the working solution from heuristic's local data */
sol = heurdata->sol;
assert(sol != NULL);
/* copy the current LP solution to the working solution */
SCIP_CALL( SCIPlinkLPSol(scip, sol) );
/* calculate the minimal objective value possible after rounding fractional variables */
minobj = SCIPgetSolTransObj(scip, sol);
assert(minobj < SCIPgetCutoffbound(scip));
for( c = 0; c < nlpcands; ++c )
{
obj = SCIPvarGetObj(lpcands[c]);
bestshiftval = obj > 0.0 ? SCIPfeasFloor(scip, lpcandssol[c]) : SCIPfeasCeil(scip, lpcandssol[c]);
minobj += obj * (bestshiftval - lpcandssol[c]);
}
/* try to shift remaining variables in order to become/stay feasible */
nnonimprovingshifts = 0;
minnviolrows = INT_MAX;
increaseweight = 1.0;
while( (nfrac > 0 || nviolrows > 0) && nnonimprovingshifts < MAXSHIFTINGS )
{
SCIP_VAR* shiftvar;
SCIP_Real oldsolval;
SCIP_Real newsolval;
SCIP_Bool oldsolvalisfrac;
int probindex;
SCIPdebugMessage("shifting heuristic: nfrac=%d, nviolrows=%d, obj=%g (best possible obj: %g), cutoff=%g\n",
nfrac, nviolrows, SCIPgetSolOrigObj(scip, sol), SCIPretransformObj(scip, minobj),
SCIPretransformObj(scip, SCIPgetCutoffbound(scip)));
nprevviolrows = nviolrows;
/* choose next variable to process:
* - if a violated row exists, shift a variable decreasing the violation, that has least impact on other rows
* - otherwise, shift a variable, that has strongest devastating impact on rows in opposite direction
*/
shiftvar = NULL;
oldsolval = 0.0;
newsolval = 0.0;
if( nviolrows > 0 && (nfrac == 0 || nnonimprovingshifts < MAXSHIFTINGS-1) )
{
SCIP_ROW* row;
int rowidx;
int rowpos;
int direction;
rowidx = -1;
rowpos = -1;
row = NULL;
if( nfrac > 0 )
{
for( rowidx = nviolrows-1; rowidx >= 0; --rowidx )
{
row = violrows[rowidx];
rowpos = SCIProwGetLPPos(row);
assert(violrowpos[rowpos] == rowidx);
if( nfracsinrow[rowpos] > 0 )
break;
}
}
if( rowidx == -1 )
{
rowidx = SCIPgetRandomInt(0, nviolrows-1, &heurdata->randseed);
row = violrows[rowidx];
rowpos = SCIProwGetLPPos(row);
assert(0 <= rowpos && rowpos < nlprows);
assert(violrowpos[rowpos] == rowidx);
assert(nfracsinrow[rowpos] == 0);
}
assert(violrowpos[rowpos] == rowidx);
SCIPdebugMessage("shifting heuristic: try to fix violated row <%s>: %g <= %g <= %g\n",
SCIProwGetName(row), SCIProwGetLhs(row), activities[rowpos], SCIProwGetRhs(row));
SCIPdebug( SCIP_CALL( SCIPprintRow(scip, row, NULL) ) );
/* get direction in which activity must be shifted */
assert(SCIPisFeasLT(scip, activities[rowpos], SCIProwGetLhs(row))
|| SCIPisFeasGT(scip, activities[rowpos], SCIProwGetRhs(row)));
direction = SCIPisFeasLT(scip, activities[rowpos], SCIProwGetLhs(row)) ? +1 : -1;
/* search a variable that can shift the activity in the necessary direction */
SCIP_CALL( selectShifting(scip, sol, row, activities[rowpos], direction,
nincreases, ndecreases, increaseweight, &shiftvar, &oldsolval, &newsolval) );
}
if( shiftvar == NULL && nfrac > 0 )
{
SCIPdebugMessage("shifting heuristic: search rounding variable and try to stay feasible\n");
SCIP_CALL( selectEssentialRounding(scip, sol, minobj, lpcands, nlpcands, &shiftvar, &oldsolval, &newsolval) );
}
/* check, whether shifting was possible */
if( shiftvar == NULL || SCIPisEQ(scip, oldsolval, newsolval) )
{
SCIPdebugMessage("shifting heuristic: -> didn't find a shifting variable\n");
break;
}
SCIPdebugMessage("shifting heuristic: -> shift var <%s>[%g,%g], type=%d, oldval=%g, newval=%g, obj=%g\n",
SCIPvarGetName(shiftvar), SCIPvarGetLbGlobal(shiftvar), SCIPvarGetUbGlobal(shiftvar), SCIPvarGetType(shiftvar),
oldsolval, newsolval, SCIPvarGetObj(shiftvar));
/* update row activities of globally valid rows */
SCIP_CALL( updateActivities(scip, activities, violrows, violrowpos, &nviolrows, nlprows,
shiftvar, oldsolval, newsolval) );
if( nviolrows >= nprevviolrows )
nnonimprovingshifts++;
else if( nviolrows < minnviolrows )
{
minnviolrows = nviolrows;
nnonimprovingshifts = 0;
}
/* store new solution value and decrease fractionality counter */
SCIP_CALL( SCIPsetSolVal(scip, sol, shiftvar, newsolval) );
/* update fractionality counter and minimal objective value possible after shifting remaining variables */
oldsolvalisfrac = !SCIPisFeasIntegral(scip, oldsolval)
&& (SCIPvarGetType(shiftvar) == SCIP_VARTYPE_BINARY || SCIPvarGetType(shiftvar) == SCIP_VARTYPE_INTEGER);
obj = SCIPvarGetObj(shiftvar);
if( (SCIPvarGetType(shiftvar) == SCIP_VARTYPE_BINARY || SCIPvarGetType(shiftvar) == SCIP_VARTYPE_INTEGER)
&& oldsolvalisfrac )
{
assert(SCIPisFeasIntegral(scip, newsolval));
nfrac--;
nnonimprovingshifts = 0;
minnviolrows = INT_MAX;
addFracCounter(nfracsinrow, nlprows, shiftvar, -1);
/* the rounding was already calculated into the minobj -> update only if rounding in "wrong" direction */
if( obj > 0.0 && newsolval > oldsolval )
minobj += obj;
else if( obj < 0.0 && newsolval < oldsolval )
minobj -= obj;
}
else
{
/* update minimal possible objective value */
minobj += obj * (newsolval - oldsolval);
}
/* update increase/decrease arrays */
if( !oldsolvalisfrac )
{
probindex = SCIPvarGetProbindex(shiftvar);
assert(0 <= probindex && probindex < nvars);
increaseweight *= WEIGHTFACTOR;
if( newsolval < oldsolval )
ndecreases[probindex] += increaseweight;
else
nincreases[probindex] += increaseweight;
if( increaseweight >= 1e+09 )
{
int i;
for( i = 0; i < nvars; ++i )
{
nincreases[i] /= increaseweight;
ndecreases[i] /= increaseweight;
}
increaseweight = 1.0;
}
}
SCIPdebugMessage("shifting heuristic: -> nfrac=%d, nviolrows=%d, obj=%g (best possible obj: %g)\n",
nfrac, nviolrows, SCIPgetSolOrigObj(scip, sol), SCIPretransformObj(scip, minobj));
}
/* check, if the new solution is feasible */
if( nfrac == 0 && nviolrows == 0 )
{
SCIP_Bool stored;
/* check solution for feasibility, and add it to solution store if possible
* neither integrality nor feasibility of LP rows has to be checked, because this is already
* done in the shifting heuristic itself; however, we better check feasibility of LP rows,
* because of numerical problems with activity updating
*/
SCIP_CALL( SCIPtrySol(scip, sol, FALSE, FALSE, FALSE, TRUE, &stored) );
if( stored )
{
SCIPdebugMessage("found feasible shifted solution:\n");
SCIPdebug( SCIP_CALL( SCIPprintSol(scip, sol, NULL, FALSE) ) );
*result = SCIP_FOUNDSOL;
}
}
/* free memory buffers */
SCIPfreeBufferArray(scip, &ndecreases);
SCIPfreeBufferArray(scip, &nincreases);
SCIPfreeBufferArray(scip, &nfracsinrow);
SCIPfreeBufferArray(scip, &violrowpos);
SCIPfreeBufferArray(scip, &violrows);
SCIPfreeBufferArray(scip, &activities);
return SCIP_OKAY;
}
/** 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;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecReoptsols)
{/*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_SOL** sols;
SCIP_Real objsimsol;
SCIP_Bool sepabestsol;
int allocmem;
int nchecksols;
int nsolsadded;
#ifdef SCIP_MORE_DEBUG
int nsolsaddedrun;
#endif
int run;
int max_run;
assert(heur != NULL);
assert(scip != NULL);
*result = SCIP_DIDNOTRUN;
if( !SCIPisReoptEnabled(scip) )
return SCIP_OKAY;
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
max_run = heurdata->maxruns == -1 ? 0 : MAX(0, SCIPgetNReoptRuns(scip)-1-heurdata->maxruns); /*lint !e666*/
nchecksols = heurdata->maxsols == -1 ? INT_MAX : heurdata->maxsols;
SCIP_CALL( SCIPgetRealParam(scip, "reoptimization/objsimsol", &objsimsol) );
SCIP_CALL( SCIPgetBoolParam(scip, "reoptimization/sepabestsol", &sepabestsol) );
/* allocate a buffer array to store the solutions */
allocmem = 20;
SCIP_CALL( SCIPallocBufferArray(scip, &sols, allocmem) );
nsolsadded = 0;
for( run = SCIPgetNReoptRuns(scip); run > max_run && nchecksols > 0; run-- )
{
SCIP_Real sim;
int nsols;
#ifdef SCIP_MORE_DEBUG
nsolsaddedrun = 0;
#endif
nsols = 0;
if( objsimsol == -1 )
sim = 1;
else
sim = SCIPgetReoptSimilarity(scip, run, SCIPgetNReoptRuns(scip)-1);
if( sim >= objsimsol )
{
int s;
/* get solutions of a specific run */
SCIP_CALL( SCIPgetReopSolsRun(scip, run, sols, allocmem, &nsols) );
/* check memory and reallocate */
if( nsols > allocmem )
{
allocmem = nsols;
SCIP_CALL( SCIPreallocBufferArray(scip, &sols, allocmem) );
SCIP_CALL( SCIPgetReopSolsRun(scip, run, sols, allocmem, &nsols) );
}
assert(nsols <= allocmem);
/* update the solutions
* stop, if the maximal number of solutions to be checked is reached
*/
for( s = 0; s < nsols && nchecksols > 0; s++ )
{
SCIP_SOL* sol;
SCIP_Real objsol;
sol = sols[s];
SCIP_CALL( SCIPrecomputeSolObj(scip, sol) );
objsol = SCIPgetSolTransObj(scip, sol);
/* we do not want to add solutions with objective value +infinity.
* moreover, the solution should improve the current primal bound
*/
if( !SCIPisInfinity(scip, objsol) && !SCIPisInfinity(scip, -objsol)
&& SCIPisFeasLT(scip, objsol, SCIPgetCutoffbound(scip)) )
{
SCIP_Bool stored;
SCIP_Bool feasible;
if( sepabestsol )
{
SCIP_CALL( SCIPcheckSolOrig(scip, sol, &feasible, FALSE, TRUE) );
}
else
feasible = TRUE;
if( feasible)
{
/* create a new solution */
SCIP_CALL( createNewSol(scip, heur, sol, &stored) );
if( stored )
{
nsolsadded++;
#ifdef SCIP_MORE_DEBUG
nsolsaddedrun++;
#endif
heurdata->nimprovingsols++;
}
}
}
nchecksols--;
heurdata->ncheckedsols++;
}
}
#ifdef SCIP_MORE_DEBUG
printf(">> heuristic <%s> found %d of %d improving solutions from run %d.\n", HEUR_NAME, nsolsaddedrun, nsols, run);
#endif
}
SCIPdebugMessage(">> heuristic <%s> found %d improving solutions.\n", HEUR_NAME, nsolsadded);
if( nsolsadded > 0 )
*result = SCIP_FOUNDSOL;
else
*result = SCIP_DIDNOTFIND;
/* reset the marks of the checked solutions */
SCIPresetReoptSolMarks(scip);
/* free the buffer array */
SCIPfreeBufferArray(scip, &sols);
return SCIP_OKAY;
}
