00001
00002
00003 #if defined(_MSC_VER)
00004
00005 # pragma warning(disable:4786)
00006 #endif
00007
00008 #include <cassert>
00009
00010 #include "OsiShallowPackedVector.hpp"
00011 #include "OsiPackedVector.hpp"
00012
00013 #ifdef NDEBUG
00014 #undef NDEBUG
00015 #endif
00016
00017 void
00018 OsiShallowPackedVectorUnitTest()
00019 {
00020 OsiRelFltEq eq;
00021 int i;
00022
00023 {
00024 OsiShallowPackedVector r;
00025 assert( r.indices_==NULL );
00026 assert( r.elements_==NULL );
00027 assert( r.nElements_==0 );
00028 }
00029
00030
00031 const int ne = 4;
00032 int inx[ne] = { 1, 3, 4, 7 };
00033 double el[ne] = { 1.2, 3.4, 5.6, 7.8 };
00034 {
00035 OsiShallowPackedVector r;
00036 assert( r.getNumElements()==0 );
00037
00038
00039 r.setVector( ne, inx, el );
00040 assert( r.getNumElements()==ne );
00041 for ( i=0; i<ne; i++ ) {
00042 assert( r.getIndices()[i] == inx[i] );
00043 assert( r.getElements()[i] == el[i] );
00044 }
00045 assert ( r.getMaxIndex()==7 );
00046 assert ( r.getMinIndex()==1 );
00047
00048
00049 r.clear();
00050 assert( r.indices_==NULL );
00051 assert( r.elements_==NULL );
00052 assert( r.nElements_==0 );
00053
00054
00055 const int ne2 = 5;
00056 int inx2[ne2] = { 2, 4, 8, 14, 3 };
00057 double el2[ne2] = { 2.2, 4.4, 6.6, 8.8, 3.3 };
00058
00059 r.setVector(ne2,inx2,el2);
00060
00061 assert( r.getNumElements()==ne2 );
00062 for (i = 0; i < ne2; ++i) {
00063 assert( r.getIndices()[i]==inx2[i] );
00064 assert( r.getElements()[i]==el2[i] );
00065 }
00066
00067 assert ( r.getMaxIndex()==14 );
00068 assert ( r.getMinIndex()==2 );
00069
00070 assert ( r.getMaxIndex()==14 );
00071 assert ( r.getMinIndex()==2 );
00072
00073 OsiShallowPackedVector r1(ne2,inx2,el2);
00074 assert( r == r1 );
00075
00076
00077 r1.clear();
00078 r1 = r;
00079 assert( r == r1 );
00080
00081
00082 OsiPackedVector pv1(ne2,inx2,el2);
00083 r1 = pv1;
00084 assert( r == r1 );
00085
00086
00087 OsiShallowPackedVector r2(r1);
00088 assert( r2 == r );
00089
00090
00091 OsiShallowPackedVector r3(pv1);
00092 assert( r3 == r );
00093
00094
00095 {
00096 const int ne3 = 4;
00097 int inx3[ne3] = { 2, 4, 2, 3 };
00098 double el3[ne3] = { 2.2, 4.4, 8.8, 6.6 };
00099 r.setVector(ne3,inx3,el3, false);
00100 assert(r.testForDuplicateIndex() == false);
00101 bool errorThrown = false;
00102 try {
00103 r.setTestForDuplicateIndex(true);
00104 }
00105 catch (CoinError e) {
00106 errorThrown = true;
00107 }
00108 assert( errorThrown );
00109
00110 r.clear();
00111 errorThrown = false;
00112 try {
00113 r.setVector(ne3,inx3,el3);
00114 }
00115 catch (CoinError e) {
00116 errorThrown = true;
00117 }
00118 assert( errorThrown );
00119
00120 errorThrown = false;
00121 try {
00122 OsiShallowPackedVector r1(ne3,inx3,el3);
00123 }
00124 catch (CoinError e) {
00125 errorThrown = true;
00126 }
00127 assert( errorThrown );
00128 }
00129
00130 }
00131
00132
00133 {
00134 OsiShallowPackedVector rhs;
00135 {
00136 OsiShallowPackedVector r;
00137 {
00138 OsiShallowPackedVector rC1(r);
00139 assert( 0==r.getNumElements() );
00140 assert( 0==rC1.getNumElements() );
00141
00142 r.setVector( ne, inx, el );
00143
00144 assert( ne==r.getNumElements() );
00145 assert( 0==rC1.getNumElements() );
00146 }
00147
00148 OsiShallowPackedVector rC2(r);
00149
00150 assert( ne==r.getNumElements() );
00151 assert( ne==rC2.getNumElements() );
00152
00153 for ( i=0; i<ne; i++ ) {
00154 assert( r.getIndices()[i] == rC2.getIndices()[i] );
00155 assert( r.getElements()[i] == rC2.getElements()[i] );
00156 }
00157
00158 rhs=rC2;
00159 }
00160
00161 assert( rhs.getNumElements()==ne );
00162
00163 for ( i=0; i<ne; i++ ) {
00164 assert( inx[i] == rhs.getIndices()[i] );
00165 assert( el[i] == rhs.getElements()[i] );
00166 }
00167 }
00168
00169
00170 {
00171 OsiShallowPackedVector v1,v2;
00172 assert( v1==v2 );
00173 assert( v2==v1 );
00174 assert( v1==v1 );
00175 assert( !(v1!=v2) );
00176
00177 v1.setVector( ne, inx, el );
00178 assert ( !(v1==v2) );
00179 assert ( v1!=v2 );
00180
00181 OsiShallowPackedVector v3(v1);
00182 assert( v3==v1 );
00183 assert( v3!=v2 );
00184
00185 OsiShallowPackedVector v4(v2);
00186 assert( v4!=v1 );
00187 assert( v4==v2 );
00188 }
00189
00190
00191
00192 {
00193
00194 const int ne = 4;
00195 int inx[ne] = { 1, 4, 0, 2 };
00196 double el[ne] = { 10., 40., 1., 50. };
00197 OsiShallowPackedVector r;
00198 assert( r[1]==0. );
00199
00200 r.setVector(ne,inx,el);
00201
00202 assert( r[-1]==0. );
00203 assert( r[ 0]==1. );
00204 assert( r[ 1]==10.);
00205 assert( r[ 2]==50.);
00206 assert( r[ 3]==0. );
00207 assert( r[ 4]==40.);
00208 assert( r[ 5]==0. );
00209 assert( r.isExistingIndex(2) );
00210 assert( !r.isExistingIndex(3) );
00211
00212 assert( !r.isExistingIndex(-1) );
00213 assert( r.isExistingIndex(0) );
00214 assert( !r.isExistingIndex(3) );
00215 assert( r.isExistingIndex(4) );
00216 assert( !r.isExistingIndex(5) );
00217
00218 assert ( r.getMaxIndex()==4 );
00219 assert ( r.getMinIndex()==0 );
00220 }
00221
00222
00223
00224 {
00225 OsiShallowPackedVector nullVec;
00226 assert( nullVec.getMaxIndex() ==
00227 INT_MIN );
00228 assert( nullVec.getMinIndex() ==
00229 INT_MAX );
00230 }
00231
00232 {
00233
00234 const int ne = 4;
00235 int inx[ne] = { 1, 4, 0, 2 };
00236 double el[ne] = { 10., 40., 1., 50. };
00237 OsiShallowPackedVector r;
00238 r.setVector(ne,inx,el);
00239 double * dense = r.denseVector(6);
00240 assert(dense[0] == 1.);
00241 assert(dense[1] == 10.);
00242 assert(dense[2] == 50.);
00243 assert(dense[3] == 0.);
00244 assert(dense[4] == 40.);
00245 assert(dense[5] == 0.);
00246 delete[] dense;
00247
00248
00249 dense = r.denseVector(7);
00250 assert(dense[0] == 1.);
00251 assert(dense[1] == 10.);
00252 assert(dense[2] == 50.);
00253 assert(dense[3] == 0.);
00254 assert(dense[4] == 40.);
00255 assert(dense[5] == 0.);
00256 assert(dense[6] == 0.);
00257 delete[] dense;
00258
00259 }
00260
00261
00262
00263
00264 #if 0
00265
00266
00267 {
00268 const int ne = 4;
00269 int inx1[ne] = { 1, 3, 4, 7 };
00270 double el1[ne] = { 1.2, 3.4, 5.6, 7.8 };
00271 OsiShallowPackedVector v1;
00272 v1.setVector(-ne,inx1,el1);
00273 }
00274 #endif
00275
00276
00277
00278 {
00279 const int ne1 = 5;
00280 int inx1[ne1] = { 1, 3, 4, 7, 5 };
00281 double el1[ne1] = { 1., 5., 6., 2., 9. };
00282 const int ne2 = 4;
00283 int inx2[ne2] = { 7, 4, 2, 1 };
00284 double el2[ne2] = { 7., 4., 2., 1. };
00285 OsiShallowPackedVector v1;
00286 v1.setVector(ne1,inx1,el1);
00287 OsiShallowPackedVector v2;
00288 v2.setVector(ne2,inx2,el2);
00289 OsiPackedVector r = v1 + v2;
00290
00291 const int ner = 6;
00292 int inxr[ner] = { 1, 2, 3, 4, 5, 7 };
00293 double elr[ner] = { 1.+1., 0.+2., 5.+0., 6.+4., 9.+0., 2.+7. };
00294 OsiPackedVector rV;
00295 rV.setVector(ner,inxr,elr);
00296 assert( rV != r );
00297 assert( r.isEquivalent(rV) );
00298
00299 OsiPackedVector p1=v1+3.1415;
00300 for ( i=0; i<p1.getNumElements(); i++ )
00301 assert( eq( p1.getElements()[i], v1.getElements()[i]+3.1415) );
00302
00303 OsiPackedVector p2=(-3.1415) + p1;
00304 assert( p2.isEquivalent(v1) );
00305 }
00306
00307
00308 {
00309 const int ne1 = 5;
00310 int inx1[ne1] = { 1, 3, 4, 7, 5 };
00311 double el1[ne1] = { 1., 5., 6., 2., 9. };
00312 const int ne2 = 4;
00313 int inx2[ne2] = { 7, 4, 2, 1 };
00314 double el2[ne2] = { 7., 4., 2., 1. };
00315 OsiShallowPackedVector v1;
00316 v1.setVector(ne1,inx1,el1);
00317 OsiShallowPackedVector v2;
00318 v2.setVector(ne2,inx2,el2);
00319 OsiPackedVector r = v1 - v2;
00320
00321 const int ner = 6;
00322 int inxr[ner] = { 1, 2, 3, 4, 5, 7 };
00323 double elr[ner] = { 1.-1., 0.-2., 5.-0., 6.-4., 9.-0., 2.-7. };
00324 OsiPackedVector rV;
00325 rV.setVector(ner,inxr,elr);
00326 assert( r.isEquivalent(rV) );
00327
00328 OsiPackedVector p1=v1-3.1415;
00329 for ( i=0; i<p1.getNumElements(); i++ )
00330 assert( eq( p1.getElements()[i], v1.getElements()[i]-3.1415) );
00331 }
00332
00333
00334 {
00335 const int ne1 = 5;
00336 int inx1[ne1] = { 1, 3, 4, 7, 5 };
00337 double el1[ne1] = { 1., 5., 6., 2., 9. };
00338 const int ne2 = 4;
00339 int inx2[ne2] = { 7, 4, 2, 1 };
00340 double el2[ne2] = { 7., 4., 2., 1. };
00341 OsiShallowPackedVector v1;
00342 v1.setVector(ne1,inx1,el1);
00343 OsiShallowPackedVector v2;
00344 v2.setVector(ne2,inx2,el2);
00345 OsiPackedVector r = v1 * v2;
00346
00347 const int ner = 6;
00348 int inxr[ner] = { 1, 2, 3, 4, 5, 7 };
00349 double elr[ner] = { 1.*1., 0.*2., 5.*0., 6.*4., 9.*0., 2.*7. };
00350 OsiPackedVector rV;
00351 rV.setVector(ner,inxr,elr);
00352 assert( r.isEquivalent(rV) );
00353
00354 OsiPackedVector p1=v1*3.3;
00355 for ( i=0; i<p1.getNumElements(); i++ )
00356 assert( eq( p1.getElements()[i], v1.getElements()[i]*3.3) );
00357
00358 OsiPackedVector p2=(1./3.3) * p1;
00359 assert( p2.isEquivalent(v1) );
00360 }
00361
00362
00363 {
00364 const int ne1 = 3;
00365 int inx1[ne1] = { 1, 4, 7 };
00366 double el1[ne1] = { 1., 6., 2. };
00367 const int ne2 = 4;
00368 int inx2[ne2] = { 7, 4, 2, 1 };
00369 double el2[ne2] = { 7., 4., 2., 1. };
00370 OsiShallowPackedVector v1;
00371 v1.setVector(ne1,inx1,el1);
00372 OsiShallowPackedVector v2;
00373 v2.setVector(ne2,inx2,el2);
00374 OsiPackedVector r = v1 / v2;
00375
00376 const int ner = 4;
00377 int inxr[ner] = { 1, 2, 4, 7 };
00378 double elr[ner] = { 1./1., 0./2., 6./4., 2./7. };
00379 OsiPackedVector rV;
00380 rV.setVector(ner,inxr,elr);
00381 assert( r.isEquivalent(rV) );
00382
00383 OsiPackedVector p1=v1/3.1415;
00384 for ( i=0; i<p1.getNumElements(); i++ )
00385 assert( eq( p1.getElements()[i], v1.getElements()[i]/3.1415) );
00386 }
00387
00388
00389 {
00390 OsiShallowPackedVector s;
00391 assert( s.sum() == 0 );
00392
00393 int inx = 25;
00394 double value = 45.;
00395 s.setVector(1, &inx, &value);
00396 assert(s.sum()==45.);
00397
00398 const int ne1 = 5;
00399 int inx1[ne1] = { 10, 3, 4, 7, 5 };
00400 double el1[ne1] = { 1., 5., 6., 2., 9. };
00401 s.setVector(ne1,inx1,el1);
00402
00403 assert(s.sum()==1.+5.+6.+2.+9.);
00404 }
00405
00406
00407 {
00408
00409 const int ne1 = 2;
00410 int inx1[ne1] = { 1, 4 };
00411 double el1[ne1] = { 1., 6. };
00412 OsiShallowPackedVector v1(ne1,inx1,el1);
00413
00414
00415 const int ne2 = 3;
00416 int inx2[ne2] = { 1, 2, 4 };
00417 double el2[ne2] = { 1., 7., 4.};
00418 OsiShallowPackedVector v2(ne2,inx2,el2);
00419
00420
00421 OsiPackedVector ratio = v1 / v2;
00422
00423
00424 ratio.sortIncrElement();
00425
00426
00427 assert( ratio.getElements()[0] == 0.0/7.0 );
00428 assert( ratio.getElements()[1] == 1.0/1.0 );
00429 assert( ratio.getElements()[2] == 6.0/4.0 );
00430
00431
00432 assert( v1[ ratio.getIndices()[0] ] == 0.0 );
00433 assert( v1[ ratio.getIndices()[1] ] == 1.0 );
00434 assert( v1[ ratio.getIndices()[2] ] == 6.0 );
00435
00436
00437 assert( v2[ ratio.getIndices()[0] ] == 7.0 );
00438 assert( v2[ ratio.getIndices()[1] ] == 1.0 );
00439 assert( v2[ ratio.getIndices()[2] ] == 4.0 );
00440 }
00441
00442 {
00443
00444
00445 const int ne = 4;
00446 int inx[ne] = { 1, 4, 0, 2 };
00447 double el[ne] = { 10., 40., 1., 50. };
00448 OsiShallowPackedVector r(ne,inx,el);
00449
00450 assert( r.getIndices()[0]== 1 );
00451 assert( r.getElements()[0]==10. );
00452 assert( r.getIndices()[1]== 4 );
00453 assert( r.getElements()[1]==40. );
00454 assert( r.getIndices()[2]== 0 );
00455 assert( r.getElements()[2]== 1. );
00456 assert( r.getIndices()[3]== 2 );
00457 assert( r.getElements()[3]==50. );
00458
00459 assert( r[ 0]==1. );
00460 assert( r[ 1]==10.);
00461 assert( r[ 2]==50.);
00462 assert( r[ 3]==0. );
00463 assert( r[ 4]==40.);
00464
00465 OsiShallowPackedVector r1;
00466 r1=r;
00467 assert( r==r1 );
00468
00469 OsiPackedVector add = r + r1;
00470 assert( add[0] == 1.+ 1. );
00471 assert( add[1] == 10.+10. );
00472 assert( add[2] == 50.+50. );
00473 assert( add[3] == 0.+ 0. );
00474 assert( add[4] == 40.+40. );
00475
00476 assert( r.sum() == 10.+40.+1.+50. );
00477 }
00478
00479 {
00480
00481 const int ne = 4;
00482 int inx[ne] = { 1, -4, 0, 2 };
00483 double el[ne] = { 10., 40., 1., 50. };
00484 OsiShallowPackedVector r(ne,inx,el);
00485
00486 assert( r.findIndex(2) == 3 );
00487 assert( r.findIndex(0) == 2 );
00488 assert( r.findIndex(-4) == 1 );
00489 assert( r.findIndex(1) == 0 );
00490 assert( r.findIndex(3) == -1 );
00491 }
00492 {
00493
00494 const int ne = 4;
00495 int inx[ne] = { 1, -4, 0, 2 };
00496 double el[ne] = { 10., 40., 1., 50. };
00497 OsiShallowPackedVector r(ne,inx,el,false);
00498
00499 assert( r.isExistingIndex(1) );
00500 assert( r.isExistingIndex(-4) );
00501 assert( r.isExistingIndex(0) );
00502 assert( r.isExistingIndex(2) );
00503 assert( !r.isExistingIndex(3) );
00504 assert( !r.isExistingIndex(-3) );
00505 }
00506 }