#include <CoinShallowPackedVector.hpp>
Inheritance diagram for CoinShallowPackedVector:
Public Member Functions | |
Get methods | |
virtual int | getNumElements () const |
Get length of indices and elements vectors. | |
virtual const int * | getIndices () const |
Get indices of elements. | |
virtual const double * | getElements () const |
Get element values. | |
Set methods | |
void | clear () |
Reset the vector (as if were just created an empty vector). | |
CoinShallowPackedVector & | operator= (const CoinShallowPackedVector &x) |
CoinShallowPackedVector & | operator= (const CoinPackedVectorBase &x) |
void | setVector (int size, const int *indices, const double *elements, bool testForDuplicateIndex=true) throw (CoinError) |
Methods to create, set and destroy | |
CoinShallowPackedVector (bool testForDuplicateIndex=true) | |
CoinShallowPackedVector (int size, const int *indices, const double *elements, bool testForDuplicateIndex=true) | |
CoinShallowPackedVector (const CoinPackedVectorBase &) | |
CoinShallowPackedVector (const CoinShallowPackedVector &) | |
~CoinShallowPackedVector () | |
Private Attributes | |
Private member data | |
const int * | indices_ |
Vector indices. | |
const double * | elements_ |
Vector elements. | |
int | nElements_ |
Size of indices and elements vectors. | |
Friends | |
void | CoinShallowPackedVectorUnitTest () |
This class is for sparse vectors where the indices and elements are stored elsewhere. This class only maintains pointers to the indices and elements. Since this class does not own the index and element data it provides read only access to to the data. An CoinSparsePackedVector must be used when the sparse vector's data will be altered.
This class stores pointers to the vectors. It does not actually contain the vectors.
Here is a sample usage:
const int ne = 4; int inx[ne] = { 1, 4, 0, 2 }; double el[ne] = { 10., 40., 1., 50. }; // Create vector and set its value CoinShallowPackedVector r(ne,inx,el); // access each index and element assert( r.indices ()[0]== 1 ); assert( r.elements()[0]==10. ); assert( r.indices ()[1]== 4 ); assert( r.elements()[1]==40. ); assert( r.indices ()[2]== 0 ); assert( r.elements()[2]== 1. ); assert( r.indices ()[3]== 2 ); assert( r.elements()[3]==50. ); // access as a full storage vector assert( r[ 0]==1. ); assert( r[ 1]==10.); assert( r[ 2]==50.); assert( r[ 3]==0. ); assert( r[ 4]==40.); // Tests for equality and equivalence CoinShallowPackedVector r1; r1=r; assert( r==r1 ); r.sort(CoinIncrElementOrdered()); assert( r!=r1 ); // Add packed vectors. // Similarly for subtraction, multiplication, // and division. CoinPackedVector add = r + r1; assert( add[0] == 1.+ 1. ); assert( add[1] == 10.+10. ); assert( add[2] == 50.+50. ); assert( add[3] == 0.+ 0. ); assert( add[4] == 40.+40. ); assert( r.sum() == 10.+40.+1.+50. );
Definition at line 71 of file CoinShallowPackedVector.hpp.
|
Default constructor. Definition at line 92 of file CoinShallowPackedVector.cpp. References CoinPackedVectorBase::setTestForDuplicateIndex().
00092 : 00093 CoinPackedVectorBase(), 00094 indices_(NULL), 00095 elements_(NULL), 00096 nElements_(0) 00097 { 00098 try { 00099 CoinPackedVectorBase::setTestForDuplicateIndex(testForDuplicateIndex); 00100 } 00101 catch (CoinError e) { 00102 throw CoinError("duplicate index", "default constructor", 00103 "CoinShallowPackedVector"); 00104 } 00105 } |
|
Explicit Constructor. Set vector size, indices, and elements. Size is the length of both the indices and elements vectors. The indices and elements vectors are not copied into this class instance. The ShallowPackedVector only maintains the pointers to the indices and elements vectors. Definition at line 110 of file CoinShallowPackedVector.cpp. References CoinPackedVectorBase::setTestForDuplicateIndex().
00113 : 00114 CoinPackedVectorBase(), 00115 indices_(inds), 00116 elements_(elems), 00117 nElements_(size) 00118 { 00119 try { 00120 CoinPackedVectorBase::setTestForDuplicateIndex(testForDuplicateIndex); 00121 } 00122 catch (CoinError e) { 00123 throw CoinError("duplicate index", "explicit constructor", 00124 "CoinShallowPackedVector"); 00125 } 00126 } |
|
Copy constructor from the base class. Definition at line 131 of file CoinShallowPackedVector.cpp. References CoinPackedVectorBase::setTestForDuplicateIndex().
00131 : 00132 CoinPackedVectorBase(), 00133 indices_(x.getIndices()), 00134 elements_(x.getElements()), 00135 nElements_(x.getNumElements()) 00136 { 00137 CoinPackedVectorBase::copyMaxMinIndex(x); 00138 try { 00139 CoinPackedVectorBase::setTestForDuplicateIndex(x.testForDuplicateIndex()); 00140 } 00141 catch (CoinError e) { 00142 throw CoinError("duplicate index", "copy constructor from base", 00143 "CoinShallowPackedVector"); 00144 } 00145 } |
|
Copy constructor. Definition at line 150 of file CoinShallowPackedVector.cpp. References CoinPackedVectorBase::setTestForDuplicateIndex().
00151 : 00152 CoinPackedVectorBase(), 00153 indices_(x.getIndices()), 00154 elements_(x.getElements()), 00155 nElements_(x.getNumElements()) 00156 { 00157 CoinPackedVectorBase::copyMaxMinIndex(x); 00158 try { 00159 CoinPackedVectorBase::setTestForDuplicateIndex(x.testForDuplicateIndex()); 00160 } 00161 catch (CoinError e) { 00162 throw CoinError("duplicate index", "copy constructor", 00163 "CoinShallowPackedVector"); 00164 } 00165 } } |
|
Destructor. Definition at line 119 of file CoinShallowPackedVector.hpp.
00119 {} |
|
Assignment operator from a CoinPackedVectorBase. Reimplemented from CoinPackedVectorBase. Definition at line 25 of file CoinShallowPackedVector.cpp. References CoinPackedVectorBase::duplicateIndex(), elements_, CoinPackedVectorBase::getElements(), CoinPackedVectorBase::getIndices(), CoinPackedVectorBase::getNumElements(), indices_, and nElements_.
00026 { 00027 if (&x != this) { 00028 indices_ = x.getIndices(); 00029 elements_ = x.getElements(); 00030 nElements_ = x.getNumElements(); 00031 CoinPackedVectorBase::clearBase(); 00032 CoinPackedVectorBase::copyMaxMinIndex(x); 00033 try { 00034 CoinPackedVectorBase::duplicateIndex(); 00035 } 00036 catch (CoinError e) { 00037 throw CoinError("duplicate index", "operator= from base", 00038 "CoinShallowPackedVector"); 00039 } 00040 } 00041 return *this; 00042 } |
|
Assignment operator. Definition at line 47 of file CoinShallowPackedVector.cpp. References CoinPackedVectorBase::duplicateIndex(), elements_, indices_, and nElements_.
00048 { 00049 if (&x != this) { 00050 indices_ = x.indices_; 00051 elements_ = x.elements_; 00052 nElements_ = x.nElements_; 00053 CoinPackedVectorBase::clearBase(); 00054 CoinPackedVectorBase::copyMaxMinIndex(x); 00055 try { 00056 CoinPackedVectorBase::duplicateIndex(); 00057 } 00058 catch (CoinError e) { 00059 throw CoinError("duplicate index", "operator=", 00060 "CoinShallowPackedVector"); 00061 } 00062 } 00063 return *this; 00064 } |
|
just like the explicit constructor Definition at line 69 of file CoinShallowPackedVector.cpp. References CoinPackedVectorBase::setTestForDuplicateIndex().
00073 { 00074 indices_ = inds; 00075 elements_ = elems; 00076 nElements_ = size; 00077 CoinPackedVectorBase::clearBase(); 00078 try { 00079 CoinPackedVectorBase::setTestForDuplicateIndex(testForDuplicateIndex); 00080 } 00081 catch (CoinError e) { 00082 throw CoinError("duplicate index", "setVector", 00083 "CoinShallowPackedVector"); 00084 } 00085 } |
|
A function that tests the methods in the CoinShallowPackedVector class. The only reason for it not to be a member method is that this way it doesn't have to be compiled into the library. And that's a gain, because the library should be compiled with optimization on, but this method should be compiled with debugging. Definition at line 18 of file CoinShallowPackedVectorTest.cpp.
00019 { 00020 CoinRelFltEq eq; 00021 int i; 00022 // Test default constructor 00023 { 00024 CoinShallowPackedVector r; 00025 assert( r.indices_==NULL ); 00026 assert( r.elements_==NULL ); 00027 assert( r.nElements_==0 ); 00028 } 00029 00030 // Test set and get methods 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 CoinShallowPackedVector r; 00036 assert( r.getNumElements()==0 ); 00037 00038 // Test setting/getting elements with int* & double* vectors 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 // try to clear it 00049 r.clear(); 00050 assert( r.indices_==NULL ); 00051 assert( r.elements_==NULL ); 00052 assert( r.nElements_==0 ); 00053 00054 // Test setting/getting elements with indices out of order 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 // try to call it once more 00070 assert ( r.getMaxIndex()==14 ); 00071 assert ( r.getMinIndex()==2 ); 00072 00073 CoinShallowPackedVector r1(ne2,inx2,el2); 00074 assert( r == r1 ); 00075 00076 // assignment operator 00077 r1.clear(); 00078 r1 = r; 00079 assert( r == r1 ); 00080 00081 // assignment from packed vector 00082 CoinPackedVector pv1(ne2,inx2,el2); 00083 r1 = pv1; 00084 assert( r == r1 ); 00085 00086 // construction 00087 CoinShallowPackedVector r2(r1); 00088 assert( r2 == r ); 00089 00090 // construction from packed vector 00091 CoinShallowPackedVector r3(pv1); 00092 assert( r3 == r ); 00093 00094 // test duplicate indices 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 CoinShallowPackedVector r1(ne3,inx3,el3); 00123 } 00124 catch (CoinError e) { 00125 errorThrown = true; 00126 } 00127 assert( errorThrown ); 00128 } 00129 00130 } 00131 00132 // Test copy constructor and assignment operator 00133 { 00134 CoinShallowPackedVector rhs; 00135 { 00136 CoinShallowPackedVector r; 00137 { 00138 CoinShallowPackedVector 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 CoinShallowPackedVector 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 // Test that rhs has correct values even though lhs has gone out of scope 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 // Test operator== 00170 { 00171 CoinShallowPackedVector 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 CoinShallowPackedVector v3(v1); 00182 assert( v3==v1 ); 00183 assert( v3!=v2 ); 00184 00185 CoinShallowPackedVector v4(v2); 00186 assert( v4!=v1 ); 00187 assert( v4==v2 ); 00188 } 00189 00190 00191 00192 { 00193 // Test operator[] and isExistingIndex() 00194 const int ne = 4; 00195 int inx[ne] = { 1, 4, 0, 2 }; 00196 double el[ne] = { 10., 40., 1., 50. }; 00197 CoinShallowPackedVector 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 // Test that attemping to get min/max index of a 0, 00223 // length vector 00224 { 00225 CoinShallowPackedVector nullVec; 00226 assert( nullVec.getMaxIndex() == 00227 /*std::numeric_limits<int>::max()*/INT_MIN/*0*/ ); 00228 assert( nullVec.getMinIndex() == 00229 /*std::numeric_limits<int>::min()*/INT_MAX/*0*/ ); 00230 } 00231 00232 { 00233 // test dense vector 00234 const int ne = 4; 00235 int inx[ne] = { 1, 4, 0, 2 }; 00236 double el[ne] = { 10., 40., 1., 50. }; 00237 CoinShallowPackedVector 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 // try once more 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 // what happens when someone sets 00266 // the number of elements to be a negative number 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 CoinShallowPackedVector v1; 00272 v1.setVector(-ne,inx1,el1); 00273 } 00274 #endif 00275 00276 00277 // Test adding vectors 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 CoinShallowPackedVector v1; 00286 v1.setVector(ne1,inx1,el1); 00287 CoinShallowPackedVector v2; 00288 v2.setVector(ne2,inx2,el2); 00289 CoinPackedVector 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 CoinPackedVector rV; 00295 rV.setVector(ner,inxr,elr); 00296 assert( rV != r ); 00297 assert( r.isEquivalent(rV) ); 00298 00299 CoinPackedVector 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 CoinPackedVector p2=(-3.1415) + p1; 00304 assert( p2.isEquivalent(v1) ); 00305 } 00306 00307 // Test subtracting vectors 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 CoinShallowPackedVector v1; 00316 v1.setVector(ne1,inx1,el1); 00317 CoinShallowPackedVector v2; 00318 v2.setVector(ne2,inx2,el2); 00319 CoinPackedVector 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 CoinPackedVector rV; 00325 rV.setVector(ner,inxr,elr); 00326 assert( r.isEquivalent(rV) ); 00327 00328 CoinPackedVector 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 // Test multiplying vectors 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 CoinShallowPackedVector v1; 00342 v1.setVector(ne1,inx1,el1); 00343 CoinShallowPackedVector v2; 00344 v2.setVector(ne2,inx2,el2); 00345 CoinPackedVector 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 CoinPackedVector rV; 00351 rV.setVector(ner,inxr,elr); 00352 assert( r.isEquivalent(rV) ); 00353 00354 CoinPackedVector 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 CoinPackedVector p2=(1./3.3) * p1; 00359 assert( p2.isEquivalent(v1) ); 00360 } 00361 00362 // Test dividing vectors 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 CoinShallowPackedVector v1; 00371 v1.setVector(ne1,inx1,el1); 00372 CoinShallowPackedVector v2; 00373 v2.setVector(ne2,inx2,el2); 00374 CoinPackedVector 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 CoinPackedVector rV; 00380 rV.setVector(ner,inxr,elr); 00381 assert( r.isEquivalent(rV) ); 00382 00383 CoinPackedVector 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 // Test sum 00389 { 00390 CoinShallowPackedVector 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 // Just another interesting test 00407 { 00408 // Create numerator vector 00409 const int ne1 = 2; 00410 int inx1[ne1] = { 1, 4 }; 00411 double el1[ne1] = { 1., 6. }; 00412 CoinShallowPackedVector v1(ne1,inx1,el1); 00413 00414 // create denominator vector 00415 const int ne2 = 3; 00416 int inx2[ne2] = { 1, 2, 4 }; 00417 double el2[ne2] = { 1., 7., 4.}; 00418 CoinShallowPackedVector v2(ne2,inx2,el2); 00419 00420 // Compute ratio 00421 CoinPackedVector ratio = v1 / v2; 00422 00423 // Sort ratios 00424 ratio.sortIncrElement(); 00425 00426 // Test that the sort really worked 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 // Get numerator of of sorted ratio vector 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 // Get denominator of of sorted ratio vector 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 // Test that sample usage works 00444 00445 const int ne = 4; 00446 int inx[ne] = { 1, 4, 0, 2 }; 00447 double el[ne] = { 10., 40., 1., 50. }; 00448 CoinShallowPackedVector 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 CoinShallowPackedVector r1; 00466 r1=r; 00467 assert( r==r1 ); 00468 00469 CoinPackedVector 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 // Test findIndex 00481 const int ne = 4; 00482 int inx[ne] = { 1, -4, 0, 2 }; 00483 double el[ne] = { 10., 40., 1., 50. }; 00484 CoinShallowPackedVector 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 // Test construction with testing for duplicates as false 00494 const int ne = 4; 00495 int inx[ne] = { 1, -4, 0, 2 }; 00496 double el[ne] = { 10., 40., 1., 50. }; 00497 CoinShallowPackedVector 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 } |