00001
00002
00003
00004 #if defined(_MSC_VER)
00005
00006 # pragma warning(disable:4786)
00007 #endif
00008
00009 #include <cassert>
00010
00011 #include "OsiFloatEqual.hpp"
00012 #include "OsiPackedVector.hpp"
00013 #include "OsiPackedMatrix.hpp"
00014
00015
00016
00017 #ifdef NDEBUG
00018 #undef NDEBUG
00019 #endif
00020
00021 void
00022 OsiPackedMatrixUnitTest()
00023 {
00024
00025 OsiRelFltEq eq;
00026
00027 {
00028
00029 OsiPackedMatrix m;
00030 OsiPackedMatrix lhs = m;
00031 OsiPackedMatrix mCopy(m);
00032
00033 assert( eq(m.getExtraGap(),.25) );
00034 assert( eq(lhs.getExtraGap(),.25) );
00035 assert( eq(mCopy.getExtraGap(),.25) );
00036
00037 assert( eq(m.getExtraMajor(),.25) );
00038 assert( eq(lhs.getExtraMajor(),.25) );
00039 assert( eq(mCopy.getExtraMajor(),.25) );
00040
00041 assert( m.isColOrdered() );
00042 assert( lhs.isColOrdered() );
00043 assert( mCopy.isColOrdered() );
00044
00045 assert( m.getNumElements() == 0 );
00046 assert( lhs.getNumElements() == 0 );
00047 assert( mCopy.getNumElements() == 0 );
00048
00049 assert( m.getNumCols() == 0 );
00050 assert( lhs.getNumCols() == 0 );
00051 assert( mCopy.getNumCols() == 0 );
00052
00053 assert( m.getNumRows() == 0 );
00054 assert( lhs.getNumRows() == 0 );
00055 assert( mCopy.getNumRows() == 0 );
00056
00057 assert( m.getElements() == 0 );
00058 assert( lhs.getElements() == 0 );
00059 assert( mCopy.getElements() == 0 );
00060
00061 assert( m.getIndices() == 0 );
00062 assert( lhs.getIndices() == 0 );
00063 assert( mCopy.getIndices() == 0 );
00064
00065 assert( m.getSizeVectorStarts()==0 );
00066 assert( lhs.getSizeVectorStarts()==0 );
00067 assert( mCopy.getSizeVectorStarts()==0 );
00068
00069 assert( m.getSizeVectorLengths()==0 );
00070 assert( lhs.getSizeVectorLengths()==0 );
00071 assert( mCopy.getSizeVectorLengths()==0 );
00072
00073 assert( m.getVectorStarts()==NULL );
00074 assert( lhs.getVectorStarts()==NULL );
00075 assert( mCopy.getVectorStarts()==NULL );
00076
00077 assert( m.getVectorLengths()==NULL );
00078 assert( lhs.getVectorLengths()==NULL );
00079 assert( mCopy.getVectorLengths()==NULL );
00080
00081 assert( m.getMajorDim() == 0 );
00082 assert( lhs.getMajorDim() == 0 );
00083 assert( mCopy.getMajorDim() == 0 );
00084
00085 assert( m.getMinorDim() == 0 );
00086 assert( lhs.getMinorDim() == 0 );
00087 assert( mCopy.getMinorDim() == 0 );
00088
00089 }
00090
00091
00092 {
00093 OsiPackedMatrix * globalP;
00094
00095 {
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106 #if 0
00107
00108 const int minor=5;
00109 const int major=8;
00110 const int numels=14;
00111 const double elemBase[numels]={3., 5.6, 1., 2., 1.1, 1., -2., 2.8, -1., 1., 1., -1.2, -1., 1.9};
00112 const int indBase[numels]={0,4,0,1,1,2,0,3,0,4,2,3,0,4};
00113 const int startsBase[major+1]={0,2,4,6,8,10,11,12,14};
00114 const int lenBase[major]={2,2,2,2,2,1,1,2};
00115 #else
00116
00117 const int minor=8;
00118 const int major=5;
00119 const int numels=14;
00120 const double elemBase[numels]={3., 1., -2., -1., -1., 2., 1.1, 1., 1., 2.8, -1.2, 5.6, 1., 1.9 };
00121 const int indBase[numels]={0,1,3,4,7,1,2,2,5,3,6,0,4,7};
00122 const int startsBase[major+1]={0,5,7,9,11,14};
00123 const int lenBase[major]={5,2,2,2,3};
00124 #endif
00125 double * elem = new double[numels];
00126 int * ind = new int[numels];
00127 int * starts = new int[major+1];
00128 int * lens = new int[major];
00129 std::copy(elemBase,elemBase+numels,elem);
00130 std::copy(indBase,indBase+numels,ind);
00131 std::copy(startsBase,startsBase+major+1,starts);
00132 std::copy(lenBase,lenBase+major,lens);
00133
00134 OsiPackedMatrix pm(false,minor,major,numels,elem,ind,starts,lens,
00135 .25,.25);
00136
00137 assert( elem!=NULL );
00138 assert( ind!=NULL );
00139 assert( starts!=NULL );
00140 assert( lens!=NULL );
00141
00142 delete[] elem;
00143 delete[] ind;
00144 delete[] starts;
00145 delete[] lens;
00146
00147 assert( eq(pm.getExtraGap(),.25) );
00148 assert( eq(pm.getExtraMajor(),.25) );
00149 assert( !pm.isColOrdered() );
00150 assert( pm.getNumElements()==numels );
00151 assert( pm.getNumCols()==minor );
00152 assert( pm.getNumRows()==major);
00153 assert( pm.getSizeVectorStarts()==major+1 );
00154 assert( pm.getSizeVectorLengths()==major );
00155
00156 const double * ev = pm.getElements();
00157 assert( eq(ev[0], 3.0) );
00158 assert( eq(ev[1], 1.0) );
00159 assert( eq(ev[2], -2.0) );
00160 assert( eq(ev[3], -1.0) );
00161 assert( eq(ev[4], -1.0) );
00162 assert( eq(ev[7], 2.0) );
00163 assert( eq(ev[8], 1.1) );
00164 assert( eq(ev[10], 1.0) );
00165 assert( eq(ev[11], 1.0) );
00166 assert( eq(ev[13], 2.8) );
00167 assert( eq(ev[14], -1.2) );
00168 assert( eq(ev[16], 5.6) );
00169 assert( eq(ev[17], 1.0) );
00170 assert( eq(ev[18], 1.9) );
00171
00172 const int * mi = pm.getVectorStarts();
00173 assert( mi[0]==0 );
00174 assert( mi[1]==7 );
00175 assert( mi[2]==10 );
00176 assert( mi[3]==13 );
00177 assert( mi[4]==16 );
00178 assert( mi[5]==20 );
00179
00180 const int * vl = pm.getVectorLengths();
00181 assert( vl[0]==5 );
00182 assert( vl[1]==2 );
00183 assert( vl[2]==2 );
00184 assert( vl[3]==2 );
00185 assert( vl[4]==3 );
00186
00187 const int * ei = pm.getIndices();
00188 assert( ei[0] == 0 );
00189 assert( ei[1] == 1 );
00190 assert( ei[2] == 3 );
00191 assert( ei[3] == 4 );
00192 assert( ei[4] == 7 );
00193 assert( ei[7] == 1 );
00194 assert( ei[8] == 2 );
00195 assert( ei[10] == 2 );
00196 assert( ei[11] == 5 );
00197 assert( ei[13] == 3 );
00198 assert( ei[14] == 6 );
00199 assert( ei[16] == 0 );
00200 assert( ei[17] == 4 );
00201 assert( ei[18] == 7 );
00202
00203 assert( pm.getMajorDim() == 5 );
00204 assert( pm.getMinorDim() == 8 );
00205 assert( pm.getNumElements() == 14 );
00206 assert( pm.getSizeVectorStarts()==6 );
00207
00208 {
00209
00210 OsiPackedMatrix pmC(pm);
00211
00212 assert( eq(pmC.getExtraGap(),.25) );
00213 assert( eq(pmC.getExtraMajor(),.25) );
00214 assert( !pmC.isColOrdered() );
00215 assert( pmC.getNumElements()==numels );
00216 assert( pmC.getNumCols()==minor );
00217 assert( pmC.getNumRows()==major);
00218 assert( pmC.getSizeVectorStarts()==major+1 );
00219 assert( pmC.getSizeVectorLengths()==major );
00220
00221
00222 assert( pm.getElements() != pmC.getElements() );
00223 const double * ev = pmC.getElements();
00224 assert( eq(ev[0], 3.0) );
00225 assert( eq(ev[1], 1.0) );
00226 assert( eq(ev[2], -2.0) );
00227 assert( eq(ev[3], -1.0) );
00228 assert( eq(ev[4], -1.0) );
00229 assert( eq(ev[7], 2.0) );
00230 assert( eq(ev[8], 1.1) );
00231 assert( eq(ev[10], 1.0) );
00232 assert( eq(ev[11], 1.0) );
00233 assert( eq(ev[13], 2.8) );
00234 assert( eq(ev[14], -1.2) );
00235 assert( eq(ev[16], 5.6) );
00236 assert( eq(ev[17], 1.0) );
00237 assert( eq(ev[18], 1.9) );
00238
00239 assert( pm.getVectorStarts() != pmC.getVectorStarts() );
00240 const int * mi = pmC.getVectorStarts();
00241 assert( mi[0]==0 );
00242 assert( mi[1]==7 );
00243 assert( mi[2]==10 );
00244 assert( mi[3]==13 );
00245 assert( mi[4]==16 );
00246 assert( mi[5]==20 );
00247
00248 assert( pm.getVectorLengths() != pmC.getVectorLengths() );
00249 const int * vl = pmC.getVectorLengths();
00250 assert( vl[0]==5 );
00251 assert( vl[1]==2 );
00252 assert( vl[2]==2 );
00253 assert( vl[3]==2 );
00254 assert( vl[4]==3 );
00255
00256 assert( pm.getIndices() != pmC.getIndices() );
00257 const int * ei = pmC.getIndices();
00258 assert( ei[0] == 0 );
00259 assert( ei[1] == 1 );
00260 assert( ei[2] == 3 );
00261 assert( ei[3] == 4 );
00262 assert( ei[4] == 7 );
00263 assert( ei[7] == 1 );
00264 assert( ei[8] == 2 );
00265 assert( ei[10] == 2 );
00266 assert( ei[11] == 5 );
00267 assert( ei[13] == 3 );
00268 assert( ei[14] == 6 );
00269 assert( ei[16] == 0 );
00270 assert( ei[17] == 4 );
00271 assert( ei[18] == 7 );
00272
00273 assert( pmC.isEquivalent(pm) );
00274
00275
00276 {
00277 OsiPackedMatrix pmA;
00278
00279 assert( eq(pmA.getExtraGap(),0.25) );
00280 assert( eq(pmA.getExtraMajor(),0.25) );
00281
00282 pmA = pm;
00283
00284 assert( eq(pmA.getExtraGap(),0.25) );
00285 assert( eq(pmA.getExtraMajor(),0.25) );
00286 assert( !pmA.isColOrdered() );
00287 assert( pmA.getNumElements()==numels );
00288 assert( pmA.getNumCols()==minor );
00289 assert( pmA.getNumRows()==major);
00290 assert( pmA.getSizeVectorStarts()==major+1 );
00291 assert( pmA.getSizeVectorLengths()==major );
00292
00293
00294 assert( pm.getElements() != pmA.getElements() );
00295 const double * ev = pmA.getElements();
00296 assert( eq(ev[0], 3.0) );
00297 assert( eq(ev[1], 1.0) );
00298 assert( eq(ev[2], -2.0) );
00299 assert( eq(ev[3], -1.0) );
00300 assert( eq(ev[4], -1.0) );
00301 assert( eq(ev[7], 2.0) );
00302 assert( eq(ev[8], 1.1) );
00303 assert( eq(ev[10], 1.0) );
00304 assert( eq(ev[11], 1.0) );
00305 assert( eq(ev[13], 2.8) );
00306 assert( eq(ev[14], -1.2) );
00307 assert( eq(ev[16], 5.6) );
00308 assert( eq(ev[17], 1.0) );
00309 assert( eq(ev[18], 1.9) );
00310
00311 assert( pm.getVectorStarts() != pmA.getVectorStarts() );
00312 const int * mi = pmA.getVectorStarts();
00313 assert( mi[0]==0 );
00314 assert( mi[1]==7 );
00315 assert( mi[2]==10 );
00316 assert( mi[3]==13 );
00317 assert( mi[4]==16 );
00318 assert( mi[5]==20 );
00319
00320 assert( pm.getVectorLengths() != pmA.getVectorLengths() );
00321 const int * vl = pmC.getVectorLengths();
00322 assert( vl[0]==5 );
00323 assert( vl[1]==2 );
00324 assert( vl[2]==2 );
00325 assert( vl[3]==2 );
00326 assert( vl[4]==3 );
00327
00328 assert( pm.getIndices() != pmA.getIndices() );
00329 const int * ei = pmA.getIndices();
00330 assert( ei[0] == 0 );
00331 assert( ei[1] == 1 );
00332 assert( ei[2] == 3 );
00333 assert( ei[3] == 4 );
00334 assert( ei[4] == 7 );
00335 assert( ei[7] == 1 );
00336 assert( ei[8] == 2 );
00337 assert( ei[10] == 2 );
00338 assert( ei[11] == 5 );
00339 assert( ei[13] == 3 );
00340 assert( ei[14] == 6 );
00341 assert( ei[16] == 0 );
00342 assert( ei[17] == 4 );
00343 assert( ei[18] == 7 );
00344
00345 assert( pmA.isEquivalent(pm) );
00346 assert( pmA.isEquivalent(pmC) );
00347
00348
00349 globalP = new OsiPackedMatrix(pmA);
00350 assert( eq(globalP->getElements()[0], 3.0) );
00351 assert( globalP->isEquivalent(pmA) );
00352 }
00353 assert( eq(globalP->getElements()[0], 3.0) );
00354 }
00355 assert( eq(globalP->getElements()[0], 3.0) );
00356 }
00357
00358
00359 const double * ev = globalP->getElements();
00360 assert( eq(ev[0], 3.0) );
00361 assert( eq(ev[1], 1.0) );
00362 assert( eq(ev[2], -2.0) );
00363 assert( eq(ev[3], -1.0) );
00364 assert( eq(ev[4], -1.0) );
00365 assert( eq(ev[7], 2.0) );
00366 assert( eq(ev[8], 1.1) );
00367 assert( eq(ev[10], 1.0) );
00368 assert( eq(ev[11], 1.0) );
00369 assert( eq(ev[13], 2.8) );
00370 assert( eq(ev[14], -1.2) );
00371 assert( eq(ev[16], 5.6) );
00372 assert( eq(ev[17], 1.0) );
00373 assert( eq(ev[18], 1.9) );
00374
00375 const int * mi = globalP->getVectorStarts();
00376 assert( mi[0]==0 );
00377 assert( mi[1]==7 );
00378 assert( mi[2]==10 );
00379 assert( mi[3]==13 );
00380 assert( mi[4]==16 );
00381 assert( mi[5]==20 );
00382
00383 const int * ei = globalP->getIndices();
00384 assert( ei[0] == 0 );
00385 assert( ei[1] == 1 );
00386 assert( ei[2] == 3 );
00387 assert( ei[3] == 4 );
00388 assert( ei[4] == 7 );
00389 assert( ei[7] == 1 );
00390 assert( ei[8] == 2 );
00391 assert( ei[10] == 2 );
00392 assert( ei[11] == 5 );
00393 assert( ei[13] == 3 );
00394 assert( ei[14] == 6 );
00395 assert( ei[16] == 0 );
00396 assert( ei[17] == 4 );
00397 assert( ei[18] == 7 );
00398
00399 assert( globalP->getMajorDim() == 5 );
00400 assert( globalP->getMinorDim() == 8 );
00401 assert( globalP->getNumElements() == 14 );
00402 assert( globalP->getSizeVectorStarts()==6 );
00403
00404
00405 assert( globalP->getVectorSize(0)==5 );
00406 assert( globalP->getVectorSize(1)==2 );
00407 assert( globalP->getVectorSize(2)==2 );
00408 assert( globalP->getVectorSize(3)==2 );
00409 assert( globalP->getVectorSize(4)==3 );
00410
00411
00412 {
00413 bool errorThrown = false;
00414 try {
00415 globalP->getVectorSize(-1);
00416 }
00417 catch (CoinError e) {
00418 errorThrown = true;
00419 }
00420 assert( errorThrown );
00421 }
00422 {
00423 bool errorThrown = false;
00424 try {
00425 globalP->getVectorSize(5);
00426 }
00427 catch (CoinError e) {
00428 errorThrown = true;
00429 }
00430 assert( errorThrown );
00431 }
00432
00433
00434 {
00435
00436 OsiShallowPackedVector pv = globalP->getVector(0);
00437 assert( pv.getNumElements() == 5 );
00438 assert( eq(pv[0], 3.0) );
00439 assert( eq(pv[1], 1.0) );
00440 assert( eq(pv[3],-2.0) );
00441 assert( eq(pv[4],-1.0) );
00442 assert( eq(pv[7],-1.0) );
00443
00444
00445 pv = globalP->getVector(1);
00446 assert( pv.getNumElements() == 2 );
00447 assert( eq(pv[1], 2.0) );
00448 assert( eq(pv[2], 1.1) );
00449
00450
00451 pv = globalP->getVector(2);
00452 assert( pv.getNumElements() == 2 );
00453 assert( eq(pv[2], 1.0) );
00454 assert( eq(pv[5], 1.0) );
00455
00456
00457 pv = globalP->getVector(3);
00458 assert( pv.getNumElements() == 2 );
00459 assert( eq(pv[3], 2.8) );
00460 assert( eq(pv[6],-1.2) );
00461
00462
00463 pv = globalP->getVector(4);
00464 assert( pv.getNumElements() == 3 );
00465 assert( eq(pv[0], 5.6) );
00466 assert( eq(pv[4], 1.0) );
00467 assert( eq(pv[7], 1.9) );
00468 }
00469
00470
00471 {
00472 bool errorThrown = false;
00473 try {
00474 OsiShallowPackedVector v = globalP->getVector(-1);
00475 }
00476 catch (CoinError e) {
00477 errorThrown = true;
00478 }
00479 assert( errorThrown );
00480 }
00481 {
00482 bool errorThrown = false;
00483 try {
00484 OsiShallowPackedVector vs = globalP->getVector(5);
00485 }
00486 catch (CoinError e) {
00487 errorThrown = true;
00488 }
00489 assert( errorThrown );
00490 }
00491
00492 {
00493 OsiPackedMatrix pm(*globalP);
00494
00495 assert( pm.getExtraGap() != 0.0 );
00496 assert( pm.getExtraMajor() != 0.0 );
00497
00498 pm.setExtraGap(0.0);
00499 pm.setExtraMajor(0.0);
00500
00501 assert( pm.getExtraGap() == 0.0 );
00502 assert( pm.getExtraMajor() == 0.0 );
00503
00504 pm.reverseOrdering();
00505
00506 assert( pm.getExtraGap() == 0.0 );
00507 assert( pm.getExtraMajor() == 0.0 );
00508 }
00509
00510
00511
00512 {
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523 const int ne=17;
00524 int ri[ne];
00525 int ci[ne];
00526 double el[ne];
00527 ri[ 0]=1; ci[ 0]=2; el[ 0]=1.1;
00528 ri[ 1]=0; ci[ 1]=3; el[ 1]=-2.0;
00529 ri[ 2]=4; ci[ 2]=7; el[ 2]=1.9;
00530 ri[ 3]=3; ci[ 3]=6; el[ 3]=-1.2;
00531 ri[ 4]=2; ci[ 4]=5; el[ 4]=1.0;
00532 ri[ 5]=4; ci[ 5]=0; el[ 5]=5.6;
00533 ri[ 6]=0; ci[ 6]=7; el[ 6]=-1.0;
00534 ri[ 7]=0; ci[ 7]=0; el[ 7]=3.0;
00535 ri[ 8]=0; ci[ 8]=4; el[ 8]=-1.0;
00536 ri[ 9]=4; ci[ 9]=4; el[ 9]=1.0;
00537 ri[10]=3; ci[10]=3; el[10]=2.0;
00538 ri[11]=1; ci[11]=1; el[11]=2.0;
00539 ri[12]=0; ci[12]=1; el[12]=1.0;
00540 ri[13]=2; ci[13]=2; el[13]=1.0;
00541 ri[14]=3; ci[14]=3; el[14]=0.8;
00542 ri[15]=2; ci[15]=0; el[15]=-3.1415;
00543 ri[16]=2; ci[16]=0; el[16]= 3.1415;
00544 assert(!globalP->isColOrdered());
00545
00546
00547 OsiPackedMatrix pmtco(true,ri,ci,el,ne);
00548
00549
00550 assert( eq( pmtco.getVector(3)[3] , 2.8 ) );
00551 assert( eq( pmtco.getVector(0)[2] , 0.0 ) );
00552
00553
00554 assert( pmtco.getVectorStarts()[0]==0 );
00555 assert( pmtco.getVectorStarts()[1]==2 );
00556 assert( pmtco.getVectorStarts()[2]==4 );
00557 assert( pmtco.getVectorStarts()[3]==6 );
00558 assert( pmtco.getVectorStarts()[4]==8 );
00559 assert( pmtco.getVectorStarts()[5]==10 );
00560 assert( pmtco.getVectorStarts()[6]==11 );
00561 assert( pmtco.getVectorStarts()[7]==12 );
00562 assert( pmtco.getVectorStarts()[8]==14 );
00563
00564
00565 OsiPackedMatrix globalco;
00566 globalco.reverseOrderedCopyOf(*globalP);
00567 assert(pmtco.isEquivalent(globalco));
00568
00569
00570 OsiPackedMatrix pmtro(false,ri,ci,el,ne);
00571 assert(!pmtro.isColOrdered());
00572 assert( eq( pmtro.getVector(3)[3] , 2.8 ) );
00573 assert( eq( pmtro.getVector(2)[0] , 0.0 ) );
00574 assert( pmtro.getVectorStarts()[0]==0 );
00575 assert( pmtro.getVectorStarts()[1]==5 );
00576 assert( pmtro.getVectorStarts()[2]==7 );
00577 assert( pmtro.getVectorStarts()[3]==9 );
00578 assert( pmtro.getVectorStarts()[4]==11 );
00579 assert( pmtro.getVectorStarts()[5]==14 );
00580 assert(globalP->isEquivalent(pmtro));
00581
00582 }
00583
00584 delete globalP;
00585 }
00586
00587 #if 0
00588 {
00589
00590 OsiPackedMatrix pm;
00591
00592 const int ne = 4;
00593 int inx[ne] = { 1, -4, 0, 2 };
00594 double el[ne] = { 10., 40., 1., 50. };
00595 OsiPackedVector r(ne,inx,el);
00596
00597 pm.appendRow(r);
00598
00599 }
00600 #endif
00601
00602 }