inline llint my_llint(SCIP* scip, SCIP_Real r)
{
llint rval = SCIPround(scip, r);
assert(SCIPisEQ(scip, rval, r) ||
SCIPisEQ(scip, r, SCIPinfinity(scip)) ||
SCIPisEQ(scip, r, -SCIPinfinity(scip)));
return rval;
}
/** creates the pseudo cost branching rule and includes it in SCIP */
SCIP_RETCODE SCIPincludeBranchrulePscost(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_BRANCHRULEDATA* branchruledata;
SCIP_BRANCHRULE* branchrule;
/* create pscost branching rule data */
SCIP_CALL( SCIPallocMemory(scip, &branchruledata) );
/* include allfullstrong branching rule */
SCIP_CALL( SCIPincludeBranchruleBasic(scip, &branchrule, BRANCHRULE_NAME, BRANCHRULE_DESC, BRANCHRULE_PRIORITY,
BRANCHRULE_MAXDEPTH, BRANCHRULE_MAXBOUNDDIST, branchruledata) );
assert(branchrule != NULL);
/* set non-fundamental callbacks via specific setter functions*/
SCIP_CALL( SCIPsetBranchruleCopy(scip, branchrule, branchCopyPscost) );
SCIP_CALL( SCIPsetBranchruleFree(scip, branchrule, branchFreePscost) );
SCIP_CALL( SCIPsetBranchruleExecLp(scip, branchrule, branchExeclpPscost) );
SCIP_CALL( SCIPsetBranchruleExecExt(scip, branchrule, branchExecextPscost) );
SCIP_CALL( SCIPaddCharParam(scip, "branching/"BRANCHRULE_NAME"/strategy",
"strategy for utilizing pseudo-costs of external branching candidates (multiply as in pseudo costs 'u'pdate rule, or by 'd'omain reduction, or by domain reduction of 's'ibling, or by 'v'ariable score)",
&branchruledata->strategy, FALSE, BRANCHRULE_STRATEGY_DEFAULT, BRANCHRULE_STRATEGIES, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip, "branching/"BRANCHRULE_NAME"/minscoreweight",
"weight for minimum of scores of a branching candidate when building weighted sum of min/max/sum of scores",
&branchruledata->scoreminweight, TRUE, BRANCHRULE_SCOREMINWEIGHT_DEFAULT, -SCIPinfinity(scip), SCIPinfinity(scip), NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip, "branching/"BRANCHRULE_NAME"/maxscoreweight",
"weight for maximum of scores of a branching candidate when building weighted sum of min/max/sum of scores",
&branchruledata->scoremaxweight, TRUE, BRANCHRULE_SCOREMAXWEIGHT_DEFAULT, -SCIPinfinity(scip), SCIPinfinity(scip), NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip, "branching/"BRANCHRULE_NAME"/sumscoreweight",
"weight for sum of scores of a branching candidate when building weighted sum of min/max/sum of scores",
&branchruledata->scoresumweight, TRUE, BRANCHRULE_SCORESUMWEIGHT_DEFAULT, -SCIPinfinity(scip), SCIPinfinity(scip), NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "branching/"BRANCHRULE_NAME"/nchildren",
"number of children to create in n-ary branching",
&branchruledata->nchildren, FALSE, BRANCHRULE_NCHILDREN_DEFAULT, 2, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "branching/"BRANCHRULE_NAME"/narymaxdepth",
"maximal depth where to do n-ary branching, -1 to turn off",
&branchruledata->narymaxdepth, FALSE, BRANCHRULE_NARYMAXDEPTH_DEFAULT, -1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip, "branching/"BRANCHRULE_NAME"/naryminwidth",
"minimal domain width in children when doing n-ary branching, relative to global bounds",
&branchruledata->naryminwidth, FALSE, BRANCHRULE_NARYMINWIDTH_DEFAULT, 0.0, 1.0, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip, "branching/"BRANCHRULE_NAME"/narywidthfactor",
"factor of domain width in n-ary branching when creating nodes with increasing distance from branching value",
&branchruledata->narywidthfactor, FALSE, BRANCHRULE_NARYWIDTHFAC_DEFAULT, 1.0, SCIP_REAL_MAX, NULL, NULL) );
return SCIP_OKAY;
}
/** update row activities after a variable's solution value changed */
static
SCIP_RETCODE updateRowActivities(
SCIP* scip, /**< SCIP data structure */
SCIP_Real* activities, /**< LP row activities */
SCIP_VAR* var, /**< variable that has been changed */
SCIP_Real shiftval /**< value that is added to variable */
)
{
SCIP_Real* colvals;
SCIP_ROW** colrows;
SCIP_COL* col;
int ncolrows;
int i;
assert(activities != NULL);
/* get data of column associated to variable */
col = SCIPvarGetCol(var);
colrows = SCIPcolGetRows(col);
colvals = SCIPcolGetVals(col);
ncolrows = SCIPcolGetNLPNonz(col);
assert(ncolrows == 0 || (colrows != NULL && colvals != NULL));
/* enumerate all rows with nonzero entry in this column */
for( i = 0; i < ncolrows; ++i )
{
SCIP_ROW* row;
int rowpos;
row = colrows[i];
rowpos = SCIProwGetLPPos(row);
assert(-1 <= rowpos && rowpos < SCIPgetNLPRows(scip) );
/* update row activity, only regard global rows in the LP */
if( rowpos >= 0 && !SCIProwIsLocal(row) )
{
activities[rowpos] += shiftval * colvals[i];
if( SCIPisInfinity(scip, activities[rowpos]) )
activities[rowpos] = SCIPinfinity(scip);
else if( SCIPisInfinity(scip, -activities[rowpos]) )
activities[rowpos] = -SCIPinfinity(scip);
}
}
return SCIP_OKAY;
}
SCIP_VAR* scip_dvar(SCIP* scip, SCIP_VAR* a, SCIP_VAR* b)
{
assert(a != b);
static unsigned int n = 0;
SCIP_CONS* cons;
SCIP_VAR* rval;
char cons_id[64], rval_id[64];
SCIP_VAR* vars[3] = {b, a, NULL};
SCIP_Real coefs[3] = {1, -1, 1};
SCIP_Real oo = SCIPinfinity(scip);
sprintf(rval_id, "dvar%d", n);
sprintf(cons_id, "deq%d", n++);
sa(SCIPcreateVarBasic(scip, &rval, rval_id, -oo, oo, 0,
SCIP_VARTYPE_INTEGER));
sa(SCIPaddVar(scip, rval));
vars[2] = rval;
sa(SCIPcreateConsLinear
(scip, &cons, cons_id, 3, vars, coefs, 0, 0,
TRUE, TRUE, TRUE, TRUE, TRUE,
FALSE, FALSE, FALSE, FALSE, FALSE));
sa(SCIPaddCons(scip, cons));
return rval;
}
/** returns whether the current token is a value */
static
SCIP_Bool isValue(
SCIP* scip, /**< SCIP data structure */
LPINPUT* lpinput, /**< LP reading data */
SCIP_Real* value /**< pointer to store the value (unchanged, if token is no value) */
)
{
assert(lpinput != NULL);
assert(value != NULL);
if( strcasecmp(lpinput->token, "INFINITY") == 0 || strcasecmp(lpinput->token, "INF") == 0 )
{
*value = SCIPinfinity(scip);
return TRUE;
}
else
{
double val;
char* endptr;
val = strtod(lpinput->token, &endptr);
if( endptr != lpinput->token && *endptr == '\0' )
{
*value = val;
return TRUE;
}
}
return FALSE;
}
/** branching execution method for fractional LP solutions */
static
SCIP_DECL_BRANCHEXECLP(branchExeclpPscost)
{ /*lint --e{715}*/
SCIP_VAR** lpcands;
SCIP_Real* lpcandssol;
SCIP_Real bestscore;
SCIP_Real bestrootdiff;
int nlpcands;
int bestcand;
int c;
assert(branchrule != NULL);
assert(strcmp(SCIPbranchruleGetName(branchrule), BRANCHRULE_NAME) == 0);
assert(scip != NULL);
assert(result != NULL);
SCIPdebugMessage("Execlp method of pscost branching\n");
/* get branching candidates */
SCIP_CALL( SCIPgetLPBranchCands(scip, &lpcands, &lpcandssol, NULL, NULL, &nlpcands, NULL) );
assert(nlpcands > 0);
bestcand = -1;
bestscore = -SCIPinfinity(scip);
bestrootdiff = 0.0;
for( c = 0; c < nlpcands; ++c )
{
SCIP_Real score;
SCIP_Real rootsolval;
SCIP_Real rootdiff;
score = SCIPgetVarPseudocostScore(scip, lpcands[c], lpcandssol[c]);
rootsolval = SCIPvarGetRootSol(lpcands[c]);
rootdiff = REALABS(lpcandssol[c] - rootsolval);
if( SCIPisSumGT(scip, score, bestscore) || (SCIPisSumEQ(scip, score, bestscore) && rootdiff > bestrootdiff) )
{
bestcand = c;
bestscore = score;
bestrootdiff = rootdiff;
}
}
assert(0 <= bestcand && bestcand < nlpcands);
assert(!SCIPisFeasIntegral(scip, lpcandssol[bestcand]));
/* perform the branching */
SCIPdebugMessage(" -> %d cands, selected cand %d: variable <%s> (solval=%g, score=%g)\n",
nlpcands, bestcand, SCIPvarGetName(lpcands[bestcand]), lpcandssol[bestcand], bestscore);
/* perform the branching */
SCIP_CALL( SCIPbranchVar(scip, lpcands[bestcand], NULL, NULL, NULL) );
*result = SCIP_BRANCHED;
return SCIP_OKAY;
}
/** initialization method of event handler (called after problem was transformed) */
static
SCIP_DECL_EVENTINIT(eventInitBoundwriting)
{ /*lint --e{715}*/
SCIP_EVENTHDLRDATA* eventhdlrdata;
assert(scip != NULL);
assert(eventhdlr != NULL);
assert(strcmp(SCIPeventhdlrGetName(eventhdlr), EVENTHDLR_NAME) == 0);
/* notify SCIP that your event handler wants to react on the event type best solution found */
SCIP_CALL( SCIPcatchEvent(scip, SCIP_EVENTTYPE_NODESOLVED, eventhdlr, NULL, NULL) );
eventhdlrdata = SCIPeventhdlrGetData(eventhdlr);
assert(eventhdlrdata != NULL);
eventhdlrdata->lastpb = SCIPinfinity(scip) * (SCIPgetObjsense(scip) == SCIP_OBJSENSE_MINIMIZE ? 1.0 : -1.0);
return SCIP_OKAY;
}
/** returns a fractional variable, that has most impact on rows in opposite direction, i.e. that is most crucial to
* fix in the other direction;
* if variables have equal impact, chooses the one with best objective value improvement in corresponding direction;
* rounding in a direction is forbidden, if this forces the objective value over the upper bound
*/
static
SCIP_RETCODE selectEssentialRounding(
SCIP* scip, /**< SCIP data structure */
SCIP_SOL* sol, /**< primal solution */
SCIP_Real minobj, /**< minimal objective value possible after rounding remaining fractional vars */
SCIP_VAR** lpcands, /**< fractional variables in LP */
int nlpcands, /**< number of fractional variables in LP */
SCIP_VAR** roundvar, /**< pointer to store the rounding variable, returns NULL if impossible */
SCIP_Real* oldsolval, /**< old (fractional) solution value of rounding variable */
SCIP_Real* newsolval /**< new (rounded) solution value of rounding variable */
)
{
SCIP_VAR* var;
SCIP_Real solval;
SCIP_Real roundval;
SCIP_Real obj;
SCIP_Real deltaobj;
SCIP_Real bestdeltaobj;
int maxnlocks;
int nlocks;
int v;
assert(roundvar != NULL);
assert(oldsolval != NULL);
assert(newsolval != NULL);
/* select rounding variable */
maxnlocks = -1;
bestdeltaobj = SCIPinfinity(scip);
*roundvar = NULL;
for( v = 0; v < nlpcands; ++v )
{
var = lpcands[v];
assert(SCIPvarGetType(var) == SCIP_VARTYPE_BINARY || SCIPvarGetType(var) == SCIP_VARTYPE_INTEGER);
solval = SCIPgetSolVal(scip, sol, var);
if( !SCIPisFeasIntegral(scip, solval) )
{
obj = SCIPvarGetObj(var);
/* rounding down */
nlocks = SCIPvarGetNLocksUp(var);
if( nlocks >= maxnlocks )
{
roundval = SCIPfeasFloor(scip, solval);
deltaobj = obj * (roundval - solval);
if( (nlocks > maxnlocks || deltaobj < bestdeltaobj) && minobj - obj < SCIPgetCutoffbound(scip) )
{
maxnlocks = nlocks;
bestdeltaobj = deltaobj;
*roundvar = var;
*oldsolval = solval;
*newsolval = roundval;
}
}
/* rounding up */
nlocks = SCIPvarGetNLocksDown(var);
if( nlocks >= maxnlocks )
{
roundval = SCIPfeasCeil(scip, solval);
deltaobj = obj * (roundval - solval);
if( (nlocks > maxnlocks || deltaobj < bestdeltaobj) && minobj + obj < SCIPgetCutoffbound(scip) )
{
maxnlocks = nlocks;
bestdeltaobj = deltaobj;
*roundvar = var;
*oldsolval = solval;
*newsolval = roundval;
}
}
}
}
return SCIP_OKAY;
}
/** checks if a given branching candidate is better than a previous one and updates the best branching candidate accordingly */
static
SCIP_RETCODE updateBestCandidate(
SCIP* scip, /**< SCIP data structure */
SCIP_BRANCHRULEDATA* branchruledata, /**< branching rule data */
SCIP_VAR** bestvar, /**< best branching candidate */
SCIP_Real* bestbrpoint, /**< branching point for best branching candidate */
SCIP_Real* bestscore, /**< score of best branching candidate */
SCIP_VAR* cand, /**< branching candidate to consider */
SCIP_Real candscoremin, /**< minimal score of branching candidate */
SCIP_Real candscoremax, /**< maximal score of branching candidate */
SCIP_Real candscoresum, /**< sum of scores of branching candidate */
SCIP_Real candsol /**< proposed branching point of branching candidate */
)
{
SCIP_Real candbrpoint;
SCIP_Real branchscore;
SCIP_Real deltaminus;
SCIP_Real deltaplus;
SCIP_Real pscostdown;
SCIP_Real pscostup;
char strategy;
assert(scip != NULL);
assert(branchruledata != NULL);
assert(bestvar != NULL);
assert(bestbrpoint != NULL);
assert(bestscore != NULL);
assert(cand != NULL);
/* a branching variable candidate should either be an active problem variable or a multi-aggregated variable */
assert(SCIPvarIsActive(SCIPvarGetProbvar(cand)) ||
SCIPvarGetStatus(SCIPvarGetProbvar(cand)) == SCIP_VARSTATUS_MULTAGGR);
if( SCIPvarGetStatus(SCIPvarGetProbvar(cand)) == SCIP_VARSTATUS_MULTAGGR )
{
/* for a multi-aggregated variable, we call updateBestCandidate function recursively with all variables in the multi-aggregation */
SCIP_VAR** multvars;
int nmultvars;
int i;
SCIP_Bool success;
SCIP_Real multvarlb;
SCIP_Real multvarub;
cand = SCIPvarGetProbvar(cand);
multvars = SCIPvarGetMultaggrVars(cand);
nmultvars = SCIPvarGetMultaggrNVars(cand);
/* if we have a candidate branching point, then first register only aggregation variables
* for which we can compute a corresponding branching point too (see also comments below)
* if this fails, then register all (unfixed) aggregation variables, thereby forgetting about candsol
*/
success = FALSE;
if( candsol != SCIP_INVALID ) /*lint !e777*/
{
SCIP_Real* multscalars;
SCIP_Real minact;
SCIP_Real maxact;
SCIP_Real aggrvarsol;
SCIP_Real aggrvarsol1;
SCIP_Real aggrvarsol2;
multscalars = SCIPvarGetMultaggrScalars(cand);
/* for computing the branching point, we need the current bounds of the multi-aggregated variable */
minact = SCIPcomputeVarLbLocal(scip, cand);
maxact = SCIPcomputeVarUbLocal(scip, cand);
for( i = 0; i < nmultvars; ++i )
{
/* skip fixed variables */
multvarlb = SCIPcomputeVarLbLocal(scip, multvars[i]);
multvarub = SCIPcomputeVarUbLocal(scip, multvars[i]);
if( SCIPisEQ(scip, multvarlb, multvarub) )
continue;
assert(multscalars != NULL);
assert(multscalars[i] != 0.0);
/* we cannot ensure that both the upper bound in the left node and the lower bound in the right node
* will be candsol by a clever choice for the branching point of multvars[i],
* but we can try to ensure that at least one of them will be at candsol
*/
if( multscalars[i] > 0.0 )
{
/* cand >= candsol
* if multvars[i] >= (candsol - (maxact - multscalars[i] * ub(multvars[i]))) / multscalars[i]
* = (candsol - maxact) / multscalars[i] + ub(multvars[i])
*/
aggrvarsol1 = (candsol - maxact) / multscalars[i] + multvarub;
/* cand <= candsol
* if multvars[i] <= (candsol - (minact - multscalar[i] * lb(multvars[i]))) / multscalars[i]
* = (candsol - minact) / multscalars[i] + lb(multvars[i])
*/
aggrvarsol2 = (candsol - minact) / multscalars[i] + multvarlb;
}
else
{
/* cand >= candsol
* if multvars[i] <= (candsol - (maxact - multscalars[i] * lb(multvars[i]))) / multscalars[i]
* = (candsol - maxact) / multscalars[i] + lb(multvars[i])
*/
aggrvarsol2 = (candsol - maxact) / multscalars[i] + multvarlb;
/* cand <= candsol
* if multvars[i] >= (candsol - (minact - multscalar[i] * ub(multvars[i]))) / multscalars[i]
* = (candsol - minact) / multscalars[i] + ub(multvars[i])
*/
aggrvarsol1 = (candsol - minact) / multscalars[i] + multvarub;
}
/* by the above choice, aggrvarsol1 <= ub(multvars[i]) and aggrvarsol2 >= lb(multvars[i])
* if aggrvarsol1 <= lb(multvars[i]) or aggrvarsol2 >= ub(multvars[i]), then choose the other one
* if both are out of bounds, then give up
* if both are inside bounds, then choose the one closer to 0.0 (someone has better idea???)
*/
if( SCIPisFeasLE(scip, aggrvarsol1, multvarlb) )
{
if( SCIPisFeasGE(scip, aggrvarsol2, multvarub) )
continue;
else
aggrvarsol = aggrvarsol2;
}
else
{
if( SCIPisFeasGE(scip, aggrvarsol2, multvarub) )
aggrvarsol = aggrvarsol1;
else
aggrvarsol = REALABS(aggrvarsol1) < REALABS(aggrvarsol2) ? aggrvarsol1 : aggrvarsol2;
}
success = TRUE;
SCIP_CALL( updateBestCandidate(scip, branchruledata, bestvar, bestbrpoint, bestscore,
multvars[i], candscoremin, candscoremax, candscoresum, aggrvarsol) );
}
}
if( !success )
for( i = 0; i < nmultvars; ++i )
{
/* skip fixed variables */
multvarlb = SCIPcomputeVarLbLocal(scip, multvars[i]);
multvarub = SCIPcomputeVarUbLocal(scip, multvars[i]);
if( SCIPisEQ(scip, multvarlb, multvarub) )
continue;
SCIP_CALL( updateBestCandidate(scip, branchruledata, bestvar, bestbrpoint, bestscore,
multvars[i], candscoremin, candscoremax, candscoresum, SCIP_INVALID) );
}
assert(*bestvar != NULL); /* if all variables were fixed, something is strange */
return SCIP_OKAY;
}
/* select branching point for this variable */
candbrpoint = SCIPgetBranchingPoint(scip, cand, candsol);
assert(candbrpoint >= SCIPvarGetLbLocal(cand));
assert(candbrpoint <= SCIPvarGetUbLocal(cand));
/* we cannot branch on a huge value for a discrete variable, because we simply cannot enumerate such huge integer values in floating point
* arithmetics
*/
if( SCIPvarGetType(cand) != SCIP_VARTYPE_CONTINUOUS && (SCIPisHugeValue(scip, candbrpoint) || SCIPisHugeValue(scip, -candbrpoint)) )
return SCIP_OKAY;
assert(SCIPvarGetType(cand) == SCIP_VARTYPE_CONTINUOUS || !SCIPisIntegral(scip, candbrpoint));
if( SCIPvarGetType(cand) == SCIP_VARTYPE_CONTINUOUS )
strategy = (branchruledata->strategy == 'u' ? branchruledata->updatestrategy : branchruledata->strategy);
else
strategy = (branchruledata->strategy == 'u' ? 'l' : branchruledata->strategy);
switch( strategy )
{
case 'l':
if( SCIPisInfinity(scip, SCIPgetSolVal(scip, NULL, cand)) || SCIPgetSolVal(scip, NULL, cand) <= SCIPadjustedVarUb(scip, cand, candbrpoint) )
deltaminus = 0.0;
else
deltaminus = SCIPgetSolVal(scip, NULL, cand) - SCIPadjustedVarUb(scip, cand, candbrpoint);
if( SCIPisInfinity(scip, -SCIPgetSolVal(scip, NULL, cand)) || SCIPgetSolVal(scip, NULL, cand) >= SCIPadjustedVarLb(scip, cand, candbrpoint) )
deltaplus = 0.0;
else
deltaplus = SCIPadjustedVarLb(scip, cand, candbrpoint) - SCIPgetSolVal(scip, NULL, cand);
break;
case 'd':
if( SCIPisInfinity(scip, -SCIPvarGetLbLocal(cand)) )
deltaminus = SCIPisInfinity(scip, candscoremax) ? SCIPinfinity(scip) : WEIGHTEDSCORING(branchruledata, candscoremin, candscoremax, candscoresum);
else
deltaminus = SCIPadjustedVarUb(scip, cand, candbrpoint) - SCIPvarGetLbLocal(cand);
if( SCIPisInfinity(scip, SCIPvarGetUbLocal(cand)) )
deltaplus = SCIPisInfinity(scip, candscoremax) ? SCIPinfinity(scip) : WEIGHTEDSCORING(branchruledata, candscoremin, candscoremax, candscoresum);
else
deltaplus = SCIPvarGetUbLocal(cand) - SCIPadjustedVarLb(scip, cand, candbrpoint);
break;
case 's':
if( SCIPisInfinity(scip, -SCIPvarGetLbLocal(cand)) )
deltaplus = SCIPisInfinity(scip, candscoremax) ? SCIPinfinity(scip) : WEIGHTEDSCORING(branchruledata, candscoremin, candscoremax, candscoresum);
else
deltaplus = SCIPadjustedVarUb(scip, cand, candbrpoint) - SCIPvarGetLbLocal(cand);
if( SCIPisInfinity(scip, SCIPvarGetUbLocal(cand)) )
deltaminus = SCIPisInfinity(scip, candscoremax) ? SCIPinfinity(scip) : WEIGHTEDSCORING(branchruledata, candscoremin, candscoremax, candscoresum);
else
deltaminus = SCIPvarGetUbLocal(cand) - SCIPadjustedVarLb(scip, cand, candbrpoint);
break;
case 'v':
deltaplus = SCIPisInfinity(scip, candscoremax) ? SCIPinfinity(scip) : WEIGHTEDSCORING(branchruledata, candscoremin, candscoremax, candscoresum);
deltaminus = deltaplus;
break;
default :
SCIPerrorMessage("branching strategy %c unknown\n", strategy);
SCIPABORT();
return SCIP_INVALIDDATA; /*lint !e527*/
}
if( SCIPisInfinity(scip, deltaminus) || SCIPisInfinity(scip, deltaplus) )
{
branchscore = SCIPinfinity(scip);
}
else
{
pscostdown = SCIPgetVarPseudocostVal(scip, cand, -deltaminus);
pscostup = SCIPgetVarPseudocostVal(scip, cand, deltaplus);
branchscore = SCIPgetBranchScore(scip, cand, pscostdown, pscostup);
assert(!SCIPisNegative(scip, branchscore));
}
SCIPdebugMessage("branching score variable <%s>[%g,%g] = %g; wscore = %g; type=%d bestbrscore=%g\n",
SCIPvarGetName(cand), SCIPvarGetLbLocal(cand), SCIPvarGetUbLocal(cand), branchscore, WEIGHTEDSCORING(branchruledata, candscoremin, candscoremax, candscoresum),
SCIPvarGetType(cand), *bestscore);
if( SCIPisInfinity(scip, branchscore) )
branchscore = 0.9*SCIPinfinity(scip);
if( SCIPisSumGT(scip, branchscore, *bestscore) )
{
(*bestscore) = branchscore;
(*bestvar) = cand;
(*bestbrpoint) = candbrpoint;
}
else if( SCIPisSumEQ(scip, branchscore, *bestscore)
&& !(SCIPisInfinity(scip, -SCIPvarGetLbLocal(*bestvar)) && SCIPisInfinity(scip, SCIPvarGetUbLocal(*bestvar))) )
{
/* if best candidate so far is not unbounded to both sides, maybe take new candidate */
if( (SCIPisInfinity(scip, -SCIPvarGetLbLocal(cand)) || SCIPisInfinity(scip, SCIPvarGetUbLocal(cand))) &&
(SCIPisInfinity(scip, -SCIPvarGetLbLocal(*bestvar)) || SCIPisInfinity(scip, SCIPvarGetUbLocal(*bestvar))) )
{
/* if both variables are unbounded but one of them is bounded on one side, take the one with the larger bound on this side (hope that this avoids branching on always the same variable) */
if( SCIPvarGetUbLocal(cand) > SCIPvarGetUbLocal(*bestvar) || SCIPvarGetLbLocal(cand) < SCIPvarGetLbLocal(*bestvar) )
{
(*bestscore) = branchscore;
(*bestvar) = cand;
(*bestbrpoint) = candbrpoint;
}
}
else if( SCIPvarGetType(*bestvar) == SCIPvarGetType(cand) )
{
/* if both have the same type, take the one with larger diameter */
if( SCIPvarGetUbLocal(*bestvar) - SCIPvarGetLbLocal(*bestvar) < SCIPvarGetUbLocal(cand) - SCIPvarGetLbLocal(cand) )
{
(*bestscore) = branchscore;
(*bestvar) = cand;
(*bestbrpoint) = candbrpoint;
}
}
else if( SCIPvarGetType(*bestvar) > SCIPvarGetType(cand) )
{
/* take the one with better type ("more discrete") */
(*bestscore) = branchscore;
(*bestvar) = cand;
(*bestbrpoint) = candbrpoint;
}
}
return SCIP_OKAY;
}
/** main procedure of the zeroobj heuristic, creates and solves a sub-SCIP */
SCIP_RETCODE SCIPapplyZeroobj(
SCIP* scip, /**< original SCIP data structure */
SCIP_HEUR* heur, /**< heuristic data structure */
SCIP_RESULT* result, /**< result data structure */
SCIP_Real minimprove, /**< factor by which zeroobj should at least improve the incumbent */
SCIP_Longint nnodes /**< node limit for the subproblem */
)
{
SCIP* subscip; /* the subproblem created by zeroobj */
SCIP_HASHMAP* varmapfw; /* mapping of SCIP variables to sub-SCIP variables */
SCIP_VAR** vars; /* original problem's variables */
SCIP_VAR** subvars; /* subproblem's variables */
SCIP_HEURDATA* heurdata; /* heuristic's private data structure */
SCIP_EVENTHDLR* eventhdlr; /* event handler for LP events */
SCIP_Real cutoff; /* objective cutoff for the subproblem */
SCIP_Real timelimit; /* time limit for zeroobj subproblem */
SCIP_Real memorylimit; /* memory limit for zeroobj subproblem */
SCIP_Real large;
int nvars; /* number of original problem's variables */
int i;
SCIP_Bool success;
SCIP_Bool valid;
SCIP_RETCODE retcode;
SCIP_SOL** subsols;
int nsubsols;
assert(scip != NULL);
assert(heur != NULL);
assert(result != NULL);
assert(nnodes >= 0);
assert(0.0 <= minimprove && minimprove <= 1.0);
*result = SCIP_DIDNOTRUN;
/* only call heuristic once at the root */
if( SCIPgetDepth(scip) <= 0 && SCIPheurGetNCalls(heur) > 0 )
return SCIP_OKAY;
/* get heuristic data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* only call the heuristic if we do not have an incumbent */
if( SCIPgetNSolsFound(scip) > 0 && heurdata->onlywithoutsol )
return SCIP_OKAY;
/* check whether there is enough time and memory left */
timelimit = 0.0;
memorylimit = 0.0;
SCIP_CALL( SCIPgetRealParam(scip, "limits/time", &timelimit) );
if( !SCIPisInfinity(scip, timelimit) )
timelimit -= SCIPgetSolvingTime(scip);
SCIP_CALL( SCIPgetRealParam(scip, "limits/memory", &memorylimit) );
/* substract the memory already used by the main SCIP and the estimated memory usage of external software */
if( !SCIPisInfinity(scip, memorylimit) )
{
memorylimit -= SCIPgetMemUsed(scip)/1048576.0;
memorylimit -= SCIPgetMemExternEstim(scip)/1048576.0;
}
/* abort if no time is left or not enough memory to create a copy of SCIP, including external memory usage */
if( timelimit <= 0.0 || memorylimit <= 2.0*SCIPgetMemExternEstim(scip)/1048576.0 )
return SCIP_OKAY;
*result = SCIP_DIDNOTFIND;
/* get variable data */
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, NULL, NULL, NULL, NULL) );
/* initialize the subproblem */
SCIP_CALL( SCIPcreate(&subscip) );
/* create the variable mapping hash map */
SCIP_CALL( SCIPhashmapCreate(&varmapfw, SCIPblkmem(subscip), SCIPcalcHashtableSize(5 * nvars)) );
SCIP_CALL( SCIPallocBufferArray(scip, &subvars, nvars) );
/* different methods to create sub-problem: either copy LP relaxation or the CIP with all constraints */
valid = FALSE;
/* copy complete SCIP instance */
SCIP_CALL( SCIPcopy(scip, subscip, varmapfw, NULL, "zeroobj", TRUE, FALSE, TRUE, &valid) );
SCIPdebugMessage("Copying the SCIP instance was %s complete.\n", valid ? "" : "not ");
/* create event handler for LP events */
eventhdlr = NULL;
SCIP_CALL( SCIPincludeEventhdlrBasic(subscip, &eventhdlr, EVENTHDLR_NAME, EVENTHDLR_DESC, eventExecZeroobj, NULL) );
if( eventhdlr == NULL )
{
SCIPerrorMessage("event handler for "HEUR_NAME" heuristic not found.\n");
return SCIP_PLUGINNOTFOUND;
}
/* determine large value to set variables to */
large = SCIPinfinity(scip);
if( !SCIPisInfinity(scip, 0.1 / SCIPfeastol(scip)) )
large = 0.1 / SCIPfeastol(scip);
/* get variable image and change to 0.0 in sub-SCIP */
for( i = 0; i < nvars; i++ )
{
SCIP_Real adjustedbound;
SCIP_Real lb;
SCIP_Real ub;
SCIP_Real inf;
subvars[i] = (SCIP_VAR*) SCIPhashmapGetImage(varmapfw, vars[i]);
SCIP_CALL( SCIPchgVarObj(subscip, subvars[i], 0.0) );
lb = SCIPvarGetLbGlobal(subvars[i]);
ub = SCIPvarGetUbGlobal(subvars[i]);
inf = SCIPinfinity(subscip);
/* adjust infinite bounds in order to avoid that variables with non-zero objective
* get fixed to infinite value in zeroobj subproblem
*/
if( SCIPisInfinity(subscip, ub ) )
{
adjustedbound = MAX(large, lb+large);
adjustedbound = MIN(adjustedbound, inf);
SCIP_CALL( SCIPchgVarUbGlobal(subscip, subvars[i], adjustedbound) );
}
if( SCIPisInfinity(subscip, -lb ) )
{
adjustedbound = MIN(-large, ub-large);
adjustedbound = MAX(adjustedbound, -inf);
SCIP_CALL( SCIPchgVarLbGlobal(subscip, subvars[i], adjustedbound) );
}
}
/* free hash map */
SCIPhashmapFree(&varmapfw);
/* do not abort subproblem on CTRL-C */
SCIP_CALL( SCIPsetBoolParam(subscip, "misc/catchctrlc", FALSE) );
/* disable output to console */
SCIP_CALL( SCIPsetIntParam(subscip, "display/verblevel", 0) );
/* set limits for the subproblem */
SCIP_CALL( SCIPsetLongintParam(subscip, "limits/nodes", nnodes) );
SCIP_CALL( SCIPsetRealParam(subscip, "limits/time", timelimit) );
SCIP_CALL( SCIPsetRealParam(subscip, "limits/memory", memorylimit) );
SCIP_CALL( SCIPsetIntParam(subscip, "limits/solutions", 1) );
/* forbid recursive call of heuristics and separators solving sub-SCIPs */
SCIP_CALL( SCIPsetSubscipsOff(subscip, TRUE) );
/* disable expensive techniques that merely work on the dual bound */
/* disable cutting plane separation */
SCIP_CALL( SCIPsetSeparating(subscip, SCIP_PARAMSETTING_OFF, TRUE) );
/* disable expensive presolving */
SCIP_CALL( SCIPsetPresolving(subscip, SCIP_PARAMSETTING_FAST, TRUE) );
if( !SCIPisParamFixed(subscip, "presolving/maxrounds") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "presolving/maxrounds", 50) );
}
/* use best dfs node selection */
if( SCIPfindNodesel(subscip, "dfs") != NULL && !SCIPisParamFixed(subscip, "nodeselection/dfs/stdpriority") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "nodeselection/dfs/stdpriority", INT_MAX/4) );
}
/* use inference branching */
if( SCIPfindBranchrule(subscip, "inference") != NULL && !SCIPisParamFixed(subscip, "branching/inference/priority") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "branching/leastinf/priority", INT_MAX/4) );
}
/* employ a limit on the number of enforcement rounds in the quadratic constraint handler; this fixes the issue that
* sometimes the quadratic constraint handler needs hundreds or thousands of enforcement rounds to determine the
* feasibility status of a single node without fractional branching candidates by separation (namely for uflquad
* instances); however, the solution status of the sub-SCIP might get corrupted by this; hence no deductions shall be
* made for the original SCIP
*/
if( SCIPfindConshdlr(subscip, "quadratic") != NULL && !SCIPisParamFixed(subscip, "constraints/quadratic/enfolplimit") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "constraints/quadratic/enfolplimit", 10) );
}
/* disable feaspump and fracdiving */
if( !SCIPisParamFixed(subscip, "heuristics/feaspump/freq") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "heuristics/feaspump/freq", -1) );
}
if( !SCIPisParamFixed(subscip, "heuristics/fracdiving/freq") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "heuristics/fracdiving/freq", -1) );
}
/* restrict LP iterations */
SCIP_CALL( SCIPsetLongintParam(subscip, "lp/iterlim", 2*heurdata->maxlpiters / MAX(1,nnodes)) );
SCIP_CALL( SCIPsetLongintParam(subscip, "lp/rootiterlim", heurdata->maxlpiters) );
#ifdef SCIP_DEBUG
/* for debugging zeroobj, enable MIP output */
SCIP_CALL( SCIPsetIntParam(subscip, "display/verblevel", 5) );
SCIP_CALL( SCIPsetIntParam(subscip, "display/freq", 100000000) );
#endif
/* if there is already a solution, add an objective cutoff */
if( SCIPgetNSols(scip) > 0 )
{
SCIP_Real upperbound;
SCIP_CONS* origobjcons;
#ifndef NDEBUG
int nobjvars;
nobjvars = 0;
#endif
cutoff = SCIPinfinity(scip);
assert( !SCIPisInfinity(scip,SCIPgetUpperbound(scip)) );
upperbound = SCIPgetUpperbound(scip) - SCIPsumepsilon(scip);
if( !SCIPisInfinity(scip,-1.0*SCIPgetLowerbound(scip)) )
{
cutoff = (1-minimprove)*SCIPgetUpperbound(scip) + minimprove*SCIPgetLowerbound(scip);
}
else
{
if( SCIPgetUpperbound(scip) >= 0 )
cutoff = ( 1 - minimprove ) * SCIPgetUpperbound ( scip );
else
cutoff = ( 1 + minimprove ) * SCIPgetUpperbound ( scip );
}
cutoff = MIN(upperbound, cutoff);
SCIP_CALL( SCIPcreateConsLinear(subscip, &origobjcons, "objbound_of_origscip", 0, NULL, NULL, -SCIPinfinity(subscip), cutoff,
TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE) );
for( i = 0; i < nvars; ++i)
{
if( !SCIPisFeasZero(subscip, SCIPvarGetObj(vars[i])) )
{
SCIP_CALL( SCIPaddCoefLinear(subscip, origobjcons, subvars[i], SCIPvarGetObj(vars[i])) );
#ifndef NDEBUG
nobjvars++;
#endif
}
}
SCIP_CALL( SCIPaddCons(subscip, origobjcons) );
SCIP_CALL( SCIPreleaseCons(subscip, &origobjcons) );
assert(nobjvars == SCIPgetNObjVars(scip));
}
/* catch LP events of sub-SCIP */
SCIP_CALL( SCIPtransformProb(subscip) );
SCIP_CALL( SCIPcatchEvent(subscip, SCIP_EVENTTYPE_NODESOLVED, eventhdlr, (SCIP_EVENTDATA*) heurdata, NULL) );
SCIPdebugMessage("solving subproblem: nnodes=%"SCIP_LONGINT_FORMAT"\n", nnodes);
retcode = SCIPsolve(subscip);
/* drop LP events of sub-SCIP */
SCIP_CALL( SCIPdropEvent(subscip, SCIP_EVENTTYPE_NODESOLVED, eventhdlr, (SCIP_EVENTDATA*) heurdata, -1) );
/* errors in solving the subproblem should not kill the overall solving process;
* hence, the return code is caught and a warning is printed, only in debug mode, SCIP will stop.
*/
if( retcode != SCIP_OKAY )
{
#ifndef NDEBUG
SCIP_CALL( retcode );
#endif
SCIPwarningMessage(scip, "Error while solving subproblem in zeroobj heuristic; sub-SCIP terminated with code <%d>\n",retcode);
}
/* check, whether a solution was found;
* due to numerics, it might happen that not all solutions are feasible -> try all solutions until one was accepted
*/
nsubsols = SCIPgetNSols(subscip);
subsols = SCIPgetSols(subscip);
success = FALSE;
for( i = 0; i < nsubsols && (!success || heurdata->addallsols); ++i )
{
SCIP_CALL( createNewSol(scip, subscip, subvars, heur, subsols[i], &success) );
if( success )
*result = SCIP_FOUNDSOL;
}
#ifdef SCIP_DEBUG
SCIP_CALL( SCIPprintStatistics(subscip, NULL) );
#endif
/* free subproblem */
SCIPfreeBufferArray(scip, &subvars);
SCIP_CALL( SCIPfree(&subscip) );
return SCIP_OKAY;
}
SCIP_RETCODE SCIPconshdlrBenders::sepaBenders(
SCIP * scip,
SCIP_CONSHDLR * conshdlr,
SCIP_SOL * sol,
whereFrom where,
SCIP_RESULT * result)
{
OsiCuts cs; /**< Benders cut placeholder */
SCIP_Real * vals = NULL; /**< current solution */
#if 1
if (scip_checkpriority_ < 0)
{
/** consider incumbent solutions only */
double primObj = SCIPgetPrimalbound(scip);
double currObj = SCIPgetSolOrigObj(scip, sol);
if (SCIPisLT(scip, primObj, currObj))
{
DSPdebugMessage(" -> primObj %e currObj %e\n", primObj, currObj);
return SCIP_OKAY;
}
}
#endif
/** allocate memory */
SCIP_CALL(SCIPallocMemoryArray(scip, &vals, nvars_));
/** get current solution */
SCIP_CALL(SCIPgetSolVals(scip, sol, nvars_, vars_, vals));
/** TODO The following filter does not work, meaning that it provides suboptimal solution.
* I do not know the reason. */
#if 0
double maxviol = 1.e-10;
for (int j = 0; j < nvars_ - naux_; ++j)
{
SCIP_VARTYPE vartype = SCIPvarGetType(vars_[j]);
if (vartype == SCIP_VARTYPE_CONTINUOUS) continue;
double viol = 0.5 - fabs(vals[j] - floor(vals[j]) - 0.5);
if (viol > maxviol)
maxviol = viol;
}
DSPdebugMessage("maximum violation %e\n", maxviol);
if (where != from_scip_check &&
where != from_scip_enfolp &&
where != from_scip_enfops &&
maxviol > 1.e-7)
{
printf("where %d maxviol %e\n", where, maxviol);
/** free memory */
SCIPfreeMemoryArray(scip, &vals);
return SCIP_OKAY;
}
#endif
#ifdef DSP_DEBUG2
double minvals = COIN_DBL_MAX;
double maxvals = -COIN_DBL_MAX;
double sumvals = 0.;
double ssvals = 0.;
//printf("nvars_ %d naux_ %d nAuxvars_ %d\n", nvars_, naux_, tss_->nAuxvars_);
for (int j = 0; j < nvars_ - naux_; ++j)
{
// if (vals[j] < 0 || vals[j] > 1)
// printf("solution %d has value %e.\n", j, vals[j]);
sumvals += vals[j];
ssvals += vals[j] * vals[j];
minvals = minvals > vals[j] ? vals[j] : minvals;
maxvals = maxvals < vals[j] ? vals[j] : maxvals;
}
DSPdebugMessage("solution: min %e max %e avg %e sum %e two-norm %e\n",
minvals, maxvals, sumvals / nvars_, sumvals, sqrt(ssvals));
#endif
#define SCAN_GLOBAL_CUT_POOL
#ifdef SCAN_GLOBAL_CUT_POOL
if (SCIPgetStage(scip) == SCIP_STAGE_SOLVING ||
SCIPgetStage(scip) == SCIP_STAGE_SOLVED ||
SCIPgetStage(scip) == SCIP_STAGE_EXITSOLVE)
{
bool addedPoolCut = false;
int numPoolCuts = SCIPgetNPoolCuts(scip);
int numCutsToScan = 100;
SCIP_CUT ** poolcuts = SCIPgetPoolCuts(scip);
for (int i = numPoolCuts - 1; i >= 0; --i)
{
if (i < 0) break;
if (numCutsToScan == 0) break;
/** retrieve row */
SCIP_ROW * poolcutrow = SCIPcutGetRow(poolcuts[i]);
/** benders? */
if (strcmp(SCIProwGetName(poolcutrow), "benders") != 0)
continue;
/** counter */
numCutsToScan--;
if (SCIPgetCutEfficacy(scip, sol, poolcutrow) > 1.e-6)
{
if (where == from_scip_sepalp ||
where == from_scip_sepasol ||
where == from_scip_enfolp)
{
/** add cut */
SCIP_Bool infeasible;
SCIP_CALL(SCIPaddCut(scip, sol, poolcutrow,
FALSE, /**< force cut */
&infeasible));
if (infeasible)
*result = SCIP_CUTOFF;
else //if (*result != SCIP_CUTOFF)
*result = SCIP_SEPARATED;
}
else
*result = SCIP_INFEASIBLE;
addedPoolCut = true;
break;
}
}
if (addedPoolCut)
{
DSPdebugMessage("Added pool cut\n");
/** free memory */
SCIPfreeMemoryArray(scip, &vals);
return SCIP_OKAY;
}
}
#endif
/** generate Benders cuts */
assert(tss_);
tss_->generateCuts(nvars_, vals, &cs);
/** If found Benders cuts */
for (int i = 0; i < cs.sizeCuts(); ++i)
{
/** get cut pointer */
OsiRowCut * rc = cs.rowCutPtr(i);
if (!rc) continue;
const CoinPackedVector cutrow = rc->row();
if (cutrow.getNumElements() == 0) continue;
/** is optimality cut? */
bool isOptimalityCut = false;
for (int j = nvars_ - naux_; j < nvars_; ++j)
{
if (cutrow.getMaxIndex() == j)
{
isOptimalityCut = true;
break;
}
}
double efficacy = rc->violated(vals) / cutrow.twoNorm();
SCIP_Bool isEfficacious = efficacy > 1.e-6;
#define KK_TEST
#ifdef KK_TEST
if (SCIPgetStage(scip) == SCIP_STAGE_INITSOLVE ||
SCIPgetStage(scip) == SCIP_STAGE_SOLVING)
{
/** create empty row */
SCIP_ROW * row = NULL;
SCIP_CALL(SCIPcreateEmptyRowCons(scip, &row, conshdlr, "benders", rc->lb(), SCIPinfinity(scip),
FALSE, /**< is row local? */
FALSE, /**< is row modifiable? */
FALSE /**< is row removable? can this be TRUE? */));
/** cache the row extension and only flush them if the cut gets added */
SCIP_CALL(SCIPcacheRowExtensions(scip, row));
/** collect all non-zero coefficients */
for (int j = 0; j < cutrow.getNumElements(); ++j)
SCIP_CALL(SCIPaddVarToRow(scip, row, vars_[cutrow.getIndices()[j]], cutrow.getElements()[j]));
DSPdebugMessage("found Benders (%s) cut: act=%f, lhs=%f, norm=%f, eff=%f, min=%f, max=%f (range=%f)\n",
isOptimalityCut ? "opti" : "feas",
SCIPgetRowLPActivity(scip, row), SCIProwGetLhs(row), SCIProwGetNorm(row),
SCIPgetCutEfficacy(scip, sol, row),
SCIPgetRowMinCoef(scip, row), SCIPgetRowMaxCoef(scip, row),
SCIPgetRowMaxCoef(scip, row)/SCIPgetRowMinCoef(scip, row));
/** flush all changes before adding cut */
SCIP_CALL(SCIPflushRowExtensions(scip, row));
DSPdebugMessage("efficacy %e isEfficatious %d\n", efficacy, isEfficacious);
if (isEfficacious)
{
if (where == from_scip_sepalp ||
where == from_scip_sepasol ||
where == from_scip_enfolp)
{
/** add cut */
SCIP_Bool infeasible;
SCIP_CALL(SCIPaddCut(scip, sol, row,
FALSE, /**< force cut */
&infeasible));
if (infeasible)
*result = SCIP_CUTOFF;
else //if (*result != SCIP_CUTOFF)
*result = SCIP_SEPARATED;
}
else
*result = SCIP_INFEASIBLE;
}
/** add cut to global pool */
SCIP_CALL(SCIPaddPoolCut(scip, row));
DSPdebugMessage("number of cuts in global cut pool: %d\n", SCIPgetNPoolCuts(scip));
/** release the row */
SCIP_CALL(SCIPreleaseRow(scip, &row));
}
else if (isEfficacious &&
where != from_scip_sepalp &&
where != from_scip_sepasol &&
where != from_scip_enfolp)
*result = SCIP_INFEASIBLE;
#else
if (where == from_scip_sepalp ||
where == from_scip_sepasol ||
where == from_scip_enfolp)
{
/** create empty row */
SCIP_ROW * row = NULL;
SCIP_CALL(SCIPcreateEmptyRowCons(scip, &row, conshdlr, "benders", rc->lb(), SCIPinfinity(scip),
FALSE, /**< is row local? */
FALSE, /**< is row modifiable? */
FALSE /**< is row removable? can this be TRUE? */));
/** cache the row extension and only flush them if the cut gets added */
SCIP_CALL(SCIPcacheRowExtensions(scip, row));
/** collect all non-zero coefficients */
for (int j = 0; j < cutrow.getNumElements(); ++j)
SCIP_CALL(SCIPaddVarToRow(scip, row, vars_[cutrow.getIndices()[j]], cutrow.getElements()[j]));
DSPdebugMessage("found Benders (%s) cut: act=%f, lhs=%f, norm=%f, eff=%f, min=%f, max=%f (range=%f)\n",
isOptimalityCut ? "opti" : "feas",
SCIPgetRowLPActivity(scip, row), SCIProwGetLhs(row), SCIProwGetNorm(row),
SCIPgetCutEfficacy(scip, NULL, row),
SCIPgetRowMinCoef(scip, row), SCIPgetRowMaxCoef(scip, row),
SCIPgetRowMaxCoef(scip, row)/SCIPgetRowMinCoef(scip, row));
/** flush all changes before adding cut */
SCIP_CALL(SCIPflushRowExtensions(scip, row));
/** is cut efficacious? */
if (isOptimalityCut)
{
efficacy = SCIPgetCutEfficacy(scip, sol, row);
isEfficacious = SCIPisCutEfficacious(scip, sol, row);
}
else
{
efficacy = rc->violated(vals);
isEfficacious = efficacy > 1.e-6;
}
if (isEfficacious)
{
/** add cut */
SCIP_Bool infeasible;
SCIP_CALL(SCIPaddCut(scip, sol, row,
FALSE, /**< force cut */
&infeasible));
if (infeasible)
*result = SCIP_CUTOFF;
else if (*result != SCIP_CUTOFF)
*result = SCIP_SEPARATED;
}
/** add cut to global pool */
SCIP_CALL(SCIPaddPoolCut(scip, row));
/** release the row */
SCIP_CALL(SCIPreleaseRow(scip, &row));
}
else
{
if (isOptimalityCut)
{
efficacy = rc->violated(vals) / cutrow.twoNorm();
isEfficacious = efficacy > 0.05;
}
else
{
efficacy = rc->violated(vals);
isEfficacious = efficacy > 1.e-6;
}
DSPdebugMessage("%s efficacy %e\n", isOptimalityCut ? "Opti" : "Feas", efficacy);
if (isEfficacious == TRUE)
*result = SCIP_INFEASIBLE;
}
#endif
}
/** free memory */
SCIPfreeMemoryArray(scip, &vals);
return SCIP_OKAY;
}
/** branching execution method for external candidates */
static
SCIP_DECL_BRANCHEXECEXT(branchExecextLeastinf)
{ /*lint --e{715}*/
SCIP_VAR** externcands;
SCIP_Real* externcandssol;
SCIP_Real* externcandsscore;
int nexterncands;
SCIP_VAR* bestcand;
SCIP_Real bestscore;
SCIP_Real bestobj;
SCIP_Real bestsol;
SCIP_Real brpoint;
int i;
SCIP_NODE* downchild;
SCIP_NODE* eqchild;
SCIP_NODE* upchild;
assert(branchrule != NULL);
assert(strcmp(SCIPbranchruleGetName(branchrule), BRANCHRULE_NAME) == 0);
assert(scip != NULL);
assert(result != NULL);
SCIPdebugMessage("Execext method of leastinf branching\n");
/* get branching candidates */
SCIP_CALL( SCIPgetExternBranchCands(scip, &externcands, &externcandssol, &externcandsscore, NULL, &nexterncands, NULL, NULL, NULL) );
assert(nexterncands > 0);
/* search the least infeasible candidate */
bestscore = SCIPinfinity(scip);
bestobj = 0.0;
bestcand = NULL;
bestsol = SCIP_INVALID;
for( i = 0; i < nexterncands; ++i )
{
updateBestCandidate(scip, &bestcand, &bestscore, &bestobj, &bestsol, externcands[i], externcandsscore[i], externcandssol[i]);
}
if( bestcand == NULL )
{
SCIPerrorMessage("branchExecextLeastinf failed to select a branching variable from %d candidates\n", nexterncands);
*result = SCIP_DIDNOTRUN;
return SCIP_OKAY;
}
brpoint = SCIPgetBranchingPoint(scip, bestcand, bestsol);
SCIPdebugMessage(" -> %d candidates, selected variable <%s> (infeas=%g, obj=%g, factor=%g, score=%g), branching point=%g\n",
nexterncands, SCIPvarGetName(bestcand), bestsol, bestobj,
SCIPvarGetBranchFactor(bestcand), bestscore, brpoint);
/* perform the branching */
SCIP_CALL( SCIPbranchVarVal(scip, bestcand, brpoint, &downchild, &eqchild, &upchild) );
if( downchild != NULL || eqchild != NULL || upchild != NULL )
{
*result = SCIP_BRANCHED;
}
else
{
/* if there are no children, then variable should have been fixed by SCIPbranchVarVal */
assert(SCIPisEQ(scip, SCIPvarGetLbLocal(bestcand), SCIPvarGetUbLocal(bestcand)));
*result = SCIP_REDUCEDDOM;
}
return SCIP_OKAY;
}
/** presolving execution method */
static
SCIP_DECL_PRESOLEXEC(presolExecBoundshift)
{ /*lint --e{715}*/
SCIP_PRESOLDATA* presoldata;
SCIP_VAR** scipvars;
SCIP_VAR** vars;
int nbinvars;
int nvars;
int v;
assert(scip != NULL);
assert(presol != NULL);
assert(strcmp(SCIPpresolGetName(presol), PRESOL_NAME) == 0);
assert(result != NULL);
*result = SCIP_DIDNOTRUN;
/* get presolver data */
presoldata = SCIPpresolGetData(presol);
assert(presoldata != NULL);
/* get the problem variables */
scipvars = SCIPgetVars(scip);
nbinvars = SCIPgetNBinVars(scip);
nvars = SCIPgetNVars(scip) - nbinvars;
if( nvars == 0 )
return SCIP_OKAY;
if( SCIPdoNotAggr(scip) )
return SCIP_OKAY;
*result = SCIP_DIDNOTFIND;
/* copy the integer variables into an own array, since adding new integer variables affects the left-most slots in
* the array and thereby interferes with our search loop
*/
SCIP_CALL( SCIPduplicateBufferArray(scip, &vars, &scipvars[nbinvars], nvars) );
/* scan the integer, implicit, and continuous variables for possible conversion */
for( v = nvars - 1; v >= 0; --v )
{
SCIP_VAR* var = vars[v];
SCIP_Real lb;
SCIP_Real ub;
assert(SCIPvarGetType(var) != SCIP_VARTYPE_BINARY);
/* get current variable's bounds */
lb = SCIPvarGetLbGlobal(var);
ub = SCIPvarGetUbGlobal(var);
assert( SCIPisLE(scip, lb, ub) );
if( SCIPisEQ(scip, lb, ub) )
continue;
if( presoldata->integer && !SCIPisIntegral(scip, ub - lb) )
continue;
/* check if bounds are shiftable */
if( !SCIPisEQ(scip, lb, 0.0) && /* lower bound != 0.0 */
SCIPisLT(scip, ub, SCIPinfinity(scip)) && /* upper bound != infinity */
SCIPisGT(scip, lb, -SCIPinfinity(scip)) && /* lower bound != -infinity */
#if 0
SCIPisLT(scip, ub - lb, SCIPinfinity(scip)) && /* interval length less than SCIPinfinity(scip) */
#endif
SCIPisLT(scip, ub - lb, (SCIP_Real) presoldata->maxshift) ) /* less than max shifting */
{
SCIP_VAR* newvar;
char newvarname[SCIP_MAXSTRLEN];
SCIP_Bool infeasible;
SCIP_Bool redundant;
SCIP_Bool aggregated;
SCIPdebugMessage("convert range <%s>[%g,%g] to [%g,%g]\n", SCIPvarGetName(var), lb, ub, 0.0, (ub - lb) );
/* create new variable */
(void) SCIPsnprintf(newvarname, SCIP_MAXSTRLEN, "%s_shift", SCIPvarGetName(var));
SCIP_CALL( SCIPcreateVar(scip, &newvar, newvarname, 0.0, (ub - lb), 0.0, SCIPvarGetType(var),
SCIPvarIsInitial(var), SCIPvarIsRemovable(var), NULL, NULL, NULL, NULL, NULL) );
SCIP_CALL( SCIPaddVar(scip, newvar) );
/* aggregate old variable with new variable */
if( presoldata->flipping )
{
if( REALABS(ub) < REALABS(lb) )
{
SCIP_CALL( SCIPaggregateVars(scip, var, newvar, 1.0, 1.0, ub, &infeasible, &redundant, &aggregated) );
}
else
{
SCIP_CALL( SCIPaggregateVars(scip, var, newvar, 1.0, -1.0, lb, &infeasible, &redundant, &aggregated) );
}
}
else
{
SCIP_CALL( SCIPaggregateVars(scip, var, newvar, 1.0, -1.0, lb, &infeasible, &redundant, &aggregated) );
}
assert(!infeasible);
assert(redundant);
assert(aggregated);
SCIPdebugMessage("var <%s> with bounds [%f,%f] has obj %f\n",
SCIPvarGetName(newvar),SCIPvarGetLbGlobal(newvar),SCIPvarGetUbGlobal(newvar),SCIPvarGetObj(newvar));
/* release variable */
SCIP_CALL( SCIPreleaseVar(scip, &newvar) );
/* take care of statistic */
(*naggrvars)++;
*result = SCIP_SUCCESS;
}
}
/* free temporary memory */
SCIPfreeBufferArray(scip, &vars);
return SCIP_OKAY;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecMutation)
{ /*lint --e{715}*/
SCIP_Longint maxnnodes;
SCIP_Longint nsubnodes; /* node limit for the subproblem */
SCIP_HEURDATA* heurdata; /* heuristic's data */
SCIP* subscip; /* the subproblem created by mutation */
SCIP_VAR** vars; /* original problem's variables */
SCIP_VAR** subvars; /* subproblem's variables */
SCIP_HASHMAP* varmapfw; /* mapping of SCIP variables to sub-SCIP variables */
SCIP_Real cutoff; /* objective cutoff for the subproblem */
SCIP_Real maxnnodesr;
SCIP_Real memorylimit;
SCIP_Real timelimit; /* timelimit for the subproblem */
SCIP_Real upperbound;
int nvars; /* number of original problem's variables */
int i;
SCIP_Bool success;
SCIP_RETCODE retcode;
assert( heur != NULL );
assert( scip != NULL );
assert( result != NULL );
/* get heuristic's data */
heurdata = SCIPheurGetData(heur);
assert( heurdata != NULL );
*result = SCIP_DELAYED;
/* only call heuristic, if feasible solution is available */
if( SCIPgetNSols(scip) <= 0 )
return SCIP_OKAY;
/* only call heuristic, if the best solution comes from transformed problem */
assert( SCIPgetBestSol(scip) != NULL );
if( SCIPsolIsOriginal(SCIPgetBestSol(scip)) )
return SCIP_OKAY;
/* only call heuristic, if enough nodes were processed since last incumbent */
if( SCIPgetNNodes(scip) - SCIPgetSolNodenum(scip,SCIPgetBestSol(scip)) < heurdata->nwaitingnodes)
return SCIP_OKAY;
*result = SCIP_DIDNOTRUN;
/* only call heuristic, if discrete variables are present */
if( SCIPgetNBinVars(scip) == 0 && SCIPgetNIntVars(scip) == 0 )
return SCIP_OKAY;
/* calculate the maximal number of branching nodes until heuristic is aborted */
maxnnodesr = heurdata->nodesquot * SCIPgetNNodes(scip);
/* reward mutation if it succeeded often, count the setup costs for the sub-MIP as 100 nodes */
maxnnodesr *= 1.0 + 2.0 * (SCIPheurGetNBestSolsFound(heur)+1.0)/(SCIPheurGetNCalls(heur) + 1.0);
maxnnodes = (SCIP_Longint) maxnnodesr - 100 * SCIPheurGetNCalls(heur);
maxnnodes += heurdata->nodesofs;
/* determine the node limit for the current process */
nsubnodes = maxnnodes - heurdata->usednodes;
nsubnodes = MIN(nsubnodes, heurdata->maxnodes);
/* check whether we have enough nodes left to call subproblem solving */
if( nsubnodes < heurdata->minnodes )
return SCIP_OKAY;
if( SCIPisStopped(scip) )
return SCIP_OKAY;
*result = SCIP_DIDNOTFIND;
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, NULL, NULL, NULL, NULL) );
/* initializing the subproblem */
SCIP_CALL( SCIPallocBufferArray(scip, &subvars, nvars) );
SCIP_CALL( SCIPcreate(&subscip) );
/* create the variable mapping hash map */
SCIP_CALL( SCIPhashmapCreate(&varmapfw, SCIPblkmem(subscip), SCIPcalcHashtableSize(5 * nvars)) );
if( heurdata->uselprows )
{
char probname[SCIP_MAXSTRLEN];
/* copy all plugins */
SCIP_CALL( SCIPincludeDefaultPlugins(subscip) );
/* get name of the original problem and add the string "_mutationsub" */
(void) SCIPsnprintf(probname, SCIP_MAXSTRLEN, "%s_mutationsub", SCIPgetProbName(scip));
/* create the subproblem */
SCIP_CALL( SCIPcreateProb(subscip, probname, NULL, NULL, NULL, NULL, NULL, NULL, NULL) );
/* copy all variables */
SCIP_CALL( SCIPcopyVars(scip, subscip, varmapfw, NULL, TRUE) );
}
else
{
SCIP_Bool valid;
valid = FALSE;
SCIP_CALL( SCIPcopy(scip, subscip, varmapfw, NULL, "rens", TRUE, FALSE, TRUE, &valid) );
if( heurdata->copycuts )
{
/* copies all active cuts from cutpool of sourcescip to linear constraints in targetscip */
SCIP_CALL( SCIPcopyCuts(scip, subscip, varmapfw, NULL, TRUE, NULL) );
}
SCIPdebugMessage("Copying the SCIP instance was %s complete.\n", valid ? "" : "not ");
}
for( i = 0; i < nvars; i++ )
subvars[i] = (SCIP_VAR*) SCIPhashmapGetImage(varmapfw, vars[i]);
/* free hash map */
SCIPhashmapFree(&varmapfw);
/* create a new problem, which fixes variables with same value in bestsol and LP relaxation */
SCIP_CALL( createSubproblem(scip, subscip, subvars, heurdata->minfixingrate, &heurdata->randseed, heurdata->uselprows) );
/* do not abort subproblem on CTRL-C */
SCIP_CALL( SCIPsetBoolParam(subscip, "misc/catchctrlc", FALSE) );
/* disable output to console */
SCIP_CALL( SCIPsetIntParam(subscip, "display/verblevel", 0) );
/* check whether there is enough time and memory left */
SCIP_CALL( SCIPgetRealParam(scip, "limits/time", &timelimit) );
if( !SCIPisInfinity(scip, timelimit) )
timelimit -= SCIPgetSolvingTime(scip);
SCIP_CALL( SCIPgetRealParam(scip, "limits/memory", &memorylimit) );
/* substract the memory already used by the main SCIP and the estimated memory usage of external software */
if( !SCIPisInfinity(scip, memorylimit) )
{
memorylimit -= SCIPgetMemUsed(scip)/1048576.0;
memorylimit -= SCIPgetMemExternEstim(scip)/1048576.0;
}
/* abort if no time is left or not enough memory to create a copy of SCIP, including external memory usage */
if( timelimit <= 0.0 || memorylimit <= 2.0*SCIPgetMemExternEstim(scip)/1048576.0 )
goto TERMINATE;
/* set limits for the subproblem */
SCIP_CALL( SCIPsetLongintParam(subscip, "limits/nodes", nsubnodes) );
SCIP_CALL( SCIPsetRealParam(subscip, "limits/time", timelimit) );
SCIP_CALL( SCIPsetRealParam(subscip, "limits/memory", memorylimit) );
/* forbid recursive call of heuristics and separators solving subMIPs */
SCIP_CALL( SCIPsetSubscipsOff(subscip, TRUE) );
/* disable cutting plane separation */
SCIP_CALL( SCIPsetSeparating(subscip, SCIP_PARAMSETTING_OFF, TRUE) );
/* disable expensive presolving */
SCIP_CALL( SCIPsetPresolving(subscip, SCIP_PARAMSETTING_FAST, TRUE) );
/* use best estimate node selection */
if( SCIPfindNodesel(subscip, "estimate") != NULL && !SCIPisParamFixed(subscip, "nodeselection/estimate/stdpriority") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "nodeselection/estimate/stdpriority", INT_MAX/4) );
}
/* use inference branching */
if( SCIPfindBranchrule(subscip, "inference") != NULL && !SCIPisParamFixed(subscip, "branching/inference/priority") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "branching/inference/priority", INT_MAX/4) );
}
/* disable conflict analysis */
if( !SCIPisParamFixed(subscip, "conflict/useprop") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/useprop", FALSE) );
}
if( !SCIPisParamFixed(subscip, "conflict/useinflp") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/useinflp", FALSE) );
}
if( !SCIPisParamFixed(subscip, "conflict/useboundlp") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/useboundlp", FALSE) );
}
if( !SCIPisParamFixed(subscip, "conflict/usesb") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/usesb", FALSE) );
}
if( !SCIPisParamFixed(subscip, "conflict/usepseudo") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/usepseudo", FALSE) );
}
/* employ a limit on the number of enforcement rounds in the quadratic constraint handlers; this fixes the issue that
* sometimes the quadratic constraint handler needs hundreds or thousands of enforcement rounds to determine the
* feasibility status of a single node without fractional branching candidates by separation (namely for uflquad
* instances); however, the solution status of the sub-SCIP might get corrupted by this; hence no decutions shall be
* made for the original SCIP
*/
if( SCIPfindConshdlr(subscip, "quadratic") != NULL && !SCIPisParamFixed(subscip, "constraints/quadratic/enfolplimit") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "constraints/quadratic/enfolplimit", 10) );
}
/* add an objective cutoff */
cutoff = SCIPinfinity(scip);
assert( !SCIPisInfinity(scip, SCIPgetUpperbound(scip)) );
upperbound = SCIPgetUpperbound(scip) - SCIPsumepsilon(scip);
if( !SCIPisInfinity(scip, -1.0 * SCIPgetLowerbound(scip)) )
{
cutoff = (1-heurdata->minimprove) * SCIPgetUpperbound(scip) + heurdata->minimprove * SCIPgetLowerbound(scip);
}
else
{
if( SCIPgetUpperbound ( scip ) >= 0 )
cutoff = ( 1 - heurdata->minimprove ) * SCIPgetUpperbound ( scip );
else
cutoff = ( 1 + heurdata->minimprove ) * SCIPgetUpperbound ( scip );
}
cutoff = MIN(upperbound, cutoff );
SCIP_CALL( SCIPsetObjlimit(subscip, cutoff) );
/* solve the subproblem */
SCIPdebugMessage("Solve Mutation subMIP\n");
retcode = SCIPsolve(subscip);
/* Errors in solving the subproblem should not kill the overall solving process
* Hence, the return code is caught and a warning is printed, only in debug mode, SCIP will stop.
*/
if( retcode != SCIP_OKAY )
{
#ifndef NDEBUG
SCIP_CALL( retcode );
#endif
SCIPwarningMessage(scip, "Error while solving subproblem in Mutation heuristic; sub-SCIP terminated with code <%d>\n",retcode);
}
heurdata->usednodes += SCIPgetNNodes(subscip);
/* check, whether a solution was found */
if( SCIPgetNSols(subscip) > 0 )
{
SCIP_SOL** subsols;
int nsubsols;
/* check, whether a solution was found;
* due to numerics, it might happen that not all solutions are feasible -> try all solutions until one was accepted
*/
nsubsols = SCIPgetNSols(subscip);
subsols = SCIPgetSols(subscip);
success = FALSE;
for( i = 0; i < nsubsols && !success; ++i )
{
SCIP_CALL( createNewSol(scip, subscip, subvars, heur, subsols[i], &success) );
}
if( success )
*result = SCIP_FOUNDSOL;
}
TERMINATE:
/* free subproblem */
SCIPfreeBufferArray(scip, &subvars);
SCIP_CALL( SCIPfree(&subscip) );
return SCIP_OKAY;
}
/** add branching decisions constraints to the sub SCIP */
static
SCIP_RETCODE addBranchingDecisionConss(
SCIP* scip, /**< SCIP data structure */
SCIP* subscip, /**< pricing SCIP data structure */
SCIP_VAR** vars, /**< variable array of the subscuip oder variables */
SCIP_CONSHDLR* conshdlr /**< constraint handler for branching data */
)
{
SCIP_CONS** conss;
SCIP_CONS* cons;
int nconss;
int id1;
int id2;
CONSTYPE type;
SCIP_Real vbdcoef;
SCIP_Real lhs;
SCIP_Real rhs;
int c;
assert( scip != NULL );
assert( subscip != NULL );
assert( conshdlr != NULL );
/* collect all branching decision constraints */
conss = SCIPconshdlrGetConss(conshdlr);
nconss = SCIPconshdlrGetNConss(conshdlr);
/* loop over all branching decision constraints and apply the branching decision if the corresponding constraint is
* active
*/
for( c = 0; c < nconss; ++c )
{
cons = conss[c];
/* ignore constraints which are not active since these are not laying on the current active path of the search
* tree
*/
if( !SCIPconsIsActive(cons) )
continue;
/* collect the two item ids and the branching type (SAME or DIFFER) on which the constraint branched */
id1 = SCIPgetItemid1Samediff(scip, cons);
id2 = SCIPgetItemid2Samediff(scip, cons);
type = SCIPgetTypeSamediff(scip, cons);
SCIPdebugMessage("create varbound for %s(%d,%d)\n", type == SAME ? "same" : "diff",
SCIPprobdataGetIds(SCIPgetProbData(scip))[id1], SCIPprobdataGetIds(SCIPgetProbData(scip))[id2]);
/* depending on the branching type select the correct left and right hand side for the linear constraint which
* enforces this branching decision in the pricing problem MIP
*/
if( type == SAME )
{
lhs = 0.0;
rhs = 0.0;
vbdcoef = -1.0;
}
else if( type == DIFFER )
{
lhs = -SCIPinfinity(scip);
rhs = 1.0;
vbdcoef = 1.0;
}
else
{
SCIPerrorMessage("unknow constraint type <%d>\n, type");
return SCIP_INVALIDDATA;
}
/* add linear (in that case a variable bound) constraint to pricing MIP depending on the branching type:
*
* - branching type SAME: x1 = x2 <=> x1 - x2 = 0 <=> 0 <= x1 - x2 <= 0
*
* - branching type DIFFER: x1 - x2 <= 1 <=> -inf <= x1 - x2 <= 1
*
*/
SCIP_CALL( SCIPcreateConsBasicVarbound(subscip, &cons, SCIPconsGetName(conss[c]),
vars[id1], vars[id2], vbdcoef, lhs, rhs) );
SCIPdebug( SCIPprintCons(subscip, cons, NULL) );
SCIP_CALL( SCIPaddCons(subscip, cons) );
SCIP_CALL( SCIPreleaseCons(subscip, &cons) );
}
return SCIP_OKAY;
}
/** node selection method of node selector */
static
SCIP_DECL_NODESELSELECT(nodeselSelectBfs)
{ /*lint --e{715}*/
SCIP_NODESELDATA* nodeseldata;
int minplungedepth;
int maxplungedepth;
int plungedepth;
SCIP_Real maxplungequot;
assert(nodesel != NULL);
assert(strcmp(SCIPnodeselGetName(nodesel), NODESEL_NAME) == 0);
assert(scip != NULL);
assert(selnode != NULL);
*selnode = NULL;
/* get node selector user data */
nodeseldata = SCIPnodeselGetData(nodesel);
assert(nodeseldata != NULL);
/* calculate minimal and maximal plunging depth */
minplungedepth = nodeseldata->minplungedepth;
maxplungedepth = nodeseldata->maxplungedepth;
maxplungequot = nodeseldata->maxplungequot;
if( minplungedepth == -1 )
{
minplungedepth = SCIPgetMaxDepth(scip)/10;
if( SCIPgetNStrongbranchLPIterations(scip) > 2*SCIPgetNNodeLPIterations(scip) )
minplungedepth += 10;
if( maxplungedepth >= 0 )
minplungedepth = MIN(minplungedepth, maxplungedepth);
}
if( maxplungedepth == -1 )
maxplungedepth = SCIPgetMaxDepth(scip)/2;
maxplungedepth = MAX(maxplungedepth, minplungedepth);
/* check, if we exceeded the maximal plunging depth */
plungedepth = SCIPgetPlungeDepth(scip);
if( plungedepth > maxplungedepth )
{
/* we don't want to plunge again: select best node from the tree */
SCIPdebugMessage("plungedepth: [%d,%d], cur: %d -> abort plunging\n", minplungedepth, maxplungedepth, plungedepth);
*selnode = SCIPgetBestNode(scip);
SCIPdebugMessage(" -> best node : lower=%g\n",
*selnode != NULL ? SCIPnodeGetLowerbound(*selnode) : SCIPinfinity(scip));
}
else
{
SCIP_NODE* node;
SCIP_Real maxbound;
/* check, if plunging is forced at the current depth */
if( plungedepth < minplungedepth )
{
maxbound = SCIPinfinity(scip);
SCIPdebugMessage("plungedepth: [%d,%d], cur: %d => maxbound: infinity\n",
minplungedepth, maxplungedepth, plungedepth);
}
else
{
SCIP_Real lowerbound;
SCIP_Real cutoffbound;
/* get global lower and cutoff bound */
lowerbound = SCIPgetLowerbound(scip);
cutoffbound = SCIPgetCutoffbound(scip);
/* if we didn't find a solution yet, the cutoff bound is usually very bad:
* use only 20% of the gap as cutoff bound
*/
if( SCIPgetNSolsFound(scip) == 0 )
cutoffbound = lowerbound + 0.2 * (cutoffbound - lowerbound);
/* calculate maximal plunging bound */
maxbound = lowerbound + maxplungequot * (cutoffbound - lowerbound);
SCIPdebugMessage("plungedepth: [%d,%d], cur: %d, bounds: [%g,%g], maxbound: %g\n",
minplungedepth, maxplungedepth, plungedepth, lowerbound, cutoffbound, maxbound);
}
/* we want to plunge again: prefer children over siblings, and siblings over leaves,
* but only select a child or sibling, if its dual bound is small enough;
* prefer using nodes with higher node selection priority assigned by the branching rule
*/
node = SCIPgetPrioChild(scip);
if( node != NULL && SCIPnodeGetLowerbound(node) < maxbound )
{
*selnode = node;
SCIPdebugMessage(" -> selected prio child: lower=%g\n", SCIPnodeGetLowerbound(*selnode));
}
else
{
node = SCIPgetBestChild(scip);
if( node != NULL && SCIPnodeGetLowerbound(node) < maxbound )
{
*selnode = node;
SCIPdebugMessage(" -> selected best child: lower=%g\n", SCIPnodeGetLowerbound(*selnode));
}
else
{
node = SCIPgetPrioSibling(scip);
if( node != NULL && SCIPnodeGetLowerbound(node) < maxbound )
{
*selnode = node;
SCIPdebugMessage(" -> selected prio sibling: lower=%g\n", SCIPnodeGetLowerbound(*selnode));
}
else
{
node = SCIPgetBestSibling(scip);
if( node != NULL && SCIPnodeGetLowerbound(node) < maxbound )
{
*selnode = node;
SCIPdebugMessage(" -> selected best sibling: lower=%g\n", SCIPnodeGetLowerbound(*selnode));
}
else
{
*selnode = SCIPgetBestNode(scip);
SCIPdebugMessage(" -> selected best leaf: lower=%g\n",
*selnode != NULL ? SCIPnodeGetLowerbound(*selnode) : SCIPinfinity(scip));
}
}
}
}
}
return SCIP_OKAY;
}
/** add a cut */
static
SCIP_RETCODE cut_add(
SCIP* scip, /**< SCIP data structure */
SCIP_CONSHDLR* conshdlr, /**< constraint handler */
const GRAPH* g, /**< graph data structure */
const int layer, /**< current layer, set to zero usually */
const SCIP_Real* xval, /**< edge values */
int* capa, /**< edges capacities (scaled) */
const int updatecapa, /**< update capacities? */
int* ncuts, /**< pointer to store number of cuts */
SCIP_Bool* success /**< pointer to store whether add cut be added */
)
{
SCIP_ROW* row;
SCIP_VAR** vars = SCIPprobdataGetVars(scip);
SCIP_Real sum = 0.0;
SCIP_Bool inccapa = FALSE;
int i;
int ind;
(*success) = FALSE;
assert(scip != NULL);
assert(g != NULL);
assert((layer >= 0) && (layer < g->layers));
SCIP_CALL( SCIPcreateEmptyRowCons(scip, &row, conshdlr, "2cut", 1.0, SCIPinfinity(scip), FALSE, FALSE, TRUE) );
SCIP_CALL( SCIPcacheRowExtensions(scip, row) );
for( i = 0; i < g->edges; i++ )
{
if( (g->mark[g->source[layer]] == g->mark[g->tail[i]])
&& (g->mark[g->tail[i]] != g->mark[g->head[i]]) )
{
ind = layer * g->edges + i;
if( updatecapa )
{
if( capa[i] < FLOW_FACTOR )
inccapa = TRUE;
SCIPdebugMessage("set capa[%d] from %6d to %6d\n", i, capa[i], FLOW_FACTOR);
capa[i] = FLOW_FACTOR;
if( !inccapa )
{
SCIP_CALL( SCIPflushRowExtensions(scip, row) );
SCIP_CALL( SCIPreleaseRow(scip, &row) );
return SCIP_OKAY;
}
}
if( xval != NULL )
{
sum += xval[ind];
if( SCIPisFeasGE(scip, sum, 1.0) )
{
SCIP_CALL( SCIPflushRowExtensions(scip, row) );
SCIP_CALL( SCIPreleaseRow(scip, &row) );
return SCIP_OKAY;
}
}
SCIP_CALL( SCIPaddVarToRow(scip, row, vars[ind], 1.0) );
}
}
assert(sum < 1.0);
SCIP_CALL( SCIPflushRowExtensions(scip, row) );
/* checks, if cut is sufficiently violated */
if( SCIPisCutEfficacious(scip, NULL, row) )
{
SCIP_Bool infeasible;
SCIPdebug( SCIP_CALL( SCIPprintRow(scip, row, NULL) ) );
SCIP_CALL( SCIPaddCut(scip, NULL, row, FALSE, &infeasible) );
(*ncuts)++;
(*success) = TRUE;
}
SCIP_CALL( SCIPreleaseRow(scip, &row) );
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;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecLocalbranching)
{ /*lint --e{715}*/
SCIP_Longint maxnnodes; /* maximum number of subnodes */
SCIP_Longint nsubnodes; /* nodelimit for subscip */
SCIP_HEURDATA* heurdata;
SCIP* subscip; /* the subproblem created by localbranching */
SCIP_VAR** subvars; /* subproblem's variables */
SCIP_SOL* bestsol; /* best solution so far */
SCIP_EVENTHDLR* eventhdlr; /* event handler for LP events */
SCIP_Real timelimit; /* timelimit for subscip (equals remaining time of scip) */
SCIP_Real cutoff; /* objective cutoff for the subproblem */
SCIP_Real upperbound;
SCIP_Real memorylimit;
SCIP_HASHMAP* varmapfw; /* mapping of SCIP variables to sub-SCIP variables */
SCIP_VAR** vars;
int nvars;
int i;
SCIP_Bool success;
SCIP_RETCODE retcode;
assert(heur != NULL);
assert(scip != NULL);
assert(result != NULL);
*result = SCIP_DIDNOTRUN;
/* get heuristic's data */
heurdata = SCIPheurGetData(heur);
assert( heurdata != NULL );
/* there should be enough binary variables that a local branching constraint makes sense */
if( SCIPgetNBinVars(scip) < 2*heurdata->neighborhoodsize )
return SCIP_OKAY;
*result = SCIP_DELAYED;
/* only call heuristic, if an IP solution is at hand */
if( SCIPgetNSols(scip) <= 0 )
return SCIP_OKAY;
bestsol = SCIPgetBestSol(scip);
assert(bestsol != NULL);
/* only call heuristic, if the best solution comes from transformed problem */
if( SCIPsolIsOriginal(bestsol) )
return SCIP_OKAY;
/* only call heuristic, if enough nodes were processed since last incumbent */
if( SCIPgetNNodes(scip) - SCIPgetSolNodenum(scip, bestsol) < heurdata->nwaitingnodes)
return SCIP_OKAY;
/* only call heuristic, if the best solution does not come from trivial heuristic */
if( SCIPsolGetHeur(bestsol) != NULL && strcmp(SCIPheurGetName(SCIPsolGetHeur(bestsol)), "trivial") == 0 )
return SCIP_OKAY;
/* reset neighborhood and minnodes, if new solution was found */
if( heurdata->lastsol != bestsol )
{
heurdata->curneighborhoodsize = heurdata->neighborhoodsize;
heurdata->curminnodes = heurdata->minnodes;
heurdata->emptyneighborhoodsize = 0;
heurdata->callstatus = EXECUTE;
heurdata->lastsol = bestsol;
}
/* if no new solution was found and local branching also seems to fail, just keep on waiting */
if( heurdata->callstatus == WAITFORNEWSOL )
return SCIP_OKAY;
*result = SCIP_DIDNOTRUN;
/* calculate the maximal number of branching nodes until heuristic is aborted */
maxnnodes = (SCIP_Longint)(heurdata->nodesquot * SCIPgetNNodes(scip));
/* reward local branching if it succeeded often */
maxnnodes = (SCIP_Longint)(maxnnodes * (1.0 + 2.0*(SCIPheurGetNBestSolsFound(heur)+1.0)/(SCIPheurGetNCalls(heur)+1.0)));
maxnnodes -= 100 * SCIPheurGetNCalls(heur); /* count the setup costs for the sub-MIP as 100 nodes */
maxnnodes += heurdata->nodesofs;
/* determine the node limit for the current process */
nsubnodes = maxnnodes - heurdata->usednodes;
nsubnodes = MIN(nsubnodes, heurdata->maxnodes);
/* check whether we have enough nodes left to call sub problem solving */
if( nsubnodes < heurdata->curminnodes )
return SCIP_OKAY;
if( SCIPisStopped(scip) )
return SCIP_OKAY;
*result = SCIP_DIDNOTFIND;
SCIPdebugMessage("running localbranching heuristic ...\n");
/* get the data of the variables and the best solution */
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, NULL, NULL, NULL, NULL) );
/* initializing the subproblem */
SCIP_CALL( SCIPallocBufferArray(scip, &subvars, nvars) );
SCIP_CALL( SCIPcreate(&subscip) );
/* create the variable mapping hash map */
SCIP_CALL( SCIPhashmapCreate(&varmapfw, SCIPblkmem(subscip), SCIPcalcHashtableSize(5 * nvars)) );
success = FALSE;
eventhdlr = NULL;
if( heurdata->uselprows )
{
char probname[SCIP_MAXSTRLEN];
/* copy all plugins */
SCIP_CALL( SCIPincludeDefaultPlugins(subscip) );
/* get name of the original problem and add the string "_localbranchsub" */
(void) SCIPsnprintf(probname, SCIP_MAXSTRLEN, "%s_localbranchsub", SCIPgetProbName(scip));
/* create the subproblem */
SCIP_CALL( SCIPcreateProb(subscip, probname, NULL, NULL, NULL, NULL, NULL, NULL, NULL) );
/* copy all variables */
SCIP_CALL( SCIPcopyVars(scip, subscip, varmapfw, NULL, TRUE) );
}
else
{
SCIP_CALL( SCIPcopy(scip, subscip, varmapfw, NULL, "localbranchsub", TRUE, FALSE, TRUE, &success) );
if( heurdata->copycuts )
{
/* copies all active cuts from cutpool of sourcescip to linear constraints in targetscip */
SCIP_CALL( SCIPcopyCuts(scip, subscip, varmapfw, NULL, TRUE, NULL) );
}
/* create event handler for LP events */
SCIP_CALL( SCIPincludeEventhdlrBasic(subscip, &eventhdlr, EVENTHDLR_NAME, EVENTHDLR_DESC, eventExecLocalbranching, NULL) );
if( eventhdlr == NULL )
{
SCIPerrorMessage("event handler for "HEUR_NAME" heuristic not found.\n");
return SCIP_PLUGINNOTFOUND;
}
}
SCIPdebugMessage("Copying the plugins was %ssuccessful.\n", success ? "" : "not ");
for (i = 0; i < nvars; ++i)
subvars[i] = (SCIP_VAR*) SCIPhashmapGetImage(varmapfw, vars[i]);
/* free hash map */
SCIPhashmapFree(&varmapfw);
/* if the subproblem could not be created, free memory and return */
if( !success )
{
*result = SCIP_DIDNOTRUN;
goto TERMINATE;
}
/* do not abort subproblem on CTRL-C */
SCIP_CALL( SCIPsetBoolParam(subscip, "misc/catchctrlc", FALSE) );
#ifndef SCIP_DEBUG
/* disable output to console */
SCIP_CALL( SCIPsetIntParam(subscip, "display/verblevel", 0) );
#endif
/* check whether there is enough time and memory left */
SCIP_CALL( SCIPgetRealParam(scip, "limits/time", &timelimit) );
if( !SCIPisInfinity(scip, timelimit) )
timelimit -= SCIPgetSolvingTime(scip);
SCIP_CALL( SCIPgetRealParam(scip, "limits/memory", &memorylimit) );
/* substract the memory already used by the main SCIP and the estimated memory usage of external software */
if( !SCIPisInfinity(scip, memorylimit) )
{
memorylimit -= SCIPgetMemUsed(scip)/1048576.0;
memorylimit -= SCIPgetMemExternEstim(scip)/1048576.0;
}
/* abort if no time is left or not enough memory to create a copy of SCIP, including external memory usage */
if( timelimit <= 0.0 || memorylimit <= 2.0*SCIPgetMemExternEstim(scip)/1048576.0 )
goto TERMINATE;
/* set limits for the subproblem */
heurdata->nodelimit = nsubnodes;
SCIP_CALL( SCIPsetLongintParam(subscip, "limits/nodes", nsubnodes) );
SCIP_CALL( SCIPsetLongintParam(subscip, "limits/stallnodes", MAX(10, nsubnodes/10)) );
SCIP_CALL( SCIPsetIntParam(subscip, "limits/bestsol", 3) );
SCIP_CALL( SCIPsetRealParam(subscip, "limits/time", timelimit) );
SCIP_CALL( SCIPsetRealParam(subscip, "limits/memory", memorylimit) );
/* forbid recursive call of heuristics and separators solving subMIPs */
SCIP_CALL( SCIPsetSubscipsOff(subscip, TRUE) );
/* disable cutting plane separation */
SCIP_CALL( SCIPsetSeparating(subscip, SCIP_PARAMSETTING_OFF, TRUE) );
/* disable expensive presolving */
SCIP_CALL( SCIPsetPresolving(subscip, SCIP_PARAMSETTING_FAST, TRUE) );
/* use best estimate node selection */
if( SCIPfindNodesel(subscip, "estimate") != NULL && !SCIPisParamFixed(subscip, "nodeselection/estimate/stdpriority") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "nodeselection/estimate/stdpriority", INT_MAX/4) );
}
/* use inference branching */
if( SCIPfindBranchrule(subscip, "inference") != NULL && !SCIPisParamFixed(subscip, "branching/inference/priority") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "branching/inference/priority", INT_MAX/4) );
}
/* disable conflict analysis */
if( !SCIPisParamFixed(subscip, "conflict/useprop") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/useprop", FALSE) );
}
if( !SCIPisParamFixed(subscip, "conflict/useinflp") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/useinflp", FALSE) );
}
if( !SCIPisParamFixed(subscip, "conflict/useboundlp") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/useboundlp", FALSE) );
}
if( !SCIPisParamFixed(subscip, "conflict/usesb") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/usesb", FALSE) );
}
if( !SCIPisParamFixed(subscip, "conflict/usepseudo") )
{
SCIP_CALL( SCIPsetBoolParam(subscip, "conflict/usepseudo", FALSE) );
}
/* employ a limit on the number of enforcement rounds in the quadratic constraint handler; this fixes the issue that
* sometimes the quadratic constraint handler needs hundreds or thousands of enforcement rounds to determine the
* feasibility status of a single node without fractional branching candidates by separation (namely for uflquad
* instances); however, the solution status of the sub-SCIP might get corrupted by this; hence no deductions shall be
* made for the original SCIP
*/
if( SCIPfindConshdlr(subscip, "quadratic") != NULL && !SCIPisParamFixed(subscip, "constraints/quadratic/enfolplimit") )
{
SCIP_CALL( SCIPsetIntParam(subscip, "constraints/quadratic/enfolplimit", 500) );
}
/* copy the original problem and add the local branching constraint */
if( heurdata->uselprows )
{
SCIP_CALL( createSubproblem(scip, subscip, subvars) );
}
SCIP_CALL( addLocalBranchingConstraint(scip, subscip, subvars, heurdata) );
/* add an objective cutoff */
cutoff = SCIPinfinity(scip);
assert( !SCIPisInfinity(scip,SCIPgetUpperbound(scip)) );
upperbound = SCIPgetUpperbound(scip) - SCIPsumepsilon(scip);
if( !SCIPisInfinity(scip,-1.0*SCIPgetLowerbound(scip)) )
{
cutoff = (1-heurdata->minimprove)*SCIPgetUpperbound(scip) + heurdata->minimprove*SCIPgetLowerbound(scip);
}
else
{
if( SCIPgetUpperbound ( scip ) >= 0 )
cutoff = ( 1 - heurdata->minimprove ) * SCIPgetUpperbound ( scip );
else
cutoff = ( 1 + heurdata->minimprove ) * SCIPgetUpperbound ( scip );
}
cutoff = MIN(upperbound, cutoff );
SCIP_CALL( SCIPsetObjlimit(subscip, cutoff) );
/* catch LP events of sub-SCIP */
if( !heurdata->uselprows )
{
assert(eventhdlr != NULL);
SCIP_CALL( SCIPtransformProb(subscip) );
SCIP_CALL( SCIPcatchEvent(subscip, SCIP_EVENTTYPE_LPSOLVED, eventhdlr, (SCIP_EVENTDATA*) heurdata, NULL) );
}
/* solve the subproblem */
SCIPdebugMessage("solving local branching subproblem with neighborhoodsize %d and maxnodes %"SCIP_LONGINT_FORMAT"\n",
heurdata->curneighborhoodsize, nsubnodes);
retcode = SCIPsolve(subscip);
/* drop LP events of sub-SCIP */
if( !heurdata->uselprows )
{
assert(eventhdlr != NULL);
SCIP_CALL( SCIPdropEvent(subscip, SCIP_EVENTTYPE_LPSOLVED, eventhdlr, (SCIP_EVENTDATA*) heurdata, -1) );
}
/* Errors in solving the subproblem should not kill the overall solving process
* Hence, the return code is caught and a warning is printed, only in debug mode, SCIP will stop.
*/
if( retcode != SCIP_OKAY )
{
#ifndef NDEBUG
SCIP_CALL( retcode );
#endif
SCIPwarningMessage(scip, "Error while solving subproblem in local branching heuristic; sub-SCIP terminated with code <%d>\n",retcode);
}
/* print solving statistics of subproblem if we are in SCIP's debug mode */
SCIPdebug( SCIP_CALL( SCIPprintStatistics(subscip, NULL) ) );
heurdata->usednodes += SCIPgetNNodes(subscip);
SCIPdebugMessage("local branching used %"SCIP_LONGINT_FORMAT"/%"SCIP_LONGINT_FORMAT" nodes\n",
SCIPgetNNodes(subscip), nsubnodes);
/* check, whether a solution was found */
if( SCIPgetNSols(subscip) > 0 )
{
SCIP_SOL** subsols;
int nsubsols;
/* check, whether a solution was found;
* due to numerics, it might happen that not all solutions are feasible -> try all solutions until one was accepted
*/
nsubsols = SCIPgetNSols(subscip);
subsols = SCIPgetSols(subscip);
success = FALSE;
for( i = 0; i < nsubsols && !success; ++i )
{
SCIP_CALL( createNewSol(scip, subscip, subvars, heur, subsols[i], &success) );
}
if( success )
{
SCIPdebugMessage("-> accepted solution of value %g\n", SCIPgetSolOrigObj(subscip, subsols[i]));
*result = SCIP_FOUNDSOL;
}
}
/* check the status of the sub-MIP */
switch( SCIPgetStatus(subscip) )
{
case SCIP_STATUS_OPTIMAL:
case SCIP_STATUS_BESTSOLLIMIT:
heurdata->callstatus = WAITFORNEWSOL; /* new solution will immediately be installed at next call */
SCIPdebugMessage(" -> found new solution\n");
break;
case SCIP_STATUS_NODELIMIT:
case SCIP_STATUS_STALLNODELIMIT:
case SCIP_STATUS_TOTALNODELIMIT:
heurdata->callstatus = EXECUTE;
heurdata->curneighborhoodsize = (heurdata->emptyneighborhoodsize + heurdata->curneighborhoodsize)/2;
heurdata->curminnodes *= 2;
SCIPdebugMessage(" -> node limit reached: reduced neighborhood to %d, increased minnodes to %d\n",
heurdata->curneighborhoodsize, heurdata->curminnodes);
if( heurdata->curneighborhoodsize <= heurdata->emptyneighborhoodsize )
{
heurdata->callstatus = WAITFORNEWSOL;
SCIPdebugMessage(" -> new neighborhood was already proven to be empty: wait for new solution\n");
}
break;
case SCIP_STATUS_INFEASIBLE:
case SCIP_STATUS_INFORUNBD:
heurdata->emptyneighborhoodsize = heurdata->curneighborhoodsize;
heurdata->curneighborhoodsize += heurdata->curneighborhoodsize/2;
heurdata->curneighborhoodsize = MAX(heurdata->curneighborhoodsize, heurdata->emptyneighborhoodsize + 2);
heurdata->callstatus = EXECUTE;
SCIPdebugMessage(" -> neighborhood is empty: increased neighborhood to %d\n", heurdata->curneighborhoodsize);
break;
case SCIP_STATUS_UNKNOWN:
case SCIP_STATUS_USERINTERRUPT:
case SCIP_STATUS_TIMELIMIT:
case SCIP_STATUS_MEMLIMIT:
case SCIP_STATUS_GAPLIMIT:
case SCIP_STATUS_SOLLIMIT:
case SCIP_STATUS_UNBOUNDED:
default:
heurdata->callstatus = WAITFORNEWSOL;
SCIPdebugMessage(" -> unexpected sub-MIP status <%d>: waiting for new solution\n", SCIPgetStatus(subscip));
break;
}
TERMINATE:
/* free subproblem */
SCIPfreeBufferArray(scip, &subvars);
SCIP_CALL( SCIPfree(&subscip) );
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;
}
/** 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;
}
/** returns a variable, that pushes activity of the row in the given direction with minimal negative impact on other rows;
* if variables have equal impact, chooses the one with best objective value improvement in corresponding direction;
* rounding in a direction is forbidden, if this forces the objective value over the upper bound
*/
static
SCIP_RETCODE selectRounding(
SCIP* scip, /**< SCIP data structure */
SCIP_SOL* sol, /**< primal solution */
SCIP_Real minobj, /**< minimal objective value possible after rounding remaining fractional vars */
SCIP_ROW* row, /**< LP row */
int direction, /**< should the activity be increased (+1) or decreased (-1)? */
SCIP_VAR** roundvar, /**< pointer to store the rounding variable, returns NULL if impossible */
SCIP_Real* oldsolval, /**< pointer to store old (fractional) solution value of rounding variable */
SCIP_Real* newsolval /**< pointer to store new (rounded) solution value of rounding variable */
)
{
SCIP_COL* col;
SCIP_VAR* var;
SCIP_Real val;
SCIP_COL** rowcols;
SCIP_Real* rowvals;
SCIP_Real solval;
SCIP_Real roundval;
SCIP_Real obj;
SCIP_Real deltaobj;
SCIP_Real bestdeltaobj;
SCIP_VARTYPE vartype;
int nrowcols;
int nlocks;
int minnlocks;
int c;
assert(direction == +1 || direction == -1);
assert(roundvar != NULL);
assert(oldsolval != NULL);
assert(newsolval != NULL);
/* get row entries */
rowcols = SCIProwGetCols(row);
rowvals = SCIProwGetVals(row);
nrowcols = SCIProwGetNLPNonz(row);
/* select rounding variable */
minnlocks = INT_MAX;
bestdeltaobj = SCIPinfinity(scip);
*roundvar = NULL;
for( c = 0; c < nrowcols; ++c )
{
col = rowcols[c];
var = SCIPcolGetVar(col);
vartype = SCIPvarGetType(var);
if( vartype == SCIP_VARTYPE_BINARY || vartype == SCIP_VARTYPE_INTEGER )
{
solval = SCIPgetSolVal(scip, sol, var);
if( !SCIPisFeasIntegral(scip, solval) )
{
val = rowvals[c];
obj = SCIPvarGetObj(var);
if( direction * val < 0.0 )
{
/* rounding down */
nlocks = SCIPvarGetNLocksDown(var);
if( nlocks <= minnlocks )
{
roundval = SCIPfeasFloor(scip, solval);
deltaobj = obj * (roundval - solval);
if( (nlocks < minnlocks || deltaobj < bestdeltaobj) && minobj - obj < SCIPgetCutoffbound(scip) )
{
minnlocks = nlocks;
bestdeltaobj = deltaobj;
*roundvar = var;
*oldsolval = solval;
*newsolval = roundval;
}
}
}
else
{
/* rounding up */
assert(direction * val > 0.0);
nlocks = SCIPvarGetNLocksUp(var);
if( nlocks <= minnlocks )
{
roundval = SCIPfeasCeil(scip, solval);
deltaobj = obj * (roundval - solval);
if( (nlocks < minnlocks || deltaobj < bestdeltaobj) && minobj + obj < SCIPgetCutoffbound(scip) )
{
minnlocks = nlocks;
bestdeltaobj = deltaobj;
*roundvar = var;
*oldsolval = solval;
*newsolval = roundval;
}
}
}
}
}
}
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;
}
/** LP solution separation method of separator */
static
SCIP_DECL_SEPAEXECLP(sepaExeclpGomory)
{ /*lint --e{715}*/
SCIP_SEPADATA* sepadata;
SCIP_VAR** vars;
SCIP_COL** cols;
SCIP_ROW** rows;
SCIP_Real* binvrow;
SCIP_Real* cutcoefs;
SCIP_Real maxscale;
SCIP_Real minfrac;
SCIP_Real maxfrac;
SCIP_Longint maxdnom;
SCIP_Bool cutoff;
int* basisind;
int naddedcuts;
int nvars;
int ncols;
int nrows;
int ncalls;
int depth;
int maxdepth;
int maxsepacuts;
int c;
int i;
assert(sepa != NULL);
assert(strcmp(SCIPsepaGetName(sepa), SEPA_NAME) == 0);
assert(scip != NULL);
assert(result != NULL);
*result = SCIP_DIDNOTRUN;
sepadata = SCIPsepaGetData(sepa);
assert(sepadata != NULL);
depth = SCIPgetDepth(scip);
ncalls = SCIPsepaGetNCallsAtNode(sepa);
minfrac = sepadata->away;
maxfrac = 1.0 - sepadata->away;
/* only call separator, if we are not close to terminating */
if( SCIPisStopped(scip) )
return SCIP_OKAY;
/* only call the gomory cut separator a given number of times at each node */
if( (depth == 0 && sepadata->maxroundsroot >= 0 && ncalls >= sepadata->maxroundsroot)
|| (depth > 0 && sepadata->maxrounds >= 0 && ncalls >= sepadata->maxrounds) )
return SCIP_OKAY;
/* only call separator, if an optimal LP solution is at hand */
if( SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
return SCIP_OKAY;
/* only call separator, if the LP solution is basic */
if( !SCIPisLPSolBasic(scip) )
return SCIP_OKAY;
/* only call separator, if there are fractional variables */
if( SCIPgetNLPBranchCands(scip) == 0 )
return SCIP_OKAY;
/* get variables data */
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, NULL, NULL, NULL, NULL) );
/* get LP data */
SCIP_CALL( SCIPgetLPColsData(scip, &cols, &ncols) );
SCIP_CALL( SCIPgetLPRowsData(scip, &rows, &nrows) );
if( ncols == 0 || nrows == 0 )
return SCIP_OKAY;
#if 0 /* if too many columns, separator is usually very slow: delay it until no other cuts have been found */
if( ncols >= 50*nrows )
return SCIP_OKAY;
if( ncols >= 5*nrows )
{
int ncutsfound;
ncutsfound = SCIPgetNCutsFound(scip);
if( ncutsfound > sepadata->lastncutsfound || !SCIPsepaWasLPDelayed(sepa) )
{
sepadata->lastncutsfound = ncutsfound;
*result = SCIP_DELAYED;
return SCIP_OKAY;
}
}
#endif
/* set the maximal denominator in rational representation of gomory cut and the maximal scale factor to
* scale resulting cut to integral values to avoid numerical instabilities
*/
/**@todo find better but still stable gomory cut settings: look at dcmulti, gesa3, khb0525, misc06, p2756 */
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;
}
/* allocate temporary memory */
SCIP_CALL( SCIPallocBufferArray(scip, &cutcoefs, nvars) );
SCIP_CALL( SCIPallocBufferArray(scip, &basisind, nrows) );
SCIP_CALL( SCIPallocBufferArray(scip, &binvrow, nrows) );
/* get basis indices */
SCIP_CALL( SCIPgetLPBasisInd(scip, basisind) );
/* get the maximal number of cuts allowed in a separation round */
if( depth == 0 )
maxsepacuts = sepadata->maxsepacutsroot;
else
maxsepacuts = sepadata->maxsepacuts;
SCIPdebugMessage("searching gomory cuts: %d cols, %d rows, maxdnom=%"SCIP_LONGINT_FORMAT", maxscale=%g, maxcuts=%d\n",
ncols, nrows, maxdnom, maxscale, maxsepacuts);
cutoff = FALSE;
naddedcuts = 0;
/* for all basic columns belonging to integer variables, try to generate a gomory cut */
for( i = 0; i < nrows && naddedcuts < maxsepacuts && !SCIPisStopped(scip) && !cutoff; ++i )
{
SCIP_Bool tryrow;
tryrow = FALSE;
c = basisind[i];
if( c >= 0 )
{
SCIP_VAR* var;
assert(c < ncols);
var = SCIPcolGetVar(cols[c]);
if( SCIPvarGetType(var) != SCIP_VARTYPE_CONTINUOUS )
{
SCIP_Real primsol;
primsol = SCIPcolGetPrimsol(cols[c]);
assert(SCIPgetVarSol(scip, var) == primsol); /*lint !e777*/
if( SCIPfeasFrac(scip, primsol) >= minfrac )
{
SCIPdebugMessage("trying gomory cut for col <%s> [%g]\n", SCIPvarGetName(var), primsol);
tryrow = TRUE;
}
}
}
else if( sepadata->separaterows )
{
SCIP_ROW* row;
assert(0 <= -c-1 && -c-1 < nrows);
row = rows[-c-1];
if( SCIProwIsIntegral(row) && !SCIProwIsModifiable(row) )
{
SCIP_Real primsol;
primsol = SCIPgetRowActivity(scip, row);
if( SCIPfeasFrac(scip, primsol) >= minfrac )
{
SCIPdebugMessage("trying gomory cut for row <%s> [%g]\n", SCIProwGetName(row), primsol);
tryrow = TRUE;
}
}
}
if( tryrow )
{
SCIP_Real cutrhs;
SCIP_Real cutact;
SCIP_Bool success;
SCIP_Bool cutislocal;
/* get the row of B^-1 for this basic integer variable with fractional solution value */
SCIP_CALL( SCIPgetLPBInvRow(scip, i, binvrow) );
cutact = 0.0;
cutrhs = SCIPinfinity(scip);
/* create a MIR cut out of the weighted LP rows using the B^-1 row as weights */
SCIP_CALL( SCIPcalcMIR(scip, NULL, BOUNDSWITCH, USEVBDS, ALLOWLOCAL, FIXINTEGRALRHS, NULL, NULL,
(int) MAXAGGRLEN(nvars), sepadata->maxweightrange, minfrac, maxfrac,
binvrow, 1.0, NULL, NULL, cutcoefs, &cutrhs, &cutact, &success, &cutislocal) );
assert(ALLOWLOCAL || !cutislocal);
/* @todo Currently we are using the SCIPcalcMIR() function to compute the coefficients of the Gomory
* cut. Alternatively, we could use the direct version (see thesis of Achterberg formula (8.4)) which
* leads to cut a of the form \sum a_i x_i \geq 1. Rumor has it that these cuts are better.
*/
SCIPdebugMessage(" -> success=%u: %g <= %g\n", success, cutact, cutrhs);
/* if successful, convert dense cut into sparse row, and add the row as a cut */
if( success && SCIPisFeasGT(scip, cutact, cutrhs) )
{
SCIP_ROW* cut;
char cutname[SCIP_MAXSTRLEN];
int v;
/* construct cut name */
if( c >= 0 )
(void) SCIPsnprintf(cutname, SCIP_MAXSTRLEN, "gom%d_x%d", SCIPgetNLPs(scip), c);
else
(void) SCIPsnprintf(cutname, SCIP_MAXSTRLEN, "gom%d_s%d", SCIPgetNLPs(scip), -c-1);
/* create empty cut */
SCIP_CALL( SCIPcreateEmptyRowSepa(scip, &cut, sepa, cutname, -SCIPinfinity(scip), cutrhs,
cutislocal, FALSE, sepadata->dynamiccuts) );
/* cache the row extension and only flush them if the cut gets added */
SCIP_CALL( SCIPcacheRowExtensions(scip, cut) );
/* collect all non-zero coefficients */
for( v = 0; v < nvars; ++v )
{
if( !SCIPisZero(scip, cutcoefs[v]) )
{
SCIP_CALL( SCIPaddVarToRow(scip, cut, vars[v], cutcoefs[v]) );
}
}
if( SCIProwGetNNonz(cut) == 0 )
{
assert(SCIPisFeasNegative(scip, cutrhs));
SCIPdebugMessage(" -> gomory cut detected infeasibility with cut 0 <= %f\n", cutrhs);
cutoff = TRUE;
}
else if( SCIProwGetNNonz(cut) == 1 )
{
/* add the bound change as cut to avoid that the LP gets modified. that would mean the LP is not flushed
* and the method SCIPgetLPBInvRow() fails; SCIP internally will apply that bound change automatically
*/
SCIP_CALL( SCIPaddCut(scip, NULL, cut, TRUE) );
naddedcuts++;
}
else
{
/* Only take efficacious cuts, except for cuts with one non-zero coefficients (= bound
* changes); the latter cuts will be handeled internally in sepastore.
*/
if( SCIPisCutEfficacious(scip, NULL, cut) )
{
assert(success == TRUE);
SCIPdebugMessage(" -> gomory cut for <%s>: act=%f, rhs=%f, eff=%f\n",
c >= 0 ? SCIPvarGetName(SCIPcolGetVar(cols[c])) : SCIProwGetName(rows[-c-1]),
cutact, cutrhs, SCIPgetCutEfficacy(scip, NULL, cut));
if( sepadata->makeintegral )
{
/* try to scale the cut to integral values */
SCIP_CALL( SCIPmakeRowIntegral(scip, cut, -SCIPepsilon(scip), SCIPsumepsilon(scip),
maxdnom, maxscale, MAKECONTINTEGRAL, &success) );
if( sepadata->forcecuts )
success = TRUE;
/* in case the left hand side in minus infinity and the right hand side is plus infinity the cut is
* useless so we are not taking it at all
*/
if( (SCIPisInfinity(scip, -SCIProwGetLhs(cut)) && SCIPisInfinity(scip, SCIProwGetRhs(cut))) )
success = FALSE;
/* @todo Trying to make the Gomory cut integral might fail. Due to numerical reasons/arguments we
* currently ignore such cuts. If the cut, however, has small support (let's say smaller or equal to
* 5), we might want to add that cut (even it does not have integral coefficients). To be able to
* do that we need to add a rank to the data structure of a row. The rank of original rows are
* zero and for aggregated rows it is the maximum over all used rows plus one.
*/
}
if( success )
{
SCIPdebugMessage(" -> found gomory cut <%s>: act=%f, rhs=%f, norm=%f, eff=%f, min=%f, max=%f (range=%f)\n",
cutname, SCIPgetRowLPActivity(scip, cut), SCIProwGetRhs(cut), SCIProwGetNorm(cut),
SCIPgetCutEfficacy(scip, NULL, cut),
SCIPgetRowMinCoef(scip, cut), SCIPgetRowMaxCoef(scip, cut),
SCIPgetRowMaxCoef(scip, cut)/SCIPgetRowMinCoef(scip, cut));
/* flush all changes before adding the cut */
SCIP_CALL( SCIPflushRowExtensions(scip, cut) );
/* add global cuts which are not implicit bound changes to the cut pool */
if( !cutislocal )
{
if( sepadata->delayedcuts )
{
SCIP_CALL( SCIPaddDelayedPoolCut(scip, cut) );
}
else
{
SCIP_CALL( SCIPaddPoolCut(scip, cut) );
}
}
else
{
/* local cuts we add to the sepastore */
SCIP_CALL( SCIPaddCut(scip, NULL, cut, FALSE) );
}
naddedcuts++;
}
}
}
/* release the row */
SCIP_CALL( SCIPreleaseRow(scip, &cut) );
}
}
}
/* free temporary memory */
SCIPfreeBufferArray(scip, &binvrow);
SCIPfreeBufferArray(scip, &basisind);
SCIPfreeBufferArray(scip, &cutcoefs);
SCIPdebugMessage("end searching gomory cuts: found %d cuts\n", naddedcuts);
sepadata->lastncutsfound = SCIPgetNCutsFound(scip);
/* evalute the result of the separation */
if( cutoff )
*result = SCIP_CUTOFF;
else if ( naddedcuts > 0 )
*result = SCIP_SEPARATED;
else
*result = SCIP_DIDNOTFIND;
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;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecZirounding)
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_SOL* sol;
SCIP_VAR** lpcands;
SCIP_VAR** zilpcands;
SCIP_VAR** slackvars;
SCIP_Real* upslacks;
SCIP_Real* downslacks;
SCIP_Real* activities;
SCIP_Real* slackvarcoeffs;
SCIP_Bool* rowneedsslackvar;
SCIP_ROW** rows;
SCIP_Real* lpcandssol;
SCIP_Real* solarray;
SCIP_Longint nlps;
int currentlpcands;
int nlpcands;
int nimplfracs;
int i;
int c;
int nslacks;
int nroundings;
SCIP_RETCODE retcode;
SCIP_Bool improvementfound;
SCIP_Bool numericalerror;
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
assert(result != NULL);
assert(SCIPhasCurrentNodeLP(scip));
*result = SCIP_DIDNOTRUN;
/* do not call heuristic of node was already detected to be infeasible */
if( nodeinfeasible )
return SCIP_OKAY;
/* only call heuristic if an optimal LP-solution is at hand */
if( SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
return SCIP_OKAY;
/* only call heuristic, if the LP objective value is smaller than the cutoff bound */
if( SCIPisGE(scip, SCIPgetLPObjval(scip), SCIPgetCutoffbound(scip)) )
return SCIP_OKAY;
/* get heuristic data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* Do not call heuristic if deactivation check is enabled and percentage of found solutions in relation
* to number of calls falls below heurdata->stoppercentage */
if( heurdata->stopziround && SCIPheurGetNCalls(heur) >= heurdata->minstopncalls
&& SCIPheurGetNSolsFound(heur)/(SCIP_Real)SCIPheurGetNCalls(heur) < heurdata->stoppercentage )
return SCIP_OKAY;
/* assure that heuristic has not already been called after the last LP had been solved */
nlps = SCIPgetNLPs(scip);
if( nlps == heurdata->lastlp )
return SCIP_OKAY;
heurdata->lastlp = nlps;
/* get fractional variables */
SCIP_CALL( SCIPgetLPBranchCands(scip, &lpcands, &lpcandssol, NULL, &nlpcands, NULL, &nimplfracs) );
nlpcands = nlpcands + nimplfracs;
/* make sure that there is at least one fractional variable that should be integral */
if( nlpcands == 0 )
return SCIP_OKAY;
assert(nlpcands > 0);
assert(lpcands != NULL);
assert(lpcandssol != NULL);
/* get LP rows data */
rows = SCIPgetLPRows(scip);
nslacks = SCIPgetNLPRows(scip);
/* cannot do anything if LP is empty */
if( nslacks == 0 )
return SCIP_OKAY;
assert(rows != NULL);
assert(nslacks > 0);
/* get the working solution from heuristic's local data */
sol = heurdata->sol;
assert(sol != NULL);
*result = SCIP_DIDNOTFIND;
solarray = NULL;
zilpcands = NULL;
retcode = SCIP_OKAY;
/* copy the current LP solution to the working solution and allocate memory for local data */
SCIP_CALL( SCIPlinkLPSol(scip, sol) );
SCIP_CALL_TERMINATE(retcode, SCIPallocBufferArray(scip, &solarray, nlpcands), TERMINATE);
SCIP_CALL_TERMINATE(retcode, SCIPallocBufferArray(scip, &zilpcands, nlpcands), TERMINATE);
/* copy necessary data to local arrays */
BMScopyMemoryArray(solarray, lpcandssol, nlpcands);
BMScopyMemoryArray(zilpcands, lpcands, nlpcands);
/* allocate buffer data arrays */
SCIP_CALL_TERMINATE(retcode, SCIPallocBufferArray(scip, &slackvars, nslacks), TERMINATE);
SCIP_CALL_TERMINATE(retcode, SCIPallocBufferArray(scip, &upslacks, nslacks), TERMINATE);
SCIP_CALL_TERMINATE(retcode, SCIPallocBufferArray(scip, &downslacks, nslacks), TERMINATE);
SCIP_CALL_TERMINATE(retcode, SCIPallocBufferArray(scip, &slackvarcoeffs, nslacks), TERMINATE);
SCIP_CALL_TERMINATE(retcode, SCIPallocBufferArray(scip, &rowneedsslackvar, nslacks), TERMINATE);
SCIP_CALL_TERMINATE(retcode, SCIPallocBufferArray(scip, &activities, nslacks), TERMINATE);
BMSclearMemoryArray(slackvars, nslacks);
BMSclearMemoryArray(slackvarcoeffs, nslacks);
BMSclearMemoryArray(rowneedsslackvar, nslacks);
numericalerror = FALSE;
nroundings = 0;
/* loop over fractional variables and involved LP rows to find all rows which require a slack variable */
for( c = 0; c < nlpcands; ++c )
{
SCIP_VAR* cand;
SCIP_ROW** candrows;
int r;
int ncandrows;
cand = zilpcands[c];
assert(cand != NULL);
assert(SCIPcolGetLPPos(SCIPvarGetCol(cand)) >= 0);
candrows = SCIPcolGetRows(SCIPvarGetCol(cand));
ncandrows = SCIPcolGetNLPNonz(SCIPvarGetCol(cand));
assert(candrows == NULL || ncandrows > 0);
for( r = 0; r < ncandrows; ++r )
{
int rowpos;
assert(candrows != NULL); /* to please flexelint */
assert(candrows[r] != NULL);
rowpos = SCIProwGetLPPos(candrows[r]);
if( rowpos >= 0 && SCIPisFeasEQ(scip, SCIProwGetLhs(candrows[r]), SCIProwGetRhs(candrows[r])) )
{
rowneedsslackvar[rowpos] = TRUE;
SCIPdebugMessage(" Row %s needs slack variable for variable %s\n", SCIProwGetName(candrows[r]), SCIPvarGetName(cand));
}
}
}
/* calculate row slacks for every every row that belongs to the current LP and ensure, that the current solution
* has no violated constraint -- if any constraint is violated, i.e. a slack is significantly smaller than zero,
* this will cause the termination of the heuristic because Zirounding does not provide feasibility recovering
*/
for( i = 0; i < nslacks; ++i )
{
SCIP_ROW* row;
SCIP_Real lhs;
SCIP_Real rhs;
row = rows[i];
assert(row != NULL);
lhs = SCIProwGetLhs(row);
rhs = SCIProwGetRhs(row);
/* get row activity */
activities[i] = SCIPgetRowActivity(scip, row);
assert(SCIPisFeasLE(scip, lhs, activities[i]) && SCIPisFeasLE(scip, activities[i], rhs));
/* in special case if LHS or RHS is (-)infinity slacks have to be initialized as infinity */
if( SCIPisInfinity(scip, -lhs) )
downslacks[i] = SCIPinfinity(scip);
else
downslacks[i] = activities[i] - lhs;
if( SCIPisInfinity(scip, rhs) )
upslacks[i] = SCIPinfinity(scip);
else
upslacks[i] = rhs - activities[i];
SCIPdebugMessage("lhs:%5.2f <= act:%5.2g <= rhs:%5.2g --> down: %5.2g, up:%5.2g\n", lhs, activities[i], rhs, downslacks[i], upslacks[i]);
/* row is an equation. Try to find a slack variable in the row, i.e.,
* a continuous variable which occurs only in this row. If no such variable exists,
* there is no hope for an IP-feasible solution in this round
*/
if( SCIPisFeasEQ(scip, lhs, rhs) && rowneedsslackvar[i] )
{
/* @todo: This is only necessary for rows containing fractional variables. */
rowFindSlackVar(scip, row, &(slackvars[i]), &(slackvarcoeffs[i]));
if( slackvars[i] == NULL )
{
SCIPdebugMessage("No slack variable found for equation %s, terminating ZI Round heuristic\n", SCIProwGetName(row));
goto TERMINATE;
}
else
{
SCIP_Real ubslackvar;
SCIP_Real lbslackvar;
SCIP_Real solvalslackvar;
SCIP_Real coeffslackvar;
SCIP_Real ubgap;
SCIP_Real lbgap;
assert(SCIPvarGetType(slackvars[i]) == SCIP_VARTYPE_CONTINUOUS);
solvalslackvar = SCIPgetSolVal(scip, sol, slackvars[i]);
ubslackvar = SCIPvarGetUbGlobal(slackvars[i]);
lbslackvar = SCIPvarGetLbGlobal(slackvars[i]);
coeffslackvar = slackvarcoeffs[i];
assert(!SCIPisFeasZero(scip, coeffslackvar));
ubgap = ubslackvar - solvalslackvar;
lbgap = solvalslackvar - lbslackvar;
if( SCIPisFeasZero(scip, ubgap) )
ubgap = 0.0;
if( SCIPisFeasZero(scip, lbgap) )
lbgap = 0.0;
if( SCIPisFeasPositive(scip, coeffslackvar) )
{
if( !SCIPisInfinity(scip, lbslackvar) )
upslacks[i] += coeffslackvar * lbgap;
else
upslacks[i] = SCIPinfinity(scip);
if( !SCIPisInfinity(scip, ubslackvar) )
downslacks[i] += coeffslackvar * ubgap;
else
downslacks[i] = SCIPinfinity(scip);
}
else
{
if( !SCIPisInfinity(scip, ubslackvar) )
upslacks[i] -= coeffslackvar * ubgap;
else
upslacks[i] = SCIPinfinity(scip);
if( !SCIPisInfinity(scip, lbslackvar) )
downslacks[i] -= coeffslackvar * lbgap;
else
downslacks[i] = SCIPinfinity(scip);
}
SCIPdebugMessage(" Slack variable for row %s at pos %d: %g <= %s = %g <= %g; Coeff %g, upslack = %g, downslack = %g \n",
SCIProwGetName(row), SCIProwGetLPPos(row), lbslackvar, SCIPvarGetName(slackvars[i]), solvalslackvar, ubslackvar, coeffslackvar,
upslacks[i], downslacks[i]);
}
}
/* due to numerical inaccuracies, the rows might be feasible, even if the slacks are
* significantly smaller than zero -> terminate
*/
if( SCIPisFeasLT(scip, upslacks[i], 0.0) || SCIPisFeasLT(scip, downslacks[i], 0.0) )
goto TERMINATE;
}
assert(nslacks == 0 || (upslacks != NULL && downslacks != NULL && activities != NULL));
/* initialize number of remaining variables and flag to enter the main loop */
currentlpcands = nlpcands;
improvementfound = TRUE;
/* iterate over variables as long as there are fractional variables left */
while( currentlpcands > 0 && improvementfound && (heurdata->maxroundingloops == -1 || nroundings < heurdata->maxroundingloops) )
{ /*lint --e{850}*/
improvementfound = FALSE;
nroundings++;
SCIPdebugMessage("zirounding enters while loop for %d time with %d candidates left. \n", nroundings, currentlpcands);
/* check for every remaining fractional variable if a shifting decreases ZI-value of the variable */
for( c = 0; c < currentlpcands; ++c )
{
SCIP_VAR* var;
SCIP_Real oldsolval;
SCIP_Real upperbound;
SCIP_Real lowerbound;
SCIP_Real up;
SCIP_Real down;
SCIP_Real ziup;
SCIP_Real zidown;
SCIP_Real zicurrent;
SCIP_Real shiftval;
DIRECTION direction;
/* get values from local data */
oldsolval = solarray[c];
var = zilpcands[c];
assert(!SCIPisFeasIntegral(scip, oldsolval));
assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_COLUMN);
/* calculate bounds for variable and make sure that there are no numerical inconsistencies */
upperbound = SCIPinfinity(scip);
lowerbound = SCIPinfinity(scip);
calculateBounds(scip, var, oldsolval, &upperbound, &lowerbound, upslacks, downslacks, nslacks, &numericalerror);
if( numericalerror )
goto TERMINATE;
/* calculate the possible values after shifting */
up = oldsolval + upperbound;
down = oldsolval - lowerbound;
/* if the variable is integer or implicit binary, do not shift further than the nearest integer */
if( SCIPvarGetType(var) != SCIP_VARTYPE_BINARY)
{
SCIP_Real ceilx;
SCIP_Real floorx;
ceilx = SCIPfeasCeil(scip, oldsolval);
floorx = SCIPfeasFloor(scip, oldsolval);
up = MIN(up, ceilx);
down = MAX(down, floorx);
}
/* calculate necessary values */
ziup = getZiValue(scip, up);
zidown = getZiValue(scip, down);
zicurrent = getZiValue(scip, oldsolval);
/* calculate the shifting direction that reduces ZI-value the most,
* if both directions improve ZI-value equally, take the direction which improves the objective
*/
if( SCIPisFeasLT(scip, zidown, zicurrent) || SCIPisFeasLT(scip, ziup, zicurrent) )
{
if( SCIPisFeasEQ(scip,ziup, zidown) )
direction = SCIPisFeasGE(scip, SCIPvarGetObj(var), 0.0) ? DIRECTION_DOWN : DIRECTION_UP;
else if( SCIPisFeasLT(scip, zidown, ziup) )
direction = DIRECTION_DOWN;
else
direction = DIRECTION_UP;
/* once a possible shifting direction and value have been found, variable value is updated */
shiftval = (direction == DIRECTION_UP ? up - oldsolval : down - oldsolval);
/* this improves numerical stability in some cases */
if( direction == DIRECTION_UP )
shiftval = MIN(shiftval, upperbound);
else
shiftval = MIN(shiftval, lowerbound);
/* update the solution */
solarray[c] = direction == DIRECTION_UP ? up : down;
SCIP_CALL( SCIPsetSolVal(scip, sol, var, solarray[c]) );
/* update the rows activities and slacks */
SCIP_CALL( updateSlacks(scip, sol, var, shiftval, upslacks,
downslacks, activities, slackvars, slackvarcoeffs, nslacks) );
SCIPdebugMessage("zirounding update step : %d var index, oldsolval=%g, shiftval=%g\n",
SCIPvarGetIndex(var), oldsolval, shiftval);
/* since at least one improvement has been found, heuristic will enter main loop for another time because the improvement
* might affect many LP rows and their current slacks and thus make further rounding steps possible */
improvementfound = TRUE;
}
/* if solution value of variable has become feasibly integral due to rounding step,
* variable is put at the end of remaining candidates array so as not to be considered in future loops
*/
if( SCIPisFeasIntegral(scip, solarray[c]) )
{
zilpcands[c] = zilpcands[currentlpcands - 1];
solarray[c] = solarray[currentlpcands - 1];
currentlpcands--;
/* counter is decreased if end of candidates array has not been reached yet */
if( c < currentlpcands )
c--;
}
else if( nroundings == heurdata->maxroundingloops - 1 )
goto TERMINATE;
}
}
/* in case that no candidate is left for rounding after the final main loop
* the found solution has to be checked for feasibility in the original problem
*/
if( currentlpcands == 0 )
{
SCIP_Bool stored;
SCIP_CALL(SCIPtrySol(scip, sol, FALSE, FALSE, TRUE, FALSE, &stored));
if( stored )
{
#ifdef SCIP_DEBUG
SCIPdebugMessage("found feasible rounded solution:\n");
SCIP_CALL( SCIPprintSol(scip, sol, NULL, FALSE) );
#endif
SCIPstatisticMessage(" ZI Round solution value: %g \n", SCIPgetSolOrigObj(scip, sol));
*result = SCIP_FOUNDSOL;
}
}
/* free memory for all locally allocated data */
TERMINATE:
SCIPfreeBufferArrayNull(scip, &activities);
SCIPfreeBufferArrayNull(scip, &rowneedsslackvar);
SCIPfreeBufferArrayNull(scip, &slackvarcoeffs);
SCIPfreeBufferArrayNull(scip, &downslacks);
SCIPfreeBufferArrayNull(scip, &upslacks);
SCIPfreeBufferArrayNull(scip, &slackvars);
SCIPfreeBufferArrayNull(scip, &zilpcands);
SCIPfreeBufferArrayNull(scip, &solarray);
return retcode;
}
/** separate */
static
SCIP_RETCODE sep_flow(
SCIP* scip, /**< SCIP data structure */
SCIP_CONSHDLR* conshdlr, /**< constraint handler */
SCIP_CONSHDLRDATA* conshdlrdata, /**< constraint handler data */
SCIP_CONSDATA* consdata, /**< constraint data */
int maxcuts, /**< maximal number of cuts */
int* ncuts /**< pointer to store number of cuts */
)
{
GRAPH* g;
SCIP_VAR** vars;
SCIP_ROW* row = NULL;
SCIP_Real* xval;
SCIP_Real sum;
int i;
int k;
int j;
int ind;
int layer;
int count = 0;
unsigned int flowsep;
assert(scip != NULL);
assert(conshdlr != NULL);
assert(conshdlrdata != NULL);
vars = SCIPprobdataGetVars(scip);
flowsep = conshdlrdata->flowsep;
/* get the graph */
g = consdata->graph;
assert(g != NULL);
xval = SCIPprobdataGetXval(scip, NULL);
assert(xval != NULL);
for(i = 0; i < g->knots; i++)
{
for(layer = 0; layer < g->layers; layer++)
{
/* continue at root */
if( i == g->source[layer] )
continue;
/* at terminal: input sum == 1
* basically a cut (starcut))
*/
if( g->term[i] == layer )
{
sum = 0.0;
for( k = g->inpbeg[i]; k != EAT_LAST; k = g->ieat[k] )
{
ind = layer * g->edges + k;
sum += (xval != NULL) ? xval[ind] : 0.0;
}
if( !SCIPisFeasEQ(scip, sum, 1.0) )
{
SCIP_Bool infeasible;
SCIP_CALL( SCIPcreateEmptyRowCons(scip, &row, conshdlr, "term", 1.0,
1.0, FALSE, FALSE, TRUE) );
SCIP_CALL( SCIPcacheRowExtensions(scip, row) );
for(k = g->inpbeg[i]; k != EAT_LAST; k = g->ieat[k])
{
ind = layer * g->edges + k;
SCIP_CALL( SCIPaddVarToRow(scip, row, vars[ind], 1.0) );
}
SCIP_CALL( SCIPflushRowExtensions(scip, row) );
SCIP_CALL( SCIPaddCut(scip, NULL, row, FALSE, &infeasible) );
count++;
SCIP_CALL( SCIPreleaseRow(scip, &row) );
if( *ncuts + count >= maxcuts )
goto TERMINATE;
}
}
/* no flows ? */
if( !flowsep )
continue;
/* the value of each outgoing edge needs to be smaller than the sum of the ingoing edges */
for( j = g->outbeg[i]; j != EAT_LAST; j = g->oeat[j] )
{
ind = layer * g->edges + j;
sum = (xval != NULL) ? -xval[ind] : -1.0;
for( k = g->inpbeg[i]; k != EAT_LAST; k = g->ieat[k] )
{
ind = layer * g->edges + k;
sum += (xval != NULL) ? xval[ind] : 0.0;
}
if( SCIPisFeasNegative(scip, sum) )
{
SCIP_Bool infeasible;
SCIP_CALL( SCIPcreateEmptyRowCons(scip, &row, conshdlr, "flow", 0.0, SCIPinfinity(scip),
FALSE, FALSE, TRUE) );
SCIP_CALL( SCIPcacheRowExtensions(scip, row) );
ind = layer * g->edges + j;
SCIP_CALL( SCIPaddVarToRow(scip, row, vars[ind], -1.0) );
for( k = g->inpbeg[i]; k != EAT_LAST; k = g->ieat[k] )
{
ind = layer * g->edges + k;
SCIP_CALL( SCIPaddVarToRow(scip, row, vars[ind], 1.0) );
}
SCIP_CALL( SCIPflushRowExtensions(scip, row) );
SCIP_CALL( SCIPaddCut(scip, NULL, row, FALSE, &infeasible) );
count++;
SCIP_CALL( SCIPreleaseRow(scip, &row) );
if( *ncuts + count >= maxcuts )
goto TERMINATE;
}
}
/* consider only non terminals */
if( g->term[i] == layer )
continue;
/* input of a vertex has to be <= 1.0 */
sum = 0.0;
for( k = g->inpbeg[i]; k != EAT_LAST; k = g->ieat[k] )
{
ind = layer * g->edges + k;
sum += (xval != NULL) ? xval[ind] : 1.0;
}
if( SCIPisFeasGT(scip, sum, 1.0) )
{
SCIP_Bool infeasible;
SCIP_CALL( SCIPcreateEmptyRowCons(scip, &row, conshdlr, "infl", -SCIPinfinity(scip),
1.0, FALSE, FALSE, TRUE) );
SCIP_CALL( SCIPcacheRowExtensions(scip, row) );
for( k = g->inpbeg[i]; k != EAT_LAST; k = g->ieat[k] )
{
ind = layer * g->edges + k;
SCIP_CALL( SCIPaddVarToRow(scip, row, vars[ind], 1.0) );
}
SCIP_CALL( SCIPflushRowExtensions(scip, row) );
SCIP_CALL( SCIPaddCut(scip, NULL, row, FALSE, &infeasible) );
count++;
SCIP_CALL( SCIPreleaseRow(scip, &row) );
if( *ncuts + count >= maxcuts )
goto TERMINATE;
}
/* incoming flow <= outgoing flow */
sum = 0.0;
for( k = g->inpbeg[i]; k != EAT_LAST; k = g->ieat[k] )
{
ind = layer * g->edges + k;
sum -= (xval != NULL) ? xval[ind] : 1.0;
}
for( k = g->outbeg[i]; k != EAT_LAST; k = g->oeat[k] )
{
ind = layer * g->edges + k;
sum += (xval != NULL) ? xval[ind] : 0.0;
}
if( SCIPisFeasNegative(scip, sum) )
{
SCIP_Bool infeasible;
SCIP_CALL( SCIPcreateEmptyRowCons(scip, &row, conshdlr, "bala", 0.0,
(g->locals[layer] == 2) ? 0.0 : SCIPinfinity(scip), FALSE, FALSE, TRUE) );
SCIP_CALL( SCIPcacheRowExtensions(scip, row) );
for( k = g->inpbeg[i]; k != EAT_LAST; k = g->ieat[k] )
{
ind = layer * g->edges + k;
SCIP_CALL( SCIPaddVarToRow(scip, row, vars[ind], -1.0) );
}
for( k = g->outbeg[i]; k != EAT_LAST; k = g->oeat[k] )
{
ind = layer * g->edges + k;
SCIP_CALL( SCIPaddVarToRow(scip, row, vars[ind], 1.0) );
}
SCIP_CALL( SCIPflushRowExtensions(scip, row) );
SCIP_CALL( SCIPaddCut(scip, NULL, row, FALSE, &infeasible) );
count++;
SCIP_CALL( SCIPreleaseRow(scip, &row) );
if( *ncuts + count >= maxcuts )
goto TERMINATE;
}
}
}
TERMINATE:
SCIPdebugMessage("In/Out Separator: %d Inequalities added\n", count);
*ncuts += count;
return SCIP_OKAY;
}
/** determines shifting bounds for variable */
static
void calculateBounds(
SCIP* scip, /**< pointer to current SCIP data structure */
SCIP_VAR* var, /**< the variable for which lb and ub have to be calculated */
SCIP_Real currentvalue, /**< the current value of var in the working solution */
SCIP_Real* upperbound, /**< pointer to store the calculated upper bound on the variable shift */
SCIP_Real* lowerbound, /**< pointer to store the calculated lower bound on the variable shift */
SCIP_Real* upslacks, /**< array that contains the slacks between row activities and the right hand sides of the rows */
SCIP_Real* downslacks, /**< array that contains lhs slacks */
int nslacks, /**< current number of slacks */
SCIP_Bool* numericalerror /**< flag to determine whether a numerical error occurred */
)
{
SCIP_COL* col;
SCIP_ROW** colrows;
SCIP_Real* colvals;
int ncolvals;
int i;
assert(scip != NULL);
assert(var != NULL);
assert(upslacks != NULL);
assert(downslacks != NULL);
assert(upperbound != NULL);
assert(lowerbound != NULL);
/* get the column associated to the variable, the nonzero rows and the nonzero coefficients */
col = SCIPvarGetCol(var);
colrows = SCIPcolGetRows(col);
colvals = SCIPcolGetVals(col);
ncolvals = SCIPcolGetNLPNonz(col);
/* only proceed, when variable has nonzero coefficients */
if( ncolvals == 0 )
return;
assert(colvals != NULL);
assert(colrows != NULL);
/* initialize the bounds on the shift to be the gap of the current solution value to the bounds of the variable */
if( SCIPisInfinity(scip, SCIPvarGetUbGlobal(var)) )
*upperbound = SCIPinfinity(scip);
else
*upperbound = SCIPvarGetUbGlobal(var) - currentvalue;
if( SCIPisInfinity(scip, -SCIPvarGetLbGlobal(var)) )
*lowerbound = SCIPinfinity(scip);
else
*lowerbound = currentvalue - SCIPvarGetLbGlobal(var);
/* go through every nonzero row coefficient corresponding to var to determine bounds for shifting
* in such a way that shifting maintains feasibility in every LP row.
* a lower or upper bound as it is calculated in zirounding always has to be >= 0.0.
* if one of these values is significantly < 0.0, this will cause the abort of execution of the heuristic so that
* infeasible solutions are avoided
*/
for( i = 0; i < ncolvals && (*lowerbound > 0.0 || *upperbound > 0.0); ++i )
{
SCIP_ROW* row;
int rowpos;
row = colrows[i];
rowpos = SCIProwGetLPPos(row);
/* the row might currently not be in the LP, ignore it! */
if( rowpos == -1 )
continue;
assert(0 <= rowpos && rowpos < nslacks);
/* all bounds and slacks as they are calculated in zirounding always have to be greater equal zero.
* It might however be due to numerical issues, e.g. with scaling, that they are not. Better abort in this case.
*/
if( SCIPisFeasLT(scip, *lowerbound, 0.0) || SCIPisFeasLT(scip, *upperbound, 0.0)
|| SCIPisFeasLT(scip, upslacks[rowpos], 0.0) || SCIPisFeasLT(scip, downslacks[rowpos] , 0.0) )
{
*numericalerror = TRUE;
return;
}
SCIPdebugMessage("colval: %15.8g, downslack: %15.8g, upslack: %5.2g, lb: %5.2g, ub: %5.2g\n", colvals[i], downslacks[rowpos], upslacks[rowpos],
*lowerbound, *upperbound);
/* if coefficient > 0, rounding up might violate up slack and rounding down might violate down slack
* thus search for the minimum so that no constraint is violated; vice versa for coefficient < 0
*/
if( colvals[i] > 0 )
{
if( !SCIPisInfinity(scip, upslacks[rowpos]) )
{
SCIP_Real upslack;
upslack = MAX(upslacks[rowpos], 0.0); /* avoid errors due to numerically slightly infeasible rows */
*upperbound = MIN(*upperbound, upslack/colvals[i]);
}
if( !SCIPisInfinity(scip, downslacks[rowpos]) )
{
SCIP_Real downslack;
downslack = MAX(downslacks[rowpos], 0.0); /* avoid errors due to numerically slightly infeasible rows */
*lowerbound = MIN(*lowerbound, downslack/colvals[i]);
}
}
else
{
assert(colvals[i] != 0.0);
if( !SCIPisInfinity(scip, upslacks[rowpos]) )
{
SCIP_Real upslack;
upslack = MAX(upslacks[rowpos], 0.0); /* avoid errors due to numerically slightly infeasible rows */
*lowerbound = MIN(*lowerbound, -upslack/colvals[i]);
}
if( !SCIPisInfinity(scip, downslacks[rowpos]) )
{
SCIP_Real downslack;
downslack = MAX(downslacks[rowpos], 0.0); /* avoid errors due to numerically slightly infeasible rows */
*upperbound = MIN(*upperbound, -downslack/colvals[i]);
}
}
}
}
/* Read SAT formula in "CNF File Format".
*
* The specification is taken from the
*
* Satisfiability Suggested Format
*
* Online available at http://www.intellektik.informatik.tu-darmstadt.de/SATLIB/Benchmarks/SAT/satformat.ps
*
* The method reads all files of CNF format. Other formats (SAT, SATX, SATE) are not supported.
*/
static
SCIP_RETCODE readCnf(
SCIP* scip, /**< SCIP data structure */
SCIP_FILE* file /**< input file */
)
{
SCIP_RETCODE retcode;
SCIP_VAR** vars;
SCIP_VAR** clausevars;
SCIP_CONS* cons;
int* varsign;
char* tok;
char* nexttok;
char line[MAXLINELEN];
char format[SCIP_MAXSTRLEN];
char varname[SCIP_MAXSTRLEN];
char s[SCIP_MAXSTRLEN];
SCIP_Bool dynamicconss;
SCIP_Bool dynamiccols;
SCIP_Bool dynamicrows;
SCIP_Bool useobj;
int linecount;
int clauselen;
int clausenum;
int nvars;
int nclauses;
int varnum;
int v;
assert(scip != NULL);
assert(file != NULL);
retcode = SCIP_OKAY;
linecount = 0;
/* read header */
SCIP_CALL( readCnfLine(scip, file, line, (int) sizeof(line), &linecount) );
if( *line != 'p' )
{
readError(scip, linecount, "problem declaration line expected");
return SCIP_READERROR;
}
if( sscanf(line, "p %8s %d %d", format, &nvars, &nclauses) != 3 )
{
readError(scip, linecount, "invalid problem declaration (must be 'p cnf <nvars> <nclauses>')");
return SCIP_READERROR;
}
if( strcmp(format, "cnf") != 0 )
{
(void) SCIPsnprintf(s, SCIP_MAXSTRLEN, "invalid format tag <%s> (must be 'cnf')", format);
readError(scip, linecount, s);
return SCIP_READERROR;
}
if( nvars <= 0 )
{
(void) SCIPsnprintf(s, SCIP_MAXSTRLEN, "invalid number of variables <%d> (must be positive)", nvars);
readError(scip, linecount, s);
return SCIP_READERROR;
}
if( nclauses <= 0 )
{
(void) SCIPsnprintf(s, SCIP_MAXSTRLEN, "invalid number of clauses <%d> (must be positive)", nclauses);
readError(scip, linecount, s);
return SCIP_READERROR;
}
/* get parameter values */
SCIP_CALL( SCIPgetBoolParam(scip, "reading/cnfreader/dynamicconss", &dynamicconss) );
SCIP_CALL( SCIPgetBoolParam(scip, "reading/cnfreader/dynamiccols", &dynamiccols) );
SCIP_CALL( SCIPgetBoolParam(scip, "reading/cnfreader/dynamicrows", &dynamicrows) );
SCIP_CALL( SCIPgetBoolParam(scip, "reading/cnfreader/useobj", &useobj) );
/* get temporary memory */
SCIP_CALL( SCIPallocBufferArray(scip, &vars, nvars) );
SCIP_CALL( SCIPallocBufferArray(scip, &clausevars, nvars) );
SCIP_CALL( SCIPallocBufferArray(scip, &varsign, nvars) );
/* create the variables */
for( v = 0; v < nvars; ++v )
{
(void) SCIPsnprintf(varname, SCIP_MAXSTRLEN, "x%d", v+1);
SCIP_CALL( SCIPcreateVar(scip, &vars[v], varname, 0.0, 1.0, 0.0, SCIP_VARTYPE_BINARY, !dynamiccols, dynamiccols,
NULL, NULL, NULL, NULL, NULL) );
SCIP_CALL( SCIPaddVar(scip, vars[v]) );
varsign[v] = 0;
}
/* read clauses */
clausenum = 0;
clauselen = 0;
do
{
retcode = readCnfLine(scip, file, line, (int) sizeof(line), &linecount);
if( retcode != SCIP_OKAY )
goto TERMINATE;
if( *line != '\0' && *line != '%' )
{
tok = SCIPstrtok(line, " \f\n\r\t", &nexttok);
while( tok != NULL )
{
/* parse literal and check for errors */
if( sscanf(tok, "%d", &v) != 1 )
{
(void) SCIPsnprintf(s, SCIP_MAXSTRLEN, "invalid literal <%s>", tok);
readError(scip, linecount, s);
retcode = SCIP_READERROR;
goto TERMINATE;
}
/* interpret literal number: v == 0: end of clause, v < 0: negated literal, v > 0: positive literal */
if( v == 0 )
{
/* end of clause: construct clause and add it to SCIP */
if( clauselen == 0 )
readWarning(scip, linecount, "empty clause detected in line -- problem infeasible");
clausenum++;
(void) SCIPsnprintf(s, SCIP_MAXSTRLEN, "c%d", clausenum);
if( SCIPfindConshdlr(scip, "logicor") != NULL )
{
/* if the constraint handler logicor exit create a logicor constraint */
SCIP_CALL( SCIPcreateConsLogicor(scip, &cons, s, clauselen, clausevars,
!dynamicrows, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, dynamicconss, dynamicrows, FALSE) );
}
else if( SCIPfindConshdlr(scip, "setppc") != NULL )
{
/* if the constraint handler logicor does not exit but constraint
* handler setppc create a setppc constraint */
SCIP_CALL( SCIPcreateConsSetcover(scip, &cons, s, clauselen, clausevars,
!dynamicrows, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, dynamicconss, dynamicrows, FALSE) );
}
else
{
/* if none of the previous constraint handler exits create a linear
* constraint */
SCIP_Real* vals;
int i;
SCIP_CALL( SCIPallocBufferArray(scip, &vals, clauselen) );
for( i = 0; i < clauselen; ++i )
vals[i] = 1.0;
SCIP_CALL( SCIPcreateConsLinear(scip, &cons, s, clauselen, clausevars, vals, 1.0, SCIPinfinity(scip),
!dynamicrows, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, dynamicconss, dynamicrows, FALSE) );
SCIPfreeBufferArray(scip, &vals);
}
SCIP_CALL( SCIPaddCons(scip, cons) );
SCIP_CALL( SCIPreleaseCons(scip, &cons) );
clauselen = 0;
}
else if( v >= -nvars && v <= nvars )
{
if( clauselen >= nvars )
{
readError(scip, linecount, "too many literals in clause");
retcode = SCIP_READERROR;
goto TERMINATE;
}
/* add literal to clause */
varnum = ABS(v)-1;
if( v < 0 )
{
SCIP_CALL( SCIPgetNegatedVar(scip, vars[varnum], &clausevars[clauselen]) );
varsign[varnum]--;
}
else
{
clausevars[clauselen] = vars[varnum];
varsign[varnum]++;
}
clauselen++;
}
else
{
(void) SCIPsnprintf(s, SCIP_MAXSTRLEN, "invalid variable number <%d>", ABS(v));
readError(scip, linecount, s);
retcode = SCIP_READERROR;
goto TERMINATE;
}
/* get next token */
tok = SCIPstrtok(NULL, " \f\n\r\t", &nexttok);
}
}
}
while( *line != '\0' && *line != '%' );
/* check for additional literals */
if( clauselen > 0 )
{
SCIPwarningMessage(scip, "found %d additional literals after last clause\n", clauselen);
}
/* check number of clauses */
if( clausenum != nclauses )
{
SCIPwarningMessage(scip, "expected %d clauses, but found %d\n", nclauses, clausenum);
}
TERMINATE:
/* change objective values and release variables */
SCIP_CALL( SCIPsetObjsense(scip, SCIP_OBJSENSE_MAXIMIZE) );
if( useobj )
{
for( v = 0; v < nvars; ++v )
{
SCIP_CALL( SCIPchgVarObj(scip, vars[v], (SCIP_Real)varsign[v]) );
SCIP_CALL( SCIPreleaseVar(scip, &vars[v]) );
}
}
/* free temporary memory */
SCIPfreeBufferArray(scip, &varsign);
SCIPfreeBufferArray(scip, &clausevars);
SCIPfreeBufferArray(scip, &vars);
return retcode;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecActconsdiving) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_LPSOLSTAT lpsolstat;
SCIP_VAR* var;
SCIP_VAR** lpcands;
SCIP_Real* lpcandssol;
SCIP_Real* lpcandsfrac;
SCIP_Real searchubbound;
SCIP_Real searchavgbound;
SCIP_Real searchbound;
SCIP_Real objval;
SCIP_Real oldobjval;
SCIP_Real frac;
SCIP_Real bestfrac;
SCIP_Bool bestcandmayrounddown;
SCIP_Bool bestcandmayroundup;
SCIP_Bool bestcandroundup;
SCIP_Bool mayrounddown;
SCIP_Bool mayroundup;
SCIP_Bool roundup;
SCIP_Bool lperror;
SCIP_Bool cutoff;
SCIP_Bool backtracked;
SCIP_Longint ncalls;
SCIP_Longint nsolsfound;
SCIP_Longint nlpiterations;
SCIP_Longint maxnlpiterations;
int nlpcands;
int startnlpcands;
int depth;
int maxdepth;
int maxdivedepth;
int divedepth;
SCIP_Real actscore;
SCIP_Real downscore;
SCIP_Real upscore;
SCIP_Real bestactscore;
int bestcand;
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, 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 fractional variables that should be integral */
SCIP_CALL( SCIPgetLPBranchCands(scip, &lpcands, &lpcandssol, &lpcandsfrac, &nlpcands, NULL, NULL) );
/* don't try to dive, if there are no fractional variables */
if( nlpcands == 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);
/* get LP objective value */
lpsolstat = SCIP_LPSOLSTAT_OPTIMAL;
objval = SCIPgetLPObjval(scip);
SCIPdebugMessage("(node %"SCIP_LONGINT_FORMAT") executing actconsdiving heuristic: depth=%d, %d fractionals, dualbound=%g, avgbound=%g, cutoffbound=%g, searchbound=%g\n",
SCIPgetNNodes(scip), SCIPgetDepth(scip), nlpcands, SCIPgetDualbound(scip), SCIPgetAvgDualbound(scip),
SCIPretransformObj(scip, SCIPgetCutoffbound(scip)), SCIPretransformObj(scip, searchbound));
/* dive as long we are in the given objective, depth and iteration limits and fractional variables exist, but
* - if possible, we dive at least with the depth 10
* - if the number of fractional variables decreased at least with 1 variable per 2 dive depths, we continue diving
*/
lperror = FALSE;
cutoff = FALSE;
divedepth = 0;
bestcandmayrounddown = FALSE;
bestcandmayroundup = FALSE;
startnlpcands = nlpcands;
while( !lperror && !cutoff && lpsolstat == SCIP_LPSOLSTAT_OPTIMAL && nlpcands > 0
&& (divedepth < 10
|| nlpcands <= startnlpcands - divedepth/2
|| (divedepth < maxdivedepth && heurdata->nlpiterations < maxnlpiterations && objval < searchbound))
&& !SCIPisStopped(scip) )
{
divedepth++;
SCIP_CALL( SCIPnewProbingNode(scip) );
/* choose variable fixing:
* - prefer variables that may not be rounded without destroying LP feasibility:
* - of these variables, round variable with least number of locks in corresponding direction
* - if all remaining fractional variables may be rounded without destroying LP feasibility:
* - round variable with least number of locks in opposite of its feasible rounding direction
*/
bestcand = -1;
bestactscore = -1.0;
bestfrac = SCIP_INVALID;
bestcandmayrounddown = TRUE;
bestcandmayroundup = TRUE;
bestcandroundup = FALSE;
for( c = 0; c < nlpcands; ++c )
{
var = lpcands[c];
mayrounddown = SCIPvarMayRoundDown(var);
mayroundup = SCIPvarMayRoundUp(var);
frac = lpcandsfrac[c];
if( mayrounddown || mayroundup )
{
/* the candidate may be rounded: choose this candidate only, if the best candidate may also be rounded */
if( bestcandmayrounddown || bestcandmayroundup )
{
/* choose rounding direction:
* - if variable may be rounded in both directions, round corresponding to the fractionality
* - otherwise, round in the infeasible direction, because feasible direction is tried by rounding
* the current fractional solution
*/
if( mayrounddown && mayroundup )
roundup = (frac > 0.5);
else
roundup = mayrounddown;
if( roundup )
frac = 1.0 - frac;
actscore = getNActiveConsScore(scip, var, &downscore, &upscore);
/* penalize too small fractions */
if( frac < 0.01 )
actscore *= 0.01;
/* prefer decisions on binary variables */
if( !SCIPvarIsBinary(var) )
actscore *= 0.01;
/* check, if candidate is new best candidate */
assert(0.0 < frac && frac < 1.0);
if( SCIPisGT(scip, actscore, bestactscore) || (SCIPisGE(scip, actscore, bestactscore) && frac < bestfrac) )
{
bestcand = c;
bestactscore = actscore;
bestfrac = frac;
bestcandmayrounddown = mayrounddown;
bestcandmayroundup = mayroundup;
bestcandroundup = roundup;
}
}
}
else
{
/* the candidate may not be rounded */
actscore = getNActiveConsScore(scip, var, &downscore, &upscore);
roundup = (downscore < upscore);
if( roundup )
frac = 1.0 - frac;
/* penalize too small fractions */
if( frac < 0.01 )
actscore *= 0.01;
/* prefer decisions on binary variables */
if( !SCIPvarIsBinary(var) )
actscore *= 0.01;
/* check, if candidate is new best candidate: prefer unroundable candidates in any case */
assert(0.0 < frac && frac < 1.0);
if( bestcandmayrounddown || bestcandmayroundup || SCIPisGT(scip, actscore, bestactscore) ||
(SCIPisGE(scip, actscore, bestactscore) && frac < bestfrac) )
{
bestcand = c;
bestactscore = actscore;
bestfrac = frac;
bestcandmayrounddown = FALSE;
bestcandmayroundup = FALSE;
bestcandroundup = roundup;
}
assert(bestfrac < SCIP_INVALID);
}
}
assert(bestcand != -1);
/* if all candidates are roundable, try to round the solution */
if( bestcandmayrounddown || bestcandmayroundup )
{
SCIP_Bool success;
/* 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("actconsdiving 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;
}
}
}
assert(bestcand != -1);
var = lpcands[bestcand];
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] (solval: %.9f), diving aborted \n",
SCIPvarGetName(var), SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var), lpcandssol[bestcand]);
cutoff = TRUE;
break;
}
if( SCIPisFeasLT(scip, lpcandssol[bestcand], SCIPvarGetLbLocal(var)) || SCIPisFeasGT(scip, lpcandssol[bestcand], 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), lpcandssol[bestcand]);
assert(backtracked);
break;
}
/* apply rounding of best candidate */
if( bestcandroundup == !backtracked )
{
/* round variable up */
SCIPdebugMessage(" dive %d/%d, LP iter %"SCIP_LONGINT_FORMAT"/%"SCIP_LONGINT_FORMAT": var <%s>, round=%u/%u, sol=%g, oldbounds=[%g,%g], newbounds=[%g,%g]\n",
divedepth, maxdivedepth, heurdata->nlpiterations, maxnlpiterations,
SCIPvarGetName(var), bestcandmayrounddown, bestcandmayroundup,
lpcandssol[bestcand], SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var),
SCIPfeasCeil(scip, lpcandssol[bestcand]), SCIPvarGetUbLocal(var));
SCIP_CALL( SCIPchgVarLbProbing(scip, var, SCIPfeasCeil(scip, lpcandssol[bestcand])) );
}
else
{
/* round variable down */
SCIPdebugMessage(" dive %d/%d, LP iter %"SCIP_LONGINT_FORMAT"/%"SCIP_LONGINT_FORMAT": var <%s>, round=%u/%u, sol=%g, oldbounds=[%g,%g], newbounds=[%g,%g]\n",
divedepth, maxdivedepth, heurdata->nlpiterations, maxnlpiterations,
SCIPvarGetName(var), bestcandmayrounddown, bestcandmayroundup,
lpcandssol[bestcand], SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var),
SCIPvarGetLbLocal(var), SCIPfeasFloor(scip, lpcandssol[bestcand]));
SCIP_CALL( SCIPchgVarUbProbing(scip, lpcands[bestcand], SCIPfeasFloor(scip, lpcandssol[bestcand])) );
}
/* apply domain propagation */
SCIP_CALL( SCIPpropagateProbing(scip, 0, &cutoff, NULL) );
if( !cutoff )
{
/* 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 Actconsdiving 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 */
heurdata->nlpiterations += SCIPgetNLPIterations(scip) - nlpiterations;
/* get LP solution status, objective value, and fractional variables, that should be integral */
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) );
SCIP_CALL( SCIPnewProbingNode(scip) );
backtracked = TRUE;
}
else
backtracked = FALSE;
}
while( backtracked );
if( !lperror && !cutoff && lpsolstat == SCIP_LPSOLSTAT_OPTIMAL )
{
/* get new objective value */
oldobjval = objval;
objval = SCIPgetLPObjval(scip);
/* update pseudo cost values */
if( SCIPisGT(scip, objval, oldobjval) )
{
if( bestcandroundup )
{
SCIP_CALL( SCIPupdateVarPseudocost(scip, lpcands[bestcand], 1.0-lpcandsfrac[bestcand],
objval - oldobjval, 1.0) );
}
else
{
SCIP_CALL( SCIPupdateVarPseudocost(scip, lpcands[bestcand], 0.0-lpcandsfrac[bestcand],
objval - oldobjval, 1.0) );
}
}
/* get new fractional variables */
SCIP_CALL( SCIPgetLPBranchCands(scip, &lpcands, &lpcandssol, &lpcandsfrac, &nlpcands, NULL, NULL) );
}
SCIPdebugMessage(" -> lpsolstat=%d, objval=%g/%g, nfrac=%d\n", lpsolstat, objval, searchbound, nlpcands);
}
/* check if a solution has been found */
if( nlpcands == 0 && !lperror && !cutoff && lpsolstat == SCIP_LPSOLSTAT_OPTIMAL )
{
SCIP_Bool success;
/* create solution from diving LP */
SCIP_CALL( SCIPlinkLPSol(scip, heurdata->sol) );
SCIPdebugMessage("actconsdiving 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( SCIPendProbing(scip) );
if( *result == SCIP_FOUNDSOL )
heurdata->nsuccess++;
SCIPdebugMessage("(node %"SCIP_LONGINT_FORMAT") finished actconsdiving heuristic: %d fractionals, dive %d/%d, LP iter %"SCIP_LONGINT_FORMAT"/%"SCIP_LONGINT_FORMAT", objval=%g/%g, lpsolstat=%d, cutoff=%u\n",
SCIPgetNNodes(scip), nlpcands, divedepth, maxdivedepth, heurdata->nlpiterations, maxnlpiterations,
SCIPretransformObj(scip, objval), SCIPretransformObj(scip, searchbound), lpsolstat, cutoff);
return SCIP_OKAY;
}