CoinUtils  2.9.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
CoinPackedMatrix.hpp
Go to the documentation of this file.
1 /* $Id: CoinPackedMatrix.hpp 1560 2012-11-24 00:29:01Z lou $ */
2 // Copyright (C) 2000, International Business Machines
3 // Corporation and others. All Rights Reserved.
4 // This code is licensed under the terms of the Eclipse Public License (EPL).
5 
6 #ifndef CoinPackedMatrix_H
7 #define CoinPackedMatrix_H
8 
9 #include "CoinError.hpp"
10 #include "CoinTypes.hpp"
11 #ifndef CLP_NO_VECTOR
12 #include "CoinPackedVectorBase.hpp"
14 #else
15 class CoinRelFltEq;
16 #endif
17 
80  friend void CoinPackedMatrixUnitTest();
81 
82 public:
83 
84 
85  //---------------------------------------------------------------------------
89  inline double getExtraGap() const { return extraGap_; }
91  inline double getExtraMajor() const { return extraMajor_; }
92 
95  void reserve(const int newMaxMajorDim, const CoinBigIndex newMaxSize,
96  bool create=false);
98  void clear();
99 
101  inline bool isColOrdered() const { return colOrdered_; }
102 
104  inline bool hasGaps() const { return (size_<start_[majorDim_]) ; }
105 
107  inline CoinBigIndex getNumElements() const { return size_; }
108 
110  inline int getNumCols() const
111  { return colOrdered_ ? majorDim_ : minorDim_; }
112 
114  inline int getNumRows() const
115  { return colOrdered_ ? minorDim_ : majorDim_; }
116 
124  inline const double * getElements() const { return element_; }
125 
134  inline const int * getIndices() const { return index_; }
135 
140  inline int getSizeVectorStarts() const
141  { return ((majorDim_ > 0)?(majorDim_+1):(0)) ; }
142 
147  inline int getSizeVectorLengths() const { return majorDim_; }
148 
154  inline const CoinBigIndex * getVectorStarts() const { return start_; }
155 
160  inline const int * getVectorLengths() const { return length_; }
161 
164  CoinBigIndex getVectorFirst(const int i) const {
165 #ifndef COIN_FAST_CODE
166  if (i < 0 || i >= majorDim_)
167  throw CoinError("bad index", "vectorFirst", "CoinPackedMatrix");
168 #endif
169  return start_[i];
170  }
173  CoinBigIndex getVectorLast(const int i) const {
174 #ifndef COIN_FAST_CODE
175  if (i < 0 || i >= majorDim_)
176  throw CoinError("bad index", "vectorLast", "CoinPackedMatrix");
177 #endif
178  return start_[i] + length_[i];
179  }
181  inline int getVectorSize(const int i) const {
182 #ifndef COIN_FAST_CODE
183  if (i < 0 || i >= majorDim_)
184  throw CoinError("bad index", "vectorSize", "CoinPackedMatrix");
185 #endif
186  return length_[i];
187  }
188 #ifndef CLP_NO_VECTOR
189 
190  const CoinShallowPackedVector getVector(int i) const {
191 #ifndef COIN_FAST_CODE
192  if (i < 0 || i >= majorDim_)
193  throw CoinError("bad index", "vector", "CoinPackedMatrix");
194 #endif
196  index_ + start_[i],
197  element_ + start_[i],
198  false);
199  }
200 #endif
201 
211  int * getMajorIndices() const;
213 
214  //---------------------------------------------------------------------------
225  void setDimensions(int numrows, int numcols);
226 
228  void setExtraGap(const double newGap);
230  void setExtraMajor(const double newMajor);
231 #ifndef CLP_NO_VECTOR
232 
238  void appendCol(const CoinPackedVectorBase& vec);
239 #endif
240 
246  void appendCol(const int vecsize,
247  const int *vecind, const double *vecelem);
248 #ifndef CLP_NO_VECTOR
249 
255  void appendCols(const int numcols,
256  const CoinPackedVectorBase * const * cols);
257 #endif
258 
263  int appendCols(const int numcols,
264  const CoinBigIndex * columnStarts, const int * row,
265  const double * element, int numberRows=-1);
266 #ifndef CLP_NO_VECTOR
267 
273  void appendRow(const CoinPackedVectorBase& vec);
274 #endif
275 
281  void appendRow(const int vecsize,
282  const int *vecind, const double *vecelem);
283 #ifndef CLP_NO_VECTOR
284 
290  void appendRows(const int numrows,
291  const CoinPackedVectorBase * const * rows);
292 #endif
293 
298  int appendRows(const int numrows,
299  const CoinBigIndex * rowStarts, const int * column,
300  const double * element, int numberColumns=-1);
301 
306  void rightAppendPackedMatrix(const CoinPackedMatrix& matrix);
311  void bottomAppendPackedMatrix(const CoinPackedMatrix& matrix);
312 
314  void deleteCols(const int numDel, const int * indDel);
316  void deleteRows(const int numDel, const int * indDel);
317 
321  void replaceVector(const int index,
322  const int numReplace, const double * newElements);
327  void modifyCoefficient(int row, int column, double newElement,
328  bool keepZero=false);
332  double getCoefficient(int row, int column) const;
333 
339  int compress(double threshold);
344  int eliminateDuplicates(double threshold);
346  void orderMatrix();
354  int cleanMatrix(double threshold=1.0e-20);
356 
357  //---------------------------------------------------------------------------
362  void removeGaps(double removeValue=-1.0);
363 
367  void submatrixOf(const CoinPackedMatrix& matrix,
368  const int numMajor, const int * indMajor);
372  void submatrixOfWithDuplicates(const CoinPackedMatrix& matrix,
373  const int numMajor, const int * indMajor);
374 #if 0
375 
378  void submatrixOf(const CoinPackedMatrix& matrix,
379  const int numMajor, const int * indMajor,
380  const int numMinor, const int * indMinor);
381 #endif
382 
385  void copyOf(const CoinPackedMatrix& rhs);
389  void copyOf(const bool colordered,
390  const int minor, const int major, const CoinBigIndex numels,
391  const double * elem, const int * ind,
392  const CoinBigIndex * start, const int * len,
393  const double extraMajor=0.0, const double extraGap=0.0);
397  void copyReuseArrays(const CoinPackedMatrix& rhs);
398 
406  void reverseOrderedCopyOf(const CoinPackedMatrix& rhs);
407 
416  void assignMatrix(const bool colordered,
417  const int minor, const int major,
418  const CoinBigIndex numels,
419  double *& elem, int *& ind,
420  CoinBigIndex *& start, int *& len,
421  const int maxmajor = -1, const CoinBigIndex maxsize = -1);
422 
423 
424 
428 
435  void reverseOrdering();
436 
446  void transpose();
447 
449  void swap(CoinPackedMatrix& matrix);
450 
452 
453  //---------------------------------------------------------------------------
459  void times(const double * x, double * y) const;
460 #ifndef CLP_NO_VECTOR
461 
463  void times(const CoinPackedVectorBase& x, double * y) const;
464 #endif
465 
468  void transposeTimes(const double * x, double * y) const;
469 #ifndef CLP_NO_VECTOR
470 
472  void transposeTimes(const CoinPackedVectorBase& x, double * y) const;
473 #endif
474 
475 
476  //---------------------------------------------------------------------------
484 
485  //-------------------------------------------------------------------------
492  int * countOrthoLength() const;
495  void countOrthoLength(int * counts) const;
498  inline int getMajorDim() const { return majorDim_; }
501  inline void setMajorDim(int value) { majorDim_ = value; }
504  inline int getMinorDim() const { return minorDim_; }
507  inline void setMinorDim(int value) { minorDim_ = value; }
511  inline int getMaxMajorDim() const { return maxMajorDim_; }
512 
515  void dumpMatrix(const char* fname = NULL) const;
516 
518  void printMatrixElement(const int row_val, const int col_val) const;
520 
521  //-------------------------------------------------------------------------
531 #ifndef CLP_NO_VECTOR
532 
533  void appendMajorVector(const CoinPackedVectorBase& vec);
534 #endif
535 
536  void appendMajorVector(const int vecsize, const int *vecind,
537  const double *vecelem);
538 #ifndef CLP_NO_VECTOR
539 
540  void appendMajorVectors(const int numvecs,
541  const CoinPackedVectorBase * const * vecs);
542 
544  void appendMinorVector(const CoinPackedVectorBase& vec);
545 #endif
546 
547  void appendMinorVector(const int vecsize, const int *vecind,
548  const double *vecelem);
549 #ifndef CLP_NO_VECTOR
550 
551  void appendMinorVectors(const int numvecs,
552  const CoinPackedVectorBase * const * vecs);
553 #endif
554 
566  void appendMinorFast(const int number,
567  const CoinBigIndex * starts, const int * index,
568  const double * element);
570 
571  //-------------------------------------------------------------------------
585  void majorAppendSameOrdered(const CoinPackedMatrix& matrix);
590  void minorAppendSameOrdered(const CoinPackedMatrix& matrix);
596  void majorAppendOrthoOrdered(const CoinPackedMatrix& matrix);
602  void minorAppendOrthoOrdered(const CoinPackedMatrix& matrix);
604 
605  //-----------------------------------------------------------------------
610  void deleteMajorVectors(const int numDel, const int * indDel);
613  void deleteMinorVectors(const int numDel, const int * indDel);
615 
616  //-----------------------------------------------------------------------
623  void timesMajor(const double * x, double * y) const;
624 #ifndef CLP_NO_VECTOR
625 
628  void timesMajor(const CoinPackedVectorBase& x, double * y) const;
629 #endif
630 
634  void timesMinor(const double * x, double * y) const;
635 #ifndef CLP_NO_VECTOR
636 
639  void timesMinor(const CoinPackedVectorBase& x, double * y) const;
640 #endif
641 
642 
643 
644  //--------------------------------------------------------------------------
647 #ifndef CLP_NO_VECTOR
648 
655  template <class FloatEqual> bool
656  isEquivalent(const CoinPackedMatrix& rhs, const FloatEqual& eq) const
657  {
658  // Both must be column order or both row ordered and must be of same size
659  if ((isColOrdered() ^ rhs.isColOrdered()) ||
660  (getNumCols() != rhs.getNumCols()) ||
661  (getNumRows() != rhs.getNumRows()) ||
662  (getNumElements() != rhs.getNumElements()))
663  return false;
664 
665  for (int i=getMajorDim()-1; i >= 0; --i) {
667  CoinShallowPackedVector rhsPv = rhs.getVector(i);
668  if ( !pv.isEquivalent(rhsPv,eq) )
669  return false;
670  }
671  return true;
672  }
673 
680  bool isEquivalent2(const CoinPackedMatrix& rhs) const;
681 #else
682 
690  bool isEquivalent(const CoinPackedMatrix& rhs, const CoinRelFltEq & eq) const;
691 #endif
692 
696  bool isEquivalent(const CoinPackedMatrix& rhs) const;
698 
699  //--------------------------------------------------------------------------
709  inline double * getMutableElements() const { return element_; }
715  inline int * getMutableIndices() const { return index_; }
716 
719  inline CoinBigIndex * getMutableVectorStarts() const { return start_; }
721  inline int * getMutableVectorLengths() const { return length_; }
723  inline void setNumElements(CoinBigIndex value)
724  { size_ = value;}
729  inline void nullElementArray() {element_=NULL;}
730 
735  inline void nullStartArray() {start_=NULL;}
736 
741  inline void nullLengthArray() {length_=NULL;}
742 
747  inline void nullIndexArray() {index_=NULL;}
749 
750  //--------------------------------------------------------------------------
753 
755 
757  CoinPackedMatrix(const bool colordered,
758  const double extraMajor, const double extraGap);
759 
760  CoinPackedMatrix(const bool colordered,
761  const int minor, const int major, const CoinBigIndex numels,
762  const double * elem, const int * ind,
763  const CoinBigIndex * start, const int * len,
764  const double extraMajor, const double extraGap);
765 
766  CoinPackedMatrix(const bool colordered,
767  const int minor, const int major, const CoinBigIndex numels,
768  const double * elem, const int * ind,
769  const CoinBigIndex * start, const int * len);
770 
781  CoinPackedMatrix(const bool colordered,
782  const int * rowIndices,
783  const int * colIndices,
784  const double * elements,
785  CoinBigIndex numels );
786 
789 
805  int extraForMajor, int extraElements,
806  bool reverseOrdering = false) ;
807 
810  CoinPackedMatrix (const CoinPackedMatrix & wholeModel,
811  int numberRows, const int * whichRows,
812  int numberColumns, const int * whichColumns);
813 
815  virtual ~CoinPackedMatrix();
817 
841  int verifyMtx(int verbosity = 1, bool zeroesAreError = false) const ;
843 
844  //--------------------------------------------------------------------------
845 protected:
846  void gutsOfDestructor();
847  void gutsOfCopyOf(const bool colordered,
848  const int minor, const int major, const CoinBigIndex numels,
849  const double * elem, const int * ind,
850  const CoinBigIndex * start, const int * len,
851  const double extraMajor=0.0, const double extraGap=0.0);
853  void gutsOfCopyOfNoGaps(const bool colordered,
854  const int minor, const int major,
855  const double * elem, const int * ind,
856  const CoinBigIndex * start);
857  void gutsOfOpEqual(const bool colordered,
858  const int minor, const int major, const CoinBigIndex numels,
859  const double * elem, const int * ind,
860  const CoinBigIndex * start, const int * len);
861  void resizeForAddingMajorVectors(const int numVec, const int * lengthVec);
862  void resizeForAddingMinorVectors(const int * addedEntries);
863 
873  int appendMajor(const int number,
874  const CoinBigIndex * starts, const int * index,
875  const double * element, int numberOther=-1);
885  int appendMinor(const int number,
886  const CoinBigIndex * starts, const int * index,
887  const double * element, int numberOther=-1);
888 
889 private:
890  inline CoinBigIndex getLastStart() const {
891  return majorDim_ == 0 ? 0 : start_[majorDim_];
892  }
893 
894  //--------------------------------------------------------------------------
895 protected:
905  double extraGap_;
909  double extraMajor_;
910 
913  double *element_;
916  int *index_;
920  int *length_;
921 
928 
934 };
935 
936 //#############################################################################
944 void
946 
947 #endif