00001
00002
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
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
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
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
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