Cbc  2.9.9
 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  //--------------------------------------------------------------------------
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
void majorAppendSameOrdered(const CoinPackedMatrix &matrix)
Append the columns of the argument to the right end of this matrix.
void transpose()
Transpose the matrix.
void removeGaps(double removeValue=-1.0)
Remove the gaps from the matrix if there were any Can also remove small elements fabs() &lt;= removeValu...
void reserve(const int newMaxMajorDim, const CoinBigIndex newMaxSize, bool create=false)
Reserve sufficient space for appending major-ordered vectors.
Error Class thrown by an exception.
Definition: CoinError.hpp:42
int appendMajor(const int number, const CoinBigIndex *starts, const int *index, const double *element, int numberOther=-1)
Append a set of rows (columns) to the end of a row (colum) ordered matrix.
bool colOrdered_
A flag indicating whether the matrix is column or row major ordered.
void appendRow(const CoinPackedVectorBase &vec)
Append a row to the end of the matrix.
int getVectorSize(const int i) const
The length of i&#39;th vector.
CoinBigIndex getNumElements() const
Number of entries in the packed matrix.
void submatrixOfWithDuplicates(const CoinPackedMatrix &matrix, const int numMajor, const int *indMajor)
Extract a submatrix from matrix.
CoinBigIndex size_
the number of nonzero entries
void deleteMajorVectors(const int numDel, const int *indDel)
Delete the major-dimension vectors whose indices are listed in indDel.
void timesMajor(const double *x, double *y) const
Return A * x (multiplied from the &quot;right&quot; direction) in y.
void deleteCols(const int numDel, const int *indDel)
Delete the columns whose indices are listed in indDel.
void appendCols(const int numcols, const CoinPackedVectorBase *const *cols)
Append a set of columns to the end of the matrix.
CoinBigIndex maxSize_
max space allocated for entries
int * length_
Lengths of major-dimension vectors.
const CoinShallowPackedVector getVector(int i) const
Return the i&#39;th vector in matrix.
void dumpMatrix(const char *fname=NULL) const
Dump the matrix on stdout.
int * index_
List of nonzero element minor-dimension indices.
CoinBigIndex * getMutableVectorStarts() const
The positions where the major-dimension vectors start in element_ and index_.
int * getMajorIndices() const
Returns an array containing major indices.
bool isEquivalent(const CoinPackedMatrix &rhs, const FloatEqual &eq) const
Test for equivalence.
double extraMajor_
his much times more space should be allocated for major-dimension vectors when the matrix is resized...
int eliminateDuplicates(double threshold)
Eliminate all duplicate AND small elements in matrix The column starts are not affected.
unsigned int verbosity
Verbosity level of unit tests.
void modifyCoefficient(int row, int column, double newElement, bool keepZero=false)
Modify one element of packed matrix.
void nullStartArray()
NULLify start array.
void setDimensions(int numrows, int numcols)
Set the dimensions of the matrix.
void nullLengthArray()
NULLify length array.
int verifyMtx(int verbosity=1, bool zeroesAreError=false) const
Scan the matrix for anomalies.
void setNumElements(CoinBigIndex value)
Change the size of the bulk store after modifying - be careful.
void gutsOfCopyOfNoGaps(const bool colordered, const int minor, const int major, const double *elem, const int *ind, const CoinBigIndex *start)
When no gaps we can do faster.
int maxMajorDim_
max space allocated for major-dimension
bool hasGaps() const
Whether the packed matrix has gaps or not.
void setExtraGap(const double newGap)
Set the extra gap to be allocated to the specified value.
bool isEquivalent(const CoinPackedVectorBase &rhs, const FloatEqual &eq) const
equivalent - If shallow packed vector A &amp; B are equivalent, then they are still equivalent no matter ...
CoinBigIndex * start_
Starting positions of major-dimension vectors.
int minorDim_
size of other dimension
bool isColOrdered() const
Whether the packed matrix is column major ordered or not.
double * element_
List of nonzero element values.
void appendCol(const CoinPackedVectorBase &vec)
Append a column to the end of the matrix.
void submatrixOf(const CoinPackedMatrix &matrix, const int numMajor, const int *indMajor)
Extract a submatrix from matrix.
Abstract base class for various sparse vectors.
void reverseOrderedCopyOf(const CoinPackedMatrix &rhs)
Make a reverse-ordered copy.
void clear()
Clear the data, but do not free any arrays.
void timesMinor(const double *x, double *y) const
Return A * x (multiplied from the &quot;right&quot; direction) in y.
int * getMutableVectorLengths() const
The lengths of the major-dimension vectors.
int majorDim_
number of vectors in matrix
CoinPackedMatrix & operator=(const CoinPackedMatrix &rhs)
Assignment operator.
int getNumCols() const
Number of columns.
void nullIndexArray()
NULLify index array.
int appendMinor(const int number, const CoinBigIndex *starts, const int *index, const double *element, int numberOther=-1)
Append a set of rows (columns) to the end of a column (row) ordered matrix.
int * countOrthoLength() const
Count the number of entries in every minor-dimension vector and return an array containing these leng...
void minorAppendSameOrdered(const CoinPackedMatrix &matrix)
Append the columns of the argument to the bottom end of this matrix.
Equality to a scaled tolerance.
void appendMinorVectors(const int numvecs, const CoinPackedVectorBase *const *vecs)
Append several minor-dimension vectors to the end of the matrix.
void times(const double *x, double *y) const
Return A * x in y.
const CoinBigIndex * getVectorStarts() const
The positions where the major-dimension vectors start in elements and indices.
void setMinorDim(int value)
Set minor dimension.
void deleteMinorVectors(const int numDel, const int *indDel)
Delete the minor-dimension vectors whose indices are listed in indDel.
void orderMatrix()
Sort all columns so indices are increasing.in each column.
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)
Assign the arguments to the matrix.
void bottomAppendPackedMatrix(const CoinPackedMatrix &matrix)
Append the argument to the &quot;bottom&quot; of the current matrix.
void resizeForAddingMajorVectors(const int numVec, const int *lengthVec)
void minorAppendOrthoOrdered(const CoinPackedMatrix &matrix)
Append the rows of the argument to the bottom end of this matrix.
double * getMutableElements() const
A vector containing the elements in the packed matrix.
void setMajorDim(int value)
Set major dimension.
CoinBigIndex getLastStart() const
const double * getElements() const
A vector containing the elements in the packed matrix.
virtual ~CoinPackedMatrix()
Destructor.
void deleteRows(const int numDel, const int *indDel)
Delete the rows whose indices are listed in indDel.
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)
int getSizeVectorLengths() const
The size of the vectorLengths array.
void appendMinorVector(const CoinPackedVectorBase &vec)
Append a minor-dimension vector to the end of the matrix.
int compress(double threshold)
Eliminate all elements in matrix whose absolute value is less than threshold.
int getNumRows() const
Number of rows.
CoinBigIndex getVectorLast(const int i) const
The position of the last element (well, one entry past the last) in the i&#39;th major-dimension vector...
void gutsOfDestructor()
void majorAppendOrthoOrdered(const CoinPackedMatrix &matrix)
Append the rows of the argument to the right end of this matrix.
int getMaxMajorDim() const
Current maximum for major dimension.
Sparse Matrix Base Class.
double getExtraGap() const
Return the current setting of the extra gap.
void reverseOrdering()
Reverse the ordering of the packed matrix.
void copyOf(const CoinPackedMatrix &rhs)
Copy method.
void replaceVector(const int index, const int numReplace, const double *newElements)
Replace the elements of a vector.
double extraGap_
This much times more space should be allocated for each major-dimension vector (with respect to the n...
int CoinBigIndex
const int * getVectorLengths() const
The lengths of the major-dimension vectors.
bool isEquivalent2(const CoinPackedMatrix &rhs) const
Test for equivalence and report differences.
void nullElementArray()
NULLify element array.
void appendMajorVector(const CoinPackedVectorBase &vec)
Append a major-dimension vector to the end of the matrix.
const int * getIndices() const
A vector containing the minor indices of the elements in the packed matrix.
void transposeTimes(const double *x, double *y) const
Return x * A in y.
void appendMajorVectors(const int numvecs, const CoinPackedVectorBase *const *vecs)
Append several major-dimensonvectors to the end of the matrix.
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)
int * getMutableIndices() const
A vector containing the minor indices of the elements in the packed matrix.
void CoinPackedMatrixUnitTest()
Test the methods in the CoinPackedMatrix class.
double getExtraMajor() const
Return the current setting of the extra major.
void printMatrixElement(const int row_val, const int col_val) const
Print a single matrix element.
int getSizeVectorStarts() const
The size of the vectorStarts array.
void setExtraMajor(const double newMajor)
Set the extra major to be allocated to the specified value.
CoinPackedMatrix()
Default Constructor creates an empty column ordered packed matrix.
int getMinorDim() const
Minor dimension.
CoinBigIndex getVectorFirst(const int i) const
The position of the first element in the i&#39;th major-dimension vector.
void resizeForAddingMinorVectors(const int *addedEntries)
friend void CoinPackedMatrixUnitTest()
Test the methods in the CoinPackedMatrix class.
void swap(CoinPackedMatrix &matrix)
Swap the content of two packed matrices.
void appendRows(const int numrows, const CoinPackedVectorBase *const *rows)
Append a set of rows to the end of the matrix.
void rightAppendPackedMatrix(const CoinPackedMatrix &matrix)
Append the argument to the &quot;right&quot; of the current matrix.
void appendMinorFast(const int number, const CoinBigIndex *starts, const int *index, const double *element)
Append a set of rows (columns) to the end of a column (row) ordered matrix.
double getCoefficient(int row, int column) const
Return one element of packed matrix.
int cleanMatrix(double threshold=1.0e-20)
Really clean up matrix.
int getMajorDim() const
Major dimension.
void copyReuseArrays(const CoinPackedMatrix &rhs)
Copy method.