CoinPackedMatrix.hpp

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

#include "CoinError.hpp"
#include "CoinPackedVectorBase.hpp"
#include "CoinShallowPackedVector.hpp"

#ifndef COIN_BIG_INDEX
typedef int CoinBigIndex;
#else
typedef long CoinBigIndex;
#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);
    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 throw(CoinError) {
      if (i < 0 || i >= majorDim_)
        throw CoinError("bad index", "vectorFirst", "CoinPackedMatrix");
      return start_[i];
    }
    CoinBigIndex getVectorLast(const int i) const throw(CoinError) {
      if (i < 0 || i >= majorDim_)
        throw CoinError("bad index", "vectorLast", "CoinPackedMatrix");
      return start_[i] + length_[i];
    }
    int getVectorSize(const int i) const throw(CoinError) {
      if (i < 0 || i >= majorDim_)
        throw CoinError("bad index", "vectorSize", "CoinPackedMatrix");
      return length_[i];
    }
  
    const CoinShallowPackedVector getVector(int i) const throw(CoinError) {
      if (i < 0 || i >= majorDim_)
        throw CoinError("bad index", "vector", "CoinPackedMatrix");
      return CoinShallowPackedVector(length_[i],
                                    index_ + start_[i],
                                    element_ + start_[i],
                                    false);
    }

  //---------------------------------------------------------------------------
    void setDimensions(int numrows, int numcols) throw(CoinError);
   
    void setExtraGap(const double newGap) throw(CoinError);
    void setExtraMajor(const double newMajor) throw(CoinError);

    void appendCol(const CoinPackedVectorBase& vec) throw(CoinError);
    void appendCol(const int vecsize,
                  const int *vecind, const double *vecelem) throw(CoinError);
    void appendCols(const int numcols,
                    const CoinPackedVectorBase * const * cols) throw(CoinError);

    void appendRow(const CoinPackedVectorBase& vec) throw(CoinError);
    void appendRow(const int vecsize,
                  const int *vecind, const double *vecelem) throw(CoinError);
    void appendRows(const int numrows,
                    const CoinPackedVectorBase * const * rows) throw(CoinError);
  
    void rightAppendPackedMatrix(const CoinPackedMatrix& matrix)
      throw(CoinError);
    void bottomAppendPackedMatrix(const CoinPackedMatrix& matrix)
      throw(CoinError);
  
    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);

    int compress(double threshold);
    int eliminateDuplicates(double threshold);

  //---------------------------------------------------------------------------
    void removeGaps();
 
    void submatrixOf(const CoinPackedMatrix& matrix,
                     const int numMajor, const int * indMajor)
       throw(CoinError);
#if 0

    void submatrixOf(const CoinPackedMatrix& matrix,
                     const int numMajor, const int * indMajor,
                     const int numMinor, const int * indMinor) throw(CoinError);
#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 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;
    void times(const CoinPackedVectorBase& x, double * y) const;
    void transposeTimes(const double * x, double * y) const;
    void transposeTimes(const CoinPackedVectorBase& x, double * y) const;

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

    //-------------------------------------------------------------------------
      int * countOrthoLength() const;
      int getMajorDim() const { return majorDim_; }
      int getMinorDim() const { return minorDim_; }
      int getMaxMajorDim() const { return maxMajorDim_; }

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

    //-------------------------------------------------------------------------
      void appendMajorVector(const CoinPackedVectorBase& vec) throw(CoinError);
      void appendMajorVector(const int vecsize, const int *vecind,
                             const double *vecelem) throw(CoinError);
      void appendMajorVectors(const int numvecs,
                              const CoinPackedVectorBase * const * vecs)
        throw(CoinError);

      void appendMinorVector(const CoinPackedVectorBase& vec) throw(CoinError);
      void appendMinorVector(const int vecsize, const int *vecind,
                             const double *vecelem) throw(CoinError);
      void appendMinorVectors(const int numvecs,
                              const CoinPackedVectorBase * const * vecs)
        throw(CoinError);

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

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

      //-----------------------------------------------------------------------
      void timesMajor(const double * x, double * y) const;
      void timesMajor(const CoinPackedVectorBase& x, double * y) const;
      void timesMinor(const double * x, double * y) const;
      void timesMinor(const CoinPackedVectorBase& x, double * y) const;


   //--------------------------------------------------------------------------
   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 isEquivalent(const CoinPackedMatrix& rhs) const
   {
      return isEquivalent(rhs,  CoinRelFltEq());
   }
  bool isEquivalent2(const CoinPackedMatrix& rhs) const;

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

   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 & 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 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);
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

---