/build/buildd/clp-1.12.0/Clp/src/ClpFactorization.hpp
Go to the documentation of this file.
00001 /* $Id: ClpFactorization.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 ClpFactorization_H
00005 #define ClpFactorization_H
00006 
00007 
00008 #include "CoinPragma.hpp"
00009 
00010 #include "CoinFactorization.hpp"
00011 class ClpMatrixBase;
00012 class ClpSimplex;
00013 class ClpNetworkBasis;
00014 class CoinOtherFactorization;
00015 #ifndef CLP_MULTIPLE_FACTORIZATIONS
00016 #define CLP_MULTIPLE_FACTORIZATIONS 4
00017 #endif
00018 #ifdef CLP_MULTIPLE_FACTORIZATIONS
00019 #include "CoinDenseFactorization.hpp"
00020 #endif
00021 #ifndef COIN_FAST_CODE
00022 #define COIN_FAST_CODE
00023 #endif
00024 
00029 class ClpFactorization
00030 #ifndef CLP_MULTIPLE_FACTORIZATIONS
00031      : public CoinFactorization
00032 #endif
00033 {
00034 
00035      //friend class CoinFactorization;
00036 
00037 public:
00049      int factorize (ClpSimplex * model, int solveType, bool valuesPass);
00051 
00052 
00056      ClpFactorization();
00058      ~ClpFactorization();
00060 
00064      ClpFactorization(const CoinFactorization&);
00066      ClpFactorization(const ClpFactorization&, int denseIfSmaller = 0);
00067 #ifdef CLP_MULTIPLE_FACTORIZATIONS
00068 
00069      ClpFactorization(const CoinOtherFactorization&);
00070 #endif
00071      ClpFactorization& operator=(const ClpFactorization&);
00073 
00074      /*  **** below here is so can use networkish basis */
00077 
00085      int replaceColumn ( const ClpSimplex * model,
00086                          CoinIndexedVector * regionSparse,
00087                          CoinIndexedVector * tableauColumn,
00088                          int pivotRow,
00089                          double pivotCheck ,
00090                          bool checkBeforeModifying = false,
00091                          double acceptablePivot = 1.0e-8);
00093 
00101      int updateColumnFT ( CoinIndexedVector * regionSparse,
00102                           CoinIndexedVector * regionSparse2);
00105      int updateColumn ( CoinIndexedVector * regionSparse,
00106                         CoinIndexedVector * regionSparse2,
00107                         bool noPermute = false) const;
00113      int updateTwoColumnsFT ( CoinIndexedVector * regionSparse1,
00114                               CoinIndexedVector * regionSparse2,
00115                               CoinIndexedVector * regionSparse3,
00116                               bool noPermuteRegion3 = false) ;
00118      int updateColumnForDebug ( CoinIndexedVector * regionSparse,
00119                                 CoinIndexedVector * regionSparse2,
00120                                 bool noPermute = false) const;
00123      int updateColumnTranspose ( CoinIndexedVector * regionSparse,
00124                                  CoinIndexedVector * regionSparse2) const;
00126 #ifdef CLP_MULTIPLE_FACTORIZATIONS
00127 
00129 
00130      inline int numberElements (  ) const {
00131           if (coinFactorizationA_) return coinFactorizationA_->numberElements();
00132           else return coinFactorizationB_->numberElements() ;
00133      }
00135      inline int *permute (  ) const {
00136           if (coinFactorizationA_) return coinFactorizationA_->permute();
00137           else return coinFactorizationB_->permute() ;
00138      }
00140      inline int *pivotColumn (  ) const {
00141           if (coinFactorizationA_) return coinFactorizationA_->pivotColumn();
00142           else return coinFactorizationB_->permute() ;
00143      }
00145      inline int maximumPivots (  ) const {
00146           if (coinFactorizationA_) return coinFactorizationA_->maximumPivots();
00147           else return coinFactorizationB_->maximumPivots() ;
00148      }
00150      inline void maximumPivots (  int value) {
00151           if (coinFactorizationA_) coinFactorizationA_->maximumPivots(value);
00152           else coinFactorizationB_->maximumPivots(value);
00153      }
00155      inline int pivots (  ) const {
00156           if (coinFactorizationA_) return coinFactorizationA_->pivots();
00157           else return coinFactorizationB_->pivots() ;
00158      }
00160      inline double areaFactor (  ) const {
00161           if (coinFactorizationA_) return coinFactorizationA_->areaFactor();
00162           else return 0.0 ;
00163      }
00165      inline void areaFactor ( double value) {
00166           if (coinFactorizationA_) coinFactorizationA_->areaFactor(value);
00167      }
00169      inline double zeroTolerance (  ) const {
00170           if (coinFactorizationA_) return coinFactorizationA_->zeroTolerance();
00171           else return coinFactorizationB_->zeroTolerance() ;
00172      }
00174      inline void zeroTolerance (  double value) {
00175           if (coinFactorizationA_) coinFactorizationA_->zeroTolerance(value);
00176           else coinFactorizationB_->zeroTolerance(value);
00177      }
00179      void saferTolerances (  double zeroTolerance, double pivotTolerance);
00181      inline int sparseThreshold ( ) const {
00182           if (coinFactorizationA_) return coinFactorizationA_->sparseThreshold();
00183           else return 0 ;
00184      }
00186      inline void sparseThreshold ( int value) {
00187           if (coinFactorizationA_) coinFactorizationA_->sparseThreshold(value);
00188      }
00190      inline int status (  ) const {
00191           if (coinFactorizationA_) return coinFactorizationA_->status();
00192           else return coinFactorizationB_->status() ;
00193      }
00195      inline void setStatus (  int value) {
00196           if (coinFactorizationA_) coinFactorizationA_->setStatus(value);
00197           else coinFactorizationB_->setStatus(value) ;
00198      }
00200      inline int numberDense() const {
00201           if (coinFactorizationA_) return coinFactorizationA_->numberDense();
00202           else return 0 ;
00203      }
00204 #if 1
00205 
00206      inline CoinBigIndex numberElementsU (  ) const {
00207           if (coinFactorizationA_) return coinFactorizationA_->numberElementsU();
00208           else return -1 ;
00209      }
00211      inline CoinBigIndex numberElementsL (  ) const {
00212           if (coinFactorizationA_) return coinFactorizationA_->numberElementsL();
00213           else return -1 ;
00214      }
00216      inline CoinBigIndex numberElementsR (  ) const {
00217           if (coinFactorizationA_) return coinFactorizationA_->numberElementsR();
00218           else return 0 ;
00219      }
00220 #endif
00221      inline bool timeToRefactorize() const {
00222           if (coinFactorizationA_) {
00223                return (coinFactorizationA_->pivots() * 3 > coinFactorizationA_->maximumPivots() * 2 &&
00224                        coinFactorizationA_->numberElementsR() * 3 > (coinFactorizationA_->numberElementsL() +
00225                                  coinFactorizationA_->numberElementsU()) * 2 + 1000 &&
00226                        !coinFactorizationA_->numberDense());
00227           } else {
00228                return coinFactorizationB_->pivots() > coinFactorizationB_->numberRows() / 2.45 + 20;
00229           }
00230      }
00232      inline int messageLevel (  ) const {
00233           if (coinFactorizationA_) return coinFactorizationA_->messageLevel();
00234           else return 1 ;
00235      }
00237      inline void messageLevel (  int value) {
00238           if (coinFactorizationA_) coinFactorizationA_->messageLevel(value);
00239      }
00241      inline void clearArrays() {
00242           if (coinFactorizationA_)
00243                coinFactorizationA_->clearArrays();
00244           else if (coinFactorizationB_)
00245                coinFactorizationB_->clearArrays();
00246      }
00248      inline int numberRows (  ) const {
00249           if (coinFactorizationA_) return coinFactorizationA_->numberRows();
00250           else return coinFactorizationB_->numberRows() ;
00251      }
00253      inline int denseThreshold() const {
00254           if (coinFactorizationA_) return coinFactorizationA_->denseThreshold();
00255           else return 0 ;
00256      }
00258      inline void setDenseThreshold(int value) {
00259           if (coinFactorizationA_) coinFactorizationA_->setDenseThreshold(value);
00260      }
00262      inline double pivotTolerance (  ) const {
00263           if (coinFactorizationA_) return coinFactorizationA_->pivotTolerance();
00264           else if (coinFactorizationB_) return coinFactorizationB_->pivotTolerance();
00265           return 1.0e-8 ;
00266      }
00268      inline void pivotTolerance (  double value) {
00269           if (coinFactorizationA_) coinFactorizationA_->pivotTolerance(value);
00270           else if (coinFactorizationB_) coinFactorizationB_->pivotTolerance(value);
00271      }
00273      inline void relaxAccuracyCheck(double value) {
00274           if (coinFactorizationA_) coinFactorizationA_->relaxAccuracyCheck(value);
00275      }
00281      inline int persistenceFlag() const {
00282           if (coinFactorizationA_) return coinFactorizationA_->persistenceFlag();
00283           else return 0 ;
00284      }
00285      inline void setPersistenceFlag(int value) {
00286           if (coinFactorizationA_) coinFactorizationA_->setPersistenceFlag(value);
00287      }
00289      inline void almostDestructor() {
00290           if (coinFactorizationA_)
00291                coinFactorizationA_->almostDestructor();
00292           else if (coinFactorizationB_)
00293                coinFactorizationB_->clearArrays();
00294      }
00296      inline double adjustedAreaFactor() const {
00297           if (coinFactorizationA_) return coinFactorizationA_->adjustedAreaFactor();
00298           else return 0.0 ;
00299      }
00300      inline void setBiasLU(int value) {
00301           if (coinFactorizationA_) coinFactorizationA_->setBiasLU(value);
00302      }
00304      inline void setForrestTomlin(bool value) {
00305           if (coinFactorizationA_) coinFactorizationA_->setForrestTomlin(value);
00306      }
00308      inline void setDefaultValues() {
00309           if (coinFactorizationA_) {
00310                // row activities have negative sign
00311 #ifndef COIN_FAST_CODE
00312                coinFactorizationA_->slackValue(-1.0);
00313 #endif
00314                coinFactorizationA_->zeroTolerance(1.0e-13);
00315           }
00316      }
00318      void forceOtherFactorization(int which);
00320      inline int goOslThreshold() const {
00321           return goOslThreshold_;
00322      }
00324      inline void setGoOslThreshold(int value) {
00325           goOslThreshold_ = value;
00326      }
00328      inline int goDenseThreshold() const {
00329           return goDenseThreshold_;
00330      }
00332      inline void setGoDenseThreshold(int value) {
00333           goDenseThreshold_ = value;
00334      }
00336      inline int goSmallThreshold() const {
00337           return goSmallThreshold_;
00338      }
00340      inline void setGoSmallThreshold(int value) {
00341           goSmallThreshold_ = value;
00342      }
00344      void goDenseOrSmall(int numberRows) ;
00346      void setFactorization(ClpFactorization & factorization);
00348      inline int isDenseOrSmall() const {
00349           return coinFactorizationB_ ? 1 : 0;
00350      }
00351 #else
00352      inline bool timeToRefactorize() const {
00353           return (pivots() * 3 > maximumPivots() * 2 &&
00354                   numberElementsR() * 3 > (numberElementsL() + numberElementsU()) * 2 + 1000 &&
00355                   !numberDense());
00356      }
00358      inline void setDefaultValues() {
00359           // row activities have negative sign
00360 #ifndef COIN_FAST_CODE
00361           slackValue(-1.0);
00362 #endif
00363           zeroTolerance(1.0e-13);
00364      }
00366      inline void goDense() {}
00367 #endif
00368 
00369 
00373      void goSparse();
00375      void cleanUp();
00377      bool needToReorder() const;
00378 #ifndef SLIM_CLP
00379 
00380      inline bool networkBasis() const {
00381           return (networkBasis_ != NULL);
00382      }
00383 #else
00384 
00385      inline bool networkBasis() const {
00386           return false;
00387      }
00388 #endif
00389 
00390      void getWeights(int * weights) const;
00392 
00394 private:
00395 
00398 
00399 #ifndef SLIM_CLP
00400      ClpNetworkBasis * networkBasis_;
00401 #endif
00402 #ifdef CLP_MULTIPLE_FACTORIZATIONS
00403 
00404      CoinFactorization * coinFactorizationA_;
00406      CoinOtherFactorization * coinFactorizationB_;
00408      int forceB_;
00410      int goOslThreshold_;
00412      int goSmallThreshold_;
00414      int goDenseThreshold_;
00415 #endif
00416 
00417 };
00418 
00419 #endif