CoinPackedVector.hpp

Go to the documentation of this file.

/* $Id: CoinPackedVector.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 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

/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/