• Main Page
  • Classes
  • Files
  • File List
  • File Members

/build/buildd/clp-1.11.1/Clp/src/ClpPackedMatrix.hpp

Go to the documentation of this file.
00001 /* $Id: ClpPackedMatrix.hpp 1458 2009-11-05 12:34:07Z forrest $ */
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 { return matrix_;}
00027   virtual bool isColOrdered() const { return matrix_->isColOrdered(); }
00029   virtual  CoinBigIndex getNumElements() const 
00030   { return matrix_->getNumElements(); }
00032   virtual int getNumCols() const { return matrix_->getNumCols(); }
00034   virtual int getNumRows() const { return matrix_->getNumRows(); }
00035   
00040   virtual const double * getElements() const 
00041   { return matrix_->getElements();}
00043   inline double * getMutableElements() const
00044   { return matrix_->getMutableElements();}
00050    virtual const int * getIndices() const 
00051   { return matrix_->getIndices();}
00052 
00053    virtual const CoinBigIndex * getVectorStarts() const 
00054   { return matrix_->getVectorStarts();}
00056    virtual const int * getVectorLengths() const 
00057   { return matrix_->getVectorLengths();} 
00059   virtual int getVectorLength(int index) const 
00060   { return matrix_->getVectorSize(index);}
00061 
00063   virtual void deleteCols(const int numDel, const int * indDel);
00065   virtual void deleteRows(const int numDel, const int * indDel);
00066 #ifndef CLP_NO_VECTOR
00067 
00068   virtual void appendCols(int number, const CoinPackedVectorBase * const * columns);
00070   virtual void appendRows(int number, const CoinPackedVectorBase * const * rows);
00071 #endif
00072 
00076   virtual int appendMatrix(int number, int type,
00077                            const CoinBigIndex * starts, const int * index,
00078                            const double * element, int numberOther=-1);
00083   virtual void replaceVector(const int index,
00084                        const int numReplace, const double * newElements)
00085       {matrix_->replaceVector(index,numReplace,newElements);}
00089   virtual void modifyCoefficient(int row, int column, double newElement,
00090                            bool keepZero=false)
00091        {matrix_->modifyCoefficient(row, column, newElement, keepZero);}
00093   virtual ClpMatrixBase * reverseOrderedCopy() const;
00095   virtual CoinBigIndex countBasis(const int * whichColumn, 
00096                                   int & numberColumnBasic);
00098   virtual void fillBasis(ClpSimplex * model,
00099                                  const int * whichColumn, 
00100                                  int & numberColumnBasic,
00101                                  int * row, int * start,
00102                                  int * rowCount, int * columnCount,
00103                                  CoinFactorizationDouble * element);
00106   virtual int scale(ClpModel * model,const ClpSimplex * baseModel=NULL) const ;
00109   virtual void scaleRowCopy(ClpModel * model) const ;
00111   void createScaledMatrix(ClpSimplex * model) const;
00115   virtual ClpMatrixBase * scaledColumnCopy(ClpModel * model) const ;
00126   virtual bool allElementsInRange(ClpModel * model,
00127                                   double smallest, double largest,
00128                                   int check=15);
00132   virtual void rangeOfElements(double & smallestNegative, double & largestNegative,
00133                        double & smallestPositive, double & largestPositive);
00134 
00137   virtual void unpack(const ClpSimplex * model,CoinIndexedVector * rowArray,
00138                    int column) const ;
00143   virtual void unpackPacked(ClpSimplex * model,
00144                             CoinIndexedVector * rowArray,
00145                             int column) const;
00148   virtual void add(const ClpSimplex * model,CoinIndexedVector * rowArray,
00149                    int column, double multiplier) const ;
00151   virtual void add(const ClpSimplex * model,double * array,
00152                    int column, double multiplier) const;
00154    virtual void releasePackedMatrix() const { }
00159   virtual CoinBigIndex * dubiousWeights(const ClpSimplex * model,int * inputWeights) const;
00161   virtual bool canDoPartialPricing() const;
00163   virtual void partialPricing(ClpSimplex * model, double start, double end,
00164                       int & bestSequence, int & numberWanted);
00166   virtual int refresh(ClpSimplex * model);
00167   // Really scale matrix
00168   virtual void reallyScale(const double * rowScale, const double * columnScale);
00174   virtual void setDimensions(int numrows, int numcols);
00176 
00182   virtual void times(double scalar,
00183                        const double * x, double * y) const;
00185   virtual void times(double scalar,
00186                      const double * x, double * y,
00187                      const double * rowScale, 
00188                      const double * columnScale) const;
00192     virtual void transposeTimes(double scalar,
00193                                 const double * x, double * y) const;
00195     virtual void transposeTimes(double scalar,
00196                                 const double * x, double * y,
00197                                 const double * rowScale, 
00198                                 const double * columnScale,
00199                                 double * spare=NULL) const;
00204   void transposeTimesSubset( int number,
00205                              const int * which,
00206                              const double * pi, double * y,
00207                              const double * rowScale, 
00208                              const double * columnScale,
00209                              double * spare=NULL) const;
00214   virtual void transposeTimes(const ClpSimplex * model, double scalar,
00215                               const CoinIndexedVector * x,
00216                               CoinIndexedVector * y,
00217                               CoinIndexedVector * z) const;
00222   void transposeTimesByColumn(const ClpSimplex * model, double scalar,
00223                               const CoinIndexedVector * x,
00224                               CoinIndexedVector * y,
00225                               CoinIndexedVector * z) const;
00231   virtual void transposeTimesByRow(const ClpSimplex * model, double scalar,
00232                               const CoinIndexedVector * x,
00233                               CoinIndexedVector * y,
00234                               CoinIndexedVector * z) const;
00238   virtual void subsetTransposeTimes(const ClpSimplex * model,
00239                                     const CoinIndexedVector * x,
00240                                     const CoinIndexedVector * y,
00241                                     CoinIndexedVector * z) const;
00244   virtual bool canCombine(const ClpSimplex * model,
00245                           const CoinIndexedVector * pi) const;
00247   virtual void transposeTimes2(const ClpSimplex * model,
00248                                const CoinIndexedVector * pi1, CoinIndexedVector * dj1,
00249                                const CoinIndexedVector * pi2, 
00250                                CoinIndexedVector * spare,
00251                                double referenceIn, double devex,
00252                                // Array for exact devex to say what is in reference framework
00253                                unsigned int * reference,
00254                                double * weights, double scaleFactor);
00256   virtual void subsetTimes2(const ClpSimplex * model,
00257                                 CoinIndexedVector * dj1,
00258                                const CoinIndexedVector * pi2, CoinIndexedVector * dj2, 
00259                                double referenceIn, double devex,
00260                                // Array for exact devex to say what is in reference framework
00261                                unsigned int * reference,
00262                                double * weights, double scaleFactor);
00264   void useEffectiveRhs(ClpSimplex * model);
00265 #if COIN_LONG_WORK 
00266   // For long double versions 
00267   virtual void times(CoinWorkDouble scalar,
00268                      const CoinWorkDouble * x, CoinWorkDouble * y) const ;
00269   virtual void transposeTimes(CoinWorkDouble scalar,
00270                               const CoinWorkDouble * x, CoinWorkDouble * y) const ;
00271 #endif
00272 
00273 
00276 
00277   inline CoinPackedMatrix * matrix() const { return matrix_;}
00281   inline void setMatrixNull()
00282   { matrix_=NULL;}
00284   inline void makeSpecialColumnCopy()
00285   { flags_ |= 16;}
00287   void releaseSpecialColumnCopy();
00289   inline bool zeros() const
00290   { return ((flags_&1)!=0);}
00292   inline bool wantsSpecialColumnCopy() const
00293   { return ((flags_&16)!=0);}
00295   inline int flags() const
00296   { return flags_;}
00298   inline void checkGaps()
00299   { flags_ = (matrix_->hasGaps()) ? (flags_|2) : (flags_&(~2));} 
00301 
00302 
00306    ClpPackedMatrix();
00308    virtual ~ClpPackedMatrix();
00310 
00314    ClpPackedMatrix(const ClpPackedMatrix&);
00316    ClpPackedMatrix(const CoinPackedMatrix&);
00319   ClpPackedMatrix (const ClpPackedMatrix & wholeModel,
00320                     int numberRows, const int * whichRows,
00321                     int numberColumns, const int * whichColumns);
00322   ClpPackedMatrix (const CoinPackedMatrix & wholeModel,
00323                     int numberRows, const int * whichRows,
00324                     int numberColumns, const int * whichColumns);
00325 
00327    ClpPackedMatrix(CoinPackedMatrix * matrix);
00328 
00329    ClpPackedMatrix& operator=(const ClpPackedMatrix&);
00331   virtual ClpMatrixBase * clone() const ;
00333   virtual void copy(const ClpPackedMatrix * from);
00336   virtual ClpMatrixBase * subsetClone (
00337                     int numberRows, const int * whichRows,
00338                     int numberColumns, const int * whichColumns) const ;
00340   void specialRowCopy(ClpSimplex * model,const ClpMatrixBase * rowCopy); 
00342   void specialColumnCopy(ClpSimplex * model); 
00344   virtual void correctSequence(const ClpSimplex * model,int & sequenceIn, int & sequenceOut) ;
00346 private:
00348   int gutsOfTransposeTimesUnscaled(const double * COIN_RESTRICT pi,
00349                                     int * COIN_RESTRICT index, 
00350                                     double * COIN_RESTRICT array,
00351                                     const double tolerance) const;
00353   int gutsOfTransposeTimesScaled(const double * COIN_RESTRICT pi,
00354                                  const double * COIN_RESTRICT columnScale,
00355                                  int * COIN_RESTRICT index, 
00356                                  double * COIN_RESTRICT array,
00357                                  const double tolerance) const;
00359   int gutsOfTransposeTimesUnscaled(const double * COIN_RESTRICT pi,
00360                                     int * COIN_RESTRICT index, 
00361                                     double * COIN_RESTRICT array,
00362                                    const unsigned char * status,
00363                                     const double tolerance) const;
00366   int gutsOfTransposeTimesUnscaled(const double * COIN_RESTRICT pi,
00367                                     int * COIN_RESTRICT index, 
00368                                     double * COIN_RESTRICT array,
00369                                    const unsigned char * status,
00370                                     int * COIN_RESTRICT spareIndex, 
00371                                     double * COIN_RESTRICT spareArray,
00372                                     const double * COIN_RESTRICT reducedCost,
00373                                    double & upperTheta,
00374                                    double & bestPossible,
00375                                    double acceptablePivot,
00376                                    double dualTolerance,
00377                                    int & numberRemaining,
00378                                     const double zeroTolerance) const;
00380   int gutsOfTransposeTimesScaled(const double * COIN_RESTRICT pi,
00381                                  const double * COIN_RESTRICT columnScale,
00382                                  int * COIN_RESTRICT index, 
00383                                  double * COIN_RESTRICT array,
00384                                    const unsigned char * status,
00385                                  const double tolerance) const;
00387   int gutsOfTransposeTimesByRowGEK(const CoinIndexedVector * COIN_RESTRICT piVector, 
00388                                    int * COIN_RESTRICT index, 
00389                                    double * COIN_RESTRICT output,
00390                                    int numberColumns,
00391                                    const double tolerance, 
00392                                    const double scalar) const;
00394   int gutsOfTransposeTimesByRowGE3(const CoinIndexedVector * COIN_RESTRICT piVector, 
00395                                    int * COIN_RESTRICT index, 
00396                                    double * COIN_RESTRICT output,
00397                                    int * COIN_RESTRICT lookup,
00398                                    char * COIN_RESTRICT marked,
00399                                    const double tolerance, 
00400                                    const double scalar) const;
00402   void gutsOfTransposeTimesByRowEQ2(const CoinIndexedVector * piVector, CoinIndexedVector * output,
00403                                    CoinIndexedVector * spareVector, const double tolerance, const double scalar) const;
00405   void gutsOfTransposeTimesByRowEQ1(const CoinIndexedVector * piVector, CoinIndexedVector * output,
00406                                    const double tolerance, const double scalar) const;
00408   void clearCopies();
00409    
00410     
00411 protected:
00413   void checkFlags(int type) const;
00417 
00418   CoinPackedMatrix * matrix_;
00420   int numberActiveColumns_;
00428   int flags_;
00430   ClpPackedMatrix2 * rowCopy_;
00432   ClpPackedMatrix3 * columnCopy_;
00434 };
00435 #ifdef THREAD
00436 #include <pthread.h>
00437 typedef struct {
00438   double acceptablePivot;
00439   const ClpSimplex * model;
00440   double * spare;
00441   int * spareIndex;
00442   double * arrayTemp;
00443   int * indexTemp;
00444   int * numberInPtr;
00445   double * bestPossiblePtr;
00446   double * upperThetaPtr;
00447   int * posFreePtr;
00448   double * freePivotPtr;
00449   int * numberOutPtr;
00450   const unsigned short * count;
00451   const double * pi;
00452   const CoinBigIndex * rowStart;
00453   const double * element;
00454   const unsigned short * column;
00455   int offset;
00456   int numberInRowArray;
00457   int numberLook;
00458 } dualColumn0Struct;
00459 #endif
00460 class ClpPackedMatrix2 {
00461   
00462 public:
00468   void transposeTimes(const ClpSimplex * model,
00469                       const CoinPackedMatrix * rowCopy,
00470                       const CoinIndexedVector * x,
00471                       CoinIndexedVector * spareArray,
00472                       CoinIndexedVector * z) const;
00474   inline bool usefulInfo() const
00475   { return rowStart_!=NULL;}
00477 
00478 
00482    ClpPackedMatrix2();
00484    ClpPackedMatrix2(ClpSimplex * model,const CoinPackedMatrix * rowCopy);
00486    virtual ~ClpPackedMatrix2();
00488 
00492    ClpPackedMatrix2(const ClpPackedMatrix2&);
00493    ClpPackedMatrix2& operator=(const ClpPackedMatrix2&);
00495    
00496     
00497 protected:
00501 
00502   int numberBlocks_;
00504   int numberRows_;
00506   int * offset_;
00508   mutable unsigned short * count_;
00510   mutable CoinBigIndex * rowStart_;
00512   unsigned short * column_;
00514   double * work_;
00515 #ifdef THREAD
00516   pthread_t * threadId_;
00517   dualColumn0Struct * info_;
00518 #endif
00519 
00520 };
00521 typedef struct {
00522   CoinBigIndex startElements_; // point to data
00523   int startIndices_; // point to column_
00524   int numberInBlock_; 
00525   int numberPrice_; // at beginning
00526   int numberElements_; // number elements per column
00527 } blockStruct;
00528 class ClpPackedMatrix3 {
00529   
00530 public:
00536   void transposeTimes(const ClpSimplex * model,
00537                       const double * pi,
00538                       CoinIndexedVector * output) const;
00540   void transposeTimes2(const ClpSimplex * model,
00541                        const double * pi, CoinIndexedVector * dj1,
00542                        const double * piWeight,
00543                        double referenceIn, double devex,
00544                        // Array for exact devex to say what is in reference framework
00545                        unsigned int * reference,
00546                        double * weights, double scaleFactor);
00548 
00549 
00553    ClpPackedMatrix3();
00555    ClpPackedMatrix3(ClpSimplex * model,const CoinPackedMatrix * columnCopy);
00557    virtual ~ClpPackedMatrix3();
00559 
00563    ClpPackedMatrix3(const ClpPackedMatrix3&);
00564    ClpPackedMatrix3& operator=(const ClpPackedMatrix3&);
00566 
00569   void sortBlocks(const ClpSimplex * model);
00571   void swapOne(const ClpSimplex * model,const ClpPackedMatrix * matrix,
00572                 int iColumn);
00574    
00575     
00576 protected:
00580 
00581   int numberBlocks_;
00583   int numberColumns_;
00585   int * column_;
00587   CoinBigIndex * start_;
00589   int * row_;
00591   double * element_;
00593   blockStruct * block_;
00595 };
00596 
00597 #endif

Generated on Fri Aug 20 2010 06:29:28 by  doxygen 1.7.1