CoinPackedMatrix.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 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
*/