ClpFactorization.hpp

Go to the documentation of this file.

/* $Id: ClpFactorization.hpp 2078 2015-01-05 12:39:49Z forrest $ */
// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

#ifndef ClpFactorization_H
#define ClpFactorization_H


#include "CoinPragma.hpp"

#include "CoinFactorization.hpp"
class ClpMatrixBase;
class ClpSimplex;
class ClpNetworkBasis;
class CoinOtherFactorization;
#ifndef CLP_MULTIPLE_FACTORIZATIONS
#define CLP_MULTIPLE_FACTORIZATIONS 4
#endif
#ifdef CLP_MULTIPLE_FACTORIZATIONS
#include "CoinDenseFactorization.hpp"
#include "ClpSimplex.hpp"
#endif
#ifndef COIN_FAST_CODE
#define COIN_FAST_CODE
#endif
#ifndef CLP_FACTORIZATION_NEW_TIMING
#define CLP_FACTORIZATION_NEW_TIMING 1
#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 CoinFactorization&);
     ClpFactorization(const ClpFactorization&, int denseIfSmaller = 0);
#ifdef CLP_MULTIPLE_FACTORIZATIONS

     ClpFactorization(const CoinOtherFactorization&);
#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,
                         double acceptablePivot = 1.0e-8);

     int updateColumnFT ( CoinIndexedVector * regionSparse,
                          CoinIndexedVector * regionSparse2);
     int updateColumn ( CoinIndexedVector * regionSparse,
                        CoinIndexedVector * regionSparse2,
                        bool noPermute = false) const;
     int updateTwoColumnsFT ( CoinIndexedVector * regionSparse1,
                              CoinIndexedVector * regionSparse2,
                              CoinIndexedVector * regionSparse3,
                              bool noPermuteRegion3 = false) ;
     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);
     }
     void saferTolerances (  double zeroTolerance, double pivotTolerance);
     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 1
     inline CoinBigIndex numberElementsU (  ) const {
          if (coinFactorizationA_) return coinFactorizationA_->numberElementsU();
          else return -1 ;
     }
     inline CoinBigIndex numberElementsL (  ) const {
          if (coinFactorizationA_) return coinFactorizationA_->numberElementsL();
          else return -1 ;
     }
     inline CoinBigIndex numberElementsR (  ) const {
          if (coinFactorizationA_) return coinFactorizationA_->numberElementsR();
          else return 0 ;
     }
#endif
     bool timeToRefactorize() const;
#if CLP_FACTORIZATION_NEW_TIMING>1
     void statsRefactor(char when) const;
#endif
     inline int messageLevel (  ) const {
          if (coinFactorizationA_) return coinFactorizationA_->messageLevel();
          else return 1 ;
     }
     inline void messageLevel (  int value) {
          if (coinFactorizationA_) coinFactorizationA_->messageLevel(value);
     }
     inline void clearArrays() {
          if (coinFactorizationA_)
               coinFactorizationA_->clearArrays();
          else if (coinFactorizationB_)
               coinFactorizationB_->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 if (coinFactorizationB_) return coinFactorizationB_->pivotTolerance();
          return 1.0e-8 ;
     }
     inline void pivotTolerance (  double value) {
          if (coinFactorizationA_) coinFactorizationA_->pivotTolerance(value);
          else if (coinFactorizationB_) coinFactorizationB_->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();
          else if (coinFactorizationB_)
               coinFactorizationB_->clearArrays();
     }
     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_) {
               // row activities have negative sign
#ifndef COIN_FAST_CODE
               coinFactorizationA_->slackValue(-1.0);
#endif
               coinFactorizationA_->zeroTolerance(1.0e-13);
          }
     }
     void forceOtherFactorization(int which);
     inline int goOslThreshold() const {
          return goOslThreshold_;
     }
     inline void setGoOslThreshold(int value) {
          goOslThreshold_ = value;
     }
     inline int goDenseThreshold() const {
          return goDenseThreshold_;
     }
     inline void setGoDenseThreshold(int value) {
          goDenseThreshold_ = value;
     }
     inline int goSmallThreshold() const {
          return goSmallThreshold_;
     }
     inline void setGoSmallThreshold(int value) {
          goSmallThreshold_ = value;
     }
     void goDenseOrSmall(int numberRows) ;
     void setFactorization(ClpFactorization & factorization);
     inline int isDenseOrSmall() const {
          return coinFactorizationB_ ? 1 : 0;
     }
#else
     inline bool timeToRefactorize() const {
          return (pivots() * 3 > maximumPivots() * 2 &&
                  numberElementsR() * 3 > (numberElementsL() + numberElementsU()) * 2 + 1000 &&
                  !numberDense());
     }
     inline void setDefaultValues() {
          // row activities have negative sign
#ifndef COIN_FAST_CODE
          slackValue(-1.0);
#endif
          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_;
     CoinOtherFactorization * coinFactorizationB_;
#ifdef CLP_REUSE_ETAS
     ClpSimplex * model_;
#endif
     int forceB_;
     int goOslThreshold_;
     int goSmallThreshold_;
     int goDenseThreshold_;
#endif
#ifdef CLP_FACTORIZATION_NEW_TIMING
     mutable double shortestAverage_;
     mutable double totalInR_;
     mutable double totalInIncreasingU_;
     mutable int endLengthU_;
     mutable int lastNumberPivots_;
     mutable int effectiveStartNumberU_;
#endif

};
 
#endif