/** evaluate the given candidate with the given score against the currently best know candidate */
static
void evaluateValueCand(
SCIP_VAR* cand, /**< candidate to be checked */
SCIP_Real score, /**< score of the candidate */
SCIP_Real branchpoint, /**< potential branching point */
SCIP_BRANCHDIR branchdir, /**< potential branching direction */
SCIP_VAR** bestcand, /**< pointer to the currently best candidate */
SCIP_Real* bestscore, /**< pointer to the score of the currently best candidate */
SCIP_Real* bestbranchpoint, /**< pointer to store the (best) branching point */
SCIP_BRANCHDIR* bestbranchdir /**< pointer to store the branching direction relative to the branching point */
)
{
/* evaluate the candidate against the currently best candidate */
if( (*bestscore) < score )
{
/* the score of the candidate is better than the currently best know candidate */
(*bestscore) = score;
(*bestcand) = cand;
(*bestbranchpoint) = branchpoint;
(*bestbranchdir) = branchdir;
}
else if( (*bestscore) == score ) /*lint !e777*/
{
SCIP_Real bestobj;
SCIP_Real candobj;
bestobj = REALABS(SCIPvarGetObj(*bestcand));
candobj = REALABS(SCIPvarGetObj(cand));
/* the candidate has the same score as the best known candidate; therefore we use a second and third
* criteria to detect a unique best candidate;
*
* - the second criteria prefers the candidate with a larger absolute value of its objective coefficient
* since branching on that variable might trigger further propagation w.r.t. objective function
* - if the absolute values of the objective coefficient are equal the variable index is used to define a
* unique best candidate
*
* @note It is very important to select a unique best candidate. Otherwise the solver might vary w.r.t. the
* performance to much since the candidate array which is used here (SCIPgetPseudoBranchCands() or
* SCIPgetLPBranchCands()) gets dynamically changed during the solution process. In particular,
* starting a probing mode might already change the order of these arrays. To be independent of that
* the selection should be unique. Otherwise, to selection process can get influenced by starting a
* probing or not.
*/
if( bestobj < candobj || (bestobj == candobj && SCIPvarGetIndex(*bestcand) < SCIPvarGetIndex(cand)) ) /*lint !e777*/
{
(*bestcand) = cand;
(*bestbranchpoint) = branchpoint;
(*bestbranchdir) = branchdir;
}
}
}
/** branching execution method for fractional LP solutions */
static
SCIP_DECL_BRANCHEXECLP(branchExeclpLeastinf)
{ /*lint --e{715}*/
SCIP_VAR** lpcands;
SCIP_Real* lpcandsfrac;
int nlpcands;
SCIP_Real infeasibility;
SCIP_Real score;
SCIP_Real obj;
SCIP_Real bestscore;
SCIP_Real bestobj;
int bestcand;
int i;
assert(branchrule != NULL);
assert(strcmp(SCIPbranchruleGetName(branchrule), BRANCHRULE_NAME) == 0);
assert(scip != NULL);
assert(result != NULL);
SCIPdebugMessage("Execlp method of leastinf branching\n");
/* get branching candidates */
SCIP_CALL( SCIPgetLPBranchCands(scip, &lpcands, NULL, &lpcandsfrac, NULL, &nlpcands, NULL) );
assert(nlpcands > 0);
/* search the least infeasible candidate */
bestscore = SCIP_REAL_MIN;
bestobj = 0.0;
bestcand = -1;
for( i = 0; i < nlpcands; ++i )
{
assert(lpcands[i] != NULL);
infeasibility = lpcandsfrac[i];
infeasibility = MIN(infeasibility, 1.0-infeasibility);
score = 1.0 - infeasibility;
score *= SCIPvarGetBranchFactor(lpcands[i]);
obj = SCIPvarGetObj(lpcands[i]);
obj = REALABS(obj);
if( SCIPisGT(scip, score, bestscore)
|| (SCIPisGE(scip, score, bestscore) && obj > bestobj) )
{
bestscore = score;
bestobj = obj;
bestcand = i;
}
}
assert(bestcand >= 0);
SCIPdebugMessage(" -> %d candidates, selected candidate %d: variable <%s> (frac=%g, obj=%g, factor=%g, score=%g)\n",
nlpcands, bestcand, SCIPvarGetName(lpcands[bestcand]), lpcandsfrac[bestcand], bestobj,
SCIPvarGetBranchFactor(lpcands[bestcand]), bestscore);
/* perform the branching */
SCIP_CALL( SCIPbranchVar(scip, lpcands[bestcand], NULL, NULL, NULL) );
*result = SCIP_BRANCHED;
return SCIP_OKAY;
}
/** find variable aggregations for downlock case */
static
SCIP_RETCODE findDownlockAggregations(
SCIP* scip, /**< SCIP main data structure */
SCIPMILPMATRIX* matrix, /**< constraint matrix */
int* nvaragg, /**< number of redundant variables */
AGGRTYPE* aggtypes, /**< type of aggregations (in same order as variables in matrix) */
SCIP_VAR** binvars /**< pointers to the binary variables (in same order as variables in matrix) */
)
{
int nvars;
int i;
assert(scip != NULL);
assert(matrix != NULL);
assert(nvaragg != NULL);
assert(aggtypes != NULL);
assert(binvars != NULL);
nvars = SCIPmatrixGetNColumns(matrix);
for( i = 0; i < nvars; i++ )
{
/* column has only one downlock which keeps it from being fixed by duality fixing;
* only handle variable if it was not yet aggregated due to a single uplock
*/
if( SCIPmatrixGetColNDownlocks(matrix, i) == 1 &&
SCIPisGE(scip, SCIPvarGetObj(SCIPmatrixGetVar(matrix, i)), 0.0) &&
aggtypes[i] == NOAGG )
{
SCIP_Real lb;
SCIP_Real ub;
lb = SCIPmatrixGetColLb(matrix, i);
ub = SCIPmatrixGetColUb(matrix, i);
assert(lb == SCIPvarGetLbGlobal(SCIPmatrixGetVar(matrix, i))); /*lint !e777*/
assert(ub == SCIPvarGetUbGlobal(SCIPmatrixGetVar(matrix, i))); /*lint !e777*/
/* the variable needs to have finite bounds to allow an agregation */
if( !SCIPisInfinity(scip, -lb) && !SCIPisInfinity(scip, ub) )
{
int binvaridx;
AGGRTYPE aggtype;
getBinVarIdxInDownlockRow(scip, matrix, i, &binvaridx, &aggtype);
if( binvaridx >= 0 )
{
aggtypes[i] = aggtype;
binvars[i] = SCIPmatrixGetVar(matrix, binvaridx);
(*nvaragg)++;
}
}
}
}
return SCIP_OKAY;
}
/** execution method of objective change event handler */
static
SCIP_DECL_EVENTEXEC(eventExecIntobj)
{ /*lint --e{715}*/
SCIP_EVENTHDLRDATA* eventhdlrdata;
SCIP_SEPADATA* sepadata;
SCIP_VAR* var;
SCIP_Real objdelta;
eventhdlrdata = SCIPeventhdlrGetData(eventhdlr);
sepadata = (SCIP_SEPADATA*)eventhdlrdata;
assert(sepadata != NULL);
/* we don't have anything to do, if the objective value inequality doesn't yet exist */
if( sepadata->objrow == NULL )
return SCIP_OKAY;
var = SCIPeventGetVar(event);
switch( SCIPeventGetType(event) )
{
case SCIP_EVENTTYPE_VARADDED:
SCIPdebugMessage("variable <%s> with obj=%g was added to the problem\n", SCIPvarGetName(var), SCIPvarGetObj(var));
objdelta = SCIPvarGetObj(var);
if( !SCIPisZero(scip, objdelta) )
{
SCIP_CALL( SCIPaddVarToRow(scip, sepadata->objrow, var, SCIPvarGetObj(var)) );
}
break;
case SCIP_EVENTTYPE_OBJCHANGED:
SCIPdebugMessage("variable <%s> changed objective value from %g to %g\n",
SCIPvarGetName(var), SCIPeventGetOldobj(event), SCIPeventGetNewobj(event));
objdelta = SCIPeventGetNewobj(event) - SCIPeventGetOldobj(event);
SCIP_CALL( SCIPaddVarToRow(scip, sepadata->objrow, var, objdelta) );
break;
default:
SCIPerrorMessage("invalid event type %x\n", SCIPeventGetType(event));
return SCIP_INVALIDDATA;
}
return SCIP_OKAY;
}
/** calculate score and preferred rounding direction for the candidate variable; the best candidate maximizes the
* score
*/
static
SCIP_DECL_DIVESETGETSCORE(divesetGetScoreGuideddiving)
{
SCIP_SOL* bestsol;
SCIP_Real bestsolval;
SCIP_Real obj;
SCIP_Real objnorm;
SCIP_Real objgain;
bestsol = SCIPgetBestSol(scip);
assert(bestsol != NULL);
assert(!SCIPsolIsOriginal(bestsol));
bestsolval = SCIPgetSolVal(scip, bestsol, cand);
/* variable should be rounded (guided) into the direction of its incumbent solution value */
if( candsol < bestsolval )
*roundup = TRUE;
else
*roundup = FALSE;
obj = SCIPvarGetObj(cand);
objnorm = SCIPgetObjNorm(scip);
/* divide by objective norm to normalize obj into [-1,1] */
if( SCIPisPositive(scip, objnorm) )
obj /= objnorm;
/* calculate objective gain and fractionality for the selected rounding direction */
if( *roundup )
{
candsfrac = 1.0 - candsfrac;
objgain = obj * candsfrac;
}
else
objgain = -obj * candsfrac;
assert(objgain >= -1.0 && objgain <= 1.0);
/* penalize too small fractions */
if( candsfrac < 0.01 )
candsfrac *= 0.1;
/* prefer decisions on binary variables */
if( !SCIPvarIsBinary(cand) )
candsfrac *= 0.1;
/* prefer variables which cannot be rounded by scoring their fractionality */
if( !(SCIPvarMayRoundDown(cand) || SCIPvarMayRoundUp(cand)) )
*score = -candsfrac;
else
*score = -2.0 - objgain;
return SCIP_OKAY;
}
/** read variable */
static
SCIP_RETCODE getVariable(
SCIP* scip, /**< SCIP data structure */
CIPINPUT* cipinput, /**< CIP parsing data */
SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
SCIP_Real objscale /**< objective scale */
)
{
SCIP_Bool success;
SCIP_VAR* var;
char* buf;
char* endptr;
buf = cipinput->strbuf;
if( strncmp(buf, "FIXED", 5) == 0 )
cipinput->section = CIP_FIXEDVARS;
else if( strncmp(buf, "CONSTRAINTS", 4) == 0 )
cipinput->section = CIP_CONSTRAINTS;
else if( strncmp(buf, "END", 3) == 0 )
cipinput->section = CIP_END;
if( cipinput->section != CIP_VARS )
return SCIP_OKAY;
SCIPdebugMessage("parse variable\n");
/* parse the variable */
SCIP_CALL( SCIPparseVar(scip, &var, buf, initial, removable, NULL, NULL, NULL, NULL, NULL, &endptr, &success) );
if( !success )
{
SCIPerrorMessage("syntax error in variable information (line: %d):\n%s\n", cipinput->linenumber, cipinput->strbuf);
cipinput->haserror = TRUE;
return SCIP_OKAY;
}
if( objscale != 1.0 )
{
SCIP_CALL( SCIPchgVarObj(scip, var, SCIPvarGetObj(var) * objscale) );
}
SCIP_CALL( SCIPaddVar(scip, var) );
SCIPdebug( SCIP_CALL( SCIPprintVar(scip, var, NULL) ) );
SCIP_CALL( SCIPreleaseVar(scip, &var) );
return SCIP_OKAY;
}
/** adds given problem variable to pricing storage, if zero is not best bound w.r.t. objective function */
static
SCIP_RETCODE addBoundViolated(
SCIP_PRICESTORE* pricestore, /**< pricing storage */
BMS_BLKMEM* blkmem, /**< block memory buffers */
SCIP_SET* set, /**< global SCIP settings */
SCIP_STAT* stat, /**< dynamic problem statistics */
SCIP_TREE* tree, /**< branch and bound tree */
SCIP_LP* lp, /**< LP data */
SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
SCIP_EVENTQUEUE* eventqueue, /**< event queue */
SCIP_VAR* var, /**< problem variable */
SCIP_Bool* added /**< pointer to store whether variable was added to pricing storage */
)
{
assert(tree != NULL);
assert(added != NULL);
*added = FALSE;
/* add variable, if zero is not feasible within the bounds */
if( SCIPsetIsPositive(set, SCIPvarGetLbLocal(var)) || SCIPsetIsNegative(set, SCIPvarGetUbLocal(var)) )
{
SCIPdebugMessage(" -> zero violates bounds of <%s> [%g,%g]\n",
SCIPvarGetName(var), SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var));
SCIP_CALL( SCIPpricestoreAddBdviolvar(pricestore, blkmem, set, stat, lp, branchcand, eventqueue, var) );
*added = TRUE;
}
else
{
SCIP_Real bestbound;
/* add variable, if zero is not best bound w.r.t. objective function */
bestbound = SCIPvarGetBestBoundLocal(var);
if( !SCIPsetIsZero(set, bestbound) )
{
SCIPdebugMessage(" -> best bound of <%s> [%g,%g] is not zero but %g\n",
SCIPvarGetName(var), SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var), bestbound);
SCIP_CALL( SCIPpricestoreAddVar(pricestore, blkmem, set, eventqueue, lp, var,
-SCIPvarGetObj(var) * bestbound, (SCIPtreeGetCurrentDepth(tree) == 0)) );
*added = TRUE;
}
}
return SCIP_OKAY;
}
/** generates the direction of the shooting ray as the inner normal of the objective function */
static
SCIP_RETCODE generateObjectiveRay(
SCIP* scip, /**< SCIP data structure */
SCIP_Real* raydirection, /**< shooting ray */
SCIP_VAR** subspacevars, /**< pointer to fractional space variables */
int nsubspacevars /**< dimension of fractional space */
)
{
int v;
assert(scip != NULL);
assert(raydirection != NULL);
assert(subspacevars != NULL);
for( v = nsubspacevars - 1; v >= 0; --v )
raydirection[v] = SCIPvarGetObj(subspacevars[v]);
return SCIP_OKAY;
}
/** adds a solution value for a new variable in the transformed problem that has no original counterpart
* a value can only be set if no value has been set for this variable before
*/
extern
SCIP_RETCODE SCIPdebugAddSolVal(
SCIP* scip, /**< SCIP data structure */
SCIP_VAR* var, /**< variable for which to add a value */
SCIP_Real val /**< solution value for variable */
)
{
const char* varname;
int i;
assert(var != NULL);
/* check if we are in the SCIP instance that we are debugging and not some different (subSCIP, auxiliary CIP, ...) */
if( !isSolutionInMip(scip->set) )
return SCIP_OKAY;
if( SCIPvarIsOriginal(var) )
{
SCIPerrorMessage("adding solution values for original variables is forbidden\n");
return SCIP_ERROR;
}
if( SCIPvarIsTransformedOrigvar(var) )
{
SCIPerrorMessage("adding solution values for variable that are direct counterparts of original variables is forbidden\n");
return SCIP_ERROR;
}
/* allocate memory */
if( nsolvals >= solsize )
{
solsize = MAX(2*solsize, nsolvals+1);
SCIP_ALLOC( BMSreallocMemoryArray(&solnames, solsize) );
SCIP_ALLOC( BMSreallocMemoryArray(&solvals, solsize) );
}
assert(nsolvals < solsize);
/* store solution value in sorted list */
varname = SCIPvarGetName(var);
for( i = nsolvals; i > 0 && strcmp(varname, solnames[i-1]) < 0; --i )
{
solnames[i] = solnames[i-1];
solvals[i] = solvals[i-1];
}
if( i > 0 && strcmp(varname, solnames[i-1]) == 0 )
{
if( REALABS(solvals[i-1] - val) > 1e-9 )
{
SCIPerrorMessage("already have stored different debugging solution value (%g) for variable <%s>, cannot store %g\n", solvals[i-1], varname, val);
return SCIP_ERROR;
}
else
{
SCIPdebugMessage("already have stored debugging solution value %g for variable <%s>, do not store same value again\n", val, varname);
for( ; i < nsolvals; ++i )
{
solnames[i] = solnames[i+1];
solvals[i] = solvals[i+1];
}
return SCIP_OKAY;
}
}
/* insert new solution value */
SCIP_ALLOC( BMSduplicateMemoryArray(&solnames[i], varname, strlen(varname)+1) );
SCIPdebugMessage("add variable <%s>: value <%g>\n", solnames[i], val);
solvals[i] = val;
nsolvals++;
/* update objective function value of debug solution */
debugsolval += solvals[i] * SCIPvarGetObj(var);
SCIPdebugMessage("Debug Solution value is now %g.\n", debugsolval);
return SCIP_OKAY;
}
/** execution method of presolver */
static
SCIP_DECL_PRESOLEXEC(presolExecDualfix)
{ /*lint --e{715}*/
SCIP_VAR** vars;
SCIP_Real bound;
SCIP_Real roundbound;
SCIP_Real obj;
SCIP_Bool infeasible;
SCIP_Bool fixed;
int nvars;
int v;
assert(presol != NULL);
assert(strcmp(SCIPpresolGetName(presol), PRESOL_NAME) == 0);
assert(result != NULL);
*result = SCIP_DIDNOTFIND;
/* get active problem variables */
vars = SCIPgetVars(scip);
nvars = SCIPgetNVars(scip);
/* look for fixable variables
* loop backwards, since a variable fixing can change the current and the subsequent slots in the vars array
*/
for( v = nvars - 1; v >= 0; --v )
{
/* don't perform dual presolving operations on deleted variables */
if( SCIPvarIsDeleted(vars[v]) )
continue;
obj = SCIPvarGetObj(vars[v]);
/* if the objective coefficient of the variable is 0 and it may be rounded both
* up and down, then fix it to the closest feasible value to 0 */
if( SCIPisZero(scip, obj) && SCIPvarMayRoundDown(vars[v]) && SCIPvarMayRoundUp(vars[v]) )
{
bound = SCIPvarGetLbGlobal(vars[v]);
if( SCIPisLT(scip, bound, 0.0) )
{
if( SCIPisLE(scip, 0.0, SCIPvarGetUbGlobal(vars[v])) )
bound = 0.0;
else
{
/* try to take an integer value, only for polishing */
roundbound = SCIPfloor(scip, SCIPvarGetUbGlobal(vars[v]));
if( roundbound < bound )
bound = SCIPvarGetUbGlobal(vars[v]);
else
bound = roundbound;
}
}
else
{
/* try to take an integer value, only for polishing */
roundbound = SCIPceil(scip, bound);
if( roundbound < SCIPvarGetUbGlobal(vars[v]) )
bound = roundbound;
}
SCIPdebugMessage("variable <%s> with objective 0 fixed to %g\n",
SCIPvarGetName(vars[v]), bound);
}
else
{
/* if it is always possible to round variable in direction of objective value,
* fix it to its proper bound
*/
if( SCIPvarMayRoundDown(vars[v]) && !SCIPisNegative(scip, obj) )
{
bound = SCIPvarGetLbGlobal(vars[v]);
if( SCIPisZero(scip, obj) && SCIPvarGetNLocksUp(vars[v]) == 1 && SCIPisInfinity(scip, -bound) )
{
/* variable can be set to -infinity, and it is only contained in one constraint:
* we hope that the corresponding constraint handler is clever enough to set/aggregate the variable
* to something more useful than -infinity and do nothing here
*/
continue;
}
SCIPdebugMessage("variable <%s> with objective %g and %d uplocks fixed to lower bound %g\n",
SCIPvarGetName(vars[v]), SCIPvarGetObj(vars[v]), SCIPvarGetNLocksUp(vars[v]), bound);
}
else if( SCIPvarMayRoundUp(vars[v]) && !SCIPisPositive(scip, obj) )
{
bound = SCIPvarGetUbGlobal(vars[v]);
if( SCIPisZero(scip, obj) && SCIPvarGetNLocksDown(vars[v]) == 1 && SCIPisInfinity(scip, bound) )
{
/* variable can be set to +infinity, and it is only contained in one constraint:
* we hope that the corresponding constraint handler is clever enough to set/aggregate the variable
* to something more useful than +infinity and do nothing here
*/
continue;
}
SCIPdebugMessage("variable <%s> with objective %g and %d downlocks fixed to upper bound %g\n",
SCIPvarGetName(vars[v]), SCIPvarGetObj(vars[v]), SCIPvarGetNLocksDown(vars[v]), bound);
}
else
continue;
}
/* apply the fixing */
if( SCIPisInfinity(scip, REALABS(bound)) && !SCIPisZero(scip, obj) )
{
SCIPdebugMessage(" -> unbounded fixing\n");
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL,
"problem infeasible or unbounded: variable <%s> with objective %.15g can be made infinitely %s\n",
SCIPvarGetName(vars[v]), SCIPvarGetObj(vars[v]), bound < 0.0 ? "small" : "large");
*result = SCIP_UNBOUNDED;
return SCIP_OKAY;
}
SCIP_CALL( SCIPfixVar(scip, vars[v], bound, &infeasible, &fixed) );
if( infeasible )
{
SCIPdebugMessage(" -> infeasible fixing\n");
*result = SCIP_CUTOFF;
return SCIP_OKAY;
}
assert(fixed);
(*nfixedvars)++;
*result = SCIP_SUCCESS;
}
return SCIP_OKAY;
}
/** 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;
}
/** perform randomized rounding of the given solution. Domain propagation is optionally applied after every rounding
* step
*/
static
SCIP_RETCODE performRandRounding(
SCIP* scip, /**< SCIP main data structure */
SCIP_HEURDATA* heurdata, /**< heuristic data */
SCIP_SOL* sol, /**< solution to round */
SCIP_VAR** cands, /**< candidate variables */
int ncands, /**< number of candidates */
SCIP_Bool propagate, /**< should the rounding be propagated? */
SCIP_RESULT* result /**< pointer to store the result of the heuristic call */
)
{
int c;
SCIP_Bool stored;
SCIP_VAR** permutedcands;
SCIP_Bool cutoff;
assert(heurdata != NULL);
/* start probing tree before rounding begins */
if( propagate )
{
SCIP_CALL( SCIPstartProbing(scip) );
SCIPenableVarHistory(scip);
}
/* copy and permute the candidate array */
SCIP_CALL( SCIPduplicateBufferArray(scip, &permutedcands, cands, ncands) );
assert(permutedcands != NULL);
SCIPpermuteArray((void **)permutedcands, 0, ncands, &heurdata->randseed);
cutoff = FALSE;
/* loop over candidates and perform randomized rounding and optionally probing. */
for (c = 0; c < ncands && !cutoff; ++c)
{
SCIP_VAR* var;
SCIP_Real oldsolval;
SCIP_Real newsolval;
SCIP_Bool mayrounddown;
SCIP_Bool mayroundup;
SCIP_Longint ndomreds;
SCIP_Real lb;
SCIP_Real ub;
SCIP_Real ceilval;
SCIP_Real floorval;
/* get next variable from permuted candidate array */
var = permutedcands[c];
oldsolval = SCIPgetSolVal(scip, sol, var);
lb = SCIPvarGetLbLocal(var);
ub = SCIPvarGetUbLocal(var);
assert( ! SCIPisFeasIntegral(scip, oldsolval) );
assert( SCIPvarGetStatus(var) == SCIP_VARSTATUS_COLUMN );
mayrounddown = SCIPvarMayRoundDown(var);
mayroundup = SCIPvarMayRoundUp(var);
ceilval = SCIPfeasCeil(scip, oldsolval);
floorval = SCIPfeasFloor(scip, oldsolval);
SCIPdebugMessage("rand rounding heuristic: var <%s>, val=%g, rounddown=%u, roundup=%u\n",
SCIPvarGetName(var), oldsolval, mayrounddown, mayroundup);
/* abort if rounded ceil and floor value lie outside the variable domain. Otherwise, check if
* bounds allow only one rounding direction, anyway */
if( lb > ceilval + 0.5 || ub < floorval - 0.5 )
{
cutoff = TRUE;
break;
}
else if( SCIPisFeasEQ(scip, lb, ceilval) )
{
/* only rounding up possible */
assert(SCIPisFeasGE(scip, ub, ceilval));
newsolval = ceilval;
}
else if( SCIPisFeasEQ(scip, ub, floorval) )
{
/* only rounding down possible */
assert(SCIPisFeasLE(scip,lb, floorval));
newsolval = floorval;
}
else if( !heurdata->usesimplerounding || !(mayroundup || mayrounddown) )
{
/* the standard randomized rounding */
SCIP_Real randnumber;
randnumber = SCIPgetRandomReal(0.0, 1.0, &heurdata->randseed);
if( randnumber <= oldsolval - floorval )
newsolval = ceilval;
else
newsolval = floorval;
}
/* choose rounding direction, if possible, or use the only direction guaranteed to be feasible */
else if( mayrounddown && mayroundup )
{
/* we can round in both directions: round in objective function direction */
if ( SCIPvarGetObj(var) >= 0.0 )
newsolval = floorval;
else
newsolval = ceilval;
}
else if( mayrounddown )
newsolval = floorval;
else
{
assert(mayroundup);
newsolval = ceilval;
}
assert(SCIPisFeasLE(scip, lb, newsolval));
assert(SCIPisFeasGE(scip, ub, newsolval));
/* if propagation is enabled, fix the candidate variable to its rounded value and propagate the solution */
if( propagate )
{
SCIP_Bool lbadjust;
SCIP_Bool ubadjust;
lbadjust = SCIPisGT(scip, newsolval, lb);
ubadjust = SCIPisLT(scip, newsolval, ub);
assert( lbadjust || ubadjust || SCIPisFeasEQ(scip, lb, ub));
/* enter a new probing node if the variable was not already fixed before */
if( lbadjust || ubadjust )
{
SCIP_RETCODE retcode;
if( SCIPisStopped(scip) )
break;
retcode = SCIPnewProbingNode(scip);
if( retcode == SCIP_MAXDEPTHLEVEL )
break;
SCIP_CALL( retcode );
/* tighten the bounds to fix the variable for the probing node */
if( lbadjust )
{
SCIP_CALL( SCIPchgVarLbProbing(scip, var, newsolval) );
}
if( ubadjust )
{
SCIP_CALL( SCIPchgVarUbProbing(scip, var, newsolval) );
}
/* call propagation routines for the reduced problem */
SCIP_CALL( SCIPpropagateProbing(scip, heurdata->maxproprounds, &cutoff, &ndomreds) );
}
}
/* store new solution value */
SCIP_CALL( SCIPsetSolVal(scip, sol, var, newsolval) );
}
/* if no cutoff was detected, the solution is a candidate to be checked for feasibility */
if( !cutoff && ! SCIPisStopped(scip) )
{
if( SCIPallColsInLP(scip) )
{
/* check solution for feasibility, and add it to solution store if possible
* neither integrality nor feasibility of LP rows has to be checked, because all fractional
* variables were already moved in feasible direction to the next integer
*/
SCIP_CALL( SCIPtrySol(scip, sol, FALSE, FALSE, FALSE, TRUE, &stored) );
}
else
{
/* if there are variables which are not present in the LP, e.g., for
* column generation, we need to check their bounds
*/
SCIP_CALL( SCIPtrySol(scip, sol, FALSE, TRUE, FALSE, TRUE, &stored) );
}
if( stored )
{
#ifdef SCIP_DEBUG
SCIPdebugMessage("found feasible rounded solution:\n");
SCIP_CALL( SCIPprintSol(scip, sol, NULL, FALSE) );
#endif
*result = SCIP_FOUNDSOL;
}
}
assert( !propagate || SCIPinProbing(scip) );
/* exit probing mode and free locally allocated memory */
if( propagate )
{
SCIP_CALL( SCIPendProbing(scip) );
}
SCIPfreeBufferArray(scip, &permutedcands);
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;
}
/** perform dual presolving */
static
SCIP_RETCODE performDualfix(
SCIP* scip, /**< SCIP data structure */
int* nfixedvars, /**< pointer to store number of fixed variables */
SCIP_Bool* unbounded, /**< pointer to store if an unboundness was detected */
SCIP_Bool* cutoff /**< pointer to store if a cutoff was detected */
)
{
SCIP_VAR** vars;
int nvars;
int v;
/* get active problem variables */
vars = SCIPgetVars(scip);
nvars = SCIPgetNVars(scip);
/* look for fixable variables
* loop backwards, since a variable fixing can change the current and the subsequent slots in the vars array
*/
for( v = nvars - 1; v >= 0; --v )
{
SCIP_VAR* var;
SCIP_Real bound;
SCIP_Real obj;
SCIP_Bool infeasible;
SCIP_Bool fixed;
var = vars[v];
assert(var != NULL);
/* don't perform dual presolving operations on deleted variables */
if( SCIPvarIsDeleted(var) )
continue;
/* ignore already fixed variables (use feasibility tolerance since this is used in SCIPfixVar() */
if( SCIPisFeasEQ(scip, SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var)) )
continue;
obj = SCIPvarGetObj(var);
/* if the objective coefficient of the variable is 0 and it may be rounded both
* up and down, then fix it to the closest feasible value to 0 */
if( SCIPisZero(scip, obj) && SCIPvarMayRoundDown(var) && SCIPvarMayRoundUp(var) )
{
SCIP_Real roundbound;
bound = SCIPvarGetLbGlobal(var);
if( SCIPisLT(scip, bound, 0.0) )
{
if( SCIPisLE(scip, 0.0, SCIPvarGetUbGlobal(var)) )
bound = 0.0;
else
{
/* try to take an integer value, only for polishing */
roundbound = SCIPfloor(scip, SCIPvarGetUbGlobal(var));
if( roundbound < bound )
bound = SCIPvarGetUbGlobal(var);
else
bound = roundbound;
}
}
else
{
/* try to take an integer value, only for polishing */
roundbound = SCIPceil(scip, bound);
if( roundbound < SCIPvarGetUbGlobal(var) )
bound = roundbound;
}
SCIPdebugMessage("fixing variable <%s> with objective 0 to %g\n", SCIPvarGetName(var), bound);
}
else
{
/* if it is always possible to round variable in direction of objective value, fix it to its proper bound */
if( SCIPvarMayRoundDown(var) && !SCIPisNegative(scip, obj) )
{
bound = SCIPvarGetLbGlobal(var);
if ( SCIPisInfinity(scip, -bound) )
{
/* variable can be fixed to -infinity */
if ( SCIPgetStage(scip) > SCIP_STAGE_PRESOLVING )
{
/* Fixing variables to infinity is not allowed after presolving, since LP-solvers cannot handle this
* consistently. We thus have to ignore this (should better be handled in presolving). */
continue;
}
if ( SCIPisZero(scip, obj) && SCIPvarGetNLocksUp(var) == 1 )
{
/* Variable is only contained in one constraint: we hope that the corresponding constraint handler is
* clever enough to set/aggregate the variable to something more useful than -infinity and do nothing
* here. */
continue;
}
}
SCIPdebugMessage("fixing variable <%s> with objective %g and %d uplocks to lower bound %g\n",
SCIPvarGetName(var), SCIPvarGetObj(var), SCIPvarGetNLocksUp(var), bound);
}
else if( SCIPvarMayRoundUp(var) && !SCIPisPositive(scip, obj) )
{
bound = SCIPvarGetUbGlobal(var);
if ( SCIPisInfinity(scip, bound) )
{
/* variable can be fixed to infinity */
if ( SCIPgetStage(scip) > SCIP_STAGE_PRESOLVING )
{
/* Fixing variables to infinity is not allowed after presolving, since LP-solvers cannot handle this
* consistently. We thus have to ignore this (should better be handled in presolving). */
continue;
}
if ( SCIPisZero(scip, obj) && SCIPvarGetNLocksDown(var) == 1 )
{
/* Variable is only contained in one constraint: we hope that the corresponding constraint handler is
* clever enough to set/aggregate the variable to something more useful than +infinity and do nothing
* here */
continue;
}
}
SCIPdebugMessage("fixing variable <%s> with objective %g and %d downlocks to upper bound %g\n",
SCIPvarGetName(var), SCIPvarGetObj(var), SCIPvarGetNLocksDown(var), bound);
}
else
continue;
}
if( SCIPisInfinity(scip, REALABS(bound)) && !SCIPisZero(scip, obj) )
{
SCIPdebugMessage(" -> unbounded fixing\n");
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL,
"problem infeasible or unbounded: variable <%s> with objective %.15g can be made infinitely %s\n",
SCIPvarGetName(var), SCIPvarGetObj(var), bound < 0.0 ? "small" : "large");
*unbounded = TRUE;
return SCIP_OKAY;
}
/* apply the fixing */
SCIPdebugMessage("apply fixing of variable %s to %g\n", SCIPvarGetName(var), bound);
SCIP_CALL( SCIPfixVar(scip, var, bound, &infeasible, &fixed) );
if( infeasible )
{
SCIPdebugMessage(" -> infeasible fixing\n");
*cutoff = TRUE;
return SCIP_OKAY;
}
assert(fixed || (SCIPgetStage(scip) == SCIP_STAGE_SOLVING && SCIPisFeasEQ(scip, bound, SCIPvarGetLbLocal(var))
&& SCIPisFeasEQ(scip, bound, SCIPvarGetUbLocal(var))));
(*nfixedvars)++;
}
return SCIP_OKAY;
}
/** 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;
}
/** 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;
* prefer fractional integers over other variables in order to become integral during the process;
* shifting in a direction is forbidden, if this forces the objective value over the upper bound, or if the variable
* was already shifted in the opposite direction
*/
static
SCIP_RETCODE selectShifting(
SCIP* scip, /**< SCIP data structure */
SCIP_SOL* sol, /**< primal solution */
SCIP_ROW* row, /**< LP row */
SCIP_Real rowactivity, /**< activity of LP row */
int direction, /**< should the activity be increased (+1) or decreased (-1)? */
SCIP_Real* nincreases, /**< array with weighted number of increasings per variables */
SCIP_Real* ndecreases, /**< array with weighted number of decreasings per variables */
SCIP_Real increaseweight, /**< current weight of increase/decrease updates */
SCIP_VAR** shiftvar, /**< pointer to store the shifting variable, returns NULL if impossible */
SCIP_Real* oldsolval, /**< pointer to store old solution value of shifting variable */
SCIP_Real* newsolval /**< pointer to store new (shifted) solution value of shifting variable */
)
{
SCIP_COL** rowcols;
SCIP_Real* rowvals;
int nrowcols;
SCIP_Real activitydelta;
SCIP_Real bestshiftscore;
SCIP_Real bestdeltaobj;
int c;
assert(direction == +1 || direction == -1);
assert(nincreases != NULL);
assert(ndecreases != NULL);
assert(shiftvar != NULL);
assert(oldsolval != NULL);
assert(newsolval != NULL);
/* get row entries */
rowcols = SCIProwGetCols(row);
rowvals = SCIProwGetVals(row);
nrowcols = SCIProwGetNLPNonz(row);
/* calculate how much the activity must be shifted in order to become feasible */
activitydelta = (direction == +1 ? SCIProwGetLhs(row) - rowactivity : SCIProwGetRhs(row) - rowactivity);
assert((direction == +1 && SCIPisPositive(scip, activitydelta))
|| (direction == -1 && SCIPisNegative(scip, activitydelta)));
/* select shifting variable */
bestshiftscore = SCIP_REAL_MAX;
bestdeltaobj = SCIPinfinity(scip);
*shiftvar = NULL;
*newsolval = 0.0;
*oldsolval = 0.0;
for( c = 0; c < nrowcols; ++c )
{
SCIP_COL* col;
SCIP_VAR* var;
SCIP_Real val;
SCIP_Real solval;
SCIP_Real shiftval;
SCIP_Real shiftscore;
SCIP_Bool isinteger;
SCIP_Bool isfrac;
SCIP_Bool increase;
col = rowcols[c];
var = SCIPcolGetVar(col);
val = rowvals[c];
assert(!SCIPisZero(scip, val));
solval = SCIPgetSolVal(scip, sol, var);
isinteger = (SCIPvarGetType(var) == SCIP_VARTYPE_BINARY || SCIPvarGetType(var) == SCIP_VARTYPE_INTEGER);
isfrac = isinteger && !SCIPisFeasIntegral(scip, solval);
increase = (direction * val > 0.0);
/* calculate the score of the shifting (prefer smaller values) */
if( isfrac )
shiftscore = increase ? -1.0 / (SCIPvarGetNLocksUp(var) + 1.0) :
-1.0 / (SCIPvarGetNLocksDown(var) + 1.0);
else
{
int probindex;
probindex = SCIPvarGetProbindex(var);
if( increase )
shiftscore = ndecreases[probindex]/increaseweight;
else
shiftscore = nincreases[probindex]/increaseweight;
if( isinteger )
shiftscore += 1.0;
}
if( shiftscore <= bestshiftscore )
{
SCIP_Real deltaobj;
if( !increase )
{
/* shifting down */
assert(direction * val < 0.0);
if( isfrac )
shiftval = SCIPfeasFloor(scip, solval);
else
{
SCIP_Real lb;
assert(activitydelta/val < 0.0);
shiftval = solval + activitydelta/val;
assert(shiftval <= solval); /* may be equal due to numerical digit erasement in the subtraction */
if( SCIPvarIsIntegral(var) )
shiftval = SCIPfeasFloor(scip, shiftval);
lb = SCIPvarGetLbGlobal(var);
shiftval = MAX(shiftval, lb);
}
}
else
{
/* shifting up */
assert(direction * val > 0.0);
if( isfrac )
shiftval = SCIPfeasCeil(scip, solval);
else
{
SCIP_Real ub;
assert(activitydelta/val > 0.0);
shiftval = solval + activitydelta/val;
assert(shiftval >= solval); /* may be equal due to numerical digit erasement in the subtraction */
if( SCIPvarIsIntegral(var) )
shiftval = SCIPfeasCeil(scip, shiftval);
ub = SCIPvarGetUbGlobal(var);
shiftval = MIN(shiftval, ub);
}
}
if( SCIPisEQ(scip, shiftval, solval) )
continue;
deltaobj = SCIPvarGetObj(var) * (shiftval - solval);
if( shiftscore < bestshiftscore || deltaobj < bestdeltaobj )
{
bestshiftscore = shiftscore;
bestdeltaobj = deltaobj;
*shiftvar = var;
*oldsolval = solval;
*newsolval = shiftval;
}
}
}
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;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecOneopt)
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_SOL* bestsol; /* incumbent solution */
SCIP_SOL* worksol; /* heuristic's working solution */
SCIP_VAR** vars; /* SCIP variables */
SCIP_VAR** shiftcands; /* shiftable variables */
SCIP_ROW** lprows; /* SCIP LP rows */
SCIP_Real* activities; /* row activities for working solution */
SCIP_Real* shiftvals;
SCIP_Real lb;
SCIP_Real ub;
SCIP_Bool localrows;
SCIP_Bool valid;
int nchgbound;
int nbinvars;
int nintvars;
int nvars;
int nlprows;
int i;
int nshiftcands;
int shiftcandssize;
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;
/* we only want to process each solution once */
bestsol = SCIPgetBestSol(scip);
if( bestsol == NULL || heurdata->lastsolindex == SCIPsolGetIndex(bestsol) )
return SCIP_OKAY;
/* reset the timing mask to its default value (at the root node it could be different) */
if( SCIPgetNNodes(scip) > 1 )
SCIPheurSetTimingmask(heur, HEUR_TIMING);
/* get problem variables */
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, &nbinvars, &nintvars, NULL, NULL) );
nintvars += nbinvars;
/* do not run if there are no discrete variables */
if( nintvars == 0 )
{
*result = SCIP_DIDNOTRUN;
return SCIP_OKAY;
}
if( heurtiming == SCIP_HEURTIMING_BEFOREPRESOL )
{
SCIP* subscip; /* the subproblem created by zeroobj */
SCIP_HASHMAP* varmapfw; /* mapping of SCIP variables to sub-SCIP variables */
SCIP_VAR** subvars; /* subproblem's variables */
SCIP_Real* subsolvals; /* solution values of the subproblem */
SCIP_Real timelimit; /* time limit for zeroobj subproblem */
SCIP_Real memorylimit; /* memory limit for zeroobj subproblem */
SCIP_SOL* startsol;
SCIP_SOL** subsols;
int nsubsols;
if( !heurdata->beforepresol )
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;
/* 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) );
/* copy complete SCIP instance */
valid = FALSE;
SCIP_CALL( SCIPcopy(scip, subscip, varmapfw, NULL, "oneopt", TRUE, FALSE, TRUE, &valid) );
SCIP_CALL( SCIPtransformProb(subscip) );
/* get variable image */
for( i = 0; i < nvars; i++ )
subvars[i] = (SCIP_VAR*) SCIPhashmapGetImage(varmapfw, vars[i]);
/* copy the solution */
SCIP_CALL( SCIPallocBufferArray(scip, &subsolvals, nvars) );
SCIP_CALL( SCIPgetSolVals(scip, bestsol, nvars, vars, subsolvals) );
/* create start solution for the subproblem */
SCIP_CALL( SCIPcreateOrigSol(subscip, &startsol, NULL) );
SCIP_CALL( SCIPsetSolVals(subscip, startsol, nvars, subvars, subsolvals) );
/* try to add new solution to sub-SCIP and free it immediately */
valid = FALSE;
SCIP_CALL( SCIPtrySolFree(subscip, &startsol, FALSE, FALSE, FALSE, FALSE, &valid) );
SCIPfreeBufferArray(scip, &subsolvals);
SCIPhashmapFree(&varmapfw);
/* disable statistic timing inside sub SCIP */
SCIP_CALL( SCIPsetBoolParam(subscip, "timing/statistictiming", FALSE) );
/* deactivate basically everything except oneopt in the sub-SCIP */
SCIP_CALL( SCIPsetPresolving(subscip, SCIP_PARAMSETTING_OFF, TRUE) );
SCIP_CALL( SCIPsetHeuristics(subscip, SCIP_PARAMSETTING_OFF, TRUE) );
SCIP_CALL( SCIPsetSeparating(subscip, SCIP_PARAMSETTING_OFF, TRUE) );
SCIP_CALL( SCIPsetLongintParam(subscip, "limits/nodes", 1LL) );
SCIP_CALL( SCIPsetRealParam(subscip, "limits/time", timelimit) );
SCIP_CALL( SCIPsetRealParam(subscip, "limits/memory", memorylimit) );
SCIP_CALL( SCIPsetBoolParam(subscip, "misc/catchctrlc", FALSE) );
SCIP_CALL( SCIPsetIntParam(subscip, "display/verblevel", 0) );
/* if necessary, some of the parameters have to be unfixed first */
if( SCIPisParamFixed(subscip, "lp/solvefreq") )
{
SCIPwarningMessage(scip, "unfixing parameter lp/solvefreq in subscip of oneopt heuristic\n");
SCIP_CALL( SCIPunfixParam(subscip, "lp/solvefreq") );
}
SCIP_CALL( SCIPsetIntParam(subscip, "lp/solvefreq", -1) );
if( SCIPisParamFixed(subscip, "heuristics/oneopt/freq") )
{
SCIPwarningMessage(scip, "unfixing parameter heuristics/oneopt/freq in subscip of oneopt heuristic\n");
SCIP_CALL( SCIPunfixParam(subscip, "heuristics/oneopt/freq") );
}
SCIP_CALL( SCIPsetIntParam(subscip, "heuristics/oneopt/freq", 1) );
if( SCIPisParamFixed(subscip, "heuristics/oneopt/forcelpconstruction") )
{
SCIPwarningMessage(scip, "unfixing parameter heuristics/oneopt/forcelpconstruction in subscip of oneopt heuristic\n");
SCIP_CALL( SCIPunfixParam(subscip, "heuristics/oneopt/forcelpconstruction") );
}
SCIP_CALL( SCIPsetBoolParam(subscip, "heuristics/oneopt/forcelpconstruction", TRUE) );
/* avoid recursive call, which would lead to an endless loop */
if( SCIPisParamFixed(subscip, "heuristics/oneopt/beforepresol") )
{
SCIPwarningMessage(scip, "unfixing parameter heuristics/oneopt/beforepresol in subscip of oneopt heuristic\n");
SCIP_CALL( SCIPunfixParam(subscip, "heuristics/oneopt/beforepresol") );
}
SCIP_CALL( SCIPsetBoolParam(subscip, "heuristics/oneopt/beforepresol", FALSE) );
if( valid )
{
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 zeroobj heuristic; sub-SCIP terminated with code <%d>\n",retcode);
}
#ifdef SCIP_DEBUG
SCIP_CALL( SCIPprintStatistics(subscip, NULL) );
#endif
}
/* 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);
valid = FALSE;
for( i = 0; i < nsubsols && !valid; ++i )
{
SCIP_CALL( createNewSol(scip, subscip, subvars, heur, subsols[i], &valid) );
if( valid )
*result = SCIP_FOUNDSOL;
}
/* free subproblem */
SCIPfreeBufferArray(scip, &subvars);
SCIP_CALL( SCIPfree(&subscip) );
return SCIP_OKAY;
}
/* we can only work on solutions valid in the transformed space */
if( SCIPsolIsOriginal(bestsol) )
return SCIP_OKAY;
if( heurtiming == SCIP_HEURTIMING_BEFORENODE && (SCIPhasCurrentNodeLP(scip) || heurdata->forcelpconstruction) )
{
SCIP_Bool cutoff;
cutoff = FALSE;
SCIP_CALL( SCIPconstructLP(scip, &cutoff) );
SCIP_CALL( SCIPflushLP(scip) );
/* get problem variables again, SCIPconstructLP() might have added new variables */
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, &nbinvars, &nintvars, NULL, NULL) );
nintvars += nbinvars;
}
/* we need an LP */
if( SCIPgetNLPRows(scip) == 0 )
return SCIP_OKAY;
*result = SCIP_DIDNOTFIND;
nchgbound = 0;
/* initialize data */
nshiftcands = 0;
shiftcandssize = 8;
heurdata->lastsolindex = SCIPsolGetIndex(bestsol);
SCIP_CALL( SCIPcreateSolCopy(scip, &worksol, bestsol) );
SCIPsolSetHeur(worksol,heur);
SCIPdebugMessage("Starting bound adjustment in 1-opt heuristic\n");
/* maybe change solution values due to global bound changes first */
for( i = nvars - 1; i >= 0; --i )
{
SCIP_VAR* var;
SCIP_Real solval;
var = vars[i];
lb = SCIPvarGetLbGlobal(var);
ub = SCIPvarGetUbGlobal(var);
solval = SCIPgetSolVal(scip, bestsol,var);
/* old solution value is smaller than the actual lower bound */
if( SCIPisFeasLT(scip, solval, lb) )
{
/* set the solution value to the global lower bound */
SCIP_CALL( SCIPsetSolVal(scip, worksol, var, lb) );
++nchgbound;
SCIPdebugMessage("var <%s> type %d, old solval %g now fixed to lb %g\n", SCIPvarGetName(var), SCIPvarGetType(var), solval, lb);
}
/* old solution value is greater than the actual upper bound */
else if( SCIPisFeasGT(scip, solval, SCIPvarGetUbGlobal(var)) )
{
/* set the solution value to the global upper bound */
SCIP_CALL( SCIPsetSolVal(scip, worksol, var, ub) );
++nchgbound;
SCIPdebugMessage("var <%s> type %d, old solval %g now fixed to ub %g\n", SCIPvarGetName(var), SCIPvarGetType(var), solval, ub);
}
}
SCIPdebugMessage("number of bound changes (due to global bounds) = %d\n", nchgbound);
SCIP_CALL( SCIPgetLPRowsData(scip, &lprows, &nlprows) );
SCIP_CALL( SCIPallocBufferArray(scip, &activities, nlprows) );
localrows = FALSE;
valid = TRUE;
/* initialize activities */
for( i = 0; i < nlprows; ++i )
{
SCIP_ROW* row;
row = lprows[i];
assert(SCIProwGetLPPos(row) == i);
if( !SCIProwIsLocal(row) )
{
activities[i] = SCIPgetRowSolActivity(scip, row, worksol);
SCIPdebugMessage("Row <%s> has activity %g\n", SCIProwGetName(row), activities[i]);
if( SCIPisFeasLT(scip, activities[i], SCIProwGetLhs(row)) || SCIPisFeasGT(scip, activities[i], SCIProwGetRhs(row)) )
{
valid = FALSE;
SCIPdebug( SCIP_CALL( SCIPprintRow(scip, row, NULL) ) );
SCIPdebugMessage("row <%s> activity %g violates bounds, lhs = %g, rhs = %g\n", SCIProwGetName(row), activities[i], SCIProwGetLhs(row), SCIProwGetRhs(row));
break;
}
}
else
localrows = TRUE;
}
if( !valid )
{
/** @todo try to correct lp rows */
SCIPdebugMessage("Some global bound changes were not valid in lp rows.\n");
goto TERMINATE;
}
SCIP_CALL( SCIPallocBufferArray(scip, &shiftcands, shiftcandssize) );
SCIP_CALL( SCIPallocBufferArray(scip, &shiftvals, shiftcandssize) );
SCIPdebugMessage("Starting 1-opt heuristic\n");
/* enumerate all integer variables and find out which of them are shiftable */
for( i = 0; i < nintvars; i++ )
{
if( SCIPvarGetStatus(vars[i]) == SCIP_VARSTATUS_COLUMN )
{
SCIP_Real shiftval;
SCIP_Real solval;
/* find out whether the variable can be shifted */
solval = SCIPgetSolVal(scip, worksol, vars[i]);
shiftval = calcShiftVal(scip, vars[i], solval, activities);
/* insert the variable into the list of shifting candidates */
if( !SCIPisFeasZero(scip, shiftval) )
{
SCIPdebugMessage(" -> Variable <%s> can be shifted by <%1.1f> \n", SCIPvarGetName(vars[i]), shiftval);
if( nshiftcands == shiftcandssize)
{
shiftcandssize *= 8;
SCIP_CALL( SCIPreallocBufferArray(scip, &shiftcands, shiftcandssize) );
SCIP_CALL( SCIPreallocBufferArray(scip, &shiftvals, shiftcandssize) );
}
shiftcands[nshiftcands] = vars[i];
shiftvals[nshiftcands] = shiftval;
nshiftcands++;
}
}
}
/* if at least one variable can be shifted, shift variables sorted by their objective */
if( nshiftcands > 0 )
{
SCIP_Real shiftval;
SCIP_Real solval;
SCIP_VAR* var;
/* the case that exactly one variable can be shifted is slightly easier */
if( nshiftcands == 1 )
{
var = shiftcands[0];
assert(var != NULL);
solval = SCIPgetSolVal(scip, worksol, var);
shiftval = shiftvals[0];
assert(!SCIPisFeasZero(scip,shiftval));
SCIPdebugMessage(" Only one shiftcand found, var <%s>, which is now shifted by<%1.1f> \n",
SCIPvarGetName(var), shiftval);
SCIP_CALL( SCIPsetSolVal(scip, worksol, var, solval+shiftval) );
}
else
{
SCIP_Real* objcoeffs;
SCIP_CALL( SCIPallocBufferArray(scip, &objcoeffs, nshiftcands) );
SCIPdebugMessage(" %d shiftcands found \n", nshiftcands);
/* sort the variables by their objective, optionally weighted with the shiftval */
if( heurdata->weightedobj )
{
for( i = 0; i < nshiftcands; ++i )
objcoeffs[i] = SCIPvarGetObj(shiftcands[i])*shiftvals[i];
}
else
{
for( i = 0; i < nshiftcands; ++i )
objcoeffs[i] = SCIPvarGetObj(shiftcands[i]);
}
/* sort arrays with respect to the first one */
SCIPsortRealPtr(objcoeffs, (void**)shiftcands, nshiftcands);
/* try to shift each variable -> Activities have to be updated */
for( i = 0; i < nshiftcands; ++i )
{
var = shiftcands[i];
assert(var != NULL);
solval = SCIPgetSolVal(scip, worksol, var);
shiftval = calcShiftVal(scip, var, solval, activities);
SCIPdebugMessage(" -> Variable <%s> is now shifted by <%1.1f> \n", SCIPvarGetName(vars[i]), shiftval);
assert(i > 0 || !SCIPisFeasZero(scip, shiftval));
assert(SCIPisFeasGE(scip, solval+shiftval, SCIPvarGetLbGlobal(var)) && SCIPisFeasLE(scip, solval+shiftval, SCIPvarGetUbGlobal(var)));
SCIP_CALL( SCIPsetSolVal(scip, worksol, var, solval+shiftval) );
SCIP_CALL( updateRowActivities(scip, activities, var, shiftval) );
}
SCIPfreeBufferArray(scip, &objcoeffs);
}
/* if the problem is a pure IP, try to install the solution, if it is a MIP, solve LP again to set the continuous
* variables to the best possible value
*/
if( nvars == nintvars || !SCIPhasCurrentNodeLP(scip) || SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
{
SCIP_Bool success;
/* since we ignore local rows, we cannot guarantee their feasibility and have to set the checklprows flag to
* TRUE if local rows are present
*/
SCIP_CALL( SCIPtrySol(scip, worksol, FALSE, FALSE, FALSE, localrows, &success) );
if( success )
{
SCIPdebugMessage("found feasible shifted solution:\n");
SCIPdebug( SCIP_CALL( SCIPprintSol(scip, worksol, NULL, FALSE) ) );
heurdata->lastsolindex = SCIPsolGetIndex(bestsol);
*result = SCIP_FOUNDSOL;
}
}
else
{
SCIP_Bool lperror;
#ifdef NDEBUG
SCIP_RETCODE retstat;
#endif
SCIPdebugMessage("shifted solution should be feasible -> solve LP to fix continuous variables to best values\n");
/* start diving to calculate the LP relaxation */
SCIP_CALL( SCIPstartDive(scip) );
/* set the bounds of the variables: fixed for integers, global bounds for continuous */
for( i = 0; i < nvars; ++i )
{
if( SCIPvarGetStatus(vars[i]) == SCIP_VARSTATUS_COLUMN )
{
SCIP_CALL( SCIPchgVarLbDive(scip, vars[i], SCIPvarGetLbGlobal(vars[i])) );
SCIP_CALL( SCIPchgVarUbDive(scip, vars[i], SCIPvarGetUbGlobal(vars[i])) );
}
}
/* apply this after global bounds to not cause an error with intermediate empty domains */
for( i = 0; i < nintvars; ++i )
{
if( SCIPvarGetStatus(vars[i]) == SCIP_VARSTATUS_COLUMN )
{
solval = SCIPgetSolVal(scip, worksol, vars[i]);
SCIP_CALL( SCIPchgVarLbDive(scip, vars[i], solval) );
SCIP_CALL( SCIPchgVarUbDive(scip, vars[i], solval) );
}
}
/* solve LP */
SCIPdebugMessage(" -> old LP iterations: %" SCIP_LONGINT_FORMAT "\n", SCIPgetNLPIterations(scip));
/**@todo in case of an MINLP, if SCIPisNLPConstructed() is TRUE, say, rather solve the NLP instead of the 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
retstat = SCIPsolveDiveLP(scip, -1, &lperror, NULL);
if( retstat != SCIP_OKAY )
{
SCIPwarningMessage(scip, "Error while solving LP in Oneopt heuristic; LP solve terminated with code <%d>\n",retstat);
}
#else
SCIP_CALL( SCIPsolveDiveLP(scip, -1, &lperror, NULL) );
#endif
SCIPdebugMessage(" -> new LP iterations: %" SCIP_LONGINT_FORMAT "\n", SCIPgetNLPIterations(scip));
SCIPdebugMessage(" -> error=%u, status=%d\n", lperror, SCIPgetLPSolstat(scip));
/* check if this is a feasible solution */
if( !lperror && SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL )
{
SCIP_Bool success;
/* copy the current LP solution to the working solution */
SCIP_CALL( SCIPlinkLPSol(scip, worksol) );
SCIP_CALL( SCIPtrySol(scip, worksol, FALSE, FALSE, FALSE, FALSE, &success) );
/* check solution for feasibility */
if( success )
{
SCIPdebugMessage("found feasible shifted solution:\n");
SCIPdebug( SCIP_CALL( SCIPprintSol(scip, worksol, NULL, FALSE) ) );
heurdata->lastsolindex = SCIPsolGetIndex(bestsol);
*result = SCIP_FOUNDSOL;
}
}
/* terminate the diving */
SCIP_CALL( SCIPendDive(scip) );
}
}
SCIPdebugMessage("Finished 1-opt heuristic\n");
SCIPfreeBufferArray(scip, &shiftvals);
SCIPfreeBufferArray(scip, &shiftcands);
TERMINATE:
SCIPfreeBufferArray(scip, &activities);
SCIP_CALL( SCIPfreeSol(scip, &worksol) );
return SCIP_OKAY;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecRounding) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_SOL* sol;
SCIP_VAR** lpcands;
SCIP_Real* lpcandssol;
SCIP_ROW** lprows;
SCIP_Real* activities;
SCIP_ROW** violrows;
int* violrowpos;
SCIP_Real obj;
SCIP_Real bestroundval;
SCIP_Real minobj;
int nlpcands;
int nlprows;
int nfrac;
int nviolrows;
int c;
int r;
SCIP_Longint nlps;
SCIP_Longint ncalls;
SCIP_Longint nsolsfound;
SCIP_Longint nnodes;
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
assert(scip != NULL);
assert(result != NULL);
assert(SCIPhasCurrentNodeLP(scip));
*result = SCIP_DIDNOTRUN;
/* only call heuristic, if an optimal LP solution is at hand */
if( SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
return SCIP_OKAY;
/* only call heuristic, if the LP objective value is smaller than the cutoff bound */
if( SCIPisGE(scip, SCIPgetLPObjval(scip), SCIPgetCutoffbound(scip)) )
return SCIP_OKAY;
/* get heuristic data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* don't call heuristic, if we have already processed the current LP solution */
nlps = SCIPgetNLPs(scip);
if( nlps == heurdata->lastlp )
return SCIP_OKAY;
heurdata->lastlp = nlps;
/* don't call heuristic, if it was not successful enough in the past */
ncalls = SCIPheurGetNCalls(heur);
nsolsfound = 10*SCIPheurGetNBestSolsFound(heur) + SCIPheurGetNSolsFound(heur);
nnodes = SCIPgetNNodes(scip);
if( nnodes % ((ncalls/heurdata->successfactor)/(nsolsfound+1)+1) != 0 )
return SCIP_OKAY;
/* get fractional variables, that should be integral */
SCIP_CALL( SCIPgetLPBranchCands(scip, &lpcands, &lpcandssol, NULL, &nlpcands, NULL, NULL) );
nfrac = nlpcands;
/* only call heuristic, if LP solution is fractional */
if( nfrac == 0 )
return SCIP_OKAY;
*result = SCIP_DIDNOTFIND;
/* get LP rows */
SCIP_CALL( SCIPgetLPRowsData(scip, &lprows, &nlprows) );
SCIPdebugMessage("executing rounding heuristic: %d LP rows, %d fractionals\n", nlprows, nfrac);
/* get memory for activities, violated rows, and row violation positions */
SCIP_CALL( SCIPallocBufferArray(scip, &activities, nlprows) );
SCIP_CALL( SCIPallocBufferArray(scip, &violrows, nlprows) );
SCIP_CALL( SCIPallocBufferArray(scip, &violrowpos, nlprows) );
/* get the activities for all globally valid rows;
* the rows should be feasible, but due to numerical inaccuracies in the LP solver, they can be violated
*/
nviolrows = 0;
for( r = 0; r < nlprows; ++r )
{
SCIP_ROW* row;
row = lprows[r];
assert(SCIProwGetLPPos(row) == r);
if( !SCIProwIsLocal(row) )
{
activities[r] = SCIPgetRowActivity(scip, row);
if( SCIPisFeasLT(scip, activities[r], SCIProwGetLhs(row))
|| SCIPisFeasGT(scip, activities[r], SCIProwGetRhs(row)) )
{
violrows[nviolrows] = row;
violrowpos[r] = nviolrows;
nviolrows++;
}
else
violrowpos[r] = -1;
}
}
/* get the working solution from heuristic's local data */
sol = heurdata->sol;
assert(sol != NULL);
/* copy the current LP solution to the working solution */
SCIP_CALL( SCIPlinkLPSol(scip, sol) );
/* calculate the minimal objective value possible after rounding fractional variables */
minobj = SCIPgetSolTransObj(scip, sol);
assert(minobj < SCIPgetCutoffbound(scip));
for( c = 0; c < nlpcands; ++c )
{
obj = SCIPvarGetObj(lpcands[c]);
bestroundval = obj > 0.0 ? SCIPfeasFloor(scip, lpcandssol[c]) : SCIPfeasCeil(scip, lpcandssol[c]);
minobj += obj * (bestroundval - lpcandssol[c]);
}
/* try to round remaining variables in order to become/stay feasible */
while( nfrac > 0 )
{
SCIP_VAR* roundvar;
SCIP_Real oldsolval;
SCIP_Real newsolval;
SCIPdebugMessage("rounding heuristic: nfrac=%d, nviolrows=%d, obj=%g (best possible obj: %g)\n",
nfrac, nviolrows, SCIPgetSolOrigObj(scip, sol), SCIPretransformObj(scip, minobj));
/* minobj < SCIPgetCutoffbound(scip) should be true, otherwise the rounding variable selection
* should have returned NULL. Due to possible cancellation we use SCIPisLE. */
assert( SCIPisLE(scip, minobj, SCIPgetCutoffbound(scip)) );
/* choose next variable to process:
* - if a violated row exists, round a variable decreasing the violation, that has least impact on other rows
* - otherwise, round a variable, that has strongest devastating impact on rows in opposite direction
*/
if( nviolrows > 0 )
{
SCIP_ROW* row;
int rowpos;
row = violrows[nviolrows-1];
rowpos = SCIProwGetLPPos(row);
assert(0 <= rowpos && rowpos < nlprows);
assert(violrowpos[rowpos] == nviolrows-1);
SCIPdebugMessage("rounding heuristic: try to fix violated row <%s>: %g <= %g <= %g\n",
SCIProwGetName(row), SCIProwGetLhs(row), activities[rowpos], SCIProwGetRhs(row));
if( SCIPisFeasLT(scip, activities[rowpos], SCIProwGetLhs(row)) )
{
/* lhs is violated: select a variable rounding, that increases the activity */
SCIP_CALL( selectIncreaseRounding(scip, sol, minobj, row, &roundvar, &oldsolval, &newsolval) );
}
else
{
assert(SCIPisFeasGT(scip, activities[rowpos], SCIProwGetRhs(row)));
/* rhs is violated: select a variable rounding, that decreases the activity */
SCIP_CALL( selectDecreaseRounding(scip, sol, minobj, row, &roundvar, &oldsolval, &newsolval) );
}
}
else
{
SCIPdebugMessage("rounding heuristic: search rounding variable and try to stay feasible\n");
SCIP_CALL( selectEssentialRounding(scip, sol, minobj, lpcands, nlpcands, &roundvar, &oldsolval, &newsolval) );
}
/* check, whether rounding was possible */
if( roundvar == NULL )
{
SCIPdebugMessage("rounding heuristic: -> didn't find a rounding variable\n");
break;
}
SCIPdebugMessage("rounding heuristic: -> round var <%s>, oldval=%g, newval=%g, obj=%g\n",
SCIPvarGetName(roundvar), oldsolval, newsolval, SCIPvarGetObj(roundvar));
/* update row activities of globally valid rows */
SCIP_CALL( updateActivities(scip, activities, violrows, violrowpos, &nviolrows, nlprows,
roundvar, oldsolval, newsolval) );
/* store new solution value and decrease fractionality counter */
SCIP_CALL( SCIPsetSolVal(scip, sol, roundvar, newsolval) );
nfrac--;
/* update minimal objective value possible after rounding remaining variables */
obj = SCIPvarGetObj(roundvar);
if( obj > 0.0 && newsolval > oldsolval )
minobj += obj;
else if( obj < 0.0 && newsolval < oldsolval )
minobj -= obj;
SCIPdebugMessage("rounding heuristic: -> nfrac=%d, nviolrows=%d, obj=%g (best possible obj: %g)\n",
nfrac, nviolrows, SCIPgetSolOrigObj(scip, sol), SCIPretransformObj(scip, minobj));
}
/* check, if the new solution is feasible */
if( nfrac == 0 && nviolrows == 0 )
{
SCIP_Bool stored;
/* check solution for feasibility, and add it to solution store if possible
* neither integrality nor feasibility of LP rows has to be checked, because this is already
* done in the rounding heuristic itself; however, be better check feasibility of LP rows,
* because of numerical problems with activity updating
*/
SCIP_CALL( SCIPtrySol(scip, sol, FALSE, FALSE, FALSE, TRUE, &stored) );
if( stored )
{
#ifdef SCIP_DEBUG
SCIPdebugMessage("found feasible rounded solution:\n");
SCIP_CALL( SCIPprintSol(scip, sol, NULL, FALSE) );
#endif
*result = SCIP_FOUNDSOL;
}
}
/* free memory buffers */
SCIPfreeBufferArray(scip, &violrowpos);
SCIPfreeBufferArray(scip, &violrows);
SCIPfreeBufferArray(scip, &activities);
return SCIP_OKAY;
}
/** compute value by which the solution of variable @p var can be shifted */
static
SCIP_Real calcShiftVal(
SCIP* scip, /**< SCIP data structure */
SCIP_VAR* var, /**< variable that should be shifted */
SCIP_Real solval, /**< current solution value */
SCIP_Real* activities /**< LP row activities */
)
{
SCIP_Real lb;
SCIP_Real ub;
SCIP_Real obj;
SCIP_Real shiftval;
SCIP_COL* col;
SCIP_ROW** colrows;
SCIP_Real* colvals;
SCIP_Bool shiftdown;
int ncolrows;
int i;
/* get variable's solution value, global bounds and objective coefficient */
lb = SCIPvarGetLbGlobal(var);
ub = SCIPvarGetUbGlobal(var);
obj = SCIPvarGetObj(var);
shiftval = 0.0;
shiftdown = TRUE;
/* determine shifting direction and maximal possible shifting w.r.t. corresponding bound */
if( obj > 0.0 && SCIPisFeasGE(scip, solval - 1.0, lb) )
shiftval = SCIPfeasFloor(scip, solval - lb);
else if( obj < 0.0 && SCIPisFeasLE(scip, solval + 1.0, ub) )
{
shiftval = SCIPfeasFloor(scip, ub - solval);
shiftdown = FALSE;
}
else
return 0.0;
SCIPdebugMessage("Try to shift %s variable <%s> with\n", shiftdown ? "down" : "up", SCIPvarGetName(var) );
SCIPdebugMessage(" lb:<%g> <= val:<%g> <= ub:<%g> and obj:<%g> by at most: <%g>\n", lb, solval, ub, obj, shiftval);
/* get data of LP column */
col = SCIPvarGetCol(var);
colrows = SCIPcolGetRows(col);
colvals = SCIPcolGetVals(col);
ncolrows = SCIPcolGetNLPNonz(col);
assert(ncolrows == 0 || (colrows != NULL && colvals != NULL));
/* find minimal shift value, st. all rows stay valid */
for( i = 0; i < ncolrows && shiftval > 0.0; ++i )
{
SCIP_ROW* row;
int rowpos;
row = colrows[i];
rowpos = SCIProwGetLPPos(row);
assert(-1 <= rowpos && rowpos < SCIPgetNLPRows(scip) );
/* only global rows need to be valid */
if( rowpos >= 0 && !SCIProwIsLocal(row) )
{
SCIP_Real shiftvalrow;
assert(SCIProwIsInLP(row));
if( shiftdown == (colvals[i] > 0) )
shiftvalrow = SCIPfeasFloor(scip, (activities[rowpos] - SCIProwGetLhs(row)) / ABS(colvals[i]));
else
shiftvalrow = SCIPfeasFloor(scip, (SCIProwGetRhs(row) - activities[rowpos]) / ABS(colvals[i]));
#ifdef SCIP_DEBUG
if( shiftvalrow < shiftval )
{
SCIPdebugMessage(" -> The shift value had to be reduced to <%g>, because of row <%s>.\n",
shiftvalrow, SCIProwGetName(row));
SCIPdebugMessage(" lhs:<%g> <= act:<%g> <= rhs:<%g>, colval:<%g>\n",
SCIProwGetLhs(row), activities[rowpos], SCIProwGetRhs(row), colvals[i]);
}
#endif
shiftval = MIN(shiftval, shiftvalrow);
/* shiftvalrow might be negative, if we detected infeasibility -> make sure that shiftval is >= 0 */
shiftval = MAX(shiftval, 0.0);
}
}
if( shiftdown )
shiftval *= -1.0;
/* we must not shift variables to infinity */
if( SCIPisInfinity(scip, solval + shiftval) )
shiftval = 0.0;
return shiftval;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecShifting) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_SOL* sol;
SCIP_VAR** lpcands;
SCIP_Real* lpcandssol;
SCIP_ROW** lprows;
SCIP_Real* activities;
SCIP_ROW** violrows;
SCIP_Real* nincreases;
SCIP_Real* ndecreases;
int* violrowpos;
int* nfracsinrow;
SCIP_Real increaseweight;
SCIP_Real obj;
SCIP_Real bestshiftval;
SCIP_Real minobj;
int nlpcands;
int nlprows;
int nvars;
int nfrac;
int nviolrows;
int nprevviolrows;
int minnviolrows;
int nnonimprovingshifts;
int c;
int r;
SCIP_Longint nlps;
SCIP_Longint ncalls;
SCIP_Longint nsolsfound;
SCIP_Longint nnodes;
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
assert(scip != NULL);
assert(result != NULL);
assert(SCIPhasCurrentNodeLP(scip));
*result = SCIP_DIDNOTRUN;
/* only call heuristic, if an optimal LP solution is at hand */
if( SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
return SCIP_OKAY;
/* only call heuristic, if the LP objective value is smaller than the cutoff bound */
if( SCIPisGE(scip, SCIPgetLPObjval(scip), SCIPgetCutoffbound(scip)) )
return SCIP_OKAY;
/* get heuristic data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* don't call heuristic, if we have already processed the current LP solution */
nlps = SCIPgetNLPs(scip);
if( nlps == heurdata->lastlp )
return SCIP_OKAY;
heurdata->lastlp = nlps;
/* don't call heuristic, if it was not successful enough in the past */
ncalls = SCIPheurGetNCalls(heur);
nsolsfound = 10*SCIPheurGetNBestSolsFound(heur) + SCIPheurGetNSolsFound(heur);
nnodes = SCIPgetNNodes(scip);
if( nnodes % ((ncalls/100)/(nsolsfound+1)+1) != 0 )
return SCIP_OKAY;
/* get fractional variables, that should be integral */
/* todo check if heuristic should include implicit integer variables for its calculations */
SCIP_CALL( SCIPgetLPBranchCands(scip, &lpcands, &lpcandssol, NULL, &nlpcands, NULL, NULL) );
nfrac = nlpcands;
/* only call heuristic, if LP solution is fractional */
if( nfrac == 0 )
return SCIP_OKAY;
*result = SCIP_DIDNOTFIND;
/* get LP rows */
SCIP_CALL( SCIPgetLPRowsData(scip, &lprows, &nlprows) );
SCIPdebugMessage("executing shifting heuristic: %d LP rows, %d fractionals\n", nlprows, nfrac);
/* get memory for activities, violated rows, and row violation positions */
nvars = SCIPgetNVars(scip);
SCIP_CALL( SCIPallocBufferArray(scip, &activities, nlprows) );
SCIP_CALL( SCIPallocBufferArray(scip, &violrows, nlprows) );
SCIP_CALL( SCIPallocBufferArray(scip, &violrowpos, nlprows) );
SCIP_CALL( SCIPallocBufferArray(scip, &nfracsinrow, nlprows) );
SCIP_CALL( SCIPallocBufferArray(scip, &nincreases, nvars) );
SCIP_CALL( SCIPallocBufferArray(scip, &ndecreases, nvars) );
BMSclearMemoryArray(nfracsinrow, nlprows);
BMSclearMemoryArray(nincreases, nvars);
BMSclearMemoryArray(ndecreases, nvars);
/* get the activities for all globally valid rows;
* the rows should be feasible, but due to numerical inaccuracies in the LP solver, they can be violated
*/
nviolrows = 0;
for( r = 0; r < nlprows; ++r )
{
SCIP_ROW* row;
row = lprows[r];
assert(SCIProwGetLPPos(row) == r);
if( !SCIProwIsLocal(row) )
{
activities[r] = SCIPgetRowActivity(scip, row);
if( SCIPisFeasLT(scip, activities[r], SCIProwGetLhs(row))
|| SCIPisFeasGT(scip, activities[r], SCIProwGetRhs(row)) )
{
violrows[nviolrows] = row;
violrowpos[r] = nviolrows;
nviolrows++;
}
else
violrowpos[r] = -1;
}
}
/* calc the current number of fractional variables in rows */
for( c = 0; c < nlpcands; ++c )
addFracCounter(nfracsinrow, nlprows, lpcands[c], +1);
/* get the working solution from heuristic's local data */
sol = heurdata->sol;
assert(sol != NULL);
/* copy the current LP solution to the working solution */
SCIP_CALL( SCIPlinkLPSol(scip, sol) );
/* calculate the minimal objective value possible after rounding fractional variables */
minobj = SCIPgetSolTransObj(scip, sol);
assert(minobj < SCIPgetCutoffbound(scip));
for( c = 0; c < nlpcands; ++c )
{
obj = SCIPvarGetObj(lpcands[c]);
bestshiftval = obj > 0.0 ? SCIPfeasFloor(scip, lpcandssol[c]) : SCIPfeasCeil(scip, lpcandssol[c]);
minobj += obj * (bestshiftval - lpcandssol[c]);
}
/* try to shift remaining variables in order to become/stay feasible */
nnonimprovingshifts = 0;
minnviolrows = INT_MAX;
increaseweight = 1.0;
while( (nfrac > 0 || nviolrows > 0) && nnonimprovingshifts < MAXSHIFTINGS )
{
SCIP_VAR* shiftvar;
SCIP_Real oldsolval;
SCIP_Real newsolval;
SCIP_Bool oldsolvalisfrac;
int probindex;
SCIPdebugMessage("shifting heuristic: nfrac=%d, nviolrows=%d, obj=%g (best possible obj: %g), cutoff=%g\n",
nfrac, nviolrows, SCIPgetSolOrigObj(scip, sol), SCIPretransformObj(scip, minobj),
SCIPretransformObj(scip, SCIPgetCutoffbound(scip)));
nprevviolrows = nviolrows;
/* choose next variable to process:
* - if a violated row exists, shift a variable decreasing the violation, that has least impact on other rows
* - otherwise, shift a variable, that has strongest devastating impact on rows in opposite direction
*/
shiftvar = NULL;
oldsolval = 0.0;
newsolval = 0.0;
if( nviolrows > 0 && (nfrac == 0 || nnonimprovingshifts < MAXSHIFTINGS-1) )
{
SCIP_ROW* row;
int rowidx;
int rowpos;
int direction;
rowidx = -1;
rowpos = -1;
row = NULL;
if( nfrac > 0 )
{
for( rowidx = nviolrows-1; rowidx >= 0; --rowidx )
{
row = violrows[rowidx];
rowpos = SCIProwGetLPPos(row);
assert(violrowpos[rowpos] == rowidx);
if( nfracsinrow[rowpos] > 0 )
break;
}
}
if( rowidx == -1 )
{
rowidx = SCIPgetRandomInt(0, nviolrows-1, &heurdata->randseed);
row = violrows[rowidx];
rowpos = SCIProwGetLPPos(row);
assert(0 <= rowpos && rowpos < nlprows);
assert(violrowpos[rowpos] == rowidx);
assert(nfracsinrow[rowpos] == 0);
}
assert(violrowpos[rowpos] == rowidx);
SCIPdebugMessage("shifting heuristic: try to fix violated row <%s>: %g <= %g <= %g\n",
SCIProwGetName(row), SCIProwGetLhs(row), activities[rowpos], SCIProwGetRhs(row));
SCIPdebug( SCIP_CALL( SCIPprintRow(scip, row, NULL) ) );
/* get direction in which activity must be shifted */
assert(SCIPisFeasLT(scip, activities[rowpos], SCIProwGetLhs(row))
|| SCIPisFeasGT(scip, activities[rowpos], SCIProwGetRhs(row)));
direction = SCIPisFeasLT(scip, activities[rowpos], SCIProwGetLhs(row)) ? +1 : -1;
/* search a variable that can shift the activity in the necessary direction */
SCIP_CALL( selectShifting(scip, sol, row, activities[rowpos], direction,
nincreases, ndecreases, increaseweight, &shiftvar, &oldsolval, &newsolval) );
}
if( shiftvar == NULL && nfrac > 0 )
{
SCIPdebugMessage("shifting heuristic: search rounding variable and try to stay feasible\n");
SCIP_CALL( selectEssentialRounding(scip, sol, minobj, lpcands, nlpcands, &shiftvar, &oldsolval, &newsolval) );
}
/* check, whether shifting was possible */
if( shiftvar == NULL || SCIPisEQ(scip, oldsolval, newsolval) )
{
SCIPdebugMessage("shifting heuristic: -> didn't find a shifting variable\n");
break;
}
SCIPdebugMessage("shifting heuristic: -> shift var <%s>[%g,%g], type=%d, oldval=%g, newval=%g, obj=%g\n",
SCIPvarGetName(shiftvar), SCIPvarGetLbGlobal(shiftvar), SCIPvarGetUbGlobal(shiftvar), SCIPvarGetType(shiftvar),
oldsolval, newsolval, SCIPvarGetObj(shiftvar));
/* update row activities of globally valid rows */
SCIP_CALL( updateActivities(scip, activities, violrows, violrowpos, &nviolrows, nlprows,
shiftvar, oldsolval, newsolval) );
if( nviolrows >= nprevviolrows )
nnonimprovingshifts++;
else if( nviolrows < minnviolrows )
{
minnviolrows = nviolrows;
nnonimprovingshifts = 0;
}
/* store new solution value and decrease fractionality counter */
SCIP_CALL( SCIPsetSolVal(scip, sol, shiftvar, newsolval) );
/* update fractionality counter and minimal objective value possible after shifting remaining variables */
oldsolvalisfrac = !SCIPisFeasIntegral(scip, oldsolval)
&& (SCIPvarGetType(shiftvar) == SCIP_VARTYPE_BINARY || SCIPvarGetType(shiftvar) == SCIP_VARTYPE_INTEGER);
obj = SCIPvarGetObj(shiftvar);
if( (SCIPvarGetType(shiftvar) == SCIP_VARTYPE_BINARY || SCIPvarGetType(shiftvar) == SCIP_VARTYPE_INTEGER)
&& oldsolvalisfrac )
{
assert(SCIPisFeasIntegral(scip, newsolval));
nfrac--;
nnonimprovingshifts = 0;
minnviolrows = INT_MAX;
addFracCounter(nfracsinrow, nlprows, shiftvar, -1);
/* the rounding was already calculated into the minobj -> update only if rounding in "wrong" direction */
if( obj > 0.0 && newsolval > oldsolval )
minobj += obj;
else if( obj < 0.0 && newsolval < oldsolval )
minobj -= obj;
}
else
{
/* update minimal possible objective value */
minobj += obj * (newsolval - oldsolval);
}
/* update increase/decrease arrays */
if( !oldsolvalisfrac )
{
probindex = SCIPvarGetProbindex(shiftvar);
assert(0 <= probindex && probindex < nvars);
increaseweight *= WEIGHTFACTOR;
if( newsolval < oldsolval )
ndecreases[probindex] += increaseweight;
else
nincreases[probindex] += increaseweight;
if( increaseweight >= 1e+09 )
{
int i;
for( i = 0; i < nvars; ++i )
{
nincreases[i] /= increaseweight;
ndecreases[i] /= increaseweight;
}
increaseweight = 1.0;
}
}
SCIPdebugMessage("shifting heuristic: -> nfrac=%d, nviolrows=%d, obj=%g (best possible obj: %g)\n",
nfrac, nviolrows, SCIPgetSolOrigObj(scip, sol), SCIPretransformObj(scip, minobj));
}
/* check, if the new solution is feasible */
if( nfrac == 0 && nviolrows == 0 )
{
SCIP_Bool stored;
/* check solution for feasibility, and add it to solution store if possible
* neither integrality nor feasibility of LP rows has to be checked, because this is already
* done in the shifting heuristic itself; however, we better check feasibility of LP rows,
* because of numerical problems with activity updating
*/
SCIP_CALL( SCIPtrySol(scip, sol, FALSE, FALSE, FALSE, TRUE, &stored) );
if( stored )
{
SCIPdebugMessage("found feasible shifted solution:\n");
SCIPdebug( SCIP_CALL( SCIPprintSol(scip, sol, NULL, FALSE) ) );
*result = SCIP_FOUNDSOL;
}
}
/* free memory buffers */
SCIPfreeBufferArray(scip, &ndecreases);
SCIPfreeBufferArray(scip, &nincreases);
SCIPfreeBufferArray(scip, &nfracsinrow);
SCIPfreeBufferArray(scip, &violrowpos);
SCIPfreeBufferArray(scip, &violrows);
SCIPfreeBufferArray(scip, &activities);
return SCIP_OKAY;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecSimplerounding) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_SOL* sol;
SCIP_VAR** lpcands;
SCIP_Real* lpcandssol;
SCIP_Longint nlps;
int nlpcands;
int c;
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
assert(result != NULL);
assert(SCIPhasCurrentNodeLP(scip));
*result = SCIP_DIDNOTRUN;
/* only call heuristic, if an optimal LP solution is at hand */
if( SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
return SCIP_OKAY;
/* get heuristic data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* on our first call or after each pricing round, calculate the number of roundable variables */
if( heurdata->nroundablevars == -1 || heurtiming == SCIP_HEURTIMING_DURINGPRICINGLOOP )
{
SCIP_VAR** vars;
int nvars;
int nroundablevars;
int i;
vars = SCIPgetVars(scip);
nvars = SCIPgetNBinVars(scip) + SCIPgetNIntVars(scip);
nroundablevars = 0;
for( i = 0; i < nvars; ++i )
{
if( SCIPvarMayRoundDown(vars[i]) || SCIPvarMayRoundUp(vars[i]) )
nroundablevars++;
}
heurdata->nroundablevars = nroundablevars;
}
/* don't call heuristic if there are no roundable variables; except we are called during pricing, in this case we
* want to detect a (mixed) integer (LP) solution which is primal feasible */
if( heurdata->nroundablevars == 0 && heurtiming != SCIP_HEURTIMING_DURINGPRICINGLOOP )
return SCIP_OKAY;
/* don't call heuristic, if we have already processed the current LP solution */
nlps = SCIPgetNLPs(scip);
if( nlps == heurdata->lastlp )
return SCIP_OKAY;
heurdata->lastlp = nlps;
/* get fractional variables, that should be integral */
SCIP_CALL( SCIPgetLPBranchCands(scip, &lpcands, &lpcandssol, NULL, &nlpcands, NULL) );
/* only call heuristic, if LP solution is fractional; except we are called during pricing, in this case we
* want to detect a (mixed) integer (LP) solution which is primal feasible */
if( nlpcands == 0 && heurtiming != SCIP_HEURTIMING_DURINGPRICINGLOOP )
return SCIP_OKAY;
/* don't call heuristic, if there are more fractional variables than roundable ones */
if( nlpcands > heurdata->nroundablevars )
return SCIP_OKAY;
*result = SCIP_DIDNOTFIND;
SCIPdebugMessage("executing simple rounding heuristic: %d fractionals\n", nlpcands);
/* get the working solution from heuristic's local data */
sol = heurdata->sol;
assert(sol != NULL);
/* copy the current LP solution to the working solution */
SCIP_CALL( SCIPlinkLPSol(scip, sol) );
/* round all roundable fractional columns in the corresponding direction as long as no unroundable column was found */
for( c = 0; c < nlpcands; ++c )
{
SCIP_VAR* var;
SCIP_Real oldsolval;
SCIP_Real newsolval;
SCIP_Bool mayrounddown;
SCIP_Bool mayroundup;
oldsolval = lpcandssol[c];
assert(!SCIPisFeasIntegral(scip, oldsolval));
var = lpcands[c];
assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_COLUMN);
mayrounddown = SCIPvarMayRoundDown(var);
mayroundup = SCIPvarMayRoundUp(var);
SCIPdebugMessage("simple rounding heuristic: var <%s>, val=%g, rounddown=%u, roundup=%u\n",
SCIPvarGetName(var), oldsolval, mayrounddown, mayroundup);
/* choose rounding direction */
if( mayrounddown && mayroundup )
{
/* we can round in both directions: round in objective function direction */
if( SCIPvarGetObj(var) >= 0.0 )
newsolval = SCIPfeasFloor(scip, oldsolval);
else
newsolval = SCIPfeasCeil(scip, oldsolval);
}
else if( mayrounddown )
newsolval = SCIPfeasFloor(scip, oldsolval);
else if( mayroundup )
newsolval = SCIPfeasCeil(scip, oldsolval);
else
break;
/* store new solution value */
SCIP_CALL( SCIPsetSolVal(scip, sol, var, newsolval) );
}
/* check, if rounding was successful */
if( c == nlpcands )
{
SCIP_Bool stored;
/* check solution for feasibility, and add it to solution store if possible
* neither integrality nor feasibility of LP rows has to be checked, because all fractional
* variables were already moved in feasible direction to the next integer
*/
SCIP_CALL( SCIPtrySol(scip, sol, FALSE, FALSE, FALSE, FALSE, &stored) );
if( stored )
{
#ifdef SCIP_DEBUG
SCIPdebugMessage("found feasible rounded solution:\n");
SCIPprintSol(scip, sol, NULL, FALSE);
#endif
*result = SCIP_FOUNDSOL;
}
}
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;
}
/** reads solution from given file into given arrays */
static
SCIP_RETCODE readSolfile(
SCIP_SET* set, /**< global SCIP settings */
const char* solfilename, /**< solution filename to read */
char*** names, /**< pointer to store the array of variable names */
SCIP_Real** vals, /**< pointer to store the array of solution values */
int* nvals, /**< pointer to store the number of non-zero elements */
int* valssize /**< pointer to store the length of the variable names and solution values arrays */
)
{
FILE* file;
int nonvalues;
int i;
assert(set != NULL);
assert(solfilename != NULL);
assert(names != NULL);
assert(*names == NULL);
assert(vals != NULL);
assert(*vals == NULL);
assert(nvals != NULL);
assert(valssize != NULL);
printf("***** debug: reading solution file <%s>\n", solfilename);
/* open solution file */
file = fopen(solfilename, "r");
if( file == NULL )
{
SCIPerrorMessage("cannot open solution file <%s> specified in scip/debug.h\n", solfilename);
SCIPprintSysError(solfilename);
return SCIP_NOFILE;
}
/* read data */
nonvalues = 0;
*valssize = 0;
while( !feof(file) )
{
char buf[SCIP_MAXSTRLEN];
char name[SCIP_MAXSTRLEN];
char objstring[SCIP_MAXSTRLEN];
SCIP_Real val;
int nread;
if( fgets(buf, SCIP_MAXSTRLEN, file) == NULL )
{
if( feof(file) )
break;
else
return SCIP_READERROR;
}
/* the lines "solution status: ..." and "objective value: ..." may preceed the solution information */
if( strncmp(buf, "solution", 8) == 0 || strncmp(buf, "objective", 9) == 0 )
{
nonvalues++;
continue;
}
/* skip empty lines */
if( strlen(buf) == 1 )
{
nonvalues++;
continue;
}
nread = sscanf(buf, "%s %lf %s\n", name, &val, objstring);
if( nread < 2 )
{
printf("invalid input line %d in solution file <%s>: <%s>\n", *nvals + nonvalues, SCIP_DEBUG_SOLUTION, name);
fclose(file);
return SCIP_READERROR;
}
/* allocate memory */
if( *nvals >= *valssize )
{
*valssize = MAX(2 * *valssize, (*nvals)+1);
SCIP_ALLOC( BMSreallocMemoryArray(names, *valssize) );
SCIP_ALLOC( BMSreallocMemoryArray(vals, *valssize) );
}
assert(*nvals < *valssize);
/* store solution value in sorted list */
for( i = *nvals; i > 0 && strcmp(name, (*names)[i-1]) < 0; --i )
{
(*names)[i] = (*names)[i-1];
(*vals)[i] = (*vals)[i-1];
}
SCIP_ALLOC( BMSduplicateMemoryArray(&(*names)[i], name, strlen(name)+1) );
SCIPdebugMessage("found variable <%s>: value <%g>\n", (*names)[i], val);
(*vals)[i] = val;
(*nvals)++;
}
debugsolval = 0.0;
/* get solution value */
for( i = *nvals - 1; i >= 0; --i)
{
SCIP_VAR* var;
var = SCIPfindVar(set->scip, (*names)[i]);
if( var != NULL )
debugsolval += (*vals)[i] * SCIPvarGetObj(var);
}
SCIPdebugMessage("Debug Solution value is %g.\n", debugsolval);
/* close file */
fclose(file);
/* remember the set pointer to identify sub-MIP calls */
mainscipset = set;
printf("***** debug: read %d non-zero entries\n", *nvals);
return SCIP_OKAY;
}
/** calculate score and preferred rounding direction for the candidate variable; the best candidate maximizes the
* score
*/
static
SCIP_DECL_DIVESETGETSCORE(divesetGetScoreFracdiving)
{
SCIP_Real obj;
SCIP_Real objnorm;
SCIP_Real objgain;
SCIP_Bool mayrounddown;
SCIP_Bool mayroundup;
/* score fractionality if candidate is an SOS1 variable */
if ( divetype == SCIP_DIVETYPE_SOS1VARIABLE )
{
*score = candsfrac;
/* 'round' in nonzero direction, i.e., fix the candidates neighbors in the conflict graph to zero */
*roundup = SCIPisFeasPositive(scip, candsol);
return SCIP_OKAY;
}
mayrounddown = SCIPvarMayRoundDown(cand);
mayroundup = SCIPvarMayRoundUp(cand);
/* choose rounding direction:
* - if variable may be rounded in either both or neither direction, 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 = mayrounddown;
else
*roundup = (candsfrac > 0.5);
obj = SCIPvarGetObj(cand);
objnorm = SCIPgetObjNorm(scip);
/* divide by objective norm to normalize obj into [-1,1] */
if( SCIPisPositive(scip, objnorm) )
obj /= objnorm;
/* calculate objective gain and fractionality for the selected rounding direction */
if( *roundup )
{
candsfrac = 1.0 - candsfrac;
objgain = obj * candsfrac;
}
else
objgain = -obj * candsfrac;
assert(objgain >= -1.0 && objgain <= 1.0);
/* penalize too small fractions */
if( candsfrac < 0.01 )
candsfrac += 10.0;
/* prefer decisions on binary variables */
if( !SCIPvarIsBinary(cand) )
candsfrac *= 1000.0;
/* prefer variables which cannot be rounded by scoring their fractionality */
if( !(mayrounddown || mayroundup) )
*score = -candsfrac;
else
*score = -2.0 - objgain;
return SCIP_OKAY;
}
/** compares the so far best branching candidate with a new candidate and updates best candidate, if new candidate is better */
static
void updateBestCandidate(
SCIP* scip, /**< SCIP data structure */
SCIP_VAR** bestvar, /**< best branching candidate */
SCIP_Real* bestscore, /**< score of best branching candidate */
SCIP_Real* bestobj, /**< absolute objective value of best branching candidate */
SCIP_Real* bestsol, /**< proposed branching point of best branching candidate */
SCIP_VAR* cand, /**< branching candidate to consider */
SCIP_Real candscore, /**< scoring of branching candidate */
SCIP_Real candsol /**< proposed branching point of branching candidate */
)
{
SCIP_Real obj;
assert(scip != NULL);
assert(bestvar != NULL);
assert(bestscore != NULL);
assert(bestobj != NULL);
assert(*bestobj >= 0.0);
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;
updateBestCandidate(scip, bestvar, bestscore, bestobj, bestsol,
multvars[i], candscore, 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;
updateBestCandidate(scip, bestvar, bestscore, bestobj, bestsol,
multvars[i], candscore, SCIP_INVALID);
}
assert(*bestvar != NULL); /* if all variables were fixed, something is strange */
return;
}
candscore *= SCIPvarGetBranchFactor(cand);
obj = SCIPvarGetObj(cand);
obj = REALABS(obj);
if( SCIPisInfinity(scip, *bestscore)
|| (!SCIPisInfinity(scip, candscore) &&
(SCIPisLT(scip, candscore, *bestscore) || (SCIPisLE(scip, candscore, *bestscore) && obj > *bestobj))) )
{
*bestvar = cand;
*bestscore = candscore;
*bestobj = obj;
*bestsol = candsol;
}
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecGuideddiving) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_LPSOLSTAT lpsolstat;
SCIP_SOL* bestsol;
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 obj;
SCIP_Real objgain;
SCIP_Real bestobjgain;
SCIP_Real frac;
SCIP_Real bestfrac;
SCIP_Real solval;
SCIP_Real bestsolval;
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;
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;
/* don't dive, if no feasible solutions exist */
if( SCIPgetNSols(scip) == 0 )
return SCIP_OKAY;
/* 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( 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;
/* get best solution that should guide the search; if this solution lives in the original variable space,
* we cannot use it since it might violate the global bounds of the current problem
*/
if( SCIPsolIsOriginal(SCIPgetBestSol(scip)) )
return SCIP_OKAY;
/* store a copy of the best solution */
SCIP_CALL( SCIPcreateSolCopy(scip, &bestsol, SCIPgetBestSol(scip)) );
*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 guideddiving heuristic: depth=%d, %d fractionals, dualbound=%g, searchbound=%g\n",
SCIPgetNNodes(scip), SCIPgetDepth(scip), nlpcands, SCIPgetDualbound(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) )
{
SCIP_CALL( SCIPnewProbingNode(scip) );
divedepth++;
/* choose variable fixing:
* - prefer variables that may not be rounded without destroying LP feasibility:
* - of these variables, round a variable to its value in direction of incumbent solution, and choose the
* variable that is closest to its rounded value
* - if all remaining fractional variables may be rounded without destroying LP feasibility:
* - round variable in direction that destroys LP feasibility (other direction is checked by SCIProundSol())
* - round variable with least increasing objective value
*/
bestcand = -1;
bestobjgain = SCIPinfinity(scip);
bestfrac = SCIP_INVALID;
bestcandmayrounddown = TRUE;
bestcandmayroundup = TRUE;
bestcandroundup = FALSE;
for( c = 0; c < nlpcands; ++c )
{
var = lpcands[c];
mayrounddown = SCIPvarMayRoundDown(var);
mayroundup = SCIPvarMayRoundUp(var);
solval = lpcandssol[c];
frac = lpcandsfrac[c];
obj = SCIPvarGetObj(var);
bestsolval = SCIPgetSolVal(scip, bestsol, var);
/* select default rounding direction */
roundup = (solval < bestsolval);
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 its value in incumbent solution
* - otherwise, round in the infeasible direction, because feasible direction is tried by rounding
* the current fractional solution with SCIProundSol()
*/
if( !mayrounddown || !mayroundup )
roundup = mayrounddown;
if( roundup )
{
frac = 1.0 - frac;
objgain = frac*obj;
}
else
objgain = -frac*obj;
/* penalize too small fractions */
if( frac < 0.01 )
objgain *= 1000.0;
/* prefer decisions on binary variables */
if( !SCIPvarIsBinary(var) )
objgain *= 1000.0;
/* check, if candidate is new best candidate */
if( SCIPisLT(scip, objgain, bestobjgain) || (SCIPisEQ(scip, objgain, bestobjgain) && frac < bestfrac) )
{
bestcand = c;
bestobjgain = objgain;
bestfrac = frac;
bestcandmayrounddown = mayrounddown;
bestcandmayroundup = mayroundup;
bestcandroundup = roundup;
}
}
}
else
{
/* the candidate may not be rounded */
if( roundup )
frac = 1.0 - frac;
/* penalize too small fractions */
if( frac < 0.01 )
frac += 10.0;
/* prefer decisions on binary variables */
if( !SCIPvarIsBinary(var) )
frac *= 1000.0;
/* check, if candidate is new best candidate: prefer unroundable candidates in any case */
if( bestcandmayrounddown || bestcandmayroundup || frac < bestfrac )
{
bestcand = c;
bestfrac = frac;
bestcandmayrounddown = FALSE;
bestcandmayroundup = FALSE;
bestcandroundup = roundup;
}
}
}
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("guideddiving 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;
}
}
}
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, bestsol=%g, oldbounds=[%g,%g], newbounds=[%g,%g]\n",
divedepth, maxdivedepth, heurdata->nlpiterations, maxnlpiterations,
SCIPvarGetName(var), bestcandmayrounddown, bestcandmayroundup,
lpcandssol[bestcand], SCIPgetSolVal(scip, bestsol, var),
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, bestsol=%g, oldbounds=[%g,%g], newbounds=[%g,%g]\n",
divedepth, maxdivedepth, heurdata->nlpiterations, maxnlpiterations,
SCIPvarGetName(var), bestcandmayrounddown, bestcandmayroundup,
lpcandssol[bestcand], SCIPgetSolVal(scip, bestsol, var),
SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var),
SCIPvarGetLbLocal(var), SCIPfeasFloor(scip, lpcandssol[bestcand]));
SCIP_CALL( SCIPchgVarUbProbing(scip, var, 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 Guideddiving 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, nfrac=%d\n", lpsolstat, objval, 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("guideddiving 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) );
/* free copied best solution */
SCIP_CALL( SCIPfreeSol(scip, &bestsol) );
if( *result == SCIP_FOUNDSOL )
heurdata->nsuccess++;
SCIPdebugMessage("guideddiving heuristic finished\n");
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;
}