00001
00002
00003
00004
00005
00006 #ifndef CoinIndexedVector_H
00007 #define CoinIndexedVector_H
00008
00009 #if defined(_MSC_VER)
00010
00011 # pragma warning(disable:4786)
00012 #endif
00013
00014 #include <map>
00015 #ifndef CLP_NO_VECTOR
00016 #include "CoinPackedVectorBase.hpp"
00017 #endif
00018 #include "CoinSort.hpp"
00019 #include "CoinHelperFunctions.hpp"
00020 #include <cassert>
00021
00022 #ifndef COIN_FLOAT
00023 #define COIN_INDEXED_TINY_ELEMENT 1.0e-50
00024 #define COIN_INDEXED_REALLY_TINY_ELEMENT 1.0e-100
00025 #else
00026 #define COIN_INDEXED_TINY_ELEMENT 1.0e-35
00027 #define COIN_INDEXED_REALLY_TINY_ELEMENT 1.0e-39
00028 #endif
00029
00103 class CoinIndexedVector {
00104 friend void CoinIndexedVectorUnitTest();
00105
00106 public:
00109
00110 inline int getNumElements() const { return nElements_; }
00112 inline const int * getIndices() const { return indices_; }
00114
00116 inline int * getIndices() { return indices_; }
00120 inline double * denseVector() const { return elements_; }
00122 inline void setDenseVector(double * array)
00123 { elements_ = array;}
00125 inline void setIndexVector(int * array)
00126 { indices_ = array;}
00129 double & operator[](int i) const;
00130
00132
00133
00134
00135
00138
00139 inline void setNumElements(int value) { nElements_ = value;
00140 if (!nElements_) packedMode_=false;}
00142 void clear();
00144 void empty();
00146 CoinIndexedVector & operator=(const CoinIndexedVector &);
00147 #ifndef CLP_NO_VECTOR
00148
00150 CoinIndexedVector & operator=(const CoinPackedVectorBase & rhs);
00151 #endif
00152
00155 void copy(const CoinIndexedVector & rhs, double multiplier=1.0);
00156
00159 void borrowVector(int size, int numberIndices, int* inds, double* elems);
00160
00164 void returnVector();
00165
00170 void setVector(int numberIndices, const int * inds, const double * elems);
00171
00176 void setVector(int size, int numberIndices, const int * inds, const double * elems);
00177
00179 void setConstant(int size, const int * inds, double elems);
00180
00182 void setFull(int size, const double * elems);
00183
00187 void setElement(int index, double element);
00188
00190 void insert(int index, double element);
00193 void add(int index, double element);
00197 inline void quickAdd(int index, double element)
00198 {
00199 if (elements_[index]) {
00200 element += elements_[index];
00201 if ((element > 0 ? element : -element) >= COIN_INDEXED_TINY_ELEMENT) {
00202 elements_[index] = element;
00203 } else {
00204 elements_[index] = 1.0e-100;
00205 }
00206 } else if ((element > 0 ? element : -element) >= COIN_INDEXED_TINY_ELEMENT) {
00207 indices_[nElements_++] = index;
00208 assert (nElements_<=capacity_);
00209 elements_[index] = element;
00210 }
00211 }
00214 inline void zero(int index)
00215 {
00216 if (elements_[index])
00217 elements_[index] = 1.0e-100;
00218 }
00221 int clean(double tolerance);
00223 int cleanAndPack(double tolerance);
00225 int cleanAndPackSafe(double tolerance);
00227 inline void setPacked()
00228 { packedMode_ = true;}
00230 void checkClear();
00232 void checkClean();
00234 int scan();
00238 int scan(int start, int end);
00241 int scan(double tolerance);
00245 int scan(int start, int end, double tolerance);
00247 int scanAndPack();
00248 int scanAndPack(int start, int end);
00249 int scanAndPack(double tolerance);
00250 int scanAndPack(int start, int end, double tolerance);
00252 void createPacked(int number, const int * indices,
00253 const double * elements);
00255 void expand();
00256 #ifndef CLP_NO_VECTOR
00258 void append(const CoinPackedVectorBase & caboose);
00259 #endif
00261 void append(const CoinIndexedVector & caboose);
00262
00264 void swap(int i, int j);
00265
00267 void truncate(int newSize);
00269 void print() const;
00271
00273
00274 void operator+=(double value);
00276 void operator-=(double value);
00278 void operator*=(double value);
00280 void operator/=(double value);
00282
00285 #ifndef CLP_NO_VECTOR
00286
00288 bool operator==(const CoinPackedVectorBase & rhs) const;
00290 bool operator!=(const CoinPackedVectorBase & rhs) const;
00291 #endif
00292
00294 bool operator==(const CoinIndexedVector & rhs) const;
00296 bool operator!=(const CoinIndexedVector & rhs) const;
00298
00301
00302 int getMaxIndex() const;
00304 int getMinIndex() const;
00306
00307
00311 void sort()
00312 { std::sort(indices_,indices_+nElements_); }
00313
00314 void sortIncrIndex()
00315 { std::sort(indices_,indices_+nElements_); }
00316
00317 void sortDecrIndex();
00318
00319 void sortIncrElement();
00320
00321 void sortDecrElement();
00322
00324
00325
00326
00338
00339 CoinIndexedVector operator+(
00340 const CoinIndexedVector& op2);
00341
00343 CoinIndexedVector operator-(
00344 const CoinIndexedVector& op2);
00345
00347 CoinIndexedVector operator*(
00348 const CoinIndexedVector& op2);
00349
00351 CoinIndexedVector operator/(
00352 const CoinIndexedVector& op2);
00354 void operator+=(const CoinIndexedVector& op2);
00355
00357 void operator-=( const CoinIndexedVector& op2);
00358
00360 void operator*=(const CoinIndexedVector& op2);
00361
00363 void operator/=(const CoinIndexedVector& op2);
00365
00372 void reserve(int n);
00376 int capacity() const { return capacity_; }
00378 inline void setPackedMode(bool yesNo)
00379 { packedMode_=yesNo;}
00381 inline bool packedMode() const
00382 { return packedMode_;}
00384
00388 CoinIndexedVector();
00390 CoinIndexedVector(int size, const int * inds, const double * elems);
00392 CoinIndexedVector(int size, const int * inds, double element);
00395 CoinIndexedVector(int size, const double * elements);
00397 CoinIndexedVector(int size);
00399 CoinIndexedVector(const CoinIndexedVector &);
00401 CoinIndexedVector(const CoinIndexedVector *);
00402 #ifndef CLP_NO_VECTOR
00403
00404 CoinIndexedVector(const CoinPackedVectorBase & rhs);
00405 #endif
00406
00407 ~CoinIndexedVector ();
00409
00410 private:
00413
00414 void gutsOfSetVector(int size,
00415 const int * inds, const double * elems);
00416 void gutsOfSetVector(int size, int numberIndices,
00417 const int * inds, const double * elems);
00418 void gutsOfSetPackedVector(int size, int numberIndices,
00419 const int * inds, const double * elems);
00421 void gutsOfSetConstant(int size,
00422 const int * inds, double value);
00424
00425 private:
00428
00429 int * indices_;
00431 double * elements_;
00433 int nElements_;
00435 int capacity_;
00437 int offset_;
00439 bool packedMode_;
00441 };
00442
00443
00449 void
00450 CoinIndexedVectorUnitTest();
00467 class CoinArrayWithLength {
00468
00469 public:
00472
00473 inline int getSize() const
00474 { return size_; }
00476 inline int rawSize() const
00477 { return size_; }
00479 inline bool switchedOn() const
00480 { return size_!=-1; }
00482 inline int getCapacity() const
00483 { return (size_>-2) ? size_ : (-size_)-2; }
00485 inline void setCapacity()
00486 { if (size_<=-2) size_ = (-size_)-2; }
00488 inline const char * array() const
00489 { return (size_>-2) ? array_ : NULL; }
00491
00494
00495 inline void setSize(int value)
00496 { size_ = value; }
00498 inline void switchOff()
00499 { size_ = -1; }
00501 void setPersistence(int flag,int currentLength);
00503 void clear();
00505 void swap(CoinArrayWithLength & other);
00507 void extend(int newSize);
00509
00512
00513 char * conditionalNew(long sizeWanted);
00515 void conditionalDelete();
00517
00521 inline CoinArrayWithLength()
00522 { array_=NULL; size_=-1;}
00524 inline CoinArrayWithLength(int size)
00525 { array_=new char [size]; size_=-1;}
00530 inline CoinArrayWithLength(int size, int mode)
00531 { array_ = new char [size]; if (mode) memset(array_,0,size);size_=size;}
00533 CoinArrayWithLength(const CoinArrayWithLength & rhs);
00535 CoinArrayWithLength(const CoinArrayWithLength * rhs);
00537 CoinArrayWithLength& operator=(const CoinArrayWithLength & rhs);
00539 void copy(const CoinArrayWithLength & rhs, int numberBytes=-1);
00541 void allocate(const CoinArrayWithLength & rhs, int numberBytes);
00543 inline ~CoinArrayWithLength ()
00544 { delete [] array_; }
00545
00547
00548 protected:
00551
00552 char * array_;
00554 int size_;
00556 };
00558
00559 class CoinDoubleArrayWithLength : public CoinArrayWithLength {
00560
00561 public:
00564
00565 inline int getSize() const
00566 { return size_/CoinSizeofAsInt(double); }
00568 inline double * array() const
00569 { return reinterpret_cast<double *> ((size_>-2) ? array_ : NULL); }
00571
00574
00575 inline void setSize(int value)
00576 { size_ = value*CoinSizeofAsInt(double); }
00578
00581
00582 inline double * conditionalNew(int sizeWanted)
00583 { return reinterpret_cast<double *> ( CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> ((sizeWanted)*CoinSizeofAsInt(double)) : -1)); }
00585
00589 inline CoinDoubleArrayWithLength()
00590 { array_=NULL; size_=-1;}
00592 inline CoinDoubleArrayWithLength(int size)
00593 { array_=new char [size*CoinSizeofAsInt(double)]; size_=-1;}
00598 inline CoinDoubleArrayWithLength(int size, int mode)
00599 : CoinArrayWithLength(size*CoinSizeofAsInt(double),mode) {}
00601 inline CoinDoubleArrayWithLength(const CoinDoubleArrayWithLength & rhs)
00602 : CoinArrayWithLength(rhs) {}
00604 inline CoinDoubleArrayWithLength(const CoinDoubleArrayWithLength * rhs)
00605 : CoinArrayWithLength(rhs) {}
00607 inline CoinDoubleArrayWithLength& operator=(const CoinDoubleArrayWithLength & rhs)
00608 { CoinArrayWithLength::operator=(rhs); return *this;}
00610 };
00612
00613 class CoinFactorizationDoubleArrayWithLength : public CoinArrayWithLength {
00614
00615 public:
00618
00619 inline int getSize() const
00620 { return size_/CoinSizeofAsInt(CoinFactorizationDouble); }
00622 inline CoinFactorizationDouble * array() const
00623 { return reinterpret_cast<CoinFactorizationDouble *> ((size_>-2) ? array_ : NULL); }
00625
00628
00629 inline void setSize(int value)
00630 { size_ = value*CoinSizeofAsInt(CoinFactorizationDouble); }
00632
00635
00636 inline CoinFactorizationDouble * conditionalNew(int sizeWanted)
00637 { return reinterpret_cast<CoinFactorizationDouble *> (CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> (( sizeWanted)*CoinSizeofAsInt(CoinFactorizationDouble)) : -1)); }
00639
00643 inline CoinFactorizationDoubleArrayWithLength()
00644 { array_=NULL; size_=-1;}
00646 inline CoinFactorizationDoubleArrayWithLength(int size)
00647 { array_=new char [size*CoinSizeofAsInt(CoinFactorizationDouble)]; size_=-1;}
00652 inline CoinFactorizationDoubleArrayWithLength(int size, int mode)
00653 : CoinArrayWithLength(size*CoinSizeofAsInt(CoinFactorizationDouble),mode) {}
00655 inline CoinFactorizationDoubleArrayWithLength(const CoinFactorizationDoubleArrayWithLength & rhs)
00656 : CoinArrayWithLength(rhs) {}
00658 inline CoinFactorizationDoubleArrayWithLength(const CoinFactorizationDoubleArrayWithLength * rhs)
00659 : CoinArrayWithLength(rhs) {}
00661 inline CoinFactorizationDoubleArrayWithLength& operator=(const CoinFactorizationDoubleArrayWithLength & rhs)
00662 { CoinArrayWithLength::operator=(rhs); return *this;}
00664 };
00666
00667 class CoinIntArrayWithLength : public CoinArrayWithLength {
00668
00669 public:
00672
00673 inline int getSize() const
00674 { return size_/CoinSizeofAsInt(int); }
00676 inline int * array() const
00677 { return reinterpret_cast<int *> ((size_>-2) ? array_ : NULL); }
00679
00682
00683 inline void setSize(int value)
00684 { size_ = value*CoinSizeofAsInt(int); }
00686
00689
00690 inline int * conditionalNew(int sizeWanted)
00691 { return reinterpret_cast<int *> (CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> (( sizeWanted)*CoinSizeofAsInt(int)) : -1)); }
00693
00697 inline CoinIntArrayWithLength()
00698 { array_=NULL; size_=-1;}
00700 inline CoinIntArrayWithLength(int size)
00701 { array_=new char [size*CoinSizeofAsInt(int)]; size_=-1;}
00706 inline CoinIntArrayWithLength(int size, int mode)
00707 : CoinArrayWithLength(size*CoinSizeofAsInt(int),mode) {}
00709 inline CoinIntArrayWithLength(const CoinIntArrayWithLength & rhs)
00710 : CoinArrayWithLength(rhs) {}
00712 inline CoinIntArrayWithLength(const CoinIntArrayWithLength * rhs)
00713 : CoinArrayWithLength(rhs) {}
00715 inline CoinIntArrayWithLength& operator=(const CoinIntArrayWithLength & rhs)
00716 { CoinArrayWithLength::operator=(rhs); return *this;}
00718 };
00720
00721 class CoinBigIndexArrayWithLength : public CoinArrayWithLength {
00722
00723 public:
00726
00727 inline int getSize() const
00728 { return size_/CoinSizeofAsInt(CoinBigIndex); }
00730 inline CoinBigIndex * array() const
00731 { return reinterpret_cast<CoinBigIndex *> ((size_>-2) ? array_ : NULL); }
00733
00736
00737 inline void setSize(int value)
00738 { size_ = value*CoinSizeofAsInt(CoinBigIndex); }
00740
00743
00744 inline CoinBigIndex * conditionalNew(int sizeWanted)
00745 { return reinterpret_cast<CoinBigIndex *> (CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> (( sizeWanted)*CoinSizeofAsInt(CoinBigIndex)) : -1)); }
00747
00751 inline CoinBigIndexArrayWithLength()
00752 { array_=NULL; size_=-1;}
00754 inline CoinBigIndexArrayWithLength(int size)
00755 { array_=new char [size*CoinSizeofAsInt(CoinBigIndex)]; size_=-1;}
00760 inline CoinBigIndexArrayWithLength(int size, int mode)
00761 : CoinArrayWithLength(size*CoinSizeofAsInt(CoinBigIndex),mode) {}
00763 inline CoinBigIndexArrayWithLength(const CoinBigIndexArrayWithLength & rhs)
00764 : CoinArrayWithLength(rhs) {}
00766 inline CoinBigIndexArrayWithLength(const CoinBigIndexArrayWithLength * rhs)
00767 : CoinArrayWithLength(rhs) {}
00769 inline CoinBigIndexArrayWithLength& operator=(const CoinBigIndexArrayWithLength & rhs)
00770 { CoinArrayWithLength::operator=(rhs); return *this;}
00772 };
00774
00775 class CoinUnsignedIntArrayWithLength : public CoinArrayWithLength {
00776
00777 public:
00780
00781 inline int getSize() const
00782 { return size_/CoinSizeofAsInt(unsigned int); }
00784 inline unsigned int * array() const
00785 { return reinterpret_cast<unsigned int *> ((size_>-2) ? array_ : NULL); }
00787
00790
00791 inline void setSize(int value)
00792 { size_ = value*CoinSizeofAsInt(unsigned int); }
00794
00797
00798 inline unsigned int * conditionalNew(int sizeWanted)
00799 { return reinterpret_cast<unsigned int *> (CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> (( sizeWanted)*CoinSizeofAsInt(unsigned int)) : -1)); }
00801
00805 inline CoinUnsignedIntArrayWithLength()
00806 { array_=NULL; size_=-1;}
00808 inline CoinUnsignedIntArrayWithLength(int size)
00809 { array_=new char [size*CoinSizeofAsInt(unsigned int)]; size_=-1;}
00814 inline CoinUnsignedIntArrayWithLength(int size, int mode)
00815 : CoinArrayWithLength(size*CoinSizeofAsInt(unsigned int),mode) {}
00817 inline CoinUnsignedIntArrayWithLength(const CoinUnsignedIntArrayWithLength & rhs)
00818 : CoinArrayWithLength(rhs) {}
00820 inline CoinUnsignedIntArrayWithLength(const CoinUnsignedIntArrayWithLength * rhs)
00821 : CoinArrayWithLength(rhs) {}
00823 inline CoinUnsignedIntArrayWithLength& operator=(const CoinUnsignedIntArrayWithLength & rhs)
00824 { CoinArrayWithLength::operator=(rhs); return *this;}
00826 };
00827 #endif