/home/coin/SVN-release/CoinAll-1.1.0/Clp/src/ClpFactorization.hpp

Go to the documentation of this file.

// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef ClpFactorization_H
#define ClpFactorization_H


#include "CoinPragma.hpp"

#include "CoinFactorization.hpp"
class ClpMatrixBase;
class ClpSimplex;
class ClpNetworkBasis;
//#define CLP_MULTIPLE_FACTORIZATIONS    
#ifdef CLP_MULTIPLE_FACTORIZATIONS    
#include "CoinDenseFactorization.hpp"
#endif

class ClpFactorization 
#ifndef CLP_MULTIPLE_FACTORIZATIONS    
  : public CoinFactorization
#endif
{

  //friend class CoinFactorization;
  
public:
  int factorize (ClpSimplex * model,int solveType, bool valuesPass);


   ClpFactorization();
   ~ClpFactorization();

   ClpFactorization(const ClpFactorization&);
   ClpFactorization(const CoinFactorization&);
#ifdef CLP_MULTIPLE_FACTORIZATIONS    

   ClpFactorization(const CoinDenseFactorization&);
#endif
   ClpFactorization& operator=(const ClpFactorization&);
   
  /*  **** below here is so can use networkish basis */

  int replaceColumn ( const ClpSimplex * model,
                      CoinIndexedVector * regionSparse,
                      CoinIndexedVector * tableauColumn,
                      int pivotRow,
                      double pivotCheck ,
                      bool checkBeforeModifying=false);

  int updateColumnFT ( CoinIndexedVector * regionSparse,
                       CoinIndexedVector * regionSparse2);
  int updateColumn ( CoinIndexedVector * regionSparse,
                     CoinIndexedVector * regionSparse2,
                     bool noPermute=false) const;
  int updateColumnForDebug ( CoinIndexedVector * regionSparse,
                     CoinIndexedVector * regionSparse2,
                     bool noPermute=false) const;
  int updateColumnTranspose ( CoinIndexedVector * regionSparse,
                              CoinIndexedVector * regionSparse2) const;
#ifdef CLP_MULTIPLE_FACTORIZATIONS    


  inline int numberElements (  ) const {
    if (coinFactorizationA_) return coinFactorizationA_->numberElements(); else return coinFactorizationB_->numberElements() ;
  }
  inline int *permute (  ) const {
    if (coinFactorizationA_) return coinFactorizationA_->permute(); else return coinFactorizationB_->permute() ;
  }
  inline int *pivotColumn (  ) const {
    if (coinFactorizationA_) return coinFactorizationA_->pivotColumn(); else return coinFactorizationB_->permute() ;
  }
  inline int maximumPivots (  ) const {
    if (coinFactorizationA_) return coinFactorizationA_->maximumPivots();  else return coinFactorizationB_->maximumPivots() ;
  }
  inline void maximumPivots (  int value) {
    if (coinFactorizationA_) coinFactorizationA_->maximumPivots(value); else coinFactorizationB_->maximumPivots(value);
  }
  inline int pivots (  ) const {
    if (coinFactorizationA_) return coinFactorizationA_->pivots(); else return coinFactorizationB_->pivots() ;
  }
  inline double areaFactor (  ) const {
    if (coinFactorizationA_) return coinFactorizationA_->areaFactor(); else return 0.0 ;
  }
  inline void areaFactor ( double value) {
    if (coinFactorizationA_) coinFactorizationA_->areaFactor(value); 
  }
  inline double zeroTolerance (  ) const {
    if (coinFactorizationA_) return coinFactorizationA_->zeroTolerance();  else return coinFactorizationB_->zeroTolerance() ;
  }
  inline void zeroTolerance (  double value) {
    if (coinFactorizationA_) coinFactorizationA_->zeroTolerance(value); else coinFactorizationB_->zeroTolerance(value);
  }
  inline int sparseThreshold ( ) const
  { if (coinFactorizationA_) return coinFactorizationA_->sparseThreshold(); else return 0 ;}
  inline void sparseThreshold ( int value) 
  { if (coinFactorizationA_) coinFactorizationA_->sparseThreshold(value); }
  inline int status (  ) const {
    if (coinFactorizationA_) return coinFactorizationA_->status(); else return coinFactorizationB_->status() ;
  }
  inline void setStatus (  int value) {
    if (coinFactorizationA_) coinFactorizationA_->setStatus(value); else coinFactorizationB_->setStatus(value) ;
  }
  inline int numberDense() const
  { if (coinFactorizationA_) return coinFactorizationA_->numberDense(); else return 0 ;}
#if 0
  inline CoinBigIndex numberElementsU (  ) const {
    if (coinFactorizationA_) return coinFactorizationA_->numberElementsU(); else return 0 ;
  }
  inline CoinBigIndex numberElementsL (  ) const {
    if (coinFactorizationA_) return coinFactorizationA_->numberElementsL(); else return 0 ;
  }
  inline CoinBigIndex numberElementsR (  ) const {
    if (coinFactorizationA_) return coinFactorizationA_->numberElementsR(); else return 0 ;
  }
#endif
  inline bool timeToRefactorize() const
  {
    if (coinFactorizationA_) {
      return (coinFactorizationA_->pivots()*3>coinFactorizationA_->maximumPivots()*2&&
              coinFactorizationA_->numberElementsR()*3>(coinFactorizationA_->numberElementsL()+
                                                        coinFactorizationA_->numberElementsU())*2+1000&&
              !coinFactorizationA_->numberDense());
    } else {
      return coinFactorizationB_->pivots()>coinFactorizationB_->numberRows()/2.45+20;
    }
  }
  inline int messageLevel (  ) const {
    if (coinFactorizationA_) return coinFactorizationA_->messageLevel();  else return 0 ;
  }
  inline void messageLevel (  int value) {
    if (coinFactorizationA_) coinFactorizationA_->messageLevel(value);
  }
  inline void clearArrays()
  { if (coinFactorizationA_) coinFactorizationA_->clearArrays();}
  inline int numberRows (  ) const {
    if (coinFactorizationA_) return coinFactorizationA_->numberRows(); else return coinFactorizationB_->numberRows() ;
  }
  inline int denseThreshold() const 
  { if (coinFactorizationA_) return coinFactorizationA_->denseThreshold(); else return 0 ;}
  inline void setDenseThreshold(int value)
  { if (coinFactorizationA_) coinFactorizationA_->setDenseThreshold(value);}
  inline double pivotTolerance (  ) const {
    if (coinFactorizationA_) return coinFactorizationA_->pivotTolerance();  else return 1.0e-8 ;
  }
  inline void pivotTolerance (  double value) {
    if (coinFactorizationA_) coinFactorizationA_->pivotTolerance(value);
  }
  inline void relaxAccuracyCheck(double value)
  { if (coinFactorizationA_) coinFactorizationA_->relaxAccuracyCheck(value);}
  inline int persistenceFlag() const
  { if (coinFactorizationA_) return coinFactorizationA_->persistenceFlag(); else return 0 ;}
  inline void setPersistenceFlag(int value)
  { if (coinFactorizationA_) coinFactorizationA_->setPersistenceFlag(value);}
  inline void almostDestructor()
  { if (coinFactorizationA_) coinFactorizationA_->almostDestructor(); }
  inline double adjustedAreaFactor() const
  { if (coinFactorizationA_) return coinFactorizationA_->adjustedAreaFactor(); else return 0.0 ; }
  inline void setBiasLU(int value)
  { if (coinFactorizationA_) coinFactorizationA_->setBiasLU(value);}
  inline void setForrestTomlin(bool value)
  { if (coinFactorizationA_) coinFactorizationA_->setForrestTomlin(value);}
  inline void setDefaultValues() {
    if (coinFactorizationA_) {
      coinFactorizationA_->increasingRows(2);
      // row activities have negative sign
      coinFactorizationA_->slackValue(-1.0);
      coinFactorizationA_->zeroTolerance(1.0e-13);
    }
  }
  void goDense() ;
#else
  inline bool timeToRefactorize() const
  {
    return (pivots()*3>maximumPivots()*2&&
            numberElementsR()*3>(numberElementsL()+numberElementsU())*2+1000&&
            !numberDense());
  }
  inline void setDefaultValues() {
    increasingRows(2);
    // row activities have negative sign
    slackValue(-1.0);
    zeroTolerance(1.0e-13);
  }
  inline void goDense() {}
#endif

    
  void goSparse();
  void cleanUp();
  bool needToReorder() const;
#ifndef SLIM_CLP
  inline bool networkBasis() const
  { return (networkBasis_!=NULL);}
#else
  inline bool networkBasis() const
  { return false;}
#endif
  void getWeights(int * weights) const;


private:


#ifndef SLIM_CLP
  ClpNetworkBasis * networkBasis_;
#endif
#ifdef CLP_MULTIPLE_FACTORIZATIONS    
  CoinFactorization * coinFactorizationA_;
  CoinDenseFactorization * coinFactorizationB_;
#endif

};

#endif

---