//===========================================================================//
CoinWarmStartBasis* UtilAlpsDecodeWarmStart(AlpsEncoded& encoded,
AlpsReturnStatus* rc)
{
//rc not used? not checked?
int numCols;
int numRows;
encoded.readRep(numCols);
encoded.readRep(numRows);
int tempInt;
// Structural
int nint = (numCols + 15) >> 4;
char* structuralStatus = new char[4 * nint];
encoded.readRep(structuralStatus, tempInt);
assert(tempInt == nint * 4);
// Artificial
nint = (numRows + 15) >> 4;
char* artificialStatus = new char[4 * nint];
encoded.readRep(artificialStatus, tempInt);
assert(tempInt == nint * 4);
CoinWarmStartBasis* ws = new CoinWarmStartBasis();
if (!ws) {
throw CoinError("Out of memory", "UtilAlpsDecodeWarmStart", "HELP");
}
ws->assignBasisStatus(numCols, numRows,
structuralStatus, artificialStatus);
return ws;
}
CoinWarmStartBasis *CoinPrePostsolveMatrix::getStatus ()
{ int n = ncols_ ;
int m = nrows_ ;
CoinWarmStartBasis *wsb = new CoinWarmStartBasis() ;
wsb->setSize(n,m) ;
for (int j = 0 ; j < n ; j++)
{ CoinWarmStartBasis::Status statj =
CoinWarmStartBasis::Status(getColumnStatus(j)) ;
wsb->setStructStatus(j,statj) ; }
for (int i = 0 ; i < m ; i++)
{ CoinWarmStartBasis::Status stati =
CoinWarmStartBasis::Status(getRowStatus(i)) ;
wsb->setArtifStatus(i,stati) ; }
return (wsb) ; }
/* returns 0 if no solution, 1 if valid solution
with better objective value than one passed in
also returns list of nodes
This does Fractional Diving
*/
int
CbcHeuristicDive::fathom(CbcModel * model, int & numberNodes,
CbcSubProblem ** & nodes)
{
double solutionValue = model->getCutoff();
numberNodes=0;
// Get solution array for heuristic solution
int numberColumns = model_->solver()->getNumCols();
double * newSolution = new double [4*numberColumns];
double * lastDjs = newSolution+numberColumns;
double * originalLower = lastDjs+numberColumns;
double * originalUpper = originalLower+numberColumns;
memcpy(originalLower,model_->solver()->getColLower(),
numberColumns*sizeof(double));
memcpy(originalUpper,model_->solver()->getColUpper(),
numberColumns*sizeof(double));
int numberCuts=0;
OsiRowCut ** cuts = NULL; //new OsiRowCut * [maxIterations_];
nodes=new CbcSubProblem * [maxIterations_+2];
int returnCode=solution(solutionValue,numberNodes,numberCuts,
cuts,nodes,
newSolution);
if (returnCode==1) {
// copy to best solution ? or put in solver
printf("Solution from heuristic fathom\n");
}
int numberFeasibleNodes=numberNodes;
if (returnCode!=1)
numberFeasibleNodes--;
if (numberFeasibleNodes>0) {
CoinWarmStartBasis * basis = nodes[numberFeasibleNodes-1]->status_;
//double * sort = new double [numberFeasibleNodes];
//int * whichNode = new int [numberFeasibleNodes];
//int numberNodesNew=0;
// use djs on previous unless feasible
for (int iNode=0;iNode<numberFeasibleNodes;iNode++) {
CbcSubProblem * sub = nodes[iNode];
double branchValue = sub->branchValue_;
int iStatus=sub->problemStatus_;
int iColumn = sub->branchVariable_;
bool secondBranch = (iStatus&2)!=0;
bool branchUp;
if (!secondBranch)
branchUp = (iStatus&1)!=0;
else
branchUp = (iStatus&1)==0;
double djValue=lastDjs[iColumn];
sub->djValue_=fabs(djValue);
if (!branchUp&&floor(branchValue)==originalLower[iColumn]
&&basis->getStructStatus(iColumn) == CoinWarmStartBasis::atLowerBound) {
if (djValue>0.0) {
// naturally goes to LB
printf("ignoring branch down on %d (node %d) from value of %g - branch was %s - dj %g\n",
iColumn,iNode,branchValue,secondBranch ? "second" : "first",
djValue);
sub->problemStatus_ |= 4;
//} else {
// put on list
//sort[numberNodesNew]=djValue;
//whichNode[numberNodesNew++]=iNode;
}
} else if (branchUp&&ceil(branchValue)==originalUpper[iColumn]
&&basis->getStructStatus(iColumn) == CoinWarmStartBasis::atUpperBound) {
if (djValue<0.0) {
// naturally goes to UB
printf("ignoring branch up on %d (node %d) from value of %g - branch was %s - dj %g\n",
iColumn,iNode,branchValue,secondBranch ? "second" : "first",
djValue);
sub->problemStatus_ |= 4;
//} else {
// put on list
//sort[numberNodesNew]=-djValue;
//whichNode[numberNodesNew++]=iNode;
}
}
}
// use conflict to order nodes
for (int iCut=0;iCut<numberCuts;iCut++) {
}
//CoinSort_2(sort,sort+numberNodesNew,whichNode);
// create nodes
// last node will have one way already done
}
for (int iCut=0;iCut<numberCuts;iCut++) {
delete cuts[iCut];
}
delete [] cuts;
delete [] newSolution;
return returnCode;
}
// Apply subproblem
void
CbcSubProblem::apply(OsiSolverInterface * solver, int what) const
{
int i;
if ((what&1) != 0) {
#ifndef NDEBUG
int nSame = 0;
#endif
for (i = 0; i < numberChangedBounds_; i++) {
int variable = variables_[i];
int k = variable & 0x3fffffff;
if ((variable&0x80000000) == 0) {
// lower bound changing
//#define CBC_PRINT2
#ifdef CBC_PRINT2
if (solver->getColLower()[k] != newBounds_[i])
printf("lower change for column %d - from %g to %g\n", k, solver->getColLower()[k], newBounds_[i]);
#endif
#ifndef NDEBUG
if ((variable&0x40000000) == 0 && true) {
double oldValue = solver->getColLower()[k];
assert (newBounds_[i] > oldValue - 1.0e-8);
if (newBounds_[i] < oldValue + 1.0e-8) {
#ifdef CBC_PRINT2
printf("bad null lower change for column %d - bound %g\n", k, oldValue);
#endif
if (newBounds_[i] == oldValue)
nSame++;
}
}
#endif
solver->setColLower(k, newBounds_[i]);
} else {
// upper bound changing
#ifdef CBC_PRINT2
if (solver->getColUpper()[k] != newBounds_[i])
printf("upper change for column %d - from %g to %g\n", k, solver->getColUpper()[k], newBounds_[i]);
#endif
#ifndef NDEBUG
if ((variable&0x40000000) == 0 && true) {
double oldValue = solver->getColUpper()[k];
assert (newBounds_[i] < oldValue + 1.0e-8);
if (newBounds_[i] > oldValue - 1.0e-8) {
#ifdef CBC_PRINT2
printf("bad null upper change for column %d - bound %g\n", k, oldValue);
#endif
if (newBounds_[i] == oldValue)
nSame++;
}
}
#endif
solver->setColUpper(k, newBounds_[i]);
}
}
#ifndef NDEBUG
#ifdef CBC_PRINT2
if (nSame && (nSame < numberChangedBounds_ || (what&3) != 3))
printf("%d changes out of %d redundant %d\n",
nSame, numberChangedBounds_, what);
else if (numberChangedBounds_ && what == 7 && !nSame)
printf("%d good changes %d\n",
numberChangedBounds_, what);
#endif
#endif
}
#ifdef JJF_ZERO
if ((what&2) != 0) {
OsiClpSolverInterface * clpSolver
= dynamic_cast<OsiClpSolverInterface *> (solver);
assert (clpSolver);
//assert (clpSolver->getNumRows()==numberRows_);
//clpSolver->setBasis(*status_);
// Current basis
CoinWarmStartBasis * basis = clpSolver->getPointerToWarmStart();
printf("BBBB\n");
basis->print();
assert (basis->fullBasis());
basis->applyDiff(status_);
printf("diff applied %x\n", status_);
printf("CCCC\n");
basis->print();
assert (basis->fullBasis());
#ifndef NDEBUG
if (!basis->fullBasis())
printf("Debug this basis!!\n");
#endif
clpSolver->setBasis(*basis);
}
#endif
if ((what&8) != 0) {
OsiClpSolverInterface * clpSolver
= dynamic_cast<OsiClpSolverInterface *> (solver);
assert (clpSolver);
clpSolver->setBasis(*status_);
delete status_;
status_ = NULL;
}
}
//--------------------------------------------------------------------------
// test solution methods.
void OsiCbcSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir)
{
{
CoinRelFltEq eq;
OsiCbcSolverInterface m;
std::string fn = mpsDir+"exmip1";
m.readMps(fn.c_str(),"mps");
{
OsiCbcSolverInterface im;
OSIUNITTEST_ASSERT_ERROR(im.getNumCols() == 0, {}, "cbc", "default constructor");
OSIUNITTEST_ASSERT_ERROR(im.getModelPtr() != NULL, {}, "cbc", "default constructor");
}
// Test copy constructor and assignment operator
{
OsiCbcSolverInterface lhs;
{
OsiCbcSolverInterface im(m);
OsiCbcSolverInterface imC1(im);
OSIUNITTEST_ASSERT_ERROR(imC1.getModelPtr() != im.getModelPtr(), {}, "cbc", "copy constructor");
OSIUNITTEST_ASSERT_ERROR(imC1.getNumCols() == im.getNumCols(), {}, "cbc", "copy constructor");
OSIUNITTEST_ASSERT_ERROR(imC1.getNumRows() == im.getNumRows(), {}, "cbc", "copy constructor");
OsiCbcSolverInterface imC2(im);
OSIUNITTEST_ASSERT_ERROR(imC2.getModelPtr() != im.getModelPtr(), {}, "cbc", "copy constructor");
OSIUNITTEST_ASSERT_ERROR(imC2.getNumCols() == im.getNumCols(), {}, "cbc", "copy constructor");
OSIUNITTEST_ASSERT_ERROR(imC2.getNumRows() == im.getNumRows(), {}, "cbc", "copy constructor");
OSIUNITTEST_ASSERT_ERROR(imC1.getModelPtr() != imC2.getModelPtr(), {}, "cbc", "copy constructor");
lhs = imC2;
}
// Test that lhs has correct values even though rhs has gone out of scope
OSIUNITTEST_ASSERT_ERROR(lhs.getModelPtr() != m.getModelPtr(), {}, "cbc", "assignment operator");
OSIUNITTEST_ASSERT_ERROR(lhs.getNumCols() == m.getNumCols(), {}, "cbc", "copy constructor");
OSIUNITTEST_ASSERT_ERROR(lhs.getNumRows() == m.getNumRows(), {}, "cbc", "copy constructor");
}
// Test clone
{
OsiCbcSolverInterface cbcSi(m);
OsiSolverInterface * siPtr = &cbcSi;
OsiSolverInterface * siClone = siPtr->clone();
OsiCbcSolverInterface * cbcClone = dynamic_cast<OsiCbcSolverInterface*>(siClone);
OSIUNITTEST_ASSERT_ERROR(cbcClone != NULL, {}, "cbc", "clone");
OSIUNITTEST_ASSERT_ERROR(cbcClone->getModelPtr() != cbcSi.getModelPtr(), {}, "cbc", "clone");
OSIUNITTEST_ASSERT_ERROR(cbcClone->getNumRows() == cbcSi.getNumRows(), {}, "cbc", "clone");
OSIUNITTEST_ASSERT_ERROR(cbcClone->getNumCols() == m.getNumCols(), {}, "cbc", "clone");
delete siClone;
}
// test infinity
{
OsiCbcSolverInterface si;
OSIUNITTEST_ASSERT_ERROR(si.getInfinity() == OsiCbcInfinity, {}, "cbc", "infinity");
}
// Test some catches
if (!OsiCbcHasNDEBUG())
{
OsiCbcSolverInterface solver;
try {
solver.setObjCoeff(0,0.0);
OSIUNITTEST_ADD_OUTCOME("cbc", "setObjCoeff on empty model", "should throw exception", OsiUnitTest::TestOutcome::ERROR, false);
}
catch (CoinError e) {
if (OsiUnitTest::verbosity >= 1)
std::cout<<"Correct throw from setObjCoeff on empty model"<<std::endl;
}
std::string fn = mpsDir+"exmip1";
solver.readMps(fn.c_str(),"mps");
OSIUNITTEST_CATCH_ERROR(solver.setObjCoeff(0,0.0), {}, "cbc", "setObjCoeff on nonempty model");
try {
int index[]={0,20};
double value[]={0.0,0.0,0.0,0.0};
solver.setColSetBounds(index,index+2,value);
OSIUNITTEST_ADD_OUTCOME("cbc", "setColSetBounds on cols not in model", "should throw exception", OsiUnitTest::TestOutcome::ERROR, false);
}
catch (CoinError e) {
if (OsiUnitTest::verbosity >= 1)
std::cout<<"Correct throw from setObjCoeff on empty model"<<std::endl;
}
}
{
OsiCbcSolverInterface cbcSi(m);
int nc = cbcSi.getNumCols();
int nr = cbcSi.getNumRows();
const double * cl = cbcSi.getColLower();
const double * cu = cbcSi.getColUpper();
const double * rl = cbcSi.getRowLower();
const double * ru = cbcSi.getRowUpper();
OSIUNITTEST_ASSERT_ERROR(nc == 8, return, "cbc", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(nr == 5, return, "cbc", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(cl[0],2.5), {}, "cbc", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(cl[1],0.0), {}, "cbc", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(cu[1],4.1), {}, "cbc", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(cu[2],1.0), {}, "cbc", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(rl[0],2.5), {}, "cbc", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(rl[4],3.0), {}, "cbc", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(ru[1],2.1), {}, "cbc", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(ru[4],15.), {}, "cbc", "read and copy exmip1");
const double * cs = cbcSi.getColSolution();
OSIUNITTEST_ASSERT_ERROR(eq(cs[0],2.5), {}, "cbc", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(cs[7],0.0), {}, "cbc", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(!eq(cl[3],1.2345), {}, "cbc", "set col lower");
cbcSi.setColLower( 3, 1.2345 );
OSIUNITTEST_ASSERT_ERROR( eq(cbcSi.getColLower()[3],1.2345), {}, "cbc", "set col lower");
OSIUNITTEST_ASSERT_ERROR(!eq(cbcSi.getColUpper()[4],10.2345), {}, "cbc", "set col upper");
cbcSi.setColUpper( 4, 10.2345 );
OSIUNITTEST_ASSERT_ERROR( eq(cbcSi.getColUpper()[4],10.2345), {}, "cbc", "set col upper");
// LH: Objective will depend on how underlying solver constructs and maintains initial solution
double objValue = cbcSi.getObjValue();
OSIUNITTEST_ASSERT_ERROR(eq(objValue,3.5) || eq(objValue,10.5), {}, "cbc", "getObjValue() before solve");
OSIUNITTEST_ASSERT_ERROR(eq(cbcSi.getObjCoefficients()[0], 1.0), {}, "cbc", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(cbcSi.getObjCoefficients()[1], 0.0), {}, "cbc", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(cbcSi.getObjCoefficients()[2], 0.0), {}, "cbc", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(cbcSi.getObjCoefficients()[3], 0.0), {}, "cbc", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(cbcSi.getObjCoefficients()[4], 2.0), {}, "cbc", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(cbcSi.getObjCoefficients()[5], 0.0), {}, "cbc", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(cbcSi.getObjCoefficients()[6], 0.0), {}, "cbc", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(cbcSi.getObjCoefficients()[7],-1.0), {}, "cbc", "read and copy exmip1");
}
// Test matrixByRow method
{
const OsiCbcSolverInterface si(m);
const CoinPackedMatrix * smP = si.getMatrixByRow();
OSIUNITTEST_ASSERT_ERROR(smP->getMajorDim() == 5, return, "cbc", "getMatrixByRow: major dim");
OSIUNITTEST_ASSERT_ERROR(smP->getMinorDim() == 8, return, "cbc", "getMatrixByRow: major dim");
OSIUNITTEST_ASSERT_ERROR(smP->getNumElements() == 14, return, "cbc", "getMatrixByRow: num elements");
OSIUNITTEST_ASSERT_ERROR(smP->getSizeVectorStarts() == 6, return, "cbc", "getMatrixByRow: num elements");
#ifdef OSICBC_TEST_MTX_STRUCTURE
CoinRelFltEq eq;
const double * ev = smP->getElements();
OSIUNITTEST_ASSERT_ERROR(eq(ev[0], 3.0), {}, "cbc", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[1], 1.0), {}, "cbc", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[2], -2.0), {}, "cbc", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[3], -1.0), {}, "cbc", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[4], -1.0), {}, "cbc", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[5], 2.0), {}, "cbc", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[6], 1.1), {}, "cbc", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[7], 1.0), {}, "cbc", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[8], 1.0), {}, "cbc", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[9], 2.8), {}, "cbc", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[10], -1.2), {}, "cbc", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[11], 5.6), {}, "cbc", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[12], 1.0), {}, "cbc", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[13], 1.9), {}, "cbc", "getMatrixByRow: elements");
const int * mi = smP->getVectorStarts();
OSIUNITTEST_ASSERT_ERROR(mi[0] == 0, {}, "cbc", "getMatrixByRow: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[1] == 5, {}, "cbc", "getMatrixByRow: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[2] == 7, {}, "cbc", "getMatrixByRow: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[3] == 9, {}, "cbc", "getMatrixByRow: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[4] == 11, {}, "cbc", "getMatrixByRow: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[5] == 14, {}, "cbc", "getMatrixByRow: vector starts");
const int * ei = smP->getIndices();
OSIUNITTEST_ASSERT_ERROR(ei[ 0] == 0, {}, "cbc", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 1] == 1, {}, "cbc", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 2] == 3, {}, "cbc", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 3] == 4, {}, "cbc", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 4] == 7, {}, "cbc", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 5] == 1, {}, "cbc", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 6] == 2, {}, "cbc", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 7] == 2, {}, "cbc", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 8] == 5, {}, "cbc", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 9] == 3, {}, "cbc", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[10] == 6, {}, "cbc", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[11] == 0, {}, "cbc", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[12] == 4, {}, "cbc", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[13] == 7, {}, "cbc", "getMatrixByRow: indices");
#else // OSICBC_TEST_MTX_STRUCTURE
CoinPackedMatrix exmip1Mtx ;
exmip1Mtx.reverseOrderedCopyOf(BuildExmip1Mtx()) ;
OSIUNITTEST_ASSERT_ERROR(exmip1Mtx.isEquivalent(*smP), {}, "cbc", "getMatrixByRow") ;
#endif // OSICBC_TEST_MTX_STRUCTURE
}
// Test adding several cuts, and handling of a coefficient of infinity
// in the constraint matrix.
{
OsiCbcSolverInterface fim;
std::string fn = mpsDir+"exmip1";
fim.readMps(fn.c_str(),"mps");
// exmip1.mps has 2 integer variables with index 2 & 3
fim.initialSolve();
OsiRowCut cuts[3];
// Generate one ineffective cut plus two trivial cuts
int c;
int nc = fim.getNumCols();
int *inx = new int[nc];
for (c=0;c<nc;c++) inx[c]=c;
double *el = new double[nc];
for (c=0;c<nc;c++) el[c]=1.0e-50+((double)c)*((double)c);
cuts[0].setRow(nc,inx,el);
cuts[0].setLb(-100.);
cuts[0].setUb(500.);
cuts[0].setEffectiveness(22);
el[4]=0.0; // to get inf later
for (c=2;c<4;c++) {
el[0]=1.0;
inx[0]=c;
cuts[c-1].setRow(1,inx,el);
cuts[c-1].setLb(1.);
cuts[c-1].setUb(100.);
cuts[c-1].setEffectiveness(c);
}
fim.writeMps("x1.mps");
fim.applyRowCuts(3,cuts);
fim.writeMps("x2.mps");
// resolve - should get message about zero elements
fim.resolve();
fim.writeMps("x3.mps");
// check integer solution
const double * cs = fim.getColSolution();
CoinRelFltEq eq;
OSIUNITTEST_ASSERT_ERROR(eq(cs[2], 1.0), {}, "cbc", "add cuts");
OSIUNITTEST_ASSERT_ERROR(eq(cs[3], 1.0), {}, "cbc", "add cuts");
// check will find invalid matrix
el[0]=1.0/el[4];
inx[0]=0;
cuts[0].setRow(nc,inx,el);
cuts[0].setLb(-100.);
cuts[0].setUb(500.);
cuts[0].setEffectiveness(22);
fim.applyRowCut(cuts[0]);
// resolve - should get message about zero elements
fim.resolve();
OSIUNITTEST_ASSERT_WARNING(fim.isAbandoned(), {}, "cbc", "add cuts");
delete[]el;
delete[]inx;
}
// Test matrixByCol method
{
const OsiCbcSolverInterface si(m);
const CoinPackedMatrix * smP = si.getMatrixByCol();
OSIUNITTEST_ASSERT_ERROR(smP->getMajorDim() == 8, return, "cbc", "getMatrixByCol: major dim");
OSIUNITTEST_ASSERT_ERROR(smP->getMinorDim() == 5, return, "cbc", "getMatrixByCol: minor dim");
OSIUNITTEST_ASSERT_ERROR(smP->getNumElements() == 14, return, "cbc", "getMatrixByCol: number of elements");
OSIUNITTEST_ASSERT_ERROR(smP->getSizeVectorStarts() == 9, return, "cbc", "getMatrixByCol: vector starts size");
#ifdef OSICBC_TEST_MTX_STRUCTURE
CoinRelFltEq eq;
const double * ev = smP->getElements();
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 0], 3.0), {}, "cbc", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 1], 5.6), {}, "cbc", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 2], 1.0), {}, "cbc", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 3], 2.0), {}, "cbc", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 4], 1.1), {}, "cbc", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 5], 1.0), {}, "cbc", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 6],-2.0), {}, "cbc", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 7], 2.8), {}, "cbc", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 8],-1.0), {}, "cbc", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 9], 1.0), {}, "cbc", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[10], 1.0), {}, "cbc", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[11],-1.2), {}, "cbc", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[12],-1.0), {}, "cbc", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[13], 1.9), {}, "cbc", "getMatrixByCol: elements");
const CoinBigIndex * mi = smP->getVectorStarts();
OSIUNITTEST_ASSERT_ERROR(mi[0] == 0, {}, "cbc", "getMatrixByCol: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[1] == 2, {}, "cbc", "getMatrixByCol: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[2] == 4, {}, "cbc", "getMatrixByCol: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[3] == 6, {}, "cbc", "getMatrixByCol: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[4] == 8, {}, "cbc", "getMatrixByCol: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[5] == 10, {}, "cbc", "getMatrixByCol: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[6] == 11, {}, "cbc", "getMatrixByCol: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[7] == 12, {}, "cbc", "getMatrixByCol: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[8] == 14, {}, "cbc", "getMatrixByCol: vector starts");
const int * ei = smP->getIndices();
OSIUNITTEST_ASSERT_ERROR(ei[ 0] == 0, {}, "cbc", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 1] == 4, {}, "cbc", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 2] == 0, {}, "cbc", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 3] == 1, {}, "cbc", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 4] == 1, {}, "cbc", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 5] == 2, {}, "cbc", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 6] == 0, {}, "cbc", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 7] == 3, {}, "cbc", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 8] == 0, {}, "cbc", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 9] == 4, {}, "cbc", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[10] == 2, {}, "cbc", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[11] == 3, {}, "cbc", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[12] == 0, {}, "cbc", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[13] == 4, {}, "cbc", "getMatrixByCol: indices");
#else // OSICBC_TEST_MTX_STRUCTURE
CoinPackedMatrix &exmip1Mtx = BuildExmip1Mtx() ;
OSIUNITTEST_ASSERT_ERROR(exmip1Mtx.isEquivalent(*smP), {}, "cbc", "getMatrixByCol");
#endif // OSICBC_TEST_MTX_STRUCTURE
}
//--------------
// Test rowsense, rhs, rowrange, matrixByRow, solver assignment
{
OsiCbcSolverInterface lhs;
{
OsiCbcSolverInterface siC1(m);
const char * siC1rs = siC1.getRowSense();
OSIUNITTEST_ASSERT_ERROR(siC1rs[0] == 'G', {}, "cbc", "row sense");
OSIUNITTEST_ASSERT_ERROR(siC1rs[1] == 'L', {}, "cbc", "row sense");
OSIUNITTEST_ASSERT_ERROR(siC1rs[2] == 'E', {}, "cbc", "row sense");
OSIUNITTEST_ASSERT_ERROR(siC1rs[3] == 'R', {}, "cbc", "row sense");
OSIUNITTEST_ASSERT_ERROR(siC1rs[4] == 'R', {}, "cbc", "row sense");
const double * siC1rhs = siC1.getRightHandSide();
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[0],2.5), {}, "cbc", "right hand side");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[1],2.1), {}, "cbc", "right hand side");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[2],4.0), {}, "cbc", "right hand side");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[3],5.0), {}, "cbc", "right hand side");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[4],15.), {}, "cbc", "right hand side");
const double * siC1rr = siC1.getRowRange();
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[0],0.0), {}, "cbc", "row range");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[1],0.0), {}, "cbc", "row range");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[2],0.0), {}, "cbc", "row range");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[3],5.0-1.8), {}, "cbc", "row range");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[4],15.0-3.0), {}, "cbc", "row range");
const CoinPackedMatrix * siC1mbr = siC1.getMatrixByRow();
OSIUNITTEST_ASSERT_ERROR(siC1mbr != NULL, {}, "cbc", "matrix by row");
OSIUNITTEST_ASSERT_ERROR(siC1mbr->getMajorDim() == 5, return, "cbc", "matrix by row: major dim");
OSIUNITTEST_ASSERT_ERROR(siC1mbr->getMinorDim() == 8, return, "cbc", "matrix by row: major dim");
OSIUNITTEST_ASSERT_ERROR(siC1mbr->getNumElements() == 14, return, "cbc", "matrix by row: num elements");
OSIUNITTEST_ASSERT_ERROR(siC1mbr->getSizeVectorStarts() == 6, return, "cbc", "matrix by row: num elements");
#ifdef OSICBC_TEST_MTX_STRUCTURE
const double * ev = siC1mbr->getElements();
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 0], 3.0), {}, "cbc", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 1], 1.0), {}, "cbc", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 2],-2.0), {}, "cbc", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 3],-1.0), {}, "cbc", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 4],-1.0), {}, "cbc", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 5], 2.0), {}, "cbc", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 6], 1.1), {}, "cbc", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 7], 1.0), {}, "cbc", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 8], 1.0), {}, "cbc", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 9], 2.8), {}, "cbc", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[10],-1.2), {}, "cbc", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[11], 5.6), {}, "cbc", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[12], 1.0), {}, "cbc", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[13], 1.9), {}, "cbc", "matrix by row: elements");
const CoinBigIndex * mi = siC1mbr->getVectorStarts();
OSIUNITTEST_ASSERT_ERROR(mi[0] == 0, {}, "cbc", "matrix by row: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[1] == 5, {}, "cbc", "matrix by row: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[2] == 7, {}, "cbc", "matrix by row: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[3] == 9, {}, "cbc", "matrix by row: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[4] == 11, {}, "cbc", "matrix by row: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[5] == 14, {}, "cbc", "matrix by row: vector starts");
const int * ei = siC1mbr->getIndices();
OSIUNITTEST_ASSERT_ERROR(ei[ 0] == 0, {}, "cbc", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 1] == 1, {}, "cbc", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 2] == 3, {}, "cbc", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 3] == 4, {}, "cbc", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 4] == 7, {}, "cbc", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 5] == 1, {}, "cbc", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 6] == 2, {}, "cbc", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 7] == 2, {}, "cbc", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 8] == 5, {}, "cbc", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 9] == 3, {}, "cbc", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[10] == 6, {}, "cbc", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[11] == 0, {}, "cbc", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[12] == 4, {}, "cbc", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[13] == 7, {}, "cbc", "matrix by row: indices");
#else // OSICBC_TEST_MTX_STRUCTURE
CoinPackedMatrix exmip1Mtx ;
exmip1Mtx.reverseOrderedCopyOf(BuildExmip1Mtx()) ;
OSIUNITTEST_ASSERT_ERROR(exmip1Mtx.isEquivalent(*siC1mbr), {}, "cbc", "matrix by row");
#endif // OSICBC_TEST_MTX_STRUCTURE
OSIUNITTEST_ASSERT_WARNING(siC1rs == siC1.getRowSense(), {}, "cbc", "row sense");
OSIUNITTEST_ASSERT_WARNING(siC1rhs == siC1.getRightHandSide(), {}, "cbc", "right hand side");
OSIUNITTEST_ASSERT_WARNING(siC1rr == siC1.getRowRange(), {}, "cbc", "row range");
// Change CBC Model by adding free row
OsiRowCut rc;
rc.setLb(-COIN_DBL_MAX);
rc.setUb( COIN_DBL_MAX);
OsiCuts cuts;
cuts.insert(rc);
siC1.applyCuts(cuts);
siC1rs = siC1.getRowSense();
OSIUNITTEST_ASSERT_ERROR(siC1rs[0] == 'G', {}, "cbc", "row sense after adding row");
OSIUNITTEST_ASSERT_ERROR(siC1rs[1] == 'L', {}, "cbc", "row sense after adding row");
OSIUNITTEST_ASSERT_ERROR(siC1rs[2] == 'E', {}, "cbc", "row sense after adding row");
OSIUNITTEST_ASSERT_ERROR(siC1rs[3] == 'R', {}, "cbc", "row sense after adding row");
OSIUNITTEST_ASSERT_ERROR(siC1rs[4] == 'R', {}, "cbc", "row sense after adding row");
OSIUNITTEST_ASSERT_ERROR(siC1rs[5] == 'N', {}, "cbc", "row sense after adding row");
siC1rhs = siC1.getRightHandSide();
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[0],2.5), {}, "cbc", "right hand side after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[1],2.1), {}, "cbc", "right hand side after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[2],4.0), {}, "cbc", "right hand side after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[3],5.0), {}, "cbc", "right hand side after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[4],15.), {}, "cbc", "right hand side after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[5],0.0), {}, "cbc", "right hand side after adding row");
siC1rr = siC1.getRowRange();
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[0],0.0), {}, "cbc", "row range after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[1],0.0), {}, "cbc", "row range after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[2],0.0), {}, "cbc", "row range after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[3],5.0-1.8), {}, "cbc", "row range after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[4],15.0-3.0), {}, "cbc", "row range after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[5],0.0), {}, "cbc", "row range after adding row");
lhs = siC1;
}
// Test that lhs has correct values even though siC1 has gone out of scope
const char * lhsrs = lhs.getRowSense();
OSIUNITTEST_ASSERT_ERROR(lhsrs[0] == 'G', {}, "cbc", "row sense after assignment");
OSIUNITTEST_ASSERT_ERROR(lhsrs[1] == 'L', {}, "cbc", "row sense after assignment");
OSIUNITTEST_ASSERT_ERROR(lhsrs[2] == 'E', {}, "cbc", "row sense after assignment");
OSIUNITTEST_ASSERT_ERROR(lhsrs[3] == 'R', {}, "cbc", "row sense after assignment");
OSIUNITTEST_ASSERT_ERROR(lhsrs[4] == 'R', {}, "cbc", "row sense after assignment");
OSIUNITTEST_ASSERT_ERROR(lhsrs[5] == 'N', {}, "cbc", "row sense after assignment");
const double * lhsrhs = lhs.getRightHandSide();
OSIUNITTEST_ASSERT_ERROR(eq(lhsrhs[0],2.5), {}, "cbc", "right hand side after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrhs[1],2.1), {}, "cbc", "right hand side after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrhs[2],4.0), {}, "cbc", "right hand side after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrhs[3],5.0), {}, "cbc", "right hand side after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrhs[4],15.), {}, "cbc", "right hand side after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrhs[5],0.0), {}, "cbc", "right hand side after assignment");
const double *lhsrr = lhs.getRowRange();
OSIUNITTEST_ASSERT_ERROR(eq(lhsrr[0],0.0), {}, "cbc", "row range after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrr[1],0.0), {}, "cbc", "row range after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrr[2],0.0), {}, "cbc", "row range after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrr[3],5.0-1.8), {}, "cbc", "row range after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrr[4],15.0-3.0), {}, "cbc", "row range after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrr[5],0.0), {}, "cbc", "row range after assignment");
const CoinPackedMatrix * lhsmbr = lhs.getMatrixByRow();
OSIUNITTEST_ASSERT_ERROR(lhsmbr != NULL, {}, "cbc", "matrix by row after assignment");
OSIUNITTEST_ASSERT_ERROR(lhsmbr->getMajorDim() == 6, return, "cbc", "matrix by row after assignment: major dim");
OSIUNITTEST_ASSERT_ERROR(lhsmbr->getNumElements() == 14, return, "cbc", "matrix by row after assignment: num elements");
#ifdef OSICBC_TEST_MTX_STRUCTURE
const double * ev = lhsmbr->getElements();
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 0], 3.0), {}, "cbc", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 1], 1.0), {}, "cbc", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 2],-2.0), {}, "cbc", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 3],-1.0), {}, "cbc", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 4],-1.0), {}, "cbc", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 5], 2.0), {}, "cbc", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 6], 1.1), {}, "cbc", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 7], 1.0), {}, "cbc", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 8], 1.0), {}, "cbc", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 9], 2.8), {}, "cbc", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[10],-1.2), {}, "cbc", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[11], 5.6), {}, "cbc", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[12], 1.0), {}, "cbc", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[13], 1.9), {}, "cbc", "matrix by row after assignment: elements");
const CoinBigIndex * mi = lhsmbr->getVectorStarts();
OSIUNITTEST_ASSERT_ERROR(mi[0] == 0, {}, "cbc", "matrix by row after assignment: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[1] == 5, {}, "cbc", "matrix by row after assignment: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[2] == 7, {}, "cbc", "matrix by row after assignment: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[3] == 9, {}, "cbc", "matrix by row after assignment: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[4] == 11, {}, "cbc", "matrix by row after assignment: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[5] == 14, {}, "cbc", "matrix by row after assignment: vector starts");
const int * ei = lhsmbr->getIndices();
OSIUNITTEST_ASSERT_ERROR(ei[ 0] == 0, {}, "cbc", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 1] == 1, {}, "cbc", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 2] == 3, {}, "cbc", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 3] == 4, {}, "cbc", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 4] == 7, {}, "cbc", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 5] == 1, {}, "cbc", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 6] == 2, {}, "cbc", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 7] == 2, {}, "cbc", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 8] == 5, {}, "cbc", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 9] == 3, {}, "cbc", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[10] == 6, {}, "cbc", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[11] == 0, {}, "cbc", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[12] == 4, {}, "cbc", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[13] == 7, {}, "cbc", "matrix by row after assignment: indices");
#else // OSICBC_TEST_MTX_STRUCTURE
/*
This admittedly looks bogus, but it's the equivalent operation on the matrix
for inserting a cut of the form -Inf <= +Inf (i.e., a cut with no
coefficients).
*/
CoinPackedMatrix exmip1Mtx ;
exmip1Mtx.reverseOrderedCopyOf(BuildExmip1Mtx()) ;
CoinPackedVector freeRow ;
exmip1Mtx.appendRow(freeRow) ;
OSIUNITTEST_ASSERT_ERROR(exmip1Mtx.isEquivalent(*lhsmbr), {}, "cbc", "matrix by row after assignment");
#endif // OSICBC_TEST_MTX_STRUCTURE
}
}
// Test add/delete columns
{
OsiCbcSolverInterface m;
std::string fn = mpsDir+"p0033";
m.readMps(fn.c_str(),"mps");
double inf = m.getInfinity();
CoinPackedVector c0;
c0.insert(0, 4);
c0.insert(1, 1);
m.addCol(c0, 0, inf, 3);
m.initialSolve();
double objValue = m.getObjValue();
CoinRelFltEq eq(1.0e-2);
OSIUNITTEST_ASSERT_ERROR(eq(objValue,2520.57), {}, "cbc", "objvalue after adding col");
// Try deleting first column that's nonbasic at lower bound (0).
int * d = new int[1];
CoinWarmStartBasis *cwsb = dynamic_cast<CoinWarmStartBasis *>(m.getWarmStart()) ;
OSIUNITTEST_ASSERT_ERROR(cwsb != NULL, {}, "cbc", "get warmstart basis");
CoinWarmStartBasis::Status stati ;
int iCol ;
for (iCol = 0 ; iCol < cwsb->getNumStructural() ; iCol++)
{ stati = cwsb->getStructStatus(iCol) ;
if (stati == CoinWarmStartBasis::atLowerBound) break ; }
d[0]=iCol;
m.deleteCols(1,d);
delete [] d;
delete cwsb;
d=NULL;
m.resolve();
objValue = m.getObjValue();
OSIUNITTEST_ASSERT_ERROR(eq(objValue,2520.57), {}, "clp", "objvalue after deleting first col");
// Try deleting column we added. If basic, go to initialSolve as deleting
// basic variable trashes basis required for warm start.
iCol = m.getNumCols()-1;
cwsb = dynamic_cast<CoinWarmStartBasis *>(m.getWarmStart()) ;
stati = cwsb->getStructStatus(iCol) ;
delete cwsb;
m.deleteCols(1,&iCol);
if (stati == CoinWarmStartBasis::basic)
{ m.initialSolve() ; }
else
{ m.resolve(); }
objValue = m.getObjValue();
OSIUNITTEST_ASSERT_ERROR(eq(objValue,2520.57), {}, "clp", "objvalue after deleting added col");
}
// Build a model
{
OsiCbcSolverInterface model;
std::string fn = mpsDir+"p0033";
model.readMps(fn.c_str(),"mps");
// Point to data
int numberRows = model.getNumRows();
const double * rowLower = model.getRowLower();
const double * rowUpper = model.getRowUpper();
int numberColumns = model.getNumCols();
const double * columnLower = model.getColLower();
const double * columnUpper = model.getColUpper();
const double * columnObjective = model.getObjCoefficients();
// get row copy
CoinPackedMatrix rowCopy = *model.getMatrixByRow();
const int * column = rowCopy.getIndices();
const int * rowLength = rowCopy.getVectorLengths();
const CoinBigIndex * rowStart = rowCopy.getVectorStarts();
const double * element = rowCopy.getElements();
// solve
model.initialSolve();
// Now build new model
CoinModel build;
// Row bounds
int iRow;
for (iRow=0;iRow<numberRows;iRow++) {
build.setRowBounds(iRow,rowLower[iRow],rowUpper[iRow]);
}
// Column bounds and objective
int iColumn;
for (iColumn=0;iColumn<numberColumns;iColumn++) {
build.setColumnLower(iColumn,columnLower[iColumn]);
build.setColumnUpper(iColumn,columnUpper[iColumn]);
build.setObjective(iColumn,columnObjective[iColumn]);
}
// Adds elements one by one by row (backwards by row)
for (iRow=numberRows-1;iRow>=0;iRow--) {
int start = rowStart[iRow];
for (int j=start;j<start+rowLength[iRow];j++)
build(iRow,column[j],element[j]);
}
// Now create Model
OsiCbcSolverInterface model2;
model2.loadFromCoinModel(build);
model2.initialSolve();
// Save - should be continuous
model2.writeMps("continuous");
int * whichInteger = new int[numberColumns];
for (iColumn=0;iColumn<numberColumns;iColumn++)
whichInteger[iColumn]=iColumn;
// mark as integer
model2.setInteger(whichInteger,numberColumns);
delete [] whichInteger;
// save - should be integer
model2.writeMps("integer");
// Now do with strings attached
// Save build to show how to go over rows
CoinModel saveBuild = build;
build = CoinModel();
// Column bounds
for (iColumn=0;iColumn<numberColumns;iColumn++) {
build.setColumnLower(iColumn,columnLower[iColumn]);
build.setColumnUpper(iColumn,columnUpper[iColumn]);
}
// Objective - half the columns as is and half with multiplier of "1.0+multiplier"
// Pick up from saveBuild (for no reason at all)
for (iColumn=0;iColumn<numberColumns;iColumn++) {
double value = saveBuild.objective(iColumn);
if (iColumn*2<numberColumns) {
build.setObjective(iColumn,columnObjective[iColumn]);
} else {
// create as string
char temp[100];
sprintf(temp,"%g + abs(%g*multiplier)",value,value);
build.setObjective(iColumn,temp);
}
}
// It then adds rows one by one but for half the rows sets their values
// with multiplier of "1.0+1.5*multiplier"
for (iRow=0;iRow<numberRows;iRow++) {
if (iRow*2<numberRows) {
// add row in simple way
int start = rowStart[iRow];
build.addRow(rowLength[iRow],column+start,element+start,
rowLower[iRow],rowUpper[iRow]);
} else {
// As we have to add one by one let's get from saveBuild
CoinModelLink triple=saveBuild.firstInRow(iRow);
while (triple.column()>=0) {
int iColumn = triple.column();
if (iColumn*2<numberColumns) {
// just value as normal
build(iRow,triple.column(),triple.value());
} else {
// create as string
char temp[100];
sprintf(temp,"%g + (1.5*%g*multiplier)",triple.value(), triple.value());
build(iRow,iColumn,temp);
}
triple=saveBuild.next(triple);
}
// but remember to do rhs
build.setRowLower(iRow,rowLower[iRow]);
build.setRowUpper(iRow,rowUpper[iRow]);
}
}
// If small switch on error printing
if (numberColumns<50)
build.setLogLevel(1);
// should fail as we never set multiplier
OSIUNITTEST_ASSERT_ERROR(model2.loadFromCoinModel(build) != 0, {}, "cbc", "build model with missing multipliers");
build.associateElement("multiplier",0.0);
OSIUNITTEST_ASSERT_ERROR(model2.loadFromCoinModel(build) == 0, {}, "cbc", "build model");
model2.initialSolve();
// It then loops with multiplier going from 0.0 to 2.0 in increments of 0.1
for (double multiplier=0.0;multiplier<2.0;multiplier+= 0.1) {
build.associateElement("multiplier",multiplier);
OSIUNITTEST_ASSERT_ERROR(model2.loadFromCoinModel(build,true) == 0, {}, "cbc", "build model with increasing multiplier");
model2.resolve();
}
}
// branch and bound
{
OsiCbcSolverInterface m;
std::string fn = mpsDir+"p0033";
m.readMps(fn.c_str(),"mps");
m.initialSolve();
//m.messageHandler()->setLogLevel(0);
m.getModelPtr()->messageHandler()->setLogLevel(0);
m.branchAndBound();
}
// branch and bound using CbcModel!!!!!!!
{
OsiCbcSolverInterface mm;
OsiCbcSolverInterface m(&mm);
std::string fn = mpsDir+"p0033";
m.readMps(fn.c_str(),"mps");
m.initialSolve();
m.branchAndBound();
}
// Do common solverInterface testing
{
OsiCbcSolverInterface m;
OsiSolverInterfaceCommonUnitTest(&m, mpsDir,netlibDir);
}
{
OsiCbcSolverInterface mm;
OsiCbcSolverInterface m(&mm);
OsiSolverInterfaceCommonUnitTest(&m, mpsDir,netlibDir);
}
}
/** Create a set of candidate branching objects. */
int
BlisBranchStrategyPseudo::createCandBranchObjects(int numPassesLeft,
double ub)
{
int bStatus = 0;
int i, pass, colInd;
int preferDir, saveLimit;
int numFirsts = 0;
int numInfs = 0;
int minCount = 0;
int numLowerTightens = 0;
int numUpperTightens = 0;
double lpX, score, infeasibility, downDeg, upDeg, sumDeg = 0.0;
bool roundAgain, downKeep, downGood, upKeep, upGood;
int *lbInd = NULL;
int *ubInd = NULL;
double *newLB = NULL;
double *newUB = NULL;
double *saveUpper = NULL;
double *saveLower = NULL;
double *saveSolution = NULL;
BlisModel *model = dynamic_cast<BlisModel *>(model_);
OsiSolverInterface *solver = model->solver();
int numCols = model->getNumCols();
int numObjects = model->numObjects();
int aveIterations = model->getAveIterations();
//std::cout << "aveIterations = " << aveIterations << std::endl;
//------------------------------------------------------
// Check if max time is reached or no pass is left.
//------------------------------------------------------
double timeLimit = model->AlpsPar()->entry(AlpsParams::timeLimit);
AlpsKnowledgeBroker *broker = model->getKnowledgeBroker();
bool maxTimeReached = (broker->timer().getTime() > timeLimit);
bool selectNow = false;
if (maxTimeReached || !numPassesLeft) {
selectNow = true;
#ifdef BLIS_DEBUG
printf("PSEUDO: CREATE: maxTimeReached %d, numPassesLeft %d\n",
maxTimeReached, numPassesLeft);
#endif
}
// Store first time objects.
std::vector<BlisObjectInt *> firstObjects;
// Store infeasible objects.
std::vector<BlisObjectInt *> infObjects;
// TODO: check if sorting is expensive.
std::multimap<double, BcpsBranchObject*, BlisPseuoGreater> candObjects;
double objValue = solver->getObjSense() * solver->getObjValue();
const double * lower = solver->getColLower();
const double * upper = solver->getColUpper();
saveSolution = new double[numCols];
memcpy(saveSolution, solver->getColSolution(), numCols*sizeof(double));
//--------------------------------------------------
// Find the infeasible objects.
// NOTE: we might go round this loop twice if we are feed in
// a "feasible" solution.
//--------------------------------------------------
for (pass = 0; pass < 2; ++pass) {
numInfs = 0;
BcpsObject * object = NULL;
BlisObjectInt * intObject = NULL;
infObjects.clear();
firstObjects.clear();
for (i = 0; i < numObjects; ++i) {
object = model->objects(i);
infeasibility = object->infeasibility(model, preferDir);
if (infeasibility) {
++numInfs;
intObject = dynamic_cast<BlisObjectInt *>(object);
if (intObject) {
infObjects.push_back(intObject);
if (!selectNow) {
minCount =
ALPS_MIN(intObject->pseudocost().getDownCount(),
intObject->pseudocost().getUpCount());
if (minCount < 1) {
firstObjects.push_back(intObject);
}
}
#ifdef BLIS_DEBUG
if (intObject->columnIndex() == 40) {
std::cout << "x[40] = " << saveSolution[40]
<< std::endl;
}
#endif
intObject = NULL;
}
else {
// TODO: currently all are integer objects.
#ifdef BLIS_DEBU
assert(0);
#endif
}
}
}
if (numInfs) {
#if 0
std::cout << "PSEUDO: numInfs = " << numInfs
<< std::endl;
#endif
break;
}
else if (pass == 0) {
// The first pass and is IP feasible.
#if 1
std::cout << "ERROR: PSEUDO: given a integer feasible sol, no fraction variable" << std::endl;
assert(0);
#endif
roundAgain = false;
CoinWarmStartBasis * ws =
dynamic_cast<CoinWarmStartBasis*>(solver->getWarmStart());
if (!ws) break;
// Force solution values within bounds
for (i = 0; i < numCols; ++i) {
lpX = saveSolution[i];
if (lpX < lower[i]) {
saveSolution[i] = lower[i];
roundAgain = true;
ws->setStructStatus(i, CoinWarmStartBasis::atLowerBound);
}
else if (lpX > upper[i]) {
saveSolution[i] = upper[i];
roundAgain = true;
ws->setStructStatus(i, CoinWarmStartBasis::atUpperBound);
}
}
if (roundAgain) {
// Need resolve and do the second round selection.
solver->setWarmStart(ws);
delete ws;
// Resolve.
solver->resolve();
if (!solver->isProvenOptimal()) {
// Become infeasible, can do nothing.
bStatus = -2;
goto TERM_CREATE;
}
else {
// Save new lp solution.
memcpy(saveSolution, solver->getColSolution(),
numCols * sizeof(double));
objValue = solver->getObjSense() * solver->getObjValue();
}
}
else {
delete ws;
break;
}
}
} // EOF 2 pass
//--------------------------------------------------
// If we have a set of first time object,
// branch up and down to initialize pseudo-cost.
//--------------------------------------------------
numFirsts = static_cast<int> (firstObjects.size());
//std::cout << "PSEUDO: numFirsts = " << numFirsts << std::endl;
if (numFirsts > 0) {
//std::cout << "PSEUDO: numFirsts = " << numFirsts << std::endl;
//--------------------------------------------------
// Backup solver status and mark hot start.
//--------------------------------------------------
saveLower = new double[numCols];
saveUpper = new double[numCols];
memcpy(saveLower, lower, numCols * sizeof(double));
memcpy(saveUpper, upper, numCols * sizeof(double));
CoinWarmStart * ws = solver->getWarmStart();
solver->getIntParam(OsiMaxNumIterationHotStart, saveLimit);
aveIterations = ALPS_MIN(50, aveIterations);
solver->setIntParam(OsiMaxNumIterationHotStart, aveIterations);
solver->markHotStart();
lbInd = new int [numFirsts];
ubInd = new int [numFirsts];
newLB = new double [numFirsts];
newUB = new double [numFirsts];
for (i = 0; i < numFirsts && bStatus != -2; ++i) {
colInd = firstObjects[i]->columnIndex();
lpX = saveSolution[colInd];
BlisStrongBranch(model, objValue, colInd, lpX,
saveLower, saveUpper,
downKeep, downGood, downDeg,
upKeep, upGood, upDeg);
if(!downKeep && !upKeep) {
// Both branch can be fathomed
bStatus = -2;
}
else if (!downKeep) {
// Down branch can be fathomed.
lbInd[numLowerTightens] = colInd;
newLB[numLowerTightens++] = ceil(lpX);
}
else if (!upKeep) {
// Up branch can be fathomed.
ubInd[numUpperTightens] = colInd;
newUB[numUpperTightens++] = floor(lpX);
}
}
//--------------------------------------------------
// Set new bounds in lp solver for resolving
//--------------------------------------------------
if (bStatus != -2) {
if (numUpperTightens > 0) {
bStatus = -1;
for (i = 0; i < numUpperTightens; ++i) {
solver->setColUpper(ubInd[i], newUB[i]);
}
}
if (numLowerTightens > 0) {
bStatus = -1;
for (i = 0; i < numLowerTightens; ++i) {
solver->setColLower(lbInd[i], newLB[i]);
}
}
}
//--------------------------------------------------
// Unmark hotstart and recover LP solver.
//--------------------------------------------------
solver->unmarkHotStart();
solver->setColSolution(saveSolution);
solver->setIntParam(OsiMaxNumIterationHotStart, saveLimit);
solver->setWarmStart(ws);
delete ws;
}
if (bStatus < 0) {
goto TERM_CREATE;
}
else {
// Create a set of candidate branching objects.
numBranchObjects_ = numInfs;
branchObjects_ = new BcpsBranchObject* [numInfs];
// NOTE: it set model->savedLpSolution.
sumDeg = 0.0;
for (i = 0; i < numInfs; ++i) {
if (infObjects[i]->pseudocost().getUpCost() <
infObjects[i]->pseudocost().getDownCost()) {
preferDir = 1;
}
else {
preferDir = -1;
}
branchObjects_[i] = infObjects[i]->createBranchObject(model,
preferDir);
score = infObjects[i]->pseudocost().getScore();
branchObjects_[i]->setUpScore(score);
sumDeg += score;
#ifdef BLIS_DEBUG_MORE
std::cout << "col[" << infObjects[i]->columnIndex() << "]: score="
<< score << ", dir=" << branchObjects_[i]->getDirection()
<< ", up=" << infObjects[i]->pseudocost().getUpCost()
<< ", down=" << infObjects[i]->pseudocost().getDownCost()
<< std::endl;
#endif
}
model->setSolEstimate(objValue + sumDeg);
}
TERM_CREATE:
//------------------------------------------------------
// Cleanup.
//------------------------------------------------------
delete [] lbInd;
delete [] ubInd;
delete [] newLB;
delete [] newUB;
delete [] saveSolution;
delete [] saveLower;
delete [] saveUpper;
return bStatus;
}
/* This version of presolve returns a pointer to a new presolved
model. NULL if infeasible
doStatus controls activities required to transform an existing
solution to match the presolved problem. I'd (lh) argue that this should
default to false, but to maintain previous behaviour it defaults to true.
Really, this is only useful if you've already optimised before applying
presolve and also want to work with the solution after presolve. I think
that this is the less common case. The more common situation is to apply
presolve before optimising.
*/
OsiSolverInterface *
OsiPresolve::presolvedModel(OsiSolverInterface & si,
double feasibilityTolerance,
bool keepIntegers,
int numberPasses,
const char * prohibited,
bool doStatus,
const char * rowProhibited)
{
ncols_ = si.getNumCols();
nrows_ = si.getNumRows();
nelems_ = si.getNumElements();
numberPasses_ = numberPasses;
double maxmin = si.getObjSense();
originalModel_ = &si;
delete [] originalColumn_;
originalColumn_ = new int[ncols_];
delete [] originalRow_;
originalRow_ = new int[nrows_];
int i;
for (i=0;i<ncols_;i++)
originalColumn_[i]=i;
for (i=0;i<nrows_;i++)
originalRow_[i]=i;
// result is 0 - okay, 1 infeasible, -1 go round again
int result = -1;
// User may have deleted - its their responsibility
presolvedModel_=NULL;
// Messages
CoinMessages messages = CoinMessage(si.messages().language());
// Only go round 100 times even if integer preprocessing
int totalPasses=100;
while (result==-1) {
// make new copy
delete presolvedModel_;
presolvedModel_ = si.clone();
totalPasses--;
// drop integer information if wanted
if (!keepIntegers) {
int i;
for (i=0;i<ncols_;i++)
presolvedModel_->setContinuous(i);
}
CoinPresolveMatrix prob(ncols_,
maxmin,
presolvedModel_,
nrows_, nelems_,doStatus,nonLinearValue_,prohibited,
rowProhibited);
// make sure row solution correct
if (doStatus) {
double *colels = prob.colels_;
int *hrow = prob.hrow_;
CoinBigIndex *mcstrt = prob.mcstrt_;
int *hincol = prob.hincol_;
int ncols = prob.ncols_;
double * csol = prob.sol_;
double * acts = prob.acts_;
int nrows = prob.nrows_;
int colx;
memset(acts,0,nrows*sizeof(double));
for (colx = 0; colx < ncols; ++colx) {
double solutionValue = csol[colx];
for (int i=mcstrt[colx]; i<mcstrt[colx]+hincol[colx]; ++i) {
int row = hrow[i];
double coeff = colels[i];
acts[row] += solutionValue*coeff;
}
}
}
// move across feasibility tolerance
prob.feasibilityTolerance_ = feasibilityTolerance;
/*
Do presolve. Allow for the possibility that presolve might be ineffective
(i.e., we're feasible but no postsolve actions are queued.
*/
paction_ = presolve(&prob) ;
result = 0 ;
// Get rid of useful arrays
prob.deleteStuff();
/*
This we don't need to do unless presolve actually reduced the system.
*/
if (prob.status_==0&&paction_) {
// Looks feasible but double check to see if anything slipped through
int n = prob.ncols_;
double * lo = prob.clo_;
double * up = prob.cup_;
int i;
for (i=0;i<n;i++) {
if (up[i]<lo[i]) {
if (up[i]<lo[i]-1.0e-8) {
// infeasible
prob.status_=1;
} else {
up[i]=lo[i];
}
}
}
n = prob.nrows_;
lo = prob.rlo_;
up = prob.rup_;
for (i=0;i<n;i++) {
if (up[i]<lo[i]) {
if (up[i]<lo[i]-1.0e-8) {
// infeasible
prob.status_=1;
} else {
up[i]=lo[i];
}
}
}
}
/*
If we're feasible, load the presolved system into the solver. Presumably we
could skip model update and copying of status and solution if presolve took
no action.
*/
if (prob.status_ == 0) {
prob.update_model(presolvedModel_, nrows_, ncols_, nelems_);
# if PRESOLVE_CONSISTENCY
if (doStatus)
{ int basicCnt = 0 ;
int basicColumns = 0;
int i ;
CoinPresolveMatrix::Status status ;
for (i = 0 ; i < prob.ncols_ ; i++)
{ status = prob.getColumnStatus(i);
if (status == CoinPrePostsolveMatrix::basic) basicColumns++ ; }
basicCnt = basicColumns;
for (i = 0 ; i < prob.nrows_ ; i++)
{ status = prob.getRowStatus(i);
if (status == CoinPrePostsolveMatrix::basic) basicCnt++ ; }
# if PRESOLVE_DEBUG
presolve_check_nbasic(&prob) ;
# endif
if (basicCnt>prob.nrows_) {
// Take out slacks
double * acts = prob.acts_;
double * rlo = prob.rlo_;
double * rup = prob.rup_;
double infinity = si.getInfinity();
for (i = 0 ; i < prob.nrows_ ; i++) {
status = prob.getRowStatus(i);
if (status == CoinPrePostsolveMatrix::basic) {
basicCnt-- ;
double down = acts[i]-rlo[i];
double up = rup[i]-acts[i];
if (CoinMin(up,down)<infinity) {
if (down<=up)
prob.setRowStatus(i,CoinPrePostsolveMatrix::atLowerBound);
else
prob.setRowStatus(i,CoinPrePostsolveMatrix::atUpperBound);
} else {
prob.setRowStatus(i,CoinPrePostsolveMatrix::isFree);
}
}
if (basicCnt==prob.nrows_)
break;
}
}
}
#endif
/*
Install the status and primal solution, if we've been carrying them along.
The code that copies status is efficient but brittle. The current definitions
for CoinWarmStartBasis::Status and CoinPrePostsolveMatrix::Status are in
one-to-one correspondence. This code will fail if that ever changes.
*/
if (doStatus) {
presolvedModel_->setColSolution(prob.sol_);
CoinWarmStartBasis *basis =
dynamic_cast<CoinWarmStartBasis *>(presolvedModel_->getEmptyWarmStart());
basis->resize(prob.nrows_,prob.ncols_);
int i;
for (i=0;i<prob.ncols_;i++) {
CoinWarmStartBasis::Status status =
static_cast<CoinWarmStartBasis::Status> (prob.getColumnStatus(i));
basis->setStructStatus(i,status);
}
for (i=0;i<prob.nrows_;i++) {
CoinWarmStartBasis::Status status =
static_cast<CoinWarmStartBasis::Status> (prob.getRowStatus(i));
basis->setArtifStatus(i,status);
}
presolvedModel_->setWarmStart(basis);
delete basis ;
delete [] prob.sol_;
delete [] prob.acts_;
delete [] prob.colstat_;
prob.sol_=NULL;
prob.acts_=NULL;
prob.colstat_=NULL;
}
/*
Copy original column and row information from the CoinPresolveMatrix object
so it'll be available for postsolve.
*/
int ncolsNow = presolvedModel_->getNumCols();
memcpy(originalColumn_,prob.originalColumn_,ncolsNow*sizeof(int));
delete [] prob.originalColumn_;
prob.originalColumn_=NULL;
int nrowsNow = presolvedModel_->getNumRows();
memcpy(originalRow_,prob.originalRow_,nrowsNow*sizeof(int));
delete [] prob.originalRow_;
prob.originalRow_=NULL;
// now clean up integer variables. This can modify original
{
int numberChanges=0;
const double * lower0 = originalModel_->getColLower();
const double * upper0 = originalModel_->getColUpper();
const double * lower = presolvedModel_->getColLower();
const double * upper = presolvedModel_->getColUpper();
for (i=0;i<ncolsNow;i++) {
if (!presolvedModel_->isInteger(i))
continue;
int iOriginal = originalColumn_[i];
double lowerValue0 = lower0[iOriginal];
double upperValue0 = upper0[iOriginal];
double lowerValue = ceil(lower[i]-1.0e-5);
double upperValue = floor(upper[i]+1.0e-5);
presolvedModel_->setColBounds(i,lowerValue,upperValue);
if (lowerValue>upperValue) {
numberChanges++;
presolvedModel_->messageHandler()->message(COIN_PRESOLVE_COLINFEAS,
messages)
<<iOriginal
<<lowerValue
<<upperValue
<<CoinMessageEol;
result=1;
} else {
if (lowerValue>lowerValue0+1.0e-8) {
originalModel_->setColLower(iOriginal,lowerValue);
numberChanges++;
}
if (upperValue<upperValue0-1.0e-8) {
originalModel_->setColUpper(iOriginal,upperValue);
numberChanges++;
}
}
}
if (numberChanges) {
presolvedModel_->messageHandler()->message(COIN_PRESOLVE_INTEGERMODS,
messages)
<<numberChanges
<<CoinMessageEol;
if (!result&&totalPasses>0&&
// we can't go round again in integer if dupcols
(prob.presolveOptions_ & 0x80000000) == 0) {
result = -1; // round again
const CoinPresolveAction *paction = paction_;
while (paction) {
const CoinPresolveAction *next = paction->next;
delete paction;
paction = next;
}
paction_=NULL;
}
}
}
} else if (prob.status_ != 0) {
// infeasible or unbounded
result = 1 ;
}
}
if (!result) {
int nrowsAfter = presolvedModel_->getNumRows();
int ncolsAfter = presolvedModel_->getNumCols();
CoinBigIndex nelsAfter = presolvedModel_->getNumElements();
presolvedModel_->messageHandler()->message(COIN_PRESOLVE_STATS, messages)
<<nrowsAfter<< -(nrows_ - nrowsAfter)
<< ncolsAfter<< -(ncols_ - ncolsAfter)
<<nelsAfter<< -(nelems_ - nelsAfter)
<<CoinMessageEol;
} else {
gutsOfDestroy();
delete presolvedModel_;
presolvedModel_=NULL;
}
return presolvedModel_;
}
void
OsiPresolve::postsolve(bool updateStatus)
{
// Messages
CoinMessages messages = CoinMessage(presolvedModel_->messages().language());
if (!presolvedModel_->isProvenOptimal()) {
presolvedModel_->messageHandler()->message(COIN_PRESOLVE_NONOPTIMAL,
messages)
<<CoinMessageEol;
}
// this is the size of the original problem
const int ncols0 = ncols_;
const int nrows0 = nrows_;
const CoinBigIndex nelems0 = nelems_;
// reality check
assert(ncols0==originalModel_->getNumCols());
assert(nrows0==originalModel_->getNumRows());
// this is the reduced problem
int ncols = presolvedModel_->getNumCols();
int nrows = presolvedModel_->getNumRows();
double *acts = new double [nrows0];
double *sol = new double [ncols0];
CoinZeroN(acts,nrows0);
CoinZeroN(sol,ncols0);
unsigned char * rowstat=NULL;
unsigned char * colstat = NULL;
CoinWarmStartBasis * presolvedBasis =
dynamic_cast<CoinWarmStartBasis*>(presolvedModel_->getWarmStart());
if (!presolvedBasis)
updateStatus=false;
if (updateStatus) {
colstat = new unsigned char[ncols0+nrows0];
# ifdef ZEROFAULT
memset(colstat,0,((ncols0+nrows0)*sizeof(char))) ;
# endif
rowstat = colstat + ncols0;
int i;
for (i=0;i<ncols;i++) {
colstat[i] = presolvedBasis->getStructStatus(i);
}
for (i=0;i<nrows;i++) {
rowstat[i] = presolvedBasis->getArtifStatus(i);
}
}
delete presolvedBasis;
# if PRESOLVE_CONSISTENCY > 0
if (updateStatus)
{ int basicCnt = 0 ;
int i ;
for (i = 0 ; i < ncols ; i++)
{ if (colstat[i] == CoinWarmStartBasis::basic) basicCnt++ ; }
for (i = 0 ; i < nrows ; i++)
{ if (rowstat[i] == CoinWarmStartBasis::basic) basicCnt++ ; }
assert (basicCnt == nrows) ;
}
# endif
/*
Postsolve back to the original problem. The CoinPostsolveMatrix object
assumes ownership of sol, acts, colstat, and rowstat.
*/
CoinPostsolveMatrix prob(presolvedModel_, ncols0, nrows0, nelems0,
presolvedModel_->getObjSense(),
sol, acts, colstat, rowstat);
postsolve(prob);
# if PRESOLVE_CONSISTENCY > 0
if (updateStatus)
{ int basicCnt = 0 ;
int i ;
for (i = 0 ; i < ncols0 ; i++)
{ if (prob.getColumnStatus(i) == CoinWarmStartBasis::basic) basicCnt++ ; }
for (i = 0 ; i < nrows0 ; i++)
{ if (prob.getRowStatus(i) == CoinWarmStartBasis::basic) basicCnt++ ; }
assert (basicCnt == nrows0) ;
}
# endif
originalModel_->setColSolution(sol);
if (updateStatus) {
CoinWarmStartBasis *basis =
dynamic_cast<CoinWarmStartBasis *>(presolvedModel_->getEmptyWarmStart());
basis->setSize(ncols0,nrows0);
int i;
for (i=0;i<ncols0;i++) {
CoinWarmStartBasis::Status status = static_cast<CoinWarmStartBasis::Status> (prob.getColumnStatus(i));
/* FIXME: these asserts seem correct, but seem to reveal some bugs in CoinPresolve */
// assert(status != CoinWarmStartBasis::atLowerBound || originalModel_->getColLower()[i] > -originalModel_->getInfinity());
// assert(status != CoinWarmStartBasis::atUpperBound || originalModel_->getColUpper()[i] < originalModel_->getInfinity());
basis->setStructStatus(i,status);
}
for (i=0;i<nrows0;i++) {
CoinWarmStartBasis::Status status = static_cast<CoinWarmStartBasis::Status> (prob.getRowStatus(i));
/* FIXME: these asserts seem correct, but seem to reveal some bugs in CoinPresolve */
// assert(status != CoinWarmStartBasis::atUpperBound || originalModel_->getRowLower()[i] > -originalModel_->getInfinity());
// assert(status != CoinWarmStartBasis::atLowerBound || originalModel_->getRowUpper()[i] < originalModel_->getInfinity());
basis->setArtifStatus(i,status);
}
originalModel_->setWarmStart(basis);
delete basis ;
}
}
/** Create a set of candidate branching objects. */
int
BlisBranchStrategyRel::createCandBranchObjects(int numPassesLeft)
{
int bStatus = 0;
int i, pass, colInd;
int preferDir, saveLimit;
int numFirsts = 0;
int numInfs = 0;
int minCount = 0;
int numLowerTightens = 0;
int numUpperTightens = 0;
double lpX, score, infeasibility, downDeg, upDeg, sumDeg = 0.0;
bool roundAgain, downKeep, downGood, upKeep, upGood;
int *lbInd = NULL;
int *ubInd = NULL;
double *newLB = NULL;
double *newUB = NULL;
double * saveUpper = NULL;
double * saveLower = NULL;
double * saveSolution = NULL;
BlisModel *model = dynamic_cast<BlisModel *>(model_);
OsiSolverInterface * solver = model->solver();
int numCols = model->getNumCols();
int numObjects = model->numObjects();
//int lookAhead = dynamic_cast<BlisParams*>
// (model->blisPar())->entry(BlisParams::lookAhead);
//------------------------------------------------------
// Check if max time is reached or no pass is left.
//------------------------------------------------------
double timeLimit = model->AlpsPar()->entry(AlpsParams::timeLimit);
bool maxTimeReached = (CoinCpuTime() - model->startTime_ > timeLimit);
bool selectNow = false;
if (maxTimeReached || !numPassesLeft) {
selectNow = true;
#ifdef BLIS_DEBUG
printf("REL: CREATE: maxTimeReached %d, numPassesLeft %d\n",
maxTimeReached, numPassesLeft);
#endif
}
// Store first time objects.
std::vector<BlisObjectInt *> firstObjects;
// Store infeasible objects.
std::vector<BlisObjectInt *> infObjects;
// TODO: check if sorting is expensive.
std::multimap<double, BlisObjectInt*, BlisPseuoGreater> sortedObjects;
double objValue = solver->getObjSense() * solver->getObjValue();
const double * lower = solver->getColLower();
const double * upper = solver->getColUpper();
int lookAhead = dynamic_cast<BlisParams*>
(model->BlisPar())->entry(BlisParams::lookAhead);
BlisObjectInt * intObject = NULL;
//------------------------------------------------------
// Backup solver status and mark hot start.
//-----------------------------------------------------
saveSolution = new double[numCols];
memcpy(saveSolution, solver->getColSolution(), numCols*sizeof(double));
saveLower = new double[numCols];
saveUpper = new double[numCols];
memcpy(saveLower, lower, numCols * sizeof(double));
memcpy(saveUpper, upper, numCols * sizeof(double));
//------------------------------------------------------
// Find the infeasible objects.
// NOTE: we might go round this loop twice if we are feed in
// a "feasible" solution.
//------------------------------------------------------
for (pass = 0; pass < 2; ++pass) {
numInfs = 0;
BcpsObject * object = NULL;
infObjects.clear();
firstObjects.clear();
for (i = 0; i < numObjects; ++i) {
object = model->objects(i);
infeasibility = object->infeasibility(model, preferDir);
if (infeasibility) {
++numInfs;
intObject = dynamic_cast<BlisObjectInt *>(object);
if (intObject) {
//score = object->pseudocost().getScore();
//tempBO = object->createBranchObject(model, preferDir);
//candObjects.insert(std::make_pair(score, tempBO));
//tempBO = NULL;
infObjects.push_back(intObject);
if (!selectNow) {
minCount =
ALPS_MIN(intObject->pseudocost().getDownCount(),
intObject->pseudocost().getUpCount());
if (minCount < 1) {
firstObjects.push_back(intObject);
}
}
#ifdef BLIS_DEBUG_MORE
if (intObject->columnIndex() == 15) {
std::cout << "x[15] = " << saveSolution[15]
<< std::endl;
}
#endif
intObject = NULL;
}
else {
// TODO: currently all are integer objects.
#ifdef BLIS_DEBU
assert(0);
#endif
}
}
}
if (numInfs) {
#ifdef BLIS_DEBUG_MORE
std::cout << "REL: numInfs = " << numInfs
<< std::endl;
#endif
break;
}
else if (pass == 0) {
// The first pass and is IP feasible.
#ifdef BLIS_DEBUG
std::cout << "REL: given a feasible sol" << std::endl;
#endif
roundAgain = false;
CoinWarmStartBasis * ws =
dynamic_cast<CoinWarmStartBasis*>(solver->getWarmStart());
if (!ws) break;
// Force solution values within bounds
for (i = 0; i < numCols; ++i) {
lpX = saveSolution[i];
if (lpX < lower[i]) {
saveSolution[i] = lower[i];
roundAgain = true;
ws->setStructStatus(i, CoinWarmStartBasis::atLowerBound);
}
else if (lpX > upper[i]) {
saveSolution[i] = upper[i];
roundAgain = true;
ws->setStructStatus(i, CoinWarmStartBasis::atUpperBound);
}
}
if (roundAgain) {
// Need resolve and do the second round selection.
solver->setWarmStart(ws);
delete ws;
// Resolve.
solver->resolve();
if (!solver->isProvenOptimal()) {
// Become infeasible, can do nothing.
bStatus = -2;
goto TERM_CREATE;
}
else {
// Save new lp solution.
memcpy(saveSolution, solver->getColSolution(),
numCols * sizeof(double));
objValue = solver->getObjSense() * solver->getObjValue();
}
}
else {
delete ws;
break;
}
}
} // EOF 2 pass
//--------------------------------------------------
// If we have a set of first time object,
// branch up and down to initialize pseudo-cost.
//--------------------------------------------------
numFirsts = static_cast<int> (firstObjects.size());
if (numFirsts > 0) {
CoinWarmStart * ws = solver->getWarmStart();
solver->getIntParam(OsiMaxNumIterationHotStart, saveLimit);
int maxIter = ALPS_MAX(model->getAveIterations(), 50);
solver->setIntParam(OsiMaxNumIterationHotStart, maxIter);
solver->markHotStart();
lbInd = new int [numFirsts];
ubInd = new int [numFirsts];
newLB = new double [numFirsts];
newUB = new double [numFirsts];
for (i = 0; i < numFirsts && bStatus != -2; ++i) {
colInd = firstObjects[i]->columnIndex();
lpX = saveSolution[colInd];
BlisStrongBranch(model, objValue, colInd, lpX,
saveLower, saveUpper,
downKeep, downGood, downDeg,
upKeep, upGood, upDeg);
if(!downKeep && !upKeep) {
// Both branch can be fathomed
bStatus = -2;
}
else if (!downKeep) {
// Down branch can be fathomed.
lbInd[numLowerTightens] = colInd;
newLB[numLowerTightens++] = ceil(lpX);
//break;
}
else if (!upKeep) {
// Up branch can be fathomed.
ubInd[numUpperTightens] = colInd;
newUB[numUpperTightens++] = floor(lpX);
// break;
}
// Update pseudocost.
if(downGood) {
firstObjects[i]->pseudocost().update(-1, downDeg, lpX);
}
if(downGood) {
firstObjects[i]->pseudocost().update(1, upDeg, lpX);
}
}
//--------------------------------------------------
// Set new bounds in lp solver for resolving
//--------------------------------------------------
if (bStatus != -2) {
if (numUpperTightens > 0) {
bStatus = -1;
for (i = 0; i < numUpperTightens; ++i) {
solver->setColUpper(ubInd[i], newUB[i]);
}
}
if (numLowerTightens > 0) {
bStatus = -1;
for (i = 0; i < numLowerTightens; ++i) {
solver->setColLower(lbInd[i], newLB[i]);
}
}
}
//--------------------------------------------------
// Unmark hotstart and recover LP solver.
//--------------------------------------------------
solver->unmarkHotStart();
solver->setColSolution(saveSolution);
solver->setIntParam(OsiMaxNumIterationHotStart, saveLimit);
solver->setWarmStart(ws);
delete ws;
}
//std::cout << "REL: bStatus = " << bStatus << std::endl;
if (bStatus < 0) {
// Infeasible or monotone.
goto TERM_CREATE;
}
else {
// All object's pseudocost have been initialized.
// Sort them, and do strong branch for the unreliable one
// NOTE: it set model->savedLpSolution.
// model->feasibleSolution(numIntegerInfs, numObjectInfs);
sumDeg = 0.0;
for (i = 0; i < numInfs; ++i) {
score = infObjects[i]->pseudocost().getScore();
sumDeg += score;
std::pair<const double, BlisObjectInt*> sa(score, infObjects[i]);
sortedObjects.insert(sa);
#ifdef BLIS_DEBUG_MORE
std::cout << "col[" << infObjects[i]->columnIndex() << "]="
<< score << ", "<< std::endl;
#endif
}
int numNotChange = 0;
std::multimap< double, BlisObjectInt*, BlisPseuoGreater >::iterator pos;
CoinWarmStart * ws = solver->getWarmStart();
solver->getIntParam(OsiMaxNumIterationHotStart, saveLimit);
int maxIter = ALPS_MAX(model->getAveIterations(), 50);
solver->setIntParam(OsiMaxNumIterationHotStart, maxIter);
solver->markHotStart();
BlisObjectInt *bestObject = NULL;
double bestScore = -10.0;
for (pos = sortedObjects.begin(); pos != sortedObjects.end(); ++pos) {
intObject = pos->second;
colInd = intObject->columnIndex();
#ifdef BLIS_DEBUG_MORE
std::cout << "col[" << colInd << "]: "
<< "score=" << pos->first
<< ", upCount=" << intObject->pseudocost().getUpCount()
<<", downCount="<< intObject->pseudocost().getDownCount()
<< std::endl;
#endif
// Check if reliable.
int objRelibility=ALPS_MIN(intObject->pseudocost().getUpCount(),
intObject->pseudocost().getDownCount());
if (objRelibility < relibility_) {
// Unrelible object. Do strong branching.
lpX = saveSolution[colInd];
BlisStrongBranch(model, objValue, colInd, lpX,
saveLower, saveUpper,
downKeep, downGood, downDeg,
upKeep, upGood, upDeg);
// Update pseudocost.
if(downGood) {
intObject->pseudocost().update(-1, downDeg, lpX);
}
if(downGood) {
intObject->pseudocost().update(1, upDeg, lpX);
}
}
// Compare with the best.
if (intObject->pseudocost().getScore() > bestScore) {
bestScore = intObject->pseudocost().getScore();
bestObject = intObject;
// Reset
numNotChange = 0;
}
else {
// If best doesn't change for "lookAhead" comparisons, then
// the best is reliable.
if (++numNotChange > lookAhead) {
if (bestObject->pseudocost().getUpCost() >
bestObject->pseudocost().getDownCost()) {
preferDir = 1;
}
else {
preferDir = -1;
}
break;
}
}
}
solver->unmarkHotStart();
solver->setColSolution(saveSolution);
solver->setIntParam(OsiMaxNumIterationHotStart, saveLimit);
solver->setWarmStart(ws);
delete ws;
model->setSolEstimate(objValue + sumDeg);
assert(bestObject != NULL);
bestBranchObject_ = bestObject->createBranchObject(model, preferDir);
}
TERM_CREATE:
//------------------------------------------------------
// Cleanup.
//------------------------------------------------------
delete [] lbInd;
delete [] ubInd;
delete [] newLB;
delete [] newUB;
delete [] saveSolution;
delete [] saveLower;
delete [] saveUpper;
return bStatus;
}
void
CbcTreeArray::cleanTree(CbcModel * model, double cutoff, double & bestPossibleObjective)
{
int j;
int nNodes = size();
int lastNode = nNodes + 1;
CbcNode ** nodeArray = new CbcNode * [lastNode];
int * depth = new int [lastNode];
int k = 0;
int kDelete = lastNode;
bestPossibleObjective = 1.0e100 ;
/*
Destructively scan the heap. Nodes to be retained go into the front of
nodeArray, nodes to be deleted into the back. Store the depth in a
correlated array for nodes to be deleted.
*/
for (j = 0; j < nNodes; j++) {
CbcNode * node = nodes_.front();
nodes_.front()->setOnTree(false);
std::pop_heap(nodes_.begin(), nodes_.end(), comparison_);
nodes_.pop_back();
double value = node ? node->objectiveValue() : COIN_DBL_MAX;
if (node && value >= cutoff) {
// double check in case node can change its mind!
value = node->checkIsCutoff(cutoff);
}
if (value >= cutoff || !node->active()) {
if (node) {
nodeArray[--kDelete] = node;
depth[kDelete] = node->depth();
}
} else {
bestPossibleObjective = CoinMin(bestPossibleObjective, value);
nodeArray[k++] = node;
}
}
if (lastNode_) {
double value = lastNode_->objectiveValue();
bestPossibleObjective = CoinMin(bestPossibleObjective, value);
if (value >= cutoff || !lastNode_->active()) {
nodeArray[--kDelete] = lastNode_;
depth[kDelete] = lastNode_->depth();
lastNode_ = NULL;
}
}
CbcCompareDefault * compareDefault
= dynamic_cast<CbcCompareDefault *> (comparison_.test_);
assert (compareDefault);
compareDefault->setBestPossible(bestPossibleObjective);
compareDefault->setCutoff(cutoff);
/*
Rebuild the heap using the retained nodes.
*/
for (j = 0; j < k; j++) {
CbcNode * node = nodeArray[j];
node->setOnTree(true);
nodes_.push_back(node);
std::push_heap(nodes_.begin(), nodes_.end(), comparison_);
}
/*
Sort the list of nodes to be deleted, nondecreasing.
*/
CoinSort_2(depth + kDelete, depth + lastNode, nodeArray + kDelete);
/*
Work back from deepest to shallowest. In spite of the name, addCuts1 is
just a preparatory step. When it returns, the following will be true:
* all cuts are removed from the solver's copy of the constraint system;
* lastws will be a basis appropriate for the specified node;
* variable bounds will be adjusted to be appropriate for the specified
node;
* addedCuts_ (returned via addedCuts()) will contain a list of cuts that
should be added to the constraint system at this node (but they have
not actually been added).
Then we scan the cut list for the node. Decrement the reference count
for the cut, and if it's gone to 0, really delete it.
I don't yet see why the checks for status != basic and addedCuts_[i] != 0
are necessary. When reconstructing a node, these checks are used to skip
over loose cuts, excluding them from the reconstituted basis. But here
we're just interested in correcting the reference count. Tight/loose
should make no difference.
Arguably a separate routine should be used in place of addCuts1. It's
doing more work than needed, modifying the model to match a subproblem
at a node that will be discarded. Then again, we seem to need the basis.
*/
for (j = lastNode - 1; j >= kDelete; j--) {
CbcNode * node = nodeArray[j];
CoinWarmStartBasis *lastws = model->getEmptyBasis() ;
model->addCuts1(node, lastws);
// Decrement cut counts
assert (node);
//assert (node->nodeInfo());
int numberLeft = (node->nodeInfo()) ? node->nodeInfo()->numberBranchesLeft() : 0;
int i;
for (i = 0; i < model->currentNumberCuts(); i++) {
// take off node
CoinWarmStartBasis::Status status =
lastws->getArtifStatus(i + model->numberRowsAtContinuous());
if (status != CoinWarmStartBasis::basic &&
model->addedCuts()[i]) {
if (!model->addedCuts()[i]->decrement(numberLeft))
delete model->addedCuts()[i];
}
}
// node should not have anything pointing to it
if (node->nodeInfo())
node->nodeInfo()->throwAway();
delete node ;
delete lastws ;
}
delete [] nodeArray;
delete [] depth;
}
void OsiGlpkSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir)
{
// Test default constructor
{
OsiGlpkSolverInterface m;
OSIUNITTEST_ASSERT_ERROR(m.obj_ == NULL, {}, "glpk", "default constructor");
OSIUNITTEST_ASSERT_ERROR(m.collower_ == NULL, {}, "glpk", "default constructor");
OSIUNITTEST_ASSERT_ERROR(m.colupper_ == NULL, {}, "glpk", "default constructor");
OSIUNITTEST_ASSERT_ERROR(m.ctype_ == NULL, {}, "glpk", "default constructor");
OSIUNITTEST_ASSERT_ERROR(m.rowsense_ == NULL, {}, "glpk", "default constructor");
OSIUNITTEST_ASSERT_ERROR(m.rhs_ == NULL, {}, "glpk", "default constructor");
OSIUNITTEST_ASSERT_ERROR(m.rowrange_ == NULL, {}, "glpk", "default constructor");
OSIUNITTEST_ASSERT_ERROR(m.rowlower_ == NULL, {}, "glpk", "default constructor");
OSIUNITTEST_ASSERT_ERROR(m.rowupper_ == NULL, {}, "glpk", "default constructor");
OSIUNITTEST_ASSERT_ERROR(m.colsol_ == NULL, {}, "glpk", "default constructor");
OSIUNITTEST_ASSERT_ERROR(m.rowsol_ == NULL, {}, "glpk", "default constructor");
OSIUNITTEST_ASSERT_ERROR(m.matrixByRow_ == NULL, {}, "glpk", "default constructor");
OSIUNITTEST_ASSERT_ERROR(m.matrixByCol_ == NULL, {}, "glpk", "default constructor");
OSIUNITTEST_ASSERT_ERROR(m.getApplicationData() == NULL, {}, "glpk", "default constructor");
int i=2346;
m.setApplicationData(&i);
OSIUNITTEST_ASSERT_ERROR(*((int *)(m.getApplicationData())) == i, {}, "glpk", "default constructor");
}
{
CoinRelFltEq eq;
OsiGlpkSolverInterface m;
std::string fn = mpsDir+"exmip1";
m.readMps(fn.c_str(),"mps");
{
OsiGlpkSolverInterface im;
OSIUNITTEST_ASSERT_ERROR(im.getNumCols() == 0, {}, "glpk", "default constructor");
OSIUNITTEST_ASSERT_ERROR(im.getModelPtr() != NULL, {}, "glpk", "default constructor");
// Test reset
im.reset();
OSIUNITTEST_ASSERT_ERROR(m.obj_ == NULL, {}, "glpk", "reset");
OSIUNITTEST_ASSERT_ERROR(m.collower_ == NULL, {}, "glpk", "reset");
OSIUNITTEST_ASSERT_ERROR(m.colupper_ == NULL, {}, "glpk", "reset");
OSIUNITTEST_ASSERT_ERROR(m.ctype_ == NULL, {}, "glpk", "reset");
OSIUNITTEST_ASSERT_ERROR(m.rowsense_ == NULL, {}, "glpk", "reset");
OSIUNITTEST_ASSERT_ERROR(m.rhs_ == NULL, {}, "glpk", "reset");
OSIUNITTEST_ASSERT_ERROR(m.rowrange_ == NULL, {}, "glpk", "reset");
OSIUNITTEST_ASSERT_ERROR(m.rowlower_ == NULL, {}, "glpk", "reset");
OSIUNITTEST_ASSERT_ERROR(m.rowupper_ == NULL, {}, "glpk", "reset");
OSIUNITTEST_ASSERT_ERROR(m.colsol_ == NULL, {}, "glpk", "reset");
OSIUNITTEST_ASSERT_ERROR(m.rowsol_ == NULL, {}, "glpk", "reset");
OSIUNITTEST_ASSERT_ERROR(m.matrixByRow_ == NULL, {}, "glpk", "reset");
OSIUNITTEST_ASSERT_ERROR(m.matrixByCol_ == NULL, {}, "glpk", "reset");
OSIUNITTEST_ASSERT_ERROR(m.getApplicationData() == NULL, {}, "glpk", "reset");
}
// Test copy constructor and assignment operator
{
OsiGlpkSolverInterface lhs;
{
OsiGlpkSolverInterface im(m);
OsiGlpkSolverInterface imC1(im);
OSIUNITTEST_ASSERT_ERROR(imC1.getModelPtr() != im.getModelPtr(), {}, "glpk", "copy constructor");
OSIUNITTEST_ASSERT_ERROR(imC1.getNumCols() == im.getNumCols(), {}, "glpk", "copy constructor");
OSIUNITTEST_ASSERT_ERROR(imC1.getNumRows() == im.getNumRows(), {}, "glpk", "copy constructor");
OsiGlpkSolverInterface imC2(im);
OSIUNITTEST_ASSERT_ERROR(imC2.getModelPtr() != im.getModelPtr(), {}, "glpk", "copy constructor");
OSIUNITTEST_ASSERT_ERROR(imC2.getNumCols() == im.getNumCols(), {}, "glpk", "copy constructor");
OSIUNITTEST_ASSERT_ERROR(imC2.getNumRows() == im.getNumRows(), {}, "glpk", "copy constructor");
OSIUNITTEST_ASSERT_ERROR(imC1.getModelPtr() != imC2.getModelPtr(), {}, "glpk", "copy constructor");
lhs = imC2;
}
// Test that lhs has correct values even though rhs has gone out of scope
OSIUNITTEST_ASSERT_ERROR(lhs.getModelPtr() != m.getModelPtr(), {}, "glpk", "assignment operator");
OSIUNITTEST_ASSERT_ERROR(lhs.getNumCols() == m.getNumCols(), {}, "glpk", "copy constructor");
OSIUNITTEST_ASSERT_ERROR(lhs.getNumRows() == m.getNumRows(), {}, "glpk", "copy constructor");
}
// Test clone
{
OsiGlpkSolverInterface glpkSi(m);
OsiSolverInterface * siPtr = &glpkSi;
OsiSolverInterface * siClone = siPtr->clone();
OsiGlpkSolverInterface * glpkClone = dynamic_cast<OsiGlpkSolverInterface*>(siClone);
OSIUNITTEST_ASSERT_ERROR(glpkClone != NULL, {}, "glpk", "clone");
OSIUNITTEST_ASSERT_ERROR(glpkClone->getModelPtr() != glpkSi.getModelPtr(), {}, "glpk", "clone");
OSIUNITTEST_ASSERT_ERROR(glpkClone->getNumRows() == glpkSi.getNumRows(), {}, "glpk", "clone");
OSIUNITTEST_ASSERT_ERROR(glpkClone->getNumCols() == glpkSi.getNumCols(), {}, "glpk", "clone");
delete siClone;
}
// test infinity
{
OsiGlpkSolverInterface si;
OSIUNITTEST_ASSERT_ERROR(si.getInfinity() == COIN_DBL_MAX, {}, "glpk", "infinity");
}
#if 0
// ??? These index error 'throw's aren't in OsiGlpk
// Test some catches
{
OsiGlpkSolverInterface solver;
try {
solver.setObjCoeff(0,0.0);
}
catch (CoinError e) {
std::cout<<"Correct throw"<<std::endl;
}
std::string fn = mpsDir+"exmip1";
solver.readMps(fn.c_str(),"mps");
try {
solver.setObjCoeff(0,0.0);
}
catch (CoinError e) {
std::cout<<"** Incorrect throw"<<std::endl;
abort();
}
try {
int index[]={0,20};
double value[]={0.0,0.0,0.0,0.0};
solver.setColSetBounds(index,index+2,value);
}
catch (CoinError e) {
std::cout<<"Correct throw"<<std::endl;
}
}
#endif
{
OsiGlpkSolverInterface glpkSi(m);
int nc = glpkSi.getNumCols();
int nr = glpkSi.getNumRows();
const double * cl = glpkSi.getColLower();
const double * cu = glpkSi.getColUpper();
const double * rl = glpkSi.getRowLower();
const double * ru = glpkSi.getRowUpper();
OSIUNITTEST_ASSERT_ERROR(nc == 8, return, "glpk", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(nr == 5, return, "glpk", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(cl[0],2.5), {}, "glpk", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(cl[1],0.0), {}, "glpk", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(cu[1],4.1), {}, "glpk", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(cu[2],1.0), {}, "glpk", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(rl[0],2.5), {}, "glpk", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(rl[4],3.0), {}, "glpk", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(ru[1],2.1), {}, "glpk", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(ru[4],15.), {}, "glpk", "read and copy exmip1");
const double * cs = glpkSi.getColSolution();
OSIUNITTEST_ASSERT_ERROR(eq(cs[0],2.5), {}, "glpk", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(cs[7],0.0), {}, "glpk", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(!eq(cl[3],1.2345), {}, "glpk", "set col lower");
glpkSi.setColLower( 3, 1.2345 );
OSIUNITTEST_ASSERT_ERROR( eq(cl[3],1.2345), {}, "glpk", "set col lower");
OSIUNITTEST_ASSERT_ERROR(!eq(glpkSi.getColUpper()[4],10.2345), {}, "glpk", "set col upper");
glpkSi.setColUpper( 4, 10.2345 );
OSIUNITTEST_ASSERT_ERROR( eq(glpkSi.getColUpper()[4],10.2345), {}, "glpk", "set col upper");
double objValue = glpkSi.getObjValue();
OSIUNITTEST_ASSERT_ERROR(eq(objValue,3.5), {}, "glpk", "getObjValue() before solve");
OSIUNITTEST_ASSERT_ERROR(eq(glpkSi.getObjCoefficients()[0], 1.0), {}, "glpk", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(glpkSi.getObjCoefficients()[1], 0.0), {}, "glpk", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(glpkSi.getObjCoefficients()[2], 0.0), {}, "glpk", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(glpkSi.getObjCoefficients()[3], 0.0), {}, "glpk", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(glpkSi.getObjCoefficients()[4], 2.0), {}, "glpk", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(glpkSi.getObjCoefficients()[5], 0.0), {}, "glpk", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(glpkSi.getObjCoefficients()[6], 0.0), {}, "glpk", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(glpkSi.getObjCoefficients()[7],-1.0), {}, "glpk", "read and copy exmip1");
}
// Test matrixByRow method
{
const OsiGlpkSolverInterface si(m);
const CoinPackedMatrix * smP = si.getMatrixByRow();
OSIUNITTEST_ASSERT_ERROR(smP->getMajorDim() == 5, return, "glpk", "getMatrixByRow: major dim");
OSIUNITTEST_ASSERT_ERROR(smP->getNumElements() == 14, return, "glpk", "getMatrixByRow: num elements");
CoinRelFltEq eq;
const double * ev = smP->getElements();
// GLPK returns each row in reverse order. This is consistent with
// the sparse matrix format but is not what most solvers do. That's
// why this section is different.
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 4], 3.0), {}, "glpk", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 3], 1.0), {}, "glpk", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 2],-2.0), {}, "glpk", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 1],-1.0), {}, "glpk", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 0],-1.0), {}, "glpk", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 6], 2.0), {}, "glpk", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 5], 1.1), {}, "glpk", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 8], 1.0), {}, "glpk", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 7], 1.0), {}, "glpk", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[10], 2.8), {}, "glpk", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 9],-1.2), {}, "glpk", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[13], 5.6), {}, "glpk", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[12], 1.0), {}, "glpk", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[11], 1.9), {}, "glpk", "getMatrixByRow: elements");
const CoinBigIndex * mi = smP->getVectorStarts();
OSIUNITTEST_ASSERT_ERROR(mi[0] == 0, {}, "glpk", "getMatrixByRow: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[1] == 5, {}, "glpk", "getMatrixByRow: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[2] == 7, {}, "glpk", "getMatrixByRow: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[3] == 9, {}, "glpk", "getMatrixByRow: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[4] == 11, {}, "glpk", "getMatrixByRow: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[5] == 14, {}, "glpk", "getMatrixByRow: vector starts");
const int * ei = smP->getIndices();
OSIUNITTEST_ASSERT_ERROR(ei[ 4] == 0, {}, "glpk", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 3] == 1, {}, "glpk", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 2] == 3, {}, "glpk", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 1] == 4, {}, "glpk", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 0] == 7, {}, "glpk", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 6] == 1, {}, "glpk", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 5] == 2, {}, "glpk", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 8] == 2, {}, "glpk", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 7] == 5, {}, "glpk", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[10] == 3, {}, "glpk", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 9] == 6, {}, "glpk", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[13] == 0, {}, "glpk", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[12] == 4, {}, "glpk", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[11] == 7, {}, "glpk", "getMatrixByRow: indices");
}
// Test adding several cuts
{
OsiGlpkSolverInterface fim;
std::string fn = mpsDir+"exmip1";
fim.readMps(fn.c_str(),"mps");
// exmip1.mps has 2 integer variables with index 2 & 3
fim.initialSolve();
OsiRowCut cuts[3];
// Generate one ineffective cut plus two trivial cuts
int c;
int nc = fim.getNumCols();
int *inx = new int[nc];
for (c=0;c<nc;c++) inx[c]=c;
double *el = new double[nc];
for (c=0;c<nc;c++) el[c]=1.0e-50+((double)c)*((double)c);
cuts[0].setRow(nc,inx,el);
cuts[0].setLb(-100.);
cuts[0].setUb(500.);
cuts[0].setEffectiveness(22);
el[4]=0.0; // to get inf later
for (c=2;c<4;c++) {
el[0]=1.0;
inx[0]=c;
cuts[c-1].setRow(1,inx,el);
cuts[c-1].setLb(1.);
cuts[c-1].setUb(100.);
cuts[c-1].setEffectiveness(c);
}
fim.writeMps("x1.mps");
fim.applyRowCuts(3,cuts);
fim.writeMps("x2.mps");
// resolve - should get message about zero elements
fim.resolve();
fim.writeMps("x3.mps");
// check integer solution
const double * cs = fim.getColSolution();
CoinRelFltEq eq;
OSIUNITTEST_ASSERT_ERROR(eq(cs[2], 1.0), {}, "glpk", "add cuts");
OSIUNITTEST_ASSERT_ERROR(eq(cs[3], 1.0), {}, "glpk", "add cuts");
#if 0 // ??? Not working for some reason.
// check will find invalid matrix
el[0]=1.0/el[4];
inx[0]=0;
cuts[0].setRow(nc,inx,el);
cuts[0].setLb(-100.);
cuts[0].setUb(500.);
cuts[0].setEffectiveness(22);
fim.applyRowCut(cuts[0]);
// resolve - should get message about zero elements
fim.resolve();
OSIUNITTEST_ASSERT_WARNING(fim.isAbandoned(), {}, "glpk", "add cuts");
#endif
delete[]el;
delete[]inx;
}
// Test matrixByCol method
{
const OsiGlpkSolverInterface si(m);
const CoinPackedMatrix * smP = si.getMatrixByCol();
OSIUNITTEST_ASSERT_ERROR(smP->getMajorDim() == 8, return, "glpk", "getMatrixByCol: major dim");
OSIUNITTEST_ASSERT_ERROR(smP->getMinorDim() == 5, return, "glpk", "getMatrixByCol: minor dim");
OSIUNITTEST_ASSERT_ERROR(smP->getNumElements() == 14, return, "glpk", "getMatrixByCol: number of elements");
OSIUNITTEST_ASSERT_ERROR(smP->getSizeVectorStarts() == 9, return, "glpk", "getMatrixByCol: vector starts size");
CoinRelFltEq eq;
const double * ev = smP->getElements();
// Unlike row-ordered matrices, GLPK does column-ordered the "normal" way
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 0], 3.0), {}, "glpk", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 1], 5.6), {}, "glpk", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 2], 1.0), {}, "glpk", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 3], 2.0), {}, "glpk", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 4], 1.1), {}, "glpk", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 5], 1.0), {}, "glpk", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 6],-2.0), {}, "glpk", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 7], 2.8), {}, "glpk", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 8],-1.0), {}, "glpk", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 9], 1.0), {}, "glpk", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[10], 1.0), {}, "glpk", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[11],-1.2), {}, "glpk", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[12],-1.0), {}, "glpk", "getMatrixByCol: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[13], 1.9), {}, "glpk", "getMatrixByCol: elements");
const CoinBigIndex * mi = smP->getVectorStarts();
OSIUNITTEST_ASSERT_ERROR(mi[0] == 0, {}, "glpk", "getMatrixByCol: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[1] == 2, {}, "glpk", "getMatrixByCol: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[2] == 4, {}, "glpk", "getMatrixByCol: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[3] == 6, {}, "glpk", "getMatrixByCol: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[4] == 8, {}, "glpk", "getMatrixByCol: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[5] == 10, {}, "glpk", "getMatrixByCol: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[6] == 11, {}, "glpk", "getMatrixByCol: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[7] == 12, {}, "glpk", "getMatrixByCol: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[8] == 14, {}, "glpk", "getMatrixByCol: vector starts");
const int * ei = smP->getIndices();
OSIUNITTEST_ASSERT_ERROR(ei[ 0] == 0, {}, "glpk", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 1] == 4, {}, "glpk", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 2] == 0, {}, "glpk", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 3] == 1, {}, "glpk", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 4] == 1, {}, "glpk", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 5] == 2, {}, "glpk", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 6] == 0, {}, "glpk", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 7] == 3, {}, "glpk", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 8] == 0, {}, "glpk", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 9] == 4, {}, "glpk", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[10] == 2, {}, "glpk", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[11] == 3, {}, "glpk", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[12] == 0, {}, "glpk", "getMatrixByCol: indices");
OSIUNITTEST_ASSERT_ERROR(ei[13] == 4, {}, "glpk", "getMatrixByCol: indices");
}
//--------------
// Test rowsense, rhs, rowrange, matrixByRow
{
OsiGlpkSolverInterface lhs;
{
#if 0 // FIXME ??? these won't work because the copy constructor changes the values in m
OSIUNITTEST_ASSERT_ERROR(m.rowrange_ == NULL, {}, "glpk", "???");
OSIUNITTEST_ASSERT_ERROR(m.rowsense_ == NULL, {}, "glpk", "???");
OSIUNITTEST_ASSERT_ERROR(m.rhs_ == NULL, {}, "glpk", "???");
OSIUNITTEST_ASSERT_ERROR(m.matrixByRow_ == NULL, {}, "glpk", "???");
#endif
OsiGlpkSolverInterface siC1(m);
OSIUNITTEST_ASSERT_WARNING(siC1.rowrange_ == NULL, {}, "glpk", "row range");
OSIUNITTEST_ASSERT_WARNING(siC1.rowsense_ == NULL, {}, "glpk", "row sense");
OSIUNITTEST_ASSERT_WARNING(siC1.rhs_ == NULL, {}, "glpk", "right hand side");
OSIUNITTEST_ASSERT_WARNING(siC1.matrixByRow_ == NULL, {}, "glpk", "matrix by row");
const char * siC1rs = siC1.getRowSense();
OSIUNITTEST_ASSERT_ERROR(siC1rs[0] == 'G', {}, "glpk", "row sense");
OSIUNITTEST_ASSERT_ERROR(siC1rs[1] == 'L', {}, "glpk", "row sense");
OSIUNITTEST_ASSERT_ERROR(siC1rs[2] == 'E', {}, "glpk", "row sense");
OSIUNITTEST_ASSERT_ERROR(siC1rs[3] == 'R', {}, "glpk", "row sense");
OSIUNITTEST_ASSERT_ERROR(siC1rs[4] == 'R', {}, "glpk", "row sense");
const double * siC1rhs = siC1.getRightHandSide();
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[0],2.5), {}, "glpk", "right hand side");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[1],2.1), {}, "glpk", "right hand side");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[2],4.0), {}, "glpk", "right hand side");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[3],5.0), {}, "glpk", "right hand side");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[4],15.), {}, "glpk", "right hand side");
const double * siC1rr = siC1.getRowRange();
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[0],0.0), {}, "glpk", "row range");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[1],0.0), {}, "glpk", "row range");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[2],0.0), {}, "glpk", "row range");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[3],5.0-1.8), {}, "glpk", "row range");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[4],15.0-3.0), {}, "glpk", "row range");
const CoinPackedMatrix * siC1mbr = siC1.getMatrixByRow();
OSIUNITTEST_ASSERT_ERROR(siC1mbr != NULL, {}, "glpk", "matrix by row");
OSIUNITTEST_ASSERT_ERROR(siC1mbr->getMajorDim() == 5, return, "glpk", "matrix by row: major dim");
OSIUNITTEST_ASSERT_ERROR(siC1mbr->getNumElements() == 14, return, "glpk", "matrix by row: num elements");
const double * ev = siC1mbr->getElements();
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 4], 3.0), {}, "glpk", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 3], 1.0), {}, "glpk", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 2],-2.0), {}, "glpk", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 1],-1.0), {}, "glpk", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 0],-1.0), {}, "glpk", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 6], 2.0), {}, "glpk", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 5], 1.1), {}, "glpk", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 8], 1.0), {}, "glpk", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 7], 1.0), {}, "glpk", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[10], 2.8), {}, "glpk", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 9],-1.2), {}, "glpk", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[13], 5.6), {}, "glpk", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[12], 1.0), {}, "glpk", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[11], 1.9), {}, "glpk", "matrix by row: elements");
const CoinBigIndex * mi = siC1mbr->getVectorStarts();
OSIUNITTEST_ASSERT_ERROR(mi[0] == 0, {}, "glpk", "matrix by row: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[1] == 5, {}, "glpk", "matrix by row: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[2] == 7, {}, "glpk", "matrix by row: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[3] == 9, {}, "glpk", "matrix by row: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[4] == 11, {}, "glpk", "matrix by row: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[5] == 14, {}, "glpk", "matrix by row: vector starts");
const int * ei = siC1mbr->getIndices();
OSIUNITTEST_ASSERT_ERROR(ei[ 4] == 0, {}, "glpk", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 3] == 1, {}, "glpk", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 2] == 3, {}, "glpk", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 1] == 4, {}, "glpk", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 0] == 7, {}, "glpk", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 6] == 1, {}, "glpk", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 5] == 2, {}, "glpk", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 8] == 2, {}, "glpk", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 7] == 5, {}, "glpk", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[10] == 3, {}, "glpk", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 9] == 6, {}, "glpk", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[13] == 0, {}, "glpk", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[12] == 4, {}, "glpk", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[11] == 7, {}, "glpk", "matrix by row: indices");
OSIUNITTEST_ASSERT_WARNING(siC1rs == siC1.getRowSense(), {}, "glpk", "row sense");
OSIUNITTEST_ASSERT_WARNING(siC1rhs == siC1.getRightHandSide(), {}, "glpk", "right hand side");
OSIUNITTEST_ASSERT_WARNING(siC1rr == siC1.getRowRange(), {}, "glpk", "row range");
// Change glpk Model by adding free row
OsiRowCut rc;
rc.setLb(-COIN_DBL_MAX);
rc.setUb( COIN_DBL_MAX);
OsiCuts cuts;
cuts.insert(rc);
siC1.applyCuts(cuts);
// Since model was changed, test that cached data is now freed.
OSIUNITTEST_ASSERT_ERROR(siC1.rowrange_ == NULL, {}, "glpk", "free cached data after adding row");
OSIUNITTEST_ASSERT_ERROR(siC1.rowsense_ == NULL, {}, "glpk", "free cached data after adding row");
OSIUNITTEST_ASSERT_ERROR(siC1.rhs_ == NULL, {}, "glpk", "free cached data after adding row");
OSIUNITTEST_ASSERT_ERROR(siC1.matrixByRow_ == NULL, {}, "glpk", "free cached data after adding row");
siC1rs = siC1.getRowSense();
OSIUNITTEST_ASSERT_ERROR(siC1rs[0] == 'G', {}, "glpk", "row sense after adding row");
OSIUNITTEST_ASSERT_ERROR(siC1rs[1] == 'L', {}, "glpk", "row sense after adding row");
OSIUNITTEST_ASSERT_ERROR(siC1rs[2] == 'E', {}, "glpk", "row sense after adding row");
OSIUNITTEST_ASSERT_ERROR(siC1rs[3] == 'R', {}, "glpk", "row sense after adding row");
OSIUNITTEST_ASSERT_ERROR(siC1rs[4] == 'R', {}, "glpk", "row sense after adding row");
OSIUNITTEST_ASSERT_ERROR(siC1rs[5] == 'N', {}, "glpk", "row sense after adding row");
siC1rhs = siC1.getRightHandSide();
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[0],2.5), {}, "glpk", "right hand side after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[1],2.1), {}, "glpk", "right hand side after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[2],4.0), {}, "glpk", "right hand side after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[3],5.0), {}, "glpk", "right hand side after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[4],15.), {}, "glpk", "right hand side after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[5],0.0), {}, "glpk", "right hand side after adding row");
siC1rr = siC1.getRowRange();
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[0],0.0), {}, "glpk", "row range after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[1],0.0), {}, "glpk", "row range after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[2],0.0), {}, "glpk", "row range after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[3],5.0-1.8), {}, "glpk", "row range after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[4],15.0-3.0), {}, "glpk", "row range after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[5],0.0), {}, "glpk", "row range after adding row");
lhs = siC1;
}
// Test that lhs has correct values even though siC1 has gone out of scope
OSIUNITTEST_ASSERT_ERROR(lhs.rowrange_ == NULL, {}, "glpk", "freed origin after assignment");
OSIUNITTEST_ASSERT_ERROR(lhs.rowsense_ == NULL, {}, "glpk", "freed origin after assignment");
OSIUNITTEST_ASSERT_ERROR(lhs.rhs_ == NULL, {}, "glpk", "freed origin after assignment");
OSIUNITTEST_ASSERT_ERROR(lhs.matrixByRow_ == NULL, {}, "glpk", "freed origin after assignment");
const char * lhsrs = lhs.getRowSense();
OSIUNITTEST_ASSERT_ERROR(lhsrs[0] == 'G', {}, "glpk", "row sense after assignment");
OSIUNITTEST_ASSERT_ERROR(lhsrs[1] == 'L', {}, "glpk", "row sense after assignment");
OSIUNITTEST_ASSERT_ERROR(lhsrs[2] == 'E', {}, "glpk", "row sense after assignment");
OSIUNITTEST_ASSERT_ERROR(lhsrs[3] == 'R', {}, "glpk", "row sense after assignment");
OSIUNITTEST_ASSERT_ERROR(lhsrs[4] == 'R', {}, "glpk", "row sense after assignment");
OSIUNITTEST_ASSERT_ERROR(lhsrs[5] == 'N', {}, "glpk", "row sense after assignment");
const double * lhsrhs = lhs.getRightHandSide();
OSIUNITTEST_ASSERT_ERROR(eq(lhsrhs[0],2.5), {}, "glpk", "right hand side after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrhs[1],2.1), {}, "glpk", "right hand side after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrhs[2],4.0), {}, "glpk", "right hand side after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrhs[3],5.0), {}, "glpk", "right hand side after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrhs[4],15.), {}, "glpk", "right hand side after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrhs[5],0.0), {}, "glpk", "right hand side after assignment");
const double *lhsrr = lhs.getRowRange();
OSIUNITTEST_ASSERT_ERROR(eq(lhsrr[0],0.0), {}, "glpk", "row range after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrr[1],0.0), {}, "glpk", "row range after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrr[2],0.0), {}, "glpk", "row range after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrr[3],5.0-1.8), {}, "glpk", "row range after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrr[4],15.0-3.0), {}, "glpk", "row range after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrr[5],0.0), {}, "glpk", "row range after assignment");
const CoinPackedMatrix * lhsmbr = lhs.getMatrixByRow();
OSIUNITTEST_ASSERT_ERROR(lhsmbr != NULL, return, "glpk", "matrix by row after assignment");
OSIUNITTEST_ASSERT_ERROR(lhsmbr->getMajorDim() == 6, return, "glpk", "matrix by row after assignment: major dim");
OSIUNITTEST_ASSERT_ERROR(lhsmbr->getNumElements() == 14, return, "glpk", "matrix by row after assignment: num elements");
const double * ev = lhsmbr->getElements();
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 4], 3.0), {}, "glpk", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 3], 1.0), {}, "glpk", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 2],-2.0), {}, "glpk", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 1],-1.0), {}, "glpk", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 0],-1.0), {}, "glpk", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 6], 2.0), {}, "glpk", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 5], 1.1), {}, "glpk", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 8], 1.0), {}, "glpk", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 7], 1.0), {}, "glpk", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[10], 2.8), {}, "glpk", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 9],-1.2), {}, "glpk", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[13], 5.6), {}, "glpk", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[12], 1.0), {}, "glpk", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[11], 1.9), {}, "glpk", "matrix by row after assignment: elements");
const CoinBigIndex * mi = lhsmbr->getVectorStarts();
OSIUNITTEST_ASSERT_ERROR(mi[0] == 0, {}, "glpk", "matrix by row after assignment: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[1] == 5, {}, "glpk", "matrix by row after assignment: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[2] == 7, {}, "glpk", "matrix by row after assignment: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[3] == 9, {}, "glpk", "matrix by row after assignment: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[4] == 11, {}, "glpk", "matrix by row after assignment: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[5] == 14, {}, "glpk", "matrix by row after assignment: vector starts");
const int * ei = lhsmbr->getIndices();
OSIUNITTEST_ASSERT_ERROR(ei[ 4] == 0, {}, "glpk", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 3] == 1, {}, "glpk", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 2] == 3, {}, "glpk", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 1] == 4, {}, "glpk", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 0] == 7, {}, "glpk", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 6] == 1, {}, "glpk", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 5] == 2, {}, "glpk", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 8] == 2, {}, "glpk", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 7] == 5, {}, "glpk", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[10] == 3, {}, "glpk", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 9] == 6, {}, "glpk", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[13] == 0, {}, "glpk", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[12] == 4, {}, "glpk", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[11] == 7, {}, "glpk", "matrix by row after assignment: indices");
}
}
// Test add/delete columns
{
OsiGlpkSolverInterface m;
std::string fn = mpsDir+"p0033";
m.readMps(fn.c_str(),"mps");
double inf = m.getInfinity();
CoinPackedVector c0;
c0.insert(0, 4);
c0.insert(1, 1);
m.addCol(c0, 0, inf, 3);
m.initialSolve();
double objValue = m.getObjValue();
CoinRelFltEq eq(1.0e-2);
OSIUNITTEST_ASSERT_ERROR(eq(objValue,2520.57), {}, "glpk", "add/delete columns: first optimal value");
// Try deleting first column that's nonbasic at lower bound (0).
int * d = new int[1];
CoinWarmStartBasis *cwsb = dynamic_cast<CoinWarmStartBasis *>(m.getWarmStart()) ;
OSIUNITTEST_ASSERT_ERROR(cwsb != NULL, {}, "glpk", "add/delete columns: have warm start basis");
CoinWarmStartBasis::Status stati ;
int iCol ;
for (iCol = 0 ; iCol < cwsb->getNumStructural() ; iCol++)
{ stati = cwsb->getStructStatus(iCol) ;
if (stati == CoinWarmStartBasis::atLowerBound) break ; }
d[0]=iCol;
m.deleteCols(1,d);
delete [] d;
delete cwsb;
d=NULL;
m.resolve();
objValue = m.getObjValue();
OSIUNITTEST_ASSERT_ERROR(eq(objValue,2520.57), {}, "glpk", "add/delete columns: optimal value after deleting nonbasic column");
// Try deleting column we added. If basic, go to initialSolve as deleting
// basic variable trashes basis required for warm start.
iCol = m.getNumCols()-1;
cwsb = dynamic_cast<CoinWarmStartBasis *>(m.getWarmStart()) ;
stati = cwsb->getStructStatus(iCol) ;
delete cwsb;
m.deleteCols(1,&iCol);
if (stati == CoinWarmStartBasis::basic)
{ m.initialSolve() ; }
else
{ m.resolve(); }
objValue = m.getObjValue();
OSIUNITTEST_ASSERT_ERROR(eq(objValue,2520.57), {}, "glpk", "add/delete columns: optimal value after deleting added column");
}
#if 0
// ??? Simplex routines not adapted to OsiGlpk yet
// Solve an lp by hand
{
OsiGlpkSolverInterface m;
std::string fn = mpsDir+"p0033";
m.readMps(fn.c_str(),"mps");
m.setObjSense(-1.0);
m.getModelPtr()->messageHandler()->setLogLevel(4);
m.initialSolve();
m.getModelPtr()->factorization()->maximumPivots(5);
m.setObjSense(1.0);
// enable special mode
m.enableSimplexInterface(true);
// we happen to know that variables are 0-1 and rows are L
int numberIterations=0;
int numberColumns = m.getNumCols();
int numberRows = m.getNumRows();
double * fakeCost = new double[numberColumns];
double * duals = new double [numberRows];
double * djs = new double [numberColumns];
const double * solution = m.getColSolution();
memcpy(fakeCost,m.getObjCoefficients(),numberColumns*sizeof(double));
while (1) {
const double * dj;
const double * dual;
if ((numberIterations&1)==0) {
// use given ones
dj = m.getReducedCost();
dual = m.getRowPrice();
} else {
// create
dj = djs;
dual = duals;
m.getReducedGradient(djs,duals,fakeCost);
}
int i;
int colIn=9999;
int direction=1;
double best=1.0e-6;
// find most negative reduced cost
// Should check basic - but should be okay on this problem
for (i=0;i<numberRows;i++) {
double value=dual[i];
if (value>best) {
direction=-1;
best=value;
colIn=-i-1;
}
}
for (i=0;i<numberColumns;i++) {
double value=dj[i];
if (value<-best&&solution[i]<1.0e-6) {
direction=1;
best=-value;
colIn=i;
} else if (value>best&&solution[i]>1.0-1.0e-6) {
direction=-1;
best=value;
colIn=i;
}
}
if (colIn==9999)
break; // should be optimal
int colOut;
int outStatus;
double theta;
OSIUNITTEST_ASSERT_ERROR(m.primalPivotResult(colIn,direction,colOut,outStatus,theta,NULL) == 0, {}, "glpk", "simplex routines");
printf("out %d, direction %d theta %g\n", colOut,outStatus,theta);
numberIterations++;
}
delete [] fakeCost;
delete [] duals;
delete [] djs;
// exit special mode
m.disableSimplexInterface();
m.getModelPtr()->messageHandler()->setLogLevel(4);
m.resolve();
OSIUNITTEST_ASSERT_ERROR(m.getIterationCount() == 0, {}, "glpk", "simplex routines");
m.setObjSense(-1.0);
m.initialSolve();
}
// Solve an lp when interface is on
{
OsiGlpkSolverInterface m;
std::string fn = mpsDir+"p0033";
m.readMps(fn.c_str(),"mps");
// enable special mode
m.setHintParam(OsiDoScale,false,OsiHintDo);
m.setHintParam(OsiDoPresolveInInitial,false,OsiHintDo);
m.setHintParam(OsiDoDualInInitial,false,OsiHintDo);
m.setHintParam(OsiDoPresolveInResolve,false,OsiHintDo);
m.setHintParam(OsiDoDualInResolve,false,OsiHintDo);
m.enableSimplexInterface(true);
m.initialSolve();
}
// Check tableau stuff when simplex interface is on
{
OsiGlpkSolverInterface m;
/*
Wolsey : Page 130
max 4x1 - x2
7x1 - 2x2 <= 14
x2 <= 3
2x1 - 2x2 <= 3
x1 in Z+, x2 >= 0
*/
double inf_ = m.getInfinity();
int n_cols = 2;
int n_rows = 3;
double obj[2] = {-4.0, 1.0};
double collb[2] = {0.0, 0.0};
double colub[2] = {inf_, inf_};
double rowlb[3] = {-inf_, -inf_, -inf_};
double rowub[3] = {14.0, 3.0, 3.0};
int rowIndices[5] = {0, 2, 0, 1, 2};
int colIndices[5] = {0, 0, 1, 1, 1};
double elements[5] = {7.0, 2.0, -2.0, 1.0, -2.0};
CoinPackedMatrix M(true, rowIndices, colIndices, elements, 5);
m.loadProblem(M, collb, colub, obj, rowlb, rowub);
m.enableSimplexInterface(true);
m.initialSolve();
//check that the tableau matches wolsey (B-1 A)
// slacks in second part of binvA
double * binvA = (double*) malloc((n_cols+n_rows) * sizeof(double));
printf("B-1 A");
for(int i = 0; i < n_rows; i++){
m.getBInvARow(i, binvA,binvA+n_cols);
printf("\nrow: %d -> ",i);
for(int j=0; j < n_cols+n_rows; j++){
printf("%g, ", binvA[j]);
}
}
printf("\n");
m.disableSimplexInterface();
free(binvA);
}
#endif
/*
Read in exmip1 and solve it with verbose output setting.
*/
{ OsiGlpkSolverInterface osi ;
std::cout << "Boosting verbosity.\n" ;
osi.setHintParam(OsiDoReducePrint,false,OsiForceDo) ;
std::string exmpsfile = mpsDir+"exmip1" ;
std::string probname ;
std::cout << "Reading mps file \"" << exmpsfile << "\"\n" ;
osi.readMps(exmpsfile.c_str(), "mps") ;
OSIUNITTEST_ASSERT_ERROR(osi.getStrParam(OsiProbName,probname), {}, "glpk", "get problem name");
std::cout << "Solving " << probname << " ... \n" ;
osi.initialSolve() ;
double val = osi.getObjValue() ;
std::cout << "And the answer is " << val << ".\n" ;
OSIUNITTEST_ASSERT_ERROR(fabs(val - 3.23) < 0.01, {}, "glpk", "solve exmip1");
}
// Do common solverInterface testing
{
OsiGlpkSolverInterface m;
OsiSolverInterfaceCommonUnitTest(&m, mpsDir,netlibDir);
}
}
//--------------------------------------------------------------------------
// ** At present this does not use any solver
void
CglGomoryUnitTest(
const OsiSolverInterface * baseSiP,
const std::string mpsDir )
{
CoinRelFltEq eq(0.000001);
// Test default constructor
{
CglGomory aGenerator;
assert (aGenerator.getLimit()==50);
assert (aGenerator.getAway()==0.05);
}
// Test copy & assignment etc
{
CglGomory rhs;
{
CglGomory bGenerator;
bGenerator.setLimit(99);
bGenerator.setAway(0.2);
CglGomory cGenerator(bGenerator);
rhs=bGenerator;
assert (rhs.getLimit()==99);
assert (rhs.getAway()==0.2);
}
}
// Test explicit form - all integer (pg 125 Wolsey)
if (1) {
OsiCuts osicuts;
CglGomory test1;
int i;
int nOldCuts=0,nRowCuts;
// matrix data
//deliberate hiccup of 2 between 0 and 1
CoinBigIndex start[5]={0,4,7,8,9};
int length[5]={2,3,1,1,1};
int rows[11]={0,2,-1,-1,0,1,2,0,1,2};
double elements[11]={7.0,2.0,1.0e10,1.0e10,-2.0,1.0,-2.0,1,1,1};
CoinPackedMatrix matrix(true,3,5,8,elements,rows,start,length);
// rim data (objective not used just yet)
double rowLower[5]={14.0,3.0,3.0,1.0e10,1.0e10};
double rowUpper[5]={14.0,3.0,3.0,-1.0e10,-1.0e10};
double colLower[7]={0.0,0.0,0.0,0.0,0.0,0.0,0.0};
double colUpper[7]={100.0,100.0,100.0,100.0,100.0,100.0,100.0};
// integer
char intVar[7]={2,2,2,2,2,2,2};
// basis 1
int rowBasis1[3]={-1,-1,-1};
int colBasis1[5]={1,1,-1,-1,1};
CoinWarmStartBasis warm;
warm.setSize(5,3);
for (i=0;i<3;i++) {
if (rowBasis1[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<5;i++) {
if (colBasis1[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 1
double colsol1[5]={20.0/7.0,3.0,0.0,0.0,23.0/7.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol1,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==2);
// cuts always <=
int testCut=0; // test first cut as stronger
double rhs=-6.0;
double testCut1[5]={0.0,0.0,-1.0,-2.0,0.0};
double * cut = testCut1;
double * colsol = colsol1;
for (i=nOldCuts; i<nRowCuts; i++){
OsiRowCut rcut;
CoinPackedVector rpv;
rcut = osicuts.rowCut(i);
rpv = rcut.row();
const int n = rpv.getNumElements();
const int * indices = rpv.getIndices();
double* elements = rpv.getElements();
double sum2=0.0;
int k=0;
for (k=0; k<n; k++){
int column=indices[k];
sum2 += colsol[column]*elements[k];
}
double ub=rcut.ub();
#ifdef CGL_DEBUG
double lb=rcut.lb();
if (sum2 >ub + 1.0e-7 ||sum2 < lb - 1.0e-7) {
std::cout<<"Cut "<<i<<" lb "<<lb<<" solution "<<sum2<<" ub "<<ub<<std::endl;
for (k=0; k<n; k++){
int column=indices[k];
std::cout<<"(col="<<column<<",el="<<elements[k]<<",sol="<<
colsol[column]<<") ";
}
std::cout <<std::endl;
}
#endif
if (i-nOldCuts==testCut) {
assert( eq(rhs,ub));
assert(n==2);
for (k=0; k<n; k++){
int column=indices[k];
assert (eq(cut[column],elements[k]));
}
// add cut
// explicit slack
matrix.setDimensions(-1,6);
rpv.insert(5,1.0*7.0); // to get cut in book
rowLower[3]=ub;
rowUpper[3]=ub;
matrix.appendRow(rpv);
}
}
nOldCuts=nRowCuts;
// basis 2
int rowBasis2[4]={-1,-1,-1,-1};
int colBasis2[6]={1,1,1,1,-1,-1};
warm.setSize(6,4);
for (i=0;i<4;i++) {
if (rowBasis2[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<6;i++) {
if (colBasis2[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 2
double colsol2[6]={2.0,0.5,1.0,2.5,0.0,0.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol2,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts-nOldCuts==2);
// cuts always <=
testCut=0; // test first cut as stronger
rhs=-1.0;
double testCut2[6]={0.0,0.0,0.0,0.0,-1.0,0.0};
cut = testCut2;
colsol = colsol2;
for (i=nOldCuts; i<nRowCuts; i++){
OsiRowCut rcut;
CoinPackedVector rpv;
rcut = osicuts.rowCut(i);
rpv = rcut.row();
const int n = rpv.getNumElements();
const int * indices = rpv.getIndices();
double* elements = rpv.getElements();
double sum2=0.0;
int k=0;
for (k=0; k<n; k++){
int column=indices[k];
sum2 += colsol[column]*elements[k];
}
double ub=rcut.ub();
#ifdef CGL_DEBUG
double lb=rcut.lb();
if (sum2 >ub + 1.0e-7 ||sum2 < lb - 1.0e-7) {
std::cout<<"Cut "<<i<<" lb "<<lb<<" solution "<<sum2<<" ub "<<ub<<std::endl;
for (k=0; k<n; k++){
int column=indices[k];
std::cout<<"(col="<<column<<",el="<<elements[k]<<",sol="<<
colsol[column]<<") ";
}
std::cout <<std::endl;
}
#endif
if (i-nOldCuts==testCut) {
assert( eq(rhs,ub));
assert(n==1);
for (k=0; k<n; k++){
int column=indices[k];
assert (eq(cut[column],elements[k]));
}
// add cut
// explicit slack
matrix.setDimensions(-1,7);
rpv.insert(6,1.0);
rowLower[4]=ub;
rowUpper[4]=ub;
matrix.appendRow(rpv);
}
}
nOldCuts=nRowCuts;
// basis 3
int rowBasis3[5]={-1,-1,-1,-1,-1};
int colBasis3[7]={1,1,1,1,1,-1,-1};
warm.setSize(7,5);
for (i=0;i<5;i++) {
if (rowBasis3[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<7;i++) {
if (colBasis3[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 3
double colsol3[7]={2.0,1.0,2.0,2.0,1.0,0.0,0.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol3,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==nOldCuts);
}
// Test explicit form - this time with x4 flipped
if (1) {
OsiCuts osicuts;
CglGomory test1;
int i;
int nOldCuts=0,nRowCuts;
// matrix data
//deliberate hiccup of 2 between 0 and 1
CoinBigIndex start[5]={0,4,7,8,9};
int length[5]={2,3,1,1,1};
int rows[11]={0,2,-1,-1,0,1,2,0,1,2};
double elements[11]={7.0,2.0,1.0e10,1.0e10,-2.0,1.0,-2.0,1,-1,1};
CoinPackedMatrix matrix(true,3,5,8,elements,rows,start,length);
// rim data (objective not used just yet)
double rowLower[5]={14.0,-5.0,3.0,1.0e10,1.0e10};
double rowUpper[5]={14.0,-5.0,3.0,-1.0e10,-1.0e10};
double colLower[7]={0.0,0.0,0.0,0.0,0.0,0.0,0.0};
double colUpper[7]={100.0,100.0,100.0,8.0,100.0,100.0,100.0};
// integer
char intVar[7]={2,2,2,2,2,2,2};
// basis 1
int rowBasis1[3]={-1,-1,-1};
int colBasis1[5]={1,1,-1,-1,1};
CoinWarmStartBasis warm;
warm.setSize(5,3);
for (i=0;i<3;i++) {
if (rowBasis1[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<5;i++) {
if (colBasis1[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 1
double colsol1[5]={20.0/7.0,3.0,0.0,8.0,23.0/7.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol1,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==2);
// cuts always <=
int testCut=0; // test first cut as stronger
double rhs=10.0;
double testCut1[5]={0.0,0.0,-1.0,2.0,0.0};
double * cut = testCut1;
double * colsol = colsol1;
for (i=nOldCuts; i<nRowCuts; i++){
OsiRowCut rcut;
CoinPackedVector rpv;
rcut = osicuts.rowCut(i);
rpv = rcut.row();
const int n = rpv.getNumElements();
const int * indices = rpv.getIndices();
double* elements = rpv.getElements();
double sum2=0.0;
int k=0;
for (k=0; k<n; k++){
int column=indices[k];
sum2 += colsol[column]*elements[k];
}
double ub=rcut.ub();
#ifdef CGL_DEBUG
double lb=rcut.lb();
if (sum2 >ub + 1.0e-7 ||sum2 < lb - 1.0e-7) {
std::cout<<"Cut "<<i<<" lb "<<lb<<" solution "<<sum2<<" ub "<<ub<<std::endl;
for (k=0; k<n; k++){
int column=indices[k];
std::cout<<"(col="<<column<<",el="<<elements[k]<<",sol="<<
colsol[column]<<") ";
}
std::cout <<std::endl;
}
#endif
if (i-nOldCuts==testCut) {
assert( eq(rhs,ub));
assert(n==2);
for (k=0; k<n; k++){
int column=indices[k];
assert (eq(cut[column],elements[k]));
}
// add cut
// explicit slack
matrix.setDimensions(-1,6);
rpv.insert(5,1.0*7.0); // to get cut in book
rowLower[3]=ub;
rowUpper[3]=ub;
matrix.appendRow(rpv);
}
}
nOldCuts=nRowCuts;
// basis 2
int rowBasis2[4]={-1,-1,-1,-1};
int colBasis2[6]={1,1,1,1,-1,-1};
warm.setSize(6,4);
for (i=0;i<4;i++) {
if (rowBasis2[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<6;i++) {
if (colBasis2[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 2
double colsol2[6]={2.0,0.5,1.0,5.5,0.0,0.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol2,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts-nOldCuts==2);
// cuts always <=
testCut=0; // test first cut as stronger
rhs=-1.0;
double testCut2[6]={0.0,0.0,0.0,0.0,-1.0,0.0};
cut = testCut2;
colsol = colsol2;
for (i=nOldCuts; i<nRowCuts; i++){
OsiRowCut rcut;
CoinPackedVector rpv;
rcut = osicuts.rowCut(i);
rpv = rcut.row();
const int n = rpv.getNumElements();
const int * indices = rpv.getIndices();
double* elements = rpv.getElements();
double sum2=0.0;
int k=0;
for (k=0; k<n; k++){
int column=indices[k];
sum2 += colsol[column]*elements[k];
}
double ub=rcut.ub();
#ifdef CGL_DEBUG
double lb=rcut.lb();
if (sum2 >ub + 1.0e-7 ||sum2 < lb - 1.0e-7) {
std::cout<<"Cut "<<i<<" lb "<<lb<<" solution "<<sum2<<" ub "<<ub<<std::endl;
for (k=0; k<n; k++){
int column=indices[k];
std::cout<<"(col="<<column<<",el="<<elements[k]<<",sol="<<
colsol[column]<<") ";
}
std::cout <<std::endl;
}
#endif
if (i-nOldCuts==testCut) {
assert( eq(rhs,ub));
assert(n==1);
for (k=0; k<n; k++){
int column=indices[k];
assert (eq(cut[column],elements[k]));
}
// add cut
// explicit slack
matrix.setDimensions(-1,7);
rpv.insert(6,1.0);
rowLower[4]=ub;
rowUpper[4]=ub;
matrix.appendRow(rpv);
}
}
nOldCuts=nRowCuts;
// basis 3
int rowBasis3[5]={-1,-1,-1,-1,-1};
int colBasis3[7]={1,1,1,1,1,-1,-1};
warm.setSize(7,5);
for (i=0;i<5;i++) {
if (rowBasis3[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<7;i++) {
if (colBasis3[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 3
double colsol3[7]={2.0,1.0,2.0,6.0,1.0,0.0,0.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol3,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==nOldCuts);
}
// Test with slacks
if (1) {
OsiCuts osicuts;
CglGomory test1;
int i;
int nOldCuts=0,nRowCuts;
// matrix data
//deliberate hiccup of 2 between 0 and 1
CoinBigIndex start[5]={0,4};
int length[5]={2,3};
int rows[11]={0,2,-1,-1,0,1,2};
double elements[11]={7.0,2.0,1.0e10,1.0e10,-2.0,1.0,-2.0};
CoinPackedMatrix matrix(true,3,2,5,elements,rows,start,length);
// rim data (objective not used just yet)
double rowLower[5]={-1.0e10,-1.0e10,-1.0e10,1.0e10,1.0e10};
double rowUpper[5]={14.0,3.0,3.0,-1.0e10,-1.0e10};
double colLower[2]={0.0,0.0};
double colUpper[2]={100.0,100.0};
// integer
char intVar[2]={2,2};
// basis 1
int rowBasis1[3]={-1,-1,1};
int colBasis1[2]={1,1};
CoinWarmStartBasis warm;
warm.setSize(2,3);
for (i=0;i<3;i++) {
if (rowBasis1[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<2;i++) {
if (colBasis1[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 1
double colsol1[2]={20.0/7.0,3.0};
test1.generateCuts(NULL, osicuts, matrix,
/* objective,*/ colsol1,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==1);
// cuts always <=
int testCut=0; // test first cut as stronger
double rhs=2.0;
double testCut1[2]={1.0,0.0};
double * cut = testCut1;
double * colsol = colsol1;
for (i=nOldCuts; i<nRowCuts; i++){
OsiRowCut rcut;
CoinPackedVector rpv;
rcut = osicuts.rowCut(i);
rpv = rcut.row();
const int n = rpv.getNumElements();
const int * indices = rpv.getIndices();
double* elements = rpv.getElements();
double sum2=0.0;
int k=0;
for (k=0; k<n; k++){
int column=indices[k];
sum2 += colsol[column]*elements[k];
}
double ub=rcut.ub();
#ifdef CGL_DEBUG
double lb=rcut.lb();
if (sum2 >ub + 1.0e-7 ||sum2 < lb - 1.0e-7) {
std::cout<<"Cut "<<i<<" lb "<<lb<<" solution "<<sum2<<" ub "<<ub<<std::endl;
for (k=0; k<n; k++){
int column=indices[k];
std::cout<<"(col="<<column<<",el="<<elements[k]<<",sol="<<
colsol[column]<<") ";
}
std::cout <<std::endl;
}
#endif
if (i-nOldCuts==testCut) {
assert( eq(rhs,ub));
assert(n==1);
for (k=0; k<n; k++){
int column=indices[k];
assert (eq(cut[column],elements[k]));
}
// add cut
rowLower[3]=-1.0e100;
rowUpper[3]=ub;
matrix.appendRow(rpv);
}
}
nOldCuts=nRowCuts;
// basis 2
int rowBasis2[4]={1,1,-1,-1};
int colBasis2[2]={1,1};
warm.setSize(2,4);
for (i=0;i<4;i++) {
if (rowBasis2[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<2;i++) {
if (colBasis2[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 2
double colsol2[2]={2.0,0.5};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol2,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts-nOldCuts==1);
// cuts always <=
testCut=0; // test first cut as stronger
rhs=1.0;
double testCut2[2]={1.0,-1.0};
cut = testCut2;
colsol = colsol2;
for (i=nOldCuts; i<nRowCuts; i++){
OsiRowCut rcut;
CoinPackedVector rpv;
rcut = osicuts.rowCut(i);
rpv = rcut.row();
const int n = rpv.getNumElements();
const int * indices = rpv.getIndices();
double* elements = rpv.getElements();
double sum2=0.0;
int k=0;
for (k=0; k<n; k++){
int column=indices[k];
sum2 += colsol[column]*elements[k];
}
double ub=rcut.ub();
#ifdef CGL_DEBUG
double lb=rcut.lb();
if (sum2 >ub + 1.0e-7 ||sum2 < lb - 1.0e-7) {
std::cout<<"Cut "<<i<<" lb "<<lb<<" solution "<<sum2<<" ub "<<ub<<std::endl;
for (k=0; k<n; k++){
int column=indices[k];
std::cout<<"(col="<<column<<",el="<<elements[k]<<",sol="<<
colsol[column]<<") ";
}
std::cout <<std::endl;
}
#endif
if (i-nOldCuts==testCut) {
assert( eq(rhs,ub));
assert(n==2);
for (k=0; k<n; k++){
int column=indices[k];
assert (eq(cut[column],elements[k]));
}
// add cut
rowLower[4]=-1.0e100;
rowUpper[4]=ub;
matrix.appendRow(rpv);
}
}
nOldCuts=nRowCuts;
// basis 3
int rowBasis3[5]={1,1,1,-1,-1};
int colBasis3[2]={1,1};
warm.setSize(2,5);
for (i=0;i<5;i++) {
if (rowBasis3[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<2;i++) {
if (colBasis3[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 3
double colsol3[2]={2.0,1.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol3,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==nOldCuts);
}
// swap some rows to G
if (1) {
OsiCuts osicuts;
CglGomory test1;
int i;
int nOldCuts=0,nRowCuts;
// matrix data
//deliberate hiccup of 2 between 0 and 1
CoinBigIndex start[5]={0,4};
int length[5]={2,3};
int rows[11]={0,2,-1,-1,0,1,2};
double elements[11]={-7.0,-2.0,1.0e10,1.0e10,+2.0,1.0,+2.0};
CoinPackedMatrix matrix(true,3,2,5,elements,rows,start,length);
// rim data (objective not used just yet)
double rowUpper[5]={1.0e10,3.0,1.0e10,-1.0e10,-1.0e10};
double rowLower[5]={-14.0,-1.0e10,-3.0,1.0e10,1.0e10};
double colLower[2]={0.0,0.0};
double colUpper[2]={100.0,100.0};
// integer
char intVar[2]={2,2};
// basis 1
int rowBasis1[3]={-1,-1,1};
int colBasis1[2]={1,1};
CoinWarmStartBasis warm;
warm.setSize(2,3);
for (i=0;i<3;i++) {
if (rowBasis1[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<2;i++) {
if (colBasis1[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 1
double colsol1[2]={20.0/7.0,3.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol1,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==1);
// cuts always <=
int testCut=0; // test first cut as stronger
double rhs=2.0;
double testCut1[2]={1.0,0.0};
double * cut = testCut1;
double * colsol = colsol1;
for (i=nOldCuts; i<nRowCuts; i++){
OsiRowCut rcut;
CoinPackedVector rpv;
rcut = osicuts.rowCut(i);
rpv = rcut.row();
const int n = rpv.getNumElements();
const int * indices = rpv.getIndices();
double* elements = rpv.getElements();
double sum2=0.0;
int k=0;
for (k=0; k<n; k++){
int column=indices[k];
sum2 += colsol[column]*elements[k];
}
double ub=rcut.ub();
#ifdef CGL_DEBUG
double lb=rcut.lb();
if (sum2 >ub + 1.0e-7 ||sum2 < lb - 1.0e-7) {
std::cout<<"Cut "<<i<<" lb "<<lb<<" solution "<<sum2<<" ub "<<ub<<std::endl;
for (k=0; k<n; k++){
int column=indices[k];
std::cout<<"(col="<<column<<",el="<<elements[k]<<",sol="<<
colsol[column]<<") ";
}
std::cout <<std::endl;
}
#endif
if (i-nOldCuts==testCut) {
assert( eq(rhs,ub));
assert(n==1);
for (k=0; k<n; k++){
int column=indices[k];
assert (eq(cut[column],elements[k]));
}
// add cut
rowLower[3]=-1.0e100;
rowUpper[3]=ub;
matrix.appendRow(rpv);
}
}
nOldCuts=nRowCuts;
// basis 2
int rowBasis2[4]={1,1,-1,-1};
int colBasis2[2]={1,1};
warm.setSize(2,4);
for (i=0;i<4;i++) {
if (rowBasis2[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<2;i++) {
if (colBasis2[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 2
double colsol2[2]={2.0,0.5};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol2,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts-nOldCuts==1);
// cuts always <=
testCut=0; // test first cut as stronger
rhs=1.0;
double testCut2[2]={1.0,-1.0};
cut = testCut2;
colsol = colsol2;
for (i=nOldCuts; i<nRowCuts; i++){
OsiRowCut rcut;
CoinPackedVector rpv;
rcut = osicuts.rowCut(i);
rpv = rcut.row();
const int n = rpv.getNumElements();
const int * indices = rpv.getIndices();
double* elements = rpv.getElements();
double sum2=0.0;
int k=0;
for (k=0; k<n; k++){
int column=indices[k];
sum2 += colsol[column]*elements[k];
}
double ub=rcut.ub();
#ifdef CGL_DEBUG
double lb=rcut.lb();
if (sum2 >ub + 1.0e-7 ||sum2 < lb - 1.0e-7) {
std::cout<<"Cut "<<i<<" lb "<<lb<<" solution "<<sum2<<" ub "<<ub<<std::endl;
for (k=0; k<n; k++){
int column=indices[k];
std::cout<<"(col="<<column<<",el="<<elements[k]<<",sol="<<
colsol[column]<<") ";
}
std::cout <<std::endl;
}
#endif
if (i-nOldCuts==testCut) {
assert( eq(rhs,ub));
assert(n==2);
for (k=0; k<n; k++){
int column=indices[k];
assert (eq(cut[column],elements[k]));
}
// add cut
rowLower[4]=-1.0e100;
rowUpper[4]=ub;
matrix.appendRow(rpv);
}
}
nOldCuts=nRowCuts;
// basis 3
int rowBasis3[5]={1,1,1,-1,-1};
int colBasis3[2]={1,1};
warm.setSize(2,5);
for (i=0;i<5;i++) {
if (rowBasis3[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<2;i++) {
if (colBasis3[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 3
double colsol3[2]={2.0,1.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol3,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==nOldCuts);
}
// NOW mixed integer gomory cuts
// Test explicit form - (pg 130 Wolsey)
// Some arrays left same size as previously although not used in full
if (1) {
OsiCuts osicuts;
CglGomory test1;
int i;
int nOldCuts=0,nRowCuts;
// matrix data
//deliberate hiccup of 2 between 0 and 1
CoinBigIndex start[5]={0,4,7,8,9};
int length[5]={2,3,1,1,1};
int rows[11]={0,2,-1,-1,0,1,2,0,1,2};
double elements[11]={7.0,2.0,1.0e10,1.0e10,-2.0,1.0,-2.0,1,1,1};
CoinPackedMatrix matrix(true,3,5,8,elements,rows,start,length);
// rim data (objective not used just yet)
double rowLower[5]={14.0,3.0,3.0,1.0e10,1.0e10};
double rowUpper[5]={14.0,3.0,3.0,-1.0e10,-1.0e10};
double colLower[7]={0.0,0.0,0.0,0.0,0.0,0.0,0.0};
double colUpper[7]={100.0,100.0,100.0,100.0,100.0,100.0,100.0};
// integer
char intVar[7]={2,0,0,0,0,0,0};
// basis 1
int rowBasis1[3]={-1,-1,-1};
int colBasis1[5]={1,1,-1,-1,1};
CoinWarmStartBasis warm;
warm.setSize(5,3);
for (i=0;i<3;i++) {
if (rowBasis1[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<5;i++) {
if (colBasis1[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 1
double colsol1[5]={20.0/7.0,3.0,0.0,0.0,23.0/7.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol1,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==1);
// cuts always <=
int testCut=0; // test first cut as stronger
double rhs=-6.0/7.0;
double testCut1[5]={0.0,0.0,-1.0/7.0,-2.0/7.0,0.0};
double * cut = testCut1;
double * colsol = colsol1;
for (i=nOldCuts; i<nRowCuts; i++){
OsiRowCut rcut;
CoinPackedVector rpv;
rcut = osicuts.rowCut(i);
rpv = rcut.row();
const int n = rpv.getNumElements();
const int * indices = rpv.getIndices();
double* elements = rpv.getElements();
double sum2=0.0;
int k=0;
for (k=0; k<n; k++){
int column=indices[k];
sum2 += colsol[column]*elements[k];
}
double ub=rcut.ub();
#ifdef CGL_DEBUG
double lb=rcut.lb();
if (sum2 >ub + 1.0e-7 ||sum2 < lb - 1.0e-7) {
std::cout<<"Cut "<<i<<" lb "<<lb<<" solution "<<sum2<<" ub "<<ub<<std::endl;
for (k=0; k<n; k++){
int column=indices[k];
std::cout<<"(col="<<column<<",el="<<elements[k]<<",sol="<<
colsol[column]<<") ";
}
std::cout <<std::endl;
}
#endif
if (i-nOldCuts==testCut) {
assert( eq(rhs,ub));
assert(n==2);
for (k=0; k<n; k++){
int column=indices[k];
assert (eq(cut[column],elements[k]));
}
// add cut
// explicit slack
matrix.setDimensions(-1,6);
rpv.insert(5,1.0); // to get cut in book
rowLower[3]=ub;
rowUpper[3]=ub;
matrix.appendRow(rpv);
}
}
nOldCuts=nRowCuts;
// basis 2
int rowBasis2[4]={-1,-1,-1,-1};
int colBasis2[6]={1,1,1,1,-1,-1};
warm.setSize(6,4);
for (i=0;i<4;i++) {
if (rowBasis2[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<6;i++) {
if (colBasis2[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 2
double colsol2[6]={2.0,0.5,1.0,2.5,0.0,0.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol2,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==nOldCuts);
}
// Test explicit form - this time with x4 flipped
if (1) {
OsiCuts osicuts;
CglGomory test1;
int i;
int nOldCuts=0,nRowCuts;
// matrix data
//deliberate hiccup of 2 between 0 and 1
CoinBigIndex start[5]={0,4,7,8,9};
int length[5]={2,3,1,1,1};
int rows[11]={0,2,-1,-1,0,1,2,0,1,2};
double elements[11]={7.0,2.0,1.0e10,1.0e10,-2.0,1.0,-2.0,1,-1,1};
CoinPackedMatrix matrix(true,3,5,8,elements,rows,start,length);
// rim data (objective not used just yet)
double rowLower[5]={14.0,-5.0,3.0,1.0e10,1.0e10};
double rowUpper[5]={14.0,-5.0,3.0,-1.0e10,-1.0e10};
double colLower[7]={0.0,0.0,0.0,0.0,0.0,0.0,0.0};
double colUpper[7]={100.0,100.0,100.0,8.0,100.0,100.0,100.0};
// integer
char intVar[7]={2,0,0,0,0,0,0};
// basis 1
int rowBasis1[3]={-1,-1,-1};
int colBasis1[5]={1,1,-1,-1,1};
CoinWarmStartBasis warm;
warm.setSize(5,3);
for (i=0;i<3;i++) {
if (rowBasis1[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<5;i++) {
if (colBasis1[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 1
double colsol1[5]={20.0/7.0,3.0,0.0,8.0,23.0/7.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol1,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==1);
// cuts always <=
int testCut=0;
double rhs=10.0/7.0;
double testCut1[5]={0.0,0.0,-1.0/7.0,2.0/7.0,0.0};
double * cut = testCut1;
double * colsol = colsol1;
for (i=nOldCuts; i<nRowCuts; i++){
OsiRowCut rcut;
CoinPackedVector rpv;
rcut = osicuts.rowCut(i);
rpv = rcut.row();
const int n = rpv.getNumElements();
const int * indices = rpv.getIndices();
double* elements = rpv.getElements();
double sum2=0.0;
int k=0;
for (k=0; k<n; k++){
int column=indices[k];
sum2 += colsol[column]*elements[k];
}
double ub=rcut.ub();
#ifdef CGL_DEBUG
double lb=rcut.lb();
if (sum2 >ub + 1.0e-7 ||sum2 < lb - 1.0e-7) {
std::cout<<"Cut "<<i<<" lb "<<lb<<" solution "<<sum2<<" ub "<<ub<<std::endl;
for (k=0; k<n; k++){
int column=indices[k];
std::cout<<"(col="<<column<<",el="<<elements[k]<<",sol="<<
colsol[column]<<") ";
}
std::cout <<std::endl;
}
#endif
if (i-nOldCuts==testCut) {
assert( eq(rhs,ub));
assert(n==2);
for (k=0; k<n; k++){
int column=indices[k];
assert (eq(cut[column],elements[k]));
}
// add cut
// explicit slack
matrix.setDimensions(-1,6);
rpv.insert(5,1.0); // to get cut in book
rowLower[3]=ub;
rowUpper[3]=ub;
matrix.appendRow(rpv);
}
}
nOldCuts=nRowCuts;
// basis 2
int rowBasis2[4]={-1,-1,-1,-1};
int colBasis2[6]={1,1,1,1,-1,-1};
warm.setSize(6,4);
for (i=0;i<4;i++) {
if (rowBasis2[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<6;i++) {
if (colBasis2[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 2
double colsol2[6]={2.0,0.5,1.0,5.5,0.0,0.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol2,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==nOldCuts);
}
// Test with slacks
if (1) {
OsiCuts osicuts;
CglGomory test1;
int i;
int nOldCuts=0,nRowCuts;
// matrix data
//deliberate hiccup of 2 between 0 and 1
CoinBigIndex start[5]={0,4};
int length[5]={2,3};
int rows[11]={0,2,-1,-1,0,1,2};
double elements[11]={7.0,2.0,1.0e10,1.0e10,-2.0,1.0,-2.0};
CoinPackedMatrix matrix(true,3,2,5,elements,rows,start,length);
// rim data (objective not used just yet)
double rowLower[5]={-1.0e10,-1.0e10,-1.0e10,1.0e10,1.0e10};
double rowUpper[5]={14.0,3.0,3.0,-1.0e10,-1.0e10};
double colLower[2]={0.0,0.0};
double colUpper[2]={100.0,100.0};
// integer
char intVar[2]={2,0};
// basis 1
int rowBasis1[3]={-1,-1,1};
int colBasis1[2]={1,1};
CoinWarmStartBasis warm;
warm.setSize(2,3);
for (i=0;i<3;i++) {
if (rowBasis1[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<2;i++) {
if (colBasis1[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 1
double colsol1[2]={20.0/7.0,3.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol1,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==1);
// cuts always <=
int testCut=0; // test first cut as stronger
double rhs=2.0;
double testCut1[2]={1.0,0.0};
double * cut = testCut1;
double * colsol = colsol1;
for (i=nOldCuts; i<nRowCuts; i++){
OsiRowCut rcut;
CoinPackedVector rpv;
rcut = osicuts.rowCut(i);
rpv = rcut.row();
const int n = rpv.getNumElements();
const int * indices = rpv.getIndices();
double* elements = rpv.getElements();
double sum2=0.0;
int k=0;
for (k=0; k<n; k++){
int column=indices[k];
sum2 += colsol[column]*elements[k];
}
double ub=rcut.ub();
#ifdef CGL_DEBUG
double lb=rcut.lb();
if (sum2 >ub + 1.0e-7 ||sum2 < lb - 1.0e-7) {
std::cout<<"Cut "<<i<<" lb "<<lb<<" solution "<<sum2<<" ub "<<ub<<std::endl;
for (k=0; k<n; k++){
int column=indices[k];
std::cout<<"(col="<<column<<",el="<<elements[k]<<",sol="<<
colsol[column]<<") ";
}
std::cout <<std::endl;
}
#endif
if (i-nOldCuts==testCut) {
assert( eq(rhs,ub));
assert(n==1);
for (k=0; k<n; k++){
int column=indices[k];
assert (eq(cut[column],elements[k]));
}
// add cut
rowLower[3]=-1.0e100;
rowUpper[3]=ub;
matrix.appendRow(rpv);
}
}
nOldCuts=nRowCuts;
// basis 2
int rowBasis2[4]={1,1,-1,-1};
int colBasis2[2]={1,1};
warm.setSize(2,4);
for (i=0;i<4;i++) {
if (rowBasis2[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<2;i++) {
if (colBasis2[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 2
double colsol2[2]={2.0,0.5};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol2,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==nOldCuts);
}
// swap some rows to G
if (1) {
OsiCuts osicuts;
CglGomory test1;
int i;
int nOldCuts=0,nRowCuts;
// matrix data
//deliberate hiccup of 2 between 0 and 1
CoinBigIndex start[5]={0,4};
int length[5]={2,3};
int rows[11]={0,2,-1,-1,0,1,2};
double elements[11]={-7.0,-2.0,1.0e10,1.0e10,+2.0,1.0,+2.0};
CoinPackedMatrix matrix(true,3,2,5,elements,rows,start,length);
// rim data (objective not used just yet)
double rowUpper[5]={1.0e10,3.0,1.0e10,-1.0e10,-1.0e10};
double rowLower[5]={-14.0,-1.0e10,-3.0,1.0e10,1.0e10};
double colLower[2]={0.0,0.0};
double colUpper[2]={100.0,100.0};
// integer
char intVar[2]={2,0};
// basis 1
int rowBasis1[3]={-1,-1,1};
int colBasis1[2]={1,1};
CoinWarmStartBasis warm;
warm.setSize(2,3);
for (i=0;i<3;i++) {
if (rowBasis1[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<2;i++) {
if (colBasis1[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 1
double colsol1[2]={20.0/7.0,3.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol1,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==1);
// cuts always <=
int testCut=0; // test first cut as stronger
double rhs=2.0;
double testCut1[2]={1.0,0.0};
double * cut = testCut1;
double * colsol = colsol1;
for (i=nOldCuts; i<nRowCuts; i++){
OsiRowCut rcut;
CoinPackedVector rpv;
rcut = osicuts.rowCut(i);
rpv = rcut.row();
const int n = rpv.getNumElements();
const int * indices = rpv.getIndices();
double* elements = rpv.getElements();
double sum2=0.0;
int k=0;
for (k=0; k<n; k++){
int column=indices[k];
sum2 += colsol[column]*elements[k];
}
double ub=rcut.ub();
#ifdef CGL_DEBUG
double lb=rcut.lb();
if (sum2 >ub + 1.0e-7 ||sum2 < lb - 1.0e-7) {
std::cout<<"Cut "<<i<<" lb "<<lb<<" solution "<<sum2<<" ub "<<ub<<std::endl;
for (k=0; k<n; k++){
int column=indices[k];
std::cout<<"(col="<<column<<",el="<<elements[k]<<",sol="<<
colsol[column]<<") ";
}
std::cout <<std::endl;
}
#endif
if (i-nOldCuts==testCut) {
assert( eq(rhs,ub));
assert(n==1);
for (k=0; k<n; k++){
int column=indices[k];
assert (eq(cut[column],elements[k]));
}
// add cut
rowLower[3]=-1.0e100;
rowUpper[3]=ub;
matrix.appendRow(rpv);
}
}
nOldCuts=nRowCuts;
// basis 2
int rowBasis2[4]={1,1,-1,-1};
int colBasis2[2]={1,1};
warm.setSize(2,4);
for (i=0;i<4;i++) {
if (rowBasis2[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<2;i++) {
if (colBasis2[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 2
double colsol2[2]={2.0,0.5};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol2,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==nOldCuts);
}
// Miplib3 problem p0033
if (1) {
// Setup
OsiSolverInterface * siP = baseSiP->clone();
std::string fn(mpsDir+"p0033");
siP->readMps(fn.c_str(),"mps");
siP->activateRowCutDebugger("p0033");
CglGomory test;
// Solve the LP relaxation of the model and
// print out ofv for sake of comparison
siP->initialSolve();
double lpRelaxBefore=siP->getObjValue();
std::cout<<"Initial LP value: "<<lpRelaxBefore<<std::endl;
assert( eq(lpRelaxBefore, 2520.5717391304347) );
// Fails with OsiCpx, OsiXpr:
/**********
double mycs[] = {0, 1, 0, 0, -2.0837010502455788e-19, 1, 0, 0, 1,
0.021739130434782594, 0.35652173913043478,
-6.7220534694101275e-18, 5.3125906451789717e-18,
1, 0, 1.9298798670241979e-17, 0, 0, 0,
7.8875708048320448e-18, 0.5, 0,
0.85999999999999999, 1, 1, 0.57999999999999996,
1, 0, 1, 0, 0.25, 0, 0.67500000000000004};
siP->setColSolution(mycs);
****/
OsiCuts cuts;
// Test generateCuts method
test.generateCuts(*siP,cuts);
int nRowCuts = cuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" Gomory cuts"<<std::endl;
assert(cuts.sizeRowCuts() > 0);
OsiSolverInterface::ApplyCutsReturnCode rc = siP->applyCuts(cuts);
siP->resolve();
double lpRelaxAfter=siP->getObjValue();
std::cout<<"LP value with cuts: "<<lpRelaxAfter<<std::endl;
//assert( eq(lpRelaxAfter, 2592.1908295194507) );
assert( lpRelaxAfter> 2550.0 );
assert( lpRelaxBefore < lpRelaxAfter );
assert(lpRelaxAfter < 3089.1);
delete siP;
}
}
void OsiIF::_loadBasis(
Array<LPVARSTAT::STATUS> &lpVarStat,
Array<SlackStat::STATUS> &slackStat)
{
int lps = lpVarStat.size();
int sls = slackStat.size();
CoinWarmStartBasis *ws = nullptr;
ws = new CoinWarmStartBasis();
ws->setSize(numCols_, numRows_);
if (osiLP_->getNumCols() > lps) {
Logger::ifout() << "OsiIF::_loadBasis: mismatch in number of columns: OSI " << osiLP_->getNumCols() << ", Abacus: " << lps << "\n";
OGDF_THROW_PARAM(AlgorithmFailureException, ogdf::afcOsiIf);
}
for (int i = 0; i < numCols_; i++)
ws->setStructStatus(i, lpVarStat2osi(lpVarStat[i]));
if (osiLP_->getNumRows() > sls) {
Logger::ifout() << "OsiIF::_loadBasis: mismatch in number of rows: OSI " << osiLP_->getNumCols() << ", Abacus: " << sls << "\n";
OGDF_THROW_PARAM(AlgorithmFailureException, ogdf::afcOsiIf);
}
for (int i = 0; i < numRows_; i++)
ws->setArtifStatus(i, slackStat2osi(slackStat[i]));
lpSolverTime_.start();
slackStatus_ = basisStatus_ = Missing;
int status = 0;
// FIXME loadBasis
// better test whether the number of basic structurals is correct?
if (ws->numberBasicStructurals() > 0) {
status = osiLP_->setWarmStart(dynamic_cast<CoinWarmStart *> (ws));
if (ws_ != nullptr) delete ws_;
ws_ = dynamic_cast<CoinWarmStartBasis*> (osiLP_->getWarmStart());
if (ws_ != nullptr) {
delete[] cStat_;
int nStructBytes = (int) ceil( ws_->getNumStructural() / 4.0);
cStat_ = new char[nStructBytes];
for(int i = 0; i < nStructBytes; i++) {
cStat_[i] = ws_->getStructuralStatus()[i];
}
delete[] rStat_;
int nArtBytes = (int) ceil( ws_->getNumArtificial() / 4.0 );
rStat_ = new char[nArtBytes];
for(int i = 0; i < nArtBytes; i++) {
rStat_[i] = ws_->getArtificialStatus()[i];
}
basisStatus_ = Available;
} else
basisStatus_ = Missing;
} else
status = 2;
lpSolverTime_.stop();
delete ws;
if (status == 0) {
Logger::ifout()
<< "OsiIF::_loadBasis(): loading the new basis has failed. Status "
<< status << endl;
// FIXME loadBasis
return;
} else
return;
}
