//-------------------------------------------------------------------
// Constructor from solver
//-------------------------------------------------------------------
OsiSolverResult::OsiSolverResult(const OsiSolverInterface &solver, const double *lowerBefore,
const double *upperBefore)
: objectiveValue_(COIN_DBL_MAX)
, primalSolution_(NULL)
, dualSolution_(NULL)
{
if (solver.isProvenOptimal() && !solver.isDualObjectiveLimitReached()) {
objectiveValue_ = solver.getObjValue() * solver.getObjSense();
CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver.getWarmStart());
assert(basis);
basis_ = *basis;
delete basis;
int numberRows = basis_.getNumArtificial();
int numberColumns = basis_.getNumStructural();
assert(numberColumns == solver.getNumCols());
assert(numberRows == solver.getNumRows());
primalSolution_ = CoinCopyOfArray(solver.getColSolution(), numberColumns);
dualSolution_ = CoinCopyOfArray(solver.getRowPrice(), numberRows);
fixed_.addBranch(-1, numberColumns, lowerBefore, solver.getColLower(),
upperBefore, solver.getColUpper());
}
}
int main( int argc, char **argv )
{
if ( argc < 2 )
{
printf("Invalid number of parameters!\n");
exit( EXIT_FAILURE );
}
char problemName[ 256 ];
getFileName( problemName, argv[1] );
clock_t start = clock();
OsiClpSolverInterface *realSolver = new OsiClpSolverInterface();
realSolver->getModelPtr()->setPerturbation(50); /* makes CLP faster for hard instances */
OsiSolverInterface *solver = (OsiSolverInterface*) realSolver;
parseParameters( argc, argv );
readLP( solver, argv[1] );
FILE *log = NULL;
if(!output.empty())
{
log = fopen(output.c_str(), "a");
if(!log)
{
printf("Could not open the file!\n");
exit(EXIT_FAILURE);
}
}
const int numCols = solver->getNumCols(), numRows = solver->getNumRows();
int pass = 0, newCuts = 0, totalCuts = 0;
double pTime, opt, cgTime;
CGraph *cgraph = NULL;
if(sepMethod == Npsep)
cgraph = build_cgraph_osi( solver );
if(!optFile.empty())
{
getOptimals();
if(optimals.find(problemName) == optimals.end())
{
fprintf(stderr, "ERROR: optimal value not found!\n");
exit(EXIT_FAILURE);
}
opt = optimals[problemName];
}
solver->initialSolve();
if (!solver->isProvenOptimal())
{
if (solver->isAbandoned())
{
fprintf( stderr, "LP solver abandoned due to numerical dificulties.\n" );
exit( EXIT_FAILURE );
}
if (solver->isProvenPrimalInfeasible())
{
fprintf( stderr, "LP solver says PRIMAL INFEASIBLE.\n" );
exit( EXIT_FAILURE );
}
if (solver->isProvenDualInfeasible())
{
fprintf( stderr, "LP solver says DUAL INFEASIBLE.\n" );
exit( EXIT_FAILURE );
}
if (solver->isPrimalObjectiveLimitReached())
{
fprintf( stderr, "LP solver says isPrimalObjectiveLimitReached.\n" );
exit( EXIT_FAILURE );
}
if (solver->isDualObjectiveLimitReached())
{
fprintf( stderr, "LP solver says isDualObjectiveLimitReached.\n" );
exit( EXIT_FAILURE );
}
if (solver->isIterationLimitReached())
{
fprintf( stderr, "LP solver says isIterationLimitReached.\n" );
exit( EXIT_FAILURE );
}
fprintf( stderr, "ERROR: Could not solve LP relaxation to optimality. Checking status...\n" );
exit( EXIT_FAILURE );
}
double initialBound = solver->getObjValue();
printf("%.2lf %d %d %.7lf", ((double)(clock()-start)) / ((double)CLOCKS_PER_SEC), pass, 0, solver->getObjValue());
if(!optFile.empty())
{
printf(" %.7lf %.7lf", opt, abs_mip_gap(solver->getObjValue(), opt));
}
printf("\n");
do
{
clock_t startSep = clock();
newCuts = 0;
switch (sepMethod)
{
case Npsep:
{
CglEClique cliqueGen;
OsiCuts cuts;
CglTreeInfo info;
info.level = 0;
info.pass = 1;
vector<string> varNames = getVarNames(solver->getColNames(), numCols);
cliqueGen.parseParameters( argc, (const char**)argv );
cliqueGen.setCGraph( cgraph );
cliqueGen.setGenOddHoles( true ); //allow (or not) inserting odd hole cuts
cliqueGen.colNames = &varNames;
cliqueGen.generateCuts( *solver, cuts, info );
newCuts = cuts.sizeCuts();
solver->applyCuts( cuts );
}
break;
case CglSepM:
{
CglClique cliqueGen;
OsiCuts cuts;
CglTreeInfo info;
info.level = 0;
info.pass = 1;
cliqueGen.setMinViolation( MIN_VIOLATION );
cliqueGen.setStarCliqueReport(false);
cliqueGen.setRowCliqueReport(false);
cliqueGen.generateCuts( *solver, cuts, info );
newCuts = cuts.sizeCuts();
solver->applyCuts( cuts );
}
break;
Default:
{
fprintf( stderr, "Separation Method does not recognized!\n" );
exit( EXIT_FAILURE );
}
}
pTime = ((double)(clock()-start)) / ((double)CLOCKS_PER_SEC);
if(pTime > MAX_TIME) break;
totalCuts += newCuts;
++pass;
if (newCuts)
{
solver->resolve();
if (!solver->isProvenOptimal())
{
if (solver->isAbandoned())
{
fprintf( stderr, "LP solver abandoned due to numerical dificulties.\n" );
exit( EXIT_FAILURE );
}
if (solver->isProvenPrimalInfeasible())
{
fprintf( stderr, "LP solver says PRIMAL INFEASIBLE.\n" );
exit( EXIT_FAILURE );
}
if (solver->isProvenDualInfeasible())
{
fprintf( stderr, "LP solver says DUAL INFEASIBLE.\n" );
exit( EXIT_FAILURE );
}
if (solver->isPrimalObjectiveLimitReached())
{
fprintf( stderr, "LP solver says isPrimalObjectiveLimitReached.\n" );
exit( EXIT_FAILURE );
}
if (solver->isDualObjectiveLimitReached())
{
fprintf( stderr, "LP solver says isDualObjectiveLimitReached.\n" );
exit( EXIT_FAILURE );
}
if (solver->isIterationLimitReached())
{
fprintf( stderr, "LP solver says isIterationLimitReached.\n" );
exit( EXIT_FAILURE );
}
fprintf( stderr, "ERROR: Could not solve LP relaxation. Exiting.\n" );
exit( EXIT_FAILURE );
}
pTime = ((double)(clock()-start)) / ((double)CLOCKS_PER_SEC);
if(pTime > MAX_TIME) break;
double sepTime = ((double)(clock()-startSep)) / ((double)CLOCKS_PER_SEC);
printf("%.2lf %d %d %.7lf", sepTime, pass, newCuts, solver->getObjValue());
if(!optFile.empty())
printf(" %.7lf %.7lf", opt, abs_mip_gap(solver->getObjValue(), opt));
printf("\n");
}
}
while ( (newCuts>0) && (pass<MAX_PASSES) ) ;
if(log)
{
double totalTime = ((double)(clock()-start)) / ((double)CLOCKS_PER_SEC);
fprintf(log, "%s %.2lf %d %d %.7lf", problemName, totalTime, pass - 1, totalCuts, solver->getObjValue());
if(!optFile.empty())
fprintf(log, " %.7lf", abs_mip_gap(solver->getObjValue(), opt));
fprintf(log, "\n");
}
if(cgraph)
cgraph_free( &cgraph );
delete realSolver;
return EXIT_SUCCESS;
}
// Generate cuts
void
CglFakeClique::generateCuts(const OsiSolverInterface& si, OsiCuts & cs,
const CglTreeInfo info)
{
if (fakeSolver_) {
assert (si.getNumCols()==fakeSolver_->getNumCols());
fakeSolver_->setColLower(si.getColLower());
const double * solution = si.getColSolution();
fakeSolver_->setColSolution(solution);
fakeSolver_->setColUpper(si.getColUpper());
// get and set branch and bound cutoff
double cutoff;
si.getDblParam(OsiDualObjectiveLimit,cutoff);
fakeSolver_->setDblParam(OsiDualObjectiveLimit,COIN_DBL_MAX);
#ifdef COIN_HAS_CLP
OsiClpSolverInterface * clpSolver
= dynamic_cast<OsiClpSolverInterface *> (fakeSolver_);
if (clpSolver) {
// fix up fake solver
const ClpSimplex * siSimplex = clpSolver->getModelPtr();
// need to set djs
memcpy(siSimplex->primalColumnSolution(),
si.getReducedCost(),si.getNumCols()*sizeof(double));
fakeSolver_->setDblParam(OsiDualObjectiveLimit,cutoff);
}
#endif
const CoinPackedMatrix * matrixByRow = si.getMatrixByRow();
const double * elementByRow = matrixByRow->getElements();
const int * column = matrixByRow->getIndices();
const CoinBigIndex * rowStart = matrixByRow->getVectorStarts();
const int * rowLength = matrixByRow->getVectorLengths();
const double * rowUpper = si.getRowUpper();
const double * rowLower = si.getRowLower();
// Scan all rows looking for possibles
int numberRows = si.getNumRows();
double tolerance = 1.0e-3;
for (int iRow=0;iRow<numberRows;iRow++) {
CoinBigIndex start = rowStart[iRow];
CoinBigIndex end = start + rowLength[iRow];
double upRhs = rowUpper[iRow];
double loRhs = rowLower[iRow];
double sum = 0.0;
for (CoinBigIndex j=start;j<end;j++) {
int iColumn=column[j];
double value = elementByRow[j];
sum += solution[iColumn]*value;
}
if (sum<loRhs-tolerance||sum>upRhs+tolerance) {
// add as cut
OsiRowCut rc;
rc.setLb(loRhs);
rc.setUb(upRhs);
rc.setRow(end-start,column+start,elementByRow+start,false);
CoinAbsFltEq equal(1.0e-12);
cs.insertIfNotDuplicate(rc,equal);
}
}
CglClique::generateCuts(*fakeSolver_,cs,info);
if (probing_) {
probing_->generateCuts(*fakeSolver_,cs,info);
}
} else {
// just use real solver
CglClique::generateCuts(si,cs,info);
}
}
// Create a list of rows which might yield cuts
// The possible parameter is a list to cut down search
void CglOddHole::createRowList( const OsiSolverInterface & si,
const int * possible)
{
// Get basic problem information
int nRows=si.getNumRows();
const CoinPackedMatrix * rowCopy = si.getMatrixByRow();
const int * column = rowCopy->getIndices();
const CoinBigIndex * rowStart = rowCopy->getVectorStarts();
const int * rowLength = rowCopy->getVectorLengths();
int rowIndex;
delete [] suitableRows_;
numberRows_=nRows;
const double * rowElements = rowCopy->getElements();
const double * rowupper = si.getRowUpper();
const double * rowlower = si.getRowLower();
const double * collower = si.getColLower();
const double * colupper = si.getColUpper();
suitableRows_=new int[nRows];
if (possible) {
memcpy(suitableRows_,possible,nRows*sizeof(int));
} else {
int i;
for (i=0;i<nRows;i++) {
suitableRows_[i]=1;
}
}
for (rowIndex=0; rowIndex<nRows; rowIndex++){
double rhs1=rowupper[rowIndex];
double rhs2=rowlower[rowIndex];
if (suitableRows_[rowIndex]) {
int i;
bool goodRow=true;
for (i=rowStart[rowIndex];
i<rowStart[rowIndex]+rowLength[rowIndex];i++) {
int thisCol=column[i];
if (colupper[thisCol]-collower[thisCol]>epsilon_) {
// could allow general integer variables but unlikely
if (!si.isBinary(thisCol) ) {
goodRow=false;
break;
}
if (fabs(rowElements[i]-1.0)>epsilon_) {
goodRow=false;
break;
}
} else {
rhs1 -= collower[thisCol]*rowElements[i];
rhs2 -= collower[thisCol]*rowElements[i];
}
}
if (fabs(rhs1-1.0)>epsilon_&&fabs(rhs2-1.0)>epsilon_) {
goodRow=false;
}
if (goodRow) {
suitableRows_[rowIndex]=1;
} else {
suitableRows_[rowIndex]=0;
}
}
}
}
//-------------------------------------------------------------------------------
// Generate three cycle cuts
//-------------------------------------------------------------------
void CglOddHole::generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
const CglTreeInfo info)
{
// Get basic problem information
int nRows=si.getNumRows();
int nCols=si.getNumCols();
const CoinPackedMatrix * rowCopy = si.getMatrixByRow();
// Could do cliques and extra OSL cliques
// For moment just easy ones
// If no information exists then get a list of suitable rows
// If it does then suitable rows are subset of information
CglOddHole temp;
int * checkRow = new int[nRows];
int i;
if (!suitableRows_) {
for (i=0;i<nRows;i++) {
checkRow[i]=1;
}
} else {
// initialize and extend rows to current size
memset(checkRow,0,nRows*sizeof(int));
memcpy(checkRow,suitableRows_,CoinMin(nRows,numberRows_)*sizeof(int));
}
temp.createRowList(si,checkRow);
// now cut down further by only allowing rows with fractional solution
double * solution = new double[nCols];
memcpy(solution,si.getColSolution(),nCols*sizeof(double));
const int * column = rowCopy->getIndices();
const CoinBigIndex * rowStart = rowCopy->getVectorStarts();
const int * rowLength = rowCopy->getVectorLengths();
const double * collower = si.getColLower();
const double * colupper = si.getColUpper();
int * suitable = temp.suitableRows_;
// At present I am using new and delete as easier to see arrays in debugger
int * fixed = new int[nCols]; // mark fixed columns
for (i=0;i<nCols;i++) {
if (si.isBinary(i) ) {
fixed[i]=0;
if (colupper[i]-collower[i]<epsilon_) {
solution[i]=0.0;
fixed[i]=2;
} else if (solution[i]<epsilon_) {
solution[i]=0.0;
fixed[i]=-1;
} else if (solution[i]>onetol_) {
solution[i]=1.0;
fixed[i]=+1;
}
} else {
//mark as fixed even if not (can not intersect any interesting rows)
solution[i]=0.0;
fixed[i]=3;
}
}
// first do packed
const double * rowlower = si.getRowLower();
const double * rowupper = si.getRowUpper();
for (i=0;i<nRows;i++) {
if (suitable[i]) {
int k;
double sum=0.0;
if (rowupper[i]>1.001) suitable[i]=-1;
for (k=rowStart[i]; k<rowStart[i]+rowLength[i];k++) {
int icol=column[k];
if (!fixed[icol]) sum += solution[icol];
}
if (sum<0.9) suitable[i]=-1; //say no good
}
}
#ifdef CGL_DEBUG
const OsiRowCutDebugger * debugger = si.getRowCutDebugger();
if (debugger&&!debugger->onOptimalPath(si))
debugger = NULL;
#else
const OsiRowCutDebugger * debugger = NULL;
#endif
temp.generateCuts(debugger, *rowCopy,solution,
si.getReducedCost(),cs,suitable,fixed,info,true);
// now cover
//if no >= then skip
bool doCover=false;
int nsuitable=0;
for (i=0;i<nRows;i++) {
suitable[i]=abs(suitable[i]);
if (suitable[i]) {
int k;
double sum=0.0;
if (rowlower[i]<0.999) sum=2.0;
if (rowupper[i]>1.001) doCover=true;
for (k=rowStart[i]; k<rowStart[i]+rowLength[i];k++) {
int icol=column[k];
if (!fixed[icol]) sum += solution[icol];
if (fixed[icol]==1) sum=2.0; //don't use if any at 1
}
if (sum>1.1) {
suitable[i]=-1; //say no good
} else {
nsuitable++;
}
}
}
if (doCover&&nsuitable)
temp.generateCuts(debugger, *rowCopy,solution,si.getReducedCost(),
cs,suitable,fixed,info,false);
delete [] checkRow;
delete [] solution;
delete [] fixed;
}
void ModelDiscrete(const char * const name)
{
// example of direct interfaces for discrete distribution
OsiClpSolverInterface *osiClp1 = new OsiClpSolverInterface();
double INF=osiClp1->getInfinity();
/* Model dimensions */
int nels=44; // ncol=27, nrow=9
/* Sparse matrix data...organized by row */
int mrow[]={ 0, 0, 0, 0, 0,
1, 1, 1, 1,
2, 2, 2,
3, 3, 3, 3, 3,
4, 4, 4, 4,
5, 5, 5, 5, 5, 5,
6, 6, 6, 6, 6,
7, 7, 7, 7, 7, 7,
8, 8, 8, 8, 8, 8 };
int mcol[]={ 0, 1, 2, 3, 4,
5, 6, 7, 8,
9,10, 11,
12, 13, 14, 15, 16,
0, 12, 17, 18,
1, 5, 9, 13, 19, 20,
2, 6, 14, 21, 22,
3, 7, 10, 15, 23, 24,
4, 8, 11, 16, 25, 26 };
double dels[] = { 1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0,
16.0, 9.0, -1.0, 1.0,
15.0, 10.0, 5.0, 11.0, -1.0, 1.0,
28.0, 14.0, 22.0, -1.0, 1.0,
23.0, 15.0, 7.0, 17.0, -1.0, 1.0,
81.0, 57.0, 29.0, 55.0, -1.0, 1.0 };
/* Objective */
/* Objective */
double dobj[]={ 18.0, 21.0, 18.0, 16.0, 10.0, 15.0, 16.0, 14.0, 9.0,
10.0, 9.0, 6.0, 17.0, 16.0, 17.0, 15.0, 10.0, 0.0,
13.0, 0.0, 13.0, 0.0, 7.0, 0.0, 7.0, 0.0, 1.0 };
/* Column bounds */
double dclo[]={ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
double dcup[]={ INF, INF, INF, INF, INF, INF, INF, INF, INF,
INF, INF, INF, INF, INF, INF, INF, INF, INF,
INF, INF, INF, INF, INF, INF, INF, INF, INF };
/* Row bounds */
double drlo[]={ -INF, -INF, -INF, -INF, 0.0, 4.0, 0.0, 8.0, 10.0 };
double drup[]={ 10.0, 19.0, 25.0, 15.0, 0.0, 7.0, 0.0, 8.0, 90.0 };
/* Stages */
int nstg=2;
int n_first_stg_rows=4;
int rstg[]={ 0,0,0,0,1,1,1,1,1 };
int cstg[]={ 0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,1,
1,1,1,1,1,1,1,1,1 };
/* Stochastic data */
int nindp=5;
int nsamp[]={ 5, 2, 5, 5, 3 };
double demand[]={ 200, 220, 250, 270, 300,
50, 150,
140, 160, 180, 200, 220,
10, 50, 80, 100, 340,
580, 600, 620 };
double dprobs[]={ 0.2, 0.05, 0.35, 0.2, 0.2,
0.3, 0.7,
0.1, 0.2, 0.4, 0.2, 0.1,
0.2, 0.2, 0.3, 0.2, 0.1,
0.1, 0.8, 0.1 };
/* local variables */
int ii,jj;
// initialize SmiModel
SmiScnModel *smiModel = new SmiScnModel();
smiModel->setOsiSolverHandle(*osiClp1);
// set core model using Osi interface
OsiClpSolverInterface ocsi;
ocsi.loadProblem(CoinPackedMatrix( 1,mrow,mcol,dels,nels),dclo,dcup,dobj,drlo,drup);
// core model
SmiCoreData *smiCore = new SmiCoreData(&ocsi,nstg,cstg,rstg);
cout << "ModelDiscrete: generated Core data" << endl;
// Create discrete distribution
SmiDiscreteDistribution *smiDD = new SmiDiscreteDistribution(smiCore);
cout << "ModelDiscrete: adding random variables" << endl;
int index=0;
for (jj=0;jj<nindp;jj++)
{
SmiDiscreteRV *smiRV = new SmiDiscreteRV(1);
for (ii=0;ii<nsamp[jj];ii++)
{
CoinPackedVector empty_vec;
CoinPackedMatrix empty_mat;
CoinPackedVector cpv_rlo ;
CoinPackedVector cpv_rup ;
cpv_rlo.insert(n_first_stg_rows + jj, demand[index+ii]);
cpv_rup.insert(n_first_stg_rows + jj, demand[index+ii]);
smiRV->addEvent(empty_mat,empty_vec,empty_vec,empty_vec,cpv_rlo,cpv_rup,dprobs[index+ii]);
cpv_rlo.clear();
cpv_rup.clear();
}
smiDD->addDiscreteRV(smiRV);
index+=nsamp[jj];
}
assert(smiDD->getNumRV() == nindp);
cout << "ModelDiscrete: added " << nindp << " random variables" << endl;
cout << "ModelDiscrete: processing into scenarios" << endl;
smiModel->processDiscreteDistributionIntoScenarios(smiDD);
// load problem data into OsiSolver
smiModel->loadOsiSolverData();
// get Osi pointer
OsiSolverInterface *smiOsi = smiModel->getOsiSolverInterface();
// set some parameters
smiOsi->setHintParam(OsiDoPresolveInInitial,true);
smiOsi->setHintParam(OsiDoScale,true);
smiOsi->setHintParam(OsiDoCrash,true);
// solve using Osi Solver
smiOsi->initialSolve();
// test optimal value
assert(fabs(smiOsi->getObjValue()-1566.042)<0.01);
// test solutions
const double *dsoln = smiOsi->getColSolution();
double objSum = 0.0;
/* The canonical way to traverse the tree:
For each scenario, get the leaf node.
Then get the parent. Repeat until parent is NULL.
(Only the root node has a NULL parent.)
*/
for(int is=0; is<smiModel->getNumScenarios(); ++is)
{
/* this loop calculates the scenario objective value */
double scenSum = 0.0;
// start with leaf node
SmiScnNode *node = smiModel->getLeafNode(is);
// leaf node probability is the scenario probability
double scenprob = node->getModelProb();
while (node != NULL)
{
// getColStart returns the starting index of node in OSI model
for(int j=node->getColStart(); j<node->getColStart()+node->getNumCols(); ++j)
{
// getCoreColIndex returns the corresponding Core index
// in the original (user's) ordering
scenSum += dobj[node->getCoreColIndex(j)]*dsoln[j];
}
// get parent of node
node = node->getParent();
}
objSum += scenSum*scenprob;
}
assert(fabs(smiOsi->getObjValue()-objSum) < 0.01);
// print results
printf("Solved stochastic program %s\n", name);
printf("Number of rows: %d\n",smiOsi->getNumRows());
printf("Number of cols: %d\n",smiOsi->getNumCols());
printf("Optimal value: %g\n",smiOsi->getObjValue());
}
int * analyze(OsiClpSolverInterface * solverMod, int & numberChanged,
double & increment, bool changeInt,
CoinMessageHandler * generalMessageHandler, bool noPrinting)
{
bool noPrinting_ = noPrinting;
OsiSolverInterface * solver = solverMod->clone();
char generalPrint[200];
if (0) {
// just get increment
CbcModel model(*solver);
model.analyzeObjective();
double increment2 = model.getCutoffIncrement();
printf("initial cutoff increment %g\n", increment2);
}
const double *objective = solver->getObjCoefficients() ;
const double *lower = solver->getColLower() ;
const double *upper = solver->getColUpper() ;
int numberColumns = solver->getNumCols() ;
int numberRows = solver->getNumRows();
double direction = solver->getObjSense();
int iRow, iColumn;
// Row copy
CoinPackedMatrix matrixByRow(*solver->getMatrixByRow());
const double * elementByRow = matrixByRow.getElements();
const int * column = matrixByRow.getIndices();
const CoinBigIndex * rowStart = matrixByRow.getVectorStarts();
const int * rowLength = matrixByRow.getVectorLengths();
// Column copy
CoinPackedMatrix matrixByCol(*solver->getMatrixByCol());
const double * element = matrixByCol.getElements();
const int * row = matrixByCol.getIndices();
const CoinBigIndex * columnStart = matrixByCol.getVectorStarts();
const int * columnLength = matrixByCol.getVectorLengths();
const double * rowLower = solver->getRowLower();
const double * rowUpper = solver->getRowUpper();
char * ignore = new char [numberRows];
int * changed = new int[numberColumns];
int * which = new int[numberRows];
double * changeRhs = new double[numberRows];
memset(changeRhs, 0, numberRows*sizeof(double));
memset(ignore, 0, numberRows);
numberChanged = 0;
int numberInteger = 0;
for (iColumn = 0; iColumn < numberColumns; iColumn++) {
if (upper[iColumn] > lower[iColumn] + 1.0e-8 && solver->isInteger(iColumn))
numberInteger++;
}
bool finished = false;
while (!finished) {
int saveNumberChanged = numberChanged;
for (iRow = 0; iRow < numberRows; iRow++) {
int numberContinuous = 0;
double value1 = 0.0, value2 = 0.0;
bool allIntegerCoeff = true;
double sumFixed = 0.0;
int jColumn1 = -1, jColumn2 = -1;
for (CoinBigIndex j = rowStart[iRow]; j < rowStart[iRow] + rowLength[iRow]; j++) {
int jColumn = column[j];
double value = elementByRow[j];
if (upper[jColumn] > lower[jColumn] + 1.0e-8) {
if (!solver->isInteger(jColumn)) {
if (numberContinuous == 0) {
jColumn1 = jColumn;
value1 = value;
} else {
jColumn2 = jColumn;
value2 = value;
}
numberContinuous++;
} else {
if (fabs(value - floor(value + 0.5)) > 1.0e-12)
allIntegerCoeff = false;
}
} else {
sumFixed += lower[jColumn] * value;
}
}
double low = rowLower[iRow];
if (low > -1.0e20) {
low -= sumFixed;
if (fabs(low - floor(low + 0.5)) > 1.0e-12)
allIntegerCoeff = false;
}
double up = rowUpper[iRow];
if (up < 1.0e20) {
up -= sumFixed;
if (fabs(up - floor(up + 0.5)) > 1.0e-12)
allIntegerCoeff = false;
}
if (!allIntegerCoeff)
continue; // can't do
if (numberContinuous == 1) {
// see if really integer
// This does not allow for complicated cases
if (low == up) {
if (fabs(value1) > 1.0e-3) {
value1 = 1.0 / value1;
if (fabs(value1 - floor(value1 + 0.5)) < 1.0e-12) {
// integer
changed[numberChanged++] = jColumn1;
solver->setInteger(jColumn1);
if (upper[jColumn1] > 1.0e20)
solver->setColUpper(jColumn1, 1.0e20);
if (lower[jColumn1] < -1.0e20)
solver->setColLower(jColumn1, -1.0e20);
}
}
} else {
if (fabs(value1) > 1.0e-3) {
value1 = 1.0 / value1;
if (fabs(value1 - floor(value1 + 0.5)) < 1.0e-12) {
// This constraint will not stop it being integer
ignore[iRow] = 1;
}
}
}
} else if (numberContinuous == 2) {
if (low == up) {
/* need general theory - for now just look at 2 cases -
1 - +- 1 one in column and just costs i.e. matching objective
2 - +- 1 two in column but feeds into G/L row which will try and minimize
*/
if (fabs(value1) == 1.0 && value1*value2 == -1.0 && !lower[jColumn1]
&& !lower[jColumn2]) {
int n = 0;
int i;
double objChange = direction * (objective[jColumn1] + objective[jColumn2]);
double bound = CoinMin(upper[jColumn1], upper[jColumn2]);
bound = CoinMin(bound, 1.0e20);
for ( i = columnStart[jColumn1]; i < columnStart[jColumn1] + columnLength[jColumn1]; i++) {
int jRow = row[i];
double value = element[i];
if (jRow != iRow) {
which[n++] = jRow;
changeRhs[jRow] = value;
}
}
for ( i = columnStart[jColumn1]; i < columnStart[jColumn1] + columnLength[jColumn1]; i++) {
int jRow = row[i];
double value = element[i];
if (jRow != iRow) {
if (!changeRhs[jRow]) {
which[n++] = jRow;
changeRhs[jRow] = value;
} else {
changeRhs[jRow] += value;
}
}
}
if (objChange >= 0.0) {
// see if all rows OK
bool good = true;
for (i = 0; i < n; i++) {
int jRow = which[i];
double value = changeRhs[jRow];
if (value) {
value *= bound;
if (rowLength[jRow] == 1) {
if (value > 0.0) {
double rhs = rowLower[jRow];
if (rhs > 0.0) {
double ratio = rhs / value;
if (fabs(ratio - floor(ratio + 0.5)) > 1.0e-12)
good = false;
}
} else {
double rhs = rowUpper[jRow];
if (rhs < 0.0) {
double ratio = rhs / value;
if (fabs(ratio - floor(ratio + 0.5)) > 1.0e-12)
good = false;
}
}
} else if (rowLength[jRow] == 2) {
if (value > 0.0) {
if (rowLower[jRow] > -1.0e20)
good = false;
} else {
if (rowUpper[jRow] < 1.0e20)
good = false;
}
} else {
good = false;
}
}
}
if (good) {
// both can be integer
changed[numberChanged++] = jColumn1;
solver->setInteger(jColumn1);
if (upper[jColumn1] > 1.0e20)
solver->setColUpper(jColumn1, 1.0e20);
if (lower[jColumn1] < -1.0e20)
solver->setColLower(jColumn1, -1.0e20);
changed[numberChanged++] = jColumn2;
solver->setInteger(jColumn2);
if (upper[jColumn2] > 1.0e20)
solver->setColUpper(jColumn2, 1.0e20);
if (lower[jColumn2] < -1.0e20)
solver->setColLower(jColumn2, -1.0e20);
}
}
// clear
for (i = 0; i < n; i++) {
changeRhs[which[i]] = 0.0;
}
}
}
}
}
for (iColumn = 0; iColumn < numberColumns; iColumn++) {
if (upper[iColumn] > lower[iColumn] + 1.0e-8 && !solver->isInteger(iColumn)) {
double value;
value = upper[iColumn];
if (value < 1.0e20 && fabs(value - floor(value + 0.5)) > 1.0e-12)
continue;
value = lower[iColumn];
if (value > -1.0e20 && fabs(value - floor(value + 0.5)) > 1.0e-12)
continue;
bool integer = true;
for (CoinBigIndex j = columnStart[iColumn]; j < columnStart[iColumn] + columnLength[iColumn]; j++) {
int iRow = row[j];
if (!ignore[iRow]) {
integer = false;
break;
}
}
if (integer) {
// integer
changed[numberChanged++] = iColumn;
solver->setInteger(iColumn);
if (upper[iColumn] > 1.0e20)
solver->setColUpper(iColumn, 1.0e20);
if (lower[iColumn] < -1.0e20)
solver->setColLower(iColumn, -1.0e20);
}
}
}
finished = numberChanged == saveNumberChanged;
}
delete [] which;
delete [] changeRhs;
delete [] ignore;
//if (numberInteger&&!noPrinting_)
//printf("%d integer variables",numberInteger);
if (changeInt) {
//if (!noPrinting_) {
//if (numberChanged)
// printf(" and %d variables made integer\n",numberChanged);
//else
// printf("\n");
//}
//increment=0.0;
if (!numberChanged) {
delete [] changed;
delete solver;
return NULL;
} else {
for (iColumn = 0; iColumn < numberColumns; iColumn++) {
if (solver->isInteger(iColumn))
solverMod->setInteger(iColumn);
}
delete solver;
return changed;
}
} else {
//if (!noPrinting_) {
//if (numberChanged)
// printf(" and %d variables could be made integer\n",numberChanged);
//else
// printf("\n");
//}
// just get increment
int logLevel = generalMessageHandler->logLevel();
CbcModel model(*solver);
if (!model.defaultHandler())
model.passInMessageHandler(generalMessageHandler);
if (noPrinting_)
model.setLogLevel(0);
model.analyzeObjective();
generalMessageHandler->setLogLevel(logLevel);
double increment2 = model.getCutoffIncrement();
if (increment2 > increment && increment2 > 0.0) {
if (!noPrinting_) {
sprintf(generalPrint, "Cutoff increment increased from %g to %g", increment, increment2);
CoinMessages generalMessages = solverMod->getModelPtr()->messages();
generalMessageHandler->message(CLP_GENERAL, generalMessages)
<< generalPrint
<< CoinMessageEol;
}
increment = increment2;
}
delete solver;
numberChanged = 0;
delete [] changed;
return NULL;
}
}
void
CglLandP::CachedData::getData(const OsiSolverInterface &si)
{
int nBasics = si.getNumRows();
int nNonBasics = si.getNumCols();
if (basis_ != NULL)
delete basis_;
basis_ = dynamic_cast<CoinWarmStartBasis *> (si.getWarmStart());
if (!basis_)
throw NoBasisError();
if (nBasics_ > 0 || nBasics != nBasics_)
{
delete [] basics_;
basics_ = NULL;
}
if (basics_ == NULL)
{
basics_ = new int[nBasics];
nBasics_ = nBasics;
}
if (nNonBasics_ > 0 || nNonBasics != nNonBasics_)
{
delete [] nonBasics_;
nonBasics_ = NULL;
}
if (nonBasics_ == NULL)
{
nonBasics_ = new int[nNonBasics];
nNonBasics_ = nNonBasics;
}
int n = nBasics + nNonBasics;
if ( nBasics_ + nNonBasics_ > 0 || nBasics_ + nNonBasics_ != n)
{
delete [] colsol_;
delete [] integers_;
integers_ = NULL;
colsol_ = NULL;
slacks_ = NULL;
}
if (colsol_ == NULL)
{
colsol_ = new double[n];
slacks_ = &colsol_[nNonBasics];
}
if (integers_ == NULL)
{
integers_ = new bool[n];
}
const double * rowLower = si.getRowLower();
const double * rowUpper = si.getRowUpper();
//determine which slacks are integer
const CoinPackedMatrix * m = si.getMatrixByCol();
const double * elems = m->getElements();
const int * inds = m->getIndices();
const CoinBigIndex * starts = m->getVectorStarts();
const int * lengths = m->getVectorLengths();
// int numElems = m->getNumElements();
int numCols = m->getNumCols();
assert(numCols == nNonBasics_);
// int numRows = m->getNumRows();
CoinFillN(integers_ ,n, true);
for (int i = 0 ; i < numCols ; i++)
{
if (si.isContinuous(i))
integers_[i] = false;
}
bool * integerSlacks = integers_ + numCols;
for (int i = 0 ; i < nBasics ; i++)
{
if (rowLower[i] > -1e50 && INT_INFEAS(rowLower[i]) > 1e-15)
integerSlacks[i] = false;
if (rowUpper[i] < 1e50 && INT_INFEAS(rowUpper[i]) > 1e-15)
integerSlacks[i] = false;
}
for (int i = 0 ; i < numCols ; i++)
{
CoinBigIndex end = starts[i] + lengths[i];
if (integers_[i])
{
for (CoinBigIndex k=starts[i] ; k < end; k++)
{
if (integerSlacks[inds[k]] && INT_INFEAS(elems[k])>1e-15 )
integerSlacks[inds[k]] = false;
}
}
else
{
for (CoinBigIndex k=starts[i] ; k < end; k++)
{
if (integerSlacks[inds[k]])
integerSlacks[inds[k]] = false;
}
}
}
CoinCopyN(si.getColSolution(), si.getNumCols(), colsol_);
CoinCopyN(si.getRowActivity(), si.getNumRows(), slacks_);
for (int i = 0 ; i < si.getNumRows() ; i++)
{
slacks_[i]*=-1;
if (rowLower[i]>-1e50)
{
slacks_[i] += rowLower[i];
}
else
{
slacks_[i] += rowUpper[i];
}
}
//Now get the fill the arrays;
nNonBasics = 0;
nBasics = 0;
//For having the index variables correctly ordered we need to access to OsiSimplexInterface
{
OsiSolverInterface * ncSi = (const_cast<OsiSolverInterface *>(&si));
ncSi->enableSimplexInterface(0);
ncSi->getBasics(basics_);
// Save enabled solver
solver_ = si.clone();
#ifdef COIN_HAS_OSICLP
OsiClpSolverInterface * clpSi = dynamic_cast<OsiClpSolverInterface *>(solver_);
const OsiClpSolverInterface * clpSiRhs = dynamic_cast<const OsiClpSolverInterface *>(&si);
if (clpSi)
clpSi->getModelPtr()->copyEnabledStuff(clpSiRhs->getModelPtr());;
#endif
ncSi->disableSimplexInterface();
}
int numStructural = basis_->getNumStructural();
for (int i = 0 ; i < numStructural ; i++)
{
if (basis_->getStructStatus(i)== CoinWarmStartBasis::basic)
{
nBasics++;
//Basically do nothing
}
else
{
nonBasics_[nNonBasics++] = i;
}
}
int numArtificial = basis_->getNumArtificial();
for (int i = 0 ; i < numArtificial ; i++)
{
if (basis_->getArtifStatus(i)== CoinWarmStartBasis::basic)
{
//Just check number of basics
nBasics++;
}
else
{
nonBasics_[nNonBasics++] = i + basis_->getNumStructural();
}
}
}
void
CglLandP::generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
const CglTreeInfo info )
{
if ((info.pass == 0) && !info.inTree)
{
numrows_ = si.getNumRows();
}
// scanExtraCuts(cs, si.getColSolution());
Parameters params = params_;
params.rhsWeight = numrows_ + 2;
handler_->message(CUT_GAP, messages_)<<info.pass<<si.getObjValue() <<CoinMessageEol;
if (info.inTree) //put lower pivot limit
{
params.pivotLimit = std::min(params.pivotLimit, params.pivotLimitInTree);
params.countMistakenRc = true;
}
if (params.timeLimit < 0)
{
params.pivotLimit = 0;
}
assert(si.basisIsAvailable());
#ifdef APPEND_ROW
OsiSolverInterface * t_si = si.clone();
if (params.modularize)
{
int new_idx = si.getNumCols();
int v_idx[1] = {new_idx};
double v_val[1] = {-1};
CoinPackedVector v(1, v_idx, v_val, false);
t_si->addCol(CoinPackedVector(), 0, 1, 0);
t_si->setInteger(new_idx);
t_si->addRow(v,0, 0);
t_si->resolve();
}
#else
const OsiSolverInterface * t_si = &si;
#endif
cached_.getData(*t_si);
CglLandPSimplex landpSi(*t_si, cached_, params, validator_);
if (params.generateExtraCuts == CglLandP::AllViolatedMigs)
{
landpSi.genThisBasisMigs(cached_, params);
}
landpSi.setLogLevel(handler_->logLevel());
int nCut = 0;
std::vector<int> indices;
getSortedFractionalIndices(indices,cached_, params);
#ifndef NDEBUG
int numrows = si.getNumRows();
#endif
#ifdef DO_STAT
//Get informations on current optimum
{
OsiSolverInterface * gapTester = si.clone();
gapTester->resolve();
roundsStats_.analyseOptimalBasis(gapTester,info.pass, numrows_);
delete gapTester;
}
#endif
params_.timeLimit += CoinCpuTime();
CoinRelFltEq eq(1e-04);
for (unsigned int i = 0; i < indices.size() && nCut < params.maxCutPerRound &&
nCut < cached_.nBasics_ ; i++)
{
//Check for time limit
int iRow = indices[i];
assert(iRow < numrows);
OsiRowCut cut;
int code=1;
OsiSolverInterface * ncSi = NULL;
if (params.pivotLimit != 0)
{
ncSi = t_si->clone();
landpSi.setSi(ncSi);
ncSi->setDblParam(OsiDualObjectiveLimit, COIN_DBL_MAX);
ncSi->messageHandler()->setLogLevel(0);
}
int generated = 0;
if (params.pivotLimit == 0)
{
generated = landpSi.generateMig(iRow, cut, params);
}
else
{
generated = landpSi.optimize(iRow, cut, cached_, params);
if (params.generateExtraCuts == CglLandP::AllViolatedMigs)
{
landpSi.genThisBasisMigs(cached_, params);
}
landpSi.resetSolver(cached_.basis_);
}
code = 0;
if (generated)
code = validator_(cut, cached_.colsol_, si, params, originalColLower_, originalColUpper_);
if (!generated || code)
{
if (params.pivotLimit !=0)
{
handler_->message(LAP_CUT_FAILED_DO_MIG, messages_)<<validator_.failureString(code)<<CoinMessageEol;
landpSi.freeSi();
OsiSolverInterface * ncSi = t_si->clone();
landpSi.setSi(ncSi);
params.pivotLimit = 0;
if (landpSi.optimize(iRow, cut, cached_, params))
{
code = validator_(cut, cached_.colsol_, si, params, originalColLower_, originalColUpper_);
}
params.pivotLimit = params_.pivotLimit;
}
}
if (params.pivotLimit != 0)
{
landpSi.freeSi();
}
if (code)
{
handler_->message(CUT_REJECTED, messages_)<<
validator_.failureString(code)<<CoinMessageEol;
}
else
{
if (canLift_)
{
cut.setGloballyValid(true);
}
cs.insertIfNotDuplicate(cut, eq);
//cs.insert(cut);
{
//std::cout<<"Violation "<<cut.violated(cached_.colsol_)<<std::endl;
nCut++;
}
}
}
Cuts& extra = landpSi.extraCuts();
for (int i = 0 ; i < cached_.nNonBasics_; i++)
{
OsiRowCut * cut = extra.rowCut(i);
if (cut == NULL) continue;
int code = validator_(*cut, cached_.colsol_, si, params,
originalColLower_, originalColUpper_);
if (code)
{
handler_->message(LAP_CUT_FAILED_DO_MIG, messages_)
<<validator_.failureString(code)<<CoinMessageEol;
}
else
{
cs.insertIfNotDuplicate(*cut, eq);
{
nCut++;
}
}
delete cut;
}
landpSi.outPivInfo(nCut);
params_.timeLimit -= CoinCpuTime();
cached_.clean();
#ifdef APPEND_ROW
assert(t_si != &si);
delete t_si;
#endif
}
//--------------------------------------------------------------------------
// test EKKsolution methods.
void
CglOddHoleUnitTest(
const OsiSolverInterface * baseSiP,
const std::string mpsDir )
{
CoinRelFltEq eq(0.000001);
// Test default constructor
{
CglOddHole aGenerator;
}
// Test copy & assignment
{
CglOddHole rhs;
{
CglOddHole bGenerator;
CglOddHole cGenerator(bGenerator);
rhs=bGenerator;
}
}
// test on simple case
{
const int nRows=3;
const int nCols=3;
const int nEls=6;
const double elem[]={1.0,1.0,1.0,1.0,1.0,1.0};
const int row[]={0,1,0,2,1,2};
const CoinBigIndex start[]={0,2,4};
const int len[]={2,2,2};
CoinPackedMatrix matrix(true,nRows,nCols,nEls,elem,row,start,len);
const double sol[]={0.5,0.5,0.5};
const double dj[]={0,0,0};
const int which[]={1,1,1};
const int fixed[]={0,0,0};
OsiCuts cs;
CglOddHole test1;
CglTreeInfo info;
info.randomNumberGenerator=NULL;
test1.generateCuts(NULL,matrix,sol,dj,cs,which,fixed,info,true);
CoinPackedVector check;
int index[] = {0,1,2};
double el[] = {1,1,1};
check.setVector(3,index,el);
//assert (cs.sizeRowCuts()==2);
assert (cs.sizeRowCuts()==1);
// sort Elements in increasing order
CoinPackedVector rpv=cs.rowCut(0).row();
rpv.sortIncrIndex();
assert (check==rpv);
}
// Testcase /u/rlh/osl2/mps/scOneInt.mps
// Model has 3 continous, 2 binary, and 1 general
// integer variable.
{
OsiSolverInterface * siP = baseSiP->clone();
std::string fn = mpsDir+"scOneInt";
siP->readMps(fn.c_str(),"mps");
#if 0
CglOddHole cg;
int nCols=siP->getNumCols();
// Test the siP methods for detecting
// variable type
int numCont=0, numBinary=0, numIntNonBinary=0, numInt=0;
for (int thisCol=0; thisCol<nCols; thisCol++) {
if ( siP->isContinuous(thisCol) ) numCont++;
if ( siP->isBinary(thisCol) ) numBinary++;
if ( siP->isIntegerNonBinary(thisCol) ) numIntNonBinary++;
if ( siP->isInteger(thisCol) ) numInt++;
}
assert(numCont==3);
assert(numBinary==2);
assert(numIntNonBinary==1);
assert(numInt==3);
// Test initializeCutGenerator
siP->initialSolve();
assert(xstar !=NULL);
for (i=0; i<nCols; i++){
assert(complement[i]==0);
}
int nRows=siP->getNumRows();
for (i=0; i<nRows; i++){
int vectorsize = siP->getMatrixByRow()->getVectorSize(i);
assert(vectorsize==2);
}
kccg.cleanUpCutGenerator(complement,xstar);
#endif
delete siP;
}
}
//-------------------------------------------------------------------
// 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);
}
}
/*===========================================================================*
Create the set packing submatrix
*===========================================================================*/
void
CglClique::createSetPackingSubMatrix(const OsiSolverInterface& si)
{
sp_col_start = new int[sp_numcols+1];
sp_row_start = new int[sp_numrows+1];
std::fill(sp_col_start, sp_col_start + (sp_numcols+1), 0);
std::fill(sp_row_start, sp_row_start + (sp_numrows+1), 0);
int i, j;
const CoinPackedMatrix& mcol = *si.getMatrixByCol();
const int numrows = si.getNumRows();
int* clique = new int[numrows];
std::fill(clique, clique+numrows, -1);
for (i = 0; i < sp_numrows; ++i)
clique[sp_orig_row_ind[i]] = i;
for (j = 0; j < sp_numcols; ++j) {
const CoinShallowPackedVector& vec = mcol.getVector(sp_orig_col_ind[j]);
const int* ind = vec.getIndices();
for (i = vec.getNumElements() - 1; i >= 0; --i) {
if (clique[ind[i]] >= 0) {
++sp_col_start[j];
++sp_row_start[clique[ind[i]]];
}
}
}
std::partial_sum(sp_col_start, sp_col_start+sp_numcols, sp_col_start);
std::rotate(sp_col_start, sp_col_start+sp_numcols,
sp_col_start + (sp_numcols+1));
std::partial_sum(sp_row_start, sp_row_start+sp_numrows, sp_row_start);
std::rotate(sp_row_start, sp_row_start+sp_numrows,
sp_row_start + (sp_numrows+1));
const int nzcnt = sp_col_start[sp_numcols];
assert(nzcnt == sp_row_start[sp_numrows]);
/*
Now create the vectors with row indices for each column (sp_col_ind) and
column indices for each row (sp_row_ind). It turns out that
CoinIsOrthogonal assumes that the row indices for a given column are listed
in ascending order. This is *not* a solver-independent assumption! At best,
one can hope that the underlying solver will produce an index vector that's
either ascending or descending. Under that assumption, compare the first
and last entries and proceed accordingly. Eventually some solver will come
along that hands back an index vector in random order, and CoinIsOrthogonal
will break. Until then, try and avoid the cost of a sort.
*/
sp_col_ind = new int[nzcnt];
sp_row_ind = new int[nzcnt];
int last=0;
for (j = 0; j < sp_numcols; ++j) {
const CoinShallowPackedVector& vec = mcol.getVector(sp_orig_col_ind[j]);
const int len = vec.getNumElements();
const int* ind = vec.getIndices();
if (ind[0] < ind[len-1]) {
for (i = 0; i < len; ++i) {
const int sp_row = clique[ind[i]];
if (sp_row >= 0) {
sp_col_ind[sp_col_start[j]++] = sp_row;
sp_row_ind[sp_row_start[sp_row]++] = j;
}
}
}
else {
for (i = len-1; i >= 0; --i) {
const int sp_row = clique[ind[i]];
if (sp_row >= 0) {
sp_col_ind[sp_col_start[j]++] = sp_row;
sp_row_ind[sp_row_start[sp_row]++] = j;
}
}
}
// sort
std::sort(sp_col_ind+last,sp_col_ind+sp_col_start[j]);
last=sp_col_start[j];
}
std::rotate(sp_col_start, sp_col_start+sp_numcols,
sp_col_start + (sp_numcols+1));
sp_col_start[0] = 0;
std::rotate(sp_row_start, sp_row_start+sp_numrows,
sp_row_start + (sp_numrows+1));
sp_row_start[0] = 0;
delete[] clique;
}
//Solver function
int sci_rmps(char *fname)
{
//creating a problem pointer using base class of OsiSolverInterface and
//instantiate the object using derived class of ClpSolverInterface
OsiSolverInterface* si = new OsiClpSolverInterface();
// Error management variable
SciErr sciErr;
//data declarations
int *piAddressVarOne = NULL; //pointer used to access argument of the function
char* ptr; //pointer to point to address of file name
double* options_; //options to set maximum iterations
CheckInputArgument(pvApiCtx, 2,2 ); //Check we have exactly two arguments as input or not
CheckOutputArgument(pvApiCtx, 6, 6); //Check we have exactly six arguments on output side or not
//Getting the input arguments from Scilab
//Getting the MPS file path
//Reading mps file
getStringFromScilab(1,&ptr);
std::cout<<ptr;
//get options from Scilab
if(getFixedSizeDoubleMatrixInList(2 , 2 , 1 , 1 , &options_))
{
return 1;
}
//Read the MPS file
si->readMps(ptr);
//setting options for maximum iterations
si->setIntParam(OsiMaxNumIteration,options_[0]);
//Solve the problem
si->initialSolve();
//Quering about the problem
//get number of variables
double numVars_;
numVars_ = si->getNumCols();
//get number of constraint equations
double numCons_;
numCons_ = si->getNumRows();
//Output the solution to Scilab
//get solution for x
const double* xValue = si->getColSolution();
//get objective value
double objValue = si->getObjValue();
//get Status value
double status;
if(si->isProvenOptimal())
status=0;
else if(si->isProvenPrimalInfeasible())
status=1;
else if(si->isProvenDualInfeasible())
status=2;
else if(si->isIterationLimitReached())
status=3;
else if(si->isAbandoned())
status=4;
else if(si->isPrimalObjectiveLimitReached())
status=5;
else if(si->isDualObjectiveLimitReached())
status=6;
//get number of iterations
double iterations = si->getIterationCount();
//get reduced cost
const double* reducedCost = si->getReducedCost();
//get dual vector
const double* dual = si->getRowPrice();
returnDoubleMatrixToScilab(1 , 1 , numVars_ , xValue);
returnDoubleMatrixToScilab(2 , 1 , 1 , &objValue);
returnDoubleMatrixToScilab(3 , 1 , 1 , &status);
returnDoubleMatrixToScilab(4 , 1 , 1 , &iterations);
returnDoubleMatrixToScilab(5 , 1 , numVars_ , reducedCost);
returnDoubleMatrixToScilab(6 , 1 , numCons_ , dual);
free(xValue);
free(dual);
free(reducedCost);
}
void ModelScenario(const char * const name )
{
OsiClpSolverInterface *osiClp1 = new OsiClpSolverInterface();
double INF=osiClp1->getInfinity();
// example of direct interfaces for scenario generation
/* Model dimensions */
int nels=44; // ncol=27, nrow=9
/* Sparse matrix data...organized by row */
int mrow[]={ 0, 0, 0, 0, 0,
1, 1, 1, 1,
2, 2, 2,
3, 3, 3, 3, 3,
4, 4, 4, 4,
5, 5, 5, 5, 5, 5,
6, 6, 6, 6, 6,
7, 7, 7, 7, 7, 7,
8, 8, 8, 8, 8, 8 };
int mcol[]={ 0, 1, 2, 3, 4,
5, 6, 7, 8,
9,10, 11,
12, 13, 14, 15, 16,
0, 12, 17, 18,
1, 5, 9, 13, 19, 20,
2, 6, 14, 21, 22,
3, 7, 10, 15, 23, 24,
4, 8, 11, 16, 25, 26 };
double dels[] = { 1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0,
16.0, 9.0, -1.0, 1.0,
15.0, 10.0, 5.0, 11.0, -1.0, 1.0,
28.0, 14.0, 22.0, -1.0, 1.0,
23.0, 15.0, 7.0, 17.0, -1.0, 1.0,
81.0, 57.0, 29.0, 55.0, -1.0, 1.0 };
/* Objective */
double dobj[]={ 18.0, 21.0, 18.0, 16.0, 10.0, 15.0, 16.0, 14.0, 9.0,
10.0, 9.0, 6.0, 17.0, 16.0, 17.0, 15.0, 10.0, 0.0,
13.0, 0.0, 13.0, 0.0, 7.0, 0.0, 7.0, 0.0, 1.0 };
/* Column bounds */
double dclo[]={ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
double dcup[]={ INF, INF, INF, INF, INF, INF, INF, INF, INF,
INF, INF, INF, INF, INF, INF, INF, INF, INF,
INF, INF, INF, INF, INF, INF, INF, INF, INF };
/* Row bounds */
double drlo[]={ -INF, -INF, -INF, -INF, 0.0, 4.0, 0.0, 8.0, 10.0 };
double drup[]={ 10.0, 19.0, 25.0, 15.0, 0.0, 7.0, 0.0, 8.0, 90.0 };
/* Stages */
int nstg=2;
int n_first_stg_rows=4;
int rstg[]={ 0,0,0,0,1,1,1,1,1 };
int cstg[]={ 0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,1,
1,1,1,1,1,1,1,1,1 };
/* Stochastic data */
int nindp=5;
int nsamp[]={ 5, 2, 5, 5, 3 };
double demand[]={ 200, 220, 250, 270, 300,
50, 150,
140, 160, 180, 200, 220,
10, 50, 80, 100, 340,
580, 600, 620 };
double dprobs[]={ 0.2, 0.05, 0.35, 0.2, 0.2,
0.3, 0.7,
0.1, 0.2, 0.4, 0.2, 0.1,
0.2, 0.2, 0.3, 0.2, 0.1,
0.1, 0.8, 0.1 };
/* local variables */
int ns=1,ii,iii,jj,*indx,*incr;
double dp=1.0;
for (ii=0;ii<nindp;ii++) ns *= nsamp[ii]; /* Compute number of scenarios */
// initialize SmiModel
SmiScnModel *smiModel = new SmiScnModel();
smiModel->setOsiSolverHandle(*osiClp1);
// set core model using Osi interface
OsiClpSolverInterface ocsi;
ocsi.loadProblem(CoinPackedMatrix( 1,mrow,mcol,dels,nels),dclo,dcup,dobj,drlo,drup);
SmiCoreData *osiCore = new SmiCoreData(&ocsi,nstg,cstg,rstg);
cout << "ModelScenario: Created CoreData" << endl;
// Coin structures for scenario updates to right hand sides
CoinPackedVector cpv_rlo;
CoinPackedVector cpv_rup;
// initialize right hand side data for first scenario
indx = (int *) malloc( (1+nindp)*sizeof(int) );
memset( indx,0,(1+nindp)*sizeof(int));
for (jj=0;jj<nindp;jj++) {
indx[jj+1] += indx[jj] + nsamp[jj];
dp *= dprobs[ indx[jj] ];
drlo[n_first_stg_rows + jj] = demand[ indx[jj] ];
drup[n_first_stg_rows + jj] = demand[ indx[jj] ];
cpv_rlo.insert(n_first_stg_rows + jj,demand[ indx[jj] ]);
cpv_rup.insert(n_first_stg_rows + jj,demand[ indx[jj] ]);
}
cout << "ModelScenario: Adding " << ns << " scenarios" << endl;
// first scenario
int anc = 0;
int branch = 1;
int is = smiModel->generateScenario(osiCore,NULL,NULL,NULL,NULL,
&cpv_rlo,&cpv_rup,branch,anc,dp);
/***** ...main loop to generate scenarios from discrete random variables
For each scenario index ii:
If the sample size nsamp[jj] divides the scenario index ii,
reverse the increment direction incr[jj]
and increase the random variable index jj by 1.
Increment the jj'th random variable by incr[jj]
and generate new sample data.
***** */
/* sample space increment initialized to 1 */
incr = (int *) malloc( nindp*sizeof(int) );
for (jj=0;jj<nindp;jj++) incr[jj] = 1;
for (int iss=1;iss<ns;iss++) {
iii=iss; jj=0;
while ( !(iii%nsamp[jj]) ) {
iii /= nsamp[jj];
incr[jj] = -incr[jj];
jj++;
}
dp /= dprobs[ indx[jj] ];
indx[jj] += incr[jj];
dp *= dprobs[ indx[jj] ];
// set data
drlo[n_first_stg_rows + jj] = demand[ indx[jj] ];
drup[n_first_stg_rows + jj] = demand[ indx[jj] ];
cpv_rlo.setElement(cpv_rlo.findIndex(n_first_stg_rows + jj),demand[ indx[jj] ]);
cpv_rup.setElement(cpv_rup.findIndex(n_first_stg_rows + jj),demand[ indx[jj] ]);
// genScenario
is = smiModel->generateScenario(osiCore,NULL,NULL,NULL,NULL,
&cpv_rlo,&cpv_rup,branch,anc,dp);
}
assert(ns==smiModel->getNumScenarios());
cout << "ModelScenario: Finished adding scenarios" << endl;
// load problem data into OsiSolver
smiModel->loadOsiSolverData();
// get Osi pointer
OsiSolverInterface *smiOsi = smiModel->getOsiSolverInterface();
// set some parameters
smiOsi->setHintParam(OsiDoPresolveInInitial,true);
smiOsi->setHintParam(OsiDoScale,true);
smiOsi->setHintParam(OsiDoCrash,true);
// solve using Osi Solver
smiOsi->initialSolve();
// test optimal value
assert(fabs(smiOsi->getObjValue()-1566.042)<0.01);
// test solutions
const double *dsoln = smiOsi->getColSolution();
double objSum = 0.0;
/* The canonical way to traverse the tree:
For each scenario, get the leaf node.
Then get the parent. Repeat until parent is NULL.
(Only the root node has a NULL parent.)
*/
for(is=0; is<ns; ++is)
{
/* this loop calculates the scenario objective value */
double scenSum = 0.0;
// start with leaf node
SmiScnNode *node = smiModel->getLeafNode(is);
// leaf node probability is the scenario probability
double scenprob = node->getModelProb();
while (node != NULL)
{
// getColStart returns the starting index of node in OSI model
for(int j=node->getColStart(); j<node->getColStart()+node->getNumCols(); ++j)
{
// getCoreColIndex returns the corresponding Core index
// in the original (user's) ordering
scenSum += dobj[node->getCoreColIndex(j)]*dsoln[j];
}
// get parent of node
node = node->getParent();
}
objSum += scenSum*scenprob;
}
assert(fabs(smiOsi->getObjValue()-objSum) < 0.01);
// print results
printf("Solved stochastic program %s\n", name);
printf("Number of rows: %d\n",smiOsi->getNumRows());
printf("Number of cols: %d\n",smiOsi->getNumCols());
printf("Optimal value: %g\n",smiOsi->getObjValue());
}
//--------------------------------------------------------------------------
// test cut debugger methods.
void
OsiRowCutDebuggerUnitTest(const OsiSolverInterface * baseSiP, const std::string & mpsDir)
{
CoinRelFltEq eq;
// Test default constructor
{
OsiRowCutDebugger r;
OSIUNITTEST_ASSERT_ERROR(r.integerVariable_ == NULL, {}, "osirowcutdebugger", "default constructor");
OSIUNITTEST_ASSERT_ERROR(r.knownSolution_ == NULL, {}, "osirowcutdebugger", "default constructor");
OSIUNITTEST_ASSERT_ERROR(r.numberColumns_ == 0, {}, "osirowcutdebugger", "default constructor");
}
{
// Get non trivial instance
OsiSolverInterface * imP = baseSiP->clone();
std::string fn = mpsDir+"exmip1";
imP->readMps(fn.c_str(),"mps");
OSIUNITTEST_ASSERT_ERROR(imP->getNumRows() == 5, {}, "osirowcutdebugger", "read exmip1");
/*
Activate the debugger. The garbled name here is deliberate; the
debugger should isolate the portion of the string between '/' and
'.' (in normal use, this would be the base file name, stripped of
the prefix and extension).
*/
imP->activateRowCutDebugger("ab cd /x/ /exmip1.asc");
int i;
// return debugger
const OsiRowCutDebugger * debugger = imP->getRowCutDebugger();
OSIUNITTEST_ASSERT_ERROR(debugger != NULL, {}, "osirowcutdebugger", "return debugger");
OSIUNITTEST_ASSERT_ERROR(debugger->numberColumns_ == 8, {}, "osirowcutdebugger", "return debugger");
const bool type[]={0,0,1,1,0,0,0,0};
const double values[]= {2.5, 0, 1, 1, 0.5, 3, 0, 0.26315789473684253};
CoinPackedVector objCoefs(8,imP->getObjCoefficients());
bool type_ok = true;
#if 0
for (i=0;i<8;i++)
type_ok &= type[i] == debugger->integerVariable_[i];
OSIUNITTEST_ASSERT_ERROR(type_ok, {}, "osirowcutdebugger", "???");
#endif
double objValue = objCoefs.dotProduct(values);
double debuggerObjValue = objCoefs.dotProduct(debugger->knownSolution_);
OSIUNITTEST_ASSERT_ERROR(eq(objValue, debuggerObjValue), {}, "osirowcutdebugger", "objective value");
OsiRowCutDebugger rhs;
{
OsiRowCutDebugger rC1(*debugger);
OSIUNITTEST_ASSERT_ERROR(rC1.numberColumns_ == 8, {}, "osirowcutdebugger", "copy constructor");
type_ok = true;
for (i=0;i<8;i++)
type_ok &= type[i] == rC1.integerVariable_[i];
OSIUNITTEST_ASSERT_ERROR(type_ok, {}, "osirowcutdebugger", "copy constructor");
OSIUNITTEST_ASSERT_ERROR(eq(objValue,objCoefs.dotProduct(rC1.knownSolution_)), {}, "osirowcutdebugger", "copy constructor");
rhs = rC1;
OSIUNITTEST_ASSERT_ERROR(rhs.numberColumns_ == 8, {}, "osirowcutdebugger", "assignment operator");
type_ok = true;
for (i=0;i<8;i++)
type_ok &= type[i] == rhs.integerVariable_[i];
OSIUNITTEST_ASSERT_ERROR(type_ok, {}, "osirowcutdebugger", "assignment operator");
OSIUNITTEST_ASSERT_ERROR(eq(objValue,objCoefs.dotProduct(rhs.knownSolution_)), {}, "osirowcutdebugger", "assignment operator");
}
// Test that rhs has correct values even though lhs has gone out of scope
OSIUNITTEST_ASSERT_ERROR(rhs.numberColumns_ == 8, {}, "osirowcutdebugger", "assignment operator");
type_ok = true;
for (i=0;i<8;i++)
type_ok &= type[i] == rhs.integerVariable_[i];
OSIUNITTEST_ASSERT_ERROR(type_ok, {}, "osirowcutdebugger", "assignment operator");
OSIUNITTEST_ASSERT_ERROR(eq(objValue,objCoefs.dotProduct(rhs.knownSolution_)), {}, "osirowcutdebugger", "assignment operator");
OsiRowCut cut[2];
const int ne = 3;
int inx[ne] = { 0, 2, 3 };
double el[ne] = { 1., 1., 1. };
cut[0].setRow(ne,inx,el);
cut[0].setUb(5.);
el[1]=5;
cut[1].setRow(ne,inx,el);
cut[1].setUb(5);
OsiCuts cs;
cs.insert(cut[0]);
cs.insert(cut[1]);
OSIUNITTEST_ASSERT_ERROR(!debugger->invalidCut(cut[0]), {}, "osirowcutdebugger", "recognize (in)valid cut");
OSIUNITTEST_ASSERT_ERROR( debugger->invalidCut(cut[1]), {}, "osirowcutdebugger", "recognize (in)valid cut");
OSIUNITTEST_ASSERT_ERROR(debugger->validateCuts(cs,0,2) == 1, {}, "osirowcutdebugger", "recognize (in)valid cut");
OSIUNITTEST_ASSERT_ERROR(debugger->validateCuts(cs,0,1) == 0, {}, "osirowcutdebugger", "recognize (in)valid cut");
delete imP;
}
}
//-----------------------------------------------------------------------------
// Generate Lift-and-Project cuts
//-------------------------------------------------------------------
void CglLiftAndProject::generateCuts(const OsiSolverInterface& si, OsiCuts& cs,
const CglTreeInfo /*info*/)
{
// Assumes the mixed 0-1 problem
//
// min {cx: <Atilde,x> >= btilde}
//
// is in canonical form with all bounds,
// including x_t>=0, -x_t>=-1 for x_t binary,
// explicitly stated in the constraint matrix.
// See ~/COIN/Examples/Cgl2/cgl2.cpp
// for a general purpose "convert" function.
// Reference [BCC]: Balas, Ceria, and Corneujols,
// "A lift-and-project cutting plane algorithm
// for mixed 0-1 program", Math Prog 58, (1993)
// 295-324.
// This implementation uses Normalization 1.
// Given canonical problem and
// the lp-relaxation solution, x,
// the LAP cut generator attempts to construct
// a cut for every x_j such that 0<x_j<1
// [BCC:307]
// x_j is the strictly fractional binary variable
// the cut is generated from
int j = 0;
// Get basic problem information
// let Atilde be an m by n matrix
const int m = si.getNumRows();
const int n = si.getNumCols();
const double * x = si.getColSolution();
// Remember - Atildes may have gaps..
const CoinPackedMatrix * Atilde = si.getMatrixByRow();
const double * AtildeElements = Atilde->getElements();
const int * AtildeIndices = Atilde->getIndices();
const CoinBigIndex * AtildeStarts = Atilde->getVectorStarts();
const int * AtildeLengths = Atilde->getVectorLengths();
const int AtildeFullSize = AtildeStarts[m];
const double * btilde = si.getRowLower();
// Set up memory for system (10) [BCC:307]
// (the problem over the norm intersected
// with the polar cone)
//
// min <<x^T,Atilde^T>,u> + x_ju_0
// s.t.
// <B,w> = (0,...,0,beta_,beta)^T
// w is nonneg for all but the
// last two entries, which are free.
// where
// w = (u,v,v_0,u_0)in BCC notation
// u and v are m-vectors; u,v >=0
// v_0 and u_0 are free-scalars, and
//
// B = Atilde^T -Atilde^T -e_j e_j
// btilde^T e_0^T 0 0
// e_0^T btilde^T 1 0
// ^T indicates Transpose
// e_0 is a (AtildeNCols x 1) vector of all zeros
// e_j is e_0 with a 1 in the jth position
// Storing B in column order. B is a (n+2 x 2m+2) matrix
// But need to allow for possible gaps in Atilde.
// At each iteration, only need to change 2 cols and objfunc
// Sane design of OsiSolverInterface does not permit mucking
// with matrix.
// Because we must delete and add cols to alter matrix,
// and we can only add columns on the end of the matrix
// put the v_0 and u_0 columns on the end.
// rather than as described in [BCC]
// Initially allocating B with space for v_0 and u_O cols
// but not populating, for efficiency.
// B without u_0 and v_0 is a (n+2 x 2m) size matrix.
int twoM = 2*m;
int BNumRows = n+2;
int BNumCols = twoM+2;
int BFullSize = 2*AtildeFullSize+twoM+3;
double * BElements = new double[BFullSize];
int * BIndices = new int[BFullSize];
CoinBigIndex * BStarts = new CoinBigIndex [BNumCols+1];
int * BLengths = new int[BNumCols];
int i, ij, k=0;
int nPlus1=n+1;
int offset = AtildeStarts[m]+m;
for (i=0; i<m; i++){
for (ij=AtildeStarts[i];ij<AtildeStarts[i]+AtildeLengths[i];ij++){
BElements[k]=AtildeElements[ij];
BElements[k+offset]=-AtildeElements[ij];
BIndices[k]= AtildeIndices[ij];
BIndices[k+offset]= AtildeIndices[ij];
k++;
}
BElements[k]=btilde[i];
BElements[k+offset]=btilde[i];
BIndices[k]=n;
BIndices[k+offset]=nPlus1;
BStarts[i]= AtildeStarts[i]+i;
BStarts[i+m]=offset+BStarts[i];// = AtildeStarts[m]+m+AtildeStarts[i]+i
BLengths[i]= AtildeLengths[i]+1;
BLengths[i+m]= AtildeLengths[i]+1;
k++;
}
BStarts[twoM]=BStarts[twoM-1]+BLengths[twoM-1];
// Cols that will be deleted each iteration
int BNumColsLessOne=BNumCols-1;
int BNumColsLessTwo=BNumCols-2;
const int delCols[2] = {BNumColsLessOne, BNumColsLessTwo};
// Set lower bound on u and v
// u_0, v_0 will be reset as free
const double solverINFINITY = si.getInfinity();
double * BColLowers = new double[BNumCols];
double * BColUppers = new double[BNumCols];
CoinFillN(BColLowers,BNumCols,0.0);
CoinFillN(BColUppers,BNumCols,solverINFINITY);
// Set row lowers and uppers.
// The rhs is zero, for but the last two rows.
// For these the rhs is beta_
double * BRowLowers = new double[BNumRows];
double * BRowUppers = new double[BNumRows];
CoinFillN(BRowLowers,BNumRows,0.0);
CoinFillN(BRowUppers,BNumRows,0.0);
BRowLowers[BNumRows-2]=beta_;
BRowUppers[BNumRows-2]=beta_;
BRowLowers[BNumRows-1]=beta_;
BRowUppers[BNumRows-1]=beta_;
// Calculate base objective <<x^T,Atilde^T>,u>
// Note: at each iteration coefficient u_0
// changes to <x^T,e_j>
// w=(u,v,beta,v_0,u_0) size 2m+3
// So, BOjective[2m+2]=x[j]
double * BObjective= new double[BNumCols];
double * Atildex = new double[m];
CoinFillN(BObjective,BNumCols,0.0);
Atilde->times(x,Atildex); // Atildex is size m, x is size n
CoinDisjointCopyN(Atildex,m,BObjective);
// Number of cols and size of Elements vector
// in B without the v_0 and u_0 cols
int BFullSizeLessThree = BFullSize-3;
// Load B matrix into a column orders CoinPackedMatrix
CoinPackedMatrix * BMatrix = new CoinPackedMatrix(true, BNumRows,
BNumColsLessTwo,
BFullSizeLessThree,
BElements,BIndices,
BStarts,BLengths);
// Assign problem into a solver interface
// Note: coneSi will cleanup the memory itself
OsiSolverInterface * coneSi = si.clone(false);
coneSi->assignProblem (BMatrix, BColLowers, BColUppers,
BObjective,
BRowLowers, BRowUppers);
// Problem sense should default to "min" by default,
// but just to be virtuous...
coneSi->setObjSense(1.0);
// The plot outline from here on down:
// coneSi has been assigned B without the u_0 and v_0 columns
// Calculate base objective <<x^T,Atilde^T>,u>
// bool haveWarmStart = false;
// For (j=0; j<n, j++)
// if (!isBinary(x_j) || x_j<=0 || x_j>=1) continue;
// // IMPROVEME: if(haveWarmStart) check if j attractive
// add {-e_j,0,-1} matrix column for v_0
// add {e_j,0,0} matrix column for u_0
// objective coefficient for u_0 is x_j
// if (haveWarmStart)
// set warmstart info
// solve min{objw:Bw=0; w>=0,except v_0, u_0 free}
// if (bounded)
// get warmstart info
// haveWarmStart=true;
// ustar = optimal u solution
// ustar_0 = optimal u_0 solution
// alpha^T= <ustar^T,Atilde> -ustar_0e_j^T
// (double check <alpha^T,x> >= beta_ should be violated)
// add <alpha^T,x> >= beta_ to cutset
// endif
// delete column for u_0 // this deletes all column info.
// delete column for v_0
// endFor
// clean up memory
// return 0;
int * nVectorIndices = new int[n];
CoinIotaN(nVectorIndices, n, 0);
bool haveWarmStart = false;
bool equalObj1, equalObj2;
CoinRelFltEq eq;
double v_0Elements[2] = {-1,1};
double u_0Elements[1] = {1};
CoinWarmStart * warmStart = 0;
double * ustar = new double[m];
CoinFillN(ustar, m, 0.0);
double* alpha = new double[n];
CoinFillN(alpha, n, 0.0);
for (j=0;j<n;j++){
if (!si.isBinary(j)) continue; // Better to ask coneSi? No!
// coneSi has no binInfo.
equalObj1=eq(x[j],0);
equalObj2=eq(x[j],1);
if (equalObj1 || equalObj2) continue;
// IMPROVEME: if (haveWarmStart) check if j attractive;
// AskLL:wanted to declare u_0 and v_0 packedVec outside loop
// and setIndices, but didn't see a method to do that(?)
// (Could "insert". Seems inefficient)
int v_0Indices[2]={j,nPlus1};
int u_0Indices[1]={j};
//
CoinPackedVector v_0(2,v_0Indices,v_0Elements,false);
CoinPackedVector u_0(1,u_0Indices,u_0Elements,false);
#if CGL_DEBUG
const CoinPackedMatrix *see1 = coneSi->getMatrixByRow();
#endif
coneSi->addCol(v_0,-solverINFINITY,solverINFINITY,0);
coneSi->addCol(u_0,-solverINFINITY,solverINFINITY,x[j]);
if(haveWarmStart) {
coneSi->setWarmStart(warmStart);
coneSi->resolve();
}
else {
#if CGL_DEBUG
const CoinPackedMatrix *see2 = coneSi->getMatrixByRow();
#endif
coneSi->initialSolve();
}
if(coneSi->isProvenOptimal()){
warmStart = coneSi->getWarmStart();
haveWarmStart=true;
const double * wstar = coneSi->getColSolution();
CoinDisjointCopyN(wstar, m, ustar);
Atilde->transposeTimes(ustar,alpha);
alpha[j]+=wstar[BNumCols-1];
#if debug
int p;
double sum;
for(p=0;p<n;p++)sum+=alpha[p]*x[p];
if (sum<=beta_){
throw CoinError("Cut not violated",
"cutGeneration",
"CglLiftAndProject");
}
#endif
// add <alpha^T,x> >= beta_ to cutset
OsiRowCut rc;
rc.setRow(n,nVectorIndices,alpha);
rc.setLb(beta_);
rc.setUb(solverINFINITY);
cs.insert(rc);
}
// delete col for u_o and v_0
coneSi->deleteCols(2,delCols);
// clean up memory
}
// clean up
delete [] alpha;
delete [] ustar;
delete [] nVectorIndices;
// BMatrix, BColLowers,BColUppers, BObjective, BRowLowers, BRowUppers
// are all freed by OsiSolverInterface destructor (?)
delete [] BLengths;
delete [] BStarts;
delete [] BIndices;
delete [] BElements;
}
// inner part of dive
int
CbcHeuristicDive::solution(double & solutionValue, int & numberNodes,
int & numberCuts, OsiRowCut ** cuts,
CbcSubProblem ** & nodes,
double * newSolution)
{
#ifdef DIVE_DEBUG
int nRoundInfeasible = 0;
int nRoundFeasible = 0;
#endif
int reasonToStop = 0;
double time1 = CoinCpuTime();
int numberSimplexIterations = 0;
int maxSimplexIterations = (model_->getNodeCount()) ? maxSimplexIterations_
: maxSimplexIterationsAtRoot_;
// but can't be exactly coin_int_max
maxSimplexIterations = CoinMin(maxSimplexIterations,COIN_INT_MAX>>3);
OsiSolverInterface * solver = cloneBut(6); // was model_->solver()->clone();
# ifdef COIN_HAS_CLP
OsiClpSolverInterface * clpSolver
= dynamic_cast<OsiClpSolverInterface *> (solver);
if (clpSolver) {
ClpSimplex * clpSimplex = clpSolver->getModelPtr();
int oneSolveIts = clpSimplex->maximumIterations();
oneSolveIts = CoinMin(1000+2*(clpSimplex->numberRows()+clpSimplex->numberColumns()),oneSolveIts);
clpSimplex->setMaximumIterations(oneSolveIts);
if (!nodes) {
// say give up easily
clpSimplex->setMoreSpecialOptions(clpSimplex->moreSpecialOptions() | 64);
} else {
// get ray
int specialOptions = clpSimplex->specialOptions();
specialOptions &= ~0x3100000;
specialOptions |= 32;
clpSimplex->setSpecialOptions(specialOptions);
clpSolver->setSpecialOptions(clpSolver->specialOptions() | 1048576);
if ((model_->moreSpecialOptions()&16777216)!=0) {
// cutoff is constraint
clpSolver->setDblParam(OsiDualObjectiveLimit, COIN_DBL_MAX);
}
}
}
# endif
const double * lower = solver->getColLower();
const double * upper = solver->getColUpper();
const double * rowLower = solver->getRowLower();
const double * rowUpper = solver->getRowUpper();
const double * solution = solver->getColSolution();
const double * objective = solver->getObjCoefficients();
double integerTolerance = model_->getDblParam(CbcModel::CbcIntegerTolerance);
double primalTolerance;
solver->getDblParam(OsiPrimalTolerance, primalTolerance);
int numberRows = matrix_.getNumRows();
assert (numberRows <= solver->getNumRows());
int numberIntegers = model_->numberIntegers();
const int * integerVariable = model_->integerVariable();
double direction = solver->getObjSense(); // 1 for min, -1 for max
double newSolutionValue = direction * solver->getObjValue();
int returnCode = 0;
// Column copy
const double * element = matrix_.getElements();
const int * row = matrix_.getIndices();
const CoinBigIndex * columnStart = matrix_.getVectorStarts();
const int * columnLength = matrix_.getVectorLengths();
#ifdef DIVE_FIX_BINARY_VARIABLES
// Row copy
const double * elementByRow = matrixByRow_.getElements();
const int * column = matrixByRow_.getIndices();
const CoinBigIndex * rowStart = matrixByRow_.getVectorStarts();
const int * rowLength = matrixByRow_.getVectorLengths();
#endif
// Get solution array for heuristic solution
int numberColumns = solver->getNumCols();
memcpy(newSolution, solution, numberColumns*sizeof(double));
// vectors to store the latest variables fixed at their bounds
int* columnFixed = new int [numberIntegers];
double* originalBound = new double [numberIntegers+2*numberColumns];
double * lowerBefore = originalBound+numberIntegers;
double * upperBefore = lowerBefore+numberColumns;
memcpy(lowerBefore,lower,numberColumns*sizeof(double));
memcpy(upperBefore,upper,numberColumns*sizeof(double));
double * lastDjs=newSolution+numberColumns;
bool * fixedAtLowerBound = new bool [numberIntegers];
PseudoReducedCost * candidate = new PseudoReducedCost [numberIntegers];
double * random = new double [numberIntegers];
int maxNumberAtBoundToFix = static_cast<int> (floor(percentageToFix_ * numberIntegers));
assert (!maxNumberAtBoundToFix||!nodes);
// count how many fractional variables
int numberFractionalVariables = 0;
for (int i = 0; i < numberIntegers; i++) {
random[i] = randomNumberGenerator_.randomDouble() + 0.3;
int iColumn = integerVariable[i];
double value = newSolution[iColumn];
if (fabs(floor(value + 0.5) - value) > integerTolerance) {
numberFractionalVariables++;
}
}
const double* reducedCost = NULL;
// See if not NLP
if (model_->solverCharacteristics()->reducedCostsAccurate())
reducedCost = solver->getReducedCost();
int iteration = 0;
while (numberFractionalVariables) {
iteration++;
// initialize any data
initializeData();
// select a fractional variable to bound
int bestColumn = -1;
int bestRound; // -1 rounds down, +1 rounds up
bool canRound = selectVariableToBranch(solver, newSolution,
bestColumn, bestRound);
// if the solution is not trivially roundable, we don't try to round;
// if the solution is trivially roundable, we try to round. However,
// if the rounded solution is worse than the current incumbent,
// then we don't round and proceed normally. In this case, the
// bestColumn will be a trivially roundable variable
if (canRound) {
// check if by rounding all fractional variables
// we get a solution with an objective value
// better than the current best integer solution
double delta = 0.0;
for (int i = 0; i < numberIntegers; i++) {
int iColumn = integerVariable[i];
double value = newSolution[iColumn];
if (fabs(floor(value + 0.5) - value) > integerTolerance) {
assert(downLocks_[i] == 0 || upLocks_[i] == 0);
double obj = objective[iColumn];
if (downLocks_[i] == 0 && upLocks_[i] == 0) {
if (direction * obj >= 0.0)
delta += (floor(value) - value) * obj;
else
delta += (ceil(value) - value) * obj;
} else if (downLocks_[i] == 0)
delta += (floor(value) - value) * obj;
else
delta += (ceil(value) - value) * obj;
}
}
if (direction*(solver->getObjValue() + delta) < solutionValue) {
#ifdef DIVE_DEBUG
nRoundFeasible++;
#endif
if (!nodes||bestColumn<0) {
// Round all the fractional variables
for (int i = 0; i < numberIntegers; i++) {
int iColumn = integerVariable[i];
double value = newSolution[iColumn];
if (fabs(floor(value + 0.5) - value) > integerTolerance) {
assert(downLocks_[i] == 0 || upLocks_[i] == 0);
if (downLocks_[i] == 0 && upLocks_[i] == 0) {
if (direction * objective[iColumn] >= 0.0)
newSolution[iColumn] = floor(value);
else
newSolution[iColumn] = ceil(value);
} else if (downLocks_[i] == 0)
newSolution[iColumn] = floor(value);
else
newSolution[iColumn] = ceil(value);
}
}
break;
} else {
// can't round if going to use in branching
int i;
for (i = 0; i < numberIntegers; i++) {
int iColumn = integerVariable[i];
double value = newSolution[bestColumn];
if (fabs(floor(value + 0.5) - value) > integerTolerance) {
if (iColumn==bestColumn) {
assert(downLocks_[i] == 0 || upLocks_[i] == 0);
double obj = objective[bestColumn];
if (downLocks_[i] == 0 && upLocks_[i] == 0) {
if (direction * obj >= 0.0)
bestRound=-1;
else
bestRound=1;
} else if (downLocks_[i] == 0)
bestRound=-1;
else
bestRound=1;
break;
}
}
}
}
}
#ifdef DIVE_DEBUG
else
nRoundInfeasible++;
#endif
}
// do reduced cost fixing
#ifdef DIVE_DEBUG
int numberFixed = reducedCostFix(solver);
std::cout << "numberReducedCostFixed = " << numberFixed << std::endl;
#else
reducedCostFix(solver);
#endif
int numberAtBoundFixed = 0;
#ifdef DIVE_FIX_BINARY_VARIABLES
// fix binary variables based on pseudo reduced cost
if (binVarIndex_.size()) {
int cnt = 0;
int n = static_cast<int>(binVarIndex_.size());
for (int j = 0; j < n; j++) {
int iColumn1 = binVarIndex_[j];
double value = newSolution[iColumn1];
if (fabs(value) <= integerTolerance &&
lower[iColumn1] != upper[iColumn1]) {
double maxPseudoReducedCost = 0.0;
#ifdef DIVE_DEBUG
std::cout << "iColumn1 = " << iColumn1 << ", value = " << value << std::endl;
#endif
int iRow = vbRowIndex_[j];
double chosenValue = 0.0;
for (int k = rowStart[iRow]; k < rowStart[iRow] + rowLength[iRow]; k++) {
int iColumn2 = column[k];
#ifdef DIVE_DEBUG
std::cout << "iColumn2 = " << iColumn2 << std::endl;
#endif
if (iColumn1 != iColumn2) {
double pseudoReducedCost = fabs(reducedCost[iColumn2] *
elementByRow[k]);
#ifdef DIVE_DEBUG
int k2;
for (k2 = rowStart[iRow]; k2 < rowStart[iRow] + rowLength[iRow]; k2++) {
if (column[k2] == iColumn1)
break;
}
std::cout << "reducedCost[" << iColumn2 << "] = "
<< reducedCost[iColumn2]
<< ", elementByRow[" << iColumn2 << "] = " << elementByRow[k]
<< ", elementByRow[" << iColumn1 << "] = " << elementByRow[k2]
<< ", pseudoRedCost = " << pseudoReducedCost
<< std::endl;
#endif
if (pseudoReducedCost > maxPseudoReducedCost)
maxPseudoReducedCost = pseudoReducedCost;
} else {
// save value
chosenValue = fabs(elementByRow[k]);
}
}
assert (chosenValue);
maxPseudoReducedCost /= chosenValue;
#ifdef DIVE_DEBUG
std::cout << ", maxPseudoRedCost = " << maxPseudoReducedCost << std::endl;
#endif
candidate[cnt].var = iColumn1;
candidate[cnt++].pseudoRedCost = maxPseudoReducedCost;
}
}
#ifdef DIVE_DEBUG
std::cout << "candidates for rounding = " << cnt << std::endl;
#endif
std::sort(candidate, candidate + cnt, compareBinaryVars);
for (int i = 0; i < cnt; i++) {
int iColumn = candidate[i].var;
if (numberAtBoundFixed < maxNumberAtBoundToFix) {
columnFixed[numberAtBoundFixed] = iColumn;
originalBound[numberAtBoundFixed] = upper[iColumn];
fixedAtLowerBound[numberAtBoundFixed] = true;
solver->setColUpper(iColumn, lower[iColumn]);
numberAtBoundFixed++;
if (numberAtBoundFixed == maxNumberAtBoundToFix)
break;
}
}
}
#endif
// fix other integer variables that are at their bounds
int cnt = 0;
#ifdef GAP
double gap = 1.0e30;
#endif
if (reducedCost && true) {
#ifndef JJF_ONE
cnt = fixOtherVariables(solver, solution, candidate, random);
#else
#ifdef GAP
double cutoff = model_->getCutoff() ;
if (cutoff < 1.0e20 && false) {
double direction = solver->getObjSense() ;
gap = cutoff - solver->getObjValue() * direction ;
gap *= 0.1; // Fix more if plausible
double tolerance;
solver->getDblParam(OsiDualTolerance, tolerance) ;
if (gap <= 0.0)
gap = tolerance;
gap += 100.0 * tolerance;
}
int nOverGap = 0;
#endif
int numberFree = 0;
int numberFixed = 0;
for (int i = 0; i < numberIntegers; i++) {
int iColumn = integerVariable[i];
if (upper[iColumn] > lower[iColumn]) {
numberFree++;
double value = newSolution[iColumn];
if (fabs(floor(value + 0.5) - value) <= integerTolerance) {
candidate[cnt].var = iColumn;
candidate[cnt++].pseudoRedCost =
fabs(reducedCost[iColumn] * random[i]);
#ifdef GAP
if (fabs(reducedCost[iColumn]) > gap)
nOverGap++;
#endif
}
} else {
numberFixed++;
}
}
#ifdef GAP
int nLeft = maxNumberAtBoundToFix - numberAtBoundFixed;
#ifdef CLP_INVESTIGATE4
printf("cutoff %g obj %g nover %d - %d free, %d fixed\n",
cutoff, solver->getObjValue(), nOverGap, numberFree, numberFixed);
#endif
if (nOverGap > nLeft && true) {
nOverGap = CoinMin(nOverGap, nLeft + maxNumberAtBoundToFix / 2);
maxNumberAtBoundToFix += nOverGap - nLeft;
}
#else
#ifdef CLP_INVESTIGATE4
printf("cutoff %g obj %g - %d free, %d fixed\n",
model_->getCutoff(), solver->getObjValue(), numberFree, numberFixed);
#endif
#endif
#endif
} else {
for (int i = 0; i < numberIntegers; i++) {
int iColumn = integerVariable[i];
if (upper[iColumn] > lower[iColumn]) {
double value = newSolution[iColumn];
if (fabs(floor(value + 0.5) - value) <= integerTolerance) {
candidate[cnt].var = iColumn;
candidate[cnt++].pseudoRedCost = numberIntegers - i;
}
}
}
}
std::sort(candidate, candidate + cnt, compareBinaryVars);
for (int i = 0; i < cnt; i++) {
int iColumn = candidate[i].var;
if (upper[iColumn] > lower[iColumn]) {
double value = newSolution[iColumn];
if (fabs(floor(value + 0.5) - value) <= integerTolerance &&
numberAtBoundFixed < maxNumberAtBoundToFix) {
// fix the variable at one of its bounds
if (fabs(lower[iColumn] - value) <= integerTolerance) {
columnFixed[numberAtBoundFixed] = iColumn;
originalBound[numberAtBoundFixed] = upper[iColumn];
fixedAtLowerBound[numberAtBoundFixed] = true;
solver->setColUpper(iColumn, lower[iColumn]);
numberAtBoundFixed++;
} else if (fabs(upper[iColumn] - value) <= integerTolerance) {
columnFixed[numberAtBoundFixed] = iColumn;
originalBound[numberAtBoundFixed] = lower[iColumn];
fixedAtLowerBound[numberAtBoundFixed] = false;
solver->setColLower(iColumn, upper[iColumn]);
numberAtBoundFixed++;
}
if (numberAtBoundFixed == maxNumberAtBoundToFix)
break;
}
}
}
#ifdef DIVE_DEBUG
std::cout << "numberAtBoundFixed = " << numberAtBoundFixed << std::endl;
#endif
double originalBoundBestColumn;
double bestColumnValue;
int whichWay;
if (bestColumn >= 0) {
bestColumnValue = newSolution[bestColumn];
if (bestRound < 0) {
originalBoundBestColumn = upper[bestColumn];
solver->setColUpper(bestColumn, floor(bestColumnValue));
whichWay=0;
} else {
originalBoundBestColumn = lower[bestColumn];
solver->setColLower(bestColumn, ceil(bestColumnValue));
whichWay=1;
}
} else {
break;
}
int originalBestRound = bestRound;
int saveModelOptions = model_->specialOptions();
while (1) {
model_->setSpecialOptions(saveModelOptions | 2048);
solver->resolve();
model_->setSpecialOptions(saveModelOptions);
if (!solver->isAbandoned()&&!solver->isIterationLimitReached()) {
numberSimplexIterations += solver->getIterationCount();
} else {
numberSimplexIterations = maxSimplexIterations + 1;
reasonToStop += 100;
break;
}
if (!solver->isProvenOptimal()) {
if (nodes) {
if (solver->isProvenPrimalInfeasible()) {
if (maxSimplexIterationsAtRoot_!=COIN_INT_MAX) {
// stop now
printf("stopping on first infeasibility\n");
break;
} else if (cuts) {
// can do conflict cut
printf("could do intermediate conflict cut\n");
bool localCut;
OsiRowCut * cut = model_->conflictCut(solver,localCut);
if (cut) {
if (!localCut) {
model_->makePartialCut(cut,solver);
cuts[numberCuts++]=cut;
} else {
delete cut;
}
}
}
} else {
reasonToStop += 10;
break;
}
}
if (numberAtBoundFixed > 0) {
// Remove the bound fix for variables that were at bounds
for (int i = 0; i < numberAtBoundFixed; i++) {
int iColFixed = columnFixed[i];
if (fixedAtLowerBound[i])
solver->setColUpper(iColFixed, originalBound[i]);
else
solver->setColLower(iColFixed, originalBound[i]);
}
numberAtBoundFixed = 0;
} else if (bestRound == originalBestRound) {
bestRound *= (-1);
whichWay |=2;
if (bestRound < 0) {
solver->setColLower(bestColumn, originalBoundBestColumn);
solver->setColUpper(bestColumn, floor(bestColumnValue));
} else {
solver->setColLower(bestColumn, ceil(bestColumnValue));
solver->setColUpper(bestColumn, originalBoundBestColumn);
}
} else
break;
} else
break;
}
if (!solver->isProvenOptimal() ||
direction*solver->getObjValue() >= solutionValue) {
reasonToStop += 1;
} else if (iteration > maxIterations_) {
reasonToStop += 2;
} else if (CoinCpuTime() - time1 > maxTime_) {
reasonToStop += 3;
} else if (numberSimplexIterations > maxSimplexIterations) {
reasonToStop += 4;
// also switch off
#ifdef CLP_INVESTIGATE
printf("switching off diving as too many iterations %d, %d allowed\n",
numberSimplexIterations, maxSimplexIterations);
#endif
when_ = 0;
} else if (solver->getIterationCount() > 1000 && iteration > 3 && !nodes) {
reasonToStop += 5;
// also switch off
#ifdef CLP_INVESTIGATE
printf("switching off diving one iteration took %d iterations (total %d)\n",
solver->getIterationCount(), numberSimplexIterations);
#endif
when_ = 0;
}
memcpy(newSolution, solution, numberColumns*sizeof(double));
numberFractionalVariables = 0;
double sumFractionalVariables=0.0;
for (int i = 0; i < numberIntegers; i++) {
int iColumn = integerVariable[i];
double value = newSolution[iColumn];
double away = fabs(floor(value + 0.5) - value);
if (away > integerTolerance) {
numberFractionalVariables++;
sumFractionalVariables += away;
}
}
if (nodes) {
// save information
//branchValues[numberNodes]=bestColumnValue;
//statuses[numberNodes]=whichWay+(bestColumn<<2);
//bases[numberNodes]=solver->getWarmStart();
ClpSimplex * simplex = clpSolver->getModelPtr();
CbcSubProblem * sub =
new CbcSubProblem(clpSolver,lowerBefore,upperBefore,
simplex->statusArray(),numberNodes);
nodes[numberNodes]=sub;
// other stuff
sub->branchValue_=bestColumnValue;
sub->problemStatus_=whichWay;
sub->branchVariable_=bestColumn;
sub->objectiveValue_ = simplex->objectiveValue();
sub->sumInfeasibilities_ = sumFractionalVariables;
sub->numberInfeasibilities_ = numberFractionalVariables;
printf("DiveNode %d column %d way %d bvalue %g obj %g\n",
numberNodes,sub->branchVariable_,sub->problemStatus_,
sub->branchValue_,sub->objectiveValue_);
numberNodes++;
if (solver->isProvenOptimal()) {
memcpy(lastDjs,solver->getReducedCost(),numberColumns*sizeof(double));
memcpy(lowerBefore,lower,numberColumns*sizeof(double));
memcpy(upperBefore,upper,numberColumns*sizeof(double));
}
}
if (!numberFractionalVariables||reasonToStop)
break;
}
if (nodes) {
printf("Exiting dive for reason %d\n",reasonToStop);
if (reasonToStop>1) {
printf("problems in diving\n");
int whichWay=nodes[numberNodes-1]->problemStatus_;
CbcSubProblem * sub;
if ((whichWay&2)==0) {
// leave both ways
sub = new CbcSubProblem(*nodes[numberNodes-1]);
nodes[numberNodes++]=sub;
} else {
sub = nodes[numberNodes-1];
}
if ((whichWay&1)==0)
sub->problemStatus_=whichWay|1;
else
sub->problemStatus_=whichWay&~1;
}
if (!numberNodes) {
// was good at start! - create fake
clpSolver->resolve();
ClpSimplex * simplex = clpSolver->getModelPtr();
CbcSubProblem * sub =
new CbcSubProblem(clpSolver,lowerBefore,upperBefore,
simplex->statusArray(),numberNodes);
nodes[numberNodes]=sub;
// other stuff
sub->branchValue_=0.0;
sub->problemStatus_=0;
sub->branchVariable_=-1;
sub->objectiveValue_ = simplex->objectiveValue();
sub->sumInfeasibilities_ = 0.0;
sub->numberInfeasibilities_ = 0;
printf("DiveNode %d column %d way %d bvalue %g obj %g\n",
numberNodes,sub->branchVariable_,sub->problemStatus_,
sub->branchValue_,sub->objectiveValue_);
numberNodes++;
assert (solver->isProvenOptimal());
}
nodes[numberNodes-1]->problemStatus_ |= 256*reasonToStop;
// use djs as well
if (solver->isProvenPrimalInfeasible()&&cuts) {
// can do conflict cut and re-order
printf("could do final conflict cut\n");
bool localCut;
OsiRowCut * cut = model_->conflictCut(solver,localCut);
if (cut) {
printf("cut - need to use conflict and previous djs\n");
if (!localCut) {
model_->makePartialCut(cut,solver);
cuts[numberCuts++]=cut;
} else {
delete cut;
}
} else {
printf("bad conflict - just use previous djs\n");
}
}
}
// re-compute new solution value
double objOffset = 0.0;
solver->getDblParam(OsiObjOffset, objOffset);
newSolutionValue = -objOffset;
for (int i = 0 ; i < numberColumns ; i++ )
newSolutionValue += objective[i] * newSolution[i];
newSolutionValue *= direction;
//printf("new solution value %g %g\n",newSolutionValue,solutionValue);
if (newSolutionValue < solutionValue && !reasonToStop) {
double * rowActivity = new double[numberRows];
memset(rowActivity, 0, numberRows*sizeof(double));
// paranoid check
memset(rowActivity, 0, numberRows*sizeof(double));
for (int i = 0; i < numberColumns; i++) {
int j;
double value = newSolution[i];
if (value) {
for (j = columnStart[i];
j < columnStart[i] + columnLength[i]; j++) {
int iRow = row[j];
rowActivity[iRow] += value * element[j];
}
}
}
// check was approximately feasible
bool feasible = true;
for (int i = 0; i < numberRows; i++) {
if (rowActivity[i] < rowLower[i]) {
if (rowActivity[i] < rowLower[i] - 1000.0*primalTolerance)
feasible = false;
} else if (rowActivity[i] > rowUpper[i]) {
if (rowActivity[i] > rowUpper[i] + 1000.0*primalTolerance)
feasible = false;
}
}
for (int i = 0; i < numberIntegers; i++) {
int iColumn = integerVariable[i];
double value = newSolution[iColumn];
if (fabs(floor(value + 0.5) - value) > integerTolerance) {
feasible = false;
break;
}
}
if (feasible) {
// new solution
solutionValue = newSolutionValue;
//printf("** Solution of %g found by CbcHeuristicDive\n",newSolutionValue);
//if (cuts)
//clpSolver->getModelPtr()->writeMps("good8.mps", 2);
returnCode = 1;
} else {
// Can easily happen
//printf("Debug CbcHeuristicDive giving bad solution\n");
}
delete [] rowActivity;
}
#ifdef DIVE_DEBUG
std::cout << "nRoundInfeasible = " << nRoundInfeasible
<< ", nRoundFeasible = " << nRoundFeasible
<< ", returnCode = " << returnCode
<< ", reasonToStop = " << reasonToStop
<< ", simplexIts = " << numberSimplexIterations
<< ", iterations = " << iteration << std::endl;
#endif
delete [] columnFixed;
delete [] originalBound;
delete [] fixedAtLowerBound;
delete [] candidate;
delete [] random;
delete [] downArray_;
downArray_ = NULL;
delete [] upArray_;
upArray_ = NULL;
delete solver;
return returnCode;
}
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) ;
}
