/** selects a variable out of the given candidate array and performs the branching */
static
SCIP_RETCODE performBranching(
SCIP* scip, /**< SCIP data structure */
SCIP_VAR** cands, /**< candidate array */
SCIP_Real* candsols, /**< array of candidate solution values, or NULL */
int ncands, /**< number of candidates */
SCIP_Real conflictweight, /**< weight in score calculations for conflict score */
SCIP_Real inferenceweight, /**< weight in score calculations for inference score */
SCIP_Real cutoffweight, /**< weight in score calculations for cutoff score */
SCIP_Real reliablescore, /**< score which is seen to be reliable for a branching decision */
SCIP_Bool useweightedsum, /**< should a weighted sum of inference, conflict and cutoff weights be used? */
SCIP_RESULT* result /**< buffer to store result (branched, reduced domain, ...) */
)
{
SCIP_VAR* bestaggrcand;
SCIP_VAR* bestvaluecand;
SCIP_Real bestval;
SCIP_Real bestaggrscore;
SCIP_Real bestvaluescore;
SCIP_Real bestbranchpoint;
SCIP_BRANCHDIR bestbranchdir;
SCIP_NODE* downchild;
SCIP_NODE* eqchild;
SCIP_NODE* upchild;
bestbranchpoint = SCIP_UNKNOWN;
bestbranchdir = SCIP_BRANCHDIR_DOWNWARDS;
bestvaluescore = 0.0;
bestvaluecand = NULL;
assert(ncands > 0);
assert(result != NULL);
*result = SCIP_DIDNOTFIND;
/* check if the weighted sum between the average inferences and conflict score should be used */
if( useweightedsum )
{
int c;
bestaggrcand = cands[0];
bestvaluecand = cands[0];
assert(cands[0] != NULL);
if( candsols == NULL )
{
bestval = SCIP_UNKNOWN;
/* get domain value score for the first candidate */
bestvaluescore = getValueScore(scip, cands[0], conflictweight, cutoffweight, reliablescore, &bestbranchpoint, &bestbranchdir);
SCIPdebugMessage("current best value candidate <%s>[%g,%g] %s <%g> (value %g)\n",
SCIPvarGetName(bestvaluecand), SCIPvarGetLbLocal(bestvaluecand), SCIPvarGetUbLocal(bestvaluecand),
bestbranchdir == SCIP_BRANCHDIR_DOWNWARDS ? "<=" : ">=", bestbranchpoint, bestvaluescore);
}
else
bestval = candsols[0];
/* get aggregated score for the first candidate */
bestaggrscore = getAggrScore(scip, cands[0], conflictweight, inferenceweight, cutoffweight, reliablescore);
for( c = 1; c < ncands; ++c )
{
SCIP_VAR* cand;
SCIP_Real val;
SCIP_Real aggrscore;
SCIP_Real branchpoint;
SCIP_BRANCHDIR branchdir;
cand = cands[c];
assert(cand != NULL);
if( candsols == NULL )
{
SCIP_Real valuescore;
val = SCIP_UNKNOWN;
/* get domain value score for the candidate */
valuescore = getValueScore(scip, cand, conflictweight, cutoffweight, reliablescore, &branchpoint, &branchdir);
/* evaluate the candidate against the currently best candidate w.r.t. domain value score */
evaluateValueCand(cand, valuescore, branchpoint, branchdir, &bestvaluecand, &bestvaluescore, &bestbranchpoint, &bestbranchdir);
SCIPdebugMessage("current best value candidate <%s>[%g,%g] %s <%g> (value %g)\n",
SCIPvarGetName(bestvaluecand), SCIPvarGetLbLocal(bestvaluecand), SCIPvarGetUbLocal(bestvaluecand),
bestbranchdir == SCIP_BRANCHDIR_DOWNWARDS ? "<=" : ">=", bestbranchpoint, bestvaluescore);
}
else
val = candsols[c];
/* get aggregated score for the candidate */
aggrscore = getAggrScore(scip, cand, conflictweight, inferenceweight, cutoffweight, reliablescore);
SCIPdebugMessage(" -> cand <%s>: prio=%d, solval=%g, score=%g\n", SCIPvarGetName(cand), SCIPvarGetBranchPriority(cand),
val == SCIP_UNKNOWN ? SCIPgetVarSol(scip, cand) : val, aggrscore); /*lint !e777*/
/* evaluate the candidate against the currently best candidate w.r.t. aggregated score */
evaluateAggrCand(cand, aggrscore, val, &bestaggrcand, &bestaggrscore, &bestval);
}
}
else
{
int c;
bestaggrcand = cands[0];
assert(cands[0] != NULL);
if( candsols != NULL )
bestval = candsols[0];
else
bestval = SCIP_UNKNOWN;
bestaggrscore = SCIPgetVarAvgInferenceScore(scip, cands[0]);
/* search for variable with best score w.r.t. average inferences per branching */
for( c = 1; c < ncands; ++c )
{
SCIP_VAR* cand;
SCIP_Real val;
SCIP_Real aggrscore;
cand = cands[c];
assert(cand != NULL);
if( candsols != NULL )
val = candsols[c];
else
val = SCIP_UNKNOWN;
aggrscore = SCIPgetVarAvgInferenceScore(scip, cand);
/* in case the average inferences score is below the reliable score we set it to zero since it is seen to be
* unreliable
*/
if( aggrscore < reliablescore )
aggrscore = 0.0;
SCIPdebugMessage(" -> cand <%s>: prio=%d, solval=%g, score=%g\n", SCIPvarGetName(cand), SCIPvarGetBranchPriority(cand),
val == SCIP_UNKNOWN ? SCIPgetVarSol(scip, cand) : val, aggrscore); /*lint !e777*/
/* evaluate the candidate against the currently best candidate */
evaluateAggrCand(cand, aggrscore, val, &bestaggrcand, &bestaggrscore, &bestval);
}
}
assert(bestaggrcand != NULL);
SCIPdebugMessage(" -> %d candidates, selected variable <%s>[%g,%g] (prio=%d, solval=%.12f, score=%g, conflict=%g cutoff=%g, inference=%g)\n",
ncands, SCIPvarGetName(bestaggrcand), SCIPvarGetLbLocal (bestaggrcand), SCIPvarGetUbLocal(bestaggrcand), SCIPvarGetBranchPriority(bestaggrcand),
bestval == SCIP_UNKNOWN ? SCIPgetVarSol(scip, bestaggrcand) : bestval, bestaggrscore, /*lint !e777*/
SCIPgetVarConflictScore(scip, bestaggrcand), SCIPgetVarAvgInferenceCutoffScore(scip, bestaggrcand, cutoffweight),
SCIPgetVarAvgInferenceScore(scip, bestaggrcand));
/* perform the branching */
if( candsols != NULL )
{
SCIP_CALL( SCIPbranchVarVal(scip, bestaggrcand, SCIPgetBranchingPoint(scip, bestaggrcand, bestval), &downchild, &eqchild, &upchild) );
}
else if( bestbranchpoint == SCIP_UNKNOWN ) /*lint !e777*/
{
SCIP_CALL( SCIPbranchVar(scip, bestaggrcand, &downchild, &eqchild, &upchild) );
}
else
{
SCIP_Real estimate;
SCIP_Real downprio;
SCIP_Real upprio;
SCIP_Real downub;
SCIP_Real uplb;
assert(bestvaluecand != NULL);
downprio = 0.0;
upprio = 0.0;
if( bestbranchdir == SCIP_BRANCHDIR_DOWNWARDS )
{
downprio = 1.0;
downub = bestbranchpoint;
uplb = bestbranchpoint + 1.0;
}
else
{
upprio = 1.0;
downub = bestbranchpoint - 1.0;
uplb = bestbranchpoint;
}
/* calculate the child estimate */
estimate = SCIPcalcChildEstimate(scip, bestvaluecand, downub);
/* create down child */
SCIP_CALL( SCIPcreateChild(scip, &downchild, downprio, estimate) );
/* change upper bound in down child */
SCIP_CALL( SCIPchgVarUbNode(scip, downchild, bestvaluecand, downub) );
/* calculate the child estimate */
estimate = SCIPcalcChildEstimate(scip, bestvaluecand, uplb);
/* create up child */
SCIP_CALL( SCIPcreateChild(scip, &upchild, upprio, estimate) );
/* change lower bound in up child */
SCIP_CALL( SCIPchgVarLbNode(scip, upchild, bestvaluecand, uplb) );
SCIPdebugMessage("branch on variable <%s> and value <%g>\n", SCIPvarGetName(bestvaluecand), bestbranchpoint);
eqchild = NULL;
}
if( downchild != NULL || eqchild != NULL || upchild != NULL )
{
*result = SCIP_BRANCHED;
}
else
{
/* if there are no children, then variable should have been fixed by SCIPbranchVar(Val) */
assert(SCIPisEQ(scip, SCIPvarGetLbLocal(bestaggrcand), SCIPvarGetUbLocal(bestaggrcand)));
*result = SCIP_REDUCEDDOM;
}
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;
}
/** selects a variable and fixes it to its current pseudo solution value */
static
SCIP_RETCODE fixVariable(
SCIP* scip, /**< SCIP data structure */
SCIP_VAR** pseudocands, /**< array of unfixed variables */
int npseudocands, /**< number of unfixed variables */
SCIP_Real large /**< large value to be used instead of infinity */
)
{
SCIP_VAR* var;
SCIP_Real bestscore;
SCIP_Real score;
SCIP_Real solval;
int bestcand;
int ncands;
int c;
assert(pseudocands != NULL);
assert(npseudocands > 0);
/* if existing, choose one of the highest priority binary variables; if no high priority binary variables
* exist, choose a variable among all unfixed integral variables
*/
ncands = SCIPgetNPrioPseudoBranchBins(scip);
if( ncands == 0 )
ncands = npseudocands;
/* select variable to tighten the domain for */
bestscore = -SCIPinfinity(scip);
bestcand = -1;
for( c = 0; c < ncands; ++c )
{
score = SCIPgetVarAvgInferenceScore(scip, pseudocands[c]);
if( score > bestscore )
{
bestscore = score;
bestcand = c;
}
}
assert(bestcand != -1);
/* fix variable to its current pseudo solution value */
var = pseudocands[bestcand];
solval = SCIPgetVarSol(scip, var);
/* adapt solution value if it is infinite */
if( SCIPisInfinity(scip, solval) )
{
SCIP_Real lb;
assert(SCIPisInfinity(scip, SCIPvarGetUbLocal(var)));
lb = SCIPvarGetLbLocal(var);
/* adapt fixing value by changing it to a large value */
if( SCIPisInfinity(scip, -lb) )
solval = SCIPceil(scip, large);
else if( !SCIPisInfinity(scip, SCIPceil(scip, lb+large)) )
solval = SCIPceil(scip, lb+large);
}
else if( SCIPisInfinity(scip, -solval) )
{
SCIP_Real ub;
assert(SCIPisInfinity(scip, -SCIPvarGetLbLocal(var)));
ub = SCIPvarGetUbLocal(var);
/* adapt fixing value by changing it to a large negative value */
if( SCIPisInfinity(scip, ub) )
solval = SCIPfloor(scip, -large);
else if( !SCIPisInfinity(scip, -SCIPfloor(scip, ub-large)) )
solval = SCIPfloor(scip, ub-large);
}
assert(SCIPisFeasIntegral(scip, solval)); /* in probing, we always have the pseudo solution */
SCIPdebugMessage(" -> fixed variable <%s>[%g,%g] = %g (%d candidates left)\n",
SCIPvarGetName(var), SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var), solval, npseudocands - 1);
SCIP_CALL( SCIPfixVarProbing(scip, var, solval) );
return SCIP_OKAY;
}
