//-------------------------------------------------------------------
// Determine row types. Find the VUBS and VLBS.
//-------------------------------------------------------------------
void
CglFlowCover::flowPreprocess(const OsiSolverInterface& si) const
{
CoinPackedMatrix matrixByRow(*si.getMatrixByRow());
int numRows = si.getNumRows();
int numCols = si.getNumCols();
const char* sense = si.getRowSense();
const double* RHS = si.getRightHandSide();
const double* coefByRow = matrixByRow.getElements();
const int* colInds = matrixByRow.getIndices();
const int* rowStarts = matrixByRow.getVectorStarts();
const int* rowLengths = matrixByRow.getVectorLengths();
int iRow = -1;
int iCol = -1;
numCols_ = numCols; // Record col and row numbers for copy constructor
numRows_ = numRows;
if (rowTypes_ != 0) {
delete [] rowTypes_; rowTypes_ = 0;
}
rowTypes_ = new CglFlowRowType [numRows];// Destructor will free memory
// Get integer types
const char * columnType = si.getColType (true);
// Summarize the row type infomation.
int numUNDEFINED = 0;
int numVARUB = 0;
int numVARLB = 0;
int numVAREQ = 0;
int numMIXUB = 0;
int numMIXEQ = 0;
int numNOBINUB = 0;
int numNOBINEQ = 0;
int numSUMVARUB = 0;
int numSUMVAREQ = 0;
int numUNINTERSTED = 0;
int* ind = new int [numCols];
double* coef = new double [numCols];
for (iRow = 0; iRow < numRows; ++iRow) {
int rowLen = rowLengths[iRow];
char sen = sense[iRow];
double rhs = RHS[iRow];
CoinDisjointCopyN(colInds + rowStarts[iRow], rowLen, ind);
CoinDisjointCopyN(coefByRow + rowStarts[iRow], rowLen, coef);
CglFlowRowType rowType = determineOneRowType(si, rowLen, ind, coef,
sen, rhs);
rowTypes_[iRow] = rowType;
switch(rowType) {
case CGLFLOW_ROW_UNDEFINED:
++numUNDEFINED;
break;
case CGLFLOW_ROW_VARUB:
++numVARUB;
break;
case CGLFLOW_ROW_VARLB:
++numVARLB;
break;
case CGLFLOW_ROW_VAREQ:
++numVAREQ;
break;
case CGLFLOW_ROW_MIXUB:
++numMIXUB;
break;
case CGLFLOW_ROW_MIXEQ:
++numMIXEQ;
break;
case CGLFLOW_ROW_NOBINUB:
++numNOBINUB;
break;
case CGLFLOW_ROW_NOBINEQ:
++numNOBINEQ;
break;
case CGLFLOW_ROW_SUMVARUB:
++numSUMVARUB;
break;
case CGLFLOW_ROW_SUMVAREQ:
++numSUMVAREQ;
break;
case CGLFLOW_ROW_UNINTERSTED:
++numUNINTERSTED;
break;
default:
throw CoinError("Unknown row type", "flowPreprocess",
"CglFlowCover");
}
}
delete [] ind; ind = NULL;
delete [] coef; coef = NULL;
if(CGLFLOW_DEBUG) {
std::cout << "The num of rows = " << numRows << std::endl;
std::cout << "Summary of Row Type" << std::endl;
std::cout << "numUNDEFINED = " << numUNDEFINED << std::endl;
std::cout << "numVARUB = " << numVARUB << std::endl;
std::cout << "numVARLB = " << numVARLB << std::endl;
std::cout << "numVAREQ = " << numVAREQ << std::endl;
std::cout << "numMIXUB = " << numMIXUB << std::endl;
std::cout << "numMIXEQ = " << numMIXEQ << std::endl;
std::cout << "numNOBINUB = " << numNOBINUB << std::endl;
std::cout << "numNOBINEQ = " << numNOBINEQ << std::endl;
std::cout << "numSUMVARUB = " << numSUMVARUB << std::endl;
std::cout << "numSUMVAREQ = " << numSUMVAREQ << std::endl;
std::cout << "numUNINTERSTED = " << numUNINTERSTED << std::endl;
}
//---------------------------------------------------------------------------
// Setup vubs_ and vlbs_
if (vubs_ != 0) { delete [] vubs_; vubs_ = 0; }
vubs_ = new CglFlowVUB [numCols]; // Destructor will free memory
if (vlbs_ != 0) { delete [] vlbs_; vlbs_ = 0; }
vlbs_ = new CglFlowVLB [numCols]; // Destructor will free memory
for (iCol = 0; iCol < numCols; ++iCol) { // Initilized in constructor
vubs_[iCol].setVar(UNDEFINED_); // but, need redo since may call
vlbs_[iCol].setVar(UNDEFINED_); // preprocess(...) more than once
}
for (iRow = 0; iRow < numRows; ++iRow) {
CglFlowRowType rowType2 = rowTypes_[iRow];
if ( (rowType2 == CGLFLOW_ROW_VARUB) ||
(rowType2 == CGLFLOW_ROW_VARLB) ||
(rowType2 == CGLFLOW_ROW_VAREQ) ) {
int startPos = rowStarts[iRow];
int index0 = colInds[startPos];
int index1 = colInds[startPos + 1];
double coef0 = coefByRow[startPos];
double coef1 = coefByRow[startPos + 1];
int xInd, yInd; // x is binary
double xCoef, yCoef;
if ( columnType[index0]==1 ) {
xInd = index0; yInd = index1;
xCoef = coef0; yCoef = coef1;
}
else {
xInd = index1; yInd = index0;
xCoef = coef1; yCoef = coef0;
}
switch (rowType2) {
case CGLFLOW_ROW_VARUB: // Inequality: y <= ? * x
vubs_[yInd].setVar(xInd);
vubs_[yInd].setVal(-xCoef / yCoef);
break;
case CGLFLOW_ROW_VARLB: // Inequality: y >= ? * x
vlbs_[yInd].setVar(xInd);
vlbs_[yInd].setVal(-xCoef / yCoef);
break;
case CGLFLOW_ROW_VAREQ: // Inequality: y >= AND <= ? * x
vubs_[yInd].setVar(xInd);
vubs_[yInd].setVal(-xCoef / yCoef);
vlbs_[yInd].setVar(xInd);
vlbs_[yInd].setVal(-xCoef / yCoef);
break;
default:
throw CoinError("Unknown row type: impossible",
"flowPreprocess", "CglFlowCover");
}
}
}
if(CGLFLOW_DEBUG) {
printVubs(std::cout);
}
}
//-----------------------------------------------------------------------------
// Generate LSGFC cuts
//-------------------------------------------------------------------
void CglFlowCover::generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
const CglTreeInfo info) const
{
static int count=0;
if (getMaxNumCuts() <= 0) return;
if (getNumFlowCuts() >= getMaxNumCuts()) return;
++count;
#if 0
bool preInit = false;
bool preReso = false;
si.getHintParam(OsiDoPresolveInInitial, preInit);
si.getHintParam(OsiDoPresolveInResolve, preReso);
if (preInit == false && preReso == false) { // Do once
if (doneInitPre_ == false) {
flowPreprocess(si);
doneInitPre_ = true;
}
}
else
#endif
int numberRowCutsBefore = cs.sizeRowCuts();
flowPreprocess(si);
CoinPackedMatrix matrixByRow(*si.getMatrixByRow());
const char* sense = si.getRowSense();
const double* rhs = si.getRightHandSide();
const double* elementByRow = matrixByRow.getElements();
const int* colInd = matrixByRow.getIndices();
const CoinBigIndex* rowStart = matrixByRow.getVectorStarts();
const int* rowLength = matrixByRow.getVectorLengths();
int* ind = 0;
double* coef = 0;
int iRow, iCol;
CglFlowRowType rType;
for (iRow = 0; iRow < numRows_; ++iRow) {
rType = getRowType(iRow);
if( ( rType != CGLFLOW_ROW_MIXUB ) &&
( rType != CGLFLOW_ROW_MIXEQ ) &&
( rType != CGLFLOW_ROW_NOBINUB ) &&
( rType != CGLFLOW_ROW_NOBINEQ ) &&
( rType != CGLFLOW_ROW_SUMVARUB ) &&
( rType != CGLFLOW_ROW_SUMVAREQ ) )
continue;
const int sta = rowStart[iRow]; // Start position of iRow
const int rowLen = rowLength[iRow]; // iRow length / non-zero elements
if (ind != 0) { delete [] ind; ind = 0; }
ind = new int [rowLen];
if (coef != 0) { delete [] coef; coef = 0; }
coef = new double [rowLen];
int lastPos = sta + rowLen;
for (iCol = sta; iCol < lastPos; ++iCol) {
ind[iCol - sta] = colInd[iCol];
coef[iCol - sta] = elementByRow[iCol];
}
OsiRowCut flowCut1, flowCut2, flowCut3;
double violation = 0.0;
bool hasCut = false;
if (sense[iRow] == 'E') {
hasCut = generateOneFlowCut(si, rowLen, ind, coef, 'L',
rhs[iRow], flowCut1, violation);
if (hasCut) { // If find a cut
cs.insert(flowCut1);
incNumFlowCuts();
if (getNumFlowCuts() >= getMaxNumCuts())
break;
}
hasCut = false;
hasCut = generateOneFlowCut(si, rowLen, ind, coef, 'G',
rhs[iRow], flowCut2, violation);
if (hasCut) {
cs.insert(flowCut2);
incNumFlowCuts();
if (getNumFlowCuts() >= getMaxNumCuts())
break;
}
}
if (sense[iRow] == 'L' || sense[iRow] == 'G') {
hasCut = generateOneFlowCut(si, rowLen, ind, coef, sense[iRow],
rhs[iRow], flowCut3, violation);
if (hasCut) {
cs.insert(flowCut3);
incNumFlowCuts();
if (getNumFlowCuts() >= getMaxNumCuts())
break;
}
}
}
#ifdef CGLFLOW_DEBUG2
if(CGLFLOW_DEBUG) {
std::cout << "\nnumFlowCuts = "<< getNumFlowCuts() << std::endl;
std::cout << "CGLFLOW_COL_BINNEG = "<< CGLFLOW_COL_BINNEG << std::endl;
}
#endif
if (!info.inTree&&((info.options&4)==4||((info.options&8)&&!info.pass))) {
int numberRowCutsAfter = cs.sizeRowCuts();
for (int i=numberRowCutsBefore;i<numberRowCutsAfter;i++)
cs.rowCutPtr(i)->setGloballyValid();
}
if (ind != 0) { delete [] ind; ind = 0; }
if (coef != 0) { delete [] coef; coef = 0; }
}
