CoinDenseFactorization.hpp

Go to the documentation of this file.
00001 /* $Id: CoinDenseFactorization.hpp 1759 2014-11-18 11:07:23Z forrest $ */
00002 // Copyright (C) 2008, International Business Machines
00003 // Corporation and others.  All Rights Reserved.
00004 // This code is licensed under the terms of the Eclipse Public License (EPL).
00005 
00006 
00007 /* 
00008    Authors
00009    
00010    John Forrest
00011 
00012  */
00013 #ifndef CoinDenseFactorization_H
00014 #define CoinDenseFactorization_H
00015 
00016 #include <iostream>
00017 #include <string>
00018 #include <cassert>
00019 #include "CoinTypes.hpp"
00020 #include "CoinIndexedVector.hpp"
00021 #include "CoinFactorization.hpp"
00022 #if COIN_FACTORIZATION_DENSE_CODE == 2
00023 #undef COIN_FACTORIZATION_DENSE_CODE
00024 #endif
00025 class CoinPackedMatrix;
00027 class CoinOtherFactorization {
00028 
00029 public:
00030 
00033 
00034   CoinOtherFactorization (  );
00036   CoinOtherFactorization ( const CoinOtherFactorization &other);
00037   
00039   virtual ~CoinOtherFactorization (  );
00041   CoinOtherFactorization & operator = ( const CoinOtherFactorization & other );
00042  
00044   virtual CoinOtherFactorization * clone() const = 0;
00046 
00049 
00050   inline int status (  ) const {
00051     return status_;
00052   }
00054   inline void setStatus (  int value)
00055   {  status_=value;  }
00057   inline int pivots (  ) const {
00058     return numberPivots_;
00059   }
00061   inline void setPivots (  int value ) 
00062   { numberPivots_=value; }
00064   inline void setNumberRows(int value)
00065   { numberRows_ = value; }
00067   inline int numberRows (  ) const {
00068     return numberRows_;
00069   }
00071   inline int numberColumns (  ) const {
00072     return numberColumns_;
00073   }
00075   inline int numberGoodColumns (  ) const {
00076     return numberGoodU_;
00077   }
00079   inline void relaxAccuracyCheck(double value)
00080   { relaxCheck_ = value;}
00081   inline double getAccuracyCheck() const
00082   { return relaxCheck_;}
00084   inline int maximumPivots (  ) const {
00085     return maximumPivots_ ;
00086   }
00088   virtual void maximumPivots (  int value );
00089 
00091   inline double pivotTolerance (  ) const {
00092     return pivotTolerance_ ;
00093   }
00094   void pivotTolerance (  double value );
00096   inline double zeroTolerance (  ) const {
00097     return zeroTolerance_ ;
00098   }
00099   void zeroTolerance (  double value );
00100 #ifndef COIN_FAST_CODE
00102   inline double slackValue (  ) const {
00103     return slackValue_ ;
00104   }
00105   void slackValue (  double value );
00106 #endif
00108   virtual CoinFactorizationDouble * elements() const;
00110   virtual int * pivotRow() const;
00112   virtual CoinFactorizationDouble * workArea() const;
00114   virtual int * intWorkArea() const;
00116   virtual int * numberInRow() const;
00118   virtual int * numberInColumn() const;
00120   virtual CoinBigIndex * starts() const;
00122   virtual int * permuteBack() const;
00123 
00127   inline int solveMode() const
00128   { return solveMode_ ;}
00133   inline void setSolveMode(int value)
00134   { solveMode_ = value;}
00136   virtual bool wantsTableauColumn() const;
00141   virtual void setUsefulInformation(const int * info,int whereFrom);
00143   virtual void clearArrays() {}
00145 
00147 
00148   virtual int * indices() const  = 0;
00150   virtual int * permute() const = 0;
00152   virtual int numberElements (  ) const = 0;
00154 
00156 
00157   virtual void getAreas ( int numberRows,
00158                   int numberColumns,
00159                   CoinBigIndex maximumL,
00160                   CoinBigIndex maximumU ) = 0;
00161   
00163   virtual void preProcess ( ) = 0;
00169   virtual int factor ( ) = 0;
00171   virtual void postProcess(const int * sequence, int * pivotVariable) = 0;
00173   virtual void makeNonSingular(int * sequence, int numberColumns) = 0;
00175 
00178 
00186   virtual int replaceColumn ( CoinIndexedVector * regionSparse,
00187                       int pivotRow,
00188                       double pivotCheck ,
00189                               bool checkBeforeModifying=false,
00190                               double acceptablePivot=1.0e-8)=0;
00192 
00202   virtual int updateColumnFT ( CoinIndexedVector * regionSparse,
00203                                CoinIndexedVector * regionSparse2,
00204                                bool noPermute=false) = 0;
00207   virtual int updateColumn ( CoinIndexedVector * regionSparse,
00208                      CoinIndexedVector * regionSparse2,
00209                      bool noPermute=false) const = 0;
00211     virtual int updateTwoColumnsFT(CoinIndexedVector * regionSparse1,
00212                            CoinIndexedVector * regionSparse2,
00213                            CoinIndexedVector * regionSparse3,
00214                            bool noPermute=false) = 0;
00219   virtual int updateColumnTranspose ( CoinIndexedVector * regionSparse,
00220                               CoinIndexedVector * regionSparse2) const = 0;
00222 
00224 protected:
00225 
00228 
00229   double pivotTolerance_;
00231   double zeroTolerance_;
00232 #ifndef COIN_FAST_CODE
00234   double slackValue_;
00235 #else
00236 #ifndef slackValue_
00237 #define slackValue_ -1.0
00238 #endif
00239 #endif
00241   double relaxCheck_;
00243   CoinBigIndex factorElements_;
00245   int numberRows_;
00247   int numberColumns_;
00249   int numberGoodU_;
00251   int maximumPivots_;
00253   int numberPivots_;
00255   int status_;
00257   int maximumRows_;
00259   CoinBigIndex maximumSpace_;
00261   int * pivotRow_;
00262 
00266   CoinFactorizationDouble * elements_;
00268   CoinFactorizationDouble * workArea_;
00273   int solveMode_;
00275 };
00285 class CoinDenseFactorization : public CoinOtherFactorization {
00286    friend void CoinDenseFactorizationUnitTest( const std::string & mpsDir );
00287 
00288 public:
00289 
00292 
00293   CoinDenseFactorization (  );
00295   CoinDenseFactorization ( const CoinDenseFactorization &other);
00296   
00298   virtual ~CoinDenseFactorization (  );
00300   CoinDenseFactorization & operator = ( const CoinDenseFactorization & other );
00302   virtual CoinOtherFactorization * clone() const ;
00304 
00307 
00308   virtual void getAreas ( int numberRows,
00309                   int numberColumns,
00310                   CoinBigIndex maximumL,
00311                   CoinBigIndex maximumU );
00312   
00314   virtual void preProcess ( );
00320   virtual int factor ( );
00322   virtual void postProcess(const int * sequence, int * pivotVariable);
00324   virtual void makeNonSingular(int * sequence, int numberColumns);
00326 
00329 
00330   virtual inline int numberElements (  ) const {
00331     return numberRows_*(numberColumns_+numberPivots_);
00332   }
00334   double maximumCoefficient() const;
00336 
00339 
00347   virtual int replaceColumn ( CoinIndexedVector * regionSparse,
00348                       int pivotRow,
00349                       double pivotCheck ,
00350                               bool checkBeforeModifying=false,
00351                               double acceptablePivot=1.0e-8);
00353 
00363   virtual inline int updateColumnFT ( CoinIndexedVector * regionSparse,
00364                                       CoinIndexedVector * regionSparse2,
00365                                       bool = false)
00366   { return updateColumn(regionSparse,regionSparse2);}
00369   virtual int updateColumn ( CoinIndexedVector * regionSparse,
00370                      CoinIndexedVector * regionSparse2,
00371                      bool noPermute=false) const;
00373     virtual int updateTwoColumnsFT(CoinIndexedVector * regionSparse1,
00374                            CoinIndexedVector * regionSparse2,
00375                            CoinIndexedVector * regionSparse3,
00376                            bool noPermute=false);
00381   virtual int updateColumnTranspose ( CoinIndexedVector * regionSparse,
00382                               CoinIndexedVector * regionSparse2) const;
00384 
00385 
00389 
00390   inline void clearArrays()
00391   { gutsOfDestructor();}
00393   virtual inline int * indices() const
00394   { return reinterpret_cast<int *> (elements_+numberRows_*numberRows_);}
00396   virtual inline int * permute() const
00397   { return NULL;/*pivotRow_*/;}
00399 
00401   void gutsOfDestructor();
00403   void gutsOfInitialize();
00405   void gutsOfCopy(const CoinDenseFactorization &other);
00406 
00408 protected:
00411   int checkPivot(double saveFromU, double oldPivot) const;
00413 protected:
00414 
00417 
00418 };
00419 #endif
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

Generated on 28 Aug 2016 for CoinUtils by  doxygen 1.6.1