CoinPackedVectorBase.hpp

Go to the documentation of this file.

/* $Id$ */
// 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 CoinPackedVectorBase_H
#define CoinPackedVectorBase_H
 
#include <set>
#include <map>
#include "CoinPragma.hpp"
#include "CoinError.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;
  void setTestForDuplicateIndexWhenTrue(bool test) const;
  bool testForDuplicateIndex() const { return testForDuplicateIndex_; }
  inline void setTestsOff() const
  {
    testForDuplicateIndex_ = false;
    testedDuplicateIndex_ = false;
  }
 
  double *denseVector(int denseSize) const;
  double operator[](int i) const;
 
  int getMaxIndex() const;
  int getMinIndex() const;
 
  void duplicateIndex(const char *methodName = NULL,
    const char *className = NULL) const;
 
  bool isExistingIndex(int i) const;
 
  int findIndex(int i) const;
 
 
  bool operator==(const CoinPackedVectorBase &rhs) const;
  bool operator!=(const CoinPackedVectorBase &rhs) const;
 
#if 0
   // LL: This should be implemented eventually. It is useful to have.
   int lexCompare(const CoinPackedVectorBase& rhs);
#endif
 
  int compare(const CoinPackedVectorBase &rhs) const;
 
  template < class FloatEqual >
  bool
  isEquivalent(const CoinPackedVectorBase &rhs, const FloatEqual &eq) const
  {
    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;
 
  double dotProduct(const double *dense) const;
 
  double oneNorm() const;
 
  double normSquare() const;
 
  double twoNorm() const;
 
  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;
 
  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
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/