CoinPackedVector.hpp

Go to the documentation of this file.

/* $Id: CoinPackedVector.hpp 1509 2011-12-05 13:50:48Z forrest $ */
// Copyright (C) 2000, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

#ifndef CoinPackedVector_H
#define CoinPackedVector_H

#include <map>

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

#ifdef COIN_FAST_CODE
#ifndef COIN_NOTEST_DUPLICATE
#define COIN_NOTEST_DUPLICATE
#endif
#endif

#ifndef COIN_NOTEST_DUPLICATE
#define COIN_DEFAULT_VALUE_FOR_DUPLICATE true
#else
#define COIN_DEFAULT_VALUE_FOR_DUPLICATE false
#endif

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_; }
   inline int getVectorNumElements() const { return nElements_; }
   inline const int * getVectorIndices() const { return indices_; }
   inline const double * getVectorElements() const { return elements_; }
   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 = COIN_DEFAULT_VALUE_FOR_DUPLICATE);

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

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

   void setElement(int index, double element);

   void insert(int index, double element);
   void append(const CoinPackedVectorBase & 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);

   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 = COIN_DEFAULT_VALUE_FOR_DUPLICATE);
   CoinPackedVector(int size, const int * inds, const double * elems,
                   bool testForDuplicateIndex = COIN_DEFAULT_VALUE_FOR_DUPLICATE);
   CoinPackedVector(int capacity, int size, int *&inds, double *&elems,
                    bool testForDuplicateIndex = COIN_DEFAULT_VALUE_FOR_DUPLICATE);
   CoinPackedVector(int size, const int * inds, double element,
                   bool testForDuplicateIndex = COIN_DEFAULT_VALUE_FOR_DUPLICATE);
   CoinPackedVector(int size, const double * elements,
                   bool testForDuplicateIndex = COIN_DEFAULT_VALUE_FOR_DUPLICATE);
   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();
/*
  Replaced || with &&, in response to complaint from Sven deVries, who
  rightly points out || is not appropriate for additive operations. &&
  should be ok as long as binaryOp is understood not to create something
  from nothing.         -- lh, 04.06.11
*/
   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 double sparseDotProduct(const CoinPackedVectorBase& op1,
                        const CoinPackedVectorBase& op2){
  int len, i;
  double acc = 0.0;
  CoinPackedVector retVal;

  CoinPackedVector retval = op1*op2;
  len = retval.getNumElements();
  double * CParray = retval.getElements();

  for(i = 0; i < len; i++){
    acc += CParray[i];
  }
return acc;
}


inline double sortedSparseDotProduct(const CoinPackedVectorBase& op1,
                        const CoinPackedVectorBase& op2){
  int i, j, len1, len2;
  double acc = 0.0;

  const double* v1val = op1.getElements();
  const double* v2val = op2.getElements();
  const int* v1ind = op1.getIndices();
  const int* v2ind = op2.getIndices();

  len1 = op1.getNumElements();
  len2 = op2.getNumElements();

  i = 0;
  j = 0;

  while(i < len1 && j < len2){
    if(v1ind[i] == v2ind[j]){
      acc += v1val[i] * v2val[j];
      i++;
      j++;
   }
    else if(v2ind[j] < v1ind[i]){
      j++;
    }
    else{
      i++;
    } // end if-else-elseif
  } // end while
  return acc;
 }


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

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);
   const int size = retVal.getNumElements();
   double* elems = retVal.getElements();
   for (int i = 0; i < size; ++i) {
      elems[i] = value - elems[i];
   }
   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);
   const int size = retVal.getNumElements();
   double* elems = retVal.getElements();
   for (int i = 0; i < size; ++i) {
      elems[i] = value / elems[i];
   }
   return retVal;
}

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

#endif