CoinUtils
trunk
|
00001 /* $Id$ */ 00002 // Copyright (C) 2000, International Business Machines 00003 // Corporation and others. All Rights Reserved. 00004 // This code is licensed under the terms of the Eclipse Public License (EPL). 00005 00006 #ifndef CoinIndexedVector_H 00007 #define CoinIndexedVector_H 00008 00009 #if defined(_MSC_VER) 00010 // Turn off compiler warning about long names 00011 # pragma warning(disable:4786) 00012 #endif 00013 00014 #include <map> 00015 #include "CoinFinite.hpp" 00016 #ifndef CLP_NO_VECTOR 00017 #include "CoinPackedVectorBase.hpp" 00018 #endif 00019 #include "CoinSort.hpp" 00020 #include "CoinHelperFunctions.hpp" 00021 #include <cassert> 00022 00023 #ifndef COIN_FLOAT 00024 #define COIN_INDEXED_TINY_ELEMENT 1.0e-50 00025 #define COIN_INDEXED_REALLY_TINY_ELEMENT 1.0e-100 00026 #else 00027 #define COIN_INDEXED_TINY_ELEMENT 1.0e-35 00028 #define COIN_INDEXED_REALLY_TINY_ELEMENT 1.0e-39 00029 #endif 00030 00104 class CoinIndexedVector { 00105 friend void CoinIndexedVectorUnitTest(); 00106 00107 public: 00110 00111 inline int getNumElements() const { return nElements_; } 00113 inline const int * getIndices() const { return indices_; } 00115 // ** No longer supported virtual const double * getElements() const ; 00117 inline int * getIndices() { return indices_; } 00121 inline double * denseVector() const { return elements_; } 00123 inline void setDenseVector(double * array) 00124 { elements_ = array;} 00126 inline void setIndexVector(int * array) 00127 { indices_ = array;} 00130 double & operator[](int i) const; 00131 00133 00134 //------------------------------------------------------------------- 00135 // Set indices and elements 00136 //------------------------------------------------------------------- 00139 00140 inline void setNumElements(int value) { nElements_ = value; 00141 if (!nElements_) packedMode_=false;} 00143 void clear(); 00145 void empty(); 00147 CoinIndexedVector & operator=(const CoinIndexedVector &); 00148 #ifndef CLP_NO_VECTOR 00149 00151 CoinIndexedVector & operator=(const CoinPackedVectorBase & rhs); 00152 #endif 00153 00156 void copy(const CoinIndexedVector & rhs, double multiplier=1.0); 00157 00160 void borrowVector(int size, int numberIndices, int* inds, double* elems); 00161 00165 void returnVector(); 00166 00171 void setVector(int numberIndices, const int * inds, const double * elems); 00172 00177 void setVector(int size, int numberIndices, const int * inds, const double * elems); 00178 00180 void setConstant(int size, const int * inds, double elems); 00181 00183 void setFull(int size, const double * elems); 00184 00188 void setElement(int index, double element); 00189 00191 void insert(int index, double element); 00193 inline void quickInsert(int index, double element) 00194 { 00195 assert (!elements_[index]); 00196 indices_[nElements_++] = index; 00197 assert (nElements_<=capacity_); 00198 elements_[index] = element; 00199 } 00202 void add(int index, double element); 00206 inline void quickAdd(int index, double element) 00207 { 00208 if (elements_[index]) { 00209 element += elements_[index]; 00210 if ((element > 0 ? element : -element) >= COIN_INDEXED_TINY_ELEMENT) { 00211 elements_[index] = element; 00212 } else { 00213 elements_[index] = 1.0e-100; 00214 } 00215 } else if ((element > 0 ? element : -element) >= COIN_INDEXED_TINY_ELEMENT) { 00216 indices_[nElements_++] = index; 00217 assert (nElements_<=capacity_); 00218 elements_[index] = element; 00219 } 00220 } 00225 inline void quickAddNonZero(int index, double element) 00226 { 00227 assert (element); 00228 if (elements_[index]) { 00229 element += elements_[index]; 00230 if ((element > 0 ? element : -element) >= COIN_INDEXED_TINY_ELEMENT) { 00231 elements_[index] = element; 00232 } else { 00233 elements_[index] = COIN_DBL_MIN; 00234 } 00235 } else { 00236 indices_[nElements_++] = index; 00237 assert (nElements_<=capacity_); 00238 elements_[index] = element; 00239 } 00240 } 00243 inline void zero(int index) 00244 { 00245 if (elements_[index]) 00246 elements_[index] = COIN_DBL_MIN; 00247 } 00250 int clean(double tolerance); 00252 int cleanAndPack(double tolerance); 00254 int cleanAndPackSafe(double tolerance); 00256 inline void setPacked() 00257 { packedMode_ = true;} 00258 #ifndef NDEBUG 00259 00260 void checkClear(); 00262 void checkClean(); 00263 #else 00264 inline void checkClear() {}; 00265 inline void checkClean() {}; 00266 #endif 00267 00268 int scan(); 00272 int scan(int start, int end); 00275 int scan(double tolerance); 00279 int scan(int start, int end, double tolerance); 00281 int scanAndPack(); 00282 int scanAndPack(int start, int end); 00283 int scanAndPack(double tolerance); 00284 int scanAndPack(int start, int end, double tolerance); 00286 void createPacked(int number, const int * indices, 00287 const double * elements); 00289 void createUnpacked(int number, const int * indices, 00290 const double * elements); 00292 void createOneUnpackedElement(int index, double element); 00294 void expand(); 00295 #ifndef CLP_NO_VECTOR 00296 00297 void append(const CoinPackedVectorBase & caboose); 00298 #endif 00299 00300 void append(const CoinIndexedVector & caboose); 00302 void append(CoinIndexedVector & other,int adjustIndex,bool zapElements=false); 00303 00305 void swap(int i, int j); 00306 00308 void truncate(int newSize); 00310 void print() const; 00312 00314 00315 void operator+=(double value); 00317 void operator-=(double value); 00319 void operator*=(double value); 00321 void operator/=(double value); 00323 00326 #ifndef CLP_NO_VECTOR 00327 00329 bool operator==(const CoinPackedVectorBase & rhs) const; 00331 bool operator!=(const CoinPackedVectorBase & rhs) const; 00332 #endif 00333 00335 bool operator==(const CoinIndexedVector & rhs) const; 00337 bool operator!=(const CoinIndexedVector & rhs) const; 00339 int isApproximatelyEqual(const CoinIndexedVector & rhs, double tolerance=1.0e-8) const; 00341 00344 00345 int getMaxIndex() const; 00347 int getMinIndex() const; 00349 00350 00354 void sort() 00355 { std::sort(indices_,indices_+nElements_); } 00356 00357 void sortIncrIndex() 00358 { std::sort(indices_,indices_+nElements_); } 00359 00360 void sortDecrIndex(); 00361 00362 void sortIncrElement(); 00363 00364 void sortDecrElement(); 00365 void sortPacked(); 00366 00368 00369 //############################################################################# 00370 00382 00383 CoinIndexedVector operator+( 00384 const CoinIndexedVector& op2); 00385 00387 CoinIndexedVector operator-( 00388 const CoinIndexedVector& op2); 00389 00391 CoinIndexedVector operator*( 00392 const CoinIndexedVector& op2); 00393 00395 CoinIndexedVector operator/( 00396 const CoinIndexedVector& op2); 00398 void operator+=(const CoinIndexedVector& op2); 00399 00401 void operator-=( const CoinIndexedVector& op2); 00402 00404 void operator*=(const CoinIndexedVector& op2); 00405 00407 void operator/=(const CoinIndexedVector& op2); 00409 00416 void reserve(int n); 00420 int capacity() const { return capacity_; } 00422 inline void setPackedMode(bool yesNo) 00423 { packedMode_=yesNo;} 00425 inline bool packedMode() const 00426 { return packedMode_;} 00428 00432 CoinIndexedVector(); 00434 CoinIndexedVector(int size, const int * inds, const double * elems); 00436 CoinIndexedVector(int size, const int * inds, double element); 00439 CoinIndexedVector(int size, const double * elements); 00441 CoinIndexedVector(int size); 00443 CoinIndexedVector(const CoinIndexedVector &); 00445 CoinIndexedVector(const CoinIndexedVector *); 00446 #ifndef CLP_NO_VECTOR 00447 00448 CoinIndexedVector(const CoinPackedVectorBase & rhs); 00449 #endif 00450 00451 ~CoinIndexedVector (); 00453 00454 private: 00457 00458 void gutsOfSetVector(int size, 00459 const int * inds, const double * elems); 00460 void gutsOfSetVector(int size, int numberIndices, 00461 const int * inds, const double * elems); 00462 void gutsOfSetPackedVector(int size, int numberIndices, 00463 const int * inds, const double * elems); 00465 void gutsOfSetConstant(int size, 00466 const int * inds, double value); 00468 00469 protected: 00472 00473 int * indices_; 00475 double * elements_; 00477 int nElements_; 00479 int capacity_; 00481 int offset_; 00483 bool packedMode_; 00485 }; 00486 00487 //############################################################################# 00493 void 00494 CoinIndexedVectorUnitTest(); 00511 class CoinArrayWithLength { 00512 00513 public: 00516 00517 inline int getSize() const 00518 { return size_; } 00520 inline int rawSize() const 00521 { return size_; } 00523 inline bool switchedOn() const 00524 { return size_!=-1; } 00526 inline int capacity() const 00527 { return (size_>-2) ? size_ : (-size_)-2; } 00529 inline void setCapacity() 00530 { if (size_<=-2) size_ = (-size_)-2; } 00532 inline const char * array() const 00533 { return (size_>-2) ? array_ : NULL; } 00535 00538 00539 inline void setSize(int value) 00540 { size_ = value; } 00542 inline void switchOff() 00543 { size_ = -1; } 00545 inline void switchOn(int alignment=3) 00546 { size_ = -2; alignment_=alignment;} 00548 void setPersistence(int flag,int currentLength); 00550 void clear(); 00552 void swap(CoinArrayWithLength & other); 00554 void extend(int newSize); 00556 00559 00560 char * conditionalNew(long sizeWanted); 00562 void conditionalDelete(); 00564 00568 inline CoinArrayWithLength() 00569 : array_(NULL),size_(-1),offset_(0),alignment_(0) 00570 { } 00572 inline CoinArrayWithLength(int size) 00573 : size_(-1),offset_(0),alignment_(0) 00574 { array_=new char [size];} 00581 CoinArrayWithLength(int size, int mode); 00583 CoinArrayWithLength(const CoinArrayWithLength & rhs); 00585 CoinArrayWithLength(const CoinArrayWithLength * rhs); 00587 CoinArrayWithLength& operator=(const CoinArrayWithLength & rhs); 00589 void copy(const CoinArrayWithLength & rhs, int numberBytes=-1); 00591 void allocate(const CoinArrayWithLength & rhs, int numberBytes); 00593 ~CoinArrayWithLength (); 00595 void getArray(int size); 00597 void reallyFreeArray(); 00599 void getCapacity(int numberBytes,int numberIfNeeded=-1); 00601 00602 protected: 00605 00606 char * array_; 00608 CoinBigIndex size_; 00610 int offset_; 00612 int alignment_; 00614 }; 00616 00617 class CoinDoubleArrayWithLength : public CoinArrayWithLength { 00618 00619 public: 00622 00623 inline int getSize() const 00624 { return size_/CoinSizeofAsInt(double); } 00626 inline double * array() const 00627 { return reinterpret_cast<double *> ((size_>-2) ? array_ : NULL); } 00629 00632 00633 inline void setSize(int value) 00634 { size_ = value*CoinSizeofAsInt(double); } 00636 00639 00640 inline double * conditionalNew(int sizeWanted) 00641 { return reinterpret_cast<double *> ( CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> ((sizeWanted)*CoinSizeofAsInt(double)) : -1)); } 00643 00647 inline CoinDoubleArrayWithLength() 00648 { array_=NULL; size_=-1;} 00650 inline CoinDoubleArrayWithLength(int size) 00651 { array_=new char [size*CoinSizeofAsInt(double)]; size_=-1;} 00656 inline CoinDoubleArrayWithLength(int size, int mode) 00657 : CoinArrayWithLength(size*CoinSizeofAsInt(double),mode) {} 00659 inline CoinDoubleArrayWithLength(const CoinDoubleArrayWithLength & rhs) 00660 : CoinArrayWithLength(rhs) {} 00662 inline CoinDoubleArrayWithLength(const CoinDoubleArrayWithLength * rhs) 00663 : CoinArrayWithLength(rhs) {} 00665 inline CoinDoubleArrayWithLength& operator=(const CoinDoubleArrayWithLength & rhs) 00666 { CoinArrayWithLength::operator=(rhs); return *this;} 00668 }; 00670 00671 class CoinFactorizationDoubleArrayWithLength : public CoinArrayWithLength { 00672 00673 public: 00676 00677 inline int getSize() const 00678 { return size_/CoinSizeofAsInt(CoinFactorizationDouble); } 00680 inline CoinFactorizationDouble * array() const 00681 { return reinterpret_cast<CoinFactorizationDouble *> ((size_>-2) ? array_ : NULL); } 00683 00686 00687 inline void setSize(int value) 00688 { size_ = value*CoinSizeofAsInt(CoinFactorizationDouble); } 00690 00693 00694 inline CoinFactorizationDouble * conditionalNew(int sizeWanted) 00695 { return reinterpret_cast<CoinFactorizationDouble *> (CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> (( sizeWanted)*CoinSizeofAsInt(CoinFactorizationDouble)) : -1)); } 00697 00701 inline CoinFactorizationDoubleArrayWithLength() 00702 { array_=NULL; size_=-1;} 00704 inline CoinFactorizationDoubleArrayWithLength(int size) 00705 { array_=new char [size*CoinSizeofAsInt(CoinFactorizationDouble)]; size_=-1;} 00710 inline CoinFactorizationDoubleArrayWithLength(int size, int mode) 00711 : CoinArrayWithLength(size*CoinSizeofAsInt(CoinFactorizationDouble),mode) {} 00713 inline CoinFactorizationDoubleArrayWithLength(const CoinFactorizationDoubleArrayWithLength & rhs) 00714 : CoinArrayWithLength(rhs) {} 00716 inline CoinFactorizationDoubleArrayWithLength(const CoinFactorizationDoubleArrayWithLength * rhs) 00717 : CoinArrayWithLength(rhs) {} 00719 inline CoinFactorizationDoubleArrayWithLength& operator=(const CoinFactorizationDoubleArrayWithLength & rhs) 00720 { CoinArrayWithLength::operator=(rhs); return *this;} 00722 }; 00724 00725 class CoinFactorizationLongDoubleArrayWithLength : public CoinArrayWithLength { 00726 00727 public: 00730 00731 inline int getSize() const 00732 { return size_/CoinSizeofAsInt(long double); } 00734 inline long double * array() const 00735 { return reinterpret_cast<long double *> ((size_>-2) ? array_ : NULL); } 00737 00740 00741 inline void setSize(int value) 00742 { size_ = value*CoinSizeofAsInt(long double); } 00744 00747 00748 inline long double * conditionalNew(int sizeWanted) 00749 { return reinterpret_cast<long double *> (CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> (( sizeWanted)*CoinSizeofAsInt(long double)) : -1)); } 00751 00755 inline CoinFactorizationLongDoubleArrayWithLength() 00756 { array_=NULL; size_=-1;} 00758 inline CoinFactorizationLongDoubleArrayWithLength(int size) 00759 { array_=new char [size*CoinSizeofAsInt(long double)]; size_=-1;} 00764 inline CoinFactorizationLongDoubleArrayWithLength(int size, int mode) 00765 : CoinArrayWithLength(size*CoinSizeofAsInt(long double),mode) {} 00767 inline CoinFactorizationLongDoubleArrayWithLength(const CoinFactorizationLongDoubleArrayWithLength & rhs) 00768 : CoinArrayWithLength(rhs) {} 00770 inline CoinFactorizationLongDoubleArrayWithLength(const CoinFactorizationLongDoubleArrayWithLength * rhs) 00771 : CoinArrayWithLength(rhs) {} 00773 inline CoinFactorizationLongDoubleArrayWithLength& operator=(const CoinFactorizationLongDoubleArrayWithLength & rhs) 00774 { CoinArrayWithLength::operator=(rhs); return *this;} 00776 }; 00778 00779 class CoinIntArrayWithLength : public CoinArrayWithLength { 00780 00781 public: 00784 00785 inline int getSize() const 00786 { return size_/CoinSizeofAsInt(int); } 00788 inline int * array() const 00789 { return reinterpret_cast<int *> ((size_>-2) ? array_ : NULL); } 00791 00794 00795 inline void setSize(int value) 00796 { size_ = value*CoinSizeofAsInt(int); } 00798 00801 00802 inline int * conditionalNew(int sizeWanted) 00803 { return reinterpret_cast<int *> (CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> (( sizeWanted)*CoinSizeofAsInt(int)) : -1)); } 00805 00809 inline CoinIntArrayWithLength() 00810 { array_=NULL; size_=-1;} 00812 inline CoinIntArrayWithLength(int size) 00813 { array_=new char [size*CoinSizeofAsInt(int)]; size_=-1;} 00818 inline CoinIntArrayWithLength(int size, int mode) 00819 : CoinArrayWithLength(size*CoinSizeofAsInt(int),mode) {} 00821 inline CoinIntArrayWithLength(const CoinIntArrayWithLength & rhs) 00822 : CoinArrayWithLength(rhs) {} 00824 inline CoinIntArrayWithLength(const CoinIntArrayWithLength * rhs) 00825 : CoinArrayWithLength(rhs) {} 00827 inline CoinIntArrayWithLength& operator=(const CoinIntArrayWithLength & rhs) 00828 { CoinArrayWithLength::operator=(rhs); return *this;} 00830 }; 00832 00833 class CoinBigIndexArrayWithLength : public CoinArrayWithLength { 00834 00835 public: 00838 00839 inline int getSize() const 00840 { return size_/CoinSizeofAsInt(CoinBigIndex); } 00842 inline CoinBigIndex * array() const 00843 { return reinterpret_cast<CoinBigIndex *> ((size_>-2) ? array_ : NULL); } 00845 00848 00849 inline void setSize(int value) 00850 { size_ = value*CoinSizeofAsInt(CoinBigIndex); } 00852 00855 00856 inline CoinBigIndex * conditionalNew(int sizeWanted) 00857 { return reinterpret_cast<CoinBigIndex *> (CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> (( sizeWanted)*CoinSizeofAsInt(CoinBigIndex)) : -1)); } 00859 00863 inline CoinBigIndexArrayWithLength() 00864 { array_=NULL; size_=-1;} 00866 inline CoinBigIndexArrayWithLength(int size) 00867 { array_=new char [size*CoinSizeofAsInt(CoinBigIndex)]; size_=-1;} 00872 inline CoinBigIndexArrayWithLength(int size, int mode) 00873 : CoinArrayWithLength(size*CoinSizeofAsInt(CoinBigIndex),mode) {} 00875 inline CoinBigIndexArrayWithLength(const CoinBigIndexArrayWithLength & rhs) 00876 : CoinArrayWithLength(rhs) {} 00878 inline CoinBigIndexArrayWithLength(const CoinBigIndexArrayWithLength * rhs) 00879 : CoinArrayWithLength(rhs) {} 00881 inline CoinBigIndexArrayWithLength& operator=(const CoinBigIndexArrayWithLength & rhs) 00882 { CoinArrayWithLength::operator=(rhs); return *this;} 00884 }; 00886 00887 class CoinUnsignedIntArrayWithLength : public CoinArrayWithLength { 00888 00889 public: 00892 00893 inline int getSize() const 00894 { return size_/CoinSizeofAsInt(unsigned int); } 00896 inline unsigned int * array() const 00897 { return reinterpret_cast<unsigned int *> ((size_>-2) ? array_ : NULL); } 00899 00902 00903 inline void setSize(int value) 00904 { size_ = value*CoinSizeofAsInt(unsigned int); } 00906 00909 00910 inline unsigned int * conditionalNew(int sizeWanted) 00911 { return reinterpret_cast<unsigned int *> (CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> (( sizeWanted)*CoinSizeofAsInt(unsigned int)) : -1)); } 00913 00917 inline CoinUnsignedIntArrayWithLength() 00918 { array_=NULL; size_=-1;} 00920 inline CoinUnsignedIntArrayWithLength(int size) 00921 { array_=new char [size*CoinSizeofAsInt(unsigned int)]; size_=-1;} 00926 inline CoinUnsignedIntArrayWithLength(int size, int mode) 00927 : CoinArrayWithLength(size*CoinSizeofAsInt(unsigned int),mode) {} 00929 inline CoinUnsignedIntArrayWithLength(const CoinUnsignedIntArrayWithLength & rhs) 00930 : CoinArrayWithLength(rhs) {} 00932 inline CoinUnsignedIntArrayWithLength(const CoinUnsignedIntArrayWithLength * rhs) 00933 : CoinArrayWithLength(rhs) {} 00935 inline CoinUnsignedIntArrayWithLength& operator=(const CoinUnsignedIntArrayWithLength & rhs) 00936 { CoinArrayWithLength::operator=(rhs); return *this;} 00938 }; 00940 00941 class CoinVoidStarArrayWithLength : public CoinArrayWithLength { 00942 00943 public: 00946 00947 inline int getSize() const 00948 { return size_/CoinSizeofAsInt(void *); } 00950 inline void ** array() const 00951 { return reinterpret_cast<void **> ((size_>-2) ? array_ : NULL); } 00953 00956 00957 inline void setSize(int value) 00958 { size_ = value*CoinSizeofAsInt(void *); } 00960 00963 00964 inline void ** conditionalNew(int sizeWanted) 00965 { return reinterpret_cast<void **> ( CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> ((sizeWanted)*CoinSizeofAsInt(void *)) : -1)); } 00967 00971 inline CoinVoidStarArrayWithLength() 00972 { array_=NULL; size_=-1;} 00974 inline CoinVoidStarArrayWithLength(int size) 00975 { array_=new char [size*CoinSizeofAsInt(void *)]; size_=-1;} 00980 inline CoinVoidStarArrayWithLength(int size, int mode) 00981 : CoinArrayWithLength(size*CoinSizeofAsInt(void *),mode) {} 00983 inline CoinVoidStarArrayWithLength(const CoinVoidStarArrayWithLength & rhs) 00984 : CoinArrayWithLength(rhs) {} 00986 inline CoinVoidStarArrayWithLength(const CoinVoidStarArrayWithLength * rhs) 00987 : CoinArrayWithLength(rhs) {} 00989 inline CoinVoidStarArrayWithLength& operator=(const CoinVoidStarArrayWithLength & rhs) 00990 { CoinArrayWithLength::operator=(rhs); return *this;} 00992 }; 00994 00995 class CoinArbitraryArrayWithLength : public CoinArrayWithLength { 00996 00997 public: 01000 01001 inline int getSize() const 01002 { return size_/lengthInBytes_; } 01004 inline void ** array() const 01005 { return reinterpret_cast<void **> ((size_>-2) ? array_ : NULL); } 01007 01010 01011 inline void setSize(int value) 01012 { size_ = value*lengthInBytes_; } 01014 01017 01018 inline char * conditionalNew(int length, int sizeWanted) 01019 { lengthInBytes_=length;return reinterpret_cast<char *> ( CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> 01020 ((sizeWanted)*lengthInBytes_) : -1)); } 01022 01026 inline CoinArbitraryArrayWithLength(int length=1) 01027 { array_=NULL; size_=-1;lengthInBytes_=length;} 01029 inline CoinArbitraryArrayWithLength(int length, int size) 01030 { array_=new char [size*length]; size_=-1; lengthInBytes_=length;} 01035 inline CoinArbitraryArrayWithLength(int length, int size, int mode) 01036 : CoinArrayWithLength(size*length,mode) {lengthInBytes_=length;} 01038 inline CoinArbitraryArrayWithLength(const CoinArbitraryArrayWithLength & rhs) 01039 : CoinArrayWithLength(rhs) {} 01041 inline CoinArbitraryArrayWithLength(const CoinArbitraryArrayWithLength * rhs) 01042 : CoinArrayWithLength(rhs) {} 01044 inline CoinArbitraryArrayWithLength& operator=(const CoinArbitraryArrayWithLength & rhs) 01045 { CoinArrayWithLength::operator=(rhs); return *this;} 01047 01048 protected: 01051 01052 int lengthInBytes_; 01054 }; 01055 class CoinPartitionedVector : public CoinIndexedVector { 01056 01057 public: 01058 #ifndef COIN_PARTITIONS 01059 #define COIN_PARTITIONS 8 01060 #endif 01061 01063 01064 inline int getNumElements(int partition) const { assert (partition<COIN_PARTITIONS); 01065 return numberElementsPartition_[partition]; } 01067 inline int getNumPartitions() const 01068 { return numberPartitions_; } 01070 inline int getNumElements() const { return nElements_; } 01072 inline int startPartition(int partition) const { assert (partition<=COIN_PARTITIONS); 01073 return startPartition_[partition]; } 01075 inline const int * startPartitions() const 01076 { return startPartition_; } 01078 01079 //------------------------------------------------------------------- 01080 // Set indices and elements 01081 //------------------------------------------------------------------- 01084 01085 inline void setNumElementsPartition(int partition, int value) { assert (partition<COIN_PARTITIONS); 01086 if (numberPartitions_) numberElementsPartition_[partition]=value; } 01088 inline void setTempNumElementsPartition(int partition, int value) { assert (partition<COIN_PARTITIONS); 01089 numberElementsPartition_[partition]=value; } 01091 void computeNumberElements(); 01093 void compact(); 01096 void reserve(int n); 01098 void setPartitions(int number,const int * starts); 01100 void clearAndReset(); 01102 void clearAndKeep(); 01104 void clearPartition(int partition); 01105 #ifndef NDEBUG 01106 01107 void checkClear(); 01109 void checkClean(); 01110 #else 01111 inline void checkClear() {}; 01112 inline void checkClean() {}; 01113 #endif 01114 01115 int scan(int partition, double tolerance=0.0); 01119 01120 void print() const; 01122 01126 void sort(); 01128 01132 CoinPartitionedVector(); 01134 CoinPartitionedVector(int size, const int * inds, const double * elems); 01136 CoinPartitionedVector(int size, const int * inds, double element); 01139 CoinPartitionedVector(int size, const double * elements); 01141 CoinPartitionedVector(int size); 01143 CoinPartitionedVector(const CoinPartitionedVector &); 01145 CoinPartitionedVector(const CoinPartitionedVector *); 01147 CoinPartitionedVector & operator=(const CoinPartitionedVector &); 01149 ~CoinPartitionedVector (); 01151 protected: 01154 01155 int startPartition_[COIN_PARTITIONS+1]; 01157 int numberElementsPartition_[COIN_PARTITIONS]; 01159 int numberPartitions_; 01161 }; 01162 #endif