CoinAbcDenseFactorization.hpp

Go to the documentation of this file.

/* $Id$ */
// 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
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/