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