//--------------------------------------------------------------------------
// 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);
}
}
void OsiSpxSolverInterfaceUnitTest( const std::string & mpsDir, const std::string & netlibDir )
{
// Test default constructor
{
OsiSpxSolverInterface m;
OSIUNITTEST_ASSERT_ERROR(m.soplex_ != NULL, {}, "SoPlex", "default constructor");
OSIUNITTEST_ASSERT_ERROR(m.getNumCols() == 0, {}, "SoPlex", "default constructor");
OSIUNITTEST_ASSERT_ERROR(m.rowsense_ == NULL, {}, "SoPlex", "default constructor");
OSIUNITTEST_ASSERT_ERROR(m.rhs_ == NULL, {}, "SoPlex", "default constructor");
OSIUNITTEST_ASSERT_ERROR(m.rowrange_ == NULL, {}, "SoPlex", "default constructor");
OSIUNITTEST_ASSERT_ERROR(m.colsol_ == NULL, {}, "SoPlex", "default constructor");
OSIUNITTEST_ASSERT_ERROR(m.rowsol_ == NULL, {}, "SoPlex", "default constructor");
OSIUNITTEST_ASSERT_ERROR(m.matrixByRow_ == NULL, {}, "SoPlex", "default constructor");
OSIUNITTEST_ASSERT_ERROR(m.matrixByCol_ == NULL, {}, "SoPlex", "default constructor");
OSIUNITTEST_ASSERT_ERROR(m.getApplicationData() == NULL, {}, "SoPlex", "default constructor");
int i=2346;
m.setApplicationData(&i);
OSIUNITTEST_ASSERT_ERROR(*((int *)(m.getApplicationData())) == i, {}, "SoPlex", "set application data");
}
{
CoinRelFltEq eq;
OsiSpxSolverInterface m;
std::string fn = mpsDir+"exmip1";
m.readMps(fn.c_str(),"mps");
// int ad = 13579;
// m.setApplicationData(&ad);
// OSIUNITTEST_ASSERT_ERROR(*((int *)(m.getApplicationData())) == ad, {}, "SoPlex", "set application data");
{
const CoinPackedMatrix * colCopy = m.getMatrixByCol();
OSIUNITTEST_ASSERT_ERROR(colCopy->getNumCols() == 8, {}, "SoPlex", "exmip1 matrix");
OSIUNITTEST_ASSERT_ERROR(colCopy->getMajorDim() == 8, {}, "SoPlex", "exmip1 matrix");
OSIUNITTEST_ASSERT_ERROR(colCopy->getNumRows() == 5, {}, "SoPlex", "exmip1 matrix");
OSIUNITTEST_ASSERT_ERROR(colCopy->getMinorDim() == 5, {}, "SoPlex", "exmip1 matrix");
OSIUNITTEST_ASSERT_ERROR(colCopy->getVectorLengths()[7] == 2, {}, "SoPlex", "exmip1 matrix");
CoinPackedMatrix revColCopy;
revColCopy.reverseOrderedCopyOf(*colCopy);
CoinPackedMatrix rev2ColCopy;
rev2ColCopy.reverseOrderedCopyOf(revColCopy);
OSIUNITTEST_ASSERT_ERROR(rev2ColCopy.getNumCols() == 8, {}, "SoPlex", "twice reverse matrix copy");
OSIUNITTEST_ASSERT_ERROR(rev2ColCopy.getMajorDim() == 8, {}, "SoPlex", "twice reverse matrix copy");
OSIUNITTEST_ASSERT_ERROR(rev2ColCopy.getNumRows() == 5, {}, "SoPlex", "twice reverse matrix copy");
OSIUNITTEST_ASSERT_ERROR(rev2ColCopy.getMinorDim() == 5, {}, "SoPlex", "twice reverse matrix copy");
OSIUNITTEST_ASSERT_ERROR(rev2ColCopy.getVectorLengths()[7] == 2, {}, "SoPlex", "twice reverse matrix copy");
}
// Test copy constructor and assignment operator
{
OsiSpxSolverInterface lhs;
{
OsiSpxSolverInterface im(m);
OsiSpxSolverInterface imC1(im);
OsiSpxSolverInterface imC2(im);
lhs = imC2;
}
// Test that lhs has correct values even though rhs has gone out of scope
OSIUNITTEST_ASSERT_ERROR(lhs.getNumCols() == m.getNumCols(), {}, "SoPlex", "copy constructor");
OSIUNITTEST_ASSERT_ERROR(lhs.getNumRows() == m.getNumRows(), {}, "SoPlex", "copy constructor");
}
// Test clone
{
OsiSpxSolverInterface soplexSi(m);
OsiSolverInterface * siPtr = &soplexSi;
OsiSolverInterface * siClone = siPtr->clone();
OsiSpxSolverInterface * soplexClone = dynamic_cast<OsiSpxSolverInterface*>(siClone);
OSIUNITTEST_ASSERT_ERROR(soplexClone != NULL, {}, "SoPlex", "clone");
OSIUNITTEST_ASSERT_ERROR(soplexClone->getNumRows() == soplexSi.getNumRows(), {}, "SoPlex", "clone");
OSIUNITTEST_ASSERT_ERROR(soplexClone->getNumCols() == m.getNumCols(), {}, "SoPlex", "clone");
delete siClone;
}
// test infinity
{
OsiSpxSolverInterface si;
OSIUNITTEST_ASSERT_ERROR(si.getInfinity() == soplex::infinity, {}, "SoPlex", "value for infinity");
}
{
OsiSpxSolverInterface soplexSi(m);
int nc = soplexSi.getNumCols();
int nr = soplexSi.getNumRows();
const double * cl = soplexSi.getColLower();
const double * cu = soplexSi.getColUpper();
const double * rl = soplexSi.getRowLower();
const double * ru = soplexSi.getRowUpper();
OSIUNITTEST_ASSERT_ERROR(nc == 8, return, "SoPlex", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(nr == 5, return, "SoPlex", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(cl[0],2.5), {}, "SoPlex", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(cl[1],0.0), {}, "SoPlex", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(cu[1],4.1), {}, "SoPlex", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(cu[2],1.0), {}, "SoPlex", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(rl[0],2.5), {}, "SoPlex", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(rl[4],3.0), {}, "SoPlex", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(ru[1],2.1), {}, "SoPlex", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(ru[4],15.), {}, "SoPlex", "read and copy exmip1");
double newCs[8] = {1., 2., 3., 4., 5., 6., 7., 8.};
soplexSi.setColSolution(newCs);
const double * cs = soplexSi.getColSolution();
OSIUNITTEST_ASSERT_ERROR(eq(cs[0],1.0), {}, "SoPlex", "set col solution");
OSIUNITTEST_ASSERT_ERROR(eq(cs[7],8.0), {}, "SoPlex", "set col solution");
{
OsiSpxSolverInterface solnSi(soplexSi);
const double * cs = solnSi.getColSolution();
OSIUNITTEST_ASSERT_ERROR(eq(cs[0],1.0), {}, "SoPlex", "set col solution and copy");
OSIUNITTEST_ASSERT_ERROR(eq(cs[7],8.0), {}, "SoPlex", "set col solution and copy");
}
OSIUNITTEST_ASSERT_ERROR(!eq(cl[3],1.2345), {}, "SoPlex", "set col lower");
soplexSi.setColLower( 3, 1.2345 );
OSIUNITTEST_ASSERT_ERROR( eq(cl[3],1.2345), {}, "SoPlex", "set col lower");
OSIUNITTEST_ASSERT_ERROR(!eq(cu[4],10.2345), {}, "SoPlex", "set col upper");
soplexSi.setColUpper( 4, 10.2345 );
OSIUNITTEST_ASSERT_ERROR( eq(cu[4],10.2345), {}, "SoPlex", "set col upper");
OSIUNITTEST_ASSERT_ERROR(eq(soplexSi.getObjCoefficients()[0], 1.0), {}, "SoPlex", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(soplexSi.getObjCoefficients()[1], 0.0), {}, "SoPlex", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(soplexSi.getObjCoefficients()[2], 0.0), {}, "SoPlex", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(soplexSi.getObjCoefficients()[3], 0.0), {}, "SoPlex", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(soplexSi.getObjCoefficients()[4], 2.0), {}, "SoPlex", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(soplexSi.getObjCoefficients()[5], 0.0), {}, "SoPlex", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(soplexSi.getObjCoefficients()[6], 0.0), {}, "SoPlex", "read and copy exmip1");
OSIUNITTEST_ASSERT_ERROR(eq(soplexSi.getObjCoefficients()[7],-1.0), {}, "SoPlex", "read and copy exmip1");
}
// Test getMatrixByRow method
{
const OsiSpxSolverInterface si(m);
const CoinPackedMatrix * smP = si.getMatrixByRow();
OSIUNITTEST_ASSERT_ERROR(smP->getMajorDim() == 5, return, "SoPlex", "getMatrixByRow: major dim");
OSIUNITTEST_ASSERT_ERROR(smP->getNumElements() == 14, return, "SoPlex", "getMatrixByRow: num elements");
CoinRelFltEq eq;
const double * ev = smP->getElements();
OSIUNITTEST_ASSERT_ERROR(eq(ev[0], 3.0), {}, "SoPlex", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[1], 1.0), {}, "SoPlex", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[2], -2.0), {}, "SoPlex", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[3], -1.0), {}, "SoPlex", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[4], -1.0), {}, "SoPlex", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[5], 2.0), {}, "SoPlex", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[6], 1.1), {}, "SoPlex", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[7], 1.0), {}, "SoPlex", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[8], 1.0), {}, "SoPlex", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[9], 2.8), {}, "SoPlex", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[10], -1.2), {}, "SoPlex", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[11], 5.6), {}, "SoPlex", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[12], 1.0), {}, "SoPlex", "getMatrixByRow: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[13], 1.9), {}, "SoPlex", "getMatrixByRow: elements");
const int * mi = smP->getVectorStarts();
OSIUNITTEST_ASSERT_ERROR(mi[0] == 0, {}, "SoPlex", "getMatrixByRow: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[1] == 5, {}, "SoPlex", "getMatrixByRow: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[2] == 7, {}, "SoPlex", "getMatrixByRow: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[3] == 9, {}, "SoPlex", "getMatrixByRow: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[4] == 11, {}, "SoPlex", "getMatrixByRow: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[5] == 14, {}, "SoPlex", "getMatrixByRow: vector starts");
const int * ei = smP->getIndices();
OSIUNITTEST_ASSERT_ERROR(ei[ 0] == 0, {}, "SoPlex", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 1] == 1, {}, "SoPlex", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 2] == 3, {}, "SoPlex", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 3] == 4, {}, "SoPlex", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 4] == 7, {}, "SoPlex", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 5] == 1, {}, "SoPlex", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 6] == 2, {}, "SoPlex", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 7] == 2, {}, "SoPlex", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 8] == 5, {}, "SoPlex", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 9] == 3, {}, "SoPlex", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[10] == 6, {}, "SoPlex", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[11] == 0, {}, "SoPlex", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[12] == 4, {}, "SoPlex", "getMatrixByRow: indices");
OSIUNITTEST_ASSERT_ERROR(ei[13] == 7, {}, "SoPlex", "getMatrixByRow: indices");
}
//--------------
// Test rowsense, rhs, rowrange, getMatrixByRow
{
OsiSpxSolverInterface lhs;
{
OsiSpxSolverInterface siC1(m);
OSIUNITTEST_ASSERT_WARNING(siC1.rowrange_ == NULL, {}, "SoPlex", "row range");
OSIUNITTEST_ASSERT_WARNING(siC1.rowsense_ == NULL, {}, "SoPlex", "row sense");
OSIUNITTEST_ASSERT_WARNING(siC1.rhs_ == NULL, {}, "SoPlex", "right hand side");
OSIUNITTEST_ASSERT_WARNING(siC1.matrixByRow_ == NULL, {}, "SoPlex", "matrix by row");
OSIUNITTEST_ASSERT_WARNING(siC1.colsol_ == NULL, {}, "SoPlex", "col solution");
OSIUNITTEST_ASSERT_WARNING(siC1.rowsol_ == NULL, {}, "SoPlex", "row solution");
const char * siC1rs = siC1.getRowSense();
OSIUNITTEST_ASSERT_ERROR(siC1rs[0] == 'G', {}, "SoPlex", "row sense");
OSIUNITTEST_ASSERT_ERROR(siC1rs[1] == 'L', {}, "SoPlex", "row sense");
OSIUNITTEST_ASSERT_ERROR(siC1rs[2] == 'E', {}, "SoPlex", "row sense");
OSIUNITTEST_ASSERT_ERROR(siC1rs[3] == 'R', {}, "SoPlex", "row sense");
OSIUNITTEST_ASSERT_ERROR(siC1rs[4] == 'R', {}, "SoPlex", "row sense");
const double * siC1rhs = siC1.getRightHandSide();
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[0],2.5), {}, "SoPlex", "right hand side");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[1],2.1), {}, "SoPlex", "right hand side");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[2],4.0), {}, "SoPlex", "right hand side");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[3],5.0), {}, "SoPlex", "right hand side");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[4],15.), {}, "SoPlex", "right hand side");
const double * siC1rr = siC1.getRowRange();
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[0],0.0), {}, "SoPlex", "row range");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[1],0.0), {}, "SoPlex", "row range");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[2],0.0), {}, "SoPlex", "row range");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[3],5.0-1.8), {}, "SoPlex", "row range");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[4],15.0-3.0), {}, "SoPlex", "row range");
const CoinPackedMatrix * siC1mbr = siC1.getMatrixByRow();
OSIUNITTEST_ASSERT_ERROR(siC1mbr != NULL, {}, "SoPlex", "matrix by row");
OSIUNITTEST_ASSERT_ERROR(siC1mbr->getMajorDim() == 5, return, "SoPlex", "matrix by row: major dim");
OSIUNITTEST_ASSERT_ERROR(siC1mbr->getNumElements() == 14, return, "SoPlex", "matrix by row: num elements");
const double * ev = siC1mbr->getElements();
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 0], 3.0), {}, "SoPlex", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 1], 1.0), {}, "SoPlex", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 2],-2.0), {}, "SoPlex", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 3],-1.0), {}, "SoPlex", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 4],-1.0), {}, "SoPlex", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 5], 2.0), {}, "SoPlex", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 6], 1.1), {}, "SoPlex", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 7], 1.0), {}, "SoPlex", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 8], 1.0), {}, "SoPlex", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 9], 2.8), {}, "SoPlex", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[10],-1.2), {}, "SoPlex", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[11], 5.6), {}, "SoPlex", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[12], 1.0), {}, "SoPlex", "matrix by row: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[13], 1.9), {}, "SoPlex", "matrix by row: elements");
const CoinBigIndex * mi = siC1mbr->getVectorStarts();
OSIUNITTEST_ASSERT_ERROR(mi[0] == 0, {}, "SoPlex", "matrix by row: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[1] == 5, {}, "SoPlex", "matrix by row: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[2] == 7, {}, "SoPlex", "matrix by row: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[3] == 9, {}, "SoPlex", "matrix by row: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[4] == 11, {}, "SoPlex", "matrix by row: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[5] == 14, {}, "SoPlex", "matrix by row: vector starts");
const int * ei = siC1mbr->getIndices();
OSIUNITTEST_ASSERT_ERROR(ei[ 0] == 0, {}, "SoPlex", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 1] == 1, {}, "SoPlex", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 2] == 3, {}, "SoPlex", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 3] == 4, {}, "SoPlex", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 4] == 7, {}, "SoPlex", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 5] == 1, {}, "SoPlex", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 6] == 2, {}, "SoPlex", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 7] == 2, {}, "SoPlex", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 8] == 5, {}, "SoPlex", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 9] == 3, {}, "SoPlex", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[10] == 6, {}, "SoPlex", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[11] == 0, {}, "SoPlex", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[12] == 4, {}, "SoPlex", "matrix by row: indices");
OSIUNITTEST_ASSERT_ERROR(ei[13] == 7, {}, "SoPlex", "matrix by row: indices");
OSIUNITTEST_ASSERT_WARNING(siC1rs == siC1.getRowSense(), {}, "SoPlex", "row sense");
OSIUNITTEST_ASSERT_WARNING(siC1rhs == siC1.getRightHandSide(), {}, "SoPlex", "right hand side");
OSIUNITTEST_ASSERT_WARNING(siC1rr == siC1.getRowRange(), {}, "SoPlex", "row range");
// Change SOPLEX 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, {}, "SoPlex", "free cached data after adding row");
OSIUNITTEST_ASSERT_ERROR(siC1.rowsense_ == NULL, {}, "SoPlex", "free cached data after adding row");
OSIUNITTEST_ASSERT_ERROR(siC1.rhs_ == NULL, {}, "SoPlex", "free cached data after adding row");
OSIUNITTEST_ASSERT_ERROR(siC1.matrixByRow_ == NULL, {}, "SoPlex", "free cached data after adding row");
OSIUNITTEST_ASSERT_ERROR(siC1.matrixByCol_ == NULL, {}, "SoPlex", "free cached data after adding row");
OSIUNITTEST_ASSERT_ERROR(siC1.colsol_ == NULL, {}, "SoPlex", "free cached data after adding row");
OSIUNITTEST_ASSERT_ERROR(siC1.rowsol_ == NULL, {}, "SoPlex", "free cached data after adding row");
siC1rs = siC1.getRowSense();
OSIUNITTEST_ASSERT_ERROR(siC1rs[0] == 'G', {}, "SoPlex", "row sense after adding row");
OSIUNITTEST_ASSERT_ERROR(siC1rs[1] == 'L', {}, "SoPlex", "row sense after adding row");
OSIUNITTEST_ASSERT_ERROR(siC1rs[2] == 'E', {}, "SoPlex", "row sense after adding row");
OSIUNITTEST_ASSERT_ERROR(siC1rs[3] == 'R', {}, "SoPlex", "row sense after adding row");
OSIUNITTEST_ASSERT_ERROR(siC1rs[4] == 'R', {}, "SoPlex", "row sense after adding row");
OSIUNITTEST_ASSERT_ERROR(siC1rs[5] == 'N', {}, "SoPlex", "row sense after adding row");
siC1rhs = siC1.getRightHandSide();
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[0],2.5), {}, "SoPlex", "right hand side after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[1],2.1), {}, "SoPlex", "right hand side after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[2],4.0), {}, "SoPlex", "right hand side after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[3],5.0), {}, "SoPlex", "right hand side after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[4],15.), {}, "SoPlex", "right hand side after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rhs[5],0.0), {}, "SoPlex", "right hand side after adding row");
siC1rr = siC1.getRowRange();
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[0],0.0), {}, "SoPlex", "row range after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[1],0.0), {}, "SoPlex", "row range after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[2],0.0), {}, "SoPlex", "row range after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[3],5.0-1.8), {}, "SoPlex", "row range after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[4],15.0-3.0), {}, "SoPlex", "row range after adding row");
OSIUNITTEST_ASSERT_ERROR(eq(siC1rr[5],0.0), {}, "SoPlex", "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, {}, "SoPlex", "freed origin after assignment");
OSIUNITTEST_ASSERT_ERROR(lhs.rowsense_ == NULL, {}, "SoPlex", "freed origin after assignment");
OSIUNITTEST_ASSERT_ERROR(lhs.rhs_ == NULL, {}, "SoPlex", "freed origin after assignment");
OSIUNITTEST_ASSERT_ERROR(lhs.matrixByRow_ == NULL, {}, "SoPlex", "freed origin after assignment");
OSIUNITTEST_ASSERT_ERROR(lhs.matrixByCol_ == NULL, {}, "SoPlex", "freed origin after assignment");
OSIUNITTEST_ASSERT_ERROR(lhs.colsol_ == NULL, {}, "SoPlex", "freed origin after assignment");
OSIUNITTEST_ASSERT_ERROR(lhs.rowsol_ == NULL, {}, "SoPlex", "freed origin after assignment");
const char * lhsrs = lhs.getRowSense();
OSIUNITTEST_ASSERT_ERROR(lhsrs[0] == 'G', {}, "SoPlex", "row sense after assignment");
OSIUNITTEST_ASSERT_ERROR(lhsrs[1] == 'L', {}, "SoPlex", "row sense after assignment");
OSIUNITTEST_ASSERT_ERROR(lhsrs[2] == 'E', {}, "SoPlex", "row sense after assignment");
OSIUNITTEST_ASSERT_ERROR(lhsrs[3] == 'R', {}, "SoPlex", "row sense after assignment");
OSIUNITTEST_ASSERT_ERROR(lhsrs[4] == 'R', {}, "SoPlex", "row sense after assignment");
OSIUNITTEST_ASSERT_ERROR(lhsrs[5] == 'N', {}, "SoPlex", "row sense after assignment");
const double * lhsrhs = lhs.getRightHandSide();
OSIUNITTEST_ASSERT_ERROR(eq(lhsrhs[0],2.5), {}, "SoPlex", "right hand side after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrhs[1],2.1), {}, "SoPlex", "right hand side after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrhs[2],4.0), {}, "SoPlex", "right hand side after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrhs[3],5.0), {}, "SoPlex", "right hand side after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrhs[4],15.), {}, "SoPlex", "right hand side after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrhs[5],0.0), {}, "SoPlex", "right hand side after assignment");
const double *lhsrr = lhs.getRowRange();
OSIUNITTEST_ASSERT_ERROR(eq(lhsrr[0],0.0), {}, "SoPlex", "row range after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrr[1],0.0), {}, "SoPlex", "row range after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrr[2],0.0), {}, "SoPlex", "row range after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrr[3],5.0-1.8), {}, "SoPlex", "row range after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrr[4],15.0-3.0), {}, "SoPlex", "row range after assignment");
OSIUNITTEST_ASSERT_ERROR(eq(lhsrr[5],0.0), {}, "SoPlex", "row range after assignment");
const CoinPackedMatrix * lhsmbr = lhs.getMatrixByRow();
OSIUNITTEST_ASSERT_ERROR(lhsmbr != NULL, {}, "SoPlex", "matrix by row after assignment");
OSIUNITTEST_ASSERT_ERROR(lhsmbr->getMajorDim() == 6, return, "SoPlex", "matrix by row after assignment: major dim");
OSIUNITTEST_ASSERT_ERROR(lhsmbr->getNumElements() == 14, return, "SoPlex", "matrix by row after assignment: num elements");
const double * ev = lhsmbr->getElements();
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 0], 3.0), {}, "SoPlex", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 1], 1.0), {}, "SoPlex", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 2],-2.0), {}, "SoPlex", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 3],-1.0), {}, "SoPlex", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 4],-1.0), {}, "SoPlex", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 5], 2.0), {}, "SoPlex", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 6], 1.1), {}, "SoPlex", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 7], 1.0), {}, "SoPlex", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 8], 1.0), {}, "SoPlex", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[ 9], 2.8), {}, "SoPlex", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[10],-1.2), {}, "SoPlex", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[11], 5.6), {}, "SoPlex", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[12], 1.0), {}, "SoPlex", "matrix by row after assignment: elements");
OSIUNITTEST_ASSERT_ERROR(eq(ev[13], 1.9), {}, "SoPlex", "matrix by row after assignment: elements");
const CoinBigIndex * mi = lhsmbr->getVectorStarts();
OSIUNITTEST_ASSERT_ERROR(mi[0] == 0, {}, "SoPlex", "matrix by row after assignment: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[1] == 5, {}, "SoPlex", "matrix by row after assignment: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[2] == 7, {}, "SoPlex", "matrix by row after assignment: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[3] == 9, {}, "SoPlex", "matrix by row after assignment: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[4] == 11, {}, "SoPlex", "matrix by row after assignment: vector starts");
OSIUNITTEST_ASSERT_ERROR(mi[5] == 14, {}, "SoPlex", "matrix by row after assignment: vector starts");
const int * ei = lhsmbr->getIndices();
OSIUNITTEST_ASSERT_ERROR(ei[ 0] == 0, {}, "SoPlex", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 1] == 1, {}, "SoPlex", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 2] == 3, {}, "SoPlex", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 3] == 4, {}, "SoPlex", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 4] == 7, {}, "SoPlex", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 5] == 1, {}, "SoPlex", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 6] == 2, {}, "SoPlex", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 7] == 2, {}, "SoPlex", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 8] == 5, {}, "SoPlex", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[ 9] == 3, {}, "SoPlex", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[10] == 6, {}, "SoPlex", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[11] == 0, {}, "SoPlex", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[12] == 4, {}, "SoPlex", "matrix by row after assignment: indices");
OSIUNITTEST_ASSERT_ERROR(ei[13] == 7, {}, "SoPlex", "matrix by row after assignment: indices");
}
//--------------
}
// Do common solverInterface testing by calling the
// base class testing method.
{
OsiSpxSolverInterface m;
OsiSolverInterfaceCommonUnitTest(&m, mpsDir,netlibDir);
}
}
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);
}
}
//--------------------------------------------------------------------------
// test import methods
void
CoinLpIOUnitTest(const std::string& lpDir)
{
// Test default constructor
{
CoinLpIO m;
assert( m.rowsense_ == NULL );
assert( m.rhs_ == NULL );
assert( m.rowrange_ == NULL );
assert( m.matrixByRow_ == NULL );
assert( m.matrixByColumn_ == NULL );
assert( m.integerType_ == NULL);
assert( m.fileName_ == NULL );
assert( !strcmp( m.problemName_ , ""));
assert( m.objName_ == NULL);
}
{
CoinRelFltEq eq;
CoinLpIO m;
std::string fn = lpDir + "exmip1.lp";
m.readLp(fn.c_str());
assert( !strcmp( m.problemName_ , ""));
assert( !strcmp( m.objName_ , "OBJ"));
// Test language and re-use
m.newLanguage(CoinMessages::it);
m.messageHandler()->setPrefix(false);
m.readLp(fn.c_str());
// Test copy constructor and assignment operator
{
CoinLpIO lhs;
{
CoinLpIO im(m);
CoinLpIO imC1(im);
assert( imC1.getNumCols() == im.getNumCols() );
assert( imC1.getNumRows() == im.getNumRows() );
for (int i = 0; i < im.numberHash_[0]; i++) {
// check the row name
assert(!strcmp(im.names_[0][i], imC1.names_[0][i]));
}
for (int i = 0; i < im.numberHash_[1]; i++) {
// check the column name
assert(!strcmp(im.names_[1][i], imC1.names_[1][i]));
}
for (int i = 0; i < im.maxHash_[0]; i++) {
// check hash value for row name
assert(im.hash_[0][i].next == imC1.hash_[0][i].next);
assert(im.hash_[0][i].index == imC1.hash_[0][i].index);
}
for (int i = 0; i < im.maxHash_[1]; i++) {
// check hash value for column name
assert(im.hash_[1][i].next == imC1.hash_[1][i].next);
assert(im.hash_[1][i].index == imC1.hash_[1][i].index);
}
CoinLpIO imC2(im);
assert( imC2.getNumCols() == im.getNumCols() );
assert( imC2.getNumRows() == im.getNumRows() );
lhs = imC2;
assert( lhs.getNumCols() == imC2.getNumCols() );
assert( lhs.getNumRows() == imC2.getNumRows() );
for (int i = 0; i < imC2.numberHash_[0]; i++) {
// check the row name
assert(!strcmp(lhs.names_[0][i], imC2.names_[0][i]));
}
for (int i = 0; i < imC2.numberHash_[1]; i++) {
// check the column name
assert(!strcmp(lhs.names_[1][i], imC2.names_[1][i]));
}
for (int i = 0; i < imC2.maxHash_[0]; i++) {
// check hash value for row name
assert(lhs.hash_[0][i].next == imC2.hash_[0][i].next);
assert(lhs.hash_[0][i].index == imC2.hash_[0][i].index);
}
for (int i = 0; i < im.maxHash_[1]; i++) {
// check hash value for column name
assert(lhs.hash_[1][i].next == imC2.hash_[1][i].next);
assert(lhs.hash_[1][i].index == imC2.hash_[1][i].index);
}
}
// Test that lhs has correct values even though rhs has gone out of scope
assert( lhs.getNumCols() == m.getNumCols() );
assert( lhs.getNumRows() == m.getNumRows() );
}
{
CoinLpIO dumSi(m);
int nc = dumSi.getNumCols();
int nr = dumSi.getNumRows();
const double* cl = dumSi.getColLower();
const double* cu = dumSi.getColUpper();
const double* rl = dumSi.getRowLower();
const double* ru = dumSi.getRowUpper();
assert( nc == 10 );
assert( nr == 5 );
assert( eq(cl[0], 2.5) );
assert( eq(cl[1], 0.5) );
assert( eq(cu[1], 4) );
assert( eq(cu[2], 4.3) );
assert( eq(rl[0], 2.5) );
assert( eq(rl[4], 15.0) );
assert( eq(ru[1], 2.1) );
assert( eq(ru[4], 15.0) );
assert( !eq(cl[3], 1.2345) );
assert( !eq(cu[4], 10.2345) );
assert( eq( dumSi.getObjCoefficients()[0], 1.0) );
assert( eq( dumSi.getObjCoefficients()[1], 2.0) );
assert( eq( dumSi.getObjCoefficients()[2], -1.0) );
assert( eq( dumSi.getObjCoefficients()[3], 0.0) );
assert( eq( dumSi.getObjCoefficients()[4], 0.0) );
assert( eq( dumSi.getObjCoefficients()[5], 0.0) );
assert( eq( dumSi.getObjCoefficients()[6], 0.0) );
assert( eq( dumSi.getObjCoefficients()[7], 0.0) );
assert( eq( dumSi.getObjCoefficients()[8], 0.0) );
assert( eq( dumSi.getObjCoefficients()[9], 0.0) );
dumSi.writeLp("CoinLpIoTest.lp", true);
}
// Read just written file
{
CoinLpIO dumSi;
dumSi.readLp("CoinLpIoTest.lp");
int nc = dumSi.getNumCols();
int nr = dumSi.getNumRows();
const double* cl = dumSi.getColLower();
const double* cu = dumSi.getColUpper();
const double* rl = dumSi.getRowLower();
const double* ru = dumSi.getRowUpper();
assert( nc == 10 );
assert( nr == 5 );
assert( eq(cl[0], 2.5) );
assert( eq(cl[1], 0.5) );
assert( eq(cu[1], 4) );
assert( eq(cu[2], 4.3) );
assert( eq(rl[0], 2.5) );
assert( eq(rl[4], 15.0) );
assert( eq(ru[1], 2.1) );
assert( eq(ru[4], 15.0) );
assert( !eq(cl[3], 1.2345) );
assert( !eq(cu[4], 10.2345) );
assert( eq( dumSi.getObjCoefficients()[0], 1.0) );
assert( eq( dumSi.getObjCoefficients()[1], 2.0) );
assert( eq( dumSi.getObjCoefficients()[2], -1.0) );
assert( eq( dumSi.getObjCoefficients()[3], 0.0) );
assert( eq( dumSi.getObjCoefficients()[4], 0.0) );
assert( eq( dumSi.getObjCoefficients()[5], 0.0) );
assert( eq( dumSi.getObjCoefficients()[6], 0.0) );
assert( eq( dumSi.getObjCoefficients()[7], 0.0) );
}
// Test matrixByRow method
{
const CoinLpIO si(m);
const CoinPackedMatrix* smP = si.getMatrixByRow();
CoinRelFltEq eq;
const double* ev = smP->getElements();
assert( eq(ev[0], 3.0) );
assert( eq(ev[1], 1.0) );
assert( eq(ev[2], -2.0) );
assert( eq(ev[3], -1.0) );
assert( eq(ev[4], -1.0) );
assert( eq(ev[5], 2.0) );
assert( eq(ev[6], 1.1) );
assert( eq(ev[7], 1.0) );
assert( eq(ev[8], 1.0) );
assert( eq(ev[9], 2.8) );
assert( eq(ev[10], -1.2) );
assert( eq(ev[11], -1.0 ) );
assert( eq(ev[12], 5.6) );
assert( eq(ev[13], 1.0) );
assert( eq(ev[14], 1.9) );
assert( eq(ev[15], -1.0) );
const CoinBigIndex* mi = smP->getVectorStarts();
assert( mi[0] == 0 );
assert( mi[1] == 5 );
assert( mi[2] == 7 );
assert( mi[3] == 9 );
assert( mi[4] == 12 );
assert( mi[5] == 16 );
const int* ei = smP->getIndices();
assert( ei[0] == 0 );
assert( ei[1] == 3 );
assert( ei[2] == 4 );
assert( ei[3] == 1 );
assert( ei[4] == 2 );
assert( ei[5] == 3 );
assert( ei[6] == 5 );
assert( ei[7] == 5 );
assert( ei[8] == 6 );
assert( ei[9] == 4 );
assert( ei[10] == 7 );
assert( ei[11] == 8 );
assert( ei[12] == 0 );
assert( ei[13] == 1 );
assert( ei[14] == 2 );
assert( ei[15] == 9 );
assert( smP->getMajorDim() == 5 );
assert( smP->getNumElements() == 16 );
}
// Test matrixByCol method
{
const CoinLpIO si(m);
const CoinPackedMatrix* smP = si.getMatrixByCol();
CoinRelFltEq eq;
const double* ev = smP->getElements();
assert( eq(ev[0], 3.0) );
assert( eq(ev[1], 5.6) );
assert( eq(ev[2], -1.0) );
assert( eq(ev[3], 1.0) );
assert( eq(ev[4], -1.0) );
assert( eq(ev[5], 1.9) );
assert( eq(ev[6], 1.0) );
assert( eq(ev[7], 2.0) );
assert( eq(ev[8], -2.0) );
assert( eq(ev[9], 2.8) );
assert( eq(ev[10], 1.1) );
assert( eq(ev[11], 1.0) );
assert( eq(ev[12], 1.0) );
assert( eq(ev[13], -1.2) );
assert( eq(ev[14], -1.0) );
assert( eq(ev[15], -1.0) );
const CoinBigIndex* mi = smP->getVectorStarts();
assert( mi[0] == 0 );
assert( mi[1] == 2 );
assert( mi[2] == 4 );
assert( mi[3] == 6 );
assert( mi[4] == 8 );
assert( mi[5] == 10 );
assert( mi[6] == 12 );
assert( mi[7] == 13 );
assert( mi[8] == 14 );
assert( mi[9] == 15 );
assert( mi[10] == 16 );
const int* ei = smP->getIndices();
assert( ei[0] == 0 );
assert( ei[1] == 4 );
assert( ei[2] == 0 );
assert( ei[3] == 4 );
assert( ei[4] == 0 );
assert( ei[5] == 4 );
assert( ei[6] == 0 );
assert( ei[7] == 1 );
assert( ei[8] == 0 );
assert( ei[9] == 3 );
assert( ei[10] == 1 );
assert( ei[11] == 2 );
assert( ei[12] == 2 );
assert( ei[13] == 3 );
assert( ei[14] == 3 );
assert( ei[15] == 4 );
assert( smP->getMajorDim() == 10 );
assert( smP->getNumElements() == 16 );
assert( smP->getSizeVectorStarts() == 11 );
assert( smP->getMinorDim() == 5 );
}
//--------------
// Test rowsense, rhs, rowrange, matrixByRow
{
CoinLpIO lhs;
{
assert( lhs.rowrange_ == NULL );
assert( lhs.rowsense_ == NULL );
assert( lhs.rhs_ == NULL );
assert( lhs.matrixByColumn_ == NULL );
CoinLpIO siC1(m);
assert( siC1.rowrange_ != NULL );
assert( siC1.rowsense_ != NULL );
assert( siC1.rhs_ != NULL );
assert( siC1.matrixByRow_ != NULL );
const char* siC1rs = siC1.getRowSense();
assert( siC1rs[0] == 'G' );
assert( siC1rs[1] == 'L' );
assert( siC1rs[2] == 'E' );
assert( siC1rs[3] == 'E' );
assert( siC1rs[4] == 'E' );
const double* siC1rhs = siC1.getRightHandSide();
assert( eq(siC1rhs[0], 2.5) );
assert( eq(siC1rhs[1], 2.1) );
assert( eq(siC1rhs[2], 4.0) );
assert( eq(siC1rhs[3], 1.8) );
assert( eq(siC1rhs[4], 15.) );
const double* siC1rr = siC1.getRowRange();
assert( eq(siC1rr[0], 0.0) );
assert( eq(siC1rr[1], 0.0) );
assert( eq(siC1rr[2], 0.0) );
assert( eq(siC1rr[3], 0.0) );
assert( eq(siC1rr[4], 0.0) );
const CoinPackedMatrix* siC1mbr = siC1.getMatrixByRow();
assert( siC1mbr != NULL );
const double* ev = siC1mbr->getElements();
assert( eq(ev[0], 3.0) );
assert( eq(ev[1], 1.0) );
assert( eq(ev[2], -2.0) );
assert( eq(ev[3], -1.0) );
assert( eq(ev[4], -1.0) );
assert( eq(ev[5], 2.0) );
assert( eq(ev[6], 1.1) );
assert( eq(ev[7], 1.0) );
assert( eq(ev[8], 1.0) );
assert( eq(ev[9], 2.8) );
assert( eq(ev[10], -1.2) );
assert( eq(ev[11], -1.0) );
assert( eq(ev[12], 5.6) );
assert( eq(ev[13], 1.0) );
assert( eq(ev[14], 1.9) );
assert( eq(ev[15], -1.0) );
const CoinBigIndex* mi = siC1mbr->getVectorStarts();
assert( mi[0] == 0 );
assert( mi[1] == 5 );
assert( mi[2] == 7 );
assert( mi[3] == 9 );
assert( mi[4] == 12 );
assert( mi[5] == 16 );
const int* ei = siC1mbr->getIndices();
assert( ei[0] == 0 );
assert( ei[1] == 3 );
assert( ei[2] == 4 );
assert( ei[3] == 1 );
assert( ei[4] == 2 );
assert( ei[5] == 3 );
assert( ei[6] == 5 );
assert( ei[7] == 5 );
assert( ei[8] == 6 );
assert( ei[9] == 4 );
assert( ei[10] == 7 );
assert( ei[11] == 8 );
assert( ei[12] == 0 );
assert( ei[13] == 1 );
assert( ei[14] == 2 );
assert( ei[15] == 9 );
assert( siC1mbr->getMajorDim() == 5 );
assert( siC1mbr->getNumElements() == 16 );
assert( siC1rs == siC1.getRowSense() );
assert( siC1rhs == siC1.getRightHandSide() );
assert( siC1rr == siC1.getRowRange() );
}
}
}
}
//--------------------------------------------------------------------------
void OsiCpxSolverInterfaceUnitTest( const std::string & mpsDir, const std::string & netlibDir )
{
// Test default constructor
{
OsiCpxSolverInterface m;
assert( m.obj_==NULL );
assert( m.collower_==NULL );
assert( m.colupper_==NULL );
assert( m.coltype_==NULL );
assert( m.rowsense_==NULL );
assert( m.rhs_==NULL );
assert( m.rowrange_==NULL );
assert( m.rowlower_==NULL );
assert( m.rowupper_==NULL );
assert( m.colsol_==NULL );
assert( m.rowsol_==NULL );
assert( m.matrixByRow_==NULL );
assert( m.matrixByCol_==NULL );
assert( m.coltype_==NULL );
assert( m.coltypesize_==0 );
assert( m.getApplicationData() == NULL );
int i=2346;
m.setApplicationData(&i);
assert( *((int *)(m.getApplicationData())) == i );
}
{
CoinRelFltEq eq;
OsiCpxSolverInterface m;
std::string fn = mpsDir+"exmip1";
m.readMps(fn.c_str(),"mps");
int ad = 13579;
m.setApplicationData(&ad);
assert( *((int *)(m.getApplicationData())) == ad );
{
assert( m.getNumCols()==8 );
const CoinPackedMatrix * colCopy = m.getMatrixByCol();
assert( colCopy->getNumCols() == 8 );
assert( colCopy->getMajorDim() == 8 );
assert( colCopy->getNumRows() == 5 );
assert( colCopy->getMinorDim() == 5 );
assert (colCopy->getVectorLengths()[7] == 2 );
CoinPackedMatrix revColCopy;
revColCopy.reverseOrderedCopyOf(*colCopy);
CoinPackedMatrix rev2ColCopy;
rev2ColCopy.reverseOrderedCopyOf(revColCopy);
assert( rev2ColCopy.getNumCols() == 8 );
assert( rev2ColCopy.getMajorDim() == 8 );
assert( rev2ColCopy.getNumRows() == 5 );
assert( rev2ColCopy.getMinorDim() == 5 );
assert( rev2ColCopy.getVectorLengths()[7] == 2 );
}
{
OsiCpxSolverInterface im;
assert( im.getNumCols() == 0 );
}
// Test copy constructor and assignment operator
{
OsiCpxSolverInterface lhs;
{
assert( *((int *)(m.getApplicationData())) == ad );
OsiCpxSolverInterface im(m);
assert( *((int *)(im.getApplicationData())) == ad );
OsiCpxSolverInterface imC1(im);
assert( imC1.lp_ != im.lp_ );
assert( imC1.getNumCols() == im.getNumCols() );
assert( imC1.getNumRows() == im.getNumRows() );
assert( *((int *)(imC1.getApplicationData())) == ad );
//im.setModelPtr(m);
OsiCpxSolverInterface imC2(im);
assert( imC2.lp_ != im.lp_ );
assert( imC2.getNumCols() == im.getNumCols() );
assert( imC2.getNumRows() == im.getNumRows() );
assert( *((int *)(imC2.getApplicationData())) == ad );
assert( imC2.lp_ != imC1.lp_ );
lhs=imC2;
}
// Test that lhs has correct values even though rhs has gone out of scope
assert( lhs.lp_ != m.lp_ );
assert( lhs.getNumCols() == m.getNumCols() );
assert( lhs.getNumRows() == m.getNumRows() );
assert( *((int *)(lhs.getApplicationData())) == ad );
}
// Test clone
{
OsiCpxSolverInterface cplexSi(m);
OsiSolverInterface * siPtr = &cplexSi;
OsiSolverInterface * siClone = siPtr->clone();
OsiCpxSolverInterface * cplexClone = dynamic_cast<OsiCpxSolverInterface*>(siClone);
assert( cplexClone != NULL );
assert( cplexClone->lp_ != cplexSi.lp_ );
assert( cplexClone->getNumRows() == cplexSi.getNumRows() );
assert( cplexClone->getNumCols() == m.getNumCols() );
assert( *((int *)(cplexClone->getApplicationData())) == ad );
delete siClone;
}
// test infinity
{
OsiCpxSolverInterface si;
assert( eq( si.getInfinity(), CPX_INFBOUND ) );
}
// Test setting solution
{
OsiCpxSolverInterface m1(m);
int i;
double * cs = new double[m1.getNumCols()];
for ( i = 0; i < m1.getNumCols(); i++ )
cs[i] = i + .5;
m1.setColSolution(cs);
for ( i = 0; i < m1.getNumCols(); i++ )
assert(m1.getColSolution()[i] == i + .5);
double * rs = new double[m1.getNumRows()];
for ( i = 0; i < m1.getNumRows(); i++ )
rs[i] = i - .5;
m1.setRowPrice(rs);
for ( i = 0; i < m1.getNumRows(); i++ )
assert(m1.getRowPrice()[i] == i - .5);
delete [] cs;
delete [] rs;
}
// Test fraction Indices
{
OsiCpxSolverInterface fim;
std::string fn = mpsDir+"exmip1";
fim.readMps(fn.c_str(),"mps");
//fim.setModelPtr(m);
// exmip1.mps has 2 integer variables with index 2 & 3
assert( fim.isContinuous(0) );
assert( fim.isContinuous(1) );
assert( !fim.isContinuous(2) );
assert( !fim.isContinuous(3) );
assert( fim.isContinuous(4) );
assert( !fim.isInteger(0) );
assert( !fim.isInteger(1) );
assert( fim.isInteger(2) );
assert( fim.isInteger(3) );
assert( !fim.isInteger(4) );
assert( !fim.isBinary(0) );
assert( !fim.isBinary(1) );
assert( fim.isBinary(2) );
assert( fim.isBinary(3) );
assert( !fim.isBinary(4) );
assert( !fim.isIntegerNonBinary(0) );
assert( !fim.isIntegerNonBinary(1) );
assert( !fim.isIntegerNonBinary(2) );
assert( !fim.isIntegerNonBinary(3) );
assert( !fim.isIntegerNonBinary(4) );
// Test fractionalIndices
{
// Set a solution vector
double * cs = new double[fim.getNumCols()];
for ( int i = 0; i < fim.getNumCols(); cs[i++] = 0.0 );
cs[2] = 2.9;
cs[3] = 3.0;
fim.setColSolution(cs);
OsiVectorInt fi = fim.getFractionalIndices();
assert( fi.size() == 1 );
assert( fi[0]==2 );
// Set integer variables very close to integer values
cs[2] = 5 + .00001/2.;
cs[3] = 8 - .00001/2.;
fim.setColSolution(cs);
fi = fim.getFractionalIndices(1e-5);
assert( fi.size() == 0 );
// Set integer variables close, but beyond tolerances
cs[2] = 5 + .00001*2.;
cs[3] = 8 - .00001*2.;
fim.setColSolution(cs);
fi = fim.getFractionalIndices(1e-5);
assert( fi.size() == 2 );
assert( fi[0]==2 );
assert( fi[1]==3 );
delete [] cs;
}
// Change data so column 2 & 3 are integerNonBinary
fim.setColUpper(2, 5);
fim.setColUpper(3, 6.0);
assert( !fim.isBinary(0) );
assert( !fim.isBinary(1) );
assert( !fim.isBinary(2) );
assert( !fim.isBinary(3) );
assert( !fim.isBinary(4) );
assert( !fim.isIntegerNonBinary(0) );
assert( !fim.isIntegerNonBinary(1) );
assert( fim.isIntegerNonBinary(2) );
assert( fim.isIntegerNonBinary(3) );
assert( !fim.isIntegerNonBinary(4) );
}
// Test apply cuts method
{
OsiCpxSolverInterface im(m);
OsiCuts cuts;
// Generate some cuts
{
// Get number of rows and columns in model
int nr=im.getNumRows();
int nc=im.getNumCols();
assert( nr == 5 );
assert( nc == 8 );
// Generate a valid row cut from thin air
int c;
{
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]=((double)c)*((double)c);
OsiRowCut rc;
rc.setRow(nc,inx,el);
rc.setLb(-100.);
rc.setUb(100.);
rc.setEffectiveness(22);
cuts.insert(rc);
delete[]el;
delete[]inx;
}
// Generate valid col cut from thin air
{
const double * cplexColLB = im.getColLower();
const double * cplexColUB = im.getColUpper();
int *inx = new int[nc];
for (c=0;c<nc;c++) inx[c]=c;
double *lb = new double[nc];
double *ub = new double[nc];
for (c=0;c<nc;c++) lb[c]=cplexColLB[c]+0.001;
for (c=0;c<nc;c++) ub[c]=cplexColUB[c]-0.001;
OsiColCut cc;
cc.setLbs(nc,inx,lb);
cc.setUbs(nc,inx,ub);
cuts.insert(cc);
delete [] ub;
delete [] lb;
delete [] inx;
}
{
// Generate a row and column cut which have are ineffective
OsiRowCut * rcP= new OsiRowCut;
rcP->setEffectiveness(-1.);
cuts.insert(rcP);
assert(rcP==NULL);
OsiColCut * ccP= new OsiColCut;
ccP->setEffectiveness(-12.);
cuts.insert(ccP);
assert(ccP==NULL);
}
{
//Generate inconsistent Row cut
OsiRowCut rc;
const int ne=1;
int inx[ne]={-10};
double el[ne]={2.5};
rc.setRow(ne,inx,el);
rc.setLb(3.);
rc.setUb(4.);
assert(!rc.consistent());
cuts.insert(rc);
}
{
//Generate inconsistent col cut
OsiColCut cc;
const int ne=1;
int inx[ne]={-10};
double el[ne]={2.5};
cc.setUbs(ne,inx,el);
assert(!cc.consistent());
cuts.insert(cc);
}
{
// Generate row cut which is inconsistent for model m
OsiRowCut rc;
const int ne=1;
int inx[ne]={10};
double el[ne]={2.5};
rc.setRow(ne,inx,el);
assert(rc.consistent());
assert(!rc.consistent(im));
cuts.insert(rc);
}
{
// Generate col cut which is inconsistent for model m
OsiColCut cc;
const int ne=1;
int inx[ne]={30};
double el[ne]={2.0};
cc.setLbs(ne,inx,el);
assert(cc.consistent());
assert(!cc.consistent(im));
cuts.insert(cc);
}
{
// Generate col cut which is infeasible
OsiColCut cc;
const int ne=1;
int inx[ne]={0};
double el[ne]={2.0};
cc.setUbs(ne,inx,el);
cc.setEffectiveness(1000.);
assert(cc.consistent());
assert(cc.consistent(im));
assert(cc.infeasible(im));
cuts.insert(cc);
}
}
assert(cuts.sizeRowCuts()==4);
assert(cuts.sizeColCuts()==5);
OsiSolverInterface::ApplyCutsReturnCode rc = im.applyCuts(cuts);
assert( rc.getNumIneffective() == 2 );
assert( rc.getNumApplied() == 2 );
assert( rc.getNumInfeasible() == 1 );
assert( rc.getNumInconsistentWrtIntegerModel() == 2 );
assert( rc.getNumInconsistent() == 2 );
assert( cuts.sizeCuts() == rc.getNumIneffective() +
rc.getNumApplied() +
rc.getNumInfeasible() +
rc.getNumInconsistentWrtIntegerModel() +
rc.getNumInconsistent() );
}
{
OsiCpxSolverInterface cplexSi(m);
int nc = cplexSi.getNumCols();
int nr = cplexSi.getNumRows();
const double * cl = cplexSi.getColLower();
const double * cu = cplexSi.getColUpper();
const double * rl = cplexSi.getRowLower();
const double * ru = cplexSi.getRowUpper();
assert( nc == 8 );
assert( nr == 5 );
assert( eq(cl[0],2.5) );
assert( eq(cl[1],0.0) );
assert( eq(cu[1],4.1) );
assert( eq(cu[2],1.0) );
assert( eq(rl[0],2.5) );
assert( eq(rl[4],3.0) );
assert( eq(ru[1],2.1) );
assert( eq(ru[4],15.0) );
double newCs[8] = {1., 2., 3., 4., 5., 6., 7., 8.};
cplexSi.setColSolution(newCs);
const double * cs = cplexSi.getColSolution();
assert( eq(cs[0],1.0) );
assert( eq(cs[7],8.0) );
{
OsiCpxSolverInterface solnSi(cplexSi);
const double * cs = solnSi.getColSolution();
assert( eq(cs[0],1.0) );
assert( eq(cs[7],8.0) );
}
assert( !eq(cl[3],1.2345) );
cplexSi.setColLower( 3, 1.2345 );
assert( eq(cplexSi.getColLower()[3],1.2345) );
assert( !eq(cu[4],10.2345) );
cplexSi.setColUpper( 4, 10.2345 );
assert( eq(cplexSi.getColUpper()[4],10.2345) );
assert( eq(cplexSi.getObjValue(),0.0) );
assert( eq( cplexSi.getObjCoefficients()[0], 1.0) );
assert( eq( cplexSi.getObjCoefficients()[1], 0.0) );
assert( eq( cplexSi.getObjCoefficients()[2], 0.0) );
assert( eq( cplexSi.getObjCoefficients()[3], 0.0) );
assert( eq( cplexSi.getObjCoefficients()[4], 2.0) );
assert( eq( cplexSi.getObjCoefficients()[5], 0.0) );
assert( eq( cplexSi.getObjCoefficients()[6], 0.0) );
assert( eq( cplexSi.getObjCoefficients()[7], -1.0) );
}
// Test getMatrixByRow method
{
const OsiCpxSolverInterface si(m);
const CoinPackedMatrix * smP = si.getMatrixByRow();
//const CoinPackedMatrix * osmP = dynamic_cast(const OsiCpxPackedMatrix*)(smP);
//assert( osmP!=NULL );
CoinRelFltEq eq;
const double * ev = smP->getElements();
assert( eq(ev[0], 3.0) );
assert( eq(ev[1], 1.0) );
assert( eq(ev[2], -2.0) );
assert( eq(ev[3], -1.0) );
assert( eq(ev[4], -1.0) );
assert( eq(ev[5], 2.0) );
assert( eq(ev[6], 1.1) );
assert( eq(ev[7], 1.0) );
assert( eq(ev[8], 1.0) );
assert( eq(ev[9], 2.8) );
assert( eq(ev[10], -1.2) );
assert( eq(ev[11], 5.6) );
assert( eq(ev[12], 1.0) );
assert( eq(ev[13], 1.9) );
const int * mi = smP->getVectorStarts();
assert( mi[0]==0 );
assert( mi[1]==5 );
assert( mi[2]==7 );
assert( mi[3]==9 );
assert( mi[4]==11 );
assert( mi[5]==14 );
const int * ei = smP->getIndices();
assert( ei[0] == 0 );
assert( ei[1] == 1 );
assert( ei[2] == 3 );
assert( ei[3] == 4 );
assert( ei[4] == 7 );
assert( ei[5] == 1 );
assert( ei[6] == 2 );
assert( ei[7] == 2 );
assert( ei[8] == 5 );
assert( ei[9] == 3 );
assert( ei[10] == 6 );
assert( ei[11] == 0 );
assert( ei[12] == 4 );
assert( ei[13] == 7 );
assert( smP->getMajorDim() == 5 );
assert( smP->getNumElements() == 14 );
}
//--------------
// Test rowsense, rhs, rowrange, getMatrixByRow
{
OsiCpxSolverInterface lhs;
{
#if 0
assert( m.obj_==NULL );
assert( m.collower_==NULL );
assert( m.colupper_==NULL );
assert( m.rowrange_==NULL );
assert( m.rowsense_==NULL );
assert( m.rhs_==NULL );
assert( m.rowlower_==NULL );
assert( m.rowupper_==NULL );
assert( m.colsol_==NULL );
assert( m.rowsol_==NULL );
assert( m.getMatrixByRow_==NULL );
#endif
OsiCpxSolverInterface siC1(m);
assert( siC1.obj_==NULL );
assert( siC1.collower_==NULL );
assert( siC1.colupper_==NULL );
// assert( siC1.coltype_==NULL );
assert( siC1.rowrange_==NULL );
assert( siC1.rowsense_==NULL );
assert( siC1.rhs_==NULL );
assert( siC1.rowlower_==NULL );
assert( siC1.rowupper_==NULL );
assert( siC1.colsol_!=NULL );
assert( siC1.rowsol_!=NULL );
assert( siC1.matrixByRow_==NULL );
const char * siC1rs = siC1.getRowSense();
assert( siC1rs[0]=='G' );
assert( siC1rs[1]=='L' );
assert( siC1rs[2]=='E' );
assert( siC1rs[3]=='R' );
assert( siC1rs[4]=='R' );
const double * siC1rhs = siC1.getRightHandSide();
assert( eq(siC1rhs[0],2.5) );
assert( eq(siC1rhs[1],2.1) );
assert( eq(siC1rhs[2],4.0) );
assert( eq(siC1rhs[3],5.0) );
assert( eq(siC1rhs[4],15.) );
const double * siC1rr = siC1.getRowRange();
assert( eq(siC1rr[0],0.0) );
assert( eq(siC1rr[1],0.0) );
assert( eq(siC1rr[2],0.0) );
assert( eq(siC1rr[3],5.0-1.8) );
assert( eq(siC1rr[4],15.0-3.0) );
const CoinPackedMatrix * siC1mbr = siC1.getMatrixByRow();
assert( siC1mbr != NULL );
const double * ev = siC1mbr->getElements();
assert( eq(ev[0], 3.0) );
assert( eq(ev[1], 1.0) );
assert( eq(ev[2], -2.0) );
assert( eq(ev[3], -1.0) );
assert( eq(ev[4], -1.0) );
assert( eq(ev[5], 2.0) );
assert( eq(ev[6], 1.1) );
assert( eq(ev[7], 1.0) );
assert( eq(ev[8], 1.0) );
assert( eq(ev[9], 2.8) );
assert( eq(ev[10], -1.2) );
assert( eq(ev[11], 5.6) );
assert( eq(ev[12], 1.0) );
assert( eq(ev[13], 1.9) );
const int * mi = siC1mbr->getVectorStarts();
assert( mi[0]==0 );
assert( mi[1]==5 );
assert( mi[2]==7 );
assert( mi[3]==9 );
assert( mi[4]==11 );
assert( mi[5]==14 );
const int * ei = siC1mbr->getIndices();
assert( ei[0] == 0 );
assert( ei[1] == 1 );
assert( ei[2] == 3 );
assert( ei[3] == 4 );
assert( ei[4] == 7 );
assert( ei[5] == 1 );
assert( ei[6] == 2 );
assert( ei[7] == 2 );
assert( ei[8] == 5 );
assert( ei[9] == 3 );
assert( ei[10] == 6 );
assert( ei[11] == 0 );
assert( ei[12] == 4 );
assert( ei[13] == 7 );
assert( siC1mbr->getMajorDim() == 5 );
assert( siC1mbr->getNumElements() == 14 );
assert( siC1rs == siC1.getRowSense() );
assert( siC1rhs == siC1.getRightHandSide() );
assert( siC1rr == siC1.getRowRange() );
// Change CPLEX 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.
assert( siC1.obj_==NULL );
assert( siC1.collower_==NULL );
assert( siC1.colupper_==NULL );
// assert( siC1.coltype_==NULL );
assert( siC1.rowrange_==NULL );
assert( siC1.rowsense_==NULL );
assert( siC1.rhs_==NULL );
assert( siC1.rowlower_==NULL );
assert( siC1.rowupper_==NULL );
assert( siC1.colsol_==NULL );
assert( siC1.rowsol_==NULL );
assert( siC1.matrixByRow_==NULL );
siC1rs = siC1.getRowSense();
siC1rhs = siC1.getRightHandSide();
siC1rr = siC1.getRowRange();
assert( siC1rs[0]=='G' );
assert( siC1rs[1]=='L' );
assert( siC1rs[2]=='E' );
assert( siC1rs[3]=='R' );
assert( siC1rs[4]=='R' );
assert( siC1rs[5]=='N' );
assert( eq(siC1rhs[0],2.5) );
assert( eq(siC1rhs[1],2.1) );
assert( eq(siC1rhs[2],4.0) );
assert( eq(siC1rhs[3],5.0) );
assert( eq(siC1rhs[4],15.) );
assert( eq(siC1rhs[5],0.0) );
assert( eq(siC1rr[0],0.0) );
assert( eq(siC1rr[1],0.0) );
assert( eq(siC1rr[2],0.0) );
assert( eq(siC1rr[3],5.0-1.8) );
assert( eq(siC1rr[4],15.0-3.0) );
assert( eq(siC1rr[5],0.0) );
lhs=siC1;
}
// Test that lhs has correct values even though siC1 has gone out of scope
assert( lhs.obj_==NULL );
assert( lhs.collower_==NULL );
assert( lhs.colupper_==NULL );
// assert( lhs.coltype_==NULL );
assert( lhs.rowrange_==NULL );
assert( lhs.rowsense_==NULL );
assert( lhs.rhs_==NULL );
assert( lhs.rowlower_==NULL );
assert( lhs.rowupper_==NULL );
assert( lhs.colsol_!=NULL );
assert( lhs.rowsol_!=NULL );
assert( lhs.matrixByRow_==NULL );
const char * lhsrs = lhs.getRowSense();
assert( lhsrs[0]=='G' );
assert( lhsrs[1]=='L' );
assert( lhsrs[2]=='E' );
assert( lhsrs[3]=='R' );
assert( lhsrs[4]=='R' );
assert( lhsrs[5]=='N' );
const double * lhsrhs = lhs.getRightHandSide();
assert( eq(lhsrhs[0],2.5) );
assert( eq(lhsrhs[1],2.1) );
assert( eq(lhsrhs[2],4.0) );
assert( eq(lhsrhs[3],5.0) );
assert( eq(lhsrhs[4],15.) );
assert( eq(lhsrhs[5],0.0) );
const double *lhsrr = lhs.getRowRange();
assert( eq(lhsrr[0],0.0) );
assert( eq(lhsrr[1],0.0) );
assert( eq(lhsrr[2],0.0) );
assert( eq(lhsrr[3],5.0-1.8) );
assert( eq(lhsrr[4],15.0-3.0) );
assert( eq(lhsrr[5],0.0) );
const CoinPackedMatrix * lhsmbr = lhs.getMatrixByRow();
assert( lhsmbr != NULL );
const double * ev = lhsmbr->getElements();
assert( eq(ev[0], 3.0) );
assert( eq(ev[1], 1.0) );
assert( eq(ev[2], -2.0) );
assert( eq(ev[3], -1.0) );
assert( eq(ev[4], -1.0) );
assert( eq(ev[5], 2.0) );
assert( eq(ev[6], 1.1) );
assert( eq(ev[7], 1.0) );
assert( eq(ev[8], 1.0) );
assert( eq(ev[9], 2.8) );
assert( eq(ev[10], -1.2) );
assert( eq(ev[11], 5.6) );
assert( eq(ev[12], 1.0) );
assert( eq(ev[13], 1.9) );
const int * mi = lhsmbr->getVectorStarts();
assert( mi[0]==0 );
assert( mi[1]==5 );
assert( mi[2]==7 );
assert( mi[3]==9 );
assert( mi[4]==11 );
assert( mi[5]==14 );
const int * ei = lhsmbr->getIndices();
assert( ei[0] == 0 );
assert( ei[1] == 1 );
assert( ei[2] == 3 );
assert( ei[3] == 4 );
assert( ei[4] == 7 );
assert( ei[5] == 1 );
assert( ei[6] == 2 );
assert( ei[7] == 2 );
assert( ei[8] == 5 );
assert( ei[9] == 3 );
assert( ei[10] == 6 );
assert( ei[11] == 0 );
assert( ei[12] == 4 );
assert( ei[13] == 7 );
int md = lhsmbr->getMajorDim();
assert( md == 6 );
assert( lhsmbr->getNumElements() == 14 );
}
}
// Do common solverInterface testing by calling the
// base class testing method.
{
OsiCpxSolverInterface m;
OsiSolverInterfaceCommonUnitTest(&m, mpsDir,netlibDir);
}
}
//-----------------------------------------------------------------------
// Test XPRESS-MP solution methods.
void
OsiXprSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir)
{
#if 0
// Test to at least see if licence managment is working
{
int iret = initlz(NULL, 0);
if ( iret != 0 ) getipv(N_ERRNO, &iret);
assert(iret == 0);
}
#endif
// Test default constructor
{
assert( OsiXprSolverInterface::getNumInstances()==0 );
OsiXprSolverInterface m;
// assert( m.xprSaved_ == false );
// assert( m.xprMatrixId_ = -1 );
assert( m.xprProbname_ == "" );
assert( m.matrixByRow_ == NULL );
assert( m.colupper_ == NULL );
assert( m.collower_ == NULL );
assert( m.rowupper_ == NULL );
assert( m.rowlower_ == NULL );
assert( m.rowsense_ == NULL );
assert( m.rhs_ == NULL );
assert( m.rowrange_ == NULL );
assert( m.colsol_ == NULL );
assert( m.rowprice_ == NULL );
assert( m.ivarind_ == NULL );
assert( m.ivartype_ == NULL );
assert( m.vartype_ == NULL );
assert( OsiXprSolverInterface::getNumInstances() == 1 );
// assert( OsiXprSolverInterface::xprCurrentProblem_ == NULL );
assert( m.getApplicationData() == NULL );
int i = 2346;
m.setApplicationData(&i);
assert( *((int *)(m.getApplicationData())) == i );
}
assert( OsiXprSolverInterface::getNumInstances() == 0 );
{
CoinRelFltEq eq;
OsiXprSolverInterface m;
assert( OsiXprSolverInterface::getNumInstances() == 1 );
std::string fn = mpsDir+"exmip1";
m.readMps(fn.c_str());
// assert( OsiXprSolverInterface::xprCurrentProblem_ == &m );
// This assert fails on windows because fn is mixed case and xprProbname_is uppercase.
//assert( m.xprProbname_ == fn );
int ad = 13579;
m.setApplicationData(&ad);
assert( *((int *)(m.getApplicationData())) == ad );
{
OsiXprSolverInterface im;
// assert( im.modelPtr_==NULL );
assert( im.getNumCols() == 0 );
// assert( im.modelPtr()!=NULL );
// assert( im.mutableModelPtr()!=NULL );
// assert( im.modelPtr() == im.mutableModelPtr() );
}
// Test copy constructor and assignment operator
{
OsiXprSolverInterface lhs;
{
assert( *((int *)(m.getApplicationData())) == ad );
OsiXprSolverInterface im(m);
assert( *((int *)(im.getApplicationData())) == ad );
OsiXprSolverInterface imC1(im);
// assert( imC1.mutableModelPtr()!=im.mutableModelPtr() );
// assert( imC1.modelPtr()!=im.modelPtr() );
assert( imC1.getNumCols() == im.getNumCols() );
assert( imC1.getNumRows() == im.getNumRows() );
assert( *((int *)(imC1.getApplicationData())) == ad );
//im.setModelPtr(m);
OsiXprSolverInterface imC2(im);
// assert( imC2.mutableModelPtr()!=im.mutableModelPtr() );
// assert( imC2.modelPtr()!=im.modelPtr() );
assert( imC2.getNumCols() == im.getNumCols() );
assert( imC2.getNumRows() == im.getNumRows() );
assert( *((int *)(imC2.getApplicationData())) == ad );
// assert( imC2.mutableModelPtr()!=imC1.mutableModelPtr() );
// assert( imC2.modelPtr()!=imC1.modelPtr() );
lhs=imC2;
}
// Test that lhs has correct values even though rhs has gone out of scope
// assert( lhs.mutableModelPtr() != m.mutableModelPtr() );
// assert( lhs.modelPtr() != m.modelPtr() );
assert( lhs.getNumCols() == m.getNumCols() );
assert( lhs.getNumRows() == m.getNumRows() );
assert( *((int *)(lhs.getApplicationData())) == ad );
}
// Test clone
{
OsiXprSolverInterface xprSi(m);
OsiSolverInterface * siPtr = &xprSi;
OsiSolverInterface * siClone = siPtr->clone();
OsiXprSolverInterface * xprClone = dynamic_cast<OsiXprSolverInterface*>(siClone);
assert( xprClone != NULL );
// assert( xprClone->modelPtr() != xprSi.modelPtr() );
// assert( xprClone->modelPtr() != m.modelPtr() );
assert( xprClone->getNumRows() == xprSi.getNumRows() );
assert( xprClone->getNumCols() == m.getNumCols() );
assert( *((int *)(xprClone->getApplicationData())) == ad );
delete siClone;
}
// Test infinity
{
OsiXprSolverInterface si;
assert( eq(si.getInfinity(), XPRS_PLUSINFINITY) );
}
// Test setting solution
{
OsiXprSolverInterface m1(m);
int i;
double * cs = new double[m1.getNumCols()];
for ( i = 0; i < m1.getNumCols(); i++ )
cs[i] = i + .5;
m1.setColSolution(cs);
for ( i = 0; i < m1.getNumCols(); i++ )
assert(m1.getColSolution()[i] == i + .5);
double * rs = new double[m1.getNumRows()];
for ( i = 0; i < m1.getNumRows(); i++ )
rs[i] = i - .5;
m1.setRowPrice(rs);
for ( i = 0; i < m1.getNumRows(); i++ )
assert(m1.getRowPrice()[i] == i - .5);
delete [] cs;
delete [] rs;
}
// Test fraction Indices
{
OsiXprSolverInterface fim;
std::string fn = mpsDir+"exmip1";
fim.readMps(fn.c_str());
//fim.setModelPtr(m);
// exmip1.mps has 2 integer variables with index 2 & 3
assert( fim.isContinuous(0) );
assert( fim.isContinuous(1) );
assert( !fim.isContinuous(2) );
assert( !fim.isContinuous(3) );
assert( fim.isContinuous(4) );
assert( !fim.isInteger(0) );
assert( !fim.isInteger(1) );
assert( fim.isInteger(2) );
assert( fim.isInteger(3) );
assert( !fim.isInteger(4) );
// XPRESS-MP incorrectly treats unbounded integer variables as
// general integers instead of binary (as in MPSX standard)
assert( !fim.isBinary(0) );
assert( !fim.isBinary(1) );
assert( fim.isBinary(2) );
assert( fim.isBinary(3) );
assert( !fim.isBinary(4) );
assert( !fim.isIntegerNonBinary(0) );
assert( !fim.isIntegerNonBinary(1) );
assert( !fim.isIntegerNonBinary(2) );
assert( !fim.isIntegerNonBinary(3) );
assert( !fim.isIntegerNonBinary(4) );
// Test fractionalIndices
{
// Set a solution vector
double * cs = new double[fim.getNumCols()];
for ( int i = 0; i < fim.getNumCols(); cs[i++] = 0.0 );
cs[2] = 2.9;
cs[3] = 3.0;
fim.setColSolution(cs);
OsiVectorInt fi = fim.getFractionalIndices();
assert( fi.size() == 1 );
assert( fi[0]==2 );
// Set integer variables very close to integer values
cs[2] = 5 + .00001/2.;
cs[3] = 8 - .00001/2.;
fim.setColSolution(cs);
fi = fim.getFractionalIndices(1e-5);
assert( fi.size() == 0 );
// Set integer variables close, but beyond tolerances
cs[2] = 5 + .00001*2.;
cs[3] = 8 - .00001*2.;
fim.setColSolution(cs);
fi = fim.getFractionalIndices(1e-5);
assert( fi.size() == 2 );
assert( fi[0]==2 );
assert( fi[1]==3 );
delete [] cs;
}
// Change data so column 2 & 3 are integerNonBinary
fim.setColUpper(2, 5);
fim.setColUpper(3, 6.0);
assert( !fim.isBinary(0) );
assert( !fim.isBinary(1) );
assert( !fim.isBinary(2) );
assert( !fim.isBinary(3) );
assert( !fim.isBinary(4) );
assert( !fim.isIntegerNonBinary(0) );
assert( !fim.isIntegerNonBinary(1) );
assert( fim.isIntegerNonBinary(2) );
assert( fim.isIntegerNonBinary(3) );
assert( !fim.isIntegerNonBinary(4) );
}
// Test apply cut method
{
OsiXprSolverInterface im(m);
OsiCuts cuts;
// Generate some cuts
//cg.generateCuts(im,cuts);
{
// Get number of rows and columns in model
int nr=im.getNumRows();
int nc=im.getNumCols();
assert ( nr == 5 );
assert ( nc == 8 );
// Generate a valid row cut from thin air
int c;
{
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]=((double)c)*((double)c);
OsiRowCut rc;
rc.setRow(nc,inx,el);
rc.setLb(-100.);
rc.setUb(100.);
rc.setEffectiveness(22);
cuts.insert(rc);
delete[]el;
delete[]inx;
}
// Generate valid col cut from thin air
{
const double * xprColLB = im.getColLower();
const double * xprColUB = im.getColUpper();
int *inx = new int[nc];
for (c=0;c<nc;c++) inx[c]=c;
double *lb = new double[nc];
double *ub = new double[nc];
for (c=0;c<nc;c++) lb[c]=xprColLB[c]+0.001;
for (c=0;c<nc;c++) ub[c]=xprColUB[c]-0.001;
OsiColCut cc;
cc.setLbs(nc,inx,lb);
cc.setUbs(nc,inx,ub);
cuts.insert(cc);
delete [] ub;
delete [] lb;
delete [] inx;
}
{
// Generate a row and column cut which have are ineffective
OsiRowCut * rcP= new OsiRowCut;
rcP->setEffectiveness(-1.);
cuts.insert(rcP);
assert(rcP==NULL);
OsiColCut * ccP= new OsiColCut;
ccP->setEffectiveness(-12.);
cuts.insert(ccP);
assert(ccP==NULL);
}
{
//Generate inconsistent Row cut
OsiRowCut rc;
const int ne=1;
int inx[ne]={-10};
double el[ne]={2.5};
rc.setRow(ne,inx,el);
rc.setLb(3.);
rc.setUb(4.);
assert(!rc.consistent());
cuts.insert(rc);
}
{
//Generate inconsistent col cut
OsiColCut cc;
const int ne=1;
int inx[ne]={-10};
double el[ne]={2.5};
cc.setUbs(ne,inx,el);
assert(!cc.consistent());
cuts.insert(cc);
}
{
// Generate row cut which is inconsistent for model m
OsiRowCut rc;
const int ne=1;
int inx[ne]={10};
double el[ne]={2.5};
rc.setRow(ne,inx,el);
assert(rc.consistent());
assert(!rc.consistent(im));
cuts.insert(rc);
}
{
// Generate col cut which is inconsistent for model m
OsiColCut cc;
const int ne=1;
int inx[ne]={30};
double el[ne]={2.0};
cc.setLbs(ne,inx,el);
assert(cc.consistent());
assert(!cc.consistent(im));
cuts.insert(cc);
}
{
// Generate col cut which is infeasible
OsiColCut cc;
const int ne=1;
int inx[ne]={0};
double el[ne]={2.0};
cc.setUbs(ne,inx,el);
cc.setEffectiveness(1000.);
assert(cc.consistent());
assert(cc.consistent(im));
assert(cc.infeasible(im));
cuts.insert(cc);
}
}
assert(cuts.sizeRowCuts()==4);
assert(cuts.sizeColCuts()==5);
OsiSolverInterface::ApplyCutsReturnCode rc = im.applyCuts(cuts);
assert( rc.getNumIneffective() == 2 );
assert( rc.getNumApplied() == 2 );
assert( rc.getNumInfeasible() == 1 );
assert( rc.getNumInconsistentWrtIntegerModel() == 2 );
assert( rc.getNumInconsistent() == 2 );
assert( cuts.sizeCuts() == rc.getNumIneffective() +
rc.getNumApplied() +
rc.getNumInfeasible() +
rc.getNumInconsistentWrtIntegerModel() +
rc.getNumInconsistent() );
}
{
OsiXprSolverInterface xprSi(m);
int nc = xprSi.getNumCols();
int nr = xprSi.getNumRows();
assert( nc == 8 );
assert( nr == 5 );
assert( eq(xprSi.getColLower()[0],2.5) );
assert( eq(xprSi.getColLower()[1],0.0) );
assert( eq(xprSi.getColUpper()[1],4.1) );
assert( eq(xprSi.getRowLower()[0],2.5) );
assert( eq(xprSi.getRowLower()[4],3.0) );
assert( eq(xprSi.getRowUpper()[1],2.1) );
assert( eq(xprSi.getRowUpper()[4],15.0) );
// const double * cs = xprSi.getColSolution();
// assert( eq(cs[0],2.5) );
// assert( eq(cs[7],0.0) );
assert( !eq(xprSi.getColLower()[3],1.2345) );
xprSi.setColLower( 3, 1.2345 );
assert( eq(xprSi.getColLower()[3],1.2345) );
assert( !eq(xprSi.getColUpper()[4],10.2345) );
xprSi.setColUpper( 4, 10.2345 );
assert( eq(xprSi.getColUpper()[4],10.2345) );
//assert( eq(xprSi.getObjValue(),0.0) );
assert( eq( xprSi.getObjCoefficients()[0], 1.0) );
assert( eq( xprSi.getObjCoefficients()[1], 0.0) );
assert( eq( xprSi.getObjCoefficients()[2], 0.0) );
assert( eq( xprSi.getObjCoefficients()[3], 0.0) );
assert( eq( xprSi.getObjCoefficients()[4], 2.0) );
assert( eq( xprSi.getObjCoefficients()[5], 0.0) );
assert( eq( xprSi.getObjCoefficients()[6], 0.0) );
assert( eq( xprSi.getObjCoefficients()[7], -1.0) );
}
// Test matrixByRow method
{
const OsiXprSolverInterface si(m);
const CoinPackedMatrix * smP = si.getMatrixByRow();
CoinRelFltEq eq;
const double * ev = smP->getElements();
assert( eq(ev[0], 3.0) );
assert( eq(ev[1], 1.0) );
assert( eq(ev[2], -2.0) );
assert( eq(ev[3], -1.0) );
assert( eq(ev[4], -1.0) );
assert( eq(ev[5], 2.0) );
assert( eq(ev[6], 1.1) );
assert( eq(ev[7], 1.0) );
assert( eq(ev[8], 1.0) );
assert( eq(ev[9], 2.8) );
assert( eq(ev[10], -1.2) );
assert( eq(ev[11], 5.6) );
assert( eq(ev[12], 1.0) );
assert( eq(ev[13], 1.9) );
const int * mi = smP->getVectorStarts();
assert( mi[0]==0 );
assert( mi[1]==5 );
assert( mi[2]==7 );
assert( mi[3]==9 );
assert( mi[4]==11 );
assert( mi[5]==14 );
const int * ei = smP->getIndices();
assert( ei[0] == 0 );
assert( ei[1] == 1 );
assert( ei[2] == 3 );
assert( ei[3] == 4 );
assert( ei[4] == 7 );
assert( ei[5] == 1 );
assert( ei[6] == 2 );
assert( ei[7] == 2 );
assert( ei[8] == 5 );
assert( ei[9] == 3 );
assert( ei[10] == 6 );
assert( ei[11] == 0 );
assert( ei[12] == 4 );
assert( ei[13] == 7 );
assert( smP->getMajorDim() == 5 );
assert( smP->getMinorDim() == 8 );
assert( smP->getNumElements() == 14 );
assert( smP->getSizeVectorStarts()==6 );
}
//--------------
// Test rowsense, rhs, rowrange, matrixByRow
{
OsiXprSolverInterface lhs;
{
assert( m.rowrange_==NULL );
assert( m.rowsense_==NULL );
assert( m.rhs_==NULL );
OsiXprSolverInterface siC1(m);
assert( siC1.rowrange_==NULL );
assert( siC1.rowsense_==NULL );
assert( siC1.rhs_==NULL );
const char * siC1rs = siC1.getRowSense();
assert( siC1rs[0] == 'G' );
assert( siC1rs[1] == 'L' );
assert( siC1rs[2] == 'E' );
assert( siC1rs[3] == 'R' );
assert( siC1rs[4] == 'R' );
const double * siC1rhs = siC1.getRightHandSide();
assert( eq(siC1rhs[0], 2.5) );
assert( eq(siC1rhs[1], 2.1) );
assert( eq(siC1rhs[2], 4.0) );
assert( eq(siC1rhs[3], 5.0) );
assert( eq(siC1rhs[4], 15.0) );
const double * siC1rr = siC1.getRowRange();
assert( eq(siC1rr[0], 0.0) );
assert( eq(siC1rr[1], 0.0) );
assert( eq(siC1rr[2], 0.0) );
assert( eq(siC1rr[3], 5.0 - 1.8) );
assert( eq(siC1rr[4], 15.0 - 3.0) );
const CoinPackedMatrix * siC1mbr = siC1.getMatrixByRow();
assert( siC1mbr != NULL );
const double * ev = siC1mbr->getElements();
assert( eq(ev[0], 3.0) );
assert( eq(ev[1], 1.0) );
assert( eq(ev[2], -2.0) );
assert( eq(ev[3], -1.0) );
assert( eq(ev[4], -1.0) );
assert( eq(ev[5], 2.0) );
assert( eq(ev[6], 1.1) );
assert( eq(ev[7], 1.0) );
assert( eq(ev[8], 1.0) );
assert( eq(ev[9], 2.8) );
assert( eq(ev[10], -1.2) );
assert( eq(ev[11], 5.6) );
assert( eq(ev[12], 1.0) );
assert( eq(ev[13], 1.9) );
const int * mi = siC1mbr->getVectorStarts();
assert( mi[0]==0 );
assert( mi[1]==5 );
assert( mi[2]==7 );
assert( mi[3]==9 );
assert( mi[4]==11 );
assert( mi[5]==14 );
const int * ei = siC1mbr->getIndices();
assert( ei[0] == 0 );
assert( ei[1] == 1 );
assert( ei[2] == 3 );
assert( ei[3] == 4 );
assert( ei[4] == 7 );
assert( ei[5] == 1 );
assert( ei[6] == 2 );
assert( ei[7 ] == 2 );
assert( ei[8 ] == 5 );
assert( ei[9 ] == 3 );
assert( ei[10] == 6 );
assert( ei[11] == 0 );
assert( ei[12] == 4 );
assert( ei[13] == 7 );
assert( siC1mbr->getMajorDim() == 5 );
assert( siC1mbr->getMinorDim() == 8 );
assert( siC1mbr->getNumElements() == 14 );
assert( siC1mbr->getSizeVectorStarts()==6 );
assert( siC1rs == siC1.getRowSense() );
assert( siC1rhs == siC1.getRightHandSide() );
assert( siC1rr == siC1.getRowRange() );
// Change XPRESS 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.
assert( siC1.rowrange_ == NULL );
assert( siC1.rowsense_ == NULL );
assert( siC1.rhs_ == NULL );
assert( siC1.matrixByRow_ == NULL );
siC1rs = siC1.getRowSense();
assert( siC1rs[0] == 'G' );
assert( siC1rs[1] == 'L' );
assert( siC1rs[2] == 'E' );
assert( siC1rs[3] == 'R' );
assert( siC1rs[4] == 'R' );
assert( siC1rs[5] == 'N' );
siC1rhs = siC1.getRightHandSide();
assert( eq(siC1rhs[0],2.5) );
assert( eq(siC1rhs[1],2.1) );
assert( eq(siC1rhs[2],4.0) );
assert( eq(siC1rhs[3],5.0) );
assert( eq(siC1rhs[4],15.0) );
assert( eq(siC1rhs[5],0.0) );
siC1rr = siC1.getRowRange();
assert( eq(siC1rr[0], 0.0) );
assert( eq(siC1rr[1], 0.0) );
assert( eq(siC1rr[2], 0.0) );
assert( eq(siC1rr[3], 5.0 - 1.8) );
assert( eq(siC1rr[4], 15.0 - 3.0) );
assert( eq(siC1rr[5], 0.0) );
lhs=siC1;
}
// Test that lhs has correct values even though siC1 has gone out of scope
assert( lhs.rowrange_ == NULL );
assert( lhs.rowsense_ == NULL );
assert( lhs.rhs_ == NULL );
assert( lhs.matrixByRow_ == NULL );
const char * lhsrs = lhs.getRowSense();
assert( lhsrs[0] == 'G' );
assert( lhsrs[1] == 'L' );
assert( lhsrs[2] == 'E' );
assert( lhsrs[3] == 'R' );
assert( lhsrs[4] == 'R' );
assert( lhsrs[5] == 'N' );
const double * lhsrhs = lhs.getRightHandSide();
assert( eq(lhsrhs[0], 2.5) );
assert( eq(lhsrhs[1], 2.1) );
assert( eq(lhsrhs[2], 4.0) );
assert( eq(lhsrhs[3], 5.0) );
assert( eq(lhsrhs[4], 15.0) );
assert( eq(lhsrhs[5], 0.0) );
const double *lhsrr = lhs.getRowRange();
assert( eq(lhsrr[0], 0.0) );
assert( eq(lhsrr[1], 0.0) );
assert( eq(lhsrr[2], 0.0) );
assert( eq(lhsrr[3], 5.0 - 1.8) );
assert( eq(lhsrr[4], 15.0 - 3.0) );
assert( eq(lhsrr[5], 0.0) );
const CoinPackedMatrix * lhsmbr = lhs.getMatrixByRow();
assert( lhsmbr != NULL );
const double * ev = lhsmbr->getElements();
assert( eq(ev[0], 3.0) );
assert( eq(ev[1], 1.0) );
assert( eq(ev[2], -2.0) );
assert( eq(ev[3], -1.0) );
assert( eq(ev[4], -1.0) );
assert( eq(ev[5], 2.0) );
assert( eq(ev[6], 1.1) );
assert( eq(ev[7], 1.0) );
assert( eq(ev[8], 1.0) );
assert( eq(ev[9], 2.8) );
assert( eq(ev[10], -1.2) );
assert( eq(ev[11], 5.6) );
assert( eq(ev[12], 1.0) );
assert( eq(ev[13], 1.9) );
const int * mi = lhsmbr->getVectorStarts();
assert( mi[0]==0 );
assert( mi[1]==5 );
assert( mi[2]==7 );
assert( mi[3]==9 );
assert( mi[4]==11 );
assert( mi[5]==14 );
const int * ei = lhsmbr->getIndices();
assert( ei[0] == 0 );
assert( ei[1] == 1 );
assert( ei[2] == 3 );
assert( ei[3] == 4 );
assert( ei[4] == 7 );
assert( ei[5] == 1 );
assert( ei[6] == 2 );
assert( ei[7] == 2 );
assert( ei[8] == 5 );
assert( ei[9] == 3 );
assert( ei[10] == 6 );
assert( ei[11] == 0 );
assert( ei[12] == 4 );
assert( ei[13] == 7 );
assert( lhsmbr->getMajorDim() == 6 );
assert( lhsmbr->getMinorDim() == 8 );
assert( lhsmbr->getNumElements() == 14 );
assert( lhsmbr->getSizeVectorStarts()==7 );
}
//--------------
// Test load problem
{
OsiXprSolverInterface base(m);
base.initialSolve();
assert(m.getNumRows() == base.getNumRows());
OsiXprSolverInterface si1,si2,si3,si4;
si1.loadProblem(
*base.getMatrixByCol(),
base.getColLower(),base.getColUpper(),base.getObjCoefficients(),
base.getRowSense(),base.getRightHandSide(),base.getRowRange());
si1.initialSolve();
assert(eq(base.getObjValue(), si1.getObjValue()));
assert(m.getNumRows() == si1.getNumRows());
si2.loadProblem(
*base.getMatrixByRow(),
base.getColLower(),base.getColUpper(),base.getObjCoefficients(),
base.getRowSense(),base.getRightHandSide(),base.getRowRange());
si2.initialSolve();
assert(eq(base.getObjValue(), si2.getObjValue()));
assert(m.getNumRows() == si2.getNumRows());
si3.loadProblem(
*base.getMatrixByCol(),
base.getColLower(),base.getColUpper(),base.getObjCoefficients(),
base.getRowLower(),base.getRowUpper() );
si3.initialSolve();
assert(eq(base.getObjValue(), si3.getObjValue()));
assert(m.getNumRows() == si3.getNumRows());
si4.loadProblem(
*base.getMatrixByCol(),
base.getColLower(),base.getColUpper(),base.getObjCoefficients(),
base.getRowLower(),base.getRowUpper() );
si4.initialSolve();
assert(eq(base.getObjValue(), si4.getObjValue()));
assert(m.getNumRows() == si4.getNumRows());
base.initialSolve();
si1.initialSolve();
si2.initialSolve();
si3.initialSolve();
si4.initialSolve();
// Create an indices vector
assert(base.getNumCols()<10);
assert(base.getNumRows()<10);
int indices[10];
int i;
for (i=0; i<10; i++) indices[i]=i;
// Test collower
CoinPackedVector basePv,pv;
basePv.setVector(base.getNumCols(),indices,base.getColLower());
pv.setVector( si1.getNumCols(),indices, si1.getColLower());
assert(basePv.isEquivalent(pv));
pv.setVector( si2.getNumCols(),indices, si2.getColLower());
assert(basePv.isEquivalent(pv));
pv.setVector( si3.getNumCols(),indices, si3.getColLower());
assert(basePv.isEquivalent(pv));
pv.setVector( si4.getNumCols(),indices, si4.getColLower());
assert(basePv.isEquivalent(pv));
// Test colupper
basePv.setVector(base.getNumCols(),indices,base.getColUpper());
pv.setVector( si1.getNumCols(),indices, si1.getColUpper());
assert(basePv.isEquivalent(pv));
pv.setVector( si2.getNumCols(),indices, si2.getColUpper());
assert(basePv.isEquivalent(pv));
pv.setVector( si3.getNumCols(),indices, si3.getColUpper());
assert(basePv.isEquivalent(pv));
pv.setVector( si4.getNumCols(),indices, si4.getColUpper());
assert(basePv.isEquivalent(pv));
// Test getObjCoefficients
basePv.setVector(base.getNumCols(),indices,base.getObjCoefficients());
pv.setVector( si1.getNumCols(),indices, si1.getObjCoefficients());
assert(basePv.isEquivalent(pv));
pv.setVector( si2.getNumCols(),indices, si2.getObjCoefficients());
assert(basePv.isEquivalent(pv));
pv.setVector( si3.getNumCols(),indices, si3.getObjCoefficients());
assert(basePv.isEquivalent(pv));
pv.setVector( si4.getNumCols(),indices, si4.getObjCoefficients());
assert(basePv.isEquivalent(pv));
// Test rowlower
basePv.setVector(base.getNumRows(),indices,base.getRowLower());
pv.setVector( si1.getNumRows(),indices, si1.getRowLower());
assert( eq(base.getRowLower()[3],si1.getRowLower()[3]) );
assert(basePv.isEquivalent(pv));
pv.setVector( si2.getNumRows(),indices, si2.getRowLower());
assert(basePv.isEquivalent(pv));
pv.setVector( si3.getNumRows(),indices, si3.getRowLower());
assert(basePv.isEquivalent(pv));
pv.setVector( si4.getNumRows(),indices, si4.getRowLower());
assert(basePv.isEquivalent(pv));
// Test rowupper
basePv.setVector(base.getNumRows(),indices,base.getRowUpper());
pv.setVector( si1.getNumRows(),indices, si1.getRowUpper());
assert(basePv.isEquivalent(pv));
pv.setVector( si2.getNumRows(),indices, si2.getRowUpper());
assert(basePv.isEquivalent(pv));
pv.setVector( si3.getNumRows(),indices, si3.getRowUpper());
assert(basePv.isEquivalent(pv));
pv.setVector( si4.getNumRows(),indices, si4.getRowUpper());
assert(basePv.isEquivalent(pv));
// Test Constraint Matrix
assert( base.getMatrixByCol()->isEquivalent(*si1.getMatrixByCol()) );
assert( base.getMatrixByRow()->isEquivalent(*si1.getMatrixByRow()) );
assert( base.getMatrixByCol()->isEquivalent(*si2.getMatrixByCol()) );
assert( base.getMatrixByRow()->isEquivalent(*si2.getMatrixByRow()) );
assert( base.getMatrixByCol()->isEquivalent(*si3.getMatrixByCol()) );
assert( base.getMatrixByRow()->isEquivalent(*si3.getMatrixByRow()) );
assert( base.getMatrixByCol()->isEquivalent(*si4.getMatrixByCol()) );
assert( base.getMatrixByRow()->isEquivalent(*si4.getMatrixByRow()) );
// Test Objective Value
assert( eq(base.getObjValue(),si1.getObjValue()) );
assert( eq(base.getObjValue(),si2.getObjValue()) );
assert( eq(base.getObjValue(),si3.getObjValue()) );
assert( eq(base.getObjValue(),si4.getObjValue()) );
}
//--------------
assert(OsiXprSolverInterface::getNumInstances()==1);
}
assert(OsiXprSolverInterface::getNumInstances()==0);
// Do common solverInterface testing by calling the
// base class testing method.
{
OsiXprSolverInterface m;
OsiSolverInterfaceCommonUnitTest(&m, mpsDir,netlibDir);
}
}
