/** adds cut to separation storage and captures it;
* if the cut should be forced to enter the LP, an infinite score has to be used
*/
SCIP_RETCODE SCIPsepastoreAddCut(
SCIP_SEPASTORE* sepastore, /**< separation storage */
BMS_BLKMEM* blkmem, /**< block memory */
SCIP_SET* set, /**< global SCIP settings */
SCIP_STAT* stat, /**< problem statistics data */
SCIP_EVENTQUEUE* eventqueue, /**< event queue */
SCIP_EVENTFILTER* eventfilter, /**< event filter for global events */
SCIP_LP* lp, /**< LP data */
SCIP_SOL* sol, /**< primal solution that was separated, or NULL for LP solution */
SCIP_ROW* cut, /**< separated cut */
SCIP_Bool forcecut, /**< should the cut be forced to enter the LP? */
SCIP_Bool root /**< are we at the root node? */
)
{
assert(sepastore != NULL);
assert(cut != NULL);
assert(!SCIProwIsInLP(cut));
assert(!SCIPsetIsInfinity(set, -SCIProwGetLhs(cut)) || !SCIPsetIsInfinity(set, SCIProwGetRhs(cut)));
/* debug: check cut for feasibility */
SCIP_CALL( SCIPdebugCheckRow(set, cut) ); /*lint !e506 !e774*/
/* update statistics of total number of found cuts */
if( !sepastore->initiallp )
{
sepastore->ncutsfound++;
sepastore->ncutsfoundround++;
}
/* add LP row cut to separation storage */
SCIP_CALL( sepastoreAddCut(sepastore, blkmem, set, stat, eventqueue, eventfilter, lp, sol, cut, forcecut, root) );
return SCIP_OKAY;
}
/** applies the given cut to the LP and updates the orthogonalities and scores of remaining cuts */
static
SCIP_RETCODE sepastoreApplyCut(
SCIP_SEPASTORE* sepastore, /**< separation storage */
BMS_BLKMEM* blkmem, /**< block memory */
SCIP_SET* set, /**< global SCIP settings */
SCIP_EVENTQUEUE* eventqueue, /**< event queue */
SCIP_EVENTFILTER* eventfilter, /**< global event filter */
SCIP_LP* lp, /**< LP data */
SCIP_ROW* cut, /**< cut to apply to the LP */
SCIP_Real mincutorthogonality,/**< minimal orthogonality of cuts to apply to LP */
int depth, /**< depth of current node */
int* ncutsapplied /**< pointer to count the number of applied cuts */
)
{
assert(sepastore != NULL);
assert(ncutsapplied != NULL);
/* a row could have been added twice to the separation store; add it only once! */
if( !SCIProwIsInLP(cut) )
{
/* add cut to the LP and capture it */
SCIP_CALL( SCIPlpAddRow(lp, blkmem, set, eventqueue, eventfilter, cut, depth) );
if( !sepastore->initiallp )
sepastore->ncutsapplied++;
/* update the orthogonalities */
SCIP_CALL( sepastoreUpdateOrthogonalities(sepastore, blkmem, set, eventqueue, eventfilter, lp, cut, mincutorthogonality) );
(*ncutsapplied)++;
}
return SCIP_OKAY;
}
/** searches and adds integral objective cuts that separate the given primal solution */
static
SCIP_RETCODE separateCuts(
SCIP* scip, /**< SCIP data structure */
SCIP_SEPA* sepa, /**< the intobj separator */
SCIP_SOL* sol, /**< the solution that should be separated, or NULL for LP solution */
SCIP_RESULT* result /**< pointer to store the result */
)
{
SCIP_SEPADATA* sepadata;
SCIP_Real objval;
SCIP_Real intbound;
SCIP_Bool infeasible;
SCIP_Bool tightened;
assert(result != NULL);
assert(*result == SCIP_DIDNOTRUN);
/* if the objective value may be fractional, we cannot do anything */
if( !SCIPisObjIntegral(scip) )
return SCIP_OKAY;
*result = SCIP_DIDNOTFIND;
/* if the current objective value is integral, there is no integral objective value cut */
if( sol == NULL )
objval = SCIPretransformObj(scip, SCIPgetLPObjval(scip));
else
objval = SCIPgetSolOrigObj(scip, sol);
if( SCIPisFeasIntegral(scip, objval) )
return SCIP_OKAY;
sepadata = SCIPsepaGetData(sepa);
assert(sepadata != NULL);
/* the objective value is fractional: create the objective value inequality, if not yet existing */
SCIP_CALL( createObjRow(scip, sepa, sepadata) );
/* adjust the bounds of the objective value variable */
if( SCIPgetObjsense(scip) == SCIP_OBJSENSE_MINIMIZE )
{
intbound = SCIPceil(scip, objval) - sepadata->setoff;
SCIP_CALL( SCIPtightenVarLb(scip, sepadata->objvar, intbound, FALSE, &infeasible, &tightened) );
SCIPdebugMessage("new objective variable lower bound: <%s>[%g,%g]\n",
SCIPvarGetName(sepadata->objvar), SCIPvarGetLbLocal(sepadata->objvar), SCIPvarGetUbLocal(sepadata->objvar));
}
else
{
intbound = SCIPfloor(scip, objval) - sepadata->setoff;
SCIP_CALL( SCIPtightenVarUb(scip, sepadata->objvar, intbound, FALSE, &infeasible, &tightened) );
SCIPdebugMessage("new objective variable upper bound: <%s>[%g,%g]\n",
SCIPvarGetName(sepadata->objvar), SCIPvarGetLbLocal(sepadata->objvar), SCIPvarGetUbLocal(sepadata->objvar));
}
/* add the objective value inequality as a cut to the LP */
if( infeasible )
*result = SCIP_CUTOFF;
else
{
if( !SCIProwIsInLP(sepadata->objrow) )
{
SCIP_CALL( SCIPaddCut(scip, sol, sepadata->objrow, FALSE, &infeasible) );
}
if ( infeasible )
*result = SCIP_CUTOFF;
else if ( tightened )
*result = SCIP_REDUCEDDOM;
else
*result = SCIP_SEPARATED;
}
return SCIP_OKAY;
}
/** adds cut stored as LP row to separation storage and captures it;
* if the cut should be forced to be used, an infinite score has to be used
*/
static
SCIP_RETCODE sepastoreAddCut(
SCIP_SEPASTORE* sepastore, /**< separation storage */
BMS_BLKMEM* blkmem, /**< block memory */
SCIP_SET* set, /**< global SCIP settings */
SCIP_STAT* stat, /**< problem statistics data */
SCIP_EVENTQUEUE* eventqueue, /**< event queue */
SCIP_EVENTFILTER* eventfilter, /**< event filter for global events */
SCIP_LP* lp, /**< LP data */
SCIP_SOL* sol, /**< primal solution that was separated, or NULL for LP solution */
SCIP_ROW* cut, /**< separated cut */
SCIP_Bool forcecut, /**< should the cut be forced to enter the LP? */
SCIP_Bool root /**< are we at the root node? */
)
{
SCIP_Real cutefficacy;
SCIP_Real cutobjparallelism;
SCIP_Real cutscore;
int pos;
assert(sepastore != NULL);
assert(sepastore->nforcedcuts <= sepastore->ncuts);
assert(set != NULL);
assert(cut != NULL);
assert(sol != NULL || !SCIProwIsInLP(cut));
assert(!SCIPsetIsInfinity(set, -SCIProwGetLhs(cut)) || !SCIPsetIsInfinity(set, SCIProwGetRhs(cut)));
assert(eventqueue != NULL);
assert(eventfilter != NULL);
/* in the root node, every local cut is a global cut, and global cuts are nicer in many ways...*/
if( root && SCIProwIsLocal(cut) )
{
SCIPdebugMessage("change local flag of cut <%s> to FALSE due to addition in root node\n", SCIProwGetName(cut));
SCIP_CALL( SCIProwChgLocal(cut, FALSE) );
assert(!SCIProwIsLocal(cut));
}
/* check cut for redundancy
* in each separation round, make sure that at least one (even redundant) cut enters the LP to avoid cycling
*/
if( !forcecut && sepastore->ncuts > 0 && sepastoreIsCutRedundant(sepastore, set, stat, cut) )
return SCIP_OKAY;
/* if only one cut is currently present in the cut store, it could be redundant; in this case, it can now be removed
* again, because now a non redundant cut enters the store
*/
if( sepastore->ncuts == 1 && sepastoreIsCutRedundant(sepastore, set, stat, sepastore->cuts[0]) )
{
/* check, if the row deletions from separation storage events are tracked
* if so, issue ROWDELETEDSEPA event
*/
if( eventfilter->len > 0 && (eventfilter->eventmask & SCIP_EVENTTYPE_ROWDELETEDSEPA) != 0 )
{
SCIP_EVENT* event;
SCIP_CALL( SCIPeventCreateRowDeletedSepa(&event, blkmem, sepastore->cuts[0]) );
SCIP_CALL( SCIPeventqueueAdd(eventqueue, blkmem, set, NULL, NULL, NULL, eventfilter, &event) );
}
SCIP_CALL( SCIProwRelease(&sepastore->cuts[0], blkmem, set, lp) );
sepastore->ncuts = 0;
sepastore->nforcedcuts = 0;
}
/* a cut is forced to enter the LP if
* - we construct the initial LP, or
* - it has infinite score factor, or
* - it is a bound change
* if it is a non-forced cut and no cuts should be added, abort
*/
forcecut = forcecut || sepastore->initiallp || sepastore->forcecuts
|| (!SCIProwIsModifiable(cut) && SCIProwGetNNonz(cut) == 1);
if( !forcecut && SCIPsetGetSepaMaxcuts(set, root) == 0 )
return SCIP_OKAY;
/* get enough memory to store the cut */
SCIP_CALL( sepastoreEnsureCutsMem(sepastore, set, sepastore->ncuts+1) );
assert(sepastore->ncuts < sepastore->cutssize);
if( forcecut )
{
cutefficacy = SCIPsetInfinity(set);
cutscore = SCIPsetInfinity(set);
cutobjparallelism = 1.0;
}
else
{
/* initialize values to invalid (will be initialized during cut filtering) */
cutefficacy = SCIP_INVALID;
cutscore = SCIP_INVALID;
/* initialize parallelism to objective (constant throughout filtering) */
if( set->sepa_objparalfac > 0.0 )
cutobjparallelism = SCIProwGetObjParallelism(cut, set, lp);
else
cutobjparallelism = 0.0; /* no need to calculate it */
}
SCIPdebugMessage("adding cut <%s> to separation storage of size %d (forcecut=%u, len=%d)\n",
SCIProwGetName(cut), sepastore->ncuts, forcecut, SCIProwGetNNonz(cut));
/*SCIPdebug(SCIProwPrint(cut, NULL));*/
/* capture the cut */
SCIProwCapture(cut);
/* add cut to arrays */
if( forcecut )
{
/* make room at the beginning of the array for forced cut */
pos = sepastore->nforcedcuts;
sepastore->cuts[sepastore->ncuts] = sepastore->cuts[pos];
sepastore->efficacies[sepastore->ncuts] = sepastore->efficacies[pos];
sepastore->objparallelisms[sepastore->ncuts] = sepastore->objparallelisms[pos];
sepastore->orthogonalities[sepastore->ncuts] = sepastore->orthogonalities[pos];
sepastore->scores[sepastore->ncuts] = sepastore->scores[pos];
sepastore->nforcedcuts++;
}
else
pos = sepastore->ncuts;
sepastore->cuts[pos] = cut;
sepastore->efficacies[pos] = cutefficacy;
sepastore->objparallelisms[pos] = cutobjparallelism;
sepastore->orthogonalities[pos] = 1.0;
sepastore->scores[pos] = cutscore;
sepastore->ncuts++;
/* check, if the row addition to separation storage events are tracked
* if so, issue ROWADDEDSEPA event
*/
if( eventfilter->len > 0 && (eventfilter->eventmask & SCIP_EVENTTYPE_ROWADDEDSEPA) != 0 )
{
SCIP_EVENT* event;
SCIP_CALL( SCIPeventCreateRowAddedSepa(&event, blkmem, cut) );
SCIP_CALL( SCIPeventqueueAdd(eventqueue, blkmem, set, NULL, NULL, NULL, eventfilter, &event) );
}
return SCIP_OKAY;
}
/** compute value by which the solution of variable @p var can be shifted */
static
SCIP_Real calcShiftVal(
SCIP* scip, /**< SCIP data structure */
SCIP_VAR* var, /**< variable that should be shifted */
SCIP_Real solval, /**< current solution value */
SCIP_Real* activities /**< LP row activities */
)
{
SCIP_Real lb;
SCIP_Real ub;
SCIP_Real obj;
SCIP_Real shiftval;
SCIP_COL* col;
SCIP_ROW** colrows;
SCIP_Real* colvals;
SCIP_Bool shiftdown;
int ncolrows;
int i;
/* get variable's solution value, global bounds and objective coefficient */
lb = SCIPvarGetLbGlobal(var);
ub = SCIPvarGetUbGlobal(var);
obj = SCIPvarGetObj(var);
shiftval = 0.0;
shiftdown = TRUE;
/* determine shifting direction and maximal possible shifting w.r.t. corresponding bound */
if( obj > 0.0 && SCIPisFeasGE(scip, solval - 1.0, lb) )
shiftval = SCIPfeasFloor(scip, solval - lb);
else if( obj < 0.0 && SCIPisFeasLE(scip, solval + 1.0, ub) )
{
shiftval = SCIPfeasFloor(scip, ub - solval);
shiftdown = FALSE;
}
else
return 0.0;
SCIPdebugMessage("Try to shift %s variable <%s> with\n", shiftdown ? "down" : "up", SCIPvarGetName(var) );
SCIPdebugMessage(" lb:<%g> <= val:<%g> <= ub:<%g> and obj:<%g> by at most: <%g>\n", lb, solval, ub, obj, shiftval);
/* get data of LP column */
col = SCIPvarGetCol(var);
colrows = SCIPcolGetRows(col);
colvals = SCIPcolGetVals(col);
ncolrows = SCIPcolGetNLPNonz(col);
assert(ncolrows == 0 || (colrows != NULL && colvals != NULL));
/* find minimal shift value, st. all rows stay valid */
for( i = 0; i < ncolrows && shiftval > 0.0; ++i )
{
SCIP_ROW* row;
int rowpos;
row = colrows[i];
rowpos = SCIProwGetLPPos(row);
assert(-1 <= rowpos && rowpos < SCIPgetNLPRows(scip) );
/* only global rows need to be valid */
if( rowpos >= 0 && !SCIProwIsLocal(row) )
{
SCIP_Real shiftvalrow;
assert(SCIProwIsInLP(row));
if( shiftdown == (colvals[i] > 0) )
shiftvalrow = SCIPfeasFloor(scip, (activities[rowpos] - SCIProwGetLhs(row)) / ABS(colvals[i]));
else
shiftvalrow = SCIPfeasFloor(scip, (SCIProwGetRhs(row) - activities[rowpos]) / ABS(colvals[i]));
#ifdef SCIP_DEBUG
if( shiftvalrow < shiftval )
{
SCIPdebugMessage(" -> The shift value had to be reduced to <%g>, because of row <%s>.\n",
shiftvalrow, SCIProwGetName(row));
SCIPdebugMessage(" lhs:<%g> <= act:<%g> <= rhs:<%g>, colval:<%g>\n",
SCIProwGetLhs(row), activities[rowpos], SCIProwGetRhs(row), colvals[i]);
}
#endif
shiftval = MIN(shiftval, shiftvalrow);
/* shiftvalrow might be negative, if we detected infeasibility -> make sure that shiftval is >= 0 */
shiftval = MAX(shiftval, 0.0);
}
}
if( shiftdown )
shiftval *= -1.0;
/* we must not shift variables to infinity */
if( SCIPisInfinity(scip, solval + shiftval) )
shiftval = 0.0;
return shiftval;
}
/** LP solution separation method for disjunctive cuts */
static
SCIP_DECL_SEPAEXECLP(sepaExeclpDisjunctive)
{
SCIP_SEPADATA* sepadata;
SCIP_CONSHDLR* conshdlr;
SCIP_DIGRAPH* conflictgraph;
SCIP_ROW** rows;
SCIP_COL** cols;
SCIP_Real* cutcoefs = NULL;
SCIP_Real* simplexcoefs1 = NULL;
SCIP_Real* simplexcoefs2 = NULL;
SCIP_Real* coef = NULL;
SCIP_Real* binvrow = NULL;
SCIP_Real* rowsmaxval = NULL;
SCIP_Real* violationarray = NULL;
int* fixings1 = NULL;
int* fixings2 = NULL;
int* basisind = NULL;
int* basisrow = NULL;
int* varrank = NULL;
int* edgearray = NULL;
int nedges;
int ndisjcuts;
int nrelevantedges;
int nsos1vars;
int nconss;
int maxcuts;
int ncalls;
int depth;
int ncols;
int nrows;
int ind;
int j;
int i;
assert( sepa != NULL );
assert( strcmp(SCIPsepaGetName(sepa), SEPA_NAME) == 0 );
assert( scip != NULL );
assert( result != NULL );
*result = SCIP_DIDNOTRUN;
/* only generate disjunctive cuts if we are not close to terminating */
if ( SCIPisStopped(scip) )
return SCIP_OKAY;
/* only generate disjunctive cuts if an optimal LP solution is at hand */
if ( SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
return SCIP_OKAY;
/* only generate disjunctive cuts if the LP solution is basic */
if ( ! SCIPisLPSolBasic(scip) )
return SCIP_OKAY;
/* get LP data */
SCIP_CALL( SCIPgetLPColsData(scip, &cols, &ncols) );
SCIP_CALL( SCIPgetLPRowsData(scip, &rows, &nrows) );
/* return if LP has no columns or no rows */
if ( ncols == 0 || nrows == 0 )
return SCIP_OKAY;
assert( cols != NULL );
assert( rows != NULL );
/* get sepa data */
sepadata = SCIPsepaGetData(sepa);
assert( sepadata != NULL );
/* get constraint handler */
conshdlr = sepadata->conshdlr;
if ( conshdlr == NULL )
return SCIP_OKAY;
/* get number of constraints */
nconss = SCIPconshdlrGetNConss(conshdlr);
if ( nconss == 0 )
return SCIP_OKAY;
/* check for maxdepth < depth, maxinvcutsroot = 0 and maxinvcuts = 0 */
depth = SCIPgetDepth(scip);
if ( ( sepadata->maxdepth >= 0 && sepadata->maxdepth < depth )
|| ( depth == 0 && sepadata->maxinvcutsroot == 0 )
|| ( depth > 0 && sepadata->maxinvcuts == 0 ) )
return SCIP_OKAY;
/* only call the cut separator a given number of times at each node */
ncalls = SCIPsepaGetNCallsAtNode(sepa);
if ( (depth == 0 && sepadata->maxroundsroot >= 0 && ncalls >= sepadata->maxroundsroot)
|| (depth > 0 && sepadata->maxrounds >= 0 && ncalls >= sepadata->maxrounds) )
return SCIP_OKAY;
/* get conflict graph and number of conflict graph edges (note that the digraph arcs were added in both directions) */
conflictgraph = SCIPgetConflictgraphSOS1(conshdlr);
nedges = (int)SCIPceil(scip, (SCIP_Real)SCIPdigraphGetNArcs(conflictgraph)/2);
/* if too many conflict graph edges, the separator can be slow: delay it until no other cuts have been found */
if ( sepadata->maxconfsdelay >= 0 && nedges >= sepadata->maxconfsdelay )
{
int ncutsfound;
ncutsfound = SCIPgetNCutsFound(scip);
if ( ncutsfound > sepadata->lastncutsfound || ! SCIPsepaWasLPDelayed(sepa) )
{
sepadata->lastncutsfound = ncutsfound;
*result = SCIP_DELAYED;
return SCIP_OKAY;
}
}
/* check basis status */
for (j = 0; j < ncols; ++j)
{
if ( SCIPcolGetBasisStatus(cols[j]) == SCIP_BASESTAT_ZERO )
return SCIP_OKAY;
}
/* get number of SOS1 variables */
nsos1vars = SCIPgetNSOS1Vars(conshdlr);
/* allocate buffer arrays */
SCIP_CALL( SCIPallocBufferArray(scip, &edgearray, nedges) );
SCIP_CALL( SCIPallocBufferArray(scip, &fixings1, nedges) );
SCIP_CALL( SCIPallocBufferArray(scip, &fixings2, nedges) );
SCIP_CALL( SCIPallocBufferArray(scip, &violationarray, nedges) );
/* get all violated conflicts {i, j} in the conflict graph and sort them based on the degree of a violation value */
nrelevantedges = 0;
for (j = 0; j < nsos1vars; ++j)
{
SCIP_VAR* var;
var = SCIPnodeGetVarSOS1(conflictgraph, j);
if ( SCIPvarIsActive(var) && ! SCIPisFeasZero(scip, SCIPcolGetPrimsol(SCIPvarGetCol(var))) && SCIPcolGetBasisStatus(SCIPvarGetCol(var)) == SCIP_BASESTAT_BASIC )
{
int* succ;
int nsucc;
/* get successors and number of successors */
nsucc = SCIPdigraphGetNSuccessors(conflictgraph, j);
succ = SCIPdigraphGetSuccessors(conflictgraph, j);
for (i = 0; i < nsucc; ++i)
{
SCIP_VAR* varsucc;
int succind;
succind = succ[i];
varsucc = SCIPnodeGetVarSOS1(conflictgraph, succind);
if ( SCIPvarIsActive(varsucc) && succind < j && ! SCIPisFeasZero(scip, SCIPgetSolVal(scip, NULL, varsucc) ) &&
SCIPcolGetBasisStatus(SCIPvarGetCol(varsucc)) == SCIP_BASESTAT_BASIC )
{
fixings1[nrelevantedges] = j;
fixings2[nrelevantedges] = succind;
edgearray[nrelevantedges] = nrelevantedges;
violationarray[nrelevantedges++] = SCIPgetSolVal(scip, NULL, var) * SCIPgetSolVal(scip, NULL, varsucc);
}
}
}
}
/* sort violation score values */
if ( nrelevantedges > 0)
SCIPsortDownRealInt(violationarray, edgearray, nrelevantedges);
else
{
SCIPfreeBufferArrayNull(scip, &violationarray);
SCIPfreeBufferArrayNull(scip, &fixings2);
SCIPfreeBufferArrayNull(scip, &fixings1);
SCIPfreeBufferArrayNull(scip, &edgearray);
return SCIP_OKAY;
}
SCIPfreeBufferArrayNull(scip, &violationarray);
/* compute maximal number of cuts */
if ( SCIPgetDepth(scip) == 0 )
maxcuts = MIN(sepadata->maxinvcutsroot, nrelevantedges);
else
maxcuts = MIN(sepadata->maxinvcuts, nrelevantedges);
assert( maxcuts > 0 );
/* allocate buffer arrays */
SCIP_CALL( SCIPallocBufferArray(scip, &varrank, ncols) );
SCIP_CALL( SCIPallocBufferArray(scip, &rowsmaxval, nrows) );
SCIP_CALL( SCIPallocBufferArray(scip, &basisrow, ncols) );
SCIP_CALL( SCIPallocBufferArray(scip, &binvrow, nrows) );
SCIP_CALL( SCIPallocBufferArray(scip, &coef, ncols) );
SCIP_CALL( SCIPallocBufferArray(scip, &simplexcoefs1, ncols) );
SCIP_CALL( SCIPallocBufferArray(scip, &simplexcoefs2, ncols) );
SCIP_CALL( SCIPallocBufferArray(scip, &cutcoefs, ncols) );
SCIP_CALL( SCIPallocBufferArray(scip, &basisind, nrows) );
/* get basis indices */
SCIP_CALL( SCIPgetLPBasisInd(scip, basisind) );
/* create vector "basisrow" with basisrow[column of non-slack basis variable] = corresponding row of B^-1;
* compute maximum absolute value of nonbasic row coefficients */
for (j = 0; j < nrows; ++j)
{
SCIP_COL** rowcols;
SCIP_Real* rowvals;
SCIP_ROW* row;
SCIP_Real val;
SCIP_Real max = 0.0;
int nnonz;
/* fill basisrow vector */
ind = basisind[j];
if ( ind >= 0 )
basisrow[ind] = j;
/* compute maximum absolute value of nonbasic row coefficients */
row = rows[j];
assert( row != NULL );
rowvals = SCIProwGetVals(row);
nnonz = SCIProwGetNNonz(row);
rowcols = SCIProwGetCols(row);
for (i = 0; i < nnonz; ++i)
{
if ( SCIPcolGetBasisStatus(rowcols[i]) == SCIP_BASESTAT_LOWER || SCIPcolGetBasisStatus(rowcols[i]) == SCIP_BASESTAT_UPPER )
{
val = REALABS(rowvals[i]);
if ( SCIPisFeasGT(scip, val, max) )
max = REALABS(val);
}
}
/* handle slack variable coefficient and save maximum value */
rowsmaxval[j] = MAX(max, 1.0);
}
/* initialize variable ranks with -1 */
for (j = 0; j < ncols; ++j)
varrank[j] = -1;
/* free buffer array */
SCIPfreeBufferArrayNull(scip, &basisind);
/* for the most promising disjunctions: try to generate disjunctive cuts */
ndisjcuts = 0;
for (i = 0; i < maxcuts; ++i)
{
SCIP_Bool madeintegral;
SCIP_Real cutlhs1;
SCIP_Real cutlhs2;
SCIP_Real bound1;
SCIP_Real bound2;
SCIP_ROW* row = NULL;
SCIP_VAR* var;
SCIP_COL* col;
int nonbasicnumber;
int cutrank = 0;
int edgenumber;
int rownnonz;
edgenumber = edgearray[i];
/* determine first simplex row */
var = SCIPnodeGetVarSOS1(conflictgraph, fixings1[edgenumber]);
col = SCIPvarGetCol(var);
ind = SCIPcolGetLPPos(col);
assert( ind >= 0 );
assert( SCIPcolGetBasisStatus(col) == SCIP_BASESTAT_BASIC );
/* get the 'ind'th row of B^-1 and B^-1 \cdot A */
SCIP_CALL( SCIPgetLPBInvRow(scip, basisrow[ind], binvrow, NULL, NULL) );
SCIP_CALL( SCIPgetLPBInvARow(scip, basisrow[ind], binvrow, coef, NULL, NULL) );
/* get the simplex-coefficients of the non-basic variables */
SCIP_CALL( getSimplexCoefficients(scip, rows, nrows, cols, ncols, coef, binvrow, simplexcoefs1, &nonbasicnumber) );
/* get rank of variable if not known already */
if ( varrank[ind] < 0 )
varrank[ind] = getVarRank(scip, binvrow, rowsmaxval, sepadata->maxweightrange, rows, nrows);
cutrank = MAX(cutrank, varrank[ind]);
/* get right hand side and bound of simplex talbeau row */
cutlhs1 = SCIPcolGetPrimsol(col);
if ( SCIPisFeasPositive(scip, cutlhs1) )
bound1 = SCIPcolGetUb(col);
else
bound1 = SCIPcolGetLb(col);
/* determine second simplex row */
var = SCIPnodeGetVarSOS1(conflictgraph, fixings2[edgenumber]);
col = SCIPvarGetCol(var);
ind = SCIPcolGetLPPos(col);
assert( ind >= 0 );
assert( SCIPcolGetBasisStatus(col) == SCIP_BASESTAT_BASIC );
/* get the 'ind'th row of B^-1 and B^-1 \cdot A */
SCIP_CALL( SCIPgetLPBInvRow(scip, basisrow[ind], binvrow, NULL, NULL) );
SCIP_CALL( SCIPgetLPBInvARow(scip, basisrow[ind], binvrow, coef, NULL, NULL) );
/* get the simplex-coefficients of the non-basic variables */
SCIP_CALL( getSimplexCoefficients(scip, rows, nrows, cols, ncols, coef, binvrow, simplexcoefs2, &nonbasicnumber) );
/* get rank of variable if not known already */
if ( varrank[ind] < 0 )
varrank[ind] = getVarRank(scip, binvrow, rowsmaxval, sepadata->maxweightrange, rows, nrows);
cutrank = MAX(cutrank, varrank[ind]);
/* get right hand side and bound of simplex talbeau row */
cutlhs2 = SCIPcolGetPrimsol(col);
if ( SCIPisFeasPositive(scip, cutlhs2) )
bound2 = SCIPcolGetUb(col);
else
bound2 = SCIPcolGetLb(col);
/* add coefficients to cut */
SCIP_CALL( generateDisjCutSOS1(scip, sepa, rows, nrows, cols, ncols, ndisjcuts, TRUE, sepadata->strengthen, cutlhs1, cutlhs2, bound1, bound2, simplexcoefs1, simplexcoefs2, cutcoefs, &row, &madeintegral) );
if ( row == NULL )
continue;
/* raise cutrank for present cut */
++cutrank;
/* check if there are numerical evidences */
if ( ( madeintegral && ( sepadata->maxrankintegral == -1 || cutrank <= sepadata->maxrankintegral ) )
|| ( ! madeintegral && ( sepadata->maxrank == -1 || cutrank <= sepadata->maxrank ) ) )
{
/* possibly add cut to LP if it is useful; in case the lhs of the cut is minus infinity (due to scaling) the cut is useless */
rownnonz = SCIProwGetNNonz(row);
if ( rownnonz > 0 && ! SCIPisInfinity(scip, -SCIProwGetLhs(row)) && ! SCIProwIsInLP(row) && SCIPisCutEfficacious(scip, NULL, row) )
{
SCIP_Bool infeasible;
/* set cut rank */
SCIProwChgRank(row, cutrank);
/* add cut */
SCIP_CALL( SCIPaddCut(scip, NULL, row, FALSE, &infeasible) );
SCIPdebug( SCIP_CALL( SCIPprintRow(scip, row, NULL) ) );
if ( infeasible )
{
*result = SCIP_CUTOFF;
break;
}
++ndisjcuts;
}
}
/* release row */
SCIP_CALL( SCIPreleaseRow(scip, &row) );
}
/* save total number of cuts found so far */
sepadata->lastncutsfound = SCIPgetNCutsFound(scip);
/* evaluate the result of the separation */
if ( *result != SCIP_CUTOFF )
{
if ( ndisjcuts > 0 )
*result = SCIP_SEPARATED;
else
*result = SCIP_DIDNOTFIND;
}
SCIPdebugMessage("Number of found disjunctive cuts: %d.\n", ndisjcuts);
/* free buffer arrays */
SCIPfreeBufferArrayNull(scip, &cutcoefs);
SCIPfreeBufferArrayNull(scip, &simplexcoefs2);
SCIPfreeBufferArrayNull(scip, &simplexcoefs1);
SCIPfreeBufferArrayNull(scip, &coef);
SCIPfreeBufferArrayNull(scip, &binvrow);
SCIPfreeBufferArrayNull(scip, &basisrow);
SCIPfreeBufferArrayNull(scip, &fixings2);
SCIPfreeBufferArrayNull(scip, &fixings1);
SCIPfreeBufferArrayNull(scip, &edgearray);
SCIPfreeBufferArrayNull(scip, &rowsmaxval);
SCIPfreeBufferArrayNull(scip, &varrank);
return SCIP_OKAY;
}
/** computes a disjunctive cut inequality based on two simplex taubleau rows */
static
SCIP_RETCODE generateDisjCutSOS1(
SCIP* scip, /**< SCIP pointer */
SCIP_SEPA* sepa, /**< separator */
SCIP_ROW** rows, /**< LP rows */
int nrows, /**< number of LP rows */
SCIP_COL** cols, /**< LP columns */
int ncols, /**< number of LP columns */
int ndisjcuts, /**< number of disjunctive cuts found so far */
SCIP_Bool scale, /**< should cut be scaled */
SCIP_Bool strengthen, /**< should cut be strengthened if integer variables are present */
SCIP_Real cutlhs1, /**< left hand side of the first simplex row */
SCIP_Real cutlhs2, /**< left hand side of the second simplex row */
SCIP_Real bound1, /**< bound of first simplex row */
SCIP_Real bound2, /**< bound of second simplex row */
SCIP_Real* simplexcoefs1, /**< simplex coefficients of first row */
SCIP_Real* simplexcoefs2, /**< simplex coefficients of second row */
SCIP_Real* cutcoefs, /**< pointer to store cut coefficients (length: nscipvars) */
SCIP_ROW** row, /**< pointer to store disjunctive cut inequality */
SCIP_Bool* madeintegral /**< pointer to store whether cut has been scaled to integral values */
)
{
char cutname[SCIP_MAXSTRLEN];
SCIP_COL** rowcols;
SCIP_COL* col;
SCIP_Real* rowvals;
SCIP_Real lhsrow;
SCIP_Real rhsrow;
SCIP_Real cutlhs;
SCIP_Real sgn;
SCIP_Real lb;
SCIP_Real ub;
int nonbasicnumber = 0;
int rownnonz;
int ind;
int r;
int c;
assert( scip != NULL );
assert( row != NULL );
assert( rows != NULL );
assert( cols != NULL );
assert( simplexcoefs1 != NULL );
assert( simplexcoefs2 != NULL );
assert( cutcoefs != NULL );
assert( sepa != NULL );
assert( madeintegral != NULL );
*madeintegral = FALSE;
/* check signs */
if ( SCIPisFeasPositive(scip, cutlhs1) == SCIPisFeasPositive(scip, cutlhs2) )
sgn = 1.0;
else
sgn = -1.0;
/* check bounds */
if ( SCIPisInfinity(scip, REALABS(bound1)) || SCIPisInfinity(scip, REALABS(bound2)) )
strengthen = FALSE;
/* compute left hand side of row (a later update is possible, see below) */
cutlhs = sgn * cutlhs1 * cutlhs2;
/* add cut-coefficients of the non-basic non-slack variables */
for (c = 0; c < ncols; ++c)
{
col = cols[c];
assert( col != NULL );
ind = SCIPcolGetLPPos(col);
assert( ind >= 0 );
if ( SCIPcolGetBasisStatus(col) == SCIP_BASESTAT_LOWER )
{
lb = SCIPcolGetLb(col);
/* for integer variables we may obtain stronger coefficients */
if ( strengthen && SCIPcolIsIntegral(col) )
{
SCIP_Real mval;
SCIP_Real mvalfloor;
SCIP_Real mvalceil;
mval = (cutlhs2 * simplexcoefs1[nonbasicnumber] - cutlhs1 * simplexcoefs2[nonbasicnumber]) / (cutlhs2 * bound1 + cutlhs1 * bound2);
mvalfloor = SCIPfloor(scip, mval);
mvalceil = SCIPceil(scip, mval);
cutcoefs[ind] = MIN(sgn * cutlhs2 * (simplexcoefs1[nonbasicnumber] - mvalfloor * bound1), sgn * cutlhs1 * (simplexcoefs2[nonbasicnumber] + mvalceil * bound2));
assert( SCIPisFeasLE(scip, cutcoefs[ind], MAX(sgn * cutlhs2 * simplexcoefs1[nonbasicnumber], sgn * cutlhs1 * simplexcoefs2[nonbasicnumber])) );
}
else
cutcoefs[ind] = MAX(sgn * cutlhs2 * simplexcoefs1[nonbasicnumber], sgn * cutlhs1 * simplexcoefs2[nonbasicnumber]);
cutlhs += cutcoefs[ind] * lb;
++nonbasicnumber;
}
else if ( SCIPcolGetBasisStatus(col) == SCIP_BASESTAT_UPPER )
{
ub = SCIPcolGetUb(col);
/* for integer variables we may obtain stronger coefficients */
if ( strengthen && SCIPcolIsIntegral(col) )
{
SCIP_Real mval;
SCIP_Real mvalfloor;
SCIP_Real mvalceil;
mval = (cutlhs2 * simplexcoefs1[nonbasicnumber] - cutlhs1 * simplexcoefs2[nonbasicnumber]) / (cutlhs2 * bound1 + cutlhs1 * bound2);
mvalfloor = SCIPfloor(scip, -mval);
mvalceil = SCIPceil(scip, -mval);
cutcoefs[ind] = MAX(sgn * cutlhs2 * (simplexcoefs1[nonbasicnumber] + mvalfloor * bound1), sgn * cutlhs1 * (simplexcoefs2[nonbasicnumber] - mvalceil * bound2));
assert( SCIPisFeasLE(scip, -cutcoefs[ind], -MIN(sgn * cutlhs2 * simplexcoefs1[nonbasicnumber], sgn * cutlhs1 * simplexcoefs2[nonbasicnumber])) );
}
else
cutcoefs[ind] = MIN(sgn * cutlhs2 * simplexcoefs1[nonbasicnumber], sgn * cutlhs1 * simplexcoefs2[nonbasicnumber]);
cutlhs += cutcoefs[ind] * ub;
++nonbasicnumber;
}
else
{
assert( SCIPcolGetBasisStatus(col) != SCIP_BASESTAT_ZERO );
cutcoefs[ind] = 0.0;
}
}
/* add cut-coefficients of the non-basic slack variables */
for (r = 0; r < nrows; ++r)
{
rhsrow = SCIProwGetRhs(rows[r]) - SCIProwGetConstant(rows[r]);
lhsrow = SCIProwGetLhs(rows[r]) - SCIProwGetConstant(rows[r]);
assert( SCIProwGetBasisStatus(rows[r]) != SCIP_BASESTAT_ZERO );
assert( SCIPisFeasZero(scip, lhsrow - rhsrow) || SCIPisNegative(scip, lhsrow - rhsrow) );
assert( SCIProwIsInLP(rows[r]) );
if ( SCIProwGetBasisStatus(rows[r]) != SCIP_BASESTAT_BASIC )
{
SCIP_Real cutcoef;
if ( SCIProwGetBasisStatus(rows[r]) == SCIP_BASESTAT_UPPER )
{
assert( SCIPisFeasZero(scip, SCIPgetRowLPActivity(scip, rows[r]) - SCIProwGetRhs(rows[r])) );
cutcoef = MAX(sgn * cutlhs2 * simplexcoefs1[nonbasicnumber], sgn * cutlhs1 * simplexcoefs2[nonbasicnumber]);
cutlhs -= cutcoef * rhsrow;
++nonbasicnumber;
}
else /* SCIProwGetBasisStatus(rows[r]) == SCIP_BASESTAT_LOWER */
{
assert( SCIProwGetBasisStatus(rows[r]) == SCIP_BASESTAT_LOWER );
assert( SCIPisFeasZero(scip, SCIPgetRowLPActivity(scip, rows[r]) - SCIProwGetLhs(rows[r])) );
cutcoef = MIN(sgn * cutlhs2 * simplexcoefs1[nonbasicnumber], sgn * cutlhs1 * simplexcoefs2[nonbasicnumber]);
cutlhs -= cutcoef * lhsrow;
++nonbasicnumber;
}
rownnonz = SCIProwGetNNonz(rows[r]);
rowvals = SCIProwGetVals(rows[r]);
rowcols = SCIProwGetCols(rows[r]);
for (c = 0; c < rownnonz; ++c)
{
ind = SCIPcolGetLPPos(rowcols[c]);
/* if column is not in LP, then return without generating cut */
if ( ind < 0 )
{
*row = NULL;
return SCIP_OKAY;
}
cutcoefs[ind] -= cutcoef * rowvals[c];
}
}
}
/* create cut */
(void) SCIPsnprintf(cutname, SCIP_MAXSTRLEN, "%s_%d_%d", SCIPsepaGetName(sepa), SCIPgetNLPs(scip), ndisjcuts);
if ( SCIPgetDepth(scip) == 0 )
SCIP_CALL( SCIPcreateEmptyRowSepa(scip, row, sepa, cutname, cutlhs, SCIPinfinity(scip), FALSE, FALSE, TRUE) );
else
SCIP_CALL( SCIPcreateEmptyRowSepa(scip, row, sepa, cutname, cutlhs, SCIPinfinity(scip), TRUE, FALSE, TRUE) );
SCIP_CALL( SCIPcacheRowExtensions(scip, *row) );
for (c = 0; c < ncols; ++c)
{
ind = SCIPcolGetLPPos(cols[c]);
assert( ind >= 0 );
if ( ! SCIPisFeasZero(scip, cutcoefs[ind]) )
{
SCIP_CALL( SCIPaddVarToRow(scip, *row, SCIPcolGetVar(cols[c]), cutcoefs[ind] ) );
}
}
SCIP_CALL( SCIPflushRowExtensions(scip, *row) );
/* try to scale the cut to integral values
* @todo find better but still stable disjunctive cut settings
*/
if ( scale )
{
int maxdepth;
int depth;
SCIP_Longint maxdnom;
SCIP_Real maxscale;
depth = SCIPgetDepth(scip);
assert( depth >= 0 );
maxdepth = SCIPgetMaxDepth(scip);
if ( depth == 0 )
{
maxdnom = 1000;
maxscale = 1000.0;
}
else if ( depth <= maxdepth/4 )
{
maxdnom = 1000;
maxscale = 1000.0;
}
else if ( depth <= maxdepth/2 )
{
maxdnom = 100;
maxscale = 100.0;
}
else
{
maxdnom = 10;
maxscale = 10.0;
}
SCIP_CALL( SCIPmakeRowIntegral(scip, *row, -SCIPepsilon(scip), SCIPsumepsilon(scip), maxdnom, maxscale, TRUE, madeintegral) );
}
return SCIP_OKAY;
}
/** update row activities after a variable's solution value changed */
static
SCIP_RETCODE updateActivities(
SCIP* scip, /**< SCIP data structure */
SCIP_Real* activities, /**< LP row activities */
SCIP_ROW** violrows, /**< array with currently violated rows */
int* violrowpos, /**< position of LP rows in violrows array */
int* nviolrows, /**< pointer to the number of currently violated rows */
int nlprows, /**< number of rows in current LP */
SCIP_VAR* var, /**< variable that has been changed */
SCIP_Real oldsolval, /**< old solution value of variable */
SCIP_Real newsolval /**< new solution value of variable */
)
{
SCIP_COL* col;
SCIP_ROW** colrows;
SCIP_Real* colvals;
SCIP_Real delta;
int ncolrows;
int r;
assert(activities != NULL);
assert(nviolrows != NULL);
assert(0 <= *nviolrows && *nviolrows <= nlprows);
delta = newsolval - oldsolval;
col = SCIPvarGetCol(var);
colrows = SCIPcolGetRows(col);
colvals = SCIPcolGetVals(col);
ncolrows = SCIPcolGetNLPNonz(col);
assert(ncolrows == 0 || (colrows != NULL && colvals != NULL));
for( r = 0; r < ncolrows; ++r )
{
SCIP_ROW* row;
int rowpos;
row = colrows[r];
rowpos = SCIProwGetLPPos(row);
assert(-1 <= rowpos && rowpos < nlprows);
if( rowpos >= 0 && !SCIProwIsLocal(row) )
{
SCIP_Real oldactivity;
SCIP_Real newactivity;
assert(SCIProwIsInLP(row));
/* update row activity */
oldactivity = activities[rowpos];
if( !SCIPisInfinity(scip, -oldactivity) && !SCIPisInfinity(scip, oldactivity) )
{
newactivity = oldactivity + delta * colvals[r];
if( SCIPisInfinity(scip, newactivity) )
newactivity = SCIPinfinity(scip);
else if( SCIPisInfinity(scip, -newactivity) )
newactivity = -SCIPinfinity(scip);
activities[rowpos] = newactivity;
/* update row violation arrays */
updateViolations(scip, row, violrows, violrowpos, nviolrows, oldactivity, newactivity);
}
}
}
return SCIP_OKAY;
}
