00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013 #if defined(_MSC_VER)
00014
00015 # pragma warning(disable:4786)
00016 #endif
00017
00018 #include <cassert>
00019 #include <iostream>
00020
00021 #include <string>
00022
00023 #include "OsiCpxSolverInterface.hpp"
00024 #include "OsiCuts.hpp"
00025 #include "OsiRowCut.hpp"
00026 #include "OsiColCut.hpp"
00027 #include "CoinPackedMatrix.hpp"
00028
00029 #ifdef NDEBUG
00030 #undef NDEBUG
00031 #endif
00032
00033 void OsiCpxSolverInterface::printBounds()
00034 {
00035 int nc = getNumCols();
00036 int nr = getNumRows();
00037 const char * s = getRowSense();
00038 const double * b = getRightHandSide();
00039 const double * rng = getRowRange();
00040 const double * cl = getColLower();
00041 const double * cu = getColUpper();
00042 const double * rl = getRowLower();
00043 const double * ru = getRowUpper();
00044
00045 std::cout << "ncols=" << nc << ", nrows=" << nr;
00046 std::cout << std::endl << "sns=";
00047 int i;
00048 for( i = 0; i < nr; ++i )
00049 std::cout << " " << s[i];
00050 std::cout << std::endl << "rhs=";
00051 for( i = 0; i < nr; ++i )
00052 std::cout << " " << b[i];
00053 std::cout << std::endl << "rng=";
00054 for( i = 0; i < nr; ++i )
00055 std::cout << " " << rng[i];
00056 std::cout << std::endl << "cl =";
00057 for( i = 0; i < nc; ++i )
00058 std::cout << " " << cl[i];
00059 std::cout << std::endl << "cu =";
00060 for( i = 0; i < nc; ++i )
00061 std::cout << " " << cu[i];
00062 std::cout << std::endl << "rl =";
00063 for( i = 0; i < nr; ++i )
00064 std::cout << " " << rl[i];
00065 std::cout << std::endl << "ru =";
00066 for( i = 0; i < nr; ++i )
00067 std::cout << " " << ru[i];
00068 std::cout << std::endl;
00069 }
00070
00071
00072 void OsiCpxSolverInterfaceUnitTest( const std::string & mpsDir, const std::string & netlibDir )
00073 {
00074
00075 {
00076 assert( OsiCpxSolverInterface::getNumInstances()==0 );
00077 OsiCpxSolverInterface m;
00078 assert( m.obj_==NULL );
00079 assert( m.collower_==NULL );
00080 assert( m.colupper_==NULL );
00081 assert( m.coltype_==NULL );
00082 assert( m.rowsense_==NULL );
00083 assert( m.rhs_==NULL );
00084 assert( m.rowrange_==NULL );
00085 assert( m.rowlower_==NULL );
00086 assert( m.rowupper_==NULL );
00087 assert( m.colsol_==NULL );
00088 assert( m.rowsol_==NULL );
00089 assert( m.matrixByRow_==NULL );
00090 assert( m.matrixByCol_==NULL );
00091 assert( m.coltype_==NULL );
00092 assert( m.coltypesize_==0 );
00093 assert( OsiCpxSolverInterface::getNumInstances()==1 );
00094 assert( m.getApplicationData() == NULL );
00095 int i=2346;
00096 m.setApplicationData(&i);
00097 assert( *((int *)(m.getApplicationData())) == i );
00098 }
00099 assert( OsiCpxSolverInterface::getNumInstances()==0 );
00100
00101 {
00102 CoinRelFltEq eq;
00103 OsiCpxSolverInterface m;
00104 assert( OsiCpxSolverInterface::getNumInstances()==1 );
00105 std::string fn = mpsDir+"exmip1";
00106 m.readMps(fn.c_str(),"mps");
00107 int ad = 13579;
00108 m.setApplicationData(&ad);
00109 assert( *((int *)(m.getApplicationData())) == ad );
00110
00111 {
00112 assert( m.getNumCols()==8 );
00113 const CoinPackedMatrix * colCopy = m.getMatrixByCol();
00114 assert( colCopy->getNumCols() == 8 );
00115 assert( colCopy->getMajorDim() == 8 );
00116 assert( colCopy->getNumRows() == 5 );
00117 assert( colCopy->getMinorDim() == 5 );
00118 assert (colCopy->getVectorLengths()[7] == 2 );
00119 CoinPackedMatrix revColCopy;
00120 revColCopy.reverseOrderedCopyOf(*colCopy);
00121 CoinPackedMatrix rev2ColCopy;
00122 rev2ColCopy.reverseOrderedCopyOf(revColCopy);
00123 assert( rev2ColCopy.getNumCols() == 8 );
00124 assert( rev2ColCopy.getMajorDim() == 8 );
00125 assert( rev2ColCopy.getNumRows() == 5 );
00126 assert( rev2ColCopy.getMinorDim() == 5 );
00127 assert( rev2ColCopy.getVectorLengths()[7] == 2 );
00128 }
00129
00130 {
00131 OsiCpxSolverInterface im;
00132 assert( im.getNumCols() == 0 );
00133 }
00134
00135
00136 {
00137 OsiCpxSolverInterface lhs;
00138 {
00139 assert( *((int *)(m.getApplicationData())) == ad );
00140 OsiCpxSolverInterface im(m);
00141 assert( *((int *)(im.getApplicationData())) == ad );
00142
00143 OsiCpxSolverInterface imC1(im);
00144 assert( imC1.lp_ != im.lp_ );
00145 assert( imC1.getNumCols() == im.getNumCols() );
00146 assert( imC1.getNumRows() == im.getNumRows() );
00147 assert( *((int *)(imC1.getApplicationData())) == ad );
00148
00149
00150
00151 OsiCpxSolverInterface imC2(im);
00152 assert( imC2.lp_ != im.lp_ );
00153 assert( imC2.getNumCols() == im.getNumCols() );
00154 assert( imC2.getNumRows() == im.getNumRows() );
00155 assert( *((int *)(imC2.getApplicationData())) == ad );
00156
00157 assert( imC2.lp_ != imC1.lp_ );
00158
00159 lhs=imC2;
00160 }
00161
00162
00163 assert( lhs.lp_ != m.lp_ );
00164 assert( lhs.getNumCols() == m.getNumCols() );
00165 assert( lhs.getNumRows() == m.getNumRows() );
00166 assert( *((int *)(lhs.getApplicationData())) == ad );
00167 }
00168
00169
00170 {
00171 OsiCpxSolverInterface cplexSi(m);
00172 OsiSolverInterface * siPtr = &cplexSi;
00173 OsiSolverInterface * siClone = siPtr->clone();
00174 OsiCpxSolverInterface * cplexClone = dynamic_cast<OsiCpxSolverInterface*>(siClone);
00175 assert( cplexClone != NULL );
00176 assert( cplexClone->lp_ != cplexSi.lp_ );
00177 assert( cplexClone->getNumRows() == cplexSi.getNumRows() );
00178 assert( cplexClone->getNumCols() == m.getNumCols() );
00179
00180 assert( *((int *)(cplexClone->getApplicationData())) == ad );
00181 delete siClone;
00182 }
00183
00184
00185 {
00186 OsiCpxSolverInterface si;
00187 assert( eq( si.getInfinity(), CPX_INFBOUND ) );
00188 }
00189
00190
00191 {
00192 OsiCpxSolverInterface m1(m);
00193 int i;
00194
00195 double * cs = new double[m1.getNumCols()];
00196 for ( i = 0; i < m1.getNumCols(); i++ )
00197 cs[i] = i + .5;
00198 m1.setColSolution(cs);
00199 for ( i = 0; i < m1.getNumCols(); i++ )
00200 assert(m1.getColSolution()[i] == i + .5);
00201
00202 double * rs = new double[m1.getNumRows()];
00203 for ( i = 0; i < m1.getNumRows(); i++ )
00204 rs[i] = i - .5;
00205 m1.setRowPrice(rs);
00206 for ( i = 0; i < m1.getNumRows(); i++ )
00207 assert(m1.getRowPrice()[i] == i - .5);
00208
00209 delete [] cs;
00210 delete [] rs;
00211 }
00212
00213
00214
00215 {
00216 OsiCpxSolverInterface fim;
00217 std::string fn = mpsDir+"exmip1";
00218 fim.readMps(fn.c_str(),"mps");
00219
00220
00221 assert( fim.isContinuous(0) );
00222 assert( fim.isContinuous(1) );
00223 assert( !fim.isContinuous(2) );
00224 assert( !fim.isContinuous(3) );
00225 assert( fim.isContinuous(4) );
00226
00227 assert( !fim.isInteger(0) );
00228 assert( !fim.isInteger(1) );
00229 assert( fim.isInteger(2) );
00230 assert( fim.isInteger(3) );
00231 assert( !fim.isInteger(4) );
00232
00233 assert( !fim.isBinary(0) );
00234 assert( !fim.isBinary(1) );
00235 assert( fim.isBinary(2) );
00236 assert( fim.isBinary(3) );
00237 assert( !fim.isBinary(4) );
00238
00239 assert( !fim.isIntegerNonBinary(0) );
00240 assert( !fim.isIntegerNonBinary(1) );
00241 assert( !fim.isIntegerNonBinary(2) );
00242 assert( !fim.isIntegerNonBinary(3) );
00243 assert( !fim.isIntegerNonBinary(4) );
00244
00245
00246
00247 {
00248
00249 double * cs = new double[fim.getNumCols()];
00250 for ( int i = 0; i < fim.getNumCols(); cs[i++] = 0.0 );
00251 cs[2] = 2.9;
00252 cs[3] = 3.0;
00253 fim.setColSolution(cs);
00254
00255 OsiVectorInt fi = fim.getFractionalIndices();
00256 assert( fi.size() == 1 );
00257 assert( fi[0]==2 );
00258
00259
00260 cs[2] = 5 + .00001/2.;
00261 cs[3] = 8 - .00001/2.;
00262 fim.setColSolution(cs);
00263 fi = fim.getFractionalIndices(1e-5);
00264 assert( fi.size() == 0 );
00265
00266
00267 cs[2] = 5 + .00001*2.;
00268 cs[3] = 8 - .00001*2.;
00269 fim.setColSolution(cs);
00270 fi = fim.getFractionalIndices(1e-5);
00271 assert( fi.size() == 2 );
00272 assert( fi[0]==2 );
00273 assert( fi[1]==3 );
00274
00275 delete [] cs;
00276 }
00277
00278
00279 fim.setColUpper(2, 5);
00280 fim.setColUpper(3, 6.0);
00281 assert( !fim.isBinary(0) );
00282 assert( !fim.isBinary(1) );
00283 assert( !fim.isBinary(2) );
00284 assert( !fim.isBinary(3) );
00285 assert( !fim.isBinary(4) );
00286
00287 assert( !fim.isIntegerNonBinary(0) );
00288 assert( !fim.isIntegerNonBinary(1) );
00289 assert( fim.isIntegerNonBinary(2) );
00290 assert( fim.isIntegerNonBinary(3) );
00291 assert( !fim.isIntegerNonBinary(4) );
00292 }
00293
00294
00295 {
00296 OsiCpxSolverInterface im(m);
00297 OsiCuts cuts;
00298
00299
00300 {
00301
00302 int nr=im.getNumRows();
00303 int nc=im.getNumCols();
00304 assert( nr == 5 );
00305 assert( nc == 8 );
00306
00307
00308 int c;
00309 {
00310 int *inx = new int[nc];
00311 for (c=0;c<nc;c++) inx[c]=c;
00312 double *el = new double[nc];
00313 for (c=0;c<nc;c++) el[c]=((double)c)*((double)c);
00314
00315 OsiRowCut rc;
00316 rc.setRow(nc,inx,el);
00317 rc.setLb(-100.);
00318 rc.setUb(100.);
00319 rc.setEffectiveness(22);
00320
00321 cuts.insert(rc);
00322 delete[]el;
00323 delete[]inx;
00324 }
00325
00326
00327 {
00328 const double * cplexColLB = im.getColLower();
00329 const double * cplexColUB = im.getColUpper();
00330 int *inx = new int[nc];
00331 for (c=0;c<nc;c++) inx[c]=c;
00332 double *lb = new double[nc];
00333 double *ub = new double[nc];
00334 for (c=0;c<nc;c++) lb[c]=cplexColLB[c]+0.001;
00335 for (c=0;c<nc;c++) ub[c]=cplexColUB[c]-0.001;
00336
00337 OsiColCut cc;
00338 cc.setLbs(nc,inx,lb);
00339 cc.setUbs(nc,inx,ub);
00340
00341 cuts.insert(cc);
00342 delete [] ub;
00343 delete [] lb;
00344 delete [] inx;
00345 }
00346
00347 {
00348
00349 OsiRowCut * rcP= new OsiRowCut;
00350 rcP->setEffectiveness(-1.);
00351 cuts.insert(rcP);
00352 assert(rcP==NULL);
00353
00354 OsiColCut * ccP= new OsiColCut;
00355 ccP->setEffectiveness(-12.);
00356 cuts.insert(ccP);
00357 assert(ccP==NULL);
00358 }
00359 {
00360
00361 OsiRowCut rc;
00362 const int ne=1;
00363 int inx[ne]={-10};
00364 double el[ne]={2.5};
00365 rc.setRow(ne,inx,el);
00366 rc.setLb(3.);
00367 rc.setUb(4.);
00368 assert(!rc.consistent());
00369 cuts.insert(rc);
00370 }
00371 {
00372
00373 OsiColCut cc;
00374 const int ne=1;
00375 int inx[ne]={-10};
00376 double el[ne]={2.5};
00377 cc.setUbs(ne,inx,el);
00378 assert(!cc.consistent());
00379 cuts.insert(cc);
00380 }
00381 {
00382
00383 OsiRowCut rc;
00384 const int ne=1;
00385 int inx[ne]={10};
00386 double el[ne]={2.5};
00387 rc.setRow(ne,inx,el);
00388 assert(rc.consistent());
00389 assert(!rc.consistent(im));
00390 cuts.insert(rc);
00391 }
00392 {
00393
00394 OsiColCut cc;
00395 const int ne=1;
00396 int inx[ne]={30};
00397 double el[ne]={2.0};
00398 cc.setLbs(ne,inx,el);
00399 assert(cc.consistent());
00400 assert(!cc.consistent(im));
00401 cuts.insert(cc);
00402 }
00403 {
00404
00405 OsiColCut cc;
00406 const int ne=1;
00407 int inx[ne]={0};
00408 double el[ne]={2.0};
00409 cc.setUbs(ne,inx,el);
00410 cc.setEffectiveness(1000.);
00411 assert(cc.consistent());
00412 assert(cc.consistent(im));
00413 assert(cc.infeasible(im));
00414 cuts.insert(cc);
00415 }
00416 }
00417 assert(cuts.sizeRowCuts()==4);
00418 assert(cuts.sizeColCuts()==5);
00419
00420 OsiSolverInterface::ApplyCutsReturnCode rc = im.applyCuts(cuts);
00421 assert( rc.getNumIneffective() == 2 );
00422 assert( rc.getNumApplied() == 2 );
00423 assert( rc.getNumInfeasible() == 1 );
00424 assert( rc.getNumInconsistentWrtIntegerModel() == 2 );
00425 assert( rc.getNumInconsistent() == 2 );
00426 assert( cuts.sizeCuts() == rc.getNumIneffective() +
00427 rc.getNumApplied() +
00428 rc.getNumInfeasible() +
00429 rc.getNumInconsistentWrtIntegerModel() +
00430 rc.getNumInconsistent() );
00431 }
00432 {
00433 OsiCpxSolverInterface cplexSi(m);
00434 int nc = cplexSi.getNumCols();
00435 int nr = cplexSi.getNumRows();
00436 const double * cl = cplexSi.getColLower();
00437 const double * cu = cplexSi.getColUpper();
00438 const double * rl = cplexSi.getRowLower();
00439 const double * ru = cplexSi.getRowUpper();
00440
00441 assert( nc == 8 );
00442 assert( nr == 5 );
00443 assert( eq(cl[0],2.5) );
00444 assert( eq(cl[1],0.0) );
00445 assert( eq(cu[1],4.1) );
00446 assert( eq(cu[2],1.0) );
00447
00448 assert( eq(rl[0],2.5) );
00449 assert( eq(rl[4],3.0) );
00450 assert( eq(ru[1],2.1) );
00451 assert( eq(ru[4],15.0) );
00452
00453 double newCs[8] = {1., 2., 3., 4., 5., 6., 7., 8.};
00454 cplexSi.setColSolution(newCs);
00455 const double * cs = cplexSi.getColSolution();
00456 assert( eq(cs[0],1.0) );
00457 assert( eq(cs[7],8.0) );
00458 {
00459 OsiCpxSolverInterface solnSi(cplexSi);
00460 const double * cs = solnSi.getColSolution();
00461 assert( eq(cs[0],1.0) );
00462 assert( eq(cs[7],8.0) );
00463 }
00464
00465 assert( !eq(cl[3],1.2345) );
00466 cplexSi.setColLower( 3, 1.2345 );
00467 assert( eq(cplexSi.getColLower()[3],1.2345) );
00468
00469 assert( !eq(cu[4],10.2345) );
00470 cplexSi.setColUpper( 4, 10.2345 );
00471 assert( eq(cplexSi.getColUpper()[4],10.2345) );
00472
00473 assert( eq(cplexSi.getObjValue(),0.0) );
00474
00475 assert( eq( cplexSi.getObjCoefficients()[0], 1.0) );
00476 assert( eq( cplexSi.getObjCoefficients()[1], 0.0) );
00477 assert( eq( cplexSi.getObjCoefficients()[2], 0.0) );
00478 assert( eq( cplexSi.getObjCoefficients()[3], 0.0) );
00479 assert( eq( cplexSi.getObjCoefficients()[4], 2.0) );
00480 assert( eq( cplexSi.getObjCoefficients()[5], 0.0) );
00481 assert( eq( cplexSi.getObjCoefficients()[6], 0.0) );
00482 assert( eq( cplexSi.getObjCoefficients()[7], -1.0) );
00483 }
00484
00485
00486 {
00487 const OsiCpxSolverInterface si(m);
00488 const CoinPackedMatrix * smP = si.getMatrixByRow();
00489
00490
00491
00492 CoinRelFltEq eq;
00493 const double * ev = smP->getElements();
00494 assert( eq(ev[0], 3.0) );
00495 assert( eq(ev[1], 1.0) );
00496 assert( eq(ev[2], -2.0) );
00497 assert( eq(ev[3], -1.0) );
00498 assert( eq(ev[4], -1.0) );
00499 assert( eq(ev[5], 2.0) );
00500 assert( eq(ev[6], 1.1) );
00501 assert( eq(ev[7], 1.0) );
00502 assert( eq(ev[8], 1.0) );
00503 assert( eq(ev[9], 2.8) );
00504 assert( eq(ev[10], -1.2) );
00505 assert( eq(ev[11], 5.6) );
00506 assert( eq(ev[12], 1.0) );
00507 assert( eq(ev[13], 1.9) );
00508
00509 const int * mi = smP->getVectorStarts();
00510 assert( mi[0]==0 );
00511 assert( mi[1]==5 );
00512 assert( mi[2]==7 );
00513 assert( mi[3]==9 );
00514 assert( mi[4]==11 );
00515 assert( mi[5]==14 );
00516
00517 const int * ei = smP->getIndices();
00518 assert( ei[0] == 0 );
00519 assert( ei[1] == 1 );
00520 assert( ei[2] == 3 );
00521 assert( ei[3] == 4 );
00522 assert( ei[4] == 7 );
00523 assert( ei[5] == 1 );
00524 assert( ei[6] == 2 );
00525 assert( ei[7] == 2 );
00526 assert( ei[8] == 5 );
00527 assert( ei[9] == 3 );
00528 assert( ei[10] == 6 );
00529 assert( ei[11] == 0 );
00530 assert( ei[12] == 4 );
00531 assert( ei[13] == 7 );
00532
00533 assert( smP->getMajorDim() == 5 );
00534 assert( smP->getNumElements() == 14 );
00535
00536 }
00537
00538
00539 {
00540 OsiCpxSolverInterface lhs;
00541 {
00542 #if 0
00543 assert( m.obj_==NULL );
00544 assert( m.collower_==NULL );
00545 assert( m.colupper_==NULL );
00546 assert( m.rowrange_==NULL );
00547 assert( m.rowsense_==NULL );
00548 assert( m.rhs_==NULL );
00549 assert( m.rowlower_==NULL );
00550 assert( m.rowupper_==NULL );
00551 assert( m.colsol_==NULL );
00552 assert( m.rowsol_==NULL );
00553 assert( m.getMatrixByRow_==NULL );
00554 #endif
00555
00556 OsiCpxSolverInterface siC1(m);
00557 assert( siC1.obj_==NULL );
00558 assert( siC1.collower_==NULL );
00559 assert( siC1.colupper_==NULL );
00560
00561 assert( siC1.rowrange_==NULL );
00562 assert( siC1.rowsense_==NULL );
00563 assert( siC1.rhs_==NULL );
00564 assert( siC1.rowlower_==NULL );
00565 assert( siC1.rowupper_==NULL );
00566 assert( siC1.colsol_!=NULL );
00567 assert( siC1.rowsol_!=NULL );
00568 assert( siC1.matrixByRow_==NULL );
00569
00570 const char * siC1rs = siC1.getRowSense();
00571 assert( siC1rs[0]=='G' );
00572 assert( siC1rs[1]=='L' );
00573 assert( siC1rs[2]=='E' );
00574 assert( siC1rs[3]=='R' );
00575 assert( siC1rs[4]=='R' );
00576
00577 const double * siC1rhs = siC1.getRightHandSide();
00578 assert( eq(siC1rhs[0],2.5) );
00579 assert( eq(siC1rhs[1],2.1) );
00580 assert( eq(siC1rhs[2],4.0) );
00581 assert( eq(siC1rhs[3],5.0) );
00582 assert( eq(siC1rhs[4],15.) );
00583
00584 const double * siC1rr = siC1.getRowRange();
00585 assert( eq(siC1rr[0],0.0) );
00586 assert( eq(siC1rr[1],0.0) );
00587 assert( eq(siC1rr[2],0.0) );
00588 assert( eq(siC1rr[3],5.0-1.8) );
00589 assert( eq(siC1rr[4],15.0-3.0) );
00590
00591 const CoinPackedMatrix * siC1mbr = siC1.getMatrixByRow();
00592 assert( siC1mbr != NULL );
00593
00594 const double * ev = siC1mbr->getElements();
00595 assert( eq(ev[0], 3.0) );
00596 assert( eq(ev[1], 1.0) );
00597 assert( eq(ev[2], -2.0) );
00598 assert( eq(ev[3], -1.0) );
00599 assert( eq(ev[4], -1.0) );
00600 assert( eq(ev[5], 2.0) );
00601 assert( eq(ev[6], 1.1) );
00602 assert( eq(ev[7], 1.0) );
00603 assert( eq(ev[8], 1.0) );
00604 assert( eq(ev[9], 2.8) );
00605 assert( eq(ev[10], -1.2) );
00606 assert( eq(ev[11], 5.6) );
00607 assert( eq(ev[12], 1.0) );
00608 assert( eq(ev[13], 1.9) );
00609
00610 const int * mi = siC1mbr->getVectorStarts();
00611 assert( mi[0]==0 );
00612 assert( mi[1]==5 );
00613 assert( mi[2]==7 );
00614 assert( mi[3]==9 );
00615 assert( mi[4]==11 );
00616 assert( mi[5]==14 );
00617
00618 const int * ei = siC1mbr->getIndices();
00619 assert( ei[0] == 0 );
00620 assert( ei[1] == 1 );
00621 assert( ei[2] == 3 );
00622 assert( ei[3] == 4 );
00623 assert( ei[4] == 7 );
00624 assert( ei[5] == 1 );
00625 assert( ei[6] == 2 );
00626 assert( ei[7] == 2 );
00627 assert( ei[8] == 5 );
00628 assert( ei[9] == 3 );
00629 assert( ei[10] == 6 );
00630 assert( ei[11] == 0 );
00631 assert( ei[12] == 4 );
00632 assert( ei[13] == 7 );
00633
00634 assert( siC1mbr->getMajorDim() == 5 );
00635 assert( siC1mbr->getNumElements() == 14 );
00636
00637
00638 assert( siC1rs == siC1.getRowSense() );
00639 assert( siC1rhs == siC1.getRightHandSide() );
00640 assert( siC1rr == siC1.getRowRange() );
00641
00642
00643 OsiRowCut rc;
00644 rc.setLb(-DBL_MAX);
00645 rc.setUb( DBL_MAX);
00646 OsiCuts cuts;
00647 cuts.insert(rc);
00648 siC1.applyCuts(cuts);
00649
00650
00651
00652 assert( siC1.obj_==NULL );
00653 assert( siC1.collower_==NULL );
00654 assert( siC1.colupper_==NULL );
00655
00656 assert( siC1.rowrange_==NULL );
00657 assert( siC1.rowsense_==NULL );
00658 assert( siC1.rhs_==NULL );
00659 assert( siC1.rowlower_==NULL );
00660 assert( siC1.rowupper_==NULL );
00661 assert( siC1.colsol_==NULL );
00662 assert( siC1.rowsol_==NULL );
00663 assert( siC1.matrixByRow_==NULL );
00664
00665 siC1rs = siC1.getRowSense();
00666 siC1rhs = siC1.getRightHandSide();
00667 siC1rr = siC1.getRowRange();
00668
00669 assert( siC1rs[0]=='G' );
00670 assert( siC1rs[1]=='L' );
00671 assert( siC1rs[2]=='E' );
00672 assert( siC1rs[3]=='R' );
00673 assert( siC1rs[4]=='R' );
00674 assert( siC1rs[5]=='N' );
00675
00676 assert( eq(siC1rhs[0],2.5) );
00677 assert( eq(siC1rhs[1],2.1) );
00678 assert( eq(siC1rhs[2],4.0) );
00679 assert( eq(siC1rhs[3],5.0) );
00680 assert( eq(siC1rhs[4],15.) );
00681 assert( eq(siC1rhs[5],0.0) );
00682
00683 assert( eq(siC1rr[0],0.0) );
00684 assert( eq(siC1rr[1],0.0) );
00685 assert( eq(siC1rr[2],0.0) );
00686 assert( eq(siC1rr[3],5.0-1.8) );
00687 assert( eq(siC1rr[4],15.0-3.0) );
00688 assert( eq(siC1rr[5],0.0) );
00689
00690 lhs=siC1;
00691 }
00692
00693 assert( lhs.obj_==NULL );
00694 assert( lhs.collower_==NULL );
00695 assert( lhs.colupper_==NULL );
00696
00697 assert( lhs.rowrange_==NULL );
00698 assert( lhs.rowsense_==NULL );
00699 assert( lhs.rhs_==NULL );
00700 assert( lhs.rowlower_==NULL );
00701 assert( lhs.rowupper_==NULL );
00702 assert( lhs.colsol_!=NULL );
00703 assert( lhs.rowsol_!=NULL );
00704 assert( lhs.matrixByRow_==NULL );
00705
00706 const char * lhsrs = lhs.getRowSense();
00707 assert( lhsrs[0]=='G' );
00708 assert( lhsrs[1]=='L' );
00709 assert( lhsrs[2]=='E' );
00710 assert( lhsrs[3]=='R' );
00711 assert( lhsrs[4]=='R' );
00712 assert( lhsrs[5]=='N' );
00713
00714 const double * lhsrhs = lhs.getRightHandSide();
00715 assert( eq(lhsrhs[0],2.5) );
00716 assert( eq(lhsrhs[1],2.1) );
00717 assert( eq(lhsrhs[2],4.0) );
00718 assert( eq(lhsrhs[3],5.0) );
00719 assert( eq(lhsrhs[4],15.) );
00720 assert( eq(lhsrhs[5],0.0) );
00721
00722 const double *lhsrr = lhs.getRowRange();
00723 assert( eq(lhsrr[0],0.0) );
00724 assert( eq(lhsrr[1],0.0) );
00725 assert( eq(lhsrr[2],0.0) );
00726 assert( eq(lhsrr[3],5.0-1.8) );
00727 assert( eq(lhsrr[4],15.0-3.0) );
00728 assert( eq(lhsrr[5],0.0) );
00729
00730 const CoinPackedMatrix * lhsmbr = lhs.getMatrixByRow();
00731 assert( lhsmbr != NULL );
00732 const double * ev = lhsmbr->getElements();
00733 assert( eq(ev[0], 3.0) );
00734 assert( eq(ev[1], 1.0) );
00735 assert( eq(ev[2], -2.0) );
00736 assert( eq(ev[3], -1.0) );
00737 assert( eq(ev[4], -1.0) );
00738 assert( eq(ev[5], 2.0) );
00739 assert( eq(ev[6], 1.1) );
00740 assert( eq(ev[7], 1.0) );
00741 assert( eq(ev[8], 1.0) );
00742 assert( eq(ev[9], 2.8) );
00743 assert( eq(ev[10], -1.2) );
00744 assert( eq(ev[11], 5.6) );
00745 assert( eq(ev[12], 1.0) );
00746 assert( eq(ev[13], 1.9) );
00747
00748 const int * mi = lhsmbr->getVectorStarts();
00749 assert( mi[0]==0 );
00750 assert( mi[1]==5 );
00751 assert( mi[2]==7 );
00752 assert( mi[3]==9 );
00753 assert( mi[4]==11 );
00754 assert( mi[5]==14 );
00755
00756 const int * ei = lhsmbr->getIndices();
00757 assert( ei[0] == 0 );
00758 assert( ei[1] == 1 );
00759 assert( ei[2] == 3 );
00760 assert( ei[3] == 4 );
00761 assert( ei[4] == 7 );
00762 assert( ei[5] == 1 );
00763 assert( ei[6] == 2 );
00764 assert( ei[7] == 2 );
00765 assert( ei[8] == 5 );
00766 assert( ei[9] == 3 );
00767 assert( ei[10] == 6 );
00768 assert( ei[11] == 0 );
00769 assert( ei[12] == 4 );
00770 assert( ei[13] == 7 );
00771
00772 int md = lhsmbr->getMajorDim();
00773 assert( md == 6 );
00774 assert( lhsmbr->getNumElements() == 14 );
00775 }
00776
00777
00778
00779 assert(OsiCpxSolverInterface::getNumInstances()==1);
00780 }
00781 assert(OsiCpxSolverInterface::getNumInstances()==0);
00782
00783
00784
00785
00786 {
00787 OsiCpxSolverInterface m;
00788 OsiSolverInterfaceCommonUnitTest(&m, mpsDir,netlibDir);
00789 }
00790 }