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

- File List
- File Members

# /home/coin/SVN-release/Alps-1.2.1/Clp/src/ClpPackedMatrix.hpp

Go to the documentation of this file.

    00001 /* $Id: ClpPackedMatrix.hpp 1525 2010-02-26 17:27:59Z mjs $ */
    00002 // Copyright (C) 2002, International Business Machines
    00003 // Corporation and others.  All Rights Reserved.
    00004 #ifndef ClpPackedMatrix_H
    00005 #define ClpPackedMatrix_H
    00006
    00007 #include "CoinPragma.hpp"
    00008
    00009 #include "ClpMatrixBase.hpp"
    00010
    00017 class ClpPackedMatrix2;
    00018 class ClpPackedMatrix3;
    00019 class ClpPackedMatrix : public ClpMatrixBase {
    00020
    00021 public:
    00024
    00025      virtual CoinPackedMatrix * getPackedMatrix() const {
    00026           return matrix_;
    00027      }
    00029      virtual bool isColOrdered() const {
    00030           return matrix_->isColOrdered();
    00031      }
    00033      virtual  CoinBigIndex getNumElements() const {
    00034           return matrix_->getNumElements();
    00035      }
    00037      virtual int getNumCols() const {
    00038           return matrix_->getNumCols();
    00039      }
    00041      virtual int getNumRows() const {
    00042           return matrix_->getNumRows();
    00043      }
    00044
    00049      virtual const double * getElements() const {
    00050           return matrix_->getElements();
    00051      }
    00053      inline double * getMutableElements() const {
    00054           return matrix_->getMutableElements();
    00055      }
    00061      virtual const int * getIndices() const {
    00062           return matrix_->getIndices();
    00063      }
    00064
    00065      virtual const CoinBigIndex * getVectorStarts() const {
    00066           return matrix_->getVectorStarts();
    00067      }
    00069      virtual const int * getVectorLengths() const {
    00070           return matrix_->getVectorLengths();
    00071      }
    00073      virtual int getVectorLength(int index) const {
    00074           return matrix_->getVectorSize(index);
    00075      }
    00076
    00078      virtual void deleteCols(const int numDel, const int * indDel);
    00080      virtual void deleteRows(const int numDel, const int * indDel);
    00081 #ifndef CLP_NO_VECTOR
    00083      virtual void appendCols(int number, const CoinPackedVectorBase * const * columns);
    00085      virtual void appendRows(int number, const CoinPackedVectorBase * const * rows);
    00086 #endif
    00087
    00091      virtual int appendMatrix(int number, int type,
    00092                               const CoinBigIndex * starts, const int * index,
    00093                               const double * element, int numberOther = -1);
    00098      virtual void replaceVector(const int index,
    00099                                 const int numReplace, const double * newElements) {
    00100           matrix_->replaceVector(index, numReplace, newElements);
    00101      }
    00105      virtual void modifyCoefficient(int row, int column, double newElement,
    00106                                     bool keepZero = false) {
    00107           matrix_->modifyCoefficient(row, column, newElement, keepZero);
    00108      }
    00110      virtual ClpMatrixBase * reverseOrderedCopy() const;
    00112      virtual CoinBigIndex countBasis(const int * whichColumn,
    00113                                      int & numberColumnBasic);
    00115      virtual void fillBasis(ClpSimplex * model,
    00116                             const int * whichColumn,
    00117                             int & numberColumnBasic,
    00118                             int * row, int * start,
    00119                             int * rowCount, int * columnCount,
    00120                             CoinFactorizationDouble * element);
    00123      virtual int scale(ClpModel * model, const ClpSimplex * baseModel = NULL) const ;
    00126      virtual void scaleRowCopy(ClpModel * model) const ;
    00128      void createScaledMatrix(ClpSimplex * model) const;
    00132      virtual ClpMatrixBase * scaledColumnCopy(ClpModel * model) const ;
    00143      virtual bool allElementsInRange(ClpModel * model,
    00144                                      double smallest, double largest,
    00145                                      int check = 15);
    00149      virtual void rangeOfElements(double & smallestNegative, double & largestNegative,
    00150                                   double & smallestPositive, double & largestPositive);
    00151
    00154      virtual void unpack(const ClpSimplex * model, CoinIndexedVector * rowArray,
    00155                          int column) const ;
    00160      virtual void unpackPacked(ClpSimplex * model,
    00161                                CoinIndexedVector * rowArray,
    00162                                int column) const;
    00165      virtual void add(const ClpSimplex * model, CoinIndexedVector * rowArray,
    00166                       int column, double multiplier) const ;
    00168      virtual void add(const ClpSimplex * model, double * array,
    00169                       int column, double multiplier) const;
    00171      virtual void releasePackedMatrix() const { }
    00176      virtual CoinBigIndex * dubiousWeights(const ClpSimplex * model, int * inputWeights) const;
    00178      virtual bool canDoPartialPricing() const;
    00180      virtual void partialPricing(ClpSimplex * model, double start, double end,
    00181                                  int & bestSequence, int & numberWanted);
    00183      virtual int refresh(ClpSimplex * model);
    00184      // Really scale matrix
    00185      virtual void reallyScale(const double * rowScale, const double * columnScale);
    00191      virtual void setDimensions(int numrows, int numcols);
    00193
    00199      virtual void times(double scalar,
    00200                         const double * x, double * y) const;
    00202      virtual void times(double scalar,
    00203                         const double * x, double * y,
    00204                         const double * rowScale,
    00205                         const double * columnScale) const;
    00209      virtual void transposeTimes(double scalar,
    00210                                  const double * x, double * y) const;
    00212      virtual void transposeTimes(double scalar,
    00213                                  const double * x, double * y,
    00214                                  const double * rowScale,
    00215                                  const double * columnScale,
    00216                                  double * spare = NULL) const;
    00221      void transposeTimesSubset( int number,
    00222                                 const int * which,
    00223                                 const double * pi, double * y,
    00224                                 const double * rowScale,
    00225                                 const double * columnScale,
    00226                                 double * spare = NULL) const;
    00231      virtual void transposeTimes(const ClpSimplex * model, double scalar,
    00232                                  const CoinIndexedVector * x,
    00233                                  CoinIndexedVector * y,
    00234                                  CoinIndexedVector * z) const;
    00239      void transposeTimesByColumn(const ClpSimplex * model, double scalar,
    00240                                  const CoinIndexedVector * x,
    00241                                  CoinIndexedVector * y,
    00242                                  CoinIndexedVector * z) const;
    00248      virtual void transposeTimesByRow(const ClpSimplex * model, double scalar,
    00249                                       const CoinIndexedVector * x,
    00250                                       CoinIndexedVector * y,
    00251                                       CoinIndexedVector * z) const;
    00255      virtual void subsetTransposeTimes(const ClpSimplex * model,
    00256                                        const CoinIndexedVector * x,
    00257                                        const CoinIndexedVector * y,
    00258                                        CoinIndexedVector * z) const;
    00261      virtual bool canCombine(const ClpSimplex * model,
    00262                              const CoinIndexedVector * pi) const;
    00264      virtual void transposeTimes2(const ClpSimplex * model,
    00265                                   const CoinIndexedVector * pi1, CoinIndexedVector * dj1,
    00266                                   const CoinIndexedVector * pi2,
    00267                                   CoinIndexedVector * spare,
    00268                                   double referenceIn, double devex,
    00269                                   // Array for exact devex to say what is in reference framework
    00270                                   unsigned int * reference,
    00271                                   double * weights, double scaleFactor);
    00273      virtual void subsetTimes2(const ClpSimplex * model,
    00274                                CoinIndexedVector * dj1,
    00275                                const CoinIndexedVector * pi2, CoinIndexedVector * dj2,
    00276                                double referenceIn, double devex,
    00277                                // Array for exact devex to say what is in reference framework
    00278                                unsigned int * reference,
    00279                                double * weights, double scaleFactor);
    00281      void useEffectiveRhs(ClpSimplex * model);
    00282 #if COIN_LONG_WORK
    00283      // For long double versions
    00284      virtual void times(CoinWorkDouble scalar,
    00285                         const CoinWorkDouble * x, CoinWorkDouble * y) const ;
    00286      virtual void transposeTimes(CoinWorkDouble scalar,
    00287                                  const CoinWorkDouble * x, CoinWorkDouble * y) const ;
    00288 #endif
    00289
    00290
    00293
    00294      inline CoinPackedMatrix * matrix() const {
    00295           return matrix_;
    00296      }
    00300      inline void setMatrixNull() {
    00301           matrix_ = NULL;
    00302      }
    00304      inline void makeSpecialColumnCopy() {
    00305           flags_ |= 16;
    00306      }
    00308      void releaseSpecialColumnCopy();
    00310      inline bool zeros() const {
    00311           return ((flags_ & 1) != 0);
    00312      }
    00314      inline bool wantsSpecialColumnCopy() const {
    00315           return ((flags_ & 16) != 0);
    00316      }
    00318      inline int flags() const {
    00319           return flags_;
    00320      }
    00322      inline void checkGaps() {
    00323           flags_ = (matrix_->hasGaps()) ? (flags_ | 2) : (flags_ & (~2));
    00324      }
    00326
    00327
    00331      ClpPackedMatrix();
    00333      virtual ~ClpPackedMatrix();
    00335
    00339      ClpPackedMatrix(const ClpPackedMatrix&);
    00341      ClpPackedMatrix(const CoinPackedMatrix&);
    00344      ClpPackedMatrix (const ClpPackedMatrix & wholeModel,
    00345                       int numberRows, const int * whichRows,
    00346                       int numberColumns, const int * whichColumns);
    00347      ClpPackedMatrix (const CoinPackedMatrix & wholeModel,
    00348                       int numberRows, const int * whichRows,
    00349                       int numberColumns, const int * whichColumns);
    00350
    00352      ClpPackedMatrix(CoinPackedMatrix * matrix);
    00353
    00354      ClpPackedMatrix& operator=(const ClpPackedMatrix&);
    00356      virtual ClpMatrixBase * clone() const ;
    00358      virtual void copy(const ClpPackedMatrix * from);
    00361      virtual ClpMatrixBase * subsetClone (
    00362           int numberRows, const int * whichRows,
    00363           int numberColumns, const int * whichColumns) const ;
    00365      void specialRowCopy(ClpSimplex * model, const ClpMatrixBase * rowCopy);
    00367      void specialColumnCopy(ClpSimplex * model);
    00369      virtual void correctSequence(const ClpSimplex * model, int & sequenceIn, int & sequenceOut) ;
    00371 private:
    00373      int gutsOfTransposeTimesUnscaled(const double * COIN_RESTRICT pi,
    00374                                       int * COIN_RESTRICT index,
    00375                                       double * COIN_RESTRICT array,
    00376                                       const double tolerance) const;
    00378      int gutsOfTransposeTimesScaled(const double * COIN_RESTRICT pi,
    00379                                     const double * COIN_RESTRICT columnScale,
    00380                                     int * COIN_RESTRICT index,
    00381                                     double * COIN_RESTRICT array,
    00382                                     const double tolerance) const;
    00384      int gutsOfTransposeTimesUnscaled(const double * COIN_RESTRICT pi,
    00385                                       int * COIN_RESTRICT index,
    00386                                       double * COIN_RESTRICT array,
    00387                                       const unsigned char * status,
    00388                                       const double tolerance) const;
    00391      int gutsOfTransposeTimesUnscaled(const double * COIN_RESTRICT pi,
    00392                                       int * COIN_RESTRICT index,
    00393                                       double * COIN_RESTRICT array,
    00394                                       const unsigned char * status,
    00395                                       int * COIN_RESTRICT spareIndex,
    00396                                       double * COIN_RESTRICT spareArray,
    00397                                       const double * COIN_RESTRICT reducedCost,
    00398                                       double & upperTheta,
    00399                                       double & bestPossible,
    00400                                       double acceptablePivot,
    00401                                       double dualTolerance,
    00402                                       int & numberRemaining,
    00403                                       const double zeroTolerance) const;
    00405      int gutsOfTransposeTimesScaled(const double * COIN_RESTRICT pi,
    00406                                     const double * COIN_RESTRICT columnScale,
    00407                                     int * COIN_RESTRICT index,
    00408                                     double * COIN_RESTRICT array,
    00409                                     const unsigned char * status,
    00410                                     const double tolerance) const;
    00412      int gutsOfTransposeTimesByRowGEK(const CoinIndexedVector * COIN_RESTRICT piVector,
    00413                                       int * COIN_RESTRICT index,
    00414                                       double * COIN_RESTRICT output,
    00415                                       int numberColumns,
    00416                                       const double tolerance,
    00417                                       const double scalar) const;
    00419      int gutsOfTransposeTimesByRowGE3(const CoinIndexedVector * COIN_RESTRICT piVector,
    00420                                       int * COIN_RESTRICT index,
    00421                                       double * COIN_RESTRICT output,
    00422                                       int * COIN_RESTRICT lookup,
    00423                                       char * COIN_RESTRICT marked,
    00424                                       const double tolerance,
    00425                                       const double scalar) const;
    00427      void gutsOfTransposeTimesByRowEQ2(const CoinIndexedVector * piVector, CoinIndexedVector * output,
    00428                                        CoinIndexedVector * spareVector, const double tolerance, const double scalar) const;
    00430      void gutsOfTransposeTimesByRowEQ1(const CoinIndexedVector * piVector, CoinIndexedVector * output,
    00431                                        const double tolerance, const double scalar) const;
    00433      void clearCopies();
    00434
    00435
    00436 protected:
    00438      void checkFlags(int type) const;
    00442
    00443      CoinPackedMatrix * matrix_;
    00445      int numberActiveColumns_;
    00453      int flags_;
    00455      ClpPackedMatrix2 * rowCopy_;
    00457      ClpPackedMatrix3 * columnCopy_;
    00459 };
    00460 #ifdef THREAD
    00461 #include <pthread.h>
    00462 typedef struct {
    00463      double acceptablePivot;
    00464      const ClpSimplex * model;
    00465      double * spare;
    00466      int * spareIndex;
    00467      double * arrayTemp;
    00468      int * indexTemp;
    00469      int * numberInPtr;
    00470      double * bestPossiblePtr;
    00471      double * upperThetaPtr;
    00472      int * posFreePtr;
    00473      double * freePivotPtr;
    00474      int * numberOutPtr;
    00475      const unsigned short * count;
    00476      const double * pi;
    00477      const CoinBigIndex * rowStart;
    00478      const double * element;
    00479      const unsigned short * column;
    00480      int offset;
    00481      int numberInRowArray;
    00482      int numberLook;
    00483 } dualColumn0Struct;
    00484 #endif
    00485 class ClpPackedMatrix2 {
    00486
    00487 public:
    00493      void transposeTimes(const ClpSimplex * model,
    00494                          const CoinPackedMatrix * rowCopy,
    00495                          const CoinIndexedVector * x,
    00496                          CoinIndexedVector * spareArray,
    00497                          CoinIndexedVector * z) const;
    00499      inline bool usefulInfo() const {
    00500           return rowStart_ != NULL;
    00501      }
    00503
    00504
    00508      ClpPackedMatrix2();
    00510      ClpPackedMatrix2(ClpSimplex * model, const CoinPackedMatrix * rowCopy);
    00512      virtual ~ClpPackedMatrix2();
    00514
    00518      ClpPackedMatrix2(const ClpPackedMatrix2&);
    00519      ClpPackedMatrix2& operator=(const ClpPackedMatrix2&);
    00521
    00522
    00523 protected:
    00527
    00528      int numberBlocks_;
    00530      int numberRows_;
    00532      int * offset_;
    00534      mutable unsigned short * count_;
    00536      mutable CoinBigIndex * rowStart_;
    00538      unsigned short * column_;
    00540      double * work_;
    00541 #ifdef THREAD
    00542      pthread_t * threadId_;
    00543      dualColumn0Struct * info_;
    00544 #endif
    00545
    00546 };
    00547 typedef struct {
    00548      CoinBigIndex startElements_; // point to data
    00549      int startIndices_; // point to column_
    00550      int numberInBlock_;
    00551      int numberPrice_; // at beginning
    00552      int numberElements_; // number elements per column
    00553 } blockStruct;
    00554 class ClpPackedMatrix3 {
    00555
    00556 public:
    00562      void transposeTimes(const ClpSimplex * model,
    00563                          const double * pi,
    00564                          CoinIndexedVector * output) const;
    00566      void transposeTimes2(const ClpSimplex * model,
    00567                           const double * pi, CoinIndexedVector * dj1,
    00568                           const double * piWeight,
    00569                           double referenceIn, double devex,
    00570                           // Array for exact devex to say what is in reference framework
    00571                           unsigned int * reference,
    00572                           double * weights, double scaleFactor);
    00574
    00575
    00579      ClpPackedMatrix3();
    00581      ClpPackedMatrix3(ClpSimplex * model, const CoinPackedMatrix * columnCopy);
    00583      virtual ~ClpPackedMatrix3();
    00585
    00589      ClpPackedMatrix3(const ClpPackedMatrix3&);
    00590      ClpPackedMatrix3& operator=(const ClpPackedMatrix3&);
    00592
    00595      void sortBlocks(const ClpSimplex * model);
    00597      void swapOne(const ClpSimplex * model, const ClpPackedMatrix * matrix,
    00598                   int iColumn);
    00600
    00601
    00602 protected:
    00606
    00607      int numberBlocks_;
    00609      int numberColumns_;
    00611      int * column_;
    00613      CoinBigIndex * start_;
    00615      int * row_;
    00617      double * element_;
    00619      blockStruct * block_;
    00621 };
    00622
    00623 #endif