ClpFactorization.hpp

Go to the documentation of this file.

/* $Id$ */
// 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);
#if ABOCA_LITE_FACTORIZATION
  void replaceColumn1(CoinIndexedVector *regionSparse, int pivotRow);
  int replaceColumn2(CoinIndexedVector *regionSparse,
    int pivotRow,
    double pivotCheck);
#endif
 
 
  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;
  void updateTwoColumnsTranspose(CoinIndexedVector *regionSparse,
    CoinIndexedVector *regionSparse2,
    CoinIndexedVector *regionSparse3) 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;
  }
  inline CoinFactorization *coinFactorization() const
  {
    return coinFactorizationA_;
  }
#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;
  inline void doStatistics(bool trueFalse) const
  {
    doStatistics_ = trueFalse;
  }
#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
  mutable bool doStatistics_;
};
 
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/