# CoinIndexedVector.hpp

Go to the documentation of this file.

    00001 /* $Id: CoinIndexedVector.hpp 1767 2015-01-05 12:36:13Z forrest $ */
    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
    00260    void checkClear();
    00262    void checkClean();
    00263 #else
    00264   inline void checkClear() {};
    00265   inline void checkClean() {};
    00266 #endif
    00268    int scan();
    00269
    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
    00297    void append(const CoinPackedVectorBase & caboose);
    00298 #endif
    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    inline int capacity() const { return capacity_; }
    00421    inline void setCapacity(int value)
    00422    { capacity_ = value; }
    00424    inline void setPackedMode(bool yesNo)
    00425    { packedMode_=yesNo;}
    00427    inline bool packedMode() const
    00428    { return packedMode_;}
    00430
    00434    CoinIndexedVector();
    00436   CoinIndexedVector(int size, const int * inds, const double * elems);
    00438   CoinIndexedVector(int size, const int * inds, double element);
    00441   CoinIndexedVector(int size, const double * elements);
    00443   CoinIndexedVector(int size);
    00445    CoinIndexedVector(const CoinIndexedVector &);
    00447    CoinIndexedVector(const CoinIndexedVector *);
    00448 #ifndef CLP_NO_VECTOR
    00449
    00450    CoinIndexedVector(const CoinPackedVectorBase & rhs);
    00451 #endif
    00452
    00453    ~CoinIndexedVector ();
    00455
    00456 private:
    00459
    00460    void gutsOfSetVector(int size,
    00461                         const int * inds, const double * elems);
    00462    void gutsOfSetVector(int size, int numberIndices,
    00463                         const int * inds, const double * elems);
    00464    void gutsOfSetPackedVector(int size, int numberIndices,
    00465                         const int * inds, const double * elems);
    00467    void gutsOfSetConstant(int size,
    00468                           const int * inds, double value);
    00470
    00471 protected:
    00474
    00475    int * indices_;
    00477    double * elements_;
    00479    int nElements_;
    00481    int capacity_;
    00483    int offset_;
    00485    bool packedMode_;
    00487 };
    00488
    00489 //#############################################################################
    00495 void
    00496 CoinIndexedVectorUnitTest();
    00513 class CoinArrayWithLength {
    00514
    00515 public:
    00518
    00519   inline int getSize() const
    00520   { return size_; }
    00522   inline int rawSize() const
    00523   { return size_; }
    00525   inline bool switchedOn() const
    00526   { return size_!=-1; }
    00528   inline int capacity() const
    00529   { return (size_>-2) ? size_ : (-size_)-2; }
    00531   inline void setCapacity()
    00532   { if (size_<=-2) size_ = (-size_)-2; }
    00534   inline const char * array() const
    00535   { return (size_>-2) ? array_ : NULL; }
    00537
    00540
    00541   inline void setSize(int value)
    00542   { size_ = value; }
    00544   inline void switchOff()
    00545   { size_ = -1; }
    00547   inline void switchOn(int alignment=3)
    00548   { size_ = -2; alignment_=alignment;}
    00550   void setPersistence(int flag,int currentLength);
    00552   void clear();
    00554   void swap(CoinArrayWithLength & other);
    00556   void extend(int newSize);
    00558
    00561
    00562   char * conditionalNew(long sizeWanted);
    00564   void conditionalDelete();
    00566
    00570   inline CoinArrayWithLength()
    00571     : array_(NULL),size_(-1),offset_(0),alignment_(0)
    00572   { }
    00574   inline CoinArrayWithLength(int size)
    00575     : size_(-1),offset_(0),alignment_(0)
    00576   { array_=new char [size];}
    00583   CoinArrayWithLength(int size, int mode);
    00585   CoinArrayWithLength(const CoinArrayWithLength & rhs);
    00587   CoinArrayWithLength(const CoinArrayWithLength * rhs);
    00589   CoinArrayWithLength& operator=(const CoinArrayWithLength & rhs);
    00591   void copy(const CoinArrayWithLength & rhs, int numberBytes=-1);
    00593   void allocate(const CoinArrayWithLength & rhs, int numberBytes);
    00595   ~CoinArrayWithLength ();
    00597   void getArray(int size);
    00599   void reallyFreeArray();
    00601   void getCapacity(int numberBytes,int numberIfNeeded=-1);
    00603
    00604 protected:
    00607
    00608   char * array_;
    00610   CoinBigIndex size_;
    00612   int offset_;
    00614   int alignment_;
    00616 };
    00618
    00619 class CoinDoubleArrayWithLength : public CoinArrayWithLength {
    00620
    00621 public:
    00624
    00625   inline int getSize() const
    00626   { return size_/CoinSizeofAsInt(double); }
    00628   inline double * array() const
    00629   { return reinterpret_cast<double *> ((size_>-2) ? array_ : NULL); }
    00631
    00634
    00635   inline void setSize(int value)
    00636   { size_ = value*CoinSizeofAsInt(double); }
    00638
    00641
    00642   inline double * conditionalNew(int sizeWanted)
    00643   { return reinterpret_cast<double *> ( CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> ((sizeWanted)*CoinSizeofAsInt(double)) : -1)); }
    00645
    00649   inline CoinDoubleArrayWithLength()
    00650   { array_=NULL; size_=-1;}
    00652   inline CoinDoubleArrayWithLength(int size)
    00653   { array_=new char [size*CoinSizeofAsInt(double)]; size_=-1;}
    00658   inline CoinDoubleArrayWithLength(int size, int mode)
    00659     : CoinArrayWithLength(size*CoinSizeofAsInt(double),mode) {}
    00661   inline CoinDoubleArrayWithLength(const CoinDoubleArrayWithLength & rhs)
    00662     : CoinArrayWithLength(rhs) {}
    00664   inline CoinDoubleArrayWithLength(const CoinDoubleArrayWithLength * rhs)
    00665     : CoinArrayWithLength(rhs) {}
    00667   inline CoinDoubleArrayWithLength& operator=(const CoinDoubleArrayWithLength & rhs)
    00668   { CoinArrayWithLength::operator=(rhs);  return *this;}
    00670 };
    00672
    00673 class CoinFactorizationDoubleArrayWithLength : public CoinArrayWithLength {
    00674
    00675 public:
    00678
    00679   inline int getSize() const
    00680   { return size_/CoinSizeofAsInt(CoinFactorizationDouble); }
    00682   inline CoinFactorizationDouble * array() const
    00683   { return reinterpret_cast<CoinFactorizationDouble *> ((size_>-2) ? array_ : NULL); }
    00685
    00688
    00689   inline void setSize(int value)
    00690   { size_ = value*CoinSizeofAsInt(CoinFactorizationDouble); }
    00692
    00695
    00696   inline CoinFactorizationDouble * conditionalNew(int sizeWanted)
    00697   { return reinterpret_cast<CoinFactorizationDouble *> (CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> (( sizeWanted)*CoinSizeofAsInt(CoinFactorizationDouble)) : -1)); }
    00699
    00703   inline CoinFactorizationDoubleArrayWithLength()
    00704   { array_=NULL; size_=-1;}
    00706   inline CoinFactorizationDoubleArrayWithLength(int size)
    00707   { array_=new char [size*CoinSizeofAsInt(CoinFactorizationDouble)]; size_=-1;}
    00712   inline CoinFactorizationDoubleArrayWithLength(int size, int mode)
    00713     : CoinArrayWithLength(size*CoinSizeofAsInt(CoinFactorizationDouble),mode) {}
    00715   inline CoinFactorizationDoubleArrayWithLength(const CoinFactorizationDoubleArrayWithLength & rhs)
    00716     : CoinArrayWithLength(rhs) {}
    00718   inline CoinFactorizationDoubleArrayWithLength(const CoinFactorizationDoubleArrayWithLength * rhs)
    00719     : CoinArrayWithLength(rhs) {}
    00721   inline CoinFactorizationDoubleArrayWithLength& operator=(const CoinFactorizationDoubleArrayWithLength & rhs)
    00722   { CoinArrayWithLength::operator=(rhs);  return *this;}
    00724 };
    00726
    00727 class CoinFactorizationLongDoubleArrayWithLength : public CoinArrayWithLength {
    00728
    00729 public:
    00732
    00733   inline int getSize() const
    00734   { return size_/CoinSizeofAsInt(long double); }
    00736   inline long double * array() const
    00737   { return reinterpret_cast<long double *> ((size_>-2) ? array_ : NULL); }
    00739
    00742
    00743   inline void setSize(int value)
    00744   { size_ = value*CoinSizeofAsInt(long double); }
    00746
    00749
    00750   inline long double * conditionalNew(int sizeWanted)
    00751   { return reinterpret_cast<long double *> (CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> (( sizeWanted)*CoinSizeofAsInt(long double)) : -1)); }
    00753
    00757   inline CoinFactorizationLongDoubleArrayWithLength()
    00758   { array_=NULL; size_=-1;}
    00760   inline CoinFactorizationLongDoubleArrayWithLength(int size)
    00761   { array_=new char [size*CoinSizeofAsInt(long double)]; size_=-1;}
    00766   inline CoinFactorizationLongDoubleArrayWithLength(int size, int mode)
    00767     : CoinArrayWithLength(size*CoinSizeofAsInt(long double),mode) {}
    00769   inline CoinFactorizationLongDoubleArrayWithLength(const CoinFactorizationLongDoubleArrayWithLength & rhs)
    00770     : CoinArrayWithLength(rhs) {}
    00772   inline CoinFactorizationLongDoubleArrayWithLength(const CoinFactorizationLongDoubleArrayWithLength * rhs)
    00773     : CoinArrayWithLength(rhs) {}
    00775   inline CoinFactorizationLongDoubleArrayWithLength& operator=(const CoinFactorizationLongDoubleArrayWithLength & rhs)
    00776   { CoinArrayWithLength::operator=(rhs);  return *this;}
    00778 };
    00780
    00781 class CoinIntArrayWithLength : public CoinArrayWithLength {
    00782
    00783 public:
    00786
    00787   inline int getSize() const
    00788   { return size_/CoinSizeofAsInt(int); }
    00790   inline int * array() const
    00791   { return reinterpret_cast<int *> ((size_>-2) ? array_ : NULL); }
    00793
    00796
    00797   inline void setSize(int value)
    00798   { size_ = value*CoinSizeofAsInt(int); }
    00800
    00803
    00804   inline int * conditionalNew(int sizeWanted)
    00805   { return reinterpret_cast<int *> (CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> (( sizeWanted)*CoinSizeofAsInt(int)) : -1)); }
    00807
    00811   inline CoinIntArrayWithLength()
    00812   { array_=NULL; size_=-1;}
    00814   inline CoinIntArrayWithLength(int size)
    00815   { array_=new char [size*CoinSizeofAsInt(int)]; size_=-1;}
    00820   inline CoinIntArrayWithLength(int size, int mode)
    00821     : CoinArrayWithLength(size*CoinSizeofAsInt(int),mode) {}
    00823   inline CoinIntArrayWithLength(const CoinIntArrayWithLength & rhs)
    00824     : CoinArrayWithLength(rhs) {}
    00826   inline CoinIntArrayWithLength(const CoinIntArrayWithLength * rhs)
    00827     : CoinArrayWithLength(rhs) {}
    00829   inline CoinIntArrayWithLength& operator=(const CoinIntArrayWithLength & rhs)
    00830   { CoinArrayWithLength::operator=(rhs);  return *this;}
    00832 };
    00834
    00835 class CoinBigIndexArrayWithLength : public CoinArrayWithLength {
    00836
    00837 public:
    00840
    00841   inline int getSize() const
    00842   { return size_/CoinSizeofAsInt(CoinBigIndex); }
    00844   inline CoinBigIndex * array() const
    00845   { return reinterpret_cast<CoinBigIndex *> ((size_>-2) ? array_ : NULL); }
    00847
    00850
    00851   inline void setSize(int value)
    00852   { size_ = value*CoinSizeofAsInt(CoinBigIndex); }
    00854
    00857
    00858   inline CoinBigIndex * conditionalNew(int sizeWanted)
    00859   { return reinterpret_cast<CoinBigIndex *> (CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> (( sizeWanted)*CoinSizeofAsInt(CoinBigIndex)) : -1)); }
    00861
    00865   inline CoinBigIndexArrayWithLength()
    00866   { array_=NULL; size_=-1;}
    00868   inline CoinBigIndexArrayWithLength(int size)
    00869   { array_=new char [size*CoinSizeofAsInt(CoinBigIndex)]; size_=-1;}
    00874   inline CoinBigIndexArrayWithLength(int size, int mode)
    00875     : CoinArrayWithLength(size*CoinSizeofAsInt(CoinBigIndex),mode) {}
    00877   inline CoinBigIndexArrayWithLength(const CoinBigIndexArrayWithLength & rhs)
    00878     : CoinArrayWithLength(rhs) {}
    00880   inline CoinBigIndexArrayWithLength(const CoinBigIndexArrayWithLength * rhs)
    00881     : CoinArrayWithLength(rhs) {}
    00883   inline CoinBigIndexArrayWithLength& operator=(const CoinBigIndexArrayWithLength & rhs)
    00884   { CoinArrayWithLength::operator=(rhs);  return *this;}
    00886 };
    00888
    00889 class CoinUnsignedIntArrayWithLength : public CoinArrayWithLength {
    00890
    00891 public:
    00894
    00895   inline int getSize() const
    00896   { return size_/CoinSizeofAsInt(unsigned int); }
    00898   inline unsigned int * array() const
    00899   { return reinterpret_cast<unsigned int *> ((size_>-2) ? array_ : NULL); }
    00901
    00904
    00905   inline void setSize(int value)
    00906   { size_ = value*CoinSizeofAsInt(unsigned int); }
    00908
    00911
    00912   inline unsigned int * conditionalNew(int sizeWanted)
    00913   { return reinterpret_cast<unsigned int *> (CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> (( sizeWanted)*CoinSizeofAsInt(unsigned int)) : -1)); }
    00915
    00919   inline CoinUnsignedIntArrayWithLength()
    00920   { array_=NULL; size_=-1;}
    00922   inline CoinUnsignedIntArrayWithLength(int size)
    00923   { array_=new char [size*CoinSizeofAsInt(unsigned int)]; size_=-1;}
    00928   inline CoinUnsignedIntArrayWithLength(int size, int mode)
    00929     : CoinArrayWithLength(size*CoinSizeofAsInt(unsigned int),mode) {}
    00931   inline CoinUnsignedIntArrayWithLength(const CoinUnsignedIntArrayWithLength & rhs)
    00932     : CoinArrayWithLength(rhs) {}
    00934   inline CoinUnsignedIntArrayWithLength(const CoinUnsignedIntArrayWithLength * rhs)
    00935     : CoinArrayWithLength(rhs) {}
    00937   inline CoinUnsignedIntArrayWithLength& operator=(const CoinUnsignedIntArrayWithLength & rhs)
    00938   { CoinArrayWithLength::operator=(rhs);  return *this;}
    00940 };
    00942
    00943 class CoinVoidStarArrayWithLength : public CoinArrayWithLength {
    00944
    00945 public:
    00948
    00949   inline int getSize() const
    00950   { return size_/CoinSizeofAsInt(void *); }
    00952   inline void ** array() const
    00953   { return reinterpret_cast<void **> ((size_>-2) ? array_ : NULL); }
    00955
    00958
    00959   inline void setSize(int value)
    00960   { size_ = value*CoinSizeofAsInt(void *); }
    00962
    00965
    00966   inline void ** conditionalNew(int sizeWanted)
    00967   { return reinterpret_cast<void **> ( CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> ((sizeWanted)*CoinSizeofAsInt(void *)) : -1)); }
    00969
    00973   inline CoinVoidStarArrayWithLength()
    00974   { array_=NULL; size_=-1;}
    00976   inline CoinVoidStarArrayWithLength(int size)
    00977   { array_=new char [size*CoinSizeofAsInt(void *)]; size_=-1;}
    00982   inline CoinVoidStarArrayWithLength(int size, int mode)
    00983     : CoinArrayWithLength(size*CoinSizeofAsInt(void *),mode) {}
    00985   inline CoinVoidStarArrayWithLength(const CoinVoidStarArrayWithLength & rhs)
    00986     : CoinArrayWithLength(rhs) {}
    00988   inline CoinVoidStarArrayWithLength(const CoinVoidStarArrayWithLength * rhs)
    00989     : CoinArrayWithLength(rhs) {}
    00991   inline CoinVoidStarArrayWithLength& operator=(const CoinVoidStarArrayWithLength & rhs)
    00992   { CoinArrayWithLength::operator=(rhs);  return *this;}
    00994 };
    00996
    00997 class CoinArbitraryArrayWithLength : public CoinArrayWithLength {
    00998
    00999 public:
    01002
    01003   inline int getSize() const
    01004   { return size_/lengthInBytes_; }
    01006   inline void ** array() const
    01007   { return reinterpret_cast<void **> ((size_>-2) ? array_ : NULL); }
    01009
    01012
    01013   inline void setSize(int value)
    01014   { size_ = value*lengthInBytes_; }
    01016
    01019
    01020   inline char * conditionalNew(int length, int sizeWanted)
    01021   { lengthInBytes_=length;return reinterpret_cast<char *> ( CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long>
    01022                                                                           ((sizeWanted)*lengthInBytes_) : -1)); }
    01024
    01028   inline CoinArbitraryArrayWithLength(int length=1)
    01029   { array_=NULL; size_=-1;lengthInBytes_=length;}
    01031   inline CoinArbitraryArrayWithLength(int length, int size)
    01032   { array_=new char [size*length]; size_=-1; lengthInBytes_=length;}
    01037   inline CoinArbitraryArrayWithLength(int length, int size, int mode)
    01038     : CoinArrayWithLength(size*length,mode) {lengthInBytes_=length;}
    01040   inline CoinArbitraryArrayWithLength(const CoinArbitraryArrayWithLength & rhs)
    01041     : CoinArrayWithLength(rhs) {}
    01043   inline CoinArbitraryArrayWithLength(const CoinArbitraryArrayWithLength * rhs)
    01044     : CoinArrayWithLength(rhs) {}
    01046   inline CoinArbitraryArrayWithLength& operator=(const CoinArbitraryArrayWithLength & rhs)
    01047   { CoinArrayWithLength::operator=(rhs);  return *this;}
    01049
    01050 protected:
    01053
    01054   int lengthInBytes_;
    01056 };
    01057 class CoinPartitionedVector : public CoinIndexedVector {
    01058
    01059 public:
    01060 #ifndef COIN_PARTITIONS
    01061 #define COIN_PARTITIONS 8
    01062 #endif
    01063
    01065
    01066    inline int getNumElements(int partition) const { assert (partition<COIN_PARTITIONS);
    01067      return numberElementsPartition_[partition]; }
    01069    inline int getNumPartitions() const
    01070   { return numberPartitions_; }
    01072    inline int getNumElements() const { return nElements_; }
    01074   inline int startPartition(int partition) const  { assert (partition<=COIN_PARTITIONS);
    01075     return startPartition_[partition]; }
    01077   inline const int * startPartitions() const
    01078   { return startPartition_; }
    01080
    01081    //-------------------------------------------------------------------
    01082    // Set indices and elements
    01083    //-------------------------------------------------------------------
    01086
    01087   inline void setNumElementsPartition(int partition, int value) { assert (partition<COIN_PARTITIONS);
    01088     if (numberPartitions_) numberElementsPartition_[partition]=value; }
    01090   inline void setTempNumElementsPartition(int partition, int value) { assert (partition<COIN_PARTITIONS);
    01091     numberElementsPartition_[partition]=value; }
    01093   void computeNumberElements();
    01095   void compact();
    01098    void reserve(int n);
    01100   void setPartitions(int number,const int * starts);
    01102    void clearAndReset();
    01104    void clearAndKeep();
    01106    void clearPartition(int partition);
    01107 #ifndef NDEBUG
    01109    void checkClear();
    01111    void checkClean();
    01112 #else
    01113   inline void checkClear() {};
    01114   inline void checkClean() {};
    01115 #endif
    01117   int scan(int partition, double tolerance=0.0);
    01118
    01121
    01122    void print() const;
    01124
    01128   void sort();
    01130
    01134    CoinPartitionedVector();
    01136   CoinPartitionedVector(int size, const int * inds, const double * elems);
    01138   CoinPartitionedVector(int size, const int * inds, double element);
    01141   CoinPartitionedVector(int size, const double * elements);
    01143   CoinPartitionedVector(int size);
    01145    CoinPartitionedVector(const CoinPartitionedVector &);
    01147    CoinPartitionedVector(const CoinPartitionedVector *);
    01149    CoinPartitionedVector & operator=(const CoinPartitionedVector &);
    01151    ~CoinPartitionedVector ();
    01153 protected:
    01156
    01157    int startPartition_[COIN_PARTITIONS+1];
    01159    int numberElementsPartition_[COIN_PARTITIONS];
    01161   int numberPartitions_;
    01163 };
    01164 #endif

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines