/home/coin/SVN-release/Clp-1.9.0/Clp/src/ClpFactorization.hpp

Go to the documentation of this file.
00001 // Copyright (C) 2002, International Business Machines
00002 // Corporation and others.  All Rights Reserved.
00003 #ifndef ClpFactorization_H
00004 #define ClpFactorization_H
00005 
00006 
00007 #include "CoinPragma.hpp"
00008 
00009 #include "CoinFactorization.hpp"
00010 class ClpMatrixBase;
00011 class ClpSimplex;
00012 class ClpNetworkBasis;
00013 #ifndef CLP_MULTIPLE_FACTORIZATIONS 
00014 #define CLP_MULTIPLE_FACTORIZATIONS 3
00015 #endif    
00016 #if CLP_MULTIPLE_FACTORIZATIONS == 1
00017 #include "CoinDenseFactorization.hpp"
00018 typedef CoinDenseFactorization CoinSmallFactorization;
00019 #elif CLP_MULTIPLE_FACTORIZATIONS == 2
00020 #include "CoinSimpFactorization.hpp"
00021 typedef CoinSimpFactorization CoinSmallFactorization;
00022 #elif CLP_MULTIPLE_FACTORIZATIONS == 3
00023 #include "CoinDenseFactorization.hpp"
00024 #include "CoinSimpFactorization.hpp"
00025 #endif
00026 
00031 class ClpFactorization 
00032 #ifndef CLP_MULTIPLE_FACTORIZATIONS    
00033   : public CoinFactorization
00034 #endif
00035 {
00036 
00037   //friend class CoinFactorization;
00038   
00039 public:
00051   int factorize (ClpSimplex * model,int solveType, bool valuesPass);
00053 
00054 
00058    ClpFactorization();
00060    ~ClpFactorization();
00062 
00066    ClpFactorization(const CoinFactorization&);
00068   ClpFactorization(const ClpFactorization&,int denseIfSmaller=0);
00069 #ifdef CLP_MULTIPLE_FACTORIZATIONS    
00070 
00071    ClpFactorization(const CoinSmallFactorization&);
00072 #endif
00073    ClpFactorization& operator=(const ClpFactorization&);
00075    
00076   /*  **** below here is so can use networkish basis */
00079 
00087   int replaceColumn ( const ClpSimplex * model,
00088                       CoinIndexedVector * regionSparse,
00089                       CoinIndexedVector * tableauColumn,
00090                       int pivotRow,
00091                       double pivotCheck ,
00092                       bool checkBeforeModifying=false);
00094 
00102   int updateColumnFT ( CoinIndexedVector * regionSparse,
00103                        CoinIndexedVector * regionSparse2);
00106   int updateColumn ( CoinIndexedVector * regionSparse,
00107                      CoinIndexedVector * regionSparse2,
00108                      bool noPermute=false) const;
00114   int updateTwoColumnsFT ( CoinIndexedVector * regionSparse1,
00115                            CoinIndexedVector * regionSparse2,
00116                            CoinIndexedVector * regionSparse3,
00117                            bool noPermuteRegion3=false) ;
00119   int updateColumnForDebug ( CoinIndexedVector * regionSparse,
00120                      CoinIndexedVector * regionSparse2,
00121                      bool noPermute=false) const;
00124   int updateColumnTranspose ( CoinIndexedVector * regionSparse,
00125                               CoinIndexedVector * regionSparse2) const;
00127 #ifdef CLP_MULTIPLE_FACTORIZATIONS    
00128 
00130 
00131   inline int numberElements (  ) const {
00132     if (coinFactorizationA_) return coinFactorizationA_->numberElements(); else return coinFactorizationB_->numberElements() ;
00133   }
00135   inline int *permute (  ) const {
00136     if (coinFactorizationA_) return coinFactorizationA_->permute(); else return coinFactorizationB_->permute() ;
00137   }
00139   inline int *pivotColumn (  ) const {
00140     if (coinFactorizationA_) return coinFactorizationA_->pivotColumn(); else return coinFactorizationB_->permute() ;
00141   }
00143   inline int maximumPivots (  ) const {
00144     if (coinFactorizationA_) return coinFactorizationA_->maximumPivots();  else return coinFactorizationB_->maximumPivots() ;
00145   }
00147   inline void maximumPivots (  int value) {
00148     if (coinFactorizationA_) coinFactorizationA_->maximumPivots(value); else coinFactorizationB_->maximumPivots(value);
00149   }
00151   inline int pivots (  ) const {
00152     if (coinFactorizationA_) return coinFactorizationA_->pivots(); else return coinFactorizationB_->pivots() ;
00153   }
00155   inline double areaFactor (  ) const {
00156     if (coinFactorizationA_) return coinFactorizationA_->areaFactor(); else return 0.0 ;
00157   }
00159   inline void areaFactor ( double value) {
00160     if (coinFactorizationA_) coinFactorizationA_->areaFactor(value); 
00161   }
00163   inline double zeroTolerance (  ) const {
00164     if (coinFactorizationA_) return coinFactorizationA_->zeroTolerance();  else return coinFactorizationB_->zeroTolerance() ;
00165   }
00167   inline void zeroTolerance (  double value) {
00168     if (coinFactorizationA_) coinFactorizationA_->zeroTolerance(value); else coinFactorizationB_->zeroTolerance(value);
00169   }
00171   inline int sparseThreshold ( ) const
00172   { if (coinFactorizationA_) return coinFactorizationA_->sparseThreshold(); else return 0 ;}
00174   inline void sparseThreshold ( int value) 
00175   { if (coinFactorizationA_) coinFactorizationA_->sparseThreshold(value); }
00177   inline int status (  ) const {
00178     if (coinFactorizationA_) return coinFactorizationA_->status(); else return coinFactorizationB_->status() ;
00179   }
00181   inline void setStatus (  int value) {
00182     if (coinFactorizationA_) coinFactorizationA_->setStatus(value); else coinFactorizationB_->setStatus(value) ;
00183   }
00185   inline int numberDense() const
00186   { if (coinFactorizationA_) return coinFactorizationA_->numberDense(); else return 0 ;}
00187 #if 1
00189   inline CoinBigIndex numberElementsU (  ) const {
00190     if (coinFactorizationA_) return coinFactorizationA_->numberElementsU(); else return -1 ;
00191   }
00193   inline CoinBigIndex numberElementsL (  ) const {
00194     if (coinFactorizationA_) return coinFactorizationA_->numberElementsL(); else return -1 ;
00195   }
00197   inline CoinBigIndex numberElementsR (  ) const {
00198     if (coinFactorizationA_) return coinFactorizationA_->numberElementsR(); else return 0 ;
00199   }
00200 #endif
00201   inline bool timeToRefactorize() const
00202   {
00203     if (coinFactorizationA_) {
00204       return (coinFactorizationA_->pivots()*3>coinFactorizationA_->maximumPivots()*2&&
00205               coinFactorizationA_->numberElementsR()*3>(coinFactorizationA_->numberElementsL()+
00206                                                         coinFactorizationA_->numberElementsU())*2+1000&&
00207               !coinFactorizationA_->numberDense());
00208     } else {
00209       return coinFactorizationB_->pivots()>coinFactorizationB_->numberRows()/2.45+20;
00210     }
00211   }
00213   inline int messageLevel (  ) const {
00214     if (coinFactorizationA_) return coinFactorizationA_->messageLevel();  else return 0 ;
00215   }
00217   inline void messageLevel (  int value) {
00218     if (coinFactorizationA_) coinFactorizationA_->messageLevel(value);
00219   }
00221   inline void clearArrays()
00222   { if (coinFactorizationA_) coinFactorizationA_->clearArrays();}
00224   inline int numberRows (  ) const {
00225     if (coinFactorizationA_) return coinFactorizationA_->numberRows(); else return coinFactorizationB_->numberRows() ;
00226   }
00228   inline int denseThreshold() const 
00229   { if (coinFactorizationA_) return coinFactorizationA_->denseThreshold(); else return 0 ;}
00231   inline void setDenseThreshold(int value)
00232   { if (coinFactorizationA_) coinFactorizationA_->setDenseThreshold(value);}
00234   inline double pivotTolerance (  ) const {
00235     if (coinFactorizationA_) return coinFactorizationA_->pivotTolerance();  else return 1.0e-8 ;
00236   }
00238   inline void pivotTolerance (  double value) {
00239     if (coinFactorizationA_) coinFactorizationA_->pivotTolerance(value);
00240   }
00242   inline void relaxAccuracyCheck(double value)
00243   { if (coinFactorizationA_) coinFactorizationA_->relaxAccuracyCheck(value);}
00249   inline int persistenceFlag() const
00250   { if (coinFactorizationA_) return coinFactorizationA_->persistenceFlag(); else return 0 ;}
00251   inline void setPersistenceFlag(int value)
00252   { if (coinFactorizationA_) coinFactorizationA_->setPersistenceFlag(value);}
00254   inline void almostDestructor()
00255   { if (coinFactorizationA_) coinFactorizationA_->almostDestructor(); }
00257   inline double adjustedAreaFactor() const
00258   { if (coinFactorizationA_) return coinFactorizationA_->adjustedAreaFactor(); else return 0.0 ; }
00259   inline void setBiasLU(int value)
00260   { if (coinFactorizationA_) coinFactorizationA_->setBiasLU(value);}
00262   inline void setForrestTomlin(bool value)
00263   { if (coinFactorizationA_) coinFactorizationA_->setForrestTomlin(value);}
00265   inline void setDefaultValues() {
00266     if (coinFactorizationA_) {
00267       // row activities have negative sign
00268 #ifndef COIN_FAST_CODE
00269       coinFactorizationA_->slackValue(-1.0);
00270 #endif
00271       coinFactorizationA_->zeroTolerance(1.0e-13);
00272     }
00273   }
00275   inline int goDenseThreshold() const
00276   { return goDenseThreshold_;}
00278   inline void setGoDenseThreshold(int value)
00279   { goDenseThreshold_ = value;}
00281   inline int goSmallThreshold() const
00282   { return goSmallThreshold_;}
00284   inline void setGoSmallThreshold(int value)
00285   { goSmallThreshold_ = value;}
00287   void goDenseOrSmall(int numberRows) ;
00289   inline int isDenseOrSmall() const
00290   { return coinFactorizationB_ ? 1 : 0;}
00291 #else
00292   inline bool timeToRefactorize() const
00293   {
00294     return (pivots()*3>maximumPivots()*2&&
00295             numberElementsR()*3>(numberElementsL()+numberElementsU())*2+1000&&
00296             !numberDense());
00297   }
00299   inline void setDefaultValues() {
00300     // row activities have negative sign
00301 #ifndef COIN_FAST_CODE
00302     slackValue(-1.0);
00303 #endif
00304     zeroTolerance(1.0e-13);
00305   }
00307   inline void goDense() {}
00308 #endif
00309 
00310     
00314   void goSparse();
00316   void cleanUp();
00318   bool needToReorder() const;
00319 #ifndef SLIM_CLP
00321   inline bool networkBasis() const
00322   { return (networkBasis_!=NULL);}
00323 #else
00325   inline bool networkBasis() const
00326   { return false;}
00327 #endif
00329   void getWeights(int * weights) const;
00330 
00331 
00333 private:
00334 
00337 
00338 #ifndef SLIM_CLP
00339   ClpNetworkBasis * networkBasis_;
00340 #endif
00341 #ifdef CLP_MULTIPLE_FACTORIZATIONS    
00343   CoinFactorization * coinFactorizationA_;
00345   CoinSmallFactorization * coinFactorizationB_;
00347   int goSmallThreshold_;
00349   int goDenseThreshold_;
00350 #endif
00351 
00352 };
00353 
00354 #endif

Generated on Sat Feb 7 03:01:50 2009 by  doxygen 1.4.7