AbcSimplexFactorization.hpp

Go to the documentation of this file.

/* $Id: AbcSimplexFactorization.hpp 2078 2015-01-05 12:39:49Z forrest $ */
// 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