CoinAbcDenseFactorization.hpp

Go to the documentation of this file.

/* $Id: CoinAbcDenseFactorization.hpp 1910 2013-01-27 02:00:13Z stefan $ */
// Copyright (C) 2008, 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).
 
 
/* 
   Authors
   
   John Forrest
 
 */
#ifndef CoinAbcDenseFactorization_H
#define CoinAbcDenseFactorization_H
 
#include <iostream>
#include <string>
#include <cassert>
#include "CoinTypes.hpp"
#include "CoinAbcCommon.hpp"
#include "CoinIndexedVector.hpp"
class CoinPackedMatrix;
class CoinAbcAnyFactorization {
 
public:
 
  CoinAbcAnyFactorization (  );
  CoinAbcAnyFactorization ( const CoinAbcAnyFactorization &other);
  
  virtual ~CoinAbcAnyFactorization (  );
  CoinAbcAnyFactorization & operator = ( const CoinAbcAnyFactorization & other );
 
  virtual CoinAbcAnyFactorization * clone() const = 0;
 
  inline int status (  ) const {
    return status_;
  }
  inline void setStatus (  int value)
  {  status_=value;  }
  inline int pivots (  ) const {
    return numberPivots_;
  }
#if ABC_PARALLEL==2
  inline void setParallelMode(int value)
  {parallelMode_=value;};
#endif
  inline void setPivots (  int value ) 
  { numberPivots_=value; }
  inline int numberSlacks (  ) const {
    return numberSlacks_;
  }
  inline void setNumberSlacks (  int value ) 
  { numberSlacks_=value; }
  inline void setNumberRows(int value)
  { numberRows_ = value; }
  inline int numberRows (  ) const {
    return numberRows_;
  }
  inline CoinSimplexInt numberDense (  ) const {
    return numberDense_;
  }
  inline int numberGoodColumns (  ) const {
    return numberGoodU_;
  }
  inline void relaxAccuracyCheck(double value)
  { relaxCheck_ = value;}
  inline double getAccuracyCheck() const
  { return relaxCheck_;}
  inline int maximumPivots (  ) const {
    return maximumPivots_ ;
  }
  virtual void maximumPivots (  int value );
 
  inline double pivotTolerance (  ) const {
    return pivotTolerance_ ;
  }
  void pivotTolerance (  double value );
  inline double minimumPivotTolerance (  ) const {
    return minimumPivotTolerance_ ;
  }
  void minimumPivotTolerance (  double value );
  virtual CoinFactorizationDouble * pivotRegion() const
  { return NULL;}
  inline double areaFactor (  ) const {
    return areaFactor_ ;
  }
  inline void areaFactor ( CoinSimplexDouble value ) {
    areaFactor_=value;
  }
  inline double zeroTolerance (  ) const {
    return zeroTolerance_ ;
  }
  void zeroTolerance (  double value );
  virtual CoinFactorizationDouble * elements() const;
  virtual int * pivotRow() const;
  virtual CoinFactorizationDouble * workArea() const;
  virtual int * intWorkArea() const;
  virtual int * numberInRow() const;
  virtual int * numberInColumn() const;
  virtual CoinBigIndex * starts() const;
  virtual int * permuteBack() const;
  virtual void goSparse() {}
#ifndef NDEBUG
  virtual inline void checkMarkArrays() const {}
#endif
  inline int solveMode() const
  { return solveMode_ ;}
  inline void setSolveMode(int value)
  { solveMode_ = value;}
  virtual bool wantsTableauColumn() const;
  virtual void setUsefulInformation(const int * info,int whereFrom);
  virtual void clearArrays() {}
 
  virtual int * indices() const  = 0;
  virtual int * permute() const = 0;
  virtual int * pivotColumn() const;
  virtual int numberElements (  ) const = 0;
 
  virtual void getAreas ( int numberRows,
                  int numberColumns,
                  CoinBigIndex maximumL,
                  CoinBigIndex maximumU ) = 0;
  
  virtual void preProcess ( ) = 0;
  virtual int factor (AbcSimplex * model) = 0;
#ifdef EARLY_FACTORIZE
  virtual int factorize (AbcSimplex * /*model*/, CoinIndexedVector & /*stuff*/)
  { return -2;}
#endif
  virtual void postProcess(const int * sequence, int * pivotVariable) = 0;
  virtual void makeNonSingular(int * sequence) = 0;
 
#if 0
  virtual int checkReplace ( CoinIndexedVector * /*regionSparse*/,
                             int /*pivotRow*/,
                             double & /*pivotCheck*/,
                             double /*acceptablePivot = 1.0e-8*/)
  {return 0;}
  virtual int replaceColumn ( CoinIndexedVector * regionSparse,
                      int pivotRow,
                      double pivotCheck ,
                              bool skipBtranU=false,
                              double acceptablePivot=1.0e-8)=0;
#endif
#ifdef EARLY_FACTORIZE
  virtual int replaceColumns ( const AbcSimplex * /*model*/,
                               CoinIndexedVector & /*stuff*/,
                               int /*firstPivot*/,int /*lastPivot*/,bool /*cleanUp*/)
  { return -1;}
#endif
#ifdef ABC_LONG_FACTORIZATION 
  virtual void clearHiddenArrays() {}
#endif
  virtual 
#ifdef ABC_LONG_FACTORIZATION 
  long
#endif
  double checkReplacePart1 ( CoinIndexedVector * /*regionSparse*/,
                                     int /*pivotRow*/)
  {return 0.0;}
  virtual 
#ifdef ABC_LONG_FACTORIZATION 
  long
#endif
  double checkReplacePart1 ( CoinIndexedVector * /*regionSparse*/,
                                     CoinIndexedVector * /*partialUpdate*/,
                                     int /*pivotRow*/)
  {return 0.0;}
  virtual void checkReplacePart1a ( CoinIndexedVector * /* regionSparse */,
                                    int /*pivotRow*/)
  {}
  virtual double checkReplacePart1b (CoinIndexedVector * /*regionSparse*/,
                                     int /*pivotRow*/)
  {return 0.0;}
  virtual int checkReplacePart2 ( int pivotRow,
                                  double btranAlpha, 
                                  double ftranAlpha, 
#ifdef ABC_LONG_FACTORIZATION 
                                  long
#endif
                                  double ftAlpha,
                                  double acceptablePivot = 1.0e-8) = 0;
  virtual void replaceColumnPart3 ( const AbcSimplex * model,
                      CoinIndexedVector * regionSparse,
                      CoinIndexedVector * tableauColumn,
                      int pivotRow,
#ifdef ABC_LONG_FACTORIZATION 
                                    long
#endif
                       double alpha ) = 0;
  virtual void replaceColumnPart3 ( const AbcSimplex * model,
                                    CoinIndexedVector * regionSparse,
                                    CoinIndexedVector * tableauColumn,
                                    CoinIndexedVector * partialUpdate,
                                    int pivotRow,
#ifdef ABC_LONG_FACTORIZATION 
                                  long
#endif
                                    double alpha )=0;
 
  virtual int updateColumnFT ( CoinIndexedVector & regionSparse) = 0;
  virtual int updateColumnFTPart1 ( CoinIndexedVector & regionSparse) = 0;
  virtual void updateColumnFTPart2 ( CoinIndexedVector & regionSparse) = 0;
  virtual void updateColumnFT ( CoinIndexedVector & regionSparseFT,
                                CoinIndexedVector & partialUpdate,
                                int which)=0;
  virtual int updateColumn ( CoinIndexedVector & regionSparse) const = 0;
  virtual int updateTwoColumnsFT(CoinIndexedVector & regionFT,
                                    CoinIndexedVector & regionOther) = 0;
  virtual int updateColumnTranspose ( CoinIndexedVector & regionSparse) const = 0;
  virtual void updateFullColumn ( CoinIndexedVector & regionSparse) const = 0;
  virtual void updateFullColumnTranspose ( CoinIndexedVector & regionSparse) const = 0;
  virtual void updateWeights ( CoinIndexedVector & regionSparse) const=0;
  virtual void updateColumnCpu ( CoinIndexedVector & regionSparse,int whichCpu) const;
  virtual void updateColumnTransposeCpu ( CoinIndexedVector & regionSparse,int whichCpu) const;
 
protected:
 
  double pivotTolerance_;
  double minimumPivotTolerance_;
  double areaFactor_;
  double zeroTolerance_;
  //#ifndef slackValue_ 
#define slackValue2_ 1.0
  //#endif
  double relaxCheck_;
  CoinBigIndex factorElements_;
  int numberRows_;
  int numberDense_;
  int numberGoodU_;
  int maximumPivots_;
  int numberPivots_;
  int numberSlacks_;
  int status_;
  int maximumRows_;
#if ABC_PARALLEL==2
  int parallelMode_;
#endif
  int * pivotRow_;
  CoinFactorizationDouble * elements_;
  CoinFactorizationDouble * workArea_;
  int solveMode_;
};
class CoinAbcDenseFactorization : public CoinAbcAnyFactorization {
   friend void CoinAbcDenseFactorizationUnitTest( const std::string & mpsDir );
 
public:
 
  CoinAbcDenseFactorization (  );
  CoinAbcDenseFactorization ( const CoinAbcDenseFactorization &other);
  
  virtual ~CoinAbcDenseFactorization (  );
  CoinAbcDenseFactorization & operator = ( const CoinAbcDenseFactorization & other );
  virtual CoinAbcAnyFactorization * clone() const ;
 
  virtual void getAreas ( int numberRows,
                  int numberColumns,
                  CoinBigIndex maximumL,
                  CoinBigIndex maximumU );
  
  virtual void preProcess ( );
  virtual int factor (AbcSimplex * model);
  virtual void postProcess(const int * sequence, int * pivotVariable);
  virtual void makeNonSingular(int * sequence);
 
  virtual inline int numberElements (  ) const {
    return numberRows_*(numberRows_+numberPivots_);
  }
  double maximumCoefficient() const;
 
 
  virtual int replaceColumn ( CoinIndexedVector * regionSparse,
                      int pivotRow,
                      double pivotCheck ,
                              bool skipBtranU=false,
                              double acceptablePivot=1.0e-8);
  virtual int checkReplacePart2 ( int pivotRow,
                                  double btranAlpha, 
                                  double ftranAlpha, 
#ifdef ABC_LONG_FACTORIZATION 
                                  long
#endif
                                  double ftAlpha,
                                  double acceptablePivot = 1.0e-8) ;
  virtual void replaceColumnPart3 ( const AbcSimplex * model,
                      CoinIndexedVector * regionSparse,
                      CoinIndexedVector * tableauColumn,
                      int pivotRow,
#ifdef ABC_LONG_FACTORIZATION 
                                    long
#endif
                       double alpha );
  virtual void replaceColumnPart3 ( const AbcSimplex * model,
                                    CoinIndexedVector * regionSparse,
                                    CoinIndexedVector * tableauColumn,
                                    CoinIndexedVector * /*partialUpdate*/,
                                    int pivotRow,
#ifdef ABC_LONG_FACTORIZATION 
                                    long
#endif
                                    double alpha )
  { replaceColumnPart3(model,regionSparse,tableauColumn,pivotRow,alpha);}
 
  virtual int updateColumnFT ( CoinIndexedVector & regionSparse)
  {return updateColumn(regionSparse);}
  virtual int updateColumnFTPart1 ( CoinIndexedVector & regionSparse)
  {return updateColumn(regionSparse);}
  virtual void updateColumnFTPart2 ( CoinIndexedVector & /*regionSparse*/)
  {}
  virtual void updateColumnFT ( CoinIndexedVector & regionSparseFT,CoinIndexedVector & /*partialUpdate*/,int /*which*/)
  { updateColumnFT(regionSparseFT);}
  virtual int updateColumn ( CoinIndexedVector & regionSparse) const;
  virtual int updateTwoColumnsFT(CoinIndexedVector & regionFT,
                                    CoinIndexedVector & regionOther);
  virtual int updateColumnTranspose ( CoinIndexedVector & regionSparse) const;
  virtual void updateFullColumn ( CoinIndexedVector & regionSparse) const
  {updateColumn(regionSparse);}
  virtual void updateFullColumnTranspose ( CoinIndexedVector & regionSparse) const
  {updateColumnTranspose(regionSparse);}
  virtual void updateWeights ( CoinIndexedVector & regionSparse) const;
 
 
  inline void clearArrays()
  { gutsOfDestructor();}
  virtual inline int * indices() const
  { return reinterpret_cast<int *> (elements_+numberRows_*numberRows_);}
  virtual inline int * permute() const
  { return NULL;/*pivotRow_*/;}
 
  void gutsOfDestructor();
  void gutsOfInitialize();
  void gutsOfCopy(const CoinAbcDenseFactorization &other);
 
protected:
  int checkPivot(double saveFromU, double oldPivot) const;
protected:
  CoinBigIndex maximumSpace_;
  CoinSimplexInt maximumRowsAdjusted_;
 
};
#endif