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