/home/coin/SVN-release/CoinAll-1.1.0/CoinUtils/src/CoinPackedMatrix.hpp

Go to the documentation of this file.

// Copyright (C) 2000, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef CoinPackedMatrix_H
#define CoinPackedMatrix_H

#include "CoinError.hpp"
#ifndef CLP_NO_VECTOR
#include "CoinPackedVectorBase.hpp"
#include "CoinShallowPackedVector.hpp"
#else
#include "CoinFinite.hpp"
#include "CoinFloatEqual.hpp"
#endif

class CoinPackedMatrix  {
   friend void CoinPackedMatrixUnitTest();

public:


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

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

    bool isColOrdered() const { return colOrdered_; }
    CoinBigIndex getNumElements() const { return size_; }
    int getNumCols() const { return colOrdered_ ? majorDim_ : minorDim_; }
    int getNumRows() const { return colOrdered_ ? minorDim_ : majorDim_; }

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

    int getSizeVectorStarts()const { return majorDim_ > 0 ? majorDim_+1 : 0;}
    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 {
      if (i < 0 || i >= majorDim_)
        throw CoinError("bad index", "vectorFirst", "CoinPackedMatrix");
      return start_[i];
    }
    CoinBigIndex getVectorLast(const int i) const {
      if (i < 0 || i >= majorDim_)
        throw CoinError("bad index", "vectorLast", "CoinPackedMatrix");
      return start_[i] + length_[i];
    }
    inline int getVectorSize(const int i) const {
      if (i < 0 || i >= majorDim_)
        throw CoinError("bad index", "vectorSize", "CoinPackedMatrix");
      return length_[i];
    }
#ifndef CLP_NO_VECTOR  

    const CoinShallowPackedVector getVector(int i) const {
      if (i < 0 || i >= majorDim_)
        throw CoinError("bad index", "vector", "CoinPackedMatrix");
      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;

    int compress(double threshold);
    int eliminateDuplicates(double threshold);
    void orderMatrix();
    int 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;
      int getMajorDim() const { return majorDim_; }
      int getMinorDim() const { return minorDim_; }
      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 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
   {
      return isEquivalent(rhs,  CoinRelFltEq());
   }

   //--------------------------------------------------------------------------
    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();    

   //--------------------------------------------------------------------------
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

---