00001
00002
00003
00004
00005
00006
00007
00008
00009
00010 #ifndef CoinDenseFactorization_H
00011 #define CoinDenseFactorization_H
00012
00013 #include <iostream>
00014 #include <string>
00015 #include <cassert>
00016 #include "CoinFinite.hpp"
00017 #include "CoinIndexedVector.hpp"
00018 #include "CoinFactorization.hpp"
00019 class CoinPackedMatrix;
00021 class CoinSmallFactorization {
00022
00023 public:
00024
00027
00028 CoinSmallFactorization ( );
00030 CoinSmallFactorization ( const CoinSmallFactorization &other);
00031
00033 virtual ~CoinSmallFactorization ( );
00035 CoinSmallFactorization & operator = ( const CoinSmallFactorization & other );
00036
00038 virtual CoinSmallFactorization * clone() const = 0;
00040
00043
00044 inline int status ( ) const {
00045 return status_;
00046 }
00048 inline void setStatus ( int value)
00049 { status_=value; }
00051 inline int pivots ( ) const {
00052 return numberPivots_;
00053 }
00055 inline void setPivots ( int value )
00056 { numberPivots_=value; }
00058 inline void setNumberRows(int value)
00059 { numberRows_ = value; }
00061 inline int numberRows ( ) const {
00062 return numberRows_;
00063 }
00065 inline int numberColumns ( ) const {
00066 return numberColumns_;
00067 }
00069 inline int numberGoodColumns ( ) const {
00070 return numberGoodU_;
00071 }
00073 inline void relaxAccuracyCheck(double value)
00074 { relaxCheck_ = value;}
00075 inline double getAccuracyCheck() const
00076 { return relaxCheck_;}
00078 inline int maximumPivots ( ) const {
00079 return maximumPivots_ ;
00080 }
00082 void maximumPivots ( int value );
00083
00085 inline double pivotTolerance ( ) const {
00086 return pivotTolerance_ ;
00087 }
00088 void pivotTolerance ( double value );
00090 inline double zeroTolerance ( ) const {
00091 return zeroTolerance_ ;
00092 }
00093 void zeroTolerance ( double value );
00094 #ifndef COIN_FAST_CODE
00096 inline double slackValue ( ) const {
00097 return slackValue_ ;
00098 }
00099 void slackValue ( double value );
00100 #endif
00102 inline CoinFactorizationDouble * elements() const
00103 { return elements_;}
00105 inline int * pivotRow() const
00106 { return pivotRow_;}
00108 inline CoinFactorizationDouble * workArea() const
00109 { return workArea_;}
00111 inline int * intWorkArea() const
00112 { return reinterpret_cast<int *> (workArea_);}
00114 inline CoinBigIndex * starts() const
00115 { return reinterpret_cast<CoinBigIndex *> (pivotRow_);}
00117 inline int * permuteBack() const
00118 { return pivotRow_+numberRows_;}
00120 inline int solveMode() const
00121 { return solveMode_ ;}
00123 inline void setSolveMode(int value)
00124 { solveMode_ = value;}
00126
00128
00129 virtual int * indices() const = 0;
00131 virtual int * permute() const = 0;
00133 virtual int numberElements ( ) const = 0;
00135
00137
00138 virtual void getAreas ( int numberRows,
00139 int numberColumns,
00140 CoinBigIndex maximumL,
00141 CoinBigIndex maximumU ) = 0;
00142
00144 virtual void preProcess ( ) = 0;
00150 virtual int factor ( ) = 0;
00152 virtual void postProcess(const int * sequence, int * pivotVariable) = 0;
00154 virtual void makeNonSingular(int * sequence, int numberColumns) = 0;
00156
00159
00167 virtual int replaceColumn ( CoinIndexedVector * regionSparse,
00168 int pivotRow,
00169 double pivotCheck ,
00170 bool checkBeforeModifying=false) = 0;
00172
00182 virtual int updateColumnFT ( CoinIndexedVector * regionSparse,
00183 CoinIndexedVector * regionSparse2,
00184 bool noPermute=false) = 0;
00187 virtual int updateColumn ( CoinIndexedVector * regionSparse,
00188 CoinIndexedVector * regionSparse2,
00189 bool noPermute=false) const = 0;
00191 virtual int updateTwoColumnsFT(CoinIndexedVector * regionSparse1,
00192 CoinIndexedVector * regionSparse2,
00193 CoinIndexedVector * regionSparse3,
00194 bool noPermute=false) = 0;
00199 virtual int updateColumnTranspose ( CoinIndexedVector * regionSparse,
00200 CoinIndexedVector * regionSparse2) const = 0;
00202
00204 protected:
00205
00208
00209 double pivotTolerance_;
00211 double zeroTolerance_;
00212 #ifndef COIN_FAST_CODE
00214 double slackValue_;
00215 #else
00216 #ifndef slackValue_
00217 #define slackValue_ -1.0
00218 #endif
00219 #endif
00221 double relaxCheck_;
00223 CoinBigIndex factorElements_;
00225 int numberRows_;
00227 int numberColumns_;
00229 int numberGoodU_;
00231 int maximumPivots_;
00233 int numberPivots_;
00235 int status_;
00237 int maximumRows_;
00239 CoinBigIndex maximumSpace_;
00241 int * pivotRow_;
00242
00246 CoinFactorizationDouble * elements_;
00248 CoinFactorizationDouble * workArea_;
00250 int solveMode_;
00252 };
00262 class CoinDenseFactorization : public CoinSmallFactorization {
00263 friend void CoinDenseFactorizationUnitTest( const std::string & mpsDir );
00264
00265 public:
00266
00269
00270 CoinDenseFactorization ( );
00272 CoinDenseFactorization ( const CoinDenseFactorization &other);
00273
00275 virtual ~CoinDenseFactorization ( );
00277 CoinDenseFactorization & operator = ( const CoinDenseFactorization & other );
00279 virtual CoinSmallFactorization * clone() const ;
00281
00284
00285 virtual void getAreas ( int numberRows,
00286 int numberColumns,
00287 CoinBigIndex maximumL,
00288 CoinBigIndex maximumU );
00289
00291 virtual void preProcess ( );
00297 virtual int factor ( );
00299 virtual void postProcess(const int * sequence, int * pivotVariable);
00301 virtual void makeNonSingular(int * sequence, int numberColumns);
00303
00306
00307 virtual inline int numberElements ( ) const {
00308 return numberRows_*(numberColumns_+numberPivots_);
00309 }
00311 double maximumCoefficient() const;
00313
00316
00324 virtual int replaceColumn ( CoinIndexedVector * regionSparse,
00325 int pivotRow,
00326 double pivotCheck ,
00327 bool checkBeforeModifying=false);
00329
00339 virtual inline int updateColumnFT ( CoinIndexedVector * regionSparse,
00340 CoinIndexedVector * regionSparse2,
00341 bool noPermute=false)
00342 { return updateColumn(regionSparse,regionSparse2);}
00345 virtual int updateColumn ( CoinIndexedVector * regionSparse,
00346 CoinIndexedVector * regionSparse2,
00347 bool noPermute=false) const;
00349 virtual int updateTwoColumnsFT(CoinIndexedVector * regionSparse1,
00350 CoinIndexedVector * regionSparse2,
00351 CoinIndexedVector * regionSparse3,
00352 bool noPermute=false);
00357 virtual int updateColumnTranspose ( CoinIndexedVector * regionSparse,
00358 CoinIndexedVector * regionSparse2) const;
00360
00361
00365
00366 inline void clearArrays()
00367 { gutsOfDestructor();}
00369 virtual inline int * indices() const
00370 { return reinterpret_cast<int *> (elements_+numberRows_*numberRows_);}
00372 virtual inline int * permute() const
00373 { return NULL;;}
00375
00377 void gutsOfDestructor();
00379 void gutsOfInitialize();
00381 void gutsOfCopy(const CoinDenseFactorization &other);
00382
00384 protected:
00387 int checkPivot(double saveFromU, double oldPivot) const;
00389 protected:
00390
00393
00394 };
00395 #endif