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