/** output method of display column to output file stream 'file' */
static
SCIP_DECL_DISPOUTPUT(SCIPdispOutputNfrac)
{ /*lint --e{715}*/
assert(disp != NULL);
assert(strcmp(SCIPdispGetName(disp), DISP_NAME_NFRAC) == 0);
assert(scip != NULL);
if( SCIPhasCurrentNodeLP(scip) && SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL )
SCIPdispInt(SCIPgetMessagehdlr(scip), file, SCIPgetNLPBranchCands(scip), DISP_WIDT_NFRAC);
else
SCIPinfoMessage(scip, file, " - ");
return SCIP_OKAY;
}
/** LP solution separation method of separator */
static
SCIP_DECL_SEPAEXECLP(sepaExeclpIntobj)
{ /*lint --e{715}*/
*result = SCIP_DIDNOTRUN;
/* only call separator, if we are not close to terminating */
if( SCIPisStopped(scip) )
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 there are fractional variables */
if( SCIPgetNLPBranchCands(scip) == 0 )
return SCIP_OKAY;
SCIP_CALL( separateCuts(scip, sepa, NULL, result) );
return SCIP_OKAY;
}
/** LP solution separation method of separator */
static
SCIP_DECL_SEPAEXECLP(sepaExeclpClosecuts)
{ /*lint --e{715}*/
SCIP_SEPADATA* sepadata;
SCIP_Longint currentnodenumber;
SCIP_Bool isroot;
assert( sepa != NULL );
assert( strcmp(SCIPsepaGetName(sepa), SEPA_NAME) == 0 );
assert( result != NULL );
*result = SCIP_DIDNOTRUN;
/* only call separator, if there are fractional variables */
if ( SCIPgetNLPBranchCands(scip) == 0 )
return SCIP_OKAY;
sepadata = SCIPsepaGetData(sepa);
assert( sepadata != NULL );
currentnodenumber = SCIPnodeGetNumber(SCIPgetCurrentNode(scip));
if ( sepadata->discardnode == currentnodenumber )
return SCIP_OKAY;
isroot = FALSE;
if (SCIPgetNNodes(scip) == 0)
isroot = TRUE;
/* only separate close cuts in the root if required */
if ( sepadata->separootonly || isroot )
{
SCIP_SOL* point = NULL;
SCIPdebugMessage("Separation method of closecuts separator.\n");
*result = SCIP_DIDNOTFIND;
/* check whether we have to compute a relative interior point */
if ( sepadata->separelint )
{
/* check if previous relative interior point should be forgotten,
* otherwise it is computed only once and the same point is used for all nodes */
if ( sepadata->recomputerelint && sepadata->sepasol != NULL )
{
SCIP_CALL( SCIPfreeSol(scip, &sepadata->sepasol) );
}
if ( sepadata->sepasol == NULL )
{
SCIPverbMessage(scip, SCIP_VERBLEVEL_MINIMAL, 0, "Computing relative interior point (norm type: %c) ...\n", sepadata->relintnormtype);
assert(sepadata->relintnormtype == 'o' || sepadata->relintnormtype == 's');
SCIP_CALL( SCIPcomputeLPRelIntPoint(scip, TRUE, sepadata->inclobjcutoff, sepadata->relintnormtype, &sepadata->sepasol) );
}
}
else
{
/* get best solution (NULL if not present) */
sepadata->sepasol = SCIPgetBestSol(scip);
}
/* separate close cuts */
if ( sepadata->sepasol != NULL )
{
SCIPdebugMessage("Generating close cuts ... (combination value: %f)\n", sepadata->sepacombvalue);
/* generate point to be separated */
SCIP_CALL( generateCloseCutPoint(scip, sepadata, &point) );
/* apply a separation round to generated point */
if ( point != NULL )
{
int noldcuts;
SCIP_Bool delayed;
SCIP_Bool cutoff;
noldcuts = SCIPgetNCuts(scip);
SCIP_CALL( SCIPseparateSol(scip, point, isroot, FALSE, &delayed, &cutoff) );
SCIP_CALL( SCIPfreeSol(scip, &point) );
assert( point == NULL );
/* the cuts can be not violated by the current LP if the computed point is strange */
SCIP_CALL( SCIPremoveInefficaciousCuts(scip) );
if ( cutoff )
*result = SCIP_CUTOFF;
else
{
if ( SCIPgetNCuts(scip) - noldcuts > sepadata->sepathreshold )
{
sepadata->nunsuccessful = 0;
*result = SCIP_NEWROUND;
}
else
{
if ( SCIPgetNCuts(scip) > noldcuts )
{
sepadata->nunsuccessful = 0;
*result = SCIP_SEPARATED;
}
else
++sepadata->nunsuccessful;
}
}
SCIPdebugMessage("Separated close cuts: %d (enoughcuts: %d, unsuccessful: %d).\n", SCIPgetNCuts(scip) - noldcuts,
SCIPgetNCuts(scip) - noldcuts > sepadata->sepathreshold, sepadata->nunsuccessful);
if ( sepadata->maxunsuccessful >= 0 && sepadata->nunsuccessful > sepadata->maxunsuccessful )
{
SCIPdebugMessage("Turn off close cut separation, because of %d unsuccessful calls.\n", sepadata->nunsuccessful);
sepadata->discardnode = currentnodenumber;
}
}
}
}
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;
}
/** LP solution separation method of separator */
static
SCIP_DECL_SEPAEXECLP(sepaExeclpStrongcg)
{ /*lint --e{715}*/
SCIP_SEPADATA* sepadata;
SCIP_VAR** vars;
SCIP_COL** cols;
SCIP_ROW** rows;
SCIP_Real* varsolvals;
SCIP_Real* binvrow;
SCIP_Real* cutcoefs;
SCIP_Real cutrhs;
SCIP_Real cutact;
SCIP_Real maxscale;
SCIP_Longint maxdnom;
int* basisind;
int* inds;
int ninds;
int nvars;
int ncols;
int nrows;
int ncalls;
int depth;
int maxdepth;
int maxsepacuts;
int ncuts;
int c;
int i;
int cutrank;
SCIP_Bool success;
SCIP_Bool cutislocal;
char normtype;
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);
/* only call separator, if we are not close to terminating */
if( SCIPisStopped(scip) )
return SCIP_OKAY;
/* only call the strong CG 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
/* get the type of norm to use for efficacy calculations */
SCIP_CALL( SCIPgetCharParam(scip, "separating/efficacynorm", &normtype) );
/* set the maximal denominator in rational representation of strong CG cut and the maximal scale factor to
* scale resulting cut to integral values to avoid numerical instabilities
*/
/**@todo find better but still stable strong CG 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;
}
*result = SCIP_DIDNOTFIND;
/* allocate temporary memory */
SCIP_CALL( SCIPallocBufferArray(scip, &cutcoefs, nvars) );
SCIP_CALL( SCIPallocBufferArray(scip, &basisind, nrows) );
SCIP_CALL( SCIPallocBufferArray(scip, &binvrow, nrows) );
SCIP_CALL( SCIPallocBufferArray(scip, &inds, nrows) );
varsolvals = NULL; /* allocate this later, if needed */
/* 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 strong CG cuts: %d cols, %d rows, maxdnom=%" SCIP_LONGINT_FORMAT ", maxscale=%g, maxcuts=%d\n",
ncols, nrows, maxdnom, maxscale, maxsepacuts);
/* for all basic columns belonging to integer variables, try to generate a strong CG cut */
ncuts = 0;
for( i = 0; i < nrows && ncuts < maxsepacuts && !SCIPisStopped(scip) && *result != 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 strong CG cut for col <%s> [%g]\n", SCIPvarGetName(var), primsol);
tryrow = TRUE;
}
}
}
#ifdef SEPARATEROWS
else
{
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 strong CG cut for row <%s> [%g]\n", SCIProwGetName(row), primsol);
tryrow = TRUE;
}
}
}
#endif
if( tryrow )
{
/* get the row of B^-1 for this basic integer variable with fractional solution value */
SCIP_CALL( SCIPgetLPBInvRow(scip, i, binvrow, inds, &ninds) );
#ifdef SCIP_DEBUG
/* initialize variables, that might not have been initialized in SCIPcalcMIR if success == FALSE */
cutact = 0.0;
cutrhs = SCIPinfinity(scip);
#endif
/* create a strong CG cut out of the weighted LP rows using the B^-1 row as weights */
SCIP_CALL( SCIPcalcStrongCG(scip, BOUNDSWITCH, USEVBDS, ALLOWLOCAL, (int) MAXAGGRLEN(nvars), sepadata->maxweightrange, MINFRAC, MAXFRAC,
binvrow, inds, ninds, 1.0, cutcoefs, &cutrhs, &cutact, &success, &cutislocal, &cutrank) );
assert(ALLOWLOCAL || !cutislocal);
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_VAR** cutvars;
SCIP_Real* cutvals;
SCIP_Real cutnorm;
int cutlen;
/* if this is the first successful cut, get the LP solution for all COLUMN variables */
if( varsolvals == NULL )
{
int v;
SCIP_CALL( SCIPallocBufferArray(scip, &varsolvals, nvars) );
for( v = 0; v < nvars; ++v )
{
if( SCIPvarGetStatus(vars[v]) == SCIP_VARSTATUS_COLUMN )
varsolvals[v] = SCIPvarGetLPSol(vars[v]);
}
}
assert(varsolvals != NULL);
/* get temporary memory for storing the cut as sparse row */
SCIP_CALL( SCIPallocBufferArray(scip, &cutvars, nvars) );
SCIP_CALL( SCIPallocBufferArray(scip, &cutvals, nvars) );
/* store the cut as sparse row, calculate activity and norm of cut */
SCIP_CALL( storeCutInArrays(scip, nvars, vars, cutcoefs, varsolvals, normtype,
cutvars, cutvals, &cutlen, &cutact, &cutnorm) );
SCIPdebugMessage(" -> strong CG cut for <%s>: act=%f, rhs=%f, norm=%f, eff=%f, rank=%d\n",
c >= 0 ? SCIPvarGetName(SCIPcolGetVar(cols[c])) : SCIProwGetName(rows[-c-1]),
cutact, cutrhs, cutnorm, (cutact - cutrhs)/cutnorm, cutrank);
if( SCIPisPositive(scip, cutnorm) && SCIPisEfficacious(scip, (cutact - cutrhs)/cutnorm) )
{
SCIP_ROW* cut;
char cutname[SCIP_MAXSTRLEN];
/* create the cut */
if( c >= 0 )
(void) SCIPsnprintf(cutname, SCIP_MAXSTRLEN, "scg%d_x%d", SCIPgetNLPs(scip), c);
else
(void) SCIPsnprintf(cutname, SCIP_MAXSTRLEN, "scg%d_s%d", SCIPgetNLPs(scip), -c-1);
SCIP_CALL( SCIPcreateEmptyRowSepa(scip, &cut, sepa, cutname, -SCIPinfinity(scip), cutrhs, cutislocal, FALSE, sepadata->dynamiccuts) );
SCIP_CALL( SCIPaddVarsToRow(scip, cut, cutlen, cutvars, cutvals) );
/*SCIPdebug( SCIP_CALL(SCIPprintRow(scip, cut, NULL)) );*/
SCIProwChgRank(cut, cutrank);
assert(success);
#ifdef MAKECUTINTEGRAL
/* try to scale the cut to integral values */
SCIP_CALL( SCIPmakeRowIntegral(scip, cut, -SCIPepsilon(scip), SCIPsumepsilon(scip),
maxdnom, maxscale, MAKECONTINTEGRAL, &success) );
#else
#ifdef MAKEINTCUTINTEGRAL
/* try to scale the cut to integral values if there are no continuous variables
* -> leads to an integral slack variable that can later be used for other cuts
*/
{
int k = 0;
while ( k < cutlen && SCIPvarIsIntegral(cutvars[k]) )
++k;
if( k == cutlen )
{
SCIP_CALL( SCIPmakeRowIntegral(scip, cut, -SCIPepsilon(scip), SCIPsumepsilon(scip),
maxdnom, maxscale, MAKECONTINTEGRAL, &success) );
}
}
#endif
#endif
#ifndef FORCECUTINTEGRAL
success = TRUE;
#endif
if( success )
{
if( !SCIPisCutEfficacious(scip, NULL, cut) )
{
SCIPdebugMessage(" -> strong CG cut <%s> no longer efficacious: act=%f, rhs=%f, norm=%f, eff=%f\n",
cutname, SCIPgetRowLPActivity(scip, cut), SCIProwGetRhs(cut), SCIProwGetNorm(cut),
SCIPgetCutEfficacy(scip, NULL, cut));
/*SCIPdebug( SCIP_CALL(SCIPprintRow(scip, cut, NULL)) );*/
success = FALSE;
}
else
{
SCIP_Bool infeasible;
SCIPdebugMessage(" -> found strong CG 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));
/*SCIPdebug( SCIP_CALL(SCIPprintRow(scip, cut, NULL)) );*/
SCIP_CALL( SCIPaddCut(scip, NULL, cut, FALSE, &infeasible) );
if ( infeasible )
*result = SCIP_CUTOFF;
else
{
if( !cutislocal )
{
SCIP_CALL( SCIPaddPoolCut(scip, cut) );
}
*result = SCIP_SEPARATED;
}
ncuts++;
}
}
else
{
SCIPdebugMessage(" -> strong CG cut <%s> couldn't be scaled to integral coefficients: act=%f, rhs=%f, norm=%f, eff=%f\n",
cutname, cutact, cutrhs, cutnorm, SCIPgetCutEfficacy(scip, NULL, cut));
}
/* release the row */
SCIP_CALL( SCIPreleaseRow(scip, &cut) );
}
/* free temporary memory */
SCIPfreeBufferArray(scip, &cutvals);
SCIPfreeBufferArray(scip, &cutvars);
}
}
}
/* free temporary memory */
SCIPfreeBufferArrayNull(scip, &varsolvals);
SCIPfreeBufferArray(scip, &inds);
SCIPfreeBufferArray(scip, &binvrow);
SCIPfreeBufferArray(scip, &basisind);
SCIPfreeBufferArray(scip, &cutcoefs);
SCIPdebugMessage("end searching strong CG cuts: found %d cuts\n", ncuts);
sepadata->lastncutsfound = SCIPgetNCutsFound(scip);
return SCIP_OKAY;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecRootsoldiving) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_VAR** vars;
SCIP_Real* rootsol;
SCIP_Real* objchgvals;
int* softroundings;
int* intvalrounds;
int nvars;
int nbinvars;
int nintvars;
int nlpcands;
SCIP_LPSOLSTAT lpsolstat;
SCIP_Real absstartobjval;
SCIP_Real objstep;
SCIP_Real alpha;
SCIP_Real oldobj;
SCIP_Real newobj;
SCIP_Bool lperror;
SCIP_Bool lpsolchanged;
SCIP_Longint nsolsfound;
SCIP_Longint ncalls;
SCIP_Longint nlpiterations;
SCIP_Longint maxnlpiterations;
int depth;
int maxdepth;
int maxdivedepth;
int divedepth;
int startnlpcands;
int ncycles;
int i;
assert(heur != NULL);
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
assert(scip != NULL);
assert(result != NULL);
assert(SCIPhasCurrentNodeLP(scip));
*result = SCIP_DELAYED;
/* only call heuristic, if an optimal LP solution is at hand */
if( SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
return SCIP_OKAY;
/* only call heuristic, if the LP solution is basic (which allows fast resolve in diving) */
if( !SCIPisLPSolBasic(scip) )
return SCIP_OKAY;
/* don't dive two times at the same node */
if( SCIPgetLastDivenode(scip) == SCIPgetNNodes(scip) && SCIPgetDepth(scip) > 0 )
return SCIP_OKAY;
*result = SCIP_DIDNOTRUN;
/* get heuristic's data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* only apply heuristic, if only a few solutions have been found */
if( heurdata->maxsols >= 0 && SCIPgetNSolsFound(scip) >= heurdata->maxsols )
return SCIP_OKAY;
/* only try to dive, if we are in the correct part of the tree, given by minreldepth and maxreldepth */
depth = SCIPgetDepth(scip);
maxdepth = SCIPgetMaxDepth(scip);
maxdepth = MAX(maxdepth, 30);
if( depth < heurdata->minreldepth*maxdepth || depth > heurdata->maxreldepth*maxdepth )
return SCIP_OKAY;
/* calculate the maximal number of LP iterations until heuristic is aborted */
nlpiterations = SCIPgetNNodeLPIterations(scip);
ncalls = SCIPheurGetNCalls(heur);
nsolsfound = 10*SCIPheurGetNBestSolsFound(heur) + heurdata->nsuccess;
maxnlpiterations = (SCIP_Longint)((1.0 + 10.0*(nsolsfound+1.0)/(ncalls+1.0)) * heurdata->maxlpiterquot * nlpiterations);
maxnlpiterations += heurdata->maxlpiterofs;
/* don't try to dive, if we took too many LP iterations during diving */
if( heurdata->nlpiterations >= maxnlpiterations )
return SCIP_OKAY;
/* allow at least a certain number of LP iterations in this dive */
maxnlpiterations = MAX(maxnlpiterations, heurdata->nlpiterations + MINLPITER);
/* get number of fractional variables, that should be integral */
nlpcands = SCIPgetNLPBranchCands(scip);
/* don't try to dive, if there are no fractional variables */
if( nlpcands == 0 )
return SCIP_OKAY;
/* calculate the maximal diving depth */
nvars = SCIPgetNBinVars(scip) + SCIPgetNIntVars(scip);
if( SCIPgetNSolsFound(scip) == 0 )
maxdivedepth = (int)(heurdata->depthfacnosol * nvars);
else
maxdivedepth = (int)(heurdata->depthfac * nvars);
maxdivedepth = MAX(maxdivedepth, 10);
*result = SCIP_DIDNOTFIND;
/* get all variables of LP */
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, &nbinvars, &nintvars, NULL, NULL) );
/* get root solution value of all binary and integer variables */
SCIP_CALL( SCIPallocBufferArray(scip, &rootsol, nbinvars + nintvars) );
for( i = 0; i < nbinvars + nintvars; i++ )
rootsol[i] = SCIPvarGetRootSol(vars[i]);
/* get current LP objective value, and calculate length of a single step in an objective coefficient */
absstartobjval = SCIPgetLPObjval(scip);
absstartobjval = ABS(absstartobjval);
absstartobjval = MAX(absstartobjval, 1.0);
objstep = absstartobjval / 10.0;
/* initialize array storing the preferred soft rounding directions and counting the integral value rounds */
SCIP_CALL( SCIPallocBufferArray(scip, &softroundings, nbinvars + nintvars) );
BMSclearMemoryArray(softroundings, nbinvars + nintvars);
SCIP_CALL( SCIPallocBufferArray(scip, &intvalrounds, nbinvars + nintvars) );
BMSclearMemoryArray(intvalrounds, nbinvars + nintvars);
/* allocate temporary memory for buffering objective changes */
SCIP_CALL( SCIPallocBufferArray(scip, &objchgvals, nbinvars + nintvars) );
/* start diving */
SCIP_CALL( SCIPstartDive(scip) );
SCIPdebugMessage("(node %"SCIP_LONGINT_FORMAT") executing rootsoldiving heuristic: depth=%d, %d fractionals, dualbound=%g, maxnlpiterations=%"SCIP_LONGINT_FORMAT", maxdivedepth=%d, LPobj=%g, objstep=%g\n",
SCIPgetNNodes(scip), SCIPgetDepth(scip), nlpcands, SCIPgetDualbound(scip), maxnlpiterations, maxdivedepth,
SCIPgetLPObjval(scip), objstep);
lperror = FALSE;
divedepth = 0;
lpsolstat = SCIP_LPSOLSTAT_OPTIMAL;
alpha = heurdata->alpha;
ncycles = 0;
lpsolchanged = TRUE;
startnlpcands = nlpcands;
while( !lperror && lpsolstat == SCIP_LPSOLSTAT_OPTIMAL && nlpcands > 0 && ncycles < 10
&& (divedepth < 10
|| nlpcands <= startnlpcands - divedepth/2
|| (divedepth < maxdivedepth && heurdata->nlpiterations < maxnlpiterations))
&& !SCIPisStopped(scip) )
{
SCIP_Bool success;
int hardroundingidx;
int hardroundingdir;
SCIP_Real hardroundingoldbd;
SCIP_Real hardroundingnewbd;
SCIP_Bool boundschanged;
SCIP_RETCODE retcode;
/* create solution from diving LP and try to round it */
SCIP_CALL( SCIPlinkLPSol(scip, heurdata->sol) );
SCIP_CALL( SCIProundSol(scip, heurdata->sol, &success) );
if( success )
{
SCIPdebugMessage("rootsoldiving found roundable primal solution: obj=%g\n", SCIPgetSolOrigObj(scip, heurdata->sol));
/* try to add solution to SCIP */
SCIP_CALL( SCIPtrySol(scip, heurdata->sol, FALSE, FALSE, FALSE, FALSE, &success) );
/* check, if solution was feasible and good enough */
if( success )
{
SCIPdebugMessage(" -> solution was feasible and good enough\n");
*result = SCIP_FOUNDSOL;
}
}
divedepth++;
hardroundingidx = -1;
hardroundingdir = 0;
hardroundingoldbd = 0.0;
hardroundingnewbd = 0.0;
boundschanged = FALSE;
SCIPdebugMessage("dive %d/%d, LP iter %"SCIP_LONGINT_FORMAT"/%"SCIP_LONGINT_FORMAT":\n", divedepth, maxdivedepth, heurdata->nlpiterations, maxnlpiterations);
/* round solution x* from diving LP:
* - x~_j = down(x*_j) if x*_j is integer or binary variable and x*_j <= root solution_j
* - x~_j = up(x*_j) if x*_j is integer or binary variable and x*_j > root solution_j
* - x~_j = x*_j if x*_j is continuous variable
* change objective function in diving LP:
* - if x*_j is integral, or j is a continuous variable, set obj'_j = alpha * obj_j
* - otherwise, set obj'_j = alpha * obj_j + sign(x*_j - x~_j)
*/
for( i = 0; i < nbinvars + nintvars; i++ )
{
SCIP_VAR* var;
SCIP_Real solval;
var = vars[i];
oldobj = SCIPgetVarObjDive(scip, var);
newobj = oldobj;
solval = SCIPvarGetLPSol(var);
if( SCIPisFeasIntegral(scip, solval) )
{
/* if the variable became integral after a soft rounding, count the rounds; after a while, fix it to its
* current integral value;
* otherwise, fade out the objective value
*/
if( softroundings[i] != 0 && lpsolchanged )
{
intvalrounds[i]++;
if( intvalrounds[i] == 5 && SCIPgetVarLbDive(scip, var) < SCIPgetVarUbDive(scip, var) - 0.5 )
{
/* use exact integral value, if the variable is only integral within numerical tolerances */
solval = SCIPfloor(scip, solval+0.5);
SCIPdebugMessage(" -> fixing <%s> = %g\n", SCIPvarGetName(var), solval);
SCIP_CALL( SCIPchgVarLbDive(scip, var, solval) );
SCIP_CALL( SCIPchgVarUbDive(scip, var, solval) );
boundschanged = TRUE;
}
}
else
newobj = alpha * oldobj;
}
else if( solval <= rootsol[i] )
{
/* if the variable was soft rounded most of the time downwards, round it downwards by changing the bounds;
* otherwise, apply soft rounding by changing the objective value
*/
softroundings[i]--;
if( softroundings[i] <= -10 && hardroundingidx == -1 )
{
SCIPdebugMessage(" -> hard rounding <%s>[%g] <= %g\n",
SCIPvarGetName(var), solval, SCIPfeasFloor(scip, solval));
hardroundingidx = i;
hardroundingdir = -1;
hardroundingoldbd = SCIPgetVarUbDive(scip, var);
hardroundingnewbd = SCIPfeasFloor(scip, solval);
SCIP_CALL( SCIPchgVarUbDive(scip, var, hardroundingnewbd) );
boundschanged = TRUE;
}
else
newobj = alpha * oldobj + objstep;
}
else
{
/* if the variable was soft rounded most of the time upwards, round it upwards by changing the bounds;
* otherwise, apply soft rounding by changing the objective value
*/
softroundings[i]++;
if( softroundings[i] >= +10 && hardroundingidx == -1 )
{
SCIPdebugMessage(" -> hard rounding <%s>[%g] >= %g\n",
SCIPvarGetName(var), solval, SCIPfeasCeil(scip, solval));
hardroundingidx = i;
hardroundingdir = +1;
hardroundingoldbd = SCIPgetVarLbDive(scip, var);
hardroundingnewbd = SCIPfeasCeil(scip, solval);
SCIP_CALL( SCIPchgVarLbDive(scip, var, hardroundingnewbd) );
boundschanged = TRUE;
}
else
newobj = alpha * oldobj - objstep;
}
/* remember the objective change */
objchgvals[i] = newobj;
}
/* apply objective changes if there was no bound change */
if( !boundschanged )
{
/* apply cached changes on integer variables */
for( i = 0; i < nbinvars + nintvars; ++i )
{
SCIP_VAR* var;
var = vars[i];
SCIPdebugMessage(" -> i=%d var <%s>, solval=%g, rootsol=%g, oldobj=%g, newobj=%g\n",
i, SCIPvarGetName(var), SCIPvarGetLPSol(var), rootsol[i], SCIPgetVarObjDive(scip, var), objchgvals[i]);
SCIP_CALL( SCIPchgVarObjDive(scip, var, objchgvals[i]) );
}
/* fade out the objective values of the continuous variables */
for( i = nbinvars + nintvars; i < nvars; i++ )
{
SCIP_VAR* var;
var = vars[i];
oldobj = SCIPgetVarObjDive(scip, var);
newobj = alpha * oldobj;
SCIPdebugMessage(" -> i=%d var <%s>, solval=%g, oldobj=%g, newobj=%g\n",
i, SCIPvarGetName(var), SCIPvarGetLPSol(var), oldobj, newobj);
SCIP_CALL( SCIPchgVarObjDive(scip, var, newobj) );
}
}
SOLVEAGAIN:
/* resolve the diving LP */
nlpiterations = SCIPgetNLPIterations(scip);
retcode = SCIPsolveDiveLP(scip, MAX((int)(maxnlpiterations - heurdata->nlpiterations), MINLPITER), &lperror);
lpsolstat = SCIPgetLPSolstat(scip);
/* Errors in the LP solver should not kill the overall solving process, if the LP is just needed for a heuristic.
* Hence in optimized mode, the return code is caught and a warning is printed, only in debug mode, SCIP will stop.
*/
if( retcode != SCIP_OKAY )
{
#ifndef NDEBUG
if( lpsolstat != SCIP_LPSOLSTAT_UNBOUNDEDRAY )
{
SCIP_CALL( retcode );
}
#endif
SCIPwarningMessage(scip, "Error while solving LP in Rootsoldiving heuristic; LP solve terminated with code <%d>\n", retcode);
SCIPwarningMessage(scip, "This does not affect the remaining solution procedure --> continue\n");
}
if( lperror )
break;
/* update iteration count */
heurdata->nlpiterations += SCIPgetNLPIterations(scip) - nlpiterations;
/* if no LP iterations were performed, we stayed at the same solution -> count this cycling */
lpsolchanged = (SCIPgetNLPIterations(scip) != nlpiterations);
if( lpsolchanged )
ncycles = 0;
else if( !boundschanged ) /* do not count if integral variables have been fixed */
ncycles++;
/* get LP solution status and number of fractional variables, that should be integral */
if( lpsolstat == SCIP_LPSOLSTAT_INFEASIBLE && hardroundingidx != -1 )
{
SCIP_VAR* var;
var = vars[hardroundingidx];
/* round the hard rounded variable to the opposite direction and resolve the LP */
if( hardroundingdir == -1 )
{
SCIPdebugMessage(" -> opposite hard rounding <%s> >= %g\n", SCIPvarGetName(var), hardroundingnewbd + 1.0);
SCIP_CALL( SCIPchgVarUbDive(scip, var, hardroundingoldbd) );
SCIP_CALL( SCIPchgVarLbDive(scip, var, hardroundingnewbd + 1.0) );
}
else
{
SCIPdebugMessage(" -> opposite hard rounding <%s> <= %g\n", SCIPvarGetName(var), hardroundingnewbd - 1.0);
SCIP_CALL( SCIPchgVarLbDive(scip, var, hardroundingoldbd) );
SCIP_CALL( SCIPchgVarUbDive(scip, var, hardroundingnewbd - 1.0) );
}
hardroundingidx = -1;
goto SOLVEAGAIN;
}
if( lpsolstat == SCIP_LPSOLSTAT_OPTIMAL )
nlpcands = SCIPgetNLPBranchCands(scip);
SCIPdebugMessage(" -> lpsolstat=%d, nfrac=%d\n", lpsolstat, nlpcands);
}
SCIPdebugMessage("---> diving finished: lpsolstat = %d, depth %d/%d, LP iter %"SCIP_LONGINT_FORMAT"/%"SCIP_LONGINT_FORMAT"\n",
lpsolstat, divedepth, maxdivedepth, heurdata->nlpiterations, maxnlpiterations);
/* check if a solution has been found */
if( nlpcands == 0 && !lperror && lpsolstat == SCIP_LPSOLSTAT_OPTIMAL )
{
SCIP_Bool success;
/* create solution from diving LP */
SCIP_CALL( SCIPlinkLPSol(scip, heurdata->sol) );
SCIPdebugMessage("rootsoldiving found primal solution: obj=%g\n", SCIPgetSolOrigObj(scip, heurdata->sol));
/* try to add solution to SCIP */
SCIP_CALL( SCIPtrySol(scip, heurdata->sol, FALSE, FALSE, FALSE, FALSE, &success) );
/* check, if solution was feasible and good enough */
if( success )
{
SCIPdebugMessage(" -> solution was feasible and good enough\n");
*result = SCIP_FOUNDSOL;
}
}
/* end diving */
SCIP_CALL( SCIPendDive(scip) );
if( *result == SCIP_FOUNDSOL )
heurdata->nsuccess++;
/* free temporary memory */
SCIPfreeBufferArray(scip, &objchgvals);
SCIPfreeBufferArray(scip, &intvalrounds);
SCIPfreeBufferArray(scip, &softroundings);
SCIPfreeBufferArray(scip, &rootsol);
SCIPdebugMessage("rootsoldiving heuristic finished\n");
return SCIP_OKAY;
}
