Go to the documentation of this file.00001
00002
00003
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
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
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
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
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