/** calculates the color value for a given coefficient */
static
void calcColorValue(
SCIP* scip, /**< SCIP data structure */
SCIP_READERDATA* readerdata, /**< information for reader */
SCIP_Real coef, /**< Coefficient to scale */
int* red, /**< red part */
int* green, /**< green part */
int* blue, /**< blue part */
SCIP_Real scale /**< maximal coefficient */
)
{
SCIP_Real coeflog;
assert(scip != NULL);
assert(readerdata != NULL);
assert(readerdata->rgb_limit >= 0);
assert(coef > 0);
coeflog = SCIPfloor(scip, log10(coef));
if(!(readerdata->rgb_relativ))
{
(*red) = 255;
(*blue) = ((readerdata->rgb_limit) - (unsigned short) (coef/scale*(readerdata->rgb_limit)));
(*green) = *blue;
}
else
{
if( coeflog >= 0 )
{
(*red) = 255;
if( coeflog >= (readerdata->coef_limit) )
{
(*blue) = 0;
(*green) = 0;
}
else
{
(*blue) = (readerdata->rgb_limit) - (unsigned short) ((readerdata->rgb_limit)*coeflog/(readerdata->coef_limit));
(*green) = *blue;
}
}
else
{
(*blue) = 255;
coeflog = -1.0*coeflog;
if( coeflog >= (readerdata->coef_limit) )
{
(*red) = 0;
(*green) = 0;
}
else
{
(*red) = (readerdata->rgb_limit) - (unsigned short) ((readerdata->rgb_limit)*coeflog/(readerdata->coef_limit));
(*green) = *red;
}
}
}
}
/** perform dual presolving */
static
SCIP_RETCODE performDualfix(
SCIP* scip, /**< SCIP data structure */
int* nfixedvars, /**< pointer to store number of fixed variables */
SCIP_Bool* unbounded, /**< pointer to store if an unboundness was detected */
SCIP_Bool* cutoff /**< pointer to store if a cutoff was detected */
)
{
SCIP_VAR** vars;
int nvars;
int v;
/* get active problem variables */
vars = SCIPgetVars(scip);
nvars = SCIPgetNVars(scip);
/* look for fixable variables
* loop backwards, since a variable fixing can change the current and the subsequent slots in the vars array
*/
for( v = nvars - 1; v >= 0; --v )
{
SCIP_VAR* var;
SCIP_Real bound;
SCIP_Real obj;
SCIP_Bool infeasible;
SCIP_Bool fixed;
var = vars[v];
assert(var != NULL);
/* don't perform dual presolving operations on deleted variables */
if( SCIPvarIsDeleted(var) )
continue;
/* ignore already fixed variables (use feasibility tolerance since this is used in SCIPfixVar() */
if( SCIPisFeasEQ(scip, SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var)) )
continue;
obj = SCIPvarGetObj(var);
/* if the objective coefficient of the variable is 0 and it may be rounded both
* up and down, then fix it to the closest feasible value to 0 */
if( SCIPisZero(scip, obj) && SCIPvarMayRoundDown(var) && SCIPvarMayRoundUp(var) )
{
SCIP_Real roundbound;
bound = SCIPvarGetLbGlobal(var);
if( SCIPisLT(scip, bound, 0.0) )
{
if( SCIPisLE(scip, 0.0, SCIPvarGetUbGlobal(var)) )
bound = 0.0;
else
{
/* try to take an integer value, only for polishing */
roundbound = SCIPfloor(scip, SCIPvarGetUbGlobal(var));
if( roundbound < bound )
bound = SCIPvarGetUbGlobal(var);
else
bound = roundbound;
}
}
else
{
/* try to take an integer value, only for polishing */
roundbound = SCIPceil(scip, bound);
if( roundbound < SCIPvarGetUbGlobal(var) )
bound = roundbound;
}
SCIPdebugMessage("fixing variable <%s> with objective 0 to %g\n", SCIPvarGetName(var), bound);
}
else
{
/* if it is always possible to round variable in direction of objective value, fix it to its proper bound */
if( SCIPvarMayRoundDown(var) && !SCIPisNegative(scip, obj) )
{
bound = SCIPvarGetLbGlobal(var);
if ( SCIPisInfinity(scip, -bound) )
{
/* variable can be fixed to -infinity */
if ( SCIPgetStage(scip) > SCIP_STAGE_PRESOLVING )
{
/* Fixing variables to infinity is not allowed after presolving, since LP-solvers cannot handle this
* consistently. We thus have to ignore this (should better be handled in presolving). */
continue;
}
if ( SCIPisZero(scip, obj) && SCIPvarGetNLocksUp(var) == 1 )
{
/* Variable is only contained in one constraint: we hope that the corresponding constraint handler is
* clever enough to set/aggregate the variable to something more useful than -infinity and do nothing
* here. */
continue;
}
}
SCIPdebugMessage("fixing variable <%s> with objective %g and %d uplocks to lower bound %g\n",
SCIPvarGetName(var), SCIPvarGetObj(var), SCIPvarGetNLocksUp(var), bound);
}
else if( SCIPvarMayRoundUp(var) && !SCIPisPositive(scip, obj) )
{
bound = SCIPvarGetUbGlobal(var);
if ( SCIPisInfinity(scip, bound) )
{
/* variable can be fixed to infinity */
if ( SCIPgetStage(scip) > SCIP_STAGE_PRESOLVING )
{
/* Fixing variables to infinity is not allowed after presolving, since LP-solvers cannot handle this
* consistently. We thus have to ignore this (should better be handled in presolving). */
continue;
}
if ( SCIPisZero(scip, obj) && SCIPvarGetNLocksDown(var) == 1 )
{
/* Variable is only contained in one constraint: we hope that the corresponding constraint handler is
* clever enough to set/aggregate the variable to something more useful than +infinity and do nothing
* here */
continue;
}
}
SCIPdebugMessage("fixing variable <%s> with objective %g and %d downlocks to upper bound %g\n",
SCIPvarGetName(var), SCIPvarGetObj(var), SCIPvarGetNLocksDown(var), bound);
}
else
continue;
}
if( SCIPisInfinity(scip, REALABS(bound)) && !SCIPisZero(scip, obj) )
{
SCIPdebugMessage(" -> unbounded fixing\n");
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL,
"problem infeasible or unbounded: variable <%s> with objective %.15g can be made infinitely %s\n",
SCIPvarGetName(var), SCIPvarGetObj(var), bound < 0.0 ? "small" : "large");
*unbounded = TRUE;
return SCIP_OKAY;
}
/* apply the fixing */
SCIPdebugMessage("apply fixing of variable %s to %g\n", SCIPvarGetName(var), bound);
SCIP_CALL( SCIPfixVar(scip, var, bound, &infeasible, &fixed) );
if( infeasible )
{
SCIPdebugMessage(" -> infeasible fixing\n");
*cutoff = TRUE;
return SCIP_OKAY;
}
assert(fixed || (SCIPgetStage(scip) == SCIP_STAGE_SOLVING && SCIPisFeasEQ(scip, bound, SCIPvarGetLbLocal(var))
&& SCIPisFeasEQ(scip, bound, SCIPvarGetUbLocal(var))));
(*nfixedvars)++;
}
return SCIP_OKAY;
}
/** creates a subproblem for subscip by fixing a number of variables */
static
SCIP_RETCODE createSubproblem(
SCIP* scip, /**< original SCIP data structure */
SCIP* subscip, /**< SCIP data structure for the subproblem */
SCIP_VAR** subvars, /**< the variables of the subproblem */
SCIP_Real minfixingrate, /**< percentage of integer variables that have to be fixed */
unsigned int* randseed, /**< a seed value for the random number generator */
SCIP_Bool uselprows /**< should subproblem be created out of the rows in the LP rows? */
)
{
SCIP_VAR** vars; /* original scip variables */
SCIP_SOL* sol; /* pool of solutions */
SCIP_Bool* marked; /* array of markers, which variables to fixed */
SCIP_Bool fixingmarker; /* which flag should label a fixed variable? */
int nvars;
int nbinvars;
int nintvars;
int i;
int j;
int nmarkers;
/* get required data of the original problem */
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, &nbinvars, &nintvars, NULL, NULL) );
sol = SCIPgetBestSol(scip);
assert(sol != NULL);
SCIP_CALL( SCIPallocBufferArray(scip, &marked, nbinvars+nintvars) );
if( minfixingrate > 0.5 )
{
nmarkers = nbinvars + nintvars - (int) SCIPfloor(scip, minfixingrate*(nbinvars+nintvars));
fixingmarker = FALSE;
}
else
{
nmarkers = (int) SCIPceil(scip, minfixingrate*(nbinvars+nintvars));
fixingmarker = TRUE;
}
assert( 0 <= nmarkers && nmarkers <= SCIPceil(scip,(nbinvars+nintvars)/2.0 ) );
j = 0;
BMSclearMemoryArray(marked, nbinvars+nintvars);
while( j < nmarkers )
{
do
{
i = SCIPgetRandomInt(0, nbinvars+nintvars-1, randseed);
}
while( marked[i] );
marked[i] = TRUE;
j++;
}
assert( j == nmarkers );
/* change bounds of variables of the subproblem */
for( i = 0; i < nbinvars + nintvars; i++ )
{
/* fix all randomly marked variables */
if( marked[i] == fixingmarker )
{
SCIP_Real solval;
SCIP_Real lb;
SCIP_Real ub;
solval = SCIPgetSolVal(scip, sol, vars[i]);
lb = SCIPvarGetLbGlobal(subvars[i]);
ub = SCIPvarGetUbGlobal(subvars[i]);
assert(SCIPisLE(scip, lb, ub));
/* due to dual reductions, it may happen that the solution value is not in
the variable's domain anymore */
if( SCIPisLT(scip, solval, lb) )
solval = lb;
else if( SCIPisGT(scip, solval, ub) )
solval = ub;
/* perform the bound change */
if( !SCIPisInfinity(scip, solval) && !SCIPisInfinity(scip, -solval) )
{
SCIP_CALL( SCIPchgVarLbGlobal(subscip, subvars[i], solval) );
SCIP_CALL( SCIPchgVarUbGlobal(subscip, subvars[i], solval) );
}
}
}
if( uselprows )
{
SCIP_ROW** rows; /* original scip rows */
int nrows;
/* get the rows and their number */
SCIP_CALL( SCIPgetLPRowsData(scip, &rows, &nrows) );
/* copy all rows to linear constraints */
for( i = 0; i < nrows; i++ )
{
SCIP_CONS* cons;
SCIP_VAR** consvars;
SCIP_COL** cols;
SCIP_Real constant;
SCIP_Real lhs;
SCIP_Real rhs;
SCIP_Real* vals;
int nnonz;
/* ignore rows that are only locally valid */
if( SCIProwIsLocal(rows[i]) )
continue;
/* get the row's data */
constant = SCIProwGetConstant(rows[i]);
lhs = SCIProwGetLhs(rows[i]) - constant;
rhs = SCIProwGetRhs(rows[i]) - constant;
vals = SCIProwGetVals(rows[i]);
nnonz = SCIProwGetNNonz(rows[i]);
cols = SCIProwGetCols(rows[i]);
assert( lhs <= rhs );
/* allocate memory array to be filled with the corresponding subproblem variables */
SCIP_CALL( SCIPallocBufferArray(scip, &consvars, nnonz) );
for( j = 0; j < nnonz; j++ )
consvars[j] = subvars[SCIPvarGetProbindex(SCIPcolGetVar(cols[j]))];
/* create a new linear constraint and add it to the subproblem */
SCIP_CALL( SCIPcreateConsLinear(subscip, &cons, SCIProwGetName(rows[i]), nnonz, consvars, vals, lhs, rhs,
TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, TRUE, FALSE) );
SCIP_CALL( SCIPaddCons(subscip, cons) );
SCIP_CALL( SCIPreleaseCons(subscip, &cons) );
/* free temporary memory */
SCIPfreeBufferArray(scip, &consvars);
}
}
SCIPfreeBufferArray(scip, &marked);
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;
}
/** creates the objective value inequality and the objective value variable, if not yet existing */
static
SCIP_RETCODE createObjRow(
SCIP* scip, /**< SCIP data structure */
SCIP_SEPA* sepa, /**< separator */
SCIP_SEPADATA* sepadata /**< separator data */
)
{
assert(sepadata != NULL);
if( sepadata->objrow == NULL )
{
SCIP_VAR** vars;
SCIP_Real obj;
SCIP_Real intobjval;
int nvars;
int v;
SCIP_Bool attendobjvarbound;
attendobjvarbound = FALSE;
/* create and add objective value variable */
if( sepadata->objvar == NULL )
{
SCIP_CALL( SCIPcreateVar(scip, &sepadata->objvar, "objvar", -SCIPinfinity(scip), SCIPinfinity(scip), 0.0,
SCIP_VARTYPE_IMPLINT, FALSE, TRUE, NULL, NULL, NULL, NULL, NULL) );
SCIP_CALL( SCIPaddVar(scip, sepadata->objvar) );
SCIP_CALL( SCIPaddVarLocks(scip, sepadata->objvar, +1, +1) );
}
else
attendobjvarbound = TRUE;
/* get problem variables */
vars = SCIPgetOrigVars(scip);
nvars = SCIPgetNOrigVars(scip);
/* create objective value inequality */
if( SCIPgetObjsense(scip) == SCIP_OBJSENSE_MINIMIZE )
{
if( attendobjvarbound )
intobjval = SCIPceil(scip, SCIPgetDualbound(scip)) - SCIPvarGetLbGlobal(sepadata->objvar);
else
intobjval = SCIPceil(scip, SCIPgetDualbound(scip));
SCIP_CALL( SCIPcreateEmptyRowSepa(scip, &sepadata->objrow, sepa, "objrow", intobjval, SCIPinfinity(scip),
FALSE, !SCIPallVarsInProb(scip), TRUE) );
sepadata->setoff = intobjval;
}
else
{
if( attendobjvarbound )
intobjval = SCIPceil(scip, SCIPgetDualbound(scip)) - SCIPvarGetUbGlobal(sepadata->objvar);
else
intobjval = SCIPfloor(scip, SCIPgetDualbound(scip));
SCIP_CALL( SCIPcreateEmptyRowSepa(scip, &sepadata->objrow, sepa, "objrow", -SCIPinfinity(scip), intobjval,
FALSE, !SCIPallVarsInProb(scip), TRUE) );
sepadata->setoff = intobjval;
}
SCIP_CALL( SCIPcacheRowExtensions(scip, sepadata->objrow) );
for( v = 0; v < nvars; ++v )
{
obj = SCIPvarGetObj(vars[v]);
if( !SCIPisZero(scip, obj) )
{
SCIP_CALL( SCIPaddVarToRow(scip, sepadata->objrow, vars[v], obj) );
}
}
SCIP_CALL( SCIPaddVarToRow(scip, sepadata->objrow, sepadata->objvar, -1.0) );
SCIP_CALL( SCIPflushRowExtensions(scip, sepadata->objrow) );
SCIPdebugMessage("created objective value row: ");
SCIPdebug( SCIP_CALL( SCIPprintRow(scip, sepadata->objrow, NULL) ) );
}
return SCIP_OKAY;
}
/** searches and adds integral objective cuts that separate the given primal solution */
static
SCIP_RETCODE separateCuts(
SCIP* scip, /**< SCIP data structure */
SCIP_SEPA* sepa, /**< the intobj separator */
SCIP_SOL* sol, /**< the solution that should be separated, or NULL for LP solution */
SCIP_RESULT* result /**< pointer to store the result */
)
{
SCIP_SEPADATA* sepadata;
SCIP_Real objval;
SCIP_Real intbound;
SCIP_Bool infeasible;
SCIP_Bool tightened;
assert(result != NULL);
assert(*result == SCIP_DIDNOTRUN);
/* if the objective value may be fractional, we cannot do anything */
if( !SCIPisObjIntegral(scip) )
return SCIP_OKAY;
*result = SCIP_DIDNOTFIND;
/* if the current objective value is integral, there is no integral objective value cut */
if( sol == NULL )
objval = SCIPretransformObj(scip, SCIPgetLPObjval(scip));
else
objval = SCIPgetSolOrigObj(scip, sol);
if( SCIPisFeasIntegral(scip, objval) )
return SCIP_OKAY;
sepadata = SCIPsepaGetData(sepa);
assert(sepadata != NULL);
/* the objective value is fractional: create the objective value inequality, if not yet existing */
SCIP_CALL( createObjRow(scip, sepa, sepadata) );
/* adjust the bounds of the objective value variable */
if( SCIPgetObjsense(scip) == SCIP_OBJSENSE_MINIMIZE )
{
intbound = SCIPceil(scip, objval) - sepadata->setoff;
SCIP_CALL( SCIPtightenVarLb(scip, sepadata->objvar, intbound, FALSE, &infeasible, &tightened) );
SCIPdebugMessage("new objective variable lower bound: <%s>[%g,%g]\n",
SCIPvarGetName(sepadata->objvar), SCIPvarGetLbLocal(sepadata->objvar), SCIPvarGetUbLocal(sepadata->objvar));
}
else
{
intbound = SCIPfloor(scip, objval) - sepadata->setoff;
SCIP_CALL( SCIPtightenVarUb(scip, sepadata->objvar, intbound, FALSE, &infeasible, &tightened) );
SCIPdebugMessage("new objective variable upper bound: <%s>[%g,%g]\n",
SCIPvarGetName(sepadata->objvar), SCIPvarGetLbLocal(sepadata->objvar), SCIPvarGetUbLocal(sepadata->objvar));
}
/* add the objective value inequality as a cut to the LP */
if( infeasible )
*result = SCIP_CUTOFF;
else
{
if( !SCIProwIsInLP(sepadata->objrow) )
{
SCIP_CALL( SCIPaddCut(scip, sol, sepadata->objrow, FALSE, &infeasible) );
}
if ( infeasible )
*result = SCIP_CUTOFF;
else if ( tightened )
*result = SCIP_REDUCEDDOM;
else
*result = SCIP_SEPARATED;
}
return SCIP_OKAY;
}
/** execution method of presolver */
static
SCIP_DECL_PRESOLEXEC(presolExecDualfix)
{ /*lint --e{715}*/
SCIP_VAR** vars;
SCIP_Real bound;
SCIP_Real roundbound;
SCIP_Real obj;
SCIP_Bool infeasible;
SCIP_Bool fixed;
int nvars;
int v;
assert(presol != NULL);
assert(strcmp(SCIPpresolGetName(presol), PRESOL_NAME) == 0);
assert(result != NULL);
*result = SCIP_DIDNOTFIND;
/* get active problem variables */
vars = SCIPgetVars(scip);
nvars = SCIPgetNVars(scip);
/* look for fixable variables
* loop backwards, since a variable fixing can change the current and the subsequent slots in the vars array
*/
for( v = nvars - 1; v >= 0; --v )
{
/* don't perform dual presolving operations on deleted variables */
if( SCIPvarIsDeleted(vars[v]) )
continue;
obj = SCIPvarGetObj(vars[v]);
/* if the objective coefficient of the variable is 0 and it may be rounded both
* up and down, then fix it to the closest feasible value to 0 */
if( SCIPisZero(scip, obj) && SCIPvarMayRoundDown(vars[v]) && SCIPvarMayRoundUp(vars[v]) )
{
bound = SCIPvarGetLbGlobal(vars[v]);
if( SCIPisLT(scip, bound, 0.0) )
{
if( SCIPisLE(scip, 0.0, SCIPvarGetUbGlobal(vars[v])) )
bound = 0.0;
else
{
/* try to take an integer value, only for polishing */
roundbound = SCIPfloor(scip, SCIPvarGetUbGlobal(vars[v]));
if( roundbound < bound )
bound = SCIPvarGetUbGlobal(vars[v]);
else
bound = roundbound;
}
}
else
{
/* try to take an integer value, only for polishing */
roundbound = SCIPceil(scip, bound);
if( roundbound < SCIPvarGetUbGlobal(vars[v]) )
bound = roundbound;
}
SCIPdebugMessage("variable <%s> with objective 0 fixed to %g\n",
SCIPvarGetName(vars[v]), bound);
}
else
{
/* if it is always possible to round variable in direction of objective value,
* fix it to its proper bound
*/
if( SCIPvarMayRoundDown(vars[v]) && !SCIPisNegative(scip, obj) )
{
bound = SCIPvarGetLbGlobal(vars[v]);
if( SCIPisZero(scip, obj) && SCIPvarGetNLocksUp(vars[v]) == 1 && SCIPisInfinity(scip, -bound) )
{
/* variable can be set to -infinity, and it is only contained in one constraint:
* we hope that the corresponding constraint handler is clever enough to set/aggregate the variable
* to something more useful than -infinity and do nothing here
*/
continue;
}
SCIPdebugMessage("variable <%s> with objective %g and %d uplocks fixed to lower bound %g\n",
SCIPvarGetName(vars[v]), SCIPvarGetObj(vars[v]), SCIPvarGetNLocksUp(vars[v]), bound);
}
else if( SCIPvarMayRoundUp(vars[v]) && !SCIPisPositive(scip, obj) )
{
bound = SCIPvarGetUbGlobal(vars[v]);
if( SCIPisZero(scip, obj) && SCIPvarGetNLocksDown(vars[v]) == 1 && SCIPisInfinity(scip, bound) )
{
/* variable can be set to +infinity, and it is only contained in one constraint:
* we hope that the corresponding constraint handler is clever enough to set/aggregate the variable
* to something more useful than +infinity and do nothing here
*/
continue;
}
SCIPdebugMessage("variable <%s> with objective %g and %d downlocks fixed to upper bound %g\n",
SCIPvarGetName(vars[v]), SCIPvarGetObj(vars[v]), SCIPvarGetNLocksDown(vars[v]), bound);
}
else
continue;
}
/* apply the fixing */
if( SCIPisInfinity(scip, REALABS(bound)) && !SCIPisZero(scip, obj) )
{
SCIPdebugMessage(" -> unbounded fixing\n");
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL,
"problem infeasible or unbounded: variable <%s> with objective %.15g can be made infinitely %s\n",
SCIPvarGetName(vars[v]), SCIPvarGetObj(vars[v]), bound < 0.0 ? "small" : "large");
*result = SCIP_UNBOUNDED;
return SCIP_OKAY;
}
SCIP_CALL( SCIPfixVar(scip, vars[v], bound, &infeasible, &fixed) );
if( infeasible )
{
SCIPdebugMessage(" -> infeasible fixing\n");
*result = SCIP_CUTOFF;
return SCIP_OKAY;
}
assert(fixed);
(*nfixedvars)++;
*result = SCIP_SUCCESS;
}
return SCIP_OKAY;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecTrivial)
{ /*lint --e{715}*/
SCIP_VAR** vars;
SCIP_SOL* lbsol; /* solution where all variables are set to their lower bounds */
SCIP_SOL* ubsol; /* solution where all variables are set to their upper bounds */
SCIP_SOL* zerosol; /* solution where all variables are set to zero */
SCIP_SOL* locksol; /* solution where all variables are set to the bound with the fewer locks */
SCIP_Real large;
int nvars;
int nbinvars;
int i;
SCIP_Bool success;
SCIP_Bool zerovalid;
*result = SCIP_DIDNOTRUN;
if( SCIPgetNRuns(scip) > 1 )
return SCIP_OKAY;
*result = SCIP_DIDNOTFIND;
success = FALSE;
/* initialize data structure */
SCIP_CALL( SCIPcreateSol(scip, &lbsol, heur) );
SCIP_CALL( SCIPcreateSol(scip, &ubsol, heur) );
SCIP_CALL( SCIPcreateSol(scip, &zerosol, heur) );
SCIP_CALL( SCIPcreateSol(scip, &locksol, heur) );
/* determine large value to set variables to */
large = SCIPinfinity(scip);
if( !SCIPisInfinity(scip, 0.1 / SCIPfeastol(scip)) )
large = 0.1 / SCIPfeastol(scip);
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, &nbinvars, NULL, NULL, NULL) );
/* if the problem is binary, we do not have to check the zero solution, since it is equal to the lower bound
* solution */
zerovalid = (nvars != nbinvars);
assert(vars != NULL || nvars == 0);
for( i = 0; i < nvars; i++ )
{
SCIP_Real lb;
SCIP_Real ub;
assert(vars != NULL); /* this assert is needed for flexelint */
lb = SCIPvarGetLbLocal(vars[i]);
ub = SCIPvarGetUbLocal(vars[i]);
/* if problem is obviously infeasible due to empty domain, stop */
if( SCIPisGT(scip, lb, ub) )
goto TERMINATE;
/* set bounds to sufficient large value */
if( SCIPisInfinity(scip, -lb) )
lb = MIN(-large, ub);
if( SCIPisInfinity(scip, ub) )
{
SCIP_Real tmp;
tmp = SCIPvarGetLbLocal(vars[i]);
ub = MAX(tmp, large);
}
SCIP_CALL( SCIPsetSolVal(scip, lbsol, vars[i], lb) );
SCIP_CALL( SCIPsetSolVal(scip, ubsol, vars[i], ub) );
/* try the zero vector, if it is in the bounds region */
if( zerovalid )
{
if( SCIPisLE(scip, lb, 0.0) && SCIPisLE(scip, 0.0, ub) )
{
SCIP_CALL( SCIPsetSolVal(scip, zerosol, vars[i], 0.0) );
}
else
zerovalid = FALSE;
}
/* set variables to the bound with fewer locks, if tie choose an average value */
if( SCIPvarGetNLocksDown(vars[i]) > SCIPvarGetNLocksUp(vars[i]) )
{
SCIP_CALL( SCIPsetSolVal(scip, locksol, vars[i], ub) );
}
else if( SCIPvarGetNLocksDown(vars[i]) < SCIPvarGetNLocksUp(vars[i]) )
{
SCIP_CALL( SCIPsetSolVal(scip, locksol, vars[i], lb) );
}
else
{
SCIP_Real solval;
solval = (lb+ub)/2.0;
/* if a tie occurs, roughly every third integer variable will be rounded up */
if( SCIPvarGetType(vars[i]) != SCIP_VARTYPE_CONTINUOUS )
solval = i % 3 == 0 ? SCIPceil(scip,solval) : SCIPfloor(scip,solval);
assert(SCIPisFeasLE(scip,SCIPvarGetLbLocal(vars[i]),solval) && SCIPisFeasLE(scip,solval,SCIPvarGetUbLocal(vars[i])));
SCIP_CALL( SCIPsetSolVal(scip, locksol, vars[i], solval) );
}
}
/* try lower bound solution */
SCIPdebugMessage("try lower bound solution\n");
SCIP_CALL( SCIPtrySol(scip, lbsol, FALSE, FALSE, TRUE, TRUE, &success) );
if( success )
{
SCIPdebugMessage("found feasible lower bound solution:\n");
SCIPdebug( SCIP_CALL( SCIPprintSol(scip, lbsol, NULL, FALSE) ) );
*result = SCIP_FOUNDSOL;
}
/* try upper bound solution */
SCIPdebugMessage("try upper bound solution\n");
SCIP_CALL( SCIPtrySol(scip, ubsol, FALSE, FALSE, TRUE, TRUE, &success) );
if( success )
{
SCIPdebugMessage("found feasible upper bound solution:\n");
SCIPdebug( SCIP_CALL( SCIPprintSol(scip, ubsol, NULL, FALSE) ) );
*result = SCIP_FOUNDSOL;
}
/* try zero solution */
if( zerovalid )
{
SCIPdebugMessage("try zero solution\n");
SCIP_CALL( SCIPtrySol(scip, zerosol, FALSE, FALSE, TRUE, TRUE, &success) );
if( success )
{
SCIPdebugMessage("found feasible zero solution:\n");
SCIPdebug( SCIP_CALL( SCIPprintSol(scip, zerosol, NULL, FALSE) ) );
*result = SCIP_FOUNDSOL;
}
}
/* try lock solution */
SCIPdebugMessage("try lock solution\n");
SCIP_CALL( SCIPtrySol(scip, locksol, FALSE, FALSE, TRUE, TRUE, &success) );
if( success )
{
SCIPdebugMessage("found feasible lock solution:\n");
SCIPdebug( SCIP_CALL( SCIPprintSol(scip, locksol, NULL, FALSE) ) );
*result = SCIP_FOUNDSOL;
}
TERMINATE:
/* free solutions */
SCIP_CALL( SCIPfreeSol(scip, &lbsol) );
SCIP_CALL( SCIPfreeSol(scip, &ubsol) );
SCIP_CALL( SCIPfreeSol(scip, &zerosol) );
SCIP_CALL( SCIPfreeSol(scip, &locksol) );
return SCIP_OKAY;
}
/** creates a subproblem for subscip by fixing a number of variables */
static
SCIP_RETCODE createSubproblem(
SCIP* scip, /**< original SCIP data structure */
SCIP* subscip, /**< SCIP data structure for the subproblem */
SCIP_VAR** subvars, /**< the variables of the subproblem */
SCIP_Real minfixingrate, /**< percentage of integer variables that have to be fixed */
SCIP_Bool binarybounds, /**< should general integers get binary bounds [floor(.),ceil(.)] ? */
SCIP_Bool uselprows, /**< should subproblem be created out of the rows in the LP rows? */
SCIP_Bool* success /**< pointer to store whether the problem was created successfully */
)
{
SCIP_VAR** vars; /* original SCIP variables */
SCIP_Real fixingrate;
int nvars;
int nbinvars;
int nintvars;
int i;
int fixingcounter;
assert(scip != NULL);
assert(subscip != NULL);
assert(subvars != NULL);
assert(0.0 <= minfixingrate && minfixingrate <= 1.0);
/* get required variable data */
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, &nbinvars, &nintvars, NULL, NULL) );
fixingcounter = 0;
/* change bounds of variables of the subproblem */
for( i = 0; i < nbinvars + nintvars; i++ )
{
SCIP_Real lpsolval;
SCIP_Real lb;
SCIP_Real ub;
/* get the current LP solution for each variable */
lpsolval = SCIPgetRelaxSolVal(scip, vars[i]);
if( SCIPisFeasIntegral(scip, lpsolval) )
{
/* fix variables to current LP solution if it is integral,
* use exact integral value, if the variable is only integral within numerical tolerances
*/
lb = SCIPfloor(scip, lpsolval+0.5);
ub = lb;
fixingcounter++;
}
else if( binarybounds )
{
/* if the sub problem should be a binary problem, change the bounds to nearest integers */
lb = SCIPfeasFloor(scip,lpsolval);
ub = SCIPfeasCeil(scip,lpsolval);
}
else
{
/* otherwise just copy bounds */
lb = SCIPvarGetLbGlobal(vars[i]);
ub = SCIPvarGetUbGlobal(vars[i]);
}
/* perform the bound change */
SCIP_CALL( SCIPchgVarLbGlobal(subscip, subvars[i], lb) );
SCIP_CALL( SCIPchgVarUbGlobal(subscip, subvars[i], ub) );
}
/* abort, if all integer variables were fixed (which should not happen for MIP) */
if( fixingcounter == nbinvars + nintvars )
{
*success = FALSE;
return SCIP_OKAY;
}
else
fixingrate = fixingcounter / (SCIP_Real)(MAX(nbinvars + nintvars, 1));
SCIPdebugMessage("fixing rate: %g = %d of %d\n", fixingrate, fixingcounter, nbinvars + nintvars);
/* abort, if the amount of fixed variables is insufficient */
if( fixingrate < minfixingrate )
{
*success = FALSE;
return SCIP_OKAY;
}
if( uselprows )
{
SCIP_ROW** rows; /* original scip rows */
int nrows;
/* get the rows and their number */
SCIP_CALL( SCIPgetLPRowsData(scip, &rows, &nrows) );
/* copy all rows to linear constraints */
for( i = 0; i < nrows; i++ )
{
SCIP_CONS* cons;
SCIP_VAR** consvars;
SCIP_COL** cols;
SCIP_Real constant;
SCIP_Real lhs;
SCIP_Real rhs;
SCIP_Real* vals;
int nnonz;
int j;
/* ignore rows that are only locally valid */
if( SCIProwIsLocal(rows[i]) )
continue;
/* get the row's data */
constant = SCIProwGetConstant(rows[i]);
lhs = SCIProwGetLhs(rows[i]) - constant;
rhs = SCIProwGetRhs(rows[i]) - constant;
vals = SCIProwGetVals(rows[i]);
nnonz = SCIProwGetNNonz(rows[i]);
cols = SCIProwGetCols(rows[i]);
assert( lhs <= rhs );
/* allocate memory array to be filled with the corresponding subproblem variables */
SCIP_CALL( SCIPallocBufferArray(subscip, &consvars, nnonz) );
for( j = 0; j < nnonz; j++ )
consvars[j] = subvars[SCIPvarGetProbindex(SCIPcolGetVar(cols[j]))];
/* create a new linear constraint and add it to the subproblem */
SCIP_CALL( SCIPcreateConsLinear(subscip, &cons, SCIProwGetName(rows[i]), nnonz, consvars, vals, lhs, rhs,
TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, TRUE, FALSE) );
SCIP_CALL( SCIPaddCons(subscip, cons) );
SCIP_CALL( SCIPreleaseCons(subscip, &cons) );
/* free temporary memory */
SCIPfreeBufferArray(subscip, &consvars);
}
}
*success = TRUE;
return SCIP_OKAY;
}
/** computes a disjunctive cut inequality based on two simplex taubleau rows */
static
SCIP_RETCODE generateDisjCutSOS1(
SCIP* scip, /**< SCIP pointer */
SCIP_SEPA* sepa, /**< separator */
SCIP_ROW** rows, /**< LP rows */
int nrows, /**< number of LP rows */
SCIP_COL** cols, /**< LP columns */
int ncols, /**< number of LP columns */
int ndisjcuts, /**< number of disjunctive cuts found so far */
SCIP_Bool scale, /**< should cut be scaled */
SCIP_Bool strengthen, /**< should cut be strengthened if integer variables are present */
SCIP_Real cutlhs1, /**< left hand side of the first simplex row */
SCIP_Real cutlhs2, /**< left hand side of the second simplex row */
SCIP_Real bound1, /**< bound of first simplex row */
SCIP_Real bound2, /**< bound of second simplex row */
SCIP_Real* simplexcoefs1, /**< simplex coefficients of first row */
SCIP_Real* simplexcoefs2, /**< simplex coefficients of second row */
SCIP_Real* cutcoefs, /**< pointer to store cut coefficients (length: nscipvars) */
SCIP_ROW** row, /**< pointer to store disjunctive cut inequality */
SCIP_Bool* madeintegral /**< pointer to store whether cut has been scaled to integral values */
)
{
char cutname[SCIP_MAXSTRLEN];
SCIP_COL** rowcols;
SCIP_COL* col;
SCIP_Real* rowvals;
SCIP_Real lhsrow;
SCIP_Real rhsrow;
SCIP_Real cutlhs;
SCIP_Real sgn;
SCIP_Real lb;
SCIP_Real ub;
int nonbasicnumber = 0;
int rownnonz;
int ind;
int r;
int c;
assert( scip != NULL );
assert( row != NULL );
assert( rows != NULL );
assert( cols != NULL );
assert( simplexcoefs1 != NULL );
assert( simplexcoefs2 != NULL );
assert( cutcoefs != NULL );
assert( sepa != NULL );
assert( madeintegral != NULL );
*madeintegral = FALSE;
/* check signs */
if ( SCIPisFeasPositive(scip, cutlhs1) == SCIPisFeasPositive(scip, cutlhs2) )
sgn = 1.0;
else
sgn = -1.0;
/* check bounds */
if ( SCIPisInfinity(scip, REALABS(bound1)) || SCIPisInfinity(scip, REALABS(bound2)) )
strengthen = FALSE;
/* compute left hand side of row (a later update is possible, see below) */
cutlhs = sgn * cutlhs1 * cutlhs2;
/* add cut-coefficients of the non-basic non-slack variables */
for (c = 0; c < ncols; ++c)
{
col = cols[c];
assert( col != NULL );
ind = SCIPcolGetLPPos(col);
assert( ind >= 0 );
if ( SCIPcolGetBasisStatus(col) == SCIP_BASESTAT_LOWER )
{
lb = SCIPcolGetLb(col);
/* for integer variables we may obtain stronger coefficients */
if ( strengthen && SCIPcolIsIntegral(col) )
{
SCIP_Real mval;
SCIP_Real mvalfloor;
SCIP_Real mvalceil;
mval = (cutlhs2 * simplexcoefs1[nonbasicnumber] - cutlhs1 * simplexcoefs2[nonbasicnumber]) / (cutlhs2 * bound1 + cutlhs1 * bound2);
mvalfloor = SCIPfloor(scip, mval);
mvalceil = SCIPceil(scip, mval);
cutcoefs[ind] = MIN(sgn * cutlhs2 * (simplexcoefs1[nonbasicnumber] - mvalfloor * bound1), sgn * cutlhs1 * (simplexcoefs2[nonbasicnumber] + mvalceil * bound2));
assert( SCIPisFeasLE(scip, cutcoefs[ind], MAX(sgn * cutlhs2 * simplexcoefs1[nonbasicnumber], sgn * cutlhs1 * simplexcoefs2[nonbasicnumber])) );
}
else
cutcoefs[ind] = MAX(sgn * cutlhs2 * simplexcoefs1[nonbasicnumber], sgn * cutlhs1 * simplexcoefs2[nonbasicnumber]);
cutlhs += cutcoefs[ind] * lb;
++nonbasicnumber;
}
else if ( SCIPcolGetBasisStatus(col) == SCIP_BASESTAT_UPPER )
{
ub = SCIPcolGetUb(col);
/* for integer variables we may obtain stronger coefficients */
if ( strengthen && SCIPcolIsIntegral(col) )
{
SCIP_Real mval;
SCIP_Real mvalfloor;
SCIP_Real mvalceil;
mval = (cutlhs2 * simplexcoefs1[nonbasicnumber] - cutlhs1 * simplexcoefs2[nonbasicnumber]) / (cutlhs2 * bound1 + cutlhs1 * bound2);
mvalfloor = SCIPfloor(scip, -mval);
mvalceil = SCIPceil(scip, -mval);
cutcoefs[ind] = MAX(sgn * cutlhs2 * (simplexcoefs1[nonbasicnumber] + mvalfloor * bound1), sgn * cutlhs1 * (simplexcoefs2[nonbasicnumber] - mvalceil * bound2));
assert( SCIPisFeasLE(scip, -cutcoefs[ind], -MIN(sgn * cutlhs2 * simplexcoefs1[nonbasicnumber], sgn * cutlhs1 * simplexcoefs2[nonbasicnumber])) );
}
else
cutcoefs[ind] = MIN(sgn * cutlhs2 * simplexcoefs1[nonbasicnumber], sgn * cutlhs1 * simplexcoefs2[nonbasicnumber]);
cutlhs += cutcoefs[ind] * ub;
++nonbasicnumber;
}
else
{
assert( SCIPcolGetBasisStatus(col) != SCIP_BASESTAT_ZERO );
cutcoefs[ind] = 0.0;
}
}
/* add cut-coefficients of the non-basic slack variables */
for (r = 0; r < nrows; ++r)
{
rhsrow = SCIProwGetRhs(rows[r]) - SCIProwGetConstant(rows[r]);
lhsrow = SCIProwGetLhs(rows[r]) - SCIProwGetConstant(rows[r]);
assert( SCIProwGetBasisStatus(rows[r]) != SCIP_BASESTAT_ZERO );
assert( SCIPisFeasZero(scip, lhsrow - rhsrow) || SCIPisNegative(scip, lhsrow - rhsrow) );
assert( SCIProwIsInLP(rows[r]) );
if ( SCIProwGetBasisStatus(rows[r]) != SCIP_BASESTAT_BASIC )
{
SCIP_Real cutcoef;
if ( SCIProwGetBasisStatus(rows[r]) == SCIP_BASESTAT_UPPER )
{
assert( SCIPisFeasZero(scip, SCIPgetRowLPActivity(scip, rows[r]) - SCIProwGetRhs(rows[r])) );
cutcoef = MAX(sgn * cutlhs2 * simplexcoefs1[nonbasicnumber], sgn * cutlhs1 * simplexcoefs2[nonbasicnumber]);
cutlhs -= cutcoef * rhsrow;
++nonbasicnumber;
}
else /* SCIProwGetBasisStatus(rows[r]) == SCIP_BASESTAT_LOWER */
{
assert( SCIProwGetBasisStatus(rows[r]) == SCIP_BASESTAT_LOWER );
assert( SCIPisFeasZero(scip, SCIPgetRowLPActivity(scip, rows[r]) - SCIProwGetLhs(rows[r])) );
cutcoef = MIN(sgn * cutlhs2 * simplexcoefs1[nonbasicnumber], sgn * cutlhs1 * simplexcoefs2[nonbasicnumber]);
cutlhs -= cutcoef * lhsrow;
++nonbasicnumber;
}
rownnonz = SCIProwGetNNonz(rows[r]);
rowvals = SCIProwGetVals(rows[r]);
rowcols = SCIProwGetCols(rows[r]);
for (c = 0; c < rownnonz; ++c)
{
ind = SCIPcolGetLPPos(rowcols[c]);
/* if column is not in LP, then return without generating cut */
if ( ind < 0 )
{
*row = NULL;
return SCIP_OKAY;
}
cutcoefs[ind] -= cutcoef * rowvals[c];
}
}
}
/* create cut */
(void) SCIPsnprintf(cutname, SCIP_MAXSTRLEN, "%s_%d_%d", SCIPsepaGetName(sepa), SCIPgetNLPs(scip), ndisjcuts);
if ( SCIPgetDepth(scip) == 0 )
SCIP_CALL( SCIPcreateEmptyRowSepa(scip, row, sepa, cutname, cutlhs, SCIPinfinity(scip), FALSE, FALSE, TRUE) );
else
SCIP_CALL( SCIPcreateEmptyRowSepa(scip, row, sepa, cutname, cutlhs, SCIPinfinity(scip), TRUE, FALSE, TRUE) );
SCIP_CALL( SCIPcacheRowExtensions(scip, *row) );
for (c = 0; c < ncols; ++c)
{
ind = SCIPcolGetLPPos(cols[c]);
assert( ind >= 0 );
if ( ! SCIPisFeasZero(scip, cutcoefs[ind]) )
{
SCIP_CALL( SCIPaddVarToRow(scip, *row, SCIPcolGetVar(cols[c]), cutcoefs[ind] ) );
}
}
SCIP_CALL( SCIPflushRowExtensions(scip, *row) );
/* try to scale the cut to integral values
* @todo find better but still stable disjunctive cut settings
*/
if ( scale )
{
int maxdepth;
int depth;
SCIP_Longint maxdnom;
SCIP_Real maxscale;
depth = SCIPgetDepth(scip);
assert( depth >= 0 );
maxdepth = SCIPgetMaxDepth(scip);
if ( depth == 0 )
{
maxdnom = 1000;
maxscale = 1000.0;
}
else if ( depth <= maxdepth/4 )
{
maxdnom = 1000;
maxscale = 1000.0;
}
else if ( depth <= maxdepth/2 )
{
maxdnom = 100;
maxscale = 100.0;
}
else
{
maxdnom = 10;
maxscale = 10.0;
}
SCIP_CALL( SCIPmakeRowIntegral(scip, *row, -SCIPepsilon(scip), SCIPsumepsilon(scip), maxdnom, maxscale, TRUE, madeintegral) );
}
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;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecRootsoldiving) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_VAR** vars;
SCIP_Real* rootsol;
SCIP_Real* objchgvals;
int* softroundings;
int* intvalrounds;
int nvars;
int nbinvars;
int nintvars;
int nlpcands;
SCIP_LPSOLSTAT lpsolstat;
SCIP_Real absstartobjval;
SCIP_Real objstep;
SCIP_Real alpha;
SCIP_Real oldobj;
SCIP_Real newobj;
SCIP_Bool lperror;
SCIP_Bool lpsolchanged;
SCIP_Longint nsolsfound;
SCIP_Longint ncalls;
SCIP_Longint nlpiterations;
SCIP_Longint maxnlpiterations;
int depth;
int maxdepth;
int maxdivedepth;
int divedepth;
int startnlpcands;
int ncycles;
int i;
assert(heur != NULL);
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
assert(scip != NULL);
assert(result != NULL);
assert(SCIPhasCurrentNodeLP(scip));
*result = SCIP_DELAYED;
/* only call heuristic, if an optimal LP solution is at hand */
if( SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
return SCIP_OKAY;
/* only call heuristic, if the LP solution is basic (which allows fast resolve in diving) */
if( !SCIPisLPSolBasic(scip) )
return SCIP_OKAY;
/* don't dive two times at the same node */
if( SCIPgetLastDivenode(scip) == SCIPgetNNodes(scip) && SCIPgetDepth(scip) > 0 )
return SCIP_OKAY;
*result = SCIP_DIDNOTRUN;
/* get heuristic's data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* only apply heuristic, if only a few solutions have been found */
if( heurdata->maxsols >= 0 && SCIPgetNSolsFound(scip) >= heurdata->maxsols )
return SCIP_OKAY;
/* only try to dive, if we are in the correct part of the tree, given by minreldepth and maxreldepth */
depth = SCIPgetDepth(scip);
maxdepth = SCIPgetMaxDepth(scip);
maxdepth = MAX(maxdepth, 30);
if( depth < heurdata->minreldepth*maxdepth || depth > heurdata->maxreldepth*maxdepth )
return SCIP_OKAY;
/* calculate the maximal number of LP iterations until heuristic is aborted */
nlpiterations = SCIPgetNNodeLPIterations(scip);
ncalls = SCIPheurGetNCalls(heur);
nsolsfound = 10*SCIPheurGetNBestSolsFound(heur) + heurdata->nsuccess;
maxnlpiterations = (SCIP_Longint)((1.0 + 10.0*(nsolsfound+1.0)/(ncalls+1.0)) * heurdata->maxlpiterquot * nlpiterations);
maxnlpiterations += heurdata->maxlpiterofs;
/* don't try to dive, if we took too many LP iterations during diving */
if( heurdata->nlpiterations >= maxnlpiterations )
return SCIP_OKAY;
/* allow at least a certain number of LP iterations in this dive */
maxnlpiterations = MAX(maxnlpiterations, heurdata->nlpiterations + MINLPITER);
/* get number of fractional variables, that should be integral */
nlpcands = SCIPgetNLPBranchCands(scip);
/* don't try to dive, if there are no fractional variables */
if( nlpcands == 0 )
return SCIP_OKAY;
/* calculate the maximal diving depth */
nvars = SCIPgetNBinVars(scip) + SCIPgetNIntVars(scip);
if( SCIPgetNSolsFound(scip) == 0 )
maxdivedepth = (int)(heurdata->depthfacnosol * nvars);
else
maxdivedepth = (int)(heurdata->depthfac * nvars);
maxdivedepth = MAX(maxdivedepth, 10);
*result = SCIP_DIDNOTFIND;
/* get all variables of LP */
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, &nbinvars, &nintvars, NULL, NULL) );
/* get root solution value of all binary and integer variables */
SCIP_CALL( SCIPallocBufferArray(scip, &rootsol, nbinvars + nintvars) );
for( i = 0; i < nbinvars + nintvars; i++ )
rootsol[i] = SCIPvarGetRootSol(vars[i]);
/* get current LP objective value, and calculate length of a single step in an objective coefficient */
absstartobjval = SCIPgetLPObjval(scip);
absstartobjval = ABS(absstartobjval);
absstartobjval = MAX(absstartobjval, 1.0);
objstep = absstartobjval / 10.0;
/* initialize array storing the preferred soft rounding directions and counting the integral value rounds */
SCIP_CALL( SCIPallocBufferArray(scip, &softroundings, nbinvars + nintvars) );
BMSclearMemoryArray(softroundings, nbinvars + nintvars);
SCIP_CALL( SCIPallocBufferArray(scip, &intvalrounds, nbinvars + nintvars) );
BMSclearMemoryArray(intvalrounds, nbinvars + nintvars);
/* allocate temporary memory for buffering objective changes */
SCIP_CALL( SCIPallocBufferArray(scip, &objchgvals, nbinvars + nintvars) );
/* start diving */
SCIP_CALL( SCIPstartDive(scip) );
SCIPdebugMessage("(node %"SCIP_LONGINT_FORMAT") executing rootsoldiving heuristic: depth=%d, %d fractionals, dualbound=%g, maxnlpiterations=%"SCIP_LONGINT_FORMAT", maxdivedepth=%d, LPobj=%g, objstep=%g\n",
SCIPgetNNodes(scip), SCIPgetDepth(scip), nlpcands, SCIPgetDualbound(scip), maxnlpiterations, maxdivedepth,
SCIPgetLPObjval(scip), objstep);
lperror = FALSE;
divedepth = 0;
lpsolstat = SCIP_LPSOLSTAT_OPTIMAL;
alpha = heurdata->alpha;
ncycles = 0;
lpsolchanged = TRUE;
startnlpcands = nlpcands;
while( !lperror && lpsolstat == SCIP_LPSOLSTAT_OPTIMAL && nlpcands > 0 && ncycles < 10
&& (divedepth < 10
|| nlpcands <= startnlpcands - divedepth/2
|| (divedepth < maxdivedepth && heurdata->nlpiterations < maxnlpiterations))
&& !SCIPisStopped(scip) )
{
SCIP_Bool success;
int hardroundingidx;
int hardroundingdir;
SCIP_Real hardroundingoldbd;
SCIP_Real hardroundingnewbd;
SCIP_Bool boundschanged;
SCIP_RETCODE retcode;
/* create solution from diving LP and try to round it */
SCIP_CALL( SCIPlinkLPSol(scip, heurdata->sol) );
SCIP_CALL( SCIProundSol(scip, heurdata->sol, &success) );
if( success )
{
SCIPdebugMessage("rootsoldiving found roundable primal solution: obj=%g\n", SCIPgetSolOrigObj(scip, heurdata->sol));
/* try to add solution to SCIP */
SCIP_CALL( SCIPtrySol(scip, heurdata->sol, FALSE, FALSE, FALSE, FALSE, &success) );
/* check, if solution was feasible and good enough */
if( success )
{
SCIPdebugMessage(" -> solution was feasible and good enough\n");
*result = SCIP_FOUNDSOL;
}
}
divedepth++;
hardroundingidx = -1;
hardroundingdir = 0;
hardroundingoldbd = 0.0;
hardroundingnewbd = 0.0;
boundschanged = FALSE;
SCIPdebugMessage("dive %d/%d, LP iter %"SCIP_LONGINT_FORMAT"/%"SCIP_LONGINT_FORMAT":\n", divedepth, maxdivedepth, heurdata->nlpiterations, maxnlpiterations);
/* round solution x* from diving LP:
* - x~_j = down(x*_j) if x*_j is integer or binary variable and x*_j <= root solution_j
* - x~_j = up(x*_j) if x*_j is integer or binary variable and x*_j > root solution_j
* - x~_j = x*_j if x*_j is continuous variable
* change objective function in diving LP:
* - if x*_j is integral, or j is a continuous variable, set obj'_j = alpha * obj_j
* - otherwise, set obj'_j = alpha * obj_j + sign(x*_j - x~_j)
*/
for( i = 0; i < nbinvars + nintvars; i++ )
{
SCIP_VAR* var;
SCIP_Real solval;
var = vars[i];
oldobj = SCIPgetVarObjDive(scip, var);
newobj = oldobj;
solval = SCIPvarGetLPSol(var);
if( SCIPisFeasIntegral(scip, solval) )
{
/* if the variable became integral after a soft rounding, count the rounds; after a while, fix it to its
* current integral value;
* otherwise, fade out the objective value
*/
if( softroundings[i] != 0 && lpsolchanged )
{
intvalrounds[i]++;
if( intvalrounds[i] == 5 && SCIPgetVarLbDive(scip, var) < SCIPgetVarUbDive(scip, var) - 0.5 )
{
/* use exact integral value, if the variable is only integral within numerical tolerances */
solval = SCIPfloor(scip, solval+0.5);
SCIPdebugMessage(" -> fixing <%s> = %g\n", SCIPvarGetName(var), solval);
SCIP_CALL( SCIPchgVarLbDive(scip, var, solval) );
SCIP_CALL( SCIPchgVarUbDive(scip, var, solval) );
boundschanged = TRUE;
}
}
else
newobj = alpha * oldobj;
}
else if( solval <= rootsol[i] )
{
/* if the variable was soft rounded most of the time downwards, round it downwards by changing the bounds;
* otherwise, apply soft rounding by changing the objective value
*/
softroundings[i]--;
if( softroundings[i] <= -10 && hardroundingidx == -1 )
{
SCIPdebugMessage(" -> hard rounding <%s>[%g] <= %g\n",
SCIPvarGetName(var), solval, SCIPfeasFloor(scip, solval));
hardroundingidx = i;
hardroundingdir = -1;
hardroundingoldbd = SCIPgetVarUbDive(scip, var);
hardroundingnewbd = SCIPfeasFloor(scip, solval);
SCIP_CALL( SCIPchgVarUbDive(scip, var, hardroundingnewbd) );
boundschanged = TRUE;
}
else
newobj = alpha * oldobj + objstep;
}
else
{
/* if the variable was soft rounded most of the time upwards, round it upwards by changing the bounds;
* otherwise, apply soft rounding by changing the objective value
*/
softroundings[i]++;
if( softroundings[i] >= +10 && hardroundingidx == -1 )
{
SCIPdebugMessage(" -> hard rounding <%s>[%g] >= %g\n",
SCIPvarGetName(var), solval, SCIPfeasCeil(scip, solval));
hardroundingidx = i;
hardroundingdir = +1;
hardroundingoldbd = SCIPgetVarLbDive(scip, var);
hardroundingnewbd = SCIPfeasCeil(scip, solval);
SCIP_CALL( SCIPchgVarLbDive(scip, var, hardroundingnewbd) );
boundschanged = TRUE;
}
else
newobj = alpha * oldobj - objstep;
}
/* remember the objective change */
objchgvals[i] = newobj;
}
/* apply objective changes if there was no bound change */
if( !boundschanged )
{
/* apply cached changes on integer variables */
for( i = 0; i < nbinvars + nintvars; ++i )
{
SCIP_VAR* var;
var = vars[i];
SCIPdebugMessage(" -> i=%d var <%s>, solval=%g, rootsol=%g, oldobj=%g, newobj=%g\n",
i, SCIPvarGetName(var), SCIPvarGetLPSol(var), rootsol[i], SCIPgetVarObjDive(scip, var), objchgvals[i]);
SCIP_CALL( SCIPchgVarObjDive(scip, var, objchgvals[i]) );
}
/* fade out the objective values of the continuous variables */
for( i = nbinvars + nintvars; i < nvars; i++ )
{
SCIP_VAR* var;
var = vars[i];
oldobj = SCIPgetVarObjDive(scip, var);
newobj = alpha * oldobj;
SCIPdebugMessage(" -> i=%d var <%s>, solval=%g, oldobj=%g, newobj=%g\n",
i, SCIPvarGetName(var), SCIPvarGetLPSol(var), oldobj, newobj);
SCIP_CALL( SCIPchgVarObjDive(scip, var, newobj) );
}
}
SOLVEAGAIN:
/* resolve the diving LP */
nlpiterations = SCIPgetNLPIterations(scip);
retcode = SCIPsolveDiveLP(scip, MAX((int)(maxnlpiterations - heurdata->nlpiterations), MINLPITER), &lperror);
lpsolstat = SCIPgetLPSolstat(scip);
/* Errors in the LP solver should not kill the overall solving process, if the LP is just needed for a heuristic.
* Hence in optimized mode, the return code is caught and a warning is printed, only in debug mode, SCIP will stop.
*/
if( retcode != SCIP_OKAY )
{
#ifndef NDEBUG
if( lpsolstat != SCIP_LPSOLSTAT_UNBOUNDEDRAY )
{
SCIP_CALL( retcode );
}
#endif
SCIPwarningMessage(scip, "Error while solving LP in Rootsoldiving heuristic; LP solve terminated with code <%d>\n", retcode);
SCIPwarningMessage(scip, "This does not affect the remaining solution procedure --> continue\n");
}
if( lperror )
break;
/* update iteration count */
heurdata->nlpiterations += SCIPgetNLPIterations(scip) - nlpiterations;
/* if no LP iterations were performed, we stayed at the same solution -> count this cycling */
lpsolchanged = (SCIPgetNLPIterations(scip) != nlpiterations);
if( lpsolchanged )
ncycles = 0;
else if( !boundschanged ) /* do not count if integral variables have been fixed */
ncycles++;
/* get LP solution status and number of fractional variables, that should be integral */
if( lpsolstat == SCIP_LPSOLSTAT_INFEASIBLE && hardroundingidx != -1 )
{
SCIP_VAR* var;
var = vars[hardroundingidx];
/* round the hard rounded variable to the opposite direction and resolve the LP */
if( hardroundingdir == -1 )
{
SCIPdebugMessage(" -> opposite hard rounding <%s> >= %g\n", SCIPvarGetName(var), hardroundingnewbd + 1.0);
SCIP_CALL( SCIPchgVarUbDive(scip, var, hardroundingoldbd) );
SCIP_CALL( SCIPchgVarLbDive(scip, var, hardroundingnewbd + 1.0) );
}
else
{
SCIPdebugMessage(" -> opposite hard rounding <%s> <= %g\n", SCIPvarGetName(var), hardroundingnewbd - 1.0);
SCIP_CALL( SCIPchgVarLbDive(scip, var, hardroundingoldbd) );
SCIP_CALL( SCIPchgVarUbDive(scip, var, hardroundingnewbd - 1.0) );
}
hardroundingidx = -1;
goto SOLVEAGAIN;
}
if( lpsolstat == SCIP_LPSOLSTAT_OPTIMAL )
nlpcands = SCIPgetNLPBranchCands(scip);
SCIPdebugMessage(" -> lpsolstat=%d, nfrac=%d\n", lpsolstat, nlpcands);
}
SCIPdebugMessage("---> diving finished: lpsolstat = %d, depth %d/%d, LP iter %"SCIP_LONGINT_FORMAT"/%"SCIP_LONGINT_FORMAT"\n",
lpsolstat, divedepth, maxdivedepth, heurdata->nlpiterations, maxnlpiterations);
/* check if a solution has been found */
if( nlpcands == 0 && !lperror && lpsolstat == SCIP_LPSOLSTAT_OPTIMAL )
{
SCIP_Bool success;
/* create solution from diving LP */
SCIP_CALL( SCIPlinkLPSol(scip, heurdata->sol) );
SCIPdebugMessage("rootsoldiving found primal solution: obj=%g\n", SCIPgetSolOrigObj(scip, heurdata->sol));
/* try to add solution to SCIP */
SCIP_CALL( SCIPtrySol(scip, heurdata->sol, FALSE, FALSE, FALSE, FALSE, &success) );
/* check, if solution was feasible and good enough */
if( success )
{
SCIPdebugMessage(" -> solution was feasible and good enough\n");
*result = SCIP_FOUNDSOL;
}
}
/* end diving */
SCIP_CALL( SCIPendDive(scip) );
if( *result == SCIP_FOUNDSOL )
heurdata->nsuccess++;
/* free temporary memory */
SCIPfreeBufferArray(scip, &objchgvals);
SCIPfreeBufferArray(scip, &intvalrounds);
SCIPfreeBufferArray(scip, &softroundings);
SCIPfreeBufferArray(scip, &rootsol);
SCIPdebugMessage("rootsoldiving heuristic finished\n");
return SCIP_OKAY;
}