CoinPackedVector.hpp

// Copyright (C) 2000, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef CoinPackedVector_H
#define CoinPackedVector_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"

class CoinPackedVector : public CoinPackedVectorBase {
   friend void CoinPackedVectorUnitTest();
  
public:

   virtual int getNumElements() const { return nElements_; }
   virtual const int * getIndices() const { return indices_; }
   virtual const double * getElements() const { return elements_; }
   int * getIndices() { return indices_; }
   double * getElements() { return elements_; }
   const int * getOriginalPosition() const { return origIndices_; }
 
   //-------------------------------------------------------------------
   // Set indices and elements
   //------------------------------------------------------------------- 

   void clear();
   CoinPackedVector & operator=(const CoinPackedVector &);
   CoinPackedVector & operator=(const CoinPackedVectorBase & rhs);

   void assignVector(int size, int*& inds, double*& elems,
                     bool testForDuplicateIndex = true);

   void setVector(int size, const int * inds, const double * elems,
                  bool testForDuplicateIndex = true) throw(CoinError);
  
   void setConstant(int size, const int * inds, double elems,
                    bool testForDuplicateIndex = true) throw(CoinError);
  
   void setFull(int size, const double * elems,
                bool testForDuplicateIndex = true);

   void setFullNonZero(int size, const double * elems,
                bool testForDuplicateIndex = true);

   void setElement(int index, double element) throw(CoinError);

   void insert(int index, double element) throw(CoinError);
   void append(const CoinPackedVectorBase & caboose) throw(CoinError);

   void swap(int i, int j) throw(CoinError); 

   void truncate(int newSize) throw(CoinError); 


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

   template <class CoinCompare3>
   void sort(const CoinCompare3 & tc)
   { CoinSort_3(indices_, indices_ + nElements_, origIndices_, elements_,
                tc); }

   void sortIncrIndex()
   { CoinSort_3(indices_, indices_ + nElements_, origIndices_, elements_,
                CoinFirstLess_3<int, int, double>()); }

   void sortDecrIndex()
   { CoinSort_3(indices_, indices_ + nElements_, origIndices_, elements_,
                CoinFirstGreater_3<int, int, double>()); }
  
   void sortIncrElement()
   { CoinSort_3(elements_, elements_ + nElements_, origIndices_, indices_,
                CoinFirstLess_3<double, int, int>()); }

   void sortDecrElement()
   { CoinSort_3(elements_, elements_ + nElements_, origIndices_, indices_,
                CoinFirstGreater_3<double, int, int>()); }
  

   void sortOriginalOrder();

   void reserve(int n);
   int capacity() const { return capacity_; }

   CoinPackedVector(bool testForDuplicateIndex = true);
   CoinPackedVector(int size, const int * inds, const double * elems,
                   bool testForDuplicateIndex = true);
   CoinPackedVector(int size, const int * inds, double element,
                   bool testForDuplicateIndex = true);
   CoinPackedVector(int size, const double * elements,
                   bool testForDuplicateIndex = true);
   CoinPackedVector(const CoinPackedVector &);
   CoinPackedVector(const CoinPackedVectorBase & rhs);
   virtual ~CoinPackedVector ();
    
private:

   void gutsOfSetVector(int size,
                        const int * inds, const double * elems,
                        bool testForDuplicateIndex,
                        const char * method);
   void gutsOfSetConstant(int size,
                          const int * inds, double value,
                          bool testForDuplicateIndex,
                          const char * method);

private:

   int * indices_;
   double * elements_;
   int nElements_;
   int * origIndices_;
   int capacity_;
};

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

template <class BinaryFunction> void
binaryOp(CoinPackedVector& retVal,
         const CoinPackedVectorBase& op1, double value,
         BinaryFunction bf)
{
   retVal.clear();
   const int s = op1.getNumElements();
   if (s > 0) {
      retVal.reserve(s);
      const int * inds = op1.getIndices();
      const double * elems = op1.getElements();
      for (int i=0; i<s; ++i ) {
         retVal.insert(inds[i], bf(value, elems[i]));
      }
   }
}

template <class BinaryFunction> inline void
binaryOp(CoinPackedVector& retVal,
         double value, const CoinPackedVectorBase& op2,
         BinaryFunction bf)
{
   binaryOp(retVal, op2, value, bf);
}

template <class BinaryFunction> void
binaryOp(CoinPackedVector& retVal,
         const CoinPackedVectorBase& op1, const CoinPackedVectorBase& op2,
         BinaryFunction bf)
{
   retVal.clear();
   const int s1 = op1.getNumElements();
   const int s2 = op2.getNumElements();
   if (s1 == 0 || s2 == 0)
      return;

   retVal.reserve(s1+s2);

   const int * inds1 = op1.getIndices();
   const double * elems1 = op1.getElements();
   const int * inds2 = op2.getIndices();
   const double * elems2 = op2.getElements();

   int i;
   // loop once for each element in op1
   for ( i=0; i<s1; ++i ) {
      const int index = inds1[i];
      const int pos2 = op2.findIndex(index);
      const double val = bf(elems1[i], pos2 == -1 ? 0.0 : elems2[pos2]);
      // if (val != 0.0) // *THINK* : should we put in only nonzeros?
      retVal.insert(index, val);
   }
   // loop once for each element in operand2  
   for ( i=0; i<s2; ++i ) {
      const int index = inds2[i];
      // if index exists in op1, then element was processed in prior loop
      if ( op1.isExistingIndex(index) )
         continue;
      // Index does not exist in op1, so the element value must be zero
      const double val = bf(0.0, elems2[i]);
      // if (val != 0.0) // *THINK* : should we put in only nonzeros?
      retVal.insert(index, val);
   }
}

//-----------------------------------------------------------------------------

template <class BinaryFunction> CoinPackedVector
binaryOp(const CoinPackedVectorBase& op1, double value,
         BinaryFunction bf)
{
   CoinPackedVector retVal;
   retVal.setTestForDuplicateIndex(true);
   binaryOp(retVal, op1, value, bf);
   return retVal;
}

template <class BinaryFunction> CoinPackedVector
binaryOp(double value, const CoinPackedVectorBase& op2,
         BinaryFunction bf)
{
   CoinPackedVector retVal;
   retVal.setTestForDuplicateIndex(true);
   binaryOp(retVal, op2, value, bf);
   return retVal;
}

template <class BinaryFunction> CoinPackedVector
binaryOp(const CoinPackedVectorBase& op1, const CoinPackedVectorBase& op2,
         BinaryFunction bf)
{
   CoinPackedVector retVal;
   retVal.setTestForDuplicateIndex(true);
   binaryOp(retVal, op1, op2, bf);
   return retVal;
}

//-----------------------------------------------------------------------------
inline CoinPackedVector operator+(const CoinPackedVectorBase& op1,
                                  const CoinPackedVectorBase& op2)
{
   CoinPackedVector retVal;
   retVal.setTestForDuplicateIndex(true);
   binaryOp(retVal, op1, op2, std::plus<double>());
   return retVal;
}

inline CoinPackedVector operator-(const CoinPackedVectorBase& op1,
                                 const CoinPackedVectorBase& op2)
{
   CoinPackedVector retVal;
   retVal.setTestForDuplicateIndex(true);
   binaryOp(retVal, op1, op2, std::minus<double>());
   return retVal;
}

inline CoinPackedVector operator*(const CoinPackedVectorBase& op1,
                                  const CoinPackedVectorBase& op2)
{
   CoinPackedVector retVal;
   retVal.setTestForDuplicateIndex(true);
   binaryOp(retVal, op1, op2, std::multiplies<double>());
   return retVal;
}

inline CoinPackedVector operator/(const CoinPackedVectorBase& op1,
                                  const CoinPackedVectorBase& op2)
{
   CoinPackedVector retVal;
   retVal.setTestForDuplicateIndex(true);
   binaryOp(retVal, op1, op2, std::divides<double>());
   return retVal;
}

//-----------------------------------------------------------------------------


inline CoinPackedVector
operator+(const CoinPackedVectorBase& op1, double value)
{
   CoinPackedVector retVal(op1);
   retVal += value;
   return retVal;
}

inline CoinPackedVector
operator-(const CoinPackedVectorBase& op1, double value)
{
   CoinPackedVector retVal(op1);
   retVal -= value;
   return retVal;
}

inline CoinPackedVector
operator*(const CoinPackedVectorBase& op1, double value)
{
   CoinPackedVector retVal(op1);
   retVal *= value;
   return retVal;
}

inline CoinPackedVector
operator/(const CoinPackedVectorBase& op1, double value)
{
   CoinPackedVector retVal(op1);
   retVal /= value;
   return retVal;
}

//-----------------------------------------------------------------------------

inline CoinPackedVector
operator+(double value, const CoinPackedVectorBase& op1)
{
   CoinPackedVector retVal(op1);
   retVal += value;
   return retVal;
}

inline CoinPackedVector
operator-(double value, const CoinPackedVectorBase& op1)
{
   CoinPackedVector retVal(op1);
   retVal -= value;
   return retVal;
}

inline CoinPackedVector
operator*(double value, const CoinPackedVectorBase& op1)
{
   CoinPackedVector retVal(op1);
   retVal *= value;
   return retVal;
}

inline CoinPackedVector
operator/(double value, const CoinPackedVectorBase& op1)
{
   CoinPackedVector retVal(op1);
   retVal /= value;
   return retVal;
}

//#############################################################################
void
CoinPackedVectorUnitTest();

#endif

---