/home/coin/SVN-release/CoinAll-1.1.0/CoinUtils/src/CoinIndexedVector.hpp

Go to the documentation of this file.

// Copyright (C) 2000, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef CoinIndexedVector_H
#define CoinIndexedVector_H

#if defined(_MSC_VER)
// Turn off compiler warning about long names
#  pragma warning(disable:4786)
#endif

#include <map>
#ifndef CLP_NO_VECTOR
#include "CoinPackedVectorBase.hpp"
#endif
#include "CoinSort.hpp"
#include <cassert>

#ifndef COIN_FLOAT
#define COIN_INDEXED_TINY_ELEMENT 1.0e-50
#define COIN_INDEXED_REALLY_TINY_ELEMENT 1.0e-100
#else
#define COIN_INDEXED_TINY_ELEMENT 1.0e-35
#define COIN_INDEXED_REALLY_TINY_ELEMENT 1.0e-39
#endif

class CoinIndexedVector {
   friend void CoinIndexedVectorUnitTest();
  
public:

   inline int getNumElements() const { return nElements_; }
   inline const int * getIndices() const { return indices_; }
   // ** No longer supported virtual const double * getElements() const ;
   inline int * getIndices() { return indices_; }
   inline double * denseVector() const { return elements_; }
  inline void setDenseVector(double * array)
  { elements_ = array;}
  inline void setIndexVector(int * array)
  { indices_ = array;}
   double & operator[](int i) const; 

 
   //-------------------------------------------------------------------
   // Set indices and elements
   //------------------------------------------------------------------- 

   inline void setNumElements(int value) { nElements_ = value;
   if (!nElements_) packedMode_=false;}
   void clear();
   void empty();
   CoinIndexedVector & operator=(const CoinIndexedVector &);
#ifndef CLP_NO_VECTOR

   CoinIndexedVector & operator=(const CoinPackedVectorBase & rhs);
#endif

   void copy(const CoinIndexedVector & rhs, double multiplier=1.0);

  void borrowVector(int size, int numberIndices, int* inds, double* elems);

   void returnVector();

  void setVector(int numberIndices, const int * inds, const double * elems);
  
   void setVector(int size, int numberIndices, const int * inds, const double * elems);
  
  void setConstant(int size, const int * inds, double elems);
  
  void setFull(int size, const double * elems);

   void setElement(int index, double element);

   void insert(int index, double element);
   void add(int index, double element);
   inline void quickAdd(int index, double element)
               {
                 if (elements_[index]) {
                   element += elements_[index];
                   if (fabs(element)>= COIN_INDEXED_TINY_ELEMENT) {
                     elements_[index] = element;
                   } else {
                     elements_[index] = 1.0e-100;
                   }
                 } else if (fabs(element)>= COIN_INDEXED_TINY_ELEMENT) {
                   indices_[nElements_++] = index;
                   assert (nElements_<=capacity_);
                   elements_[index] = element;
                 }
               }
   inline void zero(int index)
               {
                 if (elements_[index]) 
                   elements_[index] = 1.0e-100;
               }
   int clean(double tolerance);
   int cleanAndPack(double tolerance);
   int cleanAndPackSafe(double tolerance);
  inline void setPacked()
  { packedMode_ = true;}
   void checkClear();
   void checkClean();
   int scan();
   int scan(int start, int end);
   int scan(double tolerance);
   int scan(int start, int end, double tolerance);
   int scanAndPack();
   int scanAndPack(int start, int end);
   int scanAndPack(double tolerance);
   int scanAndPack(int start, int end, double tolerance);
   void createPacked(int number, const int * indices, 
                    const double * elements);
   void expand();
#ifndef CLP_NO_VECTOR
   void append(const CoinPackedVectorBase & caboose);
#endif
   void append(const CoinIndexedVector & caboose);

   void swap(int i, int j); 

   void truncate(int newSize); 
   void print() const;


   void operator+=(double value);
   void operator-=(double value);
   void operator*=(double value);
   void operator/=(double value);

#ifndef CLP_NO_VECTOR

   bool operator==(const CoinPackedVectorBase & rhs) const;
   bool operator!=(const CoinPackedVectorBase & rhs) const;
#endif

   bool operator==(const CoinIndexedVector & rhs) const;
   bool operator!=(const CoinIndexedVector & rhs) const;


   int getMaxIndex() const;
   int getMinIndex() const;


   void sort()
   { std::sort(indices_,indices_+nElements_); }

   void sortIncrIndex()
   { std::sort(indices_,indices_+nElements_); }

   void sortDecrIndex();
  
   void sortIncrElement();

   void sortDecrElement();


  //#############################################################################


CoinIndexedVector operator+(
                           const CoinIndexedVector& op2);

CoinIndexedVector operator-(
                           const CoinIndexedVector& op2);

CoinIndexedVector operator*(
                           const CoinIndexedVector& op2);

CoinIndexedVector operator/(
                           const CoinIndexedVector& op2);
void operator+=(const CoinIndexedVector& op2);

void operator-=( const CoinIndexedVector& op2);

void operator*=(const CoinIndexedVector& op2);

void operator/=(const CoinIndexedVector& op2);

   void reserve(int n);
   int capacity() const { return capacity_; }
   inline void setPackedMode(bool yesNo)
   { packedMode_=yesNo;}
   inline bool packedMode() const
   { return packedMode_;}

   CoinIndexedVector();
  CoinIndexedVector(int size, const int * inds, const double * elems);
  CoinIndexedVector(int size, const int * inds, double element);
  CoinIndexedVector(int size, const double * elements);
  CoinIndexedVector(int size);
   CoinIndexedVector(const CoinIndexedVector &);
   CoinIndexedVector(const CoinIndexedVector *);
#ifndef CLP_NO_VECTOR

   CoinIndexedVector(const CoinPackedVectorBase & rhs);
#endif

   ~CoinIndexedVector ();
    
private:

   void gutsOfSetVector(int size,
                        const int * inds, const double * elems);
   void gutsOfSetVector(int size, int numberIndices,
                        const int * inds, const double * elems);
   void gutsOfSetPackedVector(int size, int numberIndices,
                        const int * inds, const double * elems);
   void gutsOfSetConstant(int size,
                          const int * inds, double value);

private:

   int * indices_;
   double * elements_;
   int nElements_;
   int capacity_;
   int offset_;
   bool packedMode_;
};

//#############################################################################
void
CoinIndexedVectorUnitTest();
class CoinArrayWithLength {
  
public:

  inline int getSize() const 
  { return size_; }
  inline bool switchedOn() const 
  { return size_!=-1; }
  inline int getCapacity() const 
  { return (size_>-2) ? size_ : (-size_)-2; }
  inline void setCapacity() 
  { if (size_<=-2) size_ = (-size_)-2; }
  inline const char * array() const 
  { return (size_>-2) ? array_ : NULL; }
  

  inline void setSize(int value) 
  { size_ = value; }
  inline void switchOff() 
  { size_ = -1; }
  void setPersistence(int flag,int currentLength);
  void clear();
  void swap(CoinArrayWithLength & other);
  void extend(int newSize);
  

  char * conditionalNew(long sizeWanted); 
  void conditionalDelete();
  
  inline CoinArrayWithLength()
  { array_=NULL; size_=-1;}
  inline CoinArrayWithLength(int size)
  { array_=new char [size]; size_=-1;}
  inline CoinArrayWithLength(int size, int mode)
  { array_ = new char [size]; if (mode) memset(array_,0,size);size_=size;}
  CoinArrayWithLength(const CoinArrayWithLength & rhs);
  CoinArrayWithLength(const CoinArrayWithLength * rhs);
  CoinArrayWithLength& operator=(const CoinArrayWithLength & rhs);
  void copy(const CoinArrayWithLength & rhs, int numberBytes=-1);
  void allocate(const CoinArrayWithLength & rhs, int numberBytes);
  inline ~CoinArrayWithLength ()
  { delete [] array_; }
  // was { free(array_); }
  
protected:

  char * array_;
  int size_;
};

class CoinDoubleArrayWithLength : public CoinArrayWithLength {
  
public:

  inline int getSize() const 
  { return size_/sizeof(double); }
  inline double * array() const 
  { return (double *) ((size_>-2) ? array_ : NULL); }
  

  inline void setSize(int value) 
  { size_ = value*sizeof(double); }
  

  inline double * conditionalNew(int sizeWanted)
  { return (double *) CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? (long) (((long) sizeWanted)*sizeof(double)) : -1); }
  
  inline CoinDoubleArrayWithLength()
  { array_=NULL; size_=-1;}
  inline CoinDoubleArrayWithLength(int size)
  { array_=new char [size*sizeof(double)]; size_=-1;}
  inline CoinDoubleArrayWithLength(int size, int mode)
    : CoinArrayWithLength(size*sizeof(double),mode) {}
  inline CoinDoubleArrayWithLength(const CoinDoubleArrayWithLength & rhs)
    : CoinArrayWithLength(rhs) {}
  inline CoinDoubleArrayWithLength(const CoinDoubleArrayWithLength * rhs)
    : CoinArrayWithLength(rhs) {}
  inline CoinDoubleArrayWithLength& operator=(const CoinDoubleArrayWithLength & rhs)
  { CoinArrayWithLength::operator=(rhs);  return *this;}
};

class CoinIntArrayWithLength : public CoinArrayWithLength {
  
public:

  inline int getSize() const 
  { return size_/sizeof(int); }
  inline int * array() const 
  { return (int *) ((size_>-2) ? array_ : NULL); }
  

  inline void setSize(int value) 
  { size_ = value*sizeof(int); }
  

  inline int * conditionalNew(int sizeWanted)
  { return (int *) CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? (long) (((long) sizeWanted)*sizeof(int)) : -1); }
  
  inline CoinIntArrayWithLength()
  { array_=NULL; size_=-1;}
  inline CoinIntArrayWithLength(int size)
  { array_=new char [size*sizeof(int)]; size_=-1;}
  inline CoinIntArrayWithLength(int size, int mode)
    : CoinArrayWithLength(size*sizeof(int),mode) {}
  inline CoinIntArrayWithLength(const CoinIntArrayWithLength & rhs)
    : CoinArrayWithLength(rhs) {}
  inline CoinIntArrayWithLength(const CoinIntArrayWithLength * rhs)
    : CoinArrayWithLength(rhs) {}
  inline CoinIntArrayWithLength& operator=(const CoinIntArrayWithLength & rhs)
  { CoinArrayWithLength::operator=(rhs);  return *this;}
};

class CoinBigIndexArrayWithLength : public CoinArrayWithLength {
  
public:

  inline int getSize() const 
  { return size_/sizeof(CoinBigIndex); }
  inline CoinBigIndex * array() const 
  { return (CoinBigIndex *) ((size_>-2) ? array_ : NULL); }
  

  inline void setSize(int value) 
  { size_ = value*sizeof(CoinBigIndex); }
  

  inline CoinBigIndex * conditionalNew(int sizeWanted)
  { return (CoinBigIndex *) CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? (long) (((long) sizeWanted)*sizeof(CoinBigIndex)) : -1); }
  
  inline CoinBigIndexArrayWithLength()
  { array_=NULL; size_=-1;}
  inline CoinBigIndexArrayWithLength(int size)
  { array_=new char [size*sizeof(CoinBigIndex)]; size_=-1;}
  inline CoinBigIndexArrayWithLength(int size, int mode)
    : CoinArrayWithLength(size*sizeof(CoinBigIndex),mode) {}
  inline CoinBigIndexArrayWithLength(const CoinBigIndexArrayWithLength & rhs)
    : CoinArrayWithLength(rhs) {}
  inline CoinBigIndexArrayWithLength(const CoinBigIndexArrayWithLength * rhs)
    : CoinArrayWithLength(rhs) {}
  inline CoinBigIndexArrayWithLength& operator=(const CoinBigIndexArrayWithLength & rhs)
  { CoinArrayWithLength::operator=(rhs);  return *this;}
};

class CoinUnsignedIntArrayWithLength : public CoinArrayWithLength {
  
public:

  inline int getSize() const 
  { return size_/sizeof(unsigned int); }
  inline unsigned int * array() const 
  { return (unsigned int *) ((size_>-2) ? array_ : NULL); }
  

  inline void setSize(int value) 
  { size_ = value*sizeof(unsigned int); }
  

  inline unsigned int * conditionalNew(int sizeWanted)
  { return (unsigned int *) CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? (long) (((long) sizeWanted)*sizeof(unsigned int)) : -1); }
  
  inline CoinUnsignedIntArrayWithLength()
  { array_=NULL; size_=-1;}
  inline CoinUnsignedIntArrayWithLength(int size)
  { array_=new char [size*sizeof(unsigned int)]; size_=-1;}
  inline CoinUnsignedIntArrayWithLength(int size, int mode)
    : CoinArrayWithLength(size*sizeof(unsigned int),mode) {}
  inline CoinUnsignedIntArrayWithLength(const CoinUnsignedIntArrayWithLength & rhs)
    : CoinArrayWithLength(rhs) {}
  inline CoinUnsignedIntArrayWithLength(const CoinUnsignedIntArrayWithLength * rhs)
    : CoinArrayWithLength(rhs) {}
  inline CoinUnsignedIntArrayWithLength& operator=(const CoinUnsignedIntArrayWithLength & rhs)
  { CoinArrayWithLength::operator=(rhs);  return *this;}
};
#endif

---