OsiSolverInterface *
expandKnapsack(CoinModel & model, int * whichColumn, int * knapsackStart,
int * knapsackRow, int &numberKnapsack,
CglStored & stored, int logLevel,
int fixedPriority, int SOSPriority, CoinModel & tightenedModel)
{
int maxTotal = numberKnapsack;
// load from coin model
OsiSolverLink *si = new OsiSolverLink();
OsiSolverInterface * finalModel = NULL;
si->setDefaultMeshSize(0.001);
// need some relative granularity
si->setDefaultBound(100.0);
si->setDefaultMeshSize(0.01);
si->setDefaultBound(100000.0);
si->setIntegerPriority(1000);
si->setBiLinearPriority(10000);
si->load(model, true, logLevel);
// get priorities
const int * priorities = model.priorities();
int numberColumns = model.numberColumns();
if (priorities) {
OsiObject ** objects = si->objects();
int numberObjects = si->numberObjects();
for (int iObj = 0; iObj < numberObjects; iObj++) {
int iColumn = objects[iObj]->columnNumber();
if (iColumn >= 0 && iColumn < numberColumns) {
#ifndef NDEBUG
OsiSimpleInteger * obj =
dynamic_cast <OsiSimpleInteger *>(objects[iObj]) ;
#endif
assert (obj);
int iPriority = priorities[iColumn];
if (iPriority > 0)
objects[iObj]->setPriority(iPriority);
}
}
if (fixedPriority > 0) {
si->setFixedPriority(fixedPriority);
}
if (SOSPriority < 0)
SOSPriority = 100000;
}
CoinModel coinModel = *si->coinModel();
assert(coinModel.numberRows() > 0);
tightenedModel = coinModel;
int numberRows = coinModel.numberRows();
// Mark variables
int * whichKnapsack = new int [numberColumns];
int iRow, iColumn;
for (iColumn = 0; iColumn < numberColumns; iColumn++)
whichKnapsack[iColumn] = -1;
int kRow;
bool badModel = false;
// analyze
if (logLevel > 1) {
for (iRow = 0; iRow < numberRows; iRow++) {
/* Just obvious one at first
positive non unit coefficients
all integer
positive rowUpper
for now - linear (but further down in code may use nonlinear)
column bounds should be tight
*/
//double lower = coinModel.getRowLower(iRow);
double upper = coinModel.getRowUpper(iRow);
if (upper < 1.0e10) {
CoinModelLink triple = coinModel.firstInRow(iRow);
bool possible = true;
int n = 0;
int n1 = 0;
while (triple.column() >= 0) {
int iColumn = triple.column();
const char * el = coinModel.getElementAsString(iRow, iColumn);
if (!strcmp("Numeric", el)) {
if (coinModel.columnLower(iColumn) == coinModel.columnUpper(iColumn)) {
triple = coinModel.next(triple);
continue; // fixed
}
double value = coinModel.getElement(iRow, iColumn);
if (value < 0.0) {
possible = false;
} else {
n++;
if (value == 1.0)
n1++;
if (coinModel.columnLower(iColumn) < 0.0)
possible = false;
if (!coinModel.isInteger(iColumn))
possible = false;
if (whichKnapsack[iColumn] >= 0)
possible = false;
}
} else {
possible = false; // non linear
}
triple = coinModel.next(triple);
}
if (n - n1 > 1 && possible) {
double lower = coinModel.getRowLower(iRow);
double upper = coinModel.getRowUpper(iRow);
CoinModelLink triple = coinModel.firstInRow(iRow);
while (triple.column() >= 0) {
int iColumn = triple.column();
lower -= coinModel.columnLower(iColumn) * triple.value();
upper -= coinModel.columnLower(iColumn) * triple.value();
triple = coinModel.next(triple);
}
printf("%d is possible %g <=", iRow, lower);
// print
triple = coinModel.firstInRow(iRow);
while (triple.column() >= 0) {
int iColumn = triple.column();
if (coinModel.columnLower(iColumn) != coinModel.columnUpper(iColumn))
printf(" (%d,el %g up %g)", iColumn, triple.value(),
coinModel.columnUpper(iColumn) - coinModel.columnLower(iColumn));
triple = coinModel.next(triple);
}
printf(" <= %g\n", upper);
}
}
}
}
numberKnapsack = 0;
for (kRow = 0; kRow < numberRows; kRow++) {
iRow = kRow;
/* Just obvious one at first
positive non unit coefficients
all integer
positive rowUpper
for now - linear (but further down in code may use nonlinear)
column bounds should be tight
*/
//double lower = coinModel.getRowLower(iRow);
double upper = coinModel.getRowUpper(iRow);
if (upper < 1.0e10) {
CoinModelLink triple = coinModel.firstInRow(iRow);
bool possible = true;
int n = 0;
int n1 = 0;
while (triple.column() >= 0) {
int iColumn = triple.column();
const char * el = coinModel.getElementAsString(iRow, iColumn);
if (!strcmp("Numeric", el)) {
if (coinModel.columnLower(iColumn) == coinModel.columnUpper(iColumn)) {
triple = coinModel.next(triple);
continue; // fixed
}
double value = coinModel.getElement(iRow, iColumn);
if (value < 0.0) {
possible = false;
} else {
n++;
if (value == 1.0)
n1++;
if (coinModel.columnLower(iColumn) < 0.0)
possible = false;
if (!coinModel.isInteger(iColumn))
possible = false;
if (whichKnapsack[iColumn] >= 0)
possible = false;
}
} else {
possible = false; // non linear
}
triple = coinModel.next(triple);
}
if (n - n1 > 1 && possible) {
// try
CoinModelLink triple = coinModel.firstInRow(iRow);
while (triple.column() >= 0) {
int iColumn = triple.column();
if (coinModel.columnLower(iColumn) != coinModel.columnUpper(iColumn))
whichKnapsack[iColumn] = numberKnapsack;
triple = coinModel.next(triple);
}
knapsackRow[numberKnapsack++] = iRow;
}
}
}
if (logLevel > 0)
printf("%d out of %d candidate rows are possible\n", numberKnapsack, numberRows);
// Check whether we can get rid of nonlinearities
/* mark rows
-2 in knapsack and other variables
-1 not involved
n only in knapsack n
*/
int * markRow = new int [numberRows];
for (iRow = 0; iRow < numberRows; iRow++)
markRow[iRow] = -1;
int canDo = 1; // OK and linear
for (iColumn = 0; iColumn < numberColumns; iColumn++) {
CoinModelLink triple = coinModel.firstInColumn(iColumn);
int iKnapsack = whichKnapsack[iColumn];
bool linear = true;
// See if quadratic objective
const char * expr = coinModel.getColumnObjectiveAsString(iColumn);
if (strcmp(expr, "Numeric")) {
linear = false;
}
while (triple.row() >= 0) {
int iRow = triple.row();
if (iKnapsack >= 0) {
if (markRow[iRow] == -1) {
markRow[iRow] = iKnapsack;
} else if (markRow[iRow] != iKnapsack) {
markRow[iRow] = -2;
}
}
const char * expr = coinModel.getElementAsString(iRow, iColumn);
if (strcmp(expr, "Numeric")) {
linear = false;
}
triple = coinModel.next(triple);
}
if (!linear) {
if (whichKnapsack[iColumn] < 0) {
canDo = 0;
break;
} else {
canDo = 2;
}
}
}
int * markKnapsack = NULL;
double * coefficient = NULL;
double * linear = NULL;
int * whichRow = NULL;
int * lookupRow = NULL;
badModel = (canDo == 0);
if (numberKnapsack && canDo) {
/* double check - OK if
no nonlinear
nonlinear only on columns in knapsack
nonlinear only on columns in knapsack * ONE other - same for all in knapsack
AND that is only row connected to knapsack
(theoretically could split knapsack if two other and small numbers)
also ONE could be ONE expression - not just a variable
*/
int iKnapsack;
markKnapsack = new int [numberKnapsack];
coefficient = new double [numberKnapsack];
linear = new double [numberColumns];
for (iKnapsack = 0; iKnapsack < numberKnapsack; iKnapsack++)
markKnapsack[iKnapsack] = -1;
if (canDo == 2) {
for (iRow = -1; iRow < numberRows; iRow++) {
int numberOdd;
CoinPackedMatrix * row = coinModel.quadraticRow(iRow, linear, numberOdd);
if (row) {
// see if valid
const double * element = row->getElements();
const int * column = row->getIndices();
const CoinBigIndex * columnStart = row->getVectorStarts();
const int * columnLength = row->getVectorLengths();
int numberLook = row->getNumCols();
for (int i = 0; i < numberLook; i++) {
int iKnapsack = whichKnapsack[i];
if (iKnapsack < 0) {
// might be able to swap - but for now can't have knapsack in
for (int j = columnStart[i]; j < columnStart[i] + columnLength[i]; j++) {
int iColumn = column[j];
if (whichKnapsack[iColumn] >= 0) {
canDo = 0; // no good
badModel = true;
break;
}
}
} else {
// OK if in same knapsack - or maybe just one
int marked = markKnapsack[iKnapsack];
for (int j = columnStart[i]; j < columnStart[i] + columnLength[i]; j++) {
int iColumn = column[j];
if (whichKnapsack[iColumn] != iKnapsack && whichKnapsack[iColumn] >= 0) {
canDo = 0; // no good
badModel = true;
break;
} else if (marked == -1) {
markKnapsack[iKnapsack] = iColumn;
marked = iColumn;
coefficient[iKnapsack] = element[j];
coinModel.associateElement(coinModel.columnName(iColumn), 1.0);
} else if (marked != iColumn) {
badModel = true;
canDo = 0; // no good
break;
} else {
// could manage with different coefficients - but for now ...
assert(coefficient[iKnapsack] == element[j]);
}
}
}
}
delete row;
}
}
}
if (canDo) {
// for any rows which are cuts
whichRow = new int [numberRows];
lookupRow = new int [numberRows];
bool someNonlinear = false;
double maxCoefficient = 1.0;
for (iKnapsack = 0; iKnapsack < numberKnapsack; iKnapsack++) {
if (markKnapsack[iKnapsack] >= 0) {
someNonlinear = true;
int iColumn = markKnapsack[iKnapsack];
maxCoefficient = CoinMax(maxCoefficient, fabs(coefficient[iKnapsack] * coinModel.columnUpper(iColumn)));
}
}
if (someNonlinear) {
// associate all columns to stop possible error messages
for (iColumn = 0; iColumn < numberColumns; iColumn++) {
coinModel.associateElement(coinModel.columnName(iColumn), 1.0);
}
}
ClpSimplex tempModel;
tempModel.loadProblem(coinModel);
// Create final model - first without knapsacks
int nCol = 0;
int nRow = 0;
for (iRow = 0; iRow < numberRows; iRow++) {
if (markRow[iRow] < 0) {
lookupRow[iRow] = nRow;
whichRow[nRow++] = iRow;
} else {
lookupRow[iRow] = -1;
}
}
for (iColumn = 0; iColumn < numberColumns; iColumn++) {
if (whichKnapsack[iColumn] < 0)
whichColumn[nCol++] = iColumn;
}
ClpSimplex finalModelX(&tempModel, nRow, whichRow, nCol, whichColumn, false, false, false);
OsiClpSolverInterface finalModelY(&finalModelX, true);
finalModel = finalModelY.clone();
finalModelY.releaseClp();
// Put back priorities
const int * priorities = model.priorities();
if (priorities) {
finalModel->findIntegers(false);
OsiObject ** objects = finalModel->objects();
int numberObjects = finalModel->numberObjects();
for (int iObj = 0; iObj < numberObjects; iObj++) {
int iColumn = objects[iObj]->columnNumber();
if (iColumn >= 0 && iColumn < nCol) {
#ifndef NDEBUG
OsiSimpleInteger * obj =
dynamic_cast <OsiSimpleInteger *>(objects[iObj]) ;
#endif
assert (obj);
int iPriority = priorities[whichColumn[iColumn]];
if (iPriority > 0)
objects[iObj]->setPriority(iPriority);
}
}
}
for (iRow = 0; iRow < numberRows; iRow++) {
whichRow[iRow] = iRow;
}
int numberOther = finalModel->getNumCols();
int nLargest = 0;
int nelLargest = 0;
int nTotal = 0;
for (iKnapsack = 0; iKnapsack < numberKnapsack; iKnapsack++) {
iRow = knapsackRow[iKnapsack];
int nCreate = maxTotal;
int nelCreate = coinModel.expandKnapsack(iRow, nCreate, NULL, NULL, NULL, NULL);
if (nelCreate < 0)
badModel = true;
nTotal += nCreate;
nLargest = CoinMax(nLargest, nCreate);
nelLargest = CoinMax(nelLargest, nelCreate);
}
if (nTotal > maxTotal)
badModel = true;
if (!badModel) {
// Now arrays for building
nelLargest = CoinMax(nelLargest, nLargest) + 1;
double * buildObj = new double [nLargest];
double * buildElement = new double [nelLargest];
int * buildStart = new int[nLargest+1];
int * buildRow = new int[nelLargest];
// alow for integers in knapsacks
OsiObject ** object = new OsiObject * [numberKnapsack+nTotal];
int nSOS = 0;
int nObj = numberKnapsack;
for (iKnapsack = 0; iKnapsack < numberKnapsack; iKnapsack++) {
knapsackStart[iKnapsack] = finalModel->getNumCols();
iRow = knapsackRow[iKnapsack];
int nCreate = 10000;
coinModel.expandKnapsack(iRow, nCreate, buildObj, buildStart, buildRow, buildElement);
// Redo row numbers
for (iColumn = 0; iColumn < nCreate; iColumn++) {
for (int j = buildStart[iColumn]; j < buildStart[iColumn+1]; j++) {
int jRow = buildRow[j];
jRow = lookupRow[jRow];
assert (jRow >= 0 && jRow < nRow);
buildRow[j] = jRow;
}
}
finalModel->addCols(nCreate, buildStart, buildRow, buildElement, NULL, NULL, buildObj);
int numberFinal = finalModel->getNumCols();
for (iColumn = numberOther; iColumn < numberFinal; iColumn++) {
if (markKnapsack[iKnapsack] < 0) {
finalModel->setColUpper(iColumn, maxCoefficient);
finalModel->setInteger(iColumn);
} else {
finalModel->setColUpper(iColumn, maxCoefficient + 1.0);
finalModel->setInteger(iColumn);
}
OsiSimpleInteger * sosObject = new OsiSimpleInteger(finalModel, iColumn);
sosObject->setPriority(1000000);
object[nObj++] = sosObject;
buildRow[iColumn-numberOther] = iColumn;
buildElement[iColumn-numberOther] = 1.0;
}
if (markKnapsack[iKnapsack] < 0) {
// convexity row
finalModel->addRow(numberFinal - numberOther, buildRow, buildElement, 1.0, 1.0);
} else {
int iColumn = markKnapsack[iKnapsack];
int n = numberFinal - numberOther;
buildRow[n] = iColumn;
buildElement[n++] = -fabs(coefficient[iKnapsack]);
// convexity row (sort of)
finalModel->addRow(n, buildRow, buildElement, 0.0, 0.0);
OsiSOS * sosObject = new OsiSOS(finalModel, n - 1, buildRow, NULL, 1);
sosObject->setPriority(iKnapsack + SOSPriority);
// Say not integral even if is (switch off heuristics)
sosObject->setIntegerValued(false);
object[nSOS++] = sosObject;
}
numberOther = numberFinal;
}
finalModel->addObjects(nObj, object);
for (iKnapsack = 0; iKnapsack < nObj; iKnapsack++)
delete object[iKnapsack];
delete [] object;
// Can we move any rows to cuts
const int * cutMarker = coinModel.cutMarker();
if (cutMarker && 0) {
printf("AMPL CUTS OFF until global cuts fixed\n");
cutMarker = NULL;
}
if (cutMarker) {
// Row copy
const CoinPackedMatrix * matrixByRow = finalModel->getMatrixByRow();
const double * elementByRow = matrixByRow->getElements();
const int * column = matrixByRow->getIndices();
const CoinBigIndex * rowStart = matrixByRow->getVectorStarts();
const int * rowLength = matrixByRow->getVectorLengths();
const double * rowLower = finalModel->getRowLower();
const double * rowUpper = finalModel->getRowUpper();
int nDelete = 0;
for (iRow = 0; iRow < numberRows; iRow++) {
if (cutMarker[iRow] && lookupRow[iRow] >= 0) {
int jRow = lookupRow[iRow];
whichRow[nDelete++] = jRow;
int start = rowStart[jRow];
stored.addCut(rowLower[jRow], rowUpper[jRow],
rowLength[jRow], column + start, elementByRow + start);
}
}
finalModel->deleteRows(nDelete, whichRow);
}
knapsackStart[numberKnapsack] = finalModel->getNumCols();
delete [] buildObj;
delete [] buildElement;
delete [] buildStart;
delete [] buildRow;
finalModel->writeMps("full");
}
}
}
delete [] whichKnapsack;
delete [] markRow;
delete [] markKnapsack;
delete [] coefficient;
delete [] linear;
delete [] whichRow;
delete [] lookupRow;
delete si;
si = NULL;
if (!badModel && finalModel) {
finalModel->setDblParam(OsiObjOffset, coinModel.objectiveOffset());
return finalModel;
} else {
delete finalModel;
printf("can't make knapsacks - did you set fixedPriority (extra1)\n");
return NULL;
}
}
int
main(void)
{
// Create a problem pointer. We use the base class here.
OsiSolverInterface *si;
// When we instantiate the object, we need a specific derived class.
si = new OSIXXX;
// Build our own instance from scratch
/*
* This section adapted from Matt Galati's example
* on the COIN-OR Tutorial website.
*
* Problem from Bertsimas, Tsitsiklis page 21
*
* optimal solution: x* = (1,1)
*
* minimize -1 x0 - 1 x1
* s.t 1 x0 + 2 x1 <= 3
* 2 x0 + 1 x1 <= 3
* x0 >= 0
* x1 >= 0
*/
int n_cols = 2;
double *objective = new double[n_cols];//the objective coefficients
double *col_lb = new double[n_cols];//the column lower bounds
double *col_ub = new double[n_cols];//the column upper bounds
//Define the objective coefficients.
//minimize -1 x0 - 1 x1
objective[0] = -1.0;
objective[1] = -1.0;
//Define the variable lower/upper bounds.
// x0 >= 0 => 0 <= x0 <= infinity
// x1 >= 0 => 0 <= x1 <= infinity
col_lb[0] = 0.0;
col_lb[1] = 0.0;
col_ub[0] = si->getInfinity();
col_ub[1] = si->getInfinity();
int n_rows = 2;
double *row_lb = new double[n_rows]; //the row lower bounds
double *row_ub = new double[n_rows]; //the row upper bounds
//Define the constraint matrix.
CoinPackedMatrix *matrix = new CoinPackedMatrix(false,0,0);
matrix->setDimensions(0, n_cols);
//1 x0 + 2 x1 <= 3 => -infinity <= 1 x0 + 2 x2 <= 3
CoinPackedVector row1;
row1.insert(0, 1.0);
row1.insert(1, 2.0);
row_lb[0] = -1.0 * si->getInfinity();
row_ub[0] = 3.0;
matrix->appendRow(row1);
//2 x0 + 1 x1 <= 3 => -infinity <= 2 x0 + 1 x1 <= 3
CoinPackedVector row2;
row2.insert(0, 2.0);
row2.insert(1, 1.0);
row_lb[1] = -1.0 * si->getInfinity();
row_ub[1] = 3.0;
matrix->appendRow(row2);
//load the problem to OSI
si->loadProblem(*matrix, col_lb, col_ub, objective, row_lb, row_ub);
//write the MPS file to a file called example.mps
si->writeMps("example");
// Solve the (relaxation of the) problem
si->initialSolve();
// Check the solution
if ( si->isProvenOptimal() ) {
std::cout << "Found optimal solution!" << std::endl;
std::cout << "Objective value is " << si->getObjValue() << std::endl;
int n = si->getNumCols();
const double *solution;
solution = si->getColSolution();
// We could then print the solution or examine it.
} else {
std::cout << "Didn't find optimal solution." << std::endl;
// Could then check other status functions.
}
return 0;
}
int doBaCParam (CoinParam *param)
{
assert (param != 0) ;
CbcGenParam *genParam = dynamic_cast<CbcGenParam *>(param) ;
assert (genParam != 0) ;
CbcGenCtlBlk *ctlBlk = genParam->obj() ;
assert (ctlBlk != 0) ;
CbcModel *model = ctlBlk->model_ ;
assert (model != 0) ;
/*
Setup to return nonfatal/fatal error (1/-1) by default.
*/
int retval ;
if (CoinParamUtils::isInteractive()) {
retval = 1 ;
} else {
retval = -1 ;
}
ctlBlk->setBaBStatus(CbcGenCtlBlk::BACAbandon, CbcGenCtlBlk::BACmInvalid,
CbcGenCtlBlk::BACwNotStarted, false, 0) ;
/*
We ain't gonna do squat without a good model.
*/
if (!ctlBlk->goodModel_) {
std::cout << "** Current model not valid!" << std::endl ;
return (retval) ;
}
/*
Start the clock ticking.
*/
double time1 = CoinCpuTime() ;
double time2 ;
/*
Create a clone of the model which we can modify with impunity. Extract
the underlying solver for convenient access.
*/
CbcModel babModel(*model) ;
OsiSolverInterface *babSolver = babModel.solver() ;
assert (babSolver != 0) ;
# if CBC_TRACK_SOLVERS > 0
std::cout
<< "doBaCParam: initial babSolver is "
<< std::hex << babSolver << std::dec
<< ", log level " << babSolver->messageHandler()->logLevel()
<< "." << std::endl ;
# endif
/*
Solve the root relaxation. Bail unless it solves to optimality.
*/
if (!solveRelaxation(&babModel)) {
ctlBlk->setBaBStatus(&babModel, CbcGenCtlBlk::BACwBareRoot) ;
return (0) ;
}
# if COIN_CBC_VERBOSITY > 0
std::cout
<< "doBaCParam: initial relaxation z = "
<< babSolver->getObjValue() << "." << std::endl ;
# endif
/*
Are we up for fixing variables based on reduced cost alone?
*/
if (ctlBlk->djFix_.action_ == true) {
reducedCostHack(babSolver, ctlBlk->djFix_.threshold_) ;
}
/*
Time to consider preprocessing. We'll do a bit of setup before getting to
the meat of the issue.
preIppSolver will hold a clone of the unpreprocessed constraint system.
We'll need it when we postprocess. ippSolver holds the preprocessed
constraint system. Again, we clone it and give the clone to babModel for
B&C. Presumably we need an unmodified copy of the preprocessed system to
do postprocessing, but the copy itself is hidden inside the preprocess
object.
*/
OsiSolverInterface *preIppSolver = 0 ;
CglPreProcess ippObj ;
bool didIPP = false ;
int numberChanged = 0 ;
int numberOriginalColumns = babSolver->getNumCols() ;
CbcGenCtlBlk::IPPControl ippAction = ctlBlk->getIPPAction() ;
if (!(ippAction == CbcGenCtlBlk::IPPOff ||
ippAction == CbcGenCtlBlk::IPPStrategy)) {
double timeLeft = babModel.getMaximumSeconds() ;
preIppSolver = babSolver->clone() ;
OsiSolverInterface *ippSolver ;
# if CBC_TRACK_SOLVERS > 0
std::cout
<< "doBaCParam: clone made prior to IPP is "
<< std::hex << preIppSolver << std::dec
<< ", log level " << preIppSolver->messageHandler()->logLevel()
<< "." << std::endl ;
# endif
preIppSolver->setHintParam(OsiDoInBranchAndCut, true, OsiHintDo) ;
ippObj.messageHandler()->setLogLevel(babModel.logLevel()) ;
CglProbing probingGen ;
probingGen.setUsingObjective(true) ;
probingGen.setMaxPass(3) ;
probingGen.setMaxProbeRoot(preIppSolver->getNumCols()) ;
probingGen.setMaxElements(100) ;
probingGen.setMaxLookRoot(50) ;
probingGen.setRowCuts(3) ;
ippObj.addCutGenerator(&probingGen) ;
/*
For preProcessNonDefault, the 2nd parameter controls the conversion of
clique and SOS constraints. 0 does nothing, -1 converts <= to ==, and
2 and 3 form SOS sets under strict and not-so-strict conditions,
respectively.
*/
int convert = 0 ;
if (ippAction == CbcGenCtlBlk::IPPEqual) {
convert = -1 ;
} else if (ippAction == CbcGenCtlBlk::IPPEqualAll) {
convert = -2 ;
} else if (ippAction == CbcGenCtlBlk::IPPSOS) {
convert = 2 ;
} else if (ippAction == CbcGenCtlBlk::IPPTrySOS) {
convert = 3 ;
}
ippSolver = ippObj.preProcessNonDefault(*preIppSolver, convert, 10) ;
# if CBC_TRACK_SOLVERS > 0
std::cout
<< "doBaCParam: solver returned from IPP is "
<< std::hex << ippSolver << std::dec ;
if (ippSolver) {
std::cout
<< ", log level " << ippSolver->messageHandler()->logLevel() ;
}
std::cout << "." << std::endl ;
# endif
/*
ippSolver == 0 is success of a sort --- integer preprocess has found the
problem to be infeasible or unbounded. Need to think about how to indicate
status.
*/
if (!ippSolver) {
std::cout
<< "Integer preprocess says infeasible or unbounded" << std::endl ;
delete preIppSolver ;
ctlBlk->setBaBStatus(&babModel, CbcGenCtlBlk::BACwIPP) ;
return (0) ;
}
# if COIN_CBC_VERBOSITY > 0
else {
std::cout
<< "After integer preprocessing, model has "
<< ippSolver->getNumRows()
<< " rows, " << ippSolver->getNumCols() << " columns, and "
<< ippSolver->getNumElements() << " elements." << std::endl ;
}
# endif
preIppSolver->setHintParam(OsiDoInBranchAndCut, false, OsiHintDo) ;
ippSolver->setHintParam(OsiDoInBranchAndCut, false, OsiHintDo) ;
if (ippAction == CbcGenCtlBlk::IPPSave) {
ippSolver->writeMps("presolved", "mps", 1.0) ;
std::cout
<< "Integer preprocessed model written to `presolved.mps' "
<< "as minimisation problem." << std::endl ;
}
OsiSolverInterface *osiTmp = ippSolver->clone() ;
babModel.assignSolver(osiTmp) ;
babSolver = babModel.solver() ;
# if CBC_TRACK_SOLVERS > 0
std::cout
<< "doBaCParam: clone of IPP solver passed to babModel is "
<< std::hex << babSolver << std::dec
<< ", log level " << babSolver->messageHandler()->logLevel()
<< "." << std::endl ;
# endif
if (!solveRelaxation(&babModel)) {
delete preIppSolver ;
ctlBlk->setBaBStatus(&babModel, CbcGenCtlBlk::BACwIPPRelax) ;
return (0) ;
}
# if COIN_CBC_VERBOSITY > 0
std::cout
<< "doBaCParam: presolved relaxation z = "
<< babSolver->getObjValue() << "." << std::endl ;
# endif
babModel.setMaximumSeconds(timeLeft - (CoinCpuTime() - time1)) ;
didIPP = true ;
}
/*
At this point, babModel and babSolver hold the constraint system we'll use
for B&C (either the original system or the preprocessed system) and we have
a solution to the lp relaxation.
If we're using the COSTSTRATEGY option, set up priorities here and pass
them to the babModel.
*/
if (ctlBlk->priorityAction_ != CbcGenCtlBlk::BPOff) {
setupPriorities(&babModel, ctlBlk->priorityAction_) ;
}
/*
Install heuristics and cutting planes.
*/
installHeuristics(ctlBlk, &babModel) ;
installCutGenerators(ctlBlk, &babModel) ;
/*
Set up status print frequency for babModel.
*/
if (babModel.getNumCols() > 2000 || babModel.getNumRows() > 1500 ||
babModel.messageHandler()->logLevel() > 1)
babModel.setPrintFrequency(100) ;
/*
If we've read in a known good solution for debugging, activate the row cut
debugger.
*/
if (ctlBlk->debugSol_.values_) {
if (ctlBlk->debugSol_.numCols_ == babModel.getNumCols()) {
babSolver->activateRowCutDebugger(ctlBlk->debugSol_.values_) ;
} else {
std::cout
<< "doBaCParam: debug file has incorrect number of columns."
<< std::endl ;
}
}
/*
Set ratio-based integrality gap, if specified by user.
*/
if (ctlBlk->setByUser_[CbcCbcParam::GAPRATIO] == true) {
double obj = babSolver->getObjValue() ;
double gapRatio = babModel.getDblParam(CbcModel::CbcAllowableFractionGap) ;
double gap = gapRatio * (1.0e-5 + fabs(obj)) ;
babModel.setAllowableGap(gap) ;
std::cout
<< "doBaCParam: Continuous objective = " << obj
<< ", so allowable gap set to " << gap << std::endl ;
}
/*
A bit of mystery code. As best I can figure, setSpecialOptions(2) suppresses
the removal of warm start information when checkSolution runs an lp to check
a solution. John's comment, ``probably faster to use a basis to get integer
solutions'' makes some sense in this context. Didn't try to track down
moreMipOptions just yet.
*/
babModel.setSpecialOptions(babModel.specialOptions() | 2) ;
/*
{ int ndx = whichParam(MOREMIPOPTIONS,numberParameters,parameters) ;
int moreMipOptions = parameters[ndx].intValue() ;
if (moreMipOptions >= 0)
{ printf("more mip options %d\n",moreMipOptions);
babModel.setSearchStrategy(moreMipOptions); } }
*/
/*
Begin the final run-up to branch-and-cut.
Make sure that objects are set up in the solver. It's possible that whoever
loaded the model into the solver also set up objects. But it's also
entirely likely that none exist to this point (and interesting to note that
IPP doesn't need to know anything about objects).
*/
setupObjects(babSolver, didIPP, &ippObj) ;
/*
Set the branching method. We can't do this until we establish objects,
because the constructor will set up arrays based on the number of objects,
and there's no provision to set this information after creation. Arguably not
good --- it'd be nice to set this in the prototype model that's cloned for
this routine. In CoinSolve, shadowPriceMode is handled with the TESTOSI
option.
*/
OsiChooseStrong strong(babSolver) ;
strong.setNumberBeforeTrusted(babModel.numberBeforeTrust()) ;
strong.setNumberStrong(babModel.numberStrong()) ;
strong.setShadowPriceMode(ctlBlk->chooseStrong_.shadowPriceMode_) ;
CbcBranchDefaultDecision decision ;
decision.setChooseMethod(strong) ;
babModel.setBranchingMethod(decision) ;
/*
Here I've deleted a huge block of code that deals with external priorities,
branch direction, pseudocosts, and solution. (PRIORITYIN) Also a block of
code that generates C++ code.
*/
/*
Set up strategy for branch-and-cut. Note that the integer code supplied to
setupPreProcessing is *not* compatible with the IPPAction enum. But at least
it's documented. See desiredPreProcess_ in CbcStrategyDefault. `1' is
accidentally equivalent to IPPOn.
*/
if (ippAction == CbcGenCtlBlk::IPPStrategy) {
CbcStrategyDefault strategy(true, 5, 5) ;
strategy.setupPreProcessing(1) ;
babModel.setStrategy(strategy) ;
}
/*
Yes! At long last, we're ready for the big call. Do branch and cut. In
general, the solver used to return the solution will not be the solver we
passed in, so reset babSolver here.
*/
int statistics = (ctlBlk->printOpt_ > 0) ? ctlBlk->printOpt_ : 0 ;
# if CBC_TRACK_SOLVERS > 0
std::cout
<< "doBaCParam: solver at call to branchAndBound is "
<< std::hex << babModel.solver() << std::dec
<< ", log level " << babModel.solver()->messageHandler()->logLevel()
<< "." << std::endl ;
# endif
babModel.branchAndBound(statistics) ;
babSolver = babModel.solver() ;
# if CBC_TRACK_SOLVERS > 0
std::cout
<< "doBaCParam: solver at return from branchAndBound is "
<< std::hex << babModel.solver() << std::dec
<< ", log level " << babModel.solver()->messageHandler()->logLevel()
<< "." << std::endl ;
# endif
/*
Write out solution to preprocessed model.
*/
if (ctlBlk->debugCreate_ == "createAfterPre" &&
babModel.bestSolution()) {
CbcGenParamUtils::saveSolution(babSolver, "debug.file") ;
}
/*
Print some information about branch-and-cut.
*/
# if COIN_CBC_VERBOSITY > 0
std::cout
<< "Cuts at root node changed objective from "
<< babModel.getContinuousObjective()
<< " to " << babModel.rootObjectiveAfterCuts() << std::endl ;
for (int iGen = 0 ; iGen < babModel.numberCutGenerators() ; iGen++) {
CbcCutGenerator *generator = babModel.cutGenerator(iGen) ;
std::cout
<< generator->cutGeneratorName() << " was tried "
<< generator->numberTimesEntered() << " times and created "
<< generator->numberCutsInTotal() << " cuts of which "
<< generator->numberCutsActive()
<< " were active after adding rounds of cuts" ;
if (generator->timing()) {
std::cout << " ( " << generator->timeInCutGenerator() << " seconds)" ;
}
std::cout << std::endl ;
}
# endif
time2 = CoinCpuTime();
ctlBlk->totalTime_ += time2 - time1;
/*
If we performed integer preprocessing, time to back it out.
*/
if (ippAction != CbcGenCtlBlk::IPPOff) {
# if CBC_TRACK_SOLVERS > 0
std::cout
<< "doBaCParam: solver passed to IPP postprocess is "
<< std::hex << babSolver << std::dec << "." << std::endl ;
# endif
ippObj.postProcess(*babSolver);
babModel.assignSolver(preIppSolver) ;
babSolver = babModel.solver() ;
# if CBC_TRACK_SOLVERS > 0
std::cout
<< "doBaCParam: solver in babModel after IPP postprocess is "
<< std::hex << babSolver << std::dec << "." << std::endl ;
# endif
}
/*
Write out postprocessed solution to debug file, if requested.
*/
if (ctlBlk->debugCreate_ == "create" && babModel.bestSolution()) {
CbcGenParamUtils::saveSolution(babSolver, "debug.file") ;
}
/*
If we have a good solution, detach the solver with the answer. Fill in the
rest of the status information for the benefit of the wider world.
*/
bool keepAnswerSolver = false ;
OsiSolverInterface *answerSolver = 0 ;
if (babModel.bestSolution()) {
babModel.setModelOwnsSolver(false) ;
keepAnswerSolver = true ;
answerSolver = babSolver ;
}
ctlBlk->setBaBStatus(&babModel, CbcGenCtlBlk::BACwBAC,
keepAnswerSolver, answerSolver) ;
/*
And one last bit of information & statistics.
*/
ctlBlk->printBaBStatus() ;
std::cout << " " ;
if (keepAnswerSolver) {
std::cout
<< "objective " << babModel.getObjValue() << "; " ;
}
std::cout
<< babModel.getNodeCount() << " nodes and "
<< babModel.getIterationCount() << " iterations - took "
<< time2 - time1 << " seconds" << std::endl ;
return (0) ;
}
