AbcSimplexFactorization.hpp

Go to the documentation of this file.

/* $Id: AbcSimplexFactorization.hpp 2385 2019-01-06 19:43:06Z unxusr $ */
// Copyright (C) 2002, International Business Machines
// Corporation and others, Copyright (C) 2012, FasterCoin.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

#ifndef AbcSimplexFactorization_H
#define AbcSimplexFactorization_H

#include "CoinPragma.hpp"

#include "CoinAbcCommon.hpp"
#include "CoinAbcFactorization.hpp"
#include "AbcMatrix.hpp"
//#include "CoinAbcAnyFactorization.hpp"
#include "AbcSimplex.hpp"
#ifndef ABC_USE_COIN_FACTORIZATION
class ClpFactorization;
class CoinFactorization;
#else
#include "ClpFactorization.hpp"
#include "CoinFactorization.hpp"
#endif

class AbcSimplexFactorization {

public:
  int factorize(AbcSimplex *model, int solveType, bool valuesPass);
#ifdef EARLY_FACTORIZE
  inline int factorize(AbcSimplex *model, CoinIndexedVector &stuff)
  {
    return coinAbcFactorization_->factorize(model, stuff);
  }
#endif


  AbcSimplexFactorization(int numberRows = 0);
  ~AbcSimplexFactorization();

  AbcSimplexFactorization(const AbcSimplexFactorization &, int denseIfSmaller = 0);
  AbcSimplexFactorization &operator=(const AbcSimplexFactorization &);
  void setFactorization(AbcSimplexFactorization &rhs);

  /*  **** below here is so can use networkish basis */

  inline
#ifdef ABC_LONG_FACTORIZATION
    long
#endif
    double
    checkReplacePart1(CoinIndexedVector *regionSparse,
      int pivotRow)
  {
    return coinAbcFactorization_->checkReplacePart1(regionSparse, pivotRow);
  }
  inline
#ifdef ABC_LONG_FACTORIZATION
    long
#endif
    double
    checkReplacePart1(CoinIndexedVector *regionSparse,
      CoinIndexedVector *partialUpdate,
      int pivotRow)
  {
    return coinAbcFactorization_->checkReplacePart1(regionSparse, partialUpdate, pivotRow);
  }
#ifdef MOVE_REPLACE_PART1A

  inline void checkReplacePart1a(CoinIndexedVector *regionSparse,
    int pivotRow)
  {
    coinAbcFactorization_->checkReplacePart1a(regionSparse, pivotRow);
  }
  inline double checkReplacePart1b(CoinIndexedVector *regionSparse,
    int pivotRow)
  {
    return coinAbcFactorization_->checkReplacePart1b(regionSparse, pivotRow);
  }
#endif

  inline int checkReplacePart2(int pivotRow,
    double btranAlpha,
    double ftranAlpha,
#ifdef ABC_LONG_FACTORIZATION
    long
#endif
    double ftAlpha)
  {
    return coinAbcFactorization_->checkReplacePart2(pivotRow, btranAlpha, ftranAlpha, ftAlpha);
  }
#ifdef ABC_LONG_FACTORIZATION
  inline void clearHiddenArrays()
  {
    coinAbcFactorization_->clearHiddenArrays();
  }
#endif

  void replaceColumnPart3(const AbcSimplex *model,
    CoinIndexedVector *regionSparse,
    CoinIndexedVector *tableauColumn,
    int pivotRow,
#ifdef ABC_LONG_FACTORIZATION
    long
#endif
    double alpha);
  void replaceColumnPart3(const AbcSimplex *model,
    CoinIndexedVector *regionSparse,
    CoinIndexedVector *tableauColumn,
    CoinIndexedVector *partialUpdate,
    int pivotRow,
#ifdef ABC_LONG_FACTORIZATION
    long
#endif
    double alpha);
#ifdef EARLY_FACTORIZE
  inline int replaceColumns(const AbcSimplex *model,
    CoinIndexedVector &stuff,
    int firstPivot, int lastPivot, bool cleanUp)
  {
    return coinAbcFactorization_->replaceColumns(model, stuff, firstPivot, lastPivot, cleanUp);
  }
#endif


#if 0

  int updateColumnFT ( CoinIndexedVector * regionSparse,
                       CoinIndexedVector * regionSparse2);
  int updateColumn ( CoinIndexedVector * regionSparse,
                     CoinIndexedVector * regionSparse2) const;
  int updateTwoColumnsFT ( CoinIndexedVector * regionSparse1,
                           CoinIndexedVector * regionSparse2,
                           CoinIndexedVector * regionSparse3) ;
  int updateColumnTranspose ( CoinIndexedVector * regionSparse,
                              CoinIndexedVector * regionSparse2) const;
#endif

  inline int updateColumnFT(CoinIndexedVector &regionSparseFT)
  {
    return coinAbcFactorization_->updateColumnFT(regionSparseFT);
  }
  inline int updateColumnFTPart1(CoinIndexedVector &regionSparseFT)
  {
    return coinAbcFactorization_->updateColumnFTPart1(regionSparseFT);
  }
  inline void updateColumnFTPart2(CoinIndexedVector &regionSparseFT)
  {
    coinAbcFactorization_->updateColumnFTPart2(regionSparseFT);
  }
  inline void updateColumnFT(CoinIndexedVector &regionSparseFT,
    CoinIndexedVector &partialUpdate,
    int which)
  {
    coinAbcFactorization_->updateColumnFT(regionSparseFT, partialUpdate, which);
  }
  inline int updateColumn(CoinIndexedVector &regionSparse) const
  {
    return coinAbcFactorization_->updateColumn(regionSparse);
  }
  inline int updateTwoColumnsFT(CoinIndexedVector &regionSparseFT,
    CoinIndexedVector &regionSparseOther)
  {
    return coinAbcFactorization_->updateTwoColumnsFT(regionSparseFT, regionSparseOther);
  }
  inline int updateColumnTranspose(CoinIndexedVector &regionSparse) const
  {
    return coinAbcFactorization_->updateColumnTranspose(regionSparse);
  }
  inline void updateColumnCpu(CoinIndexedVector &regionSparse, int whichCpu) const
#ifndef ABC_USE_COIN_FACTORIZATION
  {
    coinAbcFactorization_->updateColumnCpu(regionSparse, whichCpu);
  }
#else
  {
    coinAbcFactorization_->updateColumn(regionSparse);
  }
#endif

  inline void updateColumnTransposeCpu(CoinIndexedVector &regionSparse, int whichCpu) const
#ifndef ABC_USE_COIN_FACTORIZATION
  {
    coinAbcFactorization_->updateColumnTransposeCpu(regionSparse, whichCpu);
  }
#else
  {
    coinAbcFactorization_->updateColumnTranspose(regionSparse);
  }
#endif

  inline void updateFullColumn(CoinIndexedVector &regionSparse) const
  {
    coinAbcFactorization_->updateFullColumn(regionSparse);
  }
  inline void updateFullColumnTranspose(CoinIndexedVector &regionSparse) const
  {
    coinAbcFactorization_->updateFullColumnTranspose(regionSparse);
  }
  void updateWeights(CoinIndexedVector &regionSparse) const
#ifndef ABC_USE_COIN_FACTORIZATION
  {
    coinAbcFactorization_->updateWeights(regionSparse);
  }
#else
  {
    coinAbcFactorization_->updateColumn(regionSparse);
  }
#endif


  inline int numberElements() const
  {
    return coinAbcFactorization_->numberElements();
  }
  inline int maximumPivots() const
  {
    return coinAbcFactorization_->maximumPivots();
  }
  inline void maximumPivots(int value)
  {
    coinAbcFactorization_->maximumPivots(value);
  }
  inline bool usingFT() const
  {
    return !coinAbcFactorization_->wantsTableauColumn();
  }
  inline int pivots() const
  {
    return coinAbcFactorization_->pivots();
  }
  inline void setModel(AbcSimplex *model)
  {
    model_ = model;
  }
  inline void setPivots(int value) const
  {
    coinAbcFactorization_->setPivots(value);
  }
  inline double areaFactor() const
  {
    return coinAbcFactorization_->areaFactor();
  }
  inline void areaFactor(double value)
  {
    coinAbcFactorization_->areaFactor(value);
  }
  inline double zeroTolerance() const
  {
    return coinAbcFactorization_->zeroTolerance();
  }
  inline void zeroTolerance(double value)
  {
    coinAbcFactorization_->zeroTolerance(value);
  }
  void saferTolerances(double zeroTolerance, double pivotTolerance);
  inline int status() const
  {
    return coinAbcFactorization_->status();
  }
  inline void setStatus(int value)
  {
    coinAbcFactorization_->setStatus(value);
  }
#if ABC_PARALLEL == 2
  inline void setParallelMode(int value)
  {
    coinAbcFactorization_->setParallelMode(value);
  };
#endif
  inline int numberDense() const
  {
    return coinAbcFactorization_->numberDense();
  }
  bool timeToRefactorize() const;
#if CLP_FACTORIZATION_NEW_TIMING > 1
  void statsRefactor(char when) const;
#endif
  inline void clearArrays()
  {
    coinAbcFactorization_->clearArrays();
  }
  inline int numberRows() const
  {
    return coinAbcFactorization_->numberRows();
  }
  inline int numberSlacks() const
  {
    return numberSlacks_;
  }
  inline double pivotTolerance() const
  {
    return coinAbcFactorization_->pivotTolerance();
  }
  inline void pivotTolerance(double value)
  {
    coinAbcFactorization_->pivotTolerance(value);
  }
  inline double minimumPivotTolerance() const
  {
    return coinAbcFactorization_->minimumPivotTolerance();
  }
  inline void minimumPivotTolerance(double value)
  {
    coinAbcFactorization_->minimumPivotTolerance(value);
  }
  inline double *pivotRegion() const
  {
    return coinAbcFactorization_->pivotRegion();
  }
  //inline void relaxAccuracyCheck(double /*value*/) {
  //abort();
  //}
  inline void almostDestructor()
  {
    coinAbcFactorization_->clearArrays();
  }
  void setDenseThreshold(int number);
  int getDenseThreshold() const;
  void forceOtherFactorization(int which);
  void goDenseOrSmall(int numberRows);
  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;
  }
  inline int goLongThreshold() const
  {
    return goLongThreshold_;
  }
  inline void setGoLongThreshold(int value)
  {
    goLongThreshold_ = value;
  }
  inline int typeOfFactorization() const
  {
    return forceB_;
  }
  void synchronize(const ClpFactorization *otherFactorization, const AbcSimplex *model);

  void goSparse();
#ifndef NDEBUG
#ifndef ABC_USE_COIN_FACTORIZATION
  inline void checkMarkArrays() const
  {
    coinAbcFactorization_->checkMarkArrays();
  }
#else
  inline void checkMarkArrays() const
  {
  }
#endif
#endif
  inline bool needToReorder() const
  {
    abort();
    return true;
  }
#ifndef ABC_USE_COIN_FACTORIZATION
  CoinAbcAnyFactorization *factorization() const
  {
    return coinAbcFactorization_;
  }
#else
  CoinFactorization *factorization() const
  {
    return coinAbcFactorization_;
  }
#endif


private:
  AbcSimplex *model_;
#ifndef ABC_USE_COIN_FACTORIZATION
  CoinAbcAnyFactorization *coinAbcFactorization_;
#else
  CoinFactorization *coinAbcFactorization_;
#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
  int forceB_;
  int goDenseThreshold_;
  int goSmallThreshold_;
  int goLongThreshold_;
  int numberSlacks_;
};

#endif

/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/