CoinPackedVectorBase.hpp

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

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

#include <set>
#include <map>
#include "CoinError.hpp"
#include "CoinFloatEqual.hpp"

class CoinPackedVector;

class CoinPackedVectorBase  {
  
public:

   virtual int getNumElements() const = 0;
   virtual const int * getIndices() const = 0;
   virtual const double * getElements() const = 0;

   void setTestForDuplicateIndex(bool test) const;
   bool testForDuplicateIndex() const { return testForDuplicateIndex_; }

   double * denseVector(int denseSize) const throw(CoinError);
   double operator[](int i) const throw(CoinError); 


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

   void duplicateIndex(const char* methodName = NULL,
                       const char * className = NULL)  const throw(CoinError);

   bool isExistingIndex(int i) const;
   
   int findIndex(int i) const;
 
  
   bool operator==(const CoinPackedVectorBase & rhs) const;
   bool operator!=(const CoinPackedVectorBase & rhs) const;

   template <class FloatEqual> bool
   isEquivalent(const CoinPackedVectorBase& rhs, const FloatEqual& eq) const
      throw(CoinError)
   {
      if (getNumElements() != rhs.getNumElements())
         return false;

      duplicateIndex("equivalent", "CoinPackedVector");
      rhs.duplicateIndex("equivalent", "CoinPackedVector");

      std::map<int,double> mv;
      const int * inds = getIndices();
      const double * elems = getElements();
      int i;
      for ( i = getNumElements() - 1; i >= 0; --i) {
         mv.insert(std::make_pair(inds[i], elems[i]));
      }

      std::map<int,double> mvRhs;
      inds = rhs.getIndices();
      elems = rhs.getElements();
      for ( i = getNumElements() - 1; i >= 0; --i) {
         mvRhs.insert(std::make_pair(inds[i], elems[i]));
      }

      std::map<int,double>::const_iterator mvI = mv.begin();
      std::map<int,double>::const_iterator mvIlast = mv.end();
      std::map<int,double>::const_iterator mvIrhs = mvRhs.begin();
      while (mvI != mvIlast) {
         if (mvI->first != mvIrhs->first || ! eq(mvI->second, mvIrhs->second))
            return false;
         ++mvI;
         ++mvIrhs;
      }
      return true;
   }
   bool isEquivalent(const CoinPackedVectorBase& rhs) const
   {
      return isEquivalent(rhs,  CoinRelFltEq());
   }



   double dotProduct(const double* dense) const;

   double oneNorm() const;

   double normSquare() const;

   inline double twoNorm() const { return sqrt(normSquare()); }

   double infNorm() const;

   double sum() const;

protected:

   CoinPackedVectorBase();

public:
   virtual ~CoinPackedVectorBase();

private:
   CoinPackedVectorBase(const CoinPackedVectorBase&);
   CoinPackedVectorBase& operator=(const CoinPackedVectorBase&);
   
protected:
    

   void findMaxMinIndices() const;

   std::set<int> * indexSet(const char* methodName = NULL,
                            const char * className = NULL) const
      throw(CoinError);

   void clearIndexSet() const;
   void clearBase() const;
   void copyMaxMinIndex(const CoinPackedVectorBase & x) const {
      maxIndex_ = x.maxIndex_;
      minIndex_ = x.minIndex_;
   }
    
private:

   mutable int maxIndex_;
   mutable int minIndex_;
   mutable std::set<int> * indexSetPtr_;
   mutable bool testForDuplicateIndex_;
   mutable bool testedDuplicateIndex_;
};

#endif

---