CoinPackedVectorBase.hpp

Go to the documentation of this file.

/* $Id: CoinPackedVectorBase.hpp 2083 2019-01-06 19:38:09Z unxusr $ */
// 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
*/