CoinPackedMatrix.hpp

Go to the documentation of this file.

/* $Id: CoinPackedMatrix.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 CoinPackedMatrix_H
#define CoinPackedMatrix_H

#include "CoinError.hpp"
#include "CoinTypes.hpp"
#ifndef CLP_NO_VECTOR
#include "CoinPackedVectorBase.hpp"
#include "CoinShallowPackedVector.hpp"
#else
class CoinRelFltEq;
#endif

class CoinPackedMatrix {
  friend void CoinPackedMatrixUnitTest();

public:
  //---------------------------------------------------------------------------
  inline double getExtraGap() const { return extraGap_; }
  inline double getExtraMajor() const { return extraMajor_; }

  void reserve(const int newMaxMajorDim, const CoinBigIndex newMaxSize,
    bool create = false);
  void clear();

  inline bool isColOrdered() const { return colOrdered_; }

  inline bool hasGaps() const { return (size_ < start_[majorDim_]); }

  inline CoinBigIndex getNumElements() const { return size_; }

  inline int getNumCols() const
  {
    return colOrdered_ ? majorDim_ : minorDim_;
  }

  inline int getNumRows() const
  {
    return colOrdered_ ? minorDim_ : majorDim_;
  }

  inline const double *getElements() const { return element_; }

  inline const int *getIndices() const { return index_; }

  inline int getSizeVectorStarts() const
  {
    return ((majorDim_ > 0) ? (majorDim_ + 1) : (0));
  }

  inline int getSizeVectorLengths() const { return majorDim_; }

  inline const CoinBigIndex *getVectorStarts() const { return start_; }

  inline const int *getVectorLengths() const { return length_; }

  CoinBigIndex getVectorFirst(const int i) const
  {
#ifndef COIN_FAST_CODE
    if (i < 0 || i >= majorDim_)
      throw CoinError("bad index", "vectorFirst", "CoinPackedMatrix");
#endif
    return start_[i];
  }
  CoinBigIndex getVectorLast(const int i) const
  {
#ifndef COIN_FAST_CODE
    if (i < 0 || i >= majorDim_)
      throw CoinError("bad index", "vectorLast", "CoinPackedMatrix");
#endif
    return start_[i] + length_[i];
  }
  inline int getVectorSize(const int i) const
  {
#ifndef COIN_FAST_CODE
    if (i < 0 || i >= majorDim_)
      throw CoinError("bad index", "vectorSize", "CoinPackedMatrix");
#endif
    return length_[i];
  }
#ifndef CLP_NO_VECTOR

  const CoinShallowPackedVector getVector(int i) const
  {
#ifndef COIN_FAST_CODE
    if (i < 0 || i >= majorDim_)
      throw CoinError("bad index", "vector", "CoinPackedMatrix");
#endif
    return CoinShallowPackedVector(length_[i],
      index_ + start_[i],
      element_ + start_[i],
      false);
  }
#endif

  int *getMajorIndices() const;

  //---------------------------------------------------------------------------
  void setDimensions(int numrows, int numcols);

  void setExtraGap(const double newGap);
  void setExtraMajor(const double newMajor);
#ifndef CLP_NO_VECTOR

  void appendCol(const CoinPackedVectorBase &vec);
#endif

  void appendCol(const int vecsize,
    const int *vecind, const double *vecelem);
#ifndef CLP_NO_VECTOR

  void appendCols(const int numcols,
    const CoinPackedVectorBase *const *cols);
#endif

  int appendCols(const int numcols,
    const CoinBigIndex *columnStarts, const int *row,
    const double *element, int numberRows = -1);
#ifndef CLP_NO_VECTOR

  void appendRow(const CoinPackedVectorBase &vec);
#endif

  void appendRow(const int vecsize,
    const int *vecind, const double *vecelem);
#ifndef CLP_NO_VECTOR

  void appendRows(const int numrows,
    const CoinPackedVectorBase *const *rows);
#endif

  int appendRows(const int numrows,
    const CoinBigIndex *rowStarts, const int *column,
    const double *element, int numberColumns = -1);

  void rightAppendPackedMatrix(const CoinPackedMatrix &matrix);
  void bottomAppendPackedMatrix(const CoinPackedMatrix &matrix);

  void deleteCols(const int numDel, const int *indDel);
  void deleteRows(const int numDel, const int *indDel);

  void replaceVector(const int index,
    const int numReplace, const double *newElements);
  void modifyCoefficient(int row, int column, double newElement,
    bool keepZero = false);
  double getCoefficient(int row, int column) const;

  CoinBigIndex compress(double threshold);
  CoinBigIndex eliminateDuplicates(double threshold);
  void orderMatrix();
  CoinBigIndex cleanMatrix(double threshold = 1.0e-20);

  //---------------------------------------------------------------------------
  void removeGaps(double removeValue = -1.0);

  void submatrixOf(const CoinPackedMatrix &matrix,
    const int numMajor, const int *indMajor);
  void submatrixOfWithDuplicates(const CoinPackedMatrix &matrix,
    const int numMajor, const int *indMajor);
#if 0

    void submatrixOf(const CoinPackedMatrix& matrix,
                     const int numMajor, const int * indMajor,
                     const int numMinor, const int * indMinor);
#endif

  void copyOf(const CoinPackedMatrix &rhs);
  void copyOf(const bool colordered,
    const int minor, const int major, const CoinBigIndex numels,
    const double *elem, const int *ind,
    const CoinBigIndex *start, const int *len,
    const double extraMajor = 0.0, const double extraGap = 0.0);
  void copyReuseArrays(const CoinPackedMatrix &rhs);

  void reverseOrderedCopyOf(const CoinPackedMatrix &rhs);

  void assignMatrix(const bool colordered,
    const int minor, const int major,
    const CoinBigIndex numels,
    double *&elem, int *&ind,
    CoinBigIndex *&start, int *&len,
    const int maxmajor = -1, const CoinBigIndex maxsize = -1);

  CoinPackedMatrix &operator=(const CoinPackedMatrix &rhs);

  void reverseOrdering();

  void transpose();

  void swap(CoinPackedMatrix &matrix);


  //---------------------------------------------------------------------------
  void times(const double *x, double *y) const;
#ifndef CLP_NO_VECTOR

  void times(const CoinPackedVectorBase &x, double *y) const;
#endif

  void transposeTimes(const double *x, double *y) const;
#ifndef CLP_NO_VECTOR

  void transposeTimes(const CoinPackedVectorBase &x, double *y) const;
#endif


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

  //-------------------------------------------------------------------------
  int *countOrthoLength() const;
  void countOrthoLength(int *counts) const;
  inline int getMajorDim() const { return majorDim_; }
  inline void setMajorDim(int value) { majorDim_ = value; }
  inline int getMinorDim() const { return minorDim_; }
  inline void setMinorDim(int value) { minorDim_ = value; }
  inline int getMaxMajorDim() const { return maxMajorDim_; }

  void dumpMatrix(const char *fname = NULL) const;

  void printMatrixElement(const int row_val, const int col_val) const;

  //-------------------------------------------------------------------------
#ifndef CLP_NO_VECTOR

  void appendMajorVector(const CoinPackedVectorBase &vec);
#endif

  void appendMajorVector(const int vecsize, const int *vecind,
    const double *vecelem);
#ifndef CLP_NO_VECTOR

  void appendMajorVectors(const int numvecs,
    const CoinPackedVectorBase *const *vecs);

  void appendMinorVector(const CoinPackedVectorBase &vec);
#endif

  void appendMinorVector(const int vecsize, const int *vecind,
    const double *vecelem);
#ifndef CLP_NO_VECTOR

  void appendMinorVectors(const int numvecs,
    const CoinPackedVectorBase *const *vecs);
#endif

  void appendMinorFast(const int number,
    const CoinBigIndex *starts, const int *index,
    const double *element);

  //-------------------------------------------------------------------------
  void majorAppendSameOrdered(const CoinPackedMatrix &matrix);
  void minorAppendSameOrdered(const CoinPackedMatrix &matrix);
  void majorAppendOrthoOrdered(const CoinPackedMatrix &matrix);
  void minorAppendOrthoOrdered(const CoinPackedMatrix &matrix);

  //-----------------------------------------------------------------------
  void deleteMajorVectors(const int numDel, const int *indDel);
  void deleteMinorVectors(const int numDel, const int *indDel);

  //-----------------------------------------------------------------------
  void timesMajor(const double *x, double *y) const;
#ifndef CLP_NO_VECTOR

  void timesMajor(const CoinPackedVectorBase &x, double *y) const;
#endif

  void timesMinor(const double *x, double *y) const;
#ifndef CLP_NO_VECTOR

  void timesMinor(const CoinPackedVectorBase &x, double *y) const;
#endif



  //--------------------------------------------------------------------------
#ifndef CLP_NO_VECTOR

  template < class FloatEqual >
  bool
  isEquivalent(const CoinPackedMatrix &rhs, const FloatEqual &eq) const
  {
    // Both must be column order or both row ordered and must be of same size
    if ((isColOrdered() ^ rhs.isColOrdered()) || (getNumCols() != rhs.getNumCols()) || (getNumRows() != rhs.getNumRows()) || (getNumElements() != rhs.getNumElements()))
      return false;

    for (int i = getMajorDim() - 1; i >= 0; --i) {
      CoinShallowPackedVector pv = getVector(i);
      CoinShallowPackedVector rhsPv = rhs.getVector(i);
      if (!pv.isEquivalent(rhsPv, eq))
        return false;
    }
    return true;
  }

  bool isEquivalent2(const CoinPackedMatrix &rhs) const;
#else

  bool isEquivalent(const CoinPackedMatrix &rhs, const CoinRelFltEq &eq) const;
#endif

  bool isEquivalent(const CoinPackedMatrix &rhs) const;

  //--------------------------------------------------------------------------
  inline double *getMutableElements() const { return element_; }
  inline int *getMutableIndices() const { return index_; }

  inline CoinBigIndex *getMutableVectorStarts() const { return start_; }
  inline int *getMutableVectorLengths() const { return length_; }
  inline void setNumElements(CoinBigIndex value)
  {
    size_ = value;
  }
  inline void nullElementArray() { element_ = NULL; }

  inline void nullStartArray() { start_ = NULL; }

  inline void nullLengthArray() { length_ = NULL; }

  inline void nullIndexArray() { index_ = NULL; }

  //--------------------------------------------------------------------------
  CoinPackedMatrix();

  CoinPackedMatrix(const bool colordered,
    const double extraMajor, const double extraGap);

  CoinPackedMatrix(const bool colordered,
    const int minor, const int major, const CoinBigIndex numels,
    const double *elem, const int *ind,
    const CoinBigIndex *start, const int *len,
    const double extraMajor, const double extraGap);

  CoinPackedMatrix(const bool colordered,
    const int minor, const int major, const CoinBigIndex numels,
    const double *elem, const int *ind,
    const CoinBigIndex *start, const int *len);

  CoinPackedMatrix(const bool colordered,
    const int *rowIndices,
    const int *colIndices,
    const double *elements,
    CoinBigIndex numels);

  CoinPackedMatrix(const CoinPackedMatrix &m);

  CoinPackedMatrix(const CoinPackedMatrix &m,
    int extraForMajor, int extraElements,
    bool reverseOrdering = false);

  CoinPackedMatrix(const CoinPackedMatrix &wholeModel,
    int numberRows, const int *whichRows,
    int numberColumns, const int *whichColumns);

  virtual ~CoinPackedMatrix();

  int verifyMtx(int verbosity = 1, bool zeroesAreError = false) const;

  //--------------------------------------------------------------------------
protected:
  void gutsOfDestructor();
  void gutsOfCopyOf(const bool colordered,
    const int minor, const int major, const CoinBigIndex numels,
    const double *elem, const int *ind,
    const CoinBigIndex *start, const int *len,
    const double extraMajor = 0.0, const double extraGap = 0.0);
  void gutsOfCopyOfNoGaps(const bool colordered,
    const int minor, const int major,
    const double *elem, const int *ind,
    const CoinBigIndex *start);
  void gutsOfOpEqual(const bool colordered,
    const int minor, const int major, const CoinBigIndex numels,
    const double *elem, const int *ind,
    const CoinBigIndex *start, const int *len);
  void resizeForAddingMajorVectors(const int numVec, const int *lengthVec);
  void resizeForAddingMinorVectors(const int *addedEntries);

  int appendMajor(const int number,
    const CoinBigIndex *starts, const int *index,
    const double *element, int numberOther = -1);
  int appendMinor(const int number,
    const CoinBigIndex *starts, const int *index,
    const double *element, int numberOther = -1);

private:
  inline CoinBigIndex getLastStart() const
  {
    return majorDim_ == 0 ? 0 : start_[majorDim_];
  }

  //--------------------------------------------------------------------------
protected:
  bool colOrdered_;
  double extraGap_;
  double extraMajor_;

  double *element_;
  int *index_;
  CoinBigIndex *start_;
  int *length_;

  int majorDim_;
  int minorDim_;
  CoinBigIndex size_;

  int maxMajorDim_;
  CoinBigIndex maxSize_;
};

//#############################################################################
void CoinPackedMatrixUnitTest();

#endif

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