00001
00002
00003 #if defined(_MSC_VER)
00004
00005 # pragma warning(disable:4786)
00006 #endif
00007
00008 #include <cassert>
00009
00010 #include "OsiPackedVector.hpp"
00011 #include "OsiShallowPackedVector.hpp"
00012
00013 #ifdef NDEBUG
00014 #undef NDEBUG
00015 #endif
00016
00017
00018 void
00019 OsiPackedVectorUnitTest()
00020 {
00021
00022 int i;
00023
00024 {
00025 OsiPackedVector r;
00026 assert( r.indices_==NULL );
00027 assert( r.origIndices_==NULL );
00028 assert( r.elements_==NULL );
00029 assert( r.getNumElements()==0 );
00030 assert( r.capacity_==0);
00031 }
00032
00033
00034 const int ne = 4;
00035 int inx[ne] = { 1, 3, 4, 7 };
00036 double el[ne] = { 1.2, 3.4, 5.6, 7.8 };
00037 {
00038 OsiPackedVector r;
00039 assert( r.getNumElements()==0 );
00040
00041
00042 r.setVector( ne, inx, el );
00043 assert( r.getNumElements()==ne );
00044 for ( i=0; i<ne; i++ ) {
00045 assert( r.getIndices()[i] == inx[i] );
00046 assert( r.getOriginalPosition()[i] == i );
00047 assert( r.getElements()[i] == el[i] );
00048 }
00049 assert ( r.getMaxIndex()==7 );
00050 assert ( r.getMinIndex()==1 );
00051
00052
00053 const int ne2 = 5;
00054 int inx2[ne2] = { 2, 4, 8, 14, 3 };
00055 double el2[ne2] = { 2.2, 4.4, 6.6, 8.8, 3.3 };
00056
00057 r.setVector(ne2,inx2,el2);
00058
00059 assert( r.getNumElements()==ne2 );
00060
00061 assert( r.getIndices()[0]==inx2[0] );
00062 assert( r.getOriginalPosition()[0]==0 );
00063 assert( r.getElements()[0]==el2[0] );
00064
00065 assert( r.getIndices()[1]==inx2[1] );
00066 assert( r.getOriginalPosition()[1]==1 );
00067 assert( r.getElements()[1]==el2[1] );
00068
00069 assert( r.getIndices()[2]==inx2[2] );
00070 assert( r.getOriginalPosition()[2]==2 );
00071 assert( r.getElements()[2]==el2[2] );
00072
00073 assert( r.getIndices()[3]==inx2[3] );
00074 assert( r.getOriginalPosition()[3]==3 );
00075 assert( r.getElements()[3]==el2[3] );
00076
00077 assert( r.getIndices()[4]==inx2[4] );
00078 assert( r.getOriginalPosition()[4]==4 );
00079 assert( r.getElements()[4]==el2[4] );
00080
00081 assert ( r.getMaxIndex()==14 );
00082 assert ( r.getMinIndex()==2 );
00083 assert ( r.getMaxIndex()==14 );
00084 assert ( r.getMinIndex()==2 );
00085 {
00086 bool errorThrown = false;
00087 try {
00088 r.duplicateIndex();
00089 }
00090 catch (CoinError e) {
00091 errorThrown = true;
00092 }
00093 assert( !errorThrown );
00094 }
00095
00096 OsiPackedVector r1(ne2,inx2,el2);
00097 assert( r == r1 );
00098
00099
00100
00101 {
00102 const int ne3 = 4;
00103 int inx3[ne3] = { 2, 4, 2, 3 };
00104 double el3[ne3] = { 2.2, 4.4, 8.8, 6.6 };
00105 bool errorThrown = false;
00106 try {
00107 r.setVector(ne3,inx3,el3);
00108 }
00109 catch (CoinError e) {
00110 errorThrown = true;
00111 }
00112 assert( errorThrown );
00113
00114 errorThrown = false;
00115 try {
00116 r.duplicateIndex();
00117 }
00118 catch (CoinError e) {
00119 errorThrown = true;
00120 }
00121 assert( errorThrown );
00122 }
00123
00124
00125
00126
00127 r.setVector(ne2,inx2,el2);
00128 bool incr=true;
00129 for ( i=1; i<ne2; i++ )
00130 if ( r.getElements()[i-1]>r.getElements()[i] )
00131 incr=false;
00132 assert( !incr );
00133 r.sortIncrElement();
00134 incr = true;
00135 for ( i=1; i<ne2; i++ )
00136 if ( r.getElements()[i-1]>r.getElements()[i] )
00137 incr=false;
00138 assert( incr );
00139
00140 }
00141
00142
00143 {
00144 OsiPackedVector r;
00145 const int ne = 3;
00146 int inx[ne] = { 1, 2, 3 };
00147 double el[ne] = { 2.2, 4.4, 8.8};
00148 r.setVector(ne,inx,el);
00149 int c = r.capacity();
00150 int max = r.getMaxIndex();
00151 int min = r.getMinIndex();
00152
00153 r.swap(0,2);
00154 assert( r.getIndices()[0]==3 );
00155 assert( r.getIndices()[1]==2 );
00156 assert( r.getIndices()[2]==1 );
00157 assert( r.getElements()[0]==8.8 );
00158 assert( r.getElements()[1]==4.4 );
00159 assert( r.getElements()[2]==2.2 );
00160 assert( r.getMaxIndex() == max );
00161 assert( r.getMinIndex() == min );
00162 assert( r.capacity() == c );
00163
00164
00165 OsiPackedVector s;
00166 const int nes = 4;
00167 int inxs[nes] = { 11, 12, 13, 14 };
00168 double els[nes] = { .122, 14.4, 18.8, 19.9};
00169 s.setVector(nes,inxs,els);
00170 r.append(s);
00171 assert( r.getNumElements()==7 );
00172 assert( r.getIndices()[0]==3 );
00173 assert( r.getIndices()[1]==2 );
00174 assert( r.getIndices()[2]==1 );
00175 assert( r.getIndices()[3]==11 );
00176 assert( r.getIndices()[4]==12 );
00177 assert( r.getIndices()[5]==13 );
00178 assert( r.getIndices()[6]==14 );
00179 assert( r.getElements()[0]==8.8 );
00180 assert( r.getElements()[1]==4.4 );
00181 assert( r.getElements()[2]==2.2 );
00182 assert( r.getElements()[3]==.122 );
00183 assert( r.getElements()[4]==14.4 );
00184 assert( r.getElements()[5]==18.8 );
00185 assert( r.getElements()[6]==19.9 );
00186 assert( r.getMaxIndex() == 14 );
00187 assert( r.getMinIndex() == 1 );
00188
00189
00190 c = r.capacity();
00191 r.truncate(4);
00192 assert( r.getNumElements()==4 );
00193 assert( r.getIndices()[0]==3 );
00194 assert( r.getIndices()[1]==2 );
00195 assert( r.getIndices()[2]==1 );
00196 assert( r.getIndices()[3]==11 );
00197 assert( r.getElements()[0]==8.8 );
00198 assert( r.getElements()[1]==4.4 );
00199 assert( r.getElements()[2]==2.2 );
00200 assert( r.getElements()[3]==.122 );
00201 assert( r.getMaxIndex() == 11 );
00202 assert( r.getMinIndex() == 1 );
00203 assert( r.capacity() == c );
00204 }
00205
00206
00207
00208 {
00209 OsiPackedVector rhs;
00210 {
00211 OsiPackedVector r;
00212 {
00213 OsiPackedVector rC1(r);
00214 assert( 0==r.getNumElements() );
00215 assert( 0==rC1.getNumElements() );
00216
00217
00218 r.setVector( ne, inx, el );
00219
00220 assert( ne==r.getNumElements() );
00221 assert( 0==rC1.getNumElements() );
00222 }
00223
00224 OsiPackedVector rC2(r);
00225
00226 assert( ne==r.getNumElements() );
00227 assert( ne==rC2.getNumElements() );
00228
00229 for ( i=0; i<ne; i++ ) {
00230 assert( r.getIndices()[i] == rC2.getIndices()[i] );
00231 assert( r.getOriginalPosition()[i] == rC2.getOriginalPosition()[i] );
00232 assert( r.getElements()[i] == rC2.getElements()[i] );
00233 }
00234
00235 rhs=rC2;
00236 }
00237
00238 assert( rhs.getNumElements()==ne );
00239
00240 for ( i=0; i<ne; i++ ) {
00241 assert( inx[i] == rhs.getIndices()[i] );
00242 assert( i == rhs.getOriginalPosition()[i] );
00243 assert( el[i] == rhs.getElements()[i] );
00244 }
00245 }
00246
00247
00248 {
00249 OsiPackedVector v1,v2;
00250 assert( v1==v2 );
00251 assert( v2==v1 );
00252 assert( v1==v1 );
00253 assert( !(v1!=v2) );
00254 assert( v1.isEquivalent(v2) );
00255 assert( v2.isEquivalent(v1) );
00256 assert( v1.isEquivalent(v1) );
00257
00258 v1.setVector( ne, inx, el );
00259 assert ( !(v1==v2) );
00260 assert ( v1!=v2 );
00261 assert( !v1.isEquivalent(v2) );
00262
00263 OsiPackedVector v3(v1);
00264 assert( v3==v1 );
00265 assert( v3!=v2 );
00266 assert( v1.isEquivalent(v3) );
00267 assert( v3.isEquivalent(v1) );
00268
00269 OsiPackedVector v4(v2);
00270 assert( v4!=v1 );
00271 assert( v4==v2 );
00272 }
00273
00274 {
00275
00276 const int ne = 4;
00277 int inx[ne] = { 1, 4, 0, 2 };
00278 double el[ne] = { 10., 40., 1., 20. };
00279 double extSortKey[5] = { -20., 10., 5., 4., 20. };
00280 OsiPackedVector r;
00281 r.setVector(ne,inx,el);
00282
00283
00284 r.sortIncrIndex();
00285 for ( i=1; i<ne; i++ ) assert( r.getIndices()[i-1] < r.getIndices()[i] );
00286
00287
00288 r.sortIncrElement();
00289 for ( i=1; i<ne; i++ ) assert( r.getElements()[i-1] < r.getElements()[i] );
00290
00291
00292 CoinIncrSolutionOrdered pcSo(extSortKey);
00293 r.sort(pcSo);
00294 for ( i=1; i<ne; i++ )
00295 assert( extSortKey[r.getIndices()[i-1]] < extSortKey[r.getIndices()[i]] );
00296
00297
00298
00299 r.sortIncrIndex();
00300 for ( i=1; i<ne; i++ ) assert( r.getIndices()[i-1] < r.getIndices()[i] );
00301 }
00302
00303
00304 {
00305
00306 const int ne = 4;
00307 int inx[ne] = { 1, 4, 0, 2 };
00308 double el[ne] = { 10., 40., 1., 50. };
00309 OsiPackedVector r;
00310 assert( r[1]==0. );
00311
00312 r.setVector(ne,inx,el);
00313
00314 assert( r[-1]==0. );
00315 assert( r[ 0]==1. );
00316 assert( r[ 1]==10.);
00317 assert( r[ 2]==50.);
00318 assert( r[ 3]==0. );
00319 assert( r[ 4]==40.);
00320 assert( r[ 5]==0. );
00321 assert( r.isExistingIndex(2) );
00322 assert( !r.isExistingIndex(3) );
00323
00324 r.sortIncrElement();
00325
00326 assert( r[-1]==0. );
00327 assert( r[ 0]==1. );
00328 assert( r[ 1]==10.);
00329 assert( r[ 2]==50.);
00330 assert( r[ 3]==0. );
00331 assert( r[ 4]==40.);
00332 assert( r[ 5]==0. );
00333 assert( !r.isExistingIndex(-1) );
00334 assert( r.isExistingIndex(0) );
00335 assert( !r.isExistingIndex(3) );
00336 assert( r.isExistingIndex(4) );
00337 assert( !r.isExistingIndex(5) );
00338
00339 assert ( r.getMaxIndex()==4 );
00340 assert ( r.getMinIndex()==0 );
00341 }
00342
00343
00344
00345 {
00346 OsiPackedVector nullVec;
00347 assert( nullVec.getMaxIndex() ==
00348 INT_MIN );
00349 assert( nullVec.getMinIndex() ==
00350 INT_MAX );
00351 }
00352
00353
00354 {
00355 const int ne = 4;
00356 int inx1[ne] = { 1, 3, 4, 7 };
00357 double el1[ne] = { 1.2, 3.4, 5.6, 7.8 };
00358 int inx2[ne] = { 7, 4, 3, 1 };
00359 double el2[ne] = { 7.8+.5, 5.6+.5, 3.4+.5, 1.2+.5 };
00360 OsiPackedVector v1,v2;
00361 v1.setVector(ne,inx1,el1);
00362 v2.setVector(ne,inx2,el2);
00363 assert( !v1.isEquivalent(v2) );
00364 assert( v1.isEquivalent(v2,OsiAbsFltEq(.6)) );
00365 assert( v1.isEquivalent(v2,OsiRelFltEq(.6)) );
00366 }
00367
00368 {
00369
00370 OsiPackedVector v1,v2;
00371 assert( v1.capacity()==0 );
00372 v1.reserve(6);
00373 assert( v1.capacity()==6 );
00374 assert( v1.getNumElements()==0 );
00375 v2=v1;
00376 assert( v2.capacity() == v2.getNumElements() );
00377 assert( v2.getNumElements()==0 );
00378 assert( v2==v1 );
00379 v1.setVector(0,NULL,NULL);
00380 assert( v1.capacity()==6 );
00381 assert( v1.getNumElements()==0 );
00382 assert( v2==v1 );
00383 v2=v1;
00384 assert( v2.capacity() == v2.getNumElements() );
00385 assert( v2.getNumElements()==0 );
00386 assert( v2==v1 );
00387
00388 const int ne = 2;
00389 int inx[ne] = { 1, 3 };
00390 double el[ne] = { 1.2, 3.4 };
00391 v1.setVector(ne,inx,el);
00392 assert( v1.capacity()==6 );
00393 assert( v1.getNumElements()==2 );
00394 v2=v1;
00395 assert( v2.capacity()==v2.getNumElements() );
00396 assert( v2.getNumElements()==2 );
00397 assert( v2==v1 );
00398
00399 const int ne1 = 5;
00400 int inx1[ne1] = { 1, 3, 4, 5, 6 };
00401 double el1[ne1] = { 1.2, 3.4, 5., 6., 7. };
00402 v1.setVector(ne1,inx1,el1);
00403 assert( v1.capacity()==6 );
00404 assert( v1.getNumElements()==5 );
00405 v2=v1;
00406 assert( v2.capacity()==v2.getNumElements() );
00407 assert( v2.getNumElements()==5 );
00408 assert( v2==v1 );
00409
00410 const int ne2 = 8;
00411 int inx2[ne2] = { 1, 3, 4, 5, 6, 7, 8, 9 };
00412 double el2[ne2] = { 1.2, 3.4, 5., 6., 7., 8., 9., 10. };
00413 v1.setVector(ne2,inx2,el2);
00414 assert( v1.capacity()==8 );
00415 assert( v1.getNumElements()==8 );
00416 v2=v1;
00417 assert( v2.capacity()==v2.getNumElements() );
00418 assert( v2.getNumElements()==8 );
00419 assert( v2==v1 );
00420
00421 v1.setVector(ne1,inx1,el1);
00422 assert( v1.capacity()==8 );
00423 assert( v1.getNumElements()==5 );
00424 v2=v1;
00425 assert( v2.capacity()==8 );
00426 assert( v2.getNumElements()==5 );
00427 assert( v2==v1 );
00428
00429 v1.reserve(7);
00430 assert( v1.capacity()==8 );
00431 assert( v1.getNumElements()==5 );
00432 v2=v1;
00433 assert( v2.capacity()==8 );
00434 assert( v2.getNumElements()==5 );
00435 assert( v2==v1 );
00436
00437 }
00438
00439
00440 {
00441 OsiPackedVector v1;
00442 assert( v1.getNumElements()==0 );
00443 assert( v1.capacity()==0 );
00444
00445 assert( !v1.isExistingIndex(1) );
00446 v1.insert(1,1.);
00447 assert( v1.getNumElements()==1 );
00448 assert( v1.capacity()==5 );
00449 assert( v1.getIndices()[0] == 1 );
00450 assert( v1.getElements()[0] == 1. );
00451 assert( v1.isExistingIndex(1) );
00452
00453 assert( !v1.isExistingIndex(10) );
00454 v1.insert(10,10.);
00455 assert( v1.getNumElements()==2 );
00456 assert( v1.capacity()==5 );
00457 assert( v1.getIndices()[1] == 10 );
00458 assert( v1.getElements()[1] == 10. );
00459 assert( v1.isExistingIndex(1) );
00460 assert( v1.isExistingIndex(10) );
00461
00462 assert( !v1.isExistingIndex(20) );
00463 v1.insert(20,20.);
00464 assert( v1.getNumElements()==3 );
00465 assert( v1.capacity()==5 );
00466 assert( v1.getIndices()[2] == 20 );
00467 assert( v1.getElements()[2] == 20. );
00468 assert( v1.isExistingIndex(20) );
00469
00470 assert( !v1.isExistingIndex(30) );
00471 v1.insert(30,30.);
00472 assert( v1.getNumElements()==4 );
00473 assert( v1.capacity()==5 );
00474 assert( v1.getIndices()[3] == 30 );
00475 assert( v1.getElements()[3] == 30. );
00476 assert( v1.isExistingIndex(30) );
00477
00478 assert( !v1.isExistingIndex(40) );
00479 v1.insert(40,40.);
00480 assert( v1.getNumElements()==5 );
00481 assert( v1.capacity()==5 );
00482 assert( v1.getIndices()[4] == 40 );
00483 assert( v1.getElements()[4] == 40. );
00484 assert( v1.isExistingIndex(40) );
00485
00486 assert( !v1.isExistingIndex(50) );
00487 v1.insert(50,50.);
00488 assert( v1.getNumElements()==6 );
00489 assert( v1.capacity()==10 );
00490 assert( v1.getIndices()[5] == 50 );
00491 assert( v1.getElements()[5] == 50. );
00492 assert( v1.isExistingIndex(50) );
00493
00494 OsiPackedVector v2;
00495 const int ne1 = 3;
00496 int inx1[ne1] = { 1, 3, 4 };
00497 double el1[ne1] = { 1.2, 3.4, 5. };
00498 v2.setVector(ne1,inx1,el1);
00499 assert( v2.getNumElements()==3 );
00500 assert( v2.capacity()==3 );
00501
00502 }
00503
00504 {
00505
00506 OsiPackedVector v2;
00507 const int ne1 = 3;
00508 int inx1[ne1] = { 1, 3, 4 };
00509 v2.setConstant(ne1,inx1,3.14);
00510 assert( v2.getNumElements()==3 );
00511 assert( v2.capacity()==3 );
00512 assert( v2.getIndices()[0]==1 );
00513 assert( v2.getElements()[0]==3.14 );
00514 assert( v2.getIndices()[1]==3 );
00515 assert( v2.getElements()[1]==3.14 );
00516 assert( v2.getIndices()[2]==4 );
00517 assert( v2.getElements()[2]==3.14 );
00518
00519 assert( v2[3] == 3.14 );
00520
00521 OsiPackedVector v2X(ne1,inx1,3.14);
00522 assert( v2 == v2X );
00523
00524 #if 0
00525 v2.setElement( 1 , 100. );
00526 assert( v2.getNumElements()==3 );
00527 assert( v2.capacity()==3 );
00528 assert( v2.getIndices()[0]==1 );
00529 assert( v2.getElements()[0]==3.14 );
00530 assert( v2.getIndices()[1]==3 );
00531 assert( v2.getElements()[1]==100. );
00532 assert( v2.getIndices()[2]==4 );
00533 assert( v2.getElements()[2]==3.14 );
00534
00535 assert( v2[3] == 100. );
00536
00537 bool errorThrown = false;
00538 try {
00539 v2.setElement( 100, 100. );
00540 }
00541 catch (CoinError e) {
00542 errorThrown = true;
00543 }
00544 assert( errorThrown );
00545 #endif
00546 }
00547
00548 {
00549
00550 OsiPackedVector v2;
00551 const int ne2 = 3;
00552 double el2[ne2] = { 1., 3., 4. };
00553 v2.setFull(ne2,el2);
00554 assert( v2.getNumElements()==3 );
00555 assert( v2.capacity()==3 );
00556 assert( v2.getIndices()[0]==0 );
00557 assert( v2.getElements()[0]==1. );
00558 assert( v2.getIndices()[1]==1 );
00559 assert( v2.getElements()[1]==3. );
00560 assert( v2.getIndices()[2]==2 );
00561 assert( v2.getElements()[2]==4. );
00562
00563 assert( v2[1] == 3. );
00564
00565 OsiPackedVector v2X(ne2,el2);
00566 assert( v2 == v2X );
00567
00568 v2.setFull(0,el2);
00569 assert( v2[2] == 0. );
00570 }
00571
00572
00573 #if 0
00574
00575
00576 {
00577 const int ne = 4;
00578 int inx1[ne] = { 1, 3, 4, 7 };
00579 double el1[ne] = { 1.2, 3.4, 5.6, 7.8 };
00580 OsiPackedVector v1;
00581 v1.set(-ne,inx1,el1);
00582 }
00583 #endif
00584
00585
00586
00587 {
00588 const int ne1 = 5;
00589 int inx1[ne1] = { 1, 3, 4, 7, 5 };
00590 double el1[ne1] = { 1., 5., 6., 2., 9. };
00591 const int ne2 = 4;
00592 int inx2[ne2] = { 7, 4, 2, 1 };
00593 double el2[ne2] = { 7., 4., 2., 1. };
00594 OsiPackedVector v1;
00595 v1.setVector(ne1,inx1,el1);
00596 OsiPackedVector v2;
00597 v2.setVector(ne2,inx2,el2);
00598 OsiPackedVector r = v1 + v2;
00599
00600 const int ner = 6;
00601 int inxr[ner] = { 1, 2, 3, 4, 5, 7 };
00602 double elr[ner] = { 1.+1., 0.+2., 5.+0., 6.+4., 9.+0., 2.+7. };
00603 OsiPackedVector rV;
00604 rV.setVector(ner,inxr,elr);
00605 assert( r.isEquivalent(rV) );
00606 }
00607
00608
00609 {
00610 const int ne1 = 5;
00611 int inx1[ne1] = { 1, 3, 4, 7, 5 };
00612 double el1[ne1] = { 1., 5., 6., 2., 9. };
00613 const int ne2 = 4;
00614 int inx2[ne2] = { 7, 4, 2, 1 };
00615 double el2[ne2] = { 7., 4., 2., 1. };
00616 OsiPackedVector v1;
00617 v1.setVector(ne1,inx1,el1);
00618 OsiPackedVector v2;
00619 v2.setVector(ne2,inx2,el2);
00620 OsiPackedVector r = v1 - v2;
00621
00622 const int ner = 6;
00623 int inxr[ner] = { 1, 2, 3, 4, 5, 7 };
00624 double elr[ner] = { 1.-1., 0.-2., 5.-0., 6.-4., 9.-0., 2.-7. };
00625 OsiPackedVector rV;
00626 rV.setVector(ner,inxr,elr);
00627 assert( r.isEquivalent(rV) );
00628 }
00629
00630
00631 {
00632 const int ne1 = 5;
00633 int inx1[ne1] = { 1, 3, 4, 7, 5 };
00634 double el1[ne1] = { 1., 5., 6., 2., 9. };
00635 const int ne2 = 4;
00636 int inx2[ne2] = { 7, 4, 2, 1 };
00637 double el2[ne2] = { 7., 4., 2., 1. };
00638 OsiPackedVector v1;
00639 v1.setVector(ne1,inx1,el1);
00640 OsiPackedVector v2;
00641 v2.setVector(ne2,inx2,el2);
00642 OsiPackedVector r = v1 * v2;
00643
00644 const int ner = 6;
00645 int inxr[ner] = { 1, 2, 3, 4, 5, 7 };
00646 double elr[ner] = { 1.*1., 0.*2., 5.*0., 6.*4., 9.*0., 2.*7. };
00647 OsiPackedVector rV;
00648 rV.setVector(ner,inxr,elr);
00649 assert( r.isEquivalent(rV) );
00650 }
00651
00652
00653 {
00654 const int ne1 = 3;
00655 int inx1[ne1] = { 1, 4, 7 };
00656 double el1[ne1] = { 1., 6., 2. };
00657 const int ne2 = 4;
00658 int inx2[ne2] = { 7, 4, 2, 1 };
00659 double el2[ne2] = { 7., 4., 2., 1. };
00660 OsiPackedVector v1;
00661 v1.setVector(ne1,inx1,el1);
00662 OsiPackedVector v2;
00663 v2.setVector(ne2,inx2,el2);
00664 OsiPackedVector r = v1 / v2;
00665
00666 const int ner = 4;
00667 int inxr[ner] = { 1, 2, 4, 7 };
00668 double elr[ner] = { 1./1., 0./2., 6./4., 2./7. };
00669 OsiPackedVector rV;
00670 rV.setVector(ner,inxr,elr);
00671 assert( r.isEquivalent(rV) );
00672 }
00673
00674
00675 {
00676 OsiPackedVector s;
00677 assert( s.sum() == 0 );
00678
00679 s.insert(25,45.);
00680 assert(s.sum()==45.);
00681
00682 const int ne1 = 5;
00683 int inx1[ne1] = { 10, 3, 4, 7, 5 };
00684 double el1[ne1] = { 1., 5., 6., 2., 9. };
00685 s.setVector(ne1,inx1,el1);
00686
00687 assert(s.sum()==1.+5.+6.+2.+9.);
00688 }
00689
00690
00691 {
00692
00693 const int ne1 = 2;
00694 int inx1[ne1] = { 1, 4 };
00695 double el1[ne1] = { 1., 6. };
00696 OsiPackedVector v1(ne1,inx1,el1);
00697
00698
00699 const int ne2 = 3;
00700 int inx2[ne2] = { 1, 2, 4 };
00701 double el2[ne2] = { 1., 7., 4.};
00702 OsiPackedVector v2(ne2,inx2,el2);
00703
00704
00705 OsiPackedVector ratio = v1 / v2;
00706
00707
00708 ratio.sortIncrElement();
00709
00710
00711 assert( ratio.getElements()[0] == 0.0/7.0 );
00712 assert( ratio.getElements()[1] == 1.0/1.0 );
00713 assert( ratio.getElements()[2] == 6.0/4.0 );
00714
00715
00716 assert( v1[ ratio.getIndices()[0] ] == 0.0 );
00717 assert( v1[ ratio.getIndices()[1] ] == 1.0 );
00718 assert( v1[ ratio.getIndices()[2] ] == 6.0 );
00719
00720
00721 assert( v2[ ratio.getIndices()[0] ] == 7.0 );
00722 assert( v2[ ratio.getIndices()[1] ] == 1.0 );
00723 assert( v2[ ratio.getIndices()[2] ] == 4.0 );
00724 }
00725
00726
00727 {
00728 const int ne = 4;
00729 int inx[ne] = { 1, 4, 0, 2 };
00730 double el[ne] = { 10., 40., 1., 50. };
00731 OsiPackedVector std(ne,inx,el);
00732 OsiShallowPackedVector * spvP = new OsiShallowPackedVector(ne,inx,el);
00733 OsiPackedVector pv(*spvP);
00734 assert( pv == std );
00735 assert( pv.isEquivalent(std) );
00736 delete spvP;
00737 assert( pv == std );
00738 assert( pv.isEquivalent(std) );
00739 pv.sortIncrElement();
00740 assert( pv != std );
00741 assert( pv.isEquivalent(std) );
00742 }
00743
00744
00745 {
00746 const int ne = 4;
00747 int inx[ne] = { 1, 4, 0, 2 };
00748 double el[ne] = { 10., 40., 1., 50. };
00749 OsiPackedVector std(ne,inx,el);
00750 OsiShallowPackedVector * spvP = new OsiShallowPackedVector(ne,inx,el);
00751 OsiPackedVector pv;
00752 pv = *spvP;
00753 assert( pv == std );
00754 assert( pv.isEquivalent(std) );
00755 delete spvP;
00756 assert( pv == std );
00757 assert( pv.isEquivalent(std) );
00758 pv.sortIncrElement();
00759 assert( pv != std );
00760 assert( pv.isEquivalent(std) );
00761 }
00762
00763 {
00764
00765
00766 const int ne = 4;
00767 int inx[ne] = { 1, 4, 0, 2 };
00768 double el[ne] = { 10., 40., 1., 50. };
00769 OsiPackedVector r(ne,inx,el);
00770
00771 assert( r.getIndices()[0]== 1 );
00772 assert( r.getElements()[0]==10. );
00773 assert( r.getIndices()[1]== 4 );
00774 assert( r.getElements()[1]==40. );
00775 assert( r.getIndices()[2]== 0 );
00776 assert( r.getElements()[2]== 1. );
00777 assert( r.getIndices()[3]== 2 );
00778 assert( r.getElements()[3]==50. );
00779
00780 assert( r.getOriginalPosition()[0]==0 );
00781 assert( r.getOriginalPosition()[1]==1 );
00782 assert( r.getOriginalPosition()[2]==2 );
00783 assert( r.getOriginalPosition()[3]==3 );
00784
00785 assert( r[ 0]==1. );
00786 assert( r[ 1]==10.);
00787 assert( r[ 2]==50.);
00788 assert( r[ 3]==0. );
00789 assert( r[ 4]==40.);
00790
00791 r.sortIncrElement();
00792
00793 assert( r.getIndices()[0]== 0 );
00794 assert( r.getElements()[0]== 1. );
00795 assert( r.getIndices()[1]== 1 );
00796 assert( r.getElements()[1]==10. );
00797 assert( r.getIndices()[2]== 4 );
00798 assert( r.getElements()[2]==40. );
00799 assert( r.getIndices()[3]== 2 );
00800 assert( r.getElements()[3]==50. );
00801
00802 assert( r.getOriginalPosition()[0]==2 );
00803 assert( r.getOriginalPosition()[1]==0 );
00804 assert( r.getOriginalPosition()[2]==1 );
00805 assert( r.getOriginalPosition()[3]==3 );
00806
00807 assert( r[ 0]==1. );
00808 assert( r[ 1]==10.);
00809 assert( r[ 2]==50.);
00810 assert( r[ 3]==0. );
00811 assert( r[ 4]==40.);
00812
00813 r.sortOriginalOrder();
00814
00815 assert( r.getIndices()[0]== 1 );
00816 assert( r.getElements()[0]==10. );
00817 assert( r.getIndices()[1]== 4 );
00818 assert( r.getElements()[1]==40. );
00819 assert( r.getIndices()[2]== 0 );
00820 assert( r.getElements()[2]== 1. );
00821 assert( r.getIndices()[3]== 2 );
00822 assert( r.getElements()[3]==50. );
00823
00824 OsiPackedVector r1;
00825 r1=r;
00826 assert( r==r1 );
00827 assert( r.isEquivalent(r1) );
00828 r.sortIncrElement();
00829 assert( r!=r1 );
00830 assert( r.isEquivalent(r1) );
00831
00832 OsiPackedVector add = r + r1;
00833 assert( add[0] == 1.+ 1. );
00834 assert( add[1] == 10.+10. );
00835 assert( add[2] == 50.+50. );
00836 assert( add[3] == 0.+ 0. );
00837 assert( add[4] == 40.+40. );
00838
00839 assert( r.sum() == 10.+40.+1.+50. );
00840 }
00841
00842 {
00843
00844 const int ne = 4;
00845 int inx[ne] = { 1, -4, 0, 2 };
00846 double el[ne] = { 10., 40., 1., 50. };
00847 OsiPackedVector r(ne,inx,el);
00848
00849 assert( r.findIndex(2) == 3 );
00850 assert( r.findIndex(0) == 2 );
00851 assert( r.findIndex(-4) == 1 );
00852 assert( r.findIndex(1) == 0 );
00853 assert( r.findIndex(3) == -1 );
00854 }
00855 #if 0
00856 {
00857
00858 const int ne = 4;
00859 int inx[ne] = { 1, -4, 0, 2 };
00860 double el[ne] = { 10., 40., 1., 50. };
00861 OsiPackedVector rT(ne,inx,el);
00862 OsiPackedVector r(false);
00863
00864 assert( !r.isExistingIndex(1) );
00865 r.insert(1,10.);
00866
00867 assert( !r.isExistingIndex(-4) );
00868 r.insert(-4,20.);
00869
00870 assert( !r.isExistingIndex(0) );
00871 r.insert(0,1.);
00872
00873 assert( r.isExistingIndex(-4) );
00874
00875
00876 int neg4Index = r.findIndex(-4);
00877 assert( neg4Index == 1 );
00878 r.setElement(neg4Index, r.getElements()[neg4Index] + 20);
00879
00880 assert( !r.isExistingIndex(2) );
00881 r.insert(2,50.);
00882
00883 assert( r == rT );
00884 }
00885 #endif
00886 }
00887