CoinIndexedVector.hpp

// 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>

#include "CoinPackedVectorBase.hpp"
#include "CoinSort.hpp"

#define COIN_INDEXED_TINY_ELEMENT 1.0e-50

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;};
   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 &);
   CoinIndexedVector & operator=(const CoinPackedVectorBase & rhs);

  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;
                   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();
   void append(const CoinPackedVectorBase & caboose);
   void append(const CoinIndexedVector & caboose);

   void swap(int i, int j); 

   void truncate(int newSize); 


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

   bool operator==(const CoinPackedVectorBase & rhs) const;
   bool operator!=(const CoinPackedVectorBase & rhs) const;
   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 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(const CoinIndexedVector &);
   CoinIndexedVector(const CoinIndexedVector *);
   CoinIndexedVector(const CoinPackedVectorBase & rhs);
   ~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 gutsOfSetConstant(int size,
                          const int * inds, double value);

private:

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

//#############################################################################
void
CoinIndexedVectorUnitTest();

#endif

---