- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

# /home/coin/svn-release/Blis-0.94.1/Clp/src/ClpPackedMatrix.hpp

Go to the documentation of this file.

    00001 /* $Id: ClpPackedMatrix.hpp 2078 2015-01-05 12:39:49Z forrest $ */
    00002 // Copyright (C) 2002, International Business Machines
    00003 // Corporation and others.  All Rights Reserved.
    00004 // This code is licensed under the terms of the Eclipse Public License (EPL).
    00005
    00006 #ifndef ClpPackedMatrix_H
    00007 #define ClpPackedMatrix_H
    00008
    00009 #include "CoinPragma.hpp"
    00010
    00011 #include "ClpMatrixBase.hpp"
    00012
    00019 class ClpPackedMatrix2;
    00020 class ClpPackedMatrix3;
    00021 class ClpPackedMatrix : public ClpMatrixBase {
    00022
    00023 public:
    00026
    00027      virtual CoinPackedMatrix * getPackedMatrix() const {
    00028           return matrix_;
    00029      }
    00031      virtual bool isColOrdered() const {
    00032           return matrix_->isColOrdered();
    00033      }
    00035      virtual  CoinBigIndex getNumElements() const {
    00036           return matrix_->getNumElements();
    00037      }
    00039      virtual int getNumCols() const {
    00040           return matrix_->getNumCols();
    00041      }
    00043      virtual int getNumRows() const {
    00044           return matrix_->getNumRows();
    00045      }
    00046
    00051      virtual const double * getElements() const {
    00052           return matrix_->getElements();
    00053      }
    00055      inline double * getMutableElements() const {
    00056           return matrix_->getMutableElements();
    00057      }
    00063      virtual const int * getIndices() const {
    00064           return matrix_->getIndices();
    00065      }
    00066
    00067      virtual const CoinBigIndex * getVectorStarts() const {
    00068           return matrix_->getVectorStarts();
    00069      }
    00071      virtual const int * getVectorLengths() const {
    00072           return matrix_->getVectorLengths();
    00073      }
    00075      virtual int getVectorLength(int index) const {
    00076           return matrix_->getVectorSize(index);
    00077      }
    00078
    00080      virtual void deleteCols(const int numDel, const int * indDel);
    00082      virtual void deleteRows(const int numDel, const int * indDel);
    00083 #ifndef CLP_NO_VECTOR
    00085      virtual void appendCols(int number, const CoinPackedVectorBase * const * columns);
    00087      virtual void appendRows(int number, const CoinPackedVectorBase * const * rows);
    00088 #endif
    00089
    00093      virtual int appendMatrix(int number, int type,
    00094                               const CoinBigIndex * starts, const int * index,
    00095                               const double * element, int numberOther = -1);
    00100      virtual void replaceVector(const int index,
    00101                                 const int numReplace, const double * newElements) {
    00102           matrix_->replaceVector(index, numReplace, newElements);
    00103      }
    00107      virtual void modifyCoefficient(int row, int column, double newElement,
    00108                                     bool keepZero = false) {
    00109           matrix_->modifyCoefficient(row, column, newElement, keepZero);
    00110      }
    00112      virtual ClpMatrixBase * reverseOrderedCopy() const;
    00114      virtual CoinBigIndex countBasis(const int * whichColumn,
    00115                                      int & numberColumnBasic);
    00117      virtual void fillBasis(ClpSimplex * model,
    00118                             const int * whichColumn,
    00119                             int & numberColumnBasic,
    00120                             int * row, int * start,
    00121                             int * rowCount, int * columnCount,
    00122                             CoinFactorizationDouble * element);
    00125      virtual int scale(ClpModel * model, const ClpSimplex * baseModel = NULL) const ;
    00128      virtual void scaleRowCopy(ClpModel * model) const ;
    00130      void createScaledMatrix(ClpSimplex * model) const;
    00134      virtual ClpMatrixBase * scaledColumnCopy(ClpModel * model) const ;
    00145      virtual bool allElementsInRange(ClpModel * model,
    00146                                      double smallest, double largest,
    00147                                      int check = 15);
    00151      virtual void rangeOfElements(double & smallestNegative, double & largestNegative,
    00152                                   double & smallestPositive, double & largestPositive);
    00153
    00156      virtual void unpack(const ClpSimplex * model, CoinIndexedVector * rowArray,
    00157                          int column) const ;
    00162      virtual void unpackPacked(ClpSimplex * model,
    00163                                CoinIndexedVector * rowArray,
    00164                                int column) const;
    00167      virtual void add(const ClpSimplex * model, CoinIndexedVector * rowArray,
    00168                       int column, double multiplier) const ;
    00170      virtual void add(const ClpSimplex * model, double * array,
    00171                       int column, double multiplier) const;
    00173      virtual void releasePackedMatrix() const { }
    00178      virtual CoinBigIndex * dubiousWeights(const ClpSimplex * model, int * inputWeights) const;
    00180      virtual bool canDoPartialPricing() const;
    00182      virtual void partialPricing(ClpSimplex * model, double start, double end,
    00183                                  int & bestSequence, int & numberWanted);
    00185      virtual int refresh(ClpSimplex * model);
    00186      // Really scale matrix
    00187      virtual void reallyScale(const double * rowScale, const double * columnScale);
    00193      virtual void setDimensions(int numrows, int numcols);
    00195
    00201      virtual void times(double scalar,
    00202                         const double * x, double * y) const;
    00204      virtual void times(double scalar,
    00205                         const double * x, double * y,
    00206                         const double * rowScale,
    00207                         const double * columnScale) const;
    00211      virtual void transposeTimes(double scalar,
    00212                                  const double * x, double * y) const;
    00214      virtual void transposeTimes(double scalar,
    00215                                  const double * x, double * y,
    00216                                  const double * rowScale,
    00217                                  const double * columnScale,
    00218                                  double * spare = NULL) const;
    00223      void transposeTimesSubset( int number,
    00224                                 const int * which,
    00225                                 const double * pi, double * y,
    00226                                 const double * rowScale,
    00227                                 const double * columnScale,
    00228                                 double * spare = NULL) const;
    00233      virtual void transposeTimes(const ClpSimplex * model, double scalar,
    00234                                  const CoinIndexedVector * x,
    00235                                  CoinIndexedVector * y,
    00236                                  CoinIndexedVector * z) const;
    00241      void transposeTimesByColumn(const ClpSimplex * model, double scalar,
    00242                                  const CoinIndexedVector * x,
    00243                                  CoinIndexedVector * y,
    00244                                  CoinIndexedVector * z) const;
    00250      virtual void transposeTimesByRow(const ClpSimplex * model, double scalar,
    00251                                       const CoinIndexedVector * x,
    00252                                       CoinIndexedVector * y,
    00253                                       CoinIndexedVector * z) const;
    00257      virtual void subsetTransposeTimes(const ClpSimplex * model,
    00258                                        const CoinIndexedVector * x,
    00259                                        const CoinIndexedVector * y,
    00260                                        CoinIndexedVector * z) const;
    00263      virtual bool canCombine(const ClpSimplex * model,
    00264                              const CoinIndexedVector * pi) const;
    00266      virtual void transposeTimes2(const ClpSimplex * model,
    00267                                   const CoinIndexedVector * pi1, CoinIndexedVector * dj1,
    00268                                   const CoinIndexedVector * pi2,
    00269                                   CoinIndexedVector * spare,
    00270                                   double referenceIn, double devex,
    00271                                   // Array for exact devex to say what is in reference framework
    00272                                   unsigned int * reference,
    00273                                   double * weights, double scaleFactor);
    00275      virtual void subsetTimes2(const ClpSimplex * model,
    00276                                CoinIndexedVector * dj1,
    00277                                const CoinIndexedVector * pi2, CoinIndexedVector * dj2,
    00278                                double referenceIn, double devex,
    00279                                // Array for exact devex to say what is in reference framework
    00280                                unsigned int * reference,
    00281                                double * weights, double scaleFactor);
    00283      void useEffectiveRhs(ClpSimplex * model);
    00284 #if COIN_LONG_WORK
    00285      // For long double versions
    00286      virtual void times(CoinWorkDouble scalar,
    00287                         const CoinWorkDouble * x, CoinWorkDouble * y) const ;
    00288      virtual void transposeTimes(CoinWorkDouble scalar,
    00289                                  const CoinWorkDouble * x, CoinWorkDouble * y) const ;
    00290 #endif
    00291
    00292
    00295
    00296      inline CoinPackedMatrix * matrix() const {
    00297           return matrix_;
    00298      }
    00302      inline void setMatrixNull() {
    00303           matrix_ = NULL;
    00304      }
    00306      inline void makeSpecialColumnCopy() {
    00307           flags_ |= 16;
    00308      }
    00310      void releaseSpecialColumnCopy();
    00312      inline bool zeros() const {
    00313           return ((flags_ & 1) != 0);
    00314      }
    00316      inline bool wantsSpecialColumnCopy() const {
    00317           return ((flags_ & 16) != 0);
    00318      }
    00320      inline int flags() const {
    00321           return flags_;
    00322      }
    00324      inline void checkGaps() {
    00325           flags_ = (matrix_->hasGaps()) ? (flags_ | 2) : (flags_ & (~2));
    00326      }
    00328      inline int numberActiveColumns() const
    00329      { return numberActiveColumns_;}
    00331      inline void setNumberActiveColumns(int value)
    00332      { numberActiveColumns_ = value;}
    00334
    00335
    00339      ClpPackedMatrix();
    00341      virtual ~ClpPackedMatrix();
    00343
    00347      ClpPackedMatrix(const ClpPackedMatrix&);
    00349      ClpPackedMatrix(const CoinPackedMatrix&);
    00352      ClpPackedMatrix (const ClpPackedMatrix & wholeModel,
    00353                       int numberRows, const int * whichRows,
    00354                       int numberColumns, const int * whichColumns);
    00355      ClpPackedMatrix (const CoinPackedMatrix & wholeModel,
    00356                       int numberRows, const int * whichRows,
    00357                       int numberColumns, const int * whichColumns);
    00358
    00360      ClpPackedMatrix(CoinPackedMatrix * matrix);
    00361
    00362      ClpPackedMatrix& operator=(const ClpPackedMatrix&);
    00364      virtual ClpMatrixBase * clone() const ;
    00366      virtual void copy(const ClpPackedMatrix * from);
    00369      virtual ClpMatrixBase * subsetClone (
    00370           int numberRows, const int * whichRows,
    00371           int numberColumns, const int * whichColumns) const ;
    00373      void specialRowCopy(ClpSimplex * model, const ClpMatrixBase * rowCopy);
    00375      void specialColumnCopy(ClpSimplex * model);
    00377      virtual void correctSequence(const ClpSimplex * model, int & sequenceIn, int & sequenceOut) ;
    00379 private:
    00381      int gutsOfTransposeTimesUnscaled(const double * COIN_RESTRICT pi,
    00382                                       int * COIN_RESTRICT index,
    00383                                       double * COIN_RESTRICT array,
    00384                                       const double tolerance) const;
    00386      int gutsOfTransposeTimesScaled(const double * COIN_RESTRICT pi,
    00387                                     const double * COIN_RESTRICT columnScale,
    00388                                     int * COIN_RESTRICT index,
    00389                                     double * COIN_RESTRICT array,
    00390                                     const double tolerance) const;
    00392      int gutsOfTransposeTimesUnscaled(const double * COIN_RESTRICT pi,
    00393                                       int * COIN_RESTRICT index,
    00394                                       double * COIN_RESTRICT array,
    00395                                       const unsigned char * status,
    00396                                       const double tolerance) const;
    00399      int gutsOfTransposeTimesUnscaled(const double * COIN_RESTRICT pi,
    00400                                       int * COIN_RESTRICT index,
    00401                                       double * COIN_RESTRICT array,
    00402                                       const unsigned char * status,
    00403                                       int * COIN_RESTRICT spareIndex,
    00404                                       double * COIN_RESTRICT spareArray,
    00405                                       const double * COIN_RESTRICT reducedCost,
    00406                                       double & upperTheta,
    00407                                       double & bestPossible,
    00408                                       double acceptablePivot,
    00409                                       double dualTolerance,
    00410                                       int & numberRemaining,
    00411                                       const double zeroTolerance) const;
    00413      int gutsOfTransposeTimesScaled(const double * COIN_RESTRICT pi,
    00414                                     const double * COIN_RESTRICT columnScale,
    00415                                     int * COIN_RESTRICT index,
    00416                                     double * COIN_RESTRICT array,
    00417                                     const unsigned char * status,
    00418                                     const double tolerance) const;
    00420      int gutsOfTransposeTimesByRowGEK(const CoinIndexedVector * COIN_RESTRICT piVector,
    00421                                       int * COIN_RESTRICT index,
    00422                                       double * COIN_RESTRICT output,
    00423                                       int numberColumns,
    00424                                       const double tolerance,
    00425                                       const double scalar) const;
    00427      int gutsOfTransposeTimesByRowGE3(const CoinIndexedVector * COIN_RESTRICT piVector,
    00428                                       int * COIN_RESTRICT index,
    00429                                       double * COIN_RESTRICT output,
    00430                                       double * COIN_RESTRICT array2,
    00431                                       const double tolerance,
    00432                                       const double scalar) const;
    00434      int gutsOfTransposeTimesByRowGE3a(const CoinIndexedVector * COIN_RESTRICT piVector,
    00435                                       int * COIN_RESTRICT index,
    00436                                       double * COIN_RESTRICT output,
    00437                                       int * COIN_RESTRICT lookup,
    00438                                       char * COIN_RESTRICT marked,
    00439                                       const double tolerance,
    00440                                       const double scalar) const;
    00442      void gutsOfTransposeTimesByRowEQ2(const CoinIndexedVector * piVector, CoinIndexedVector * output,
    00443                                        CoinIndexedVector * spareVector, const double tolerance, const double scalar) const;
    00445      void gutsOfTransposeTimesByRowEQ1(const CoinIndexedVector * piVector, CoinIndexedVector * output,
    00446                                        const double tolerance, const double scalar) const;
    00448      void clearCopies();
    00449
    00450
    00451 protected:
    00453      void checkFlags(int type) const;
    00457
    00458      CoinPackedMatrix * matrix_;
    00460      int numberActiveColumns_;
    00468      mutable int flags_;
    00470      ClpPackedMatrix2 * rowCopy_;
    00472      ClpPackedMatrix3 * columnCopy_;
    00474 };
    00475 #ifdef THREAD
    00476 #include <pthread.h>
    00477 typedef struct {
    00478      double acceptablePivot;
    00479      const ClpSimplex * model;
    00480      double * spare;
    00481      int * spareIndex;
    00482      double * arrayTemp;
    00483      int * indexTemp;
    00484      int * numberInPtr;
    00485      double * bestPossiblePtr;
    00486      double * upperThetaPtr;
    00487      int * posFreePtr;
    00488      double * freePivotPtr;
    00489      int * numberOutPtr;
    00490      const unsigned short * count;
    00491      const double * pi;
    00492      const CoinBigIndex * rowStart;
    00493      const double * element;
    00494      const unsigned short * column;
    00495      int offset;
    00496      int numberInRowArray;
    00497      int numberLook;
    00498 } dualColumn0Struct;
    00499 #endif
    00500 class ClpPackedMatrix2 {
    00501
    00502 public:
    00508      void transposeTimes(const ClpSimplex * model,
    00509                          const CoinPackedMatrix * rowCopy,
    00510                          const CoinIndexedVector * x,
    00511                          CoinIndexedVector * spareArray,
    00512                          CoinIndexedVector * z) const;
    00514      inline bool usefulInfo() const {
    00515           return rowStart_ != NULL;
    00516      }
    00518
    00519
    00523      ClpPackedMatrix2();
    00525      ClpPackedMatrix2(ClpSimplex * model, const CoinPackedMatrix * rowCopy);
    00527      virtual ~ClpPackedMatrix2();
    00529
    00533      ClpPackedMatrix2(const ClpPackedMatrix2&);
    00534      ClpPackedMatrix2& operator=(const ClpPackedMatrix2&);
    00536
    00537
    00538 protected:
    00542
    00543      int numberBlocks_;
    00545      int numberRows_;
    00547      int * offset_;
    00549      mutable unsigned short * count_;
    00551      mutable CoinBigIndex * rowStart_;
    00553      unsigned short * column_;
    00555      double * work_;
    00556 #ifdef THREAD
    00557      pthread_t * threadId_;
    00558      dualColumn0Struct * info_;
    00559 #endif
    00560
    00561 };
    00562 typedef struct {
    00563      CoinBigIndex startElements_; // point to data
    00564      int startIndices_; // point to column_
    00565      int numberInBlock_;
    00566      int numberPrice_; // at beginning
    00567      int numberElements_; // number elements per column
    00568 } blockStruct;
    00569 class ClpPackedMatrix3 {
    00570
    00571 public:
    00577      void transposeTimes(const ClpSimplex * model,
    00578                          const double * pi,
    00579                          CoinIndexedVector * output) const;
    00581      void transposeTimes2(const ClpSimplex * model,
    00582                           const double * pi, CoinIndexedVector * dj1,
    00583                           const double * piWeight,
    00584                           double referenceIn, double devex,
    00585                           // Array for exact devex to say what is in reference framework
    00586                           unsigned int * reference,
    00587                           double * weights, double scaleFactor);
    00589
    00590
    00594      ClpPackedMatrix3();
    00596      ClpPackedMatrix3(ClpSimplex * model, const CoinPackedMatrix * columnCopy);
    00598      virtual ~ClpPackedMatrix3();
    00600
    00604      ClpPackedMatrix3(const ClpPackedMatrix3&);
    00605      ClpPackedMatrix3& operator=(const ClpPackedMatrix3&);
    00607
    00610      void sortBlocks(const ClpSimplex * model);
    00612      void swapOne(const ClpSimplex * model, const ClpPackedMatrix * matrix,
    00613                   int iColumn);
    00615
    00616
    00617 protected:
    00621
    00622      int numberBlocks_;
    00624      int numberColumns_;
    00626      int * column_;
    00628      CoinBigIndex * start_;
    00630      int * row_;
    00632      double * element_;
    00634      blockStruct * block_;
    00636 };
    00637
    00638 #endif