/** output method of display column to output file stream 'file' */
static
SCIP_DECL_DISPOUTPUT(SCIPdispOutputGap)
{ /*lint --e{715}*/
SCIP_Real gap;
assert(disp != NULL);
assert(strcmp(SCIPdispGetName(disp), DISP_NAME_GAP) == 0);
assert(scip != NULL);
gap = SCIPgetGap(scip);
if( SCIPisInfinity(scip, gap) )
SCIPinfoMessage(scip, file, " Inf ");
else if( gap >= 100.00 )
SCIPinfoMessage(scip, file, " Large ");
else
SCIPinfoMessage(scip, file, "%7.2f%%", 100.0*gap);
if( SCIPgetNNodesLeft(scip) > 0
|| SCIPisZero(scip, gap) )
{
SCIP_CALL( SCIPsetIntParam(scip, "display/verblevel", 0) );
}
return SCIP_OKAY;
}
/** problem writing method of reader */
static
SCIP_DECL_READERWRITE(readerWriteCip)
{ /*lint --e{715}*/
int i;
SCIPinfoMessage(scip, file, "STATISTICS\n");
SCIPinfoMessage(scip, file, " Problem name : %s\n", name);
SCIPinfoMessage(scip, file, " Variables : %d (%d binary, %d integer, %d implicit integer, %d continuous)\n",
nvars, nbinvars, nintvars, nimplvars, ncontvars);
SCIPinfoMessage(scip, file, " Constraints : %d initial, %d maximal\n", startnconss, maxnconss);
SCIPinfoMessage(scip, file, "OBJECTIVE\n");
SCIPinfoMessage(scip, file, " Sense : %s\n", objsense == SCIP_OBJSENSE_MINIMIZE ? "minimize" : "maximize");
if( !SCIPisZero(scip, objoffset) )
SCIPinfoMessage(scip, file, " Offset : %+.15g\n", objoffset);
if( !SCIPisEQ(scip, objscale, 1.0) )
SCIPinfoMessage(scip, file, " Scale : %.15g\n", objscale);
if( nvars > 0 )
{
SCIPinfoMessage(scip, file, "VARIABLES\n");
for( i = 0; i < nvars; ++i )
{
SCIP_CALL( SCIPprintVar(scip, vars[i], file) );
}
}
if( nfixedvars > 0 )
{
SCIPinfoMessage(scip, file, "FIXED\n");
for( i = 0; i < nfixedvars; ++i )
{
SCIP_CALL( SCIPprintVar(scip, fixedvars[i], file) );
}
}
if( nconss > 0 )
{
SCIPinfoMessage(scip, file, "CONSTRAINTS\n");
for( i = 0; i < nconss; ++i )
{
/* in case the transformed is written only constraint are posted which are enabled in the current node */
assert(!transformed || SCIPconsIsEnabled(conss[i]));
SCIP_CALL( SCIPprintCons(scip, conss[i], file) );
SCIPinfoMessage(scip, file, ";\n");
}
}
*result = SCIP_SUCCESS;
SCIPinfoMessage(scip, file, "END\n");
return SCIP_OKAY;
}
/** generate point for close cut separation
*
* The constructed point is the convex combination of the point stored in set->closesol and the
* current LP solution. The convexity parameter is set->sepa_closecombvalue. If this parameter is
* 0, the point coincides with the LP solution.
*/
static
SCIP_RETCODE generateCloseCutPoint(
SCIP* scip, /**< SCIP data structure */
SCIP_SEPADATA* sepadata, /**< separator data */
SCIP_SOL** point /**< point to be generated (or NULL if unsuccessful) */
)
{
SCIP_VAR** vars;
SCIP_VAR* var;
SCIP_Real val;
SCIP_Real alpha;
SCIP_Real onealpha;
int nvars;
int i;
assert( scip != NULL );
assert( point != NULL );
*point = NULL;
if ( sepadata->sepasol == NULL )
return SCIP_OKAY;
alpha = sepadata->sepacombvalue;
if ( alpha < 0.001 )
return SCIP_OKAY;
onealpha = 1.0 - alpha;
/* create solution */
SCIP_CALL( SCIPcreateSol(scip, point, NULL) );
/* generate convex combination */
vars = SCIPgetVars(scip);
nvars = SCIPgetNVars(scip);
for (i = 0; i < nvars; ++i)
{
var = vars[i];
val = alpha * SCIPgetSolVal(scip, sepadata->sepasol, var) + onealpha * SCIPvarGetLPSol(var);
if ( ! SCIPisZero(scip, val) )
{
SCIP_CALL( SCIPsetSolVal(scip, *point, var, val) );
}
}
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;
}
/** 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;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecIntdiving) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_LPSOLSTAT lpsolstat;
SCIP_VAR** pseudocands;
SCIP_VAR** fixcands;
SCIP_Real* fixcandscores;
SCIP_Real searchubbound;
SCIP_Real searchavgbound;
SCIP_Real searchbound;
SCIP_Real objval;
SCIP_Bool lperror;
SCIP_Bool cutoff;
SCIP_Bool backtracked;
SCIP_Longint ncalls;
SCIP_Longint nsolsfound;
SCIP_Longint nlpiterations;
SCIP_Longint maxnlpiterations;
int nfixcands;
int nbinfixcands;
int depth;
int maxdepth;
int maxdivedepth;
int divedepth;
int nextcand;
int c;
assert(heur != NULL);
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
assert(scip != NULL);
assert(result != NULL);
assert(SCIPhasCurrentNodeLP(scip));
*result = SCIP_DELAYED;
/* do not call heuristic of node was already detected to be infeasible */
if( nodeinfeasible )
return SCIP_OKAY;
/* only call heuristic, if an optimal LP solution is at hand */
if( SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
return SCIP_OKAY;
/* only call heuristic, if the LP objective value is smaller than the cutoff bound */
if( SCIPisGE(scip, SCIPgetLPObjval(scip), SCIPgetCutoffbound(scip)) )
return SCIP_OKAY;
/* only call heuristic, if the LP solution is basic (which allows fast resolve in diving) */
if( !SCIPisLPSolBasic(scip) )
return SCIP_OKAY;
/* don't dive two times at the same node */
if( SCIPgetLastDivenode(scip) == SCIPgetNNodes(scip) && SCIPgetDepth(scip) > 0 )
return SCIP_OKAY;
*result = SCIP_DIDNOTRUN;
/* get heuristic's data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* only try to dive, if we are in the correct part of the tree, given by minreldepth and maxreldepth */
depth = SCIPgetDepth(scip);
maxdepth = SCIPgetMaxDepth(scip);
maxdepth = MAX(maxdepth, 100);
if( depth < heurdata->minreldepth*maxdepth || depth > heurdata->maxreldepth*maxdepth )
return SCIP_OKAY;
/* calculate the maximal number of LP iterations until heuristic is aborted */
nlpiterations = SCIPgetNNodeLPIterations(scip);
ncalls = SCIPheurGetNCalls(heur);
nsolsfound = 10*SCIPheurGetNBestSolsFound(heur) + heurdata->nsuccess;
maxnlpiterations = (SCIP_Longint)((1.0 + 10.0*(nsolsfound+1.0)/(ncalls+1.0)) * heurdata->maxlpiterquot * nlpiterations);
maxnlpiterations += heurdata->maxlpiterofs;
/* don't try to dive, if we took too many LP iterations during diving */
if( heurdata->nlpiterations >= maxnlpiterations )
return SCIP_OKAY;
/* allow at least a certain number of LP iterations in this dive */
maxnlpiterations = MAX(maxnlpiterations, heurdata->nlpiterations + MINLPITER);
/* get unfixed integer variables */
SCIP_CALL( SCIPgetPseudoBranchCands(scip, &pseudocands, &nfixcands, NULL) );
/* don't try to dive, if there are no fractional variables */
if( nfixcands == 0 )
return SCIP_OKAY;
/* calculate the objective search bound */
if( SCIPgetNSolsFound(scip) == 0 )
{
if( heurdata->maxdiveubquotnosol > 0.0 )
searchubbound = SCIPgetLowerbound(scip)
+ heurdata->maxdiveubquotnosol * (SCIPgetCutoffbound(scip) - SCIPgetLowerbound(scip));
else
searchubbound = SCIPinfinity(scip);
if( heurdata->maxdiveavgquotnosol > 0.0 )
searchavgbound = SCIPgetLowerbound(scip)
+ heurdata->maxdiveavgquotnosol * (SCIPgetAvgLowerbound(scip) - SCIPgetLowerbound(scip));
else
searchavgbound = SCIPinfinity(scip);
}
else
{
if( heurdata->maxdiveubquot > 0.0 )
searchubbound = SCIPgetLowerbound(scip)
+ heurdata->maxdiveubquot * (SCIPgetCutoffbound(scip) - SCIPgetLowerbound(scip));
else
searchubbound = SCIPinfinity(scip);
if( heurdata->maxdiveavgquot > 0.0 )
searchavgbound = SCIPgetLowerbound(scip)
+ heurdata->maxdiveavgquot * (SCIPgetAvgLowerbound(scip) - SCIPgetLowerbound(scip));
else
searchavgbound = SCIPinfinity(scip);
}
searchbound = MIN(searchubbound, searchavgbound);
if( SCIPisObjIntegral(scip) )
searchbound = SCIPceil(scip, searchbound);
/* calculate the maximal diving depth: 10 * min{number of integer variables, max depth} */
maxdivedepth = SCIPgetNBinVars(scip) + SCIPgetNIntVars(scip);
maxdivedepth = MIN(maxdivedepth, maxdepth);
maxdivedepth *= 10;
*result = SCIP_DIDNOTFIND;
/* start diving */
SCIP_CALL( SCIPstartProbing(scip) );
/* enables collection of variable statistics during probing */
SCIPenableVarHistory(scip);
SCIPdebugMessage("(node %" SCIP_LONGINT_FORMAT ") executing intdiving heuristic: depth=%d, %d non-fixed, dualbound=%g, searchbound=%g\n",
SCIPgetNNodes(scip), SCIPgetDepth(scip), nfixcands, SCIPgetDualbound(scip), SCIPretransformObj(scip, searchbound));
/* copy the pseudo candidates into own array, because we want to reorder them */
SCIP_CALL( SCIPduplicateBufferArray(scip, &fixcands, pseudocands, nfixcands) );
/* sort non-fixed variables by non-increasing inference score, but prefer binaries over integers in any case */
SCIP_CALL( SCIPallocBufferArray(scip, &fixcandscores, nfixcands) );
nbinfixcands = 0;
for( c = 0; c < nfixcands; ++c )
{
SCIP_VAR* var;
SCIP_Real score;
int colveclen;
int left;
int right;
int i;
assert(c >= nbinfixcands);
var = fixcands[c];
assert(SCIPvarIsIntegral(var));
colveclen = (SCIPvarGetStatus(var) == SCIP_VARSTATUS_COLUMN ? SCIPcolGetNNonz(SCIPvarGetCol(var)) : 0);
if( SCIPvarIsBinary(var) )
{
score = 500.0 * SCIPvarGetNCliques(var, TRUE) + 100.0 * SCIPvarGetNImpls(var, TRUE)
+ SCIPgetVarAvgInferenceScore(scip, var) + (SCIP_Real)colveclen/100.0;
/* shift the non-binary variables one slot to the right */
for( i = c; i > nbinfixcands; --i )
{
fixcands[i] = fixcands[i-1];
fixcandscores[i] = fixcandscores[i-1];
}
/* put the new candidate into the first nbinfixcands slot */
left = 0;
right = nbinfixcands;
nbinfixcands++;
}
else
{
score = 5.0 * (SCIPvarGetNCliques(var, FALSE) + SCIPvarGetNCliques(var, TRUE))
+ SCIPvarGetNImpls(var, FALSE) + SCIPvarGetNImpls(var, TRUE) + SCIPgetVarAvgInferenceScore(scip, var)
+ (SCIP_Real)colveclen/10000.0;
/* put the new candidate in the slots after the binary candidates */
left = nbinfixcands;
right = c;
}
for( i = right; i > left && score > fixcandscores[i-1]; --i )
{
fixcands[i] = fixcands[i-1];
fixcandscores[i] = fixcandscores[i-1];
}
fixcands[i] = var;
fixcandscores[i] = score;
SCIPdebugMessage(" <%s>: ncliques=%d/%d, nimpls=%d/%d, inferencescore=%g, colveclen=%d -> score=%g\n",
SCIPvarGetName(var), SCIPvarGetNCliques(var, FALSE), SCIPvarGetNCliques(var, TRUE),
SCIPvarGetNImpls(var, FALSE), SCIPvarGetNImpls(var, TRUE), SCIPgetVarAvgInferenceScore(scip, var),
colveclen, score);
}
SCIPfreeBufferArray(scip, &fixcandscores);
/* get LP objective value */
lpsolstat = SCIP_LPSOLSTAT_OPTIMAL;
objval = SCIPgetLPObjval(scip);
/* dive as long we are in the given objective, depth and iteration limits, but if possible, we dive at least with
* the depth 10
*/
lperror = FALSE;
cutoff = FALSE;
divedepth = 0;
nextcand = 0;
while( !lperror && !cutoff && lpsolstat == SCIP_LPSOLSTAT_OPTIMAL
&& (divedepth < 10
|| (divedepth < maxdivedepth && heurdata->nlpiterations < maxnlpiterations && objval < searchbound))
&& !SCIPisStopped(scip) )
{
SCIP_VAR* var;
SCIP_Real bestsolval;
SCIP_Real bestfixval;
int bestcand;
SCIP_Longint nnewlpiterations;
SCIP_Longint nnewdomreds;
/* open a new probing node if this will not exceed the maximal tree depth, otherwise stop here */
if( SCIPgetDepth(scip) < SCIPgetDepthLimit(scip) )
{
SCIP_CALL( SCIPnewProbingNode(scip) );
divedepth++;
}
else
break;
nnewlpiterations = 0;
nnewdomreds = 0;
/* fix binary variable that is closest to 1 in the LP solution to 1;
* if all binary variables are fixed, fix integer variable with least fractionality in LP solution
*/
bestcand = -1;
bestsolval = -1.0;
bestfixval = 1.0;
/* look in the binary variables for fixing candidates */
for( c = nextcand; c < nbinfixcands; ++c )
{
SCIP_Real solval;
var = fixcands[c];
/* ignore already fixed variables */
if( var == NULL )
continue;
if( SCIPvarGetLbLocal(var) > 0.5 || SCIPvarGetUbLocal(var) < 0.5 )
{
fixcands[c] = NULL;
continue;
}
/* get the LP solution value */
solval = SCIPvarGetLPSol(var);
if( solval > bestsolval )
{
bestcand = c;
bestfixval = 1.0;
bestsolval = solval;
if( SCIPisGE(scip, bestsolval, 1.0) )
{
/* we found an unfixed binary variable with LP solution value of 1.0 - there cannot be a better candidate */
break;
}
else if( SCIPisLE(scip, bestsolval, 0.0) )
{
/* the variable is currently at 0.0 - this is the only situation where we want to fix it to 0.0 */
bestfixval = 0.0;
}
}
}
/* if all binary variables are fixed, look in the integer variables for a fixing candidate */
if( bestcand == -1 )
{
SCIP_Real bestfrac;
bestfrac = SCIP_INVALID;
for( c = MAX(nextcand, nbinfixcands); c < nfixcands; ++c )
{
SCIP_Real solval;
SCIP_Real frac;
var = fixcands[c];
/* ignore already fixed variables */
if( var == NULL )
continue;
if( SCIPvarGetUbLocal(var) - SCIPvarGetLbLocal(var) < 0.5 )
{
fixcands[c] = NULL;
continue;
}
/* get the LP solution value */
solval = SCIPvarGetLPSol(var);
frac = SCIPfrac(scip, solval);
/* ignore integer variables that are currently integral */
if( SCIPisFeasFracIntegral(scip, frac) )
continue;
if( frac < bestfrac )
{
bestcand = c;
bestsolval = solval;
bestfrac = frac;
bestfixval = SCIPfloor(scip, bestsolval + 0.5);
if( SCIPisZero(scip, bestfrac) )
{
/* we found an unfixed integer variable with integral LP solution value */
break;
}
}
}
}
assert(-1 <= bestcand && bestcand < nfixcands);
/* if there is no unfixed candidate left, we are done */
if( bestcand == -1 )
break;
var = fixcands[bestcand];
assert(var != NULL);
assert(SCIPvarIsIntegral(var));
assert(SCIPvarGetUbLocal(var) - SCIPvarGetLbLocal(var) > 0.5);
assert(SCIPisGE(scip, bestfixval, SCIPvarGetLbLocal(var)));
assert(SCIPisLE(scip, bestfixval, SCIPvarGetUbLocal(var)));
backtracked = FALSE;
do
{
/* if the variable is already fixed or if the solution value is outside the domain, numerical troubles may have
* occured or variable was fixed by propagation while backtracking => Abort diving!
*/
if( SCIPvarGetLbLocal(var) >= SCIPvarGetUbLocal(var) - 0.5 )
{
SCIPdebugMessage("Selected variable <%s> already fixed to [%g,%g], diving aborted \n",
SCIPvarGetName(var), SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var));
cutoff = TRUE;
break;
}
if( SCIPisFeasLT(scip, bestfixval, SCIPvarGetLbLocal(var)) || SCIPisFeasGT(scip, bestfixval, SCIPvarGetUbLocal(var)) )
{
SCIPdebugMessage("selected variable's <%s> solution value is outside the domain [%g,%g] (solval: %.9f), diving aborted\n",
SCIPvarGetName(var), SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var), bestfixval);
assert(backtracked);
break;
}
/* apply fixing of best candidate */
SCIPdebugMessage(" dive %d/%d, LP iter %" SCIP_LONGINT_FORMAT "/%" SCIP_LONGINT_FORMAT ", %d unfixed: var <%s>, sol=%g, oldbounds=[%g,%g], fixed to %g\n",
divedepth, maxdivedepth, heurdata->nlpiterations, maxnlpiterations, SCIPgetNPseudoBranchCands(scip),
SCIPvarGetName(var), bestsolval, SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var), bestfixval);
SCIP_CALL( SCIPfixVarProbing(scip, var, bestfixval) );
/* apply domain propagation */
SCIP_CALL( SCIPpropagateProbing(scip, 0, &cutoff, &nnewdomreds) );
if( !cutoff )
{
/* if the best candidate was just fixed to its LP value and no domain reduction was found, the LP solution
* stays valid, and the LP does not need to be resolved
*/
if( nnewdomreds > 0 || !SCIPisEQ(scip, bestsolval, bestfixval) )
{
/* resolve the diving LP */
/* Errors in the LP solver should not kill the overall solving process, if the LP is just needed for a heuristic.
* Hence in optimized mode, the return code is caught and a warning is printed, only in debug mode, SCIP will stop.
*/
#ifdef NDEBUG
SCIP_RETCODE retstat;
nlpiterations = SCIPgetNLPIterations(scip);
retstat = SCIPsolveProbingLP(scip, MAX((int)(maxnlpiterations - heurdata->nlpiterations), MINLPITER), &lperror, &cutoff);
if( retstat != SCIP_OKAY )
{
SCIPwarningMessage(scip, "Error while solving LP in Intdiving heuristic; LP solve terminated with code <%d>\n",retstat);
}
#else
nlpiterations = SCIPgetNLPIterations(scip);
SCIP_CALL( SCIPsolveProbingLP(scip, MAX((int)(maxnlpiterations - heurdata->nlpiterations), MINLPITER), &lperror, &cutoff) );
#endif
if( lperror )
break;
/* update iteration count */
nnewlpiterations = SCIPgetNLPIterations(scip) - nlpiterations;
heurdata->nlpiterations += nnewlpiterations;
/* get LP solution status */
lpsolstat = SCIPgetLPSolstat(scip);
assert(cutoff || (lpsolstat != SCIP_LPSOLSTAT_OBJLIMIT && lpsolstat != SCIP_LPSOLSTAT_INFEASIBLE &&
(lpsolstat != SCIP_LPSOLSTAT_OPTIMAL || SCIPisLT(scip, SCIPgetLPObjval(scip), SCIPgetCutoffbound(scip)))));
}
}
/* perform backtracking if a cutoff was detected */
if( cutoff && !backtracked && heurdata->backtrack )
{
SCIPdebugMessage(" *** cutoff detected at level %d - backtracking\n", SCIPgetProbingDepth(scip));
SCIP_CALL( SCIPbacktrackProbing(scip, SCIPgetProbingDepth(scip)-1) );
/* after backtracking there has to be at least one open node without exceeding the maximal tree depth */
assert(SCIPgetDepthLimit(scip) > SCIPgetDepth(scip));
SCIP_CALL( SCIPnewProbingNode(scip) );
bestfixval = SCIPvarIsBinary(var)
? 1.0 - bestfixval
: (SCIPisGT(scip, bestsolval, bestfixval) && SCIPisFeasLE(scip, bestfixval + 1, SCIPvarGetUbLocal(var)) ? bestfixval + 1 : bestfixval - 1);
backtracked = TRUE;
}
else
backtracked = FALSE;
}
while( backtracked );
if( !lperror && !cutoff && lpsolstat == SCIP_LPSOLSTAT_OPTIMAL )
{
SCIP_Bool success;
/* get new objective value */
objval = SCIPgetLPObjval(scip);
if( nnewlpiterations > 0 || !SCIPisEQ(scip, bestsolval, bestfixval) )
{
/* we must start again with the first candidate, since the LP solution changed */
nextcand = 0;
/* create solution from diving LP and try to round it */
SCIP_CALL( SCIPlinkLPSol(scip, heurdata->sol) );
SCIP_CALL( SCIProundSol(scip, heurdata->sol, &success) );
if( success )
{
SCIPdebugMessage("intdiving found roundable primal solution: obj=%g\n",
SCIPgetSolOrigObj(scip, heurdata->sol));
/* try to add solution to SCIP */
SCIP_CALL( SCIPtrySol(scip, heurdata->sol, FALSE, FALSE, FALSE, FALSE, &success) );
/* check, if solution was feasible and good enough */
if( success )
{
SCIPdebugMessage(" -> solution was feasible and good enough\n");
*result = SCIP_FOUNDSOL;
}
}
}
else
nextcand = bestcand+1; /* continue with the next candidate in the following loop */
}
SCIPdebugMessage(" -> lpsolstat=%d, objval=%g/%g\n", lpsolstat, objval, searchbound);
}
/* free temporary memory */
SCIPfreeBufferArray(scip, &fixcands);
/* end diving */
SCIP_CALL( SCIPendProbing(scip) );
if( *result == SCIP_FOUNDSOL )
heurdata->nsuccess++;
SCIPdebugMessage("intdiving heuristic finished\n");
return SCIP_OKAY;
}
/** creates the objective value inequality and the objective value variable, if not yet existing */
static
SCIP_RETCODE createObjRow(
SCIP* scip, /**< SCIP data structure */
SCIP_SEPA* sepa, /**< separator */
SCIP_SEPADATA* sepadata /**< separator data */
)
{
assert(sepadata != NULL);
if( sepadata->objrow == NULL )
{
SCIP_VAR** vars;
SCIP_Real obj;
SCIP_Real intobjval;
int nvars;
int v;
SCIP_Bool attendobjvarbound;
attendobjvarbound = FALSE;
/* create and add objective value variable */
if( sepadata->objvar == NULL )
{
SCIP_CALL( SCIPcreateVar(scip, &sepadata->objvar, "objvar", -SCIPinfinity(scip), SCIPinfinity(scip), 0.0,
SCIP_VARTYPE_IMPLINT, FALSE, TRUE, NULL, NULL, NULL, NULL, NULL) );
SCIP_CALL( SCIPaddVar(scip, sepadata->objvar) );
SCIP_CALL( SCIPaddVarLocks(scip, sepadata->objvar, +1, +1) );
}
else
attendobjvarbound = TRUE;
/* get problem variables */
vars = SCIPgetOrigVars(scip);
nvars = SCIPgetNOrigVars(scip);
/* create objective value inequality */
if( SCIPgetObjsense(scip) == SCIP_OBJSENSE_MINIMIZE )
{
if( attendobjvarbound )
intobjval = SCIPceil(scip, SCIPgetDualbound(scip)) - SCIPvarGetLbGlobal(sepadata->objvar);
else
intobjval = SCIPceil(scip, SCIPgetDualbound(scip));
SCIP_CALL( SCIPcreateEmptyRowSepa(scip, &sepadata->objrow, sepa, "objrow", intobjval, SCIPinfinity(scip),
FALSE, !SCIPallVarsInProb(scip), TRUE) );
sepadata->setoff = intobjval;
}
else
{
if( attendobjvarbound )
intobjval = SCIPceil(scip, SCIPgetDualbound(scip)) - SCIPvarGetUbGlobal(sepadata->objvar);
else
intobjval = SCIPfloor(scip, SCIPgetDualbound(scip));
SCIP_CALL( SCIPcreateEmptyRowSepa(scip, &sepadata->objrow, sepa, "objrow", -SCIPinfinity(scip), intobjval,
FALSE, !SCIPallVarsInProb(scip), TRUE) );
sepadata->setoff = intobjval;
}
SCIP_CALL( SCIPcacheRowExtensions(scip, sepadata->objrow) );
for( v = 0; v < nvars; ++v )
{
obj = SCIPvarGetObj(vars[v]);
if( !SCIPisZero(scip, obj) )
{
SCIP_CALL( SCIPaddVarToRow(scip, sepadata->objrow, vars[v], obj) );
}
}
SCIP_CALL( SCIPaddVarToRow(scip, sepadata->objrow, sepadata->objvar, -1.0) );
SCIP_CALL( SCIPflushRowExtensions(scip, sepadata->objrow) );
SCIPdebugMessage("created objective value row: ");
SCIPdebug( SCIP_CALL( SCIPprintRow(scip, sepadata->objrow, NULL) ) );
}
return SCIP_OKAY;
}
/** 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;
}
/** transforms given solution of the master problem into solution of the original problem
* @todo think about types of epsilons used in this method
*/
SCIP_RETCODE GCGrelaxTransformMastersolToOrigsol(
SCIP* scip, /**< SCIP data structure */
SCIP_SOL* mastersol, /**< solution of the master problem, or NULL for current LP solution */
SCIP_SOL** origsol /**< pointer to store the new created original problem's solution */
)
{
SCIP* masterprob;
int npricingprobs;
int* blocknrs;
SCIP_Real* blockvalue;
SCIP_Real increaseval;
SCIP_VAR** mastervars;
SCIP_Real* mastervals;
int nmastervars;
SCIP_VAR** vars;
int nvars;
SCIP_Real feastol;
int i;
int j;
assert(scip != NULL);
assert(origsol != NULL);
masterprob = GCGrelaxGetMasterprob(scip);
npricingprobs = GCGrelaxGetNPricingprobs(scip);
assert( !SCIPisInfinity(scip, SCIPgetSolOrigObj(masterprob, mastersol)) );
SCIP_CALL( SCIPcreateSol(scip, origsol, GCGrelaxGetProbingheur(scip)) );
SCIP_CALL( SCIPallocBufferArray(scip, &blockvalue, npricingprobs) );
SCIP_CALL( SCIPallocBufferArray(scip, &blocknrs, npricingprobs) );
/* get variables of the master problem and their solution values */
SCIP_CALL( SCIPgetVarsData(masterprob, &mastervars, &nmastervars, NULL, NULL, NULL, NULL) );
assert(mastervars != NULL);
assert(nmastervars >= 0);
SCIP_CALL( SCIPallocBufferArray(scip, &mastervals, nmastervars) );
SCIP_CALL( SCIPgetSolVals(masterprob, mastersol, nmastervars, mastervars, mastervals) );
/* initialize the block values for the pricing problems */
for( i = 0; i < npricingprobs; i++ )
{
blockvalue[i] = 0.0;
blocknrs[i] = 0;
}
/* loop over all given master variables */
for( i = 0; i < nmastervars; i++ )
{
SCIP_VAR** origvars;
int norigvars;
SCIP_Real* origvals;
SCIP_Bool isray;
int blocknr;
origvars = GCGmasterVarGetOrigvars(mastervars[i]);
norigvars = GCGmasterVarGetNOrigvars(mastervars[i]);
origvals = GCGmasterVarGetOrigvals(mastervars[i]);
blocknr = GCGvarGetBlock(mastervars[i]);
isray = GCGmasterVarIsRay(mastervars[i]);
assert(GCGvarIsMaster(mastervars[i]));
assert(!SCIPisFeasNegative(scip, mastervals[i]));
/** @todo handle infinite master solution values */
assert(!SCIPisInfinity(scip, mastervals[i]));
/* first of all, handle variables representing rays */
if( isray )
{
assert(blocknr >= 0);
/* we also want to take into account variables representing rays, that have a small value (between normal and feas eps),
* so we do no feas comparison here */
if( SCIPisPositive(scip, mastervals[i]) )
{
/* loop over all original variables contained in the current master variable */
for( j = 0; j < norigvars; j++ )
{
if( SCIPisZero(scip, origvals[j]) )
break;
assert(!SCIPisZero(scip, origvals[j]));
/* the original variable is a linking variable: just transfer the solution value of the direct copy (this is done later) */
if( GCGvarIsLinking(origvars[j]) )
continue;
SCIPdebugMessage("Increasing value of %s by %f because of %s\n", SCIPvarGetName(origvars[j]), origvals[j] * mastervals[i], SCIPvarGetName(mastervars[i]));
/* increase the corresponding value */
SCIP_CALL( SCIPincSolVal(scip, *origsol, origvars[j], origvals[j] * mastervals[i]) );
}
}
mastervals[i] = 0.0;
continue;
}
/* handle the variables with value >= 1 to get integral values in original solution */
while( SCIPisFeasGE(scip, mastervals[i], 1.0) )
{
/* variable was directly transferred to the master problem (only in linking conss or linking variable) */
/** @todo this may be the wrong place for this case, handle it before the while loop
* and remove the similar case in the next while loop */
if( blocknr == -1 )
{
assert(norigvars == 1);
assert(origvals[0] == 1.0);
/* increase the corresponding value */
SCIPdebugMessage("Increasing value of %s by %f because of %s\n", SCIPvarGetName(origvars[0]), origvals[0] * mastervals[i], SCIPvarGetName(mastervars[i]));
SCIP_CALL( SCIPincSolVal(scip, *origsol, origvars[0], origvals[0] * mastervals[i]) );
mastervals[i] = 0.0;
}
else
{
assert(blocknr >= 0);
/* loop over all original variables contained in the current master variable */
for( j = 0; j < norigvars; j++ )
{
SCIP_VAR* pricingvar;
int norigpricingvars;
SCIP_VAR** origpricingvars;
if( SCIPisZero(scip, origvals[j]) )
break;
assert(!SCIPisZero(scip, origvals[j]));
/* the original variable is a linking variable: just transfer the solution value of the direct copy (this is done above) */
if( GCGvarIsLinking(origvars[j]) )
continue;
pricingvar = GCGoriginalVarGetPricingVar(origvars[j]);
assert(GCGvarIsPricing(pricingvar));
norigpricingvars = GCGpricingVarGetNOrigvars(pricingvar);
origpricingvars = GCGpricingVarGetOrigvars(pricingvar);
/* just in case a variable has a value higher than the number of blocks, it represents */
if( norigpricingvars <= blocknrs[blocknr] )
{
SCIPdebugMessage("Increasing value of %s by %f because of %s\n", SCIPvarGetName(origpricingvars[norigpricingvars-1]), mastervals[i] * origvals[j], SCIPvarGetName(mastervars[i]));
/* increase the corresponding value */
SCIP_CALL( SCIPincSolVal(scip, *origsol, origpricingvars[norigpricingvars-1], mastervals[i] * origvals[j]) );
mastervals[i] = 1.0;
}
/* this should be default */
else
{
SCIPdebugMessage("Increasing value of %s by %f because of %s\n", SCIPvarGetName(origpricingvars[blocknrs[blocknr]]), origvals[j], SCIPvarGetName(mastervars[i]) );
/* increase the corresponding value */
SCIP_CALL( SCIPincSolVal(scip, *origsol, origpricingvars[blocknrs[blocknr]], origvals[j]) );
}
}
mastervals[i] = mastervals[i] - 1.0;
blocknrs[blocknr]++;
}
}
}
/* loop over all given master variables */
for( i = 0; i < nmastervars; i++ )
{
SCIP_VAR** origvars;
int norigvars;
SCIP_Real* origvals;
int blocknr;
origvars = GCGmasterVarGetOrigvars(mastervars[i]);
norigvars = GCGmasterVarGetNOrigvars(mastervars[i]);
origvals = GCGmasterVarGetOrigvals(mastervars[i]);
blocknr = GCGvarGetBlock(mastervars[i]);
if( SCIPisFeasZero(scip, mastervals[i]) )
{
continue;
}
assert(SCIPisFeasGE(scip, mastervals[i], 0.0) && SCIPisFeasLT(scip, mastervals[i], 1.0));
while( SCIPisFeasPositive(scip, mastervals[i]) )
{
assert(GCGvarIsMaster(mastervars[i]));
assert(!GCGmasterVarIsRay(mastervars[i]));
if( blocknr == -1 )
{
assert(norigvars == 1);
assert(origvals[0] == 1.0);
SCIPdebugMessage("Increasing value of %s by %f because of %s\n", SCIPvarGetName(origvars[0]), origvals[0] * mastervals[i], SCIPvarGetName(mastervars[i]) );
/* increase the corresponding value */
SCIP_CALL( SCIPincSolVal(scip, *origsol, origvars[0], origvals[0] * mastervals[i]) );
mastervals[i] = 0.0;
}
else
{
increaseval = MIN(mastervals[i], 1.0 - blockvalue[blocknr]);
/* loop over all original variables contained in the current master variable */
for( j = 0; j < norigvars; j++ )
{
SCIP_VAR* pricingvar;
int norigpricingvars;
SCIP_VAR** origpricingvars;
if( SCIPisZero(scip, origvals[j]) )
continue;
/* the original variable is a linking variable: just transfer the solution value of the direct copy (this is done above) */
if( GCGvarIsLinking(origvars[j]) )
continue;
pricingvar = GCGoriginalVarGetPricingVar(origvars[j]);
assert(GCGvarIsPricing(pricingvar));
norigpricingvars = GCGpricingVarGetNOrigvars(pricingvar);
origpricingvars = GCGpricingVarGetOrigvars(pricingvar);
if( norigpricingvars <= blocknrs[blocknr] )
{
increaseval = mastervals[i];
SCIPdebugMessage("Increasing value of %s by %f because of %s\n", SCIPvarGetName(origpricingvars[norigpricingvars-1]), origvals[j] * increaseval, SCIPvarGetName(mastervars[i]) );
/* increase the corresponding value */
SCIP_CALL( SCIPincSolVal(scip, *origsol, origpricingvars[norigpricingvars-1], origvals[j] * increaseval) );
}
else
{
/* increase the corresponding value */
SCIPdebugMessage("Increasing value of %s by %f because of %s\n", SCIPvarGetName(origpricingvars[blocknrs[blocknr]]), origvals[j] * increaseval, SCIPvarGetName(mastervars[i]) );
SCIP_CALL( SCIPincSolVal(scip, *origsol, origpricingvars[blocknrs[blocknr]], origvals[j] * increaseval) );
}
}
mastervals[i] = mastervals[i] - increaseval;
if( SCIPisFeasZero(scip, mastervals[i]) )
{
mastervals[i] = 0.0;
}
blockvalue[blocknr] += increaseval;
/* if the value assigned to the block is equal to 1, this block is full and we take the next block */
if( SCIPisFeasGE(scip, blockvalue[blocknr], 1.0) )
{
blockvalue[blocknr] = 0.0;
blocknrs[blocknr]++;
}
}
}
}
SCIPfreeBufferArray(scip, &mastervals);
SCIPfreeBufferArray(scip, &blocknrs);
SCIPfreeBufferArray(scip, &blockvalue);
/* if the solution violates one of its bounds by more than feastol
* and less than 10*feastol, round it and print a warning
*/
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, NULL, NULL, NULL, NULL) );
SCIP_CALL( SCIPgetRealParam(scip, "numerics/feastol", &feastol) );
for( i = 0; i < nvars; ++i )
{
SCIP_Real solval;
SCIP_Real lb;
SCIP_Real ub;
solval = SCIPgetSolVal(scip, *origsol, vars[i]);
lb = SCIPvarGetLbLocal(vars[i]);
ub = SCIPvarGetUbLocal(vars[i]);
if( SCIPisFeasGT(scip, solval, ub) && EPSEQ(solval, ub, 10 * feastol) )
{
SCIP_CALL( SCIPsetSolVal(scip, *origsol, vars[i], ub) );
SCIPwarningMessage(scip, "Variable %s rounded from %g to %g in relaxation solution\n",
SCIPvarGetName(vars[i]), solval, ub);
}
else if( SCIPisFeasLT(scip, solval, lb) && EPSEQ(solval, lb, 10 * feastol) )
{
SCIP_CALL( SCIPsetSolVal(scip, *origsol, vars[i], lb) );
SCIPwarningMessage(scip, "Variable %s rounded from %g to %g in relaxation solution\n",
SCIPvarGetName(vars[i]), solval, lb);
}
}
return SCIP_OKAY;
}
/** problem writing method of reader */
static
SCIP_DECL_READERWRITE(readerWriteCip)
{ /*lint --e{715}*/
SCIP_HASHTABLE* varhash = NULL;
SCIP_READERDATA* readerdata;
int i;
assert(reader != NULL);
assert(strcmp(SCIPreaderGetName(reader), READER_NAME) == 0);
SCIPinfoMessage(scip, file, "STATISTICS\n");
SCIPinfoMessage(scip, file, " Problem name : %s\n", name);
SCIPinfoMessage(scip, file, " Variables : %d (%d binary, %d integer, %d implicit integer, %d continuous)\n",
nvars, nbinvars, nintvars, nimplvars, ncontvars);
SCIPinfoMessage(scip, file, " Constraints : %d initial, %d maximal\n", startnconss, maxnconss);
SCIPinfoMessage(scip, file, "OBJECTIVE\n");
SCIPinfoMessage(scip, file, " Sense : %s\n", objsense == SCIP_OBJSENSE_MINIMIZE ? "minimize" : "maximize");
if( !SCIPisZero(scip, objoffset) )
SCIPinfoMessage(scip, file, " Offset : %+.15g\n", objoffset);
if( !SCIPisEQ(scip, objscale, 1.0) )
SCIPinfoMessage(scip, file, " Scale : %.15g\n", objscale);
if ( nfixedvars > 0 )
{
/* set up hash table for variables that have been written property (used for writing out fixed vars in the right order) */
SCIP_CALL( SCIPhashtableCreate(&varhash, SCIPblkmem(scip), SCIPcalcHashtableSize(10 * (nvars + nfixedvars)), hashGetKeyVar, hashKeyEqVar, hashKeyValVar, NULL) );
}
if ( nvars + nfixedvars > 0 )
{
SCIPinfoMessage(scip, file, "VARIABLES\n");
}
if( nvars > 0 )
{
for( i = 0; i < nvars; ++i )
{
SCIP_VAR* var;
var = vars[i];
assert( var != NULL );
SCIP_CALL( SCIPprintVar(scip, var, file) );
if ( varhash != NULL )
{
/* add free variable to hashtable */
if ( ! SCIPhashtableExists(varhash, (void*) var) )
{
SCIP_CALL( SCIPhashtableInsert(varhash, (void*) var) );
}
}
}
}
readerdata = SCIPreaderGetData(reader);
assert(readerdata != NULL);
if( readerdata->writefixedvars && nfixedvars > 0 )
{
int nwritten = 0;
SCIPinfoMessage(scip, file, "FIXED\n");
/* loop through variables until each has been written after the variables that it depends on have been written; this
* requires several runs over the variables, but the depth (= number of loops) is usually small. */
while ( nwritten < nfixedvars )
{
SCIPdebugMessage("written %d of %d fixed variables.\n", nwritten, nfixedvars);
for (i = 0; i < nfixedvars; ++i)
{
SCIP_VAR* var;
SCIP_VAR* tmpvar;
var = fixedvars[i];
assert( var != NULL );
/* skip variables already written */
if ( SCIPhashtableExists(varhash, (void*) var) )
continue;
switch ( SCIPvarGetStatus(var) )
{
case SCIP_VARSTATUS_FIXED:
/* fixed variables can simply be output and added to the hashtable */
SCIP_CALL( SCIPprintVar(scip, var, file) );
assert( ! SCIPhashtableExists(varhash, (void*) var) );
SCIP_CALL( SCIPhashtableInsert(varhash, (void*) var) );
++nwritten;
break;
case SCIP_VARSTATUS_NEGATED:
tmpvar = SCIPvarGetNegationVar(var);
assert( tmpvar != NULL );
assert( var == SCIPvarGetNegatedVar(tmpvar) );
/* if the negated variable has been written, we can write the current variable */
if ( SCIPhashtableExists(varhash, (void*) tmpvar) )
{
SCIP_CALL( SCIPprintVar(scip, var, file) );
assert( ! SCIPhashtableExists(varhash, (void*) var) );
SCIP_CALL( SCIPhashtableInsert(varhash, (void*) var) );
++nwritten;
}
break;
case SCIP_VARSTATUS_AGGREGATED:
tmpvar = SCIPvarGetAggrVar(var);
assert( tmpvar != NULL );
/* if the aggregating variable has been written, we can write the current variable */
if ( SCIPhashtableExists(varhash, (void*) tmpvar) )
{
SCIP_CALL( SCIPprintVar(scip, var, file) );
assert( ! SCIPhashtableExists(varhash, (void*) var) );
SCIP_CALL( SCIPhashtableInsert(varhash, (void*) var) );
++nwritten;
}
break;
case SCIP_VARSTATUS_MULTAGGR:
{
SCIP_VAR** aggrvars;
int naggrvars;
int j;
/* get the active representation */
SCIP_CALL( SCIPflattenVarAggregationGraph(scip, var) );
naggrvars = SCIPvarGetMultaggrNVars(var);
aggrvars = SCIPvarGetMultaggrVars(var);
assert(aggrvars != NULL || naggrvars == 0);
for (j = 0; j < naggrvars; ++j)
{
if( !SCIPhashtableExists(varhash, (void*) aggrvars[j]) ) /*lint !e613*/
break;
}
/* if all multi-aggregating variables have been written, we can write the current variable */
if ( j >= naggrvars )
{
SCIP_CALL( SCIPprintVar(scip, var, file) );
assert( ! SCIPhashtableExists(varhash, (void*) var) );
SCIP_CALL( SCIPhashtableInsert(varhash, (void*) var) );
++nwritten;
}
break;
}
case SCIP_VARSTATUS_ORIGINAL:
case SCIP_VARSTATUS_LOOSE:
case SCIP_VARSTATUS_COLUMN:
SCIPerrorMessage("Only fixed variables are allowed to be present in fixedvars list.\n");
SCIPABORT();
return SCIP_ERROR; /*lint !e527*/
}
}
}
}
if( nconss > 0 )
{
SCIPinfoMessage(scip, file, "CONSTRAINTS\n");
for( i = 0; i < nconss; ++i )
{
SCIP_CALL( SCIPprintCons(scip, conss[i], file) );
SCIPinfoMessage(scip, file, ";\n");
}
}
SCIPinfoMessage(scip, file, "END\n");
*result = SCIP_SUCCESS;
if( nfixedvars > 0 )
SCIPhashtableFree(&varhash);
else
assert(varhash == NULL);
return SCIP_OKAY;
}
/** problem reading method of reader */
static
SCIP_DECL_READERREAD(readerReadCip)
{ /*lint --e{715}*/
CIPINPUT cipinput;
SCIP_Real objscale;
SCIP_Real objoffset;
SCIP_Bool initialconss;
SCIP_Bool dynamicconss;
SCIP_Bool dynamiccols;
SCIP_Bool dynamicrows;
SCIP_Bool initialvar;
SCIP_Bool removablevar;
SCIP_RETCODE retcode;
if( NULL == (cipinput.file = SCIPfopen(filename, "r")) )
{
SCIPerrorMessage("cannot open file <%s> for reading\n", filename);
SCIPprintSysError(filename);
return SCIP_NOFILE;
}
cipinput.len = 131071;
SCIP_CALL( SCIPallocBufferArray(scip, &(cipinput.strbuf), cipinput.len) );
cipinput.linenumber = 0;
cipinput.section = CIP_START;
cipinput.haserror = FALSE;
cipinput.endfile = FALSE;
cipinput.readingsize = 65535;
SCIP_CALL( SCIPcreateProb(scip, filename, NULL, NULL, NULL, NULL, NULL, NULL, NULL) );
SCIP_CALL( SCIPgetBoolParam(scip, "reading/initialconss", &initialconss) );
SCIP_CALL( SCIPgetBoolParam(scip, "reading/dynamiccols", &dynamiccols) );
SCIP_CALL( SCIPgetBoolParam(scip, "reading/dynamicconss", &dynamicconss) );
SCIP_CALL( SCIPgetBoolParam(scip, "reading/dynamicrows", &dynamicrows) );
initialvar = !dynamiccols;
removablevar = dynamiccols;
objscale = 1.0;
objoffset = 0.0;
while( cipinput.section != CIP_END && !cipinput.haserror )
{
/* get next input string */
SCIP_CALL( getInputString(scip, &cipinput) );
if( cipinput.endfile )
break;
switch( cipinput.section )
{
case CIP_START:
getStart(scip, &cipinput);
break;
case CIP_STATISTIC:
SCIP_CALL( getStatistics(scip, &cipinput) );
break;
case CIP_OBJECTIVE:
SCIP_CALL( getObjective(scip, &cipinput, &objscale, &objoffset) );
break;
case CIP_VARS:
retcode = getVariable(scip, &cipinput, initialvar, removablevar, objscale);
if( retcode == SCIP_READERROR )
{
cipinput.haserror = TRUE;
goto TERMINATE;
}
SCIP_CALL(retcode);
break;
case CIP_FIXEDVARS:
retcode = getFixedVariable(scip, &cipinput);
if( retcode == SCIP_READERROR )
{
cipinput.haserror = TRUE;
goto TERMINATE;
}
SCIP_CALL(retcode);
break;
case CIP_CONSTRAINTS:
retcode = getConstraint(scip, &cipinput, initialconss, dynamicconss, dynamicrows);
if( retcode == SCIP_READERROR )
{
cipinput.haserror = TRUE;
goto TERMINATE;
}
SCIP_CALL(retcode);
break;
default:
SCIPerrorMessage("invalid CIP state\n");
SCIPABORT();
return SCIP_INVALIDDATA; /*lint !e527*/
} /*lint !e788*/
}
if( !SCIPisZero(scip, objoffset) && !cipinput.haserror )
{
SCIP_VAR* objoffsetvar;
objoffset *= objscale;
SCIP_CALL( SCIPcreateVar(scip, &objoffsetvar, "objoffset", objoffset, objoffset, 1.0, SCIP_VARTYPE_CONTINUOUS,
TRUE, TRUE, NULL, NULL, NULL, NULL, NULL) );
SCIP_CALL( SCIPaddVar(scip, objoffsetvar) );
SCIP_CALL( SCIPreleaseVar(scip, &objoffsetvar) );
SCIPdebugMessage("added variables <objoffset> for objective offset of <%g>\n", objoffset);
}
if( cipinput.section != CIP_END && !cipinput.haserror )
{
SCIPerrorMessage("unexpected EOF\n");
}
TERMINATE:
/* close file stream */
SCIPfclose(cipinput.file);
SCIPfreeBufferArray(scip, &cipinput.strbuf);
if( cipinput.haserror )
return SCIP_READERROR;
/* successfully parsed cip format */
*result = SCIP_SUCCESS;
return SCIP_OKAY;
}
/** LP solution separation method of separator */
static
SCIP_DECL_SEPAEXECLP(sepaExeclpGomory)
{ /*lint --e{715}*/
SCIP_SEPADATA* sepadata;
SCIP_VAR** vars;
SCIP_COL** cols;
SCIP_ROW** rows;
SCIP_Real* binvrow;
SCIP_Real* cutcoefs;
SCIP_Real maxscale;
SCIP_Real minfrac;
SCIP_Real maxfrac;
SCIP_Longint maxdnom;
SCIP_Bool cutoff;
int* basisind;
int naddedcuts;
int nvars;
int ncols;
int nrows;
int ncalls;
int depth;
int maxdepth;
int maxsepacuts;
int c;
int i;
assert(sepa != NULL);
assert(strcmp(SCIPsepaGetName(sepa), SEPA_NAME) == 0);
assert(scip != NULL);
assert(result != NULL);
*result = SCIP_DIDNOTRUN;
sepadata = SCIPsepaGetData(sepa);
assert(sepadata != NULL);
depth = SCIPgetDepth(scip);
ncalls = SCIPsepaGetNCallsAtNode(sepa);
minfrac = sepadata->away;
maxfrac = 1.0 - sepadata->away;
/* only call separator, if we are not close to terminating */
if( SCIPisStopped(scip) )
return SCIP_OKAY;
/* only call the gomory cut separator a given number of times at each node */
if( (depth == 0 && sepadata->maxroundsroot >= 0 && ncalls >= sepadata->maxroundsroot)
|| (depth > 0 && sepadata->maxrounds >= 0 && ncalls >= sepadata->maxrounds) )
return SCIP_OKAY;
/* only call separator, if an optimal LP solution is at hand */
if( SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
return SCIP_OKAY;
/* only call separator, if the LP solution is basic */
if( !SCIPisLPSolBasic(scip) )
return SCIP_OKAY;
/* only call separator, if there are fractional variables */
if( SCIPgetNLPBranchCands(scip) == 0 )
return SCIP_OKAY;
/* get variables data */
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, NULL, NULL, NULL, NULL) );
/* get LP data */
SCIP_CALL( SCIPgetLPColsData(scip, &cols, &ncols) );
SCIP_CALL( SCIPgetLPRowsData(scip, &rows, &nrows) );
if( ncols == 0 || nrows == 0 )
return SCIP_OKAY;
#if 0 /* if too many columns, separator is usually very slow: delay it until no other cuts have been found */
if( ncols >= 50*nrows )
return SCIP_OKAY;
if( ncols >= 5*nrows )
{
int ncutsfound;
ncutsfound = SCIPgetNCutsFound(scip);
if( ncutsfound > sepadata->lastncutsfound || !SCIPsepaWasLPDelayed(sepa) )
{
sepadata->lastncutsfound = ncutsfound;
*result = SCIP_DELAYED;
return SCIP_OKAY;
}
}
#endif
/* set the maximal denominator in rational representation of gomory cut and the maximal scale factor to
* scale resulting cut to integral values to avoid numerical instabilities
*/
/**@todo find better but still stable gomory cut settings: look at dcmulti, gesa3, khb0525, misc06, p2756 */
maxdepth = SCIPgetMaxDepth(scip);
if( depth == 0 )
{
maxdnom = 1000;
maxscale = 1000.0;
}
else if( depth <= maxdepth/4 )
{
maxdnom = 1000;
maxscale = 1000.0;
}
else if( depth <= maxdepth/2 )
{
maxdnom = 100;
maxscale = 100.0;
}
else
{
maxdnom = 10;
maxscale = 10.0;
}
/* allocate temporary memory */
SCIP_CALL( SCIPallocBufferArray(scip, &cutcoefs, nvars) );
SCIP_CALL( SCIPallocBufferArray(scip, &basisind, nrows) );
SCIP_CALL( SCIPallocBufferArray(scip, &binvrow, nrows) );
/* get basis indices */
SCIP_CALL( SCIPgetLPBasisInd(scip, basisind) );
/* get the maximal number of cuts allowed in a separation round */
if( depth == 0 )
maxsepacuts = sepadata->maxsepacutsroot;
else
maxsepacuts = sepadata->maxsepacuts;
SCIPdebugMessage("searching gomory cuts: %d cols, %d rows, maxdnom=%"SCIP_LONGINT_FORMAT", maxscale=%g, maxcuts=%d\n",
ncols, nrows, maxdnom, maxscale, maxsepacuts);
cutoff = FALSE;
naddedcuts = 0;
/* for all basic columns belonging to integer variables, try to generate a gomory cut */
for( i = 0; i < nrows && naddedcuts < maxsepacuts && !SCIPisStopped(scip) && !cutoff; ++i )
{
SCIP_Bool tryrow;
tryrow = FALSE;
c = basisind[i];
if( c >= 0 )
{
SCIP_VAR* var;
assert(c < ncols);
var = SCIPcolGetVar(cols[c]);
if( SCIPvarGetType(var) != SCIP_VARTYPE_CONTINUOUS )
{
SCIP_Real primsol;
primsol = SCIPcolGetPrimsol(cols[c]);
assert(SCIPgetVarSol(scip, var) == primsol); /*lint !e777*/
if( SCIPfeasFrac(scip, primsol) >= minfrac )
{
SCIPdebugMessage("trying gomory cut for col <%s> [%g]\n", SCIPvarGetName(var), primsol);
tryrow = TRUE;
}
}
}
else if( sepadata->separaterows )
{
SCIP_ROW* row;
assert(0 <= -c-1 && -c-1 < nrows);
row = rows[-c-1];
if( SCIProwIsIntegral(row) && !SCIProwIsModifiable(row) )
{
SCIP_Real primsol;
primsol = SCIPgetRowActivity(scip, row);
if( SCIPfeasFrac(scip, primsol) >= minfrac )
{
SCIPdebugMessage("trying gomory cut for row <%s> [%g]\n", SCIProwGetName(row), primsol);
tryrow = TRUE;
}
}
}
if( tryrow )
{
SCIP_Real cutrhs;
SCIP_Real cutact;
SCIP_Bool success;
SCIP_Bool cutislocal;
/* get the row of B^-1 for this basic integer variable with fractional solution value */
SCIP_CALL( SCIPgetLPBInvRow(scip, i, binvrow) );
cutact = 0.0;
cutrhs = SCIPinfinity(scip);
/* create a MIR cut out of the weighted LP rows using the B^-1 row as weights */
SCIP_CALL( SCIPcalcMIR(scip, NULL, BOUNDSWITCH, USEVBDS, ALLOWLOCAL, FIXINTEGRALRHS, NULL, NULL,
(int) MAXAGGRLEN(nvars), sepadata->maxweightrange, minfrac, maxfrac,
binvrow, 1.0, NULL, NULL, cutcoefs, &cutrhs, &cutact, &success, &cutislocal) );
assert(ALLOWLOCAL || !cutislocal);
/* @todo Currently we are using the SCIPcalcMIR() function to compute the coefficients of the Gomory
* cut. Alternatively, we could use the direct version (see thesis of Achterberg formula (8.4)) which
* leads to cut a of the form \sum a_i x_i \geq 1. Rumor has it that these cuts are better.
*/
SCIPdebugMessage(" -> success=%u: %g <= %g\n", success, cutact, cutrhs);
/* if successful, convert dense cut into sparse row, and add the row as a cut */
if( success && SCIPisFeasGT(scip, cutact, cutrhs) )
{
SCIP_ROW* cut;
char cutname[SCIP_MAXSTRLEN];
int v;
/* construct cut name */
if( c >= 0 )
(void) SCIPsnprintf(cutname, SCIP_MAXSTRLEN, "gom%d_x%d", SCIPgetNLPs(scip), c);
else
(void) SCIPsnprintf(cutname, SCIP_MAXSTRLEN, "gom%d_s%d", SCIPgetNLPs(scip), -c-1);
/* create empty cut */
SCIP_CALL( SCIPcreateEmptyRowSepa(scip, &cut, sepa, cutname, -SCIPinfinity(scip), cutrhs,
cutislocal, FALSE, sepadata->dynamiccuts) );
/* cache the row extension and only flush them if the cut gets added */
SCIP_CALL( SCIPcacheRowExtensions(scip, cut) );
/* collect all non-zero coefficients */
for( v = 0; v < nvars; ++v )
{
if( !SCIPisZero(scip, cutcoefs[v]) )
{
SCIP_CALL( SCIPaddVarToRow(scip, cut, vars[v], cutcoefs[v]) );
}
}
if( SCIProwGetNNonz(cut) == 0 )
{
assert(SCIPisFeasNegative(scip, cutrhs));
SCIPdebugMessage(" -> gomory cut detected infeasibility with cut 0 <= %f\n", cutrhs);
cutoff = TRUE;
}
else if( SCIProwGetNNonz(cut) == 1 )
{
/* add the bound change as cut to avoid that the LP gets modified. that would mean the LP is not flushed
* and the method SCIPgetLPBInvRow() fails; SCIP internally will apply that bound change automatically
*/
SCIP_CALL( SCIPaddCut(scip, NULL, cut, TRUE) );
naddedcuts++;
}
else
{
/* Only take efficacious cuts, except for cuts with one non-zero coefficients (= bound
* changes); the latter cuts will be handeled internally in sepastore.
*/
if( SCIPisCutEfficacious(scip, NULL, cut) )
{
assert(success == TRUE);
SCIPdebugMessage(" -> gomory cut for <%s>: act=%f, rhs=%f, eff=%f\n",
c >= 0 ? SCIPvarGetName(SCIPcolGetVar(cols[c])) : SCIProwGetName(rows[-c-1]),
cutact, cutrhs, SCIPgetCutEfficacy(scip, NULL, cut));
if( sepadata->makeintegral )
{
/* try to scale the cut to integral values */
SCIP_CALL( SCIPmakeRowIntegral(scip, cut, -SCIPepsilon(scip), SCIPsumepsilon(scip),
maxdnom, maxscale, MAKECONTINTEGRAL, &success) );
if( sepadata->forcecuts )
success = TRUE;
/* in case the left hand side in minus infinity and the right hand side is plus infinity the cut is
* useless so we are not taking it at all
*/
if( (SCIPisInfinity(scip, -SCIProwGetLhs(cut)) && SCIPisInfinity(scip, SCIProwGetRhs(cut))) )
success = FALSE;
/* @todo Trying to make the Gomory cut integral might fail. Due to numerical reasons/arguments we
* currently ignore such cuts. If the cut, however, has small support (let's say smaller or equal to
* 5), we might want to add that cut (even it does not have integral coefficients). To be able to
* do that we need to add a rank to the data structure of a row. The rank of original rows are
* zero and for aggregated rows it is the maximum over all used rows plus one.
*/
}
if( success )
{
SCIPdebugMessage(" -> found gomory cut <%s>: act=%f, rhs=%f, norm=%f, eff=%f, min=%f, max=%f (range=%f)\n",
cutname, SCIPgetRowLPActivity(scip, cut), SCIProwGetRhs(cut), SCIProwGetNorm(cut),
SCIPgetCutEfficacy(scip, NULL, cut),
SCIPgetRowMinCoef(scip, cut), SCIPgetRowMaxCoef(scip, cut),
SCIPgetRowMaxCoef(scip, cut)/SCIPgetRowMinCoef(scip, cut));
/* flush all changes before adding the cut */
SCIP_CALL( SCIPflushRowExtensions(scip, cut) );
/* add global cuts which are not implicit bound changes to the cut pool */
if( !cutislocal )
{
if( sepadata->delayedcuts )
{
SCIP_CALL( SCIPaddDelayedPoolCut(scip, cut) );
}
else
{
SCIP_CALL( SCIPaddPoolCut(scip, cut) );
}
}
else
{
/* local cuts we add to the sepastore */
SCIP_CALL( SCIPaddCut(scip, NULL, cut, FALSE) );
}
naddedcuts++;
}
}
}
/* release the row */
SCIP_CALL( SCIPreleaseRow(scip, &cut) );
}
}
}
/* free temporary memory */
SCIPfreeBufferArray(scip, &binvrow);
SCIPfreeBufferArray(scip, &basisind);
SCIPfreeBufferArray(scip, &cutcoefs);
SCIPdebugMessage("end searching gomory cuts: found %d cuts\n", naddedcuts);
sepadata->lastncutsfound = SCIPgetNCutsFound(scip);
/* evalute the result of the separation */
if( cutoff )
*result = SCIP_CUTOFF;
else if ( naddedcuts > 0 )
*result = SCIP_SEPARATED;
else
*result = SCIP_DIDNOTFIND;
return SCIP_OKAY;
}
/** stores nonzero elements of dense coefficient vector as sparse vector, and calculates activity and norm */
static
SCIP_RETCODE storeCutInArrays(
SCIP* scip, /**< SCIP data structure */
int nvars, /**< number of problem variables */
SCIP_VAR** vars, /**< problem variables */
SCIP_Real* cutcoefs, /**< dense coefficient vector */
SCIP_Real* varsolvals, /**< dense variable LP solution vector */
char normtype, /**< type of norm to use for efficacy norm calculation */
SCIP_VAR** cutvars, /**< array to store variables of sparse cut vector */
SCIP_Real* cutvals, /**< array to store coefficients of sparse cut vector */
int* cutlen, /**< pointer to store number of nonzero entries in cut */
SCIP_Real* cutact, /**< pointer to store activity of cut */
SCIP_Real* cutnorm /**< pointer to store norm of cut vector */
)
{
SCIP_Real val;
SCIP_Real absval;
SCIP_Real cutsqrnorm;
SCIP_Real act;
SCIP_Real norm;
int len;
int v;
assert(nvars == 0 || cutcoefs != NULL);
assert(nvars == 0 || varsolvals != NULL);
assert(cutvars != NULL);
assert(cutvals != NULL);
assert(cutlen != NULL);
assert(cutact != NULL);
assert(cutnorm != NULL);
len = 0;
act = 0.0;
norm = 0.0;
switch( normtype )
{
case 'e':
cutsqrnorm = 0.0;
for( v = 0; v < nvars; ++v )
{
val = cutcoefs[v];
if( !SCIPisZero(scip, val) )
{
act += val * varsolvals[v];
cutsqrnorm += SQR(val);
cutvars[len] = vars[v];
cutvals[len] = val;
len++;
}
}
norm = SQRT(cutsqrnorm);
break;
case 'm':
for( v = 0; v < nvars; ++v )
{
val = cutcoefs[v];
if( !SCIPisZero(scip, val) )
{
act += val * varsolvals[v];
absval = ABS(val);
norm = MAX(norm, absval);
cutvars[len] = vars[v];
cutvals[len] = val;
len++;
}
}
break;
case 's':
for( v = 0; v < nvars; ++v )
{
val = cutcoefs[v];
if( !SCIPisZero(scip, val) )
{
act += val * varsolvals[v];
norm += ABS(val);
cutvars[len] = vars[v];
cutvals[len] = val;
len++;
}
}
break;
case 'd':
for( v = 0; v < nvars; ++v )
{
val = cutcoefs[v];
if( !SCIPisZero(scip, val) )
{
act += val * varsolvals[v];
norm = 1.0;
cutvars[len] = vars[v];
cutvals[len] = val;
len++;
}
}
break;
default:
SCIPerrorMessage("invalid efficacy norm parameter '%c'\n", normtype);
return SCIP_INVALIDDATA;
}
*cutlen = len;
*cutact = act;
*cutnorm = norm;
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;
}
/** reads an objective or constraint with name and coefficients */
static
SCIP_RETCODE readCoefficients(
SCIP* scip, /**< SCIP data structure */
LPINPUT* lpinput, /**< LP reading data */
SCIP_Bool isobjective, /**< indicates whether we are currently reading the coefficients of the objective */
char* name, /**< pointer to store the name of the line; must be at least of size
* LP_MAX_LINELEN */
SCIP_VAR*** vars, /**< pointer to store the array with variables (must be freed by caller) */
SCIP_Real** coefs, /**< pointer to store the array with coefficients (must be freed by caller) */
int* ncoefs, /**< pointer to store the number of coefficients */
SCIP_Bool* newsection /**< pointer to store whether a new section was encountered */
)
{
SCIP_Bool havesign;
SCIP_Bool havevalue;
SCIP_Real coef;
int coefsign;
int coefssize;
assert(lpinput != NULL);
assert(name != NULL);
assert(vars != NULL);
assert(coefs != NULL);
assert(ncoefs != NULL);
assert(newsection != NULL);
*vars = NULL;
*coefs = NULL;
*name = '\0';
*ncoefs = 0;
*newsection = FALSE;
/* read the first token, which may be the name of the line */
if( getNextToken(scip, lpinput) )
{
/* check if we reached a new section */
if( isNewSection(scip, lpinput) )
{
*newsection = TRUE;
return SCIP_OKAY;
}
/* remember the token in the token buffer */
swapTokenBuffer(lpinput);
/* get the next token and check, whether it is a colon */
if( getNextToken(scip, lpinput) )
{
if( strcmp(lpinput->token, ":") == 0 )
{
/* the second token was a colon: the first token is the line name */
(void)SCIPmemccpy(name, lpinput->tokenbuf, '\0', LP_MAX_LINELEN);
name[LP_MAX_LINELEN - 1] = '\0';
SCIPdebugMessage("(line %d) read constraint name: '%s'\n", lpinput->linenumber, name);
}
else
{
/* the second token was no colon: push the tokens back onto the token stack and parse them as coefficients */
pushToken(lpinput);
pushBufferToken(lpinput);
}
}
else
{
/* there was only one token left: push it back onto the token stack and parse it as coefficient */
pushBufferToken(lpinput);
}
}
/* initialize buffers for storing the coefficients */
coefssize = LP_INIT_COEFSSIZE;
SCIP_CALL( SCIPallocMemoryArray(scip, vars, coefssize) );
SCIP_CALL( SCIPallocMemoryArray(scip, coefs, coefssize) );
/* read the coefficients */
coefsign = +1;
coef = 1.0;
havesign = FALSE;
havevalue = FALSE;
*ncoefs = 0;
while( getNextToken(scip, lpinput) )
{
SCIP_VAR* var;
/* check if we read a sign */
if( isSign(lpinput, &coefsign) )
{
SCIPdebugMessage("(line %d) read coefficient sign: %+d\n", lpinput->linenumber, coefsign);
havesign = TRUE;
continue;
}
/* check if we read a value */
if( isValue(scip, lpinput, &coef) )
{
SCIPdebugMessage("(line %d) read coefficient value: %g with sign %+d\n", lpinput->linenumber, coef, coefsign);
if( havevalue )
{
syntaxError(scip, lpinput, "two consecutive values.");
return SCIP_OKAY;
}
havevalue = TRUE;
continue;
}
/* check if we reached an equation sense */
if( isSense(lpinput, NULL) )
{
if( isobjective )
{
syntaxError(scip, lpinput, "no sense allowed in objective");
return SCIP_OKAY;
}
/* put the sense back onto the token stack */
pushToken(lpinput);
break;
}
/* check if we reached a new section, that will be only allowed when having no current sign and value and if we
* are not in the quadratic part
*/
if( (isobjective || (!havevalue && !havesign)) && isNewSection(scip, lpinput) )
{
if( havesign && !havevalue )
{
SCIPwarningMessage(scip, "skipped single sign %c without value or variable in objective\n", coefsign == 1 ? '+' : '-');
}
else if( isobjective && havevalue && !SCIPisZero(scip, coef) )
{
SCIPwarningMessage(scip, "constant term %+g in objective is skipped\n", coef * coefsign);
}
*newsection = TRUE;
return SCIP_OKAY;
}
/* check if we start a quadratic part */
if( *lpinput->token == '[' )
{
syntaxError(scip, lpinput, "diff reader does not support quadratic objective function.");
return SCIP_READERROR;
}
/* all but the first coefficient need a sign */
if( *ncoefs > 0 && !havesign )
{
syntaxError(scip, lpinput, "expected sign ('+' or '-') or sense ('<' or '>').");
return SCIP_OKAY;
}
/* check if the last variable should be squared */
if( *lpinput->token == '^' )
{
syntaxError(scip, lpinput, "diff reader does not support quadratic objective function.");
return SCIP_READERROR;
}
else
{
/* the token is a variable name: get the corresponding variable */
SCIP_CALL( getVariable(scip, lpinput->token, &var) );
}
/* insert the linear coefficient */
SCIPdebugMessage("(line %d) read linear coefficient: %+g<%s>\n", lpinput->linenumber, coefsign * coef, SCIPvarGetName(var));
if( !SCIPisZero(scip, coef) )
{
/* resize the vars and coefs array if needed */
if( *ncoefs >= coefssize )
{
coefssize *= 2;
coefssize = MAX(coefssize, (*ncoefs)+1);
SCIP_CALL( SCIPreallocMemoryArray(scip, vars, coefssize) );
SCIP_CALL( SCIPreallocMemoryArray(scip, coefs, coefssize) );
}
assert(*ncoefs < coefssize);
/* add coefficient */
(*vars)[*ncoefs] = var;
(*coefs)[*ncoefs] = coefsign * coef;
(*ncoefs)++;
}
/* reset the flags and coefficient value for the next coefficient */
coefsign = +1;
coef = 1.0;
havesign = FALSE;
havevalue = FALSE;
}
return SCIP_OKAY;
}
