CoinAbcBaseFactorization.hpp

Go to the documentation of this file.

/* $Id: CoinAbcBaseFactorization.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).

/* 
   Authors
   
   John Forrest

 */
#include "AbcCommon.hpp"
#include "CoinAbcHelperFunctions.hpp"
#if ABC_PARALLEL
#define FACTOR_CPU 4
#else
#define FACTOR_CPU 1
#endif
#define LARGE_SET COIN_INT_MAX - 10
#define LARGE_UNSET (LARGE_SET + 1)

class CoinAbcTypeFactorization : public CoinAbcAnyFactorization {
  friend void CoinAbcFactorizationUnitTest(const std::string &mpsDir);

public:
  CoinAbcTypeFactorization();
  CoinAbcTypeFactorization(const CoinAbcTypeFactorization &other);
  CoinAbcTypeFactorization(const CoinFactorization &other);

  virtual ~CoinAbcTypeFactorization();
  virtual CoinAbcAnyFactorization *clone() const;
  void almostDestructor();
  void show_self() const;
  void sort() const;
  CoinAbcTypeFactorization &operator=(const CoinAbcTypeFactorization &other);

  CoinSimplexDouble conditionNumber() const;


  inline CoinSimplexInt *permute() const
  {
    return NULL; //permute_.array();
  }
  virtual inline CoinSimplexInt *indices() const
  {
    return indexRowU_.array();
  }
  virtual inline CoinSimplexInt *pivotColumn() const
  {
    return pivotColumn_.array();
  }
  virtual inline CoinFactorizationDouble *pivotRegion() const
  {
    return pivotRegionAddress_;
  }
#if ABC_SMALL < 2
  inline CoinBigIndex *startRowL() const
  {
    return startRowL_.array();
  }
#endif

  inline CoinBigIndex *startColumnL() const
  {
    return startColumnL_.array();
  }

#if ABC_SMALL < 2
  inline CoinSimplexInt *indexColumnL() const
  {
    return indexColumnL_.array();
  }
#endif

  inline CoinSimplexInt *indexRowL() const
  {
    return indexRowL_.array();
  }

#if ABC_SMALL < 2
  inline CoinFactorizationDouble *elementByRowL() const
  {
    return elementByRowL_.array();
  }
#endif

  inline CoinSimplexInt *pivotLinkedBackwards() const
  {
    return firstCount_.array() + numberRows_ + 1;
  }
  inline CoinSimplexInt *pivotLinkedForwards() const
  {
    return firstCount_.array() + 2 * numberRows_ + 3;
  }
  inline CoinSimplexInt *pivotLOrder() const
  {
    return firstCount_.array();
  }
#if ABC_SMALL < 0
#define ABC_USE_FUNCTION_POINTERS 0
#define SMALL_PERMUTE
#endif
#ifdef ABC_USE_FUNCTION_POINTERS
  typedef void (*scatterUpdate)(int, CoinFactorizationDouble, const CoinFactorizationDouble *, CoinFactorizationDouble *);
#if ABC_USE_FUNCTION_POINTERS
  typedef struct {
    scatterUpdate functionPointer;
    CoinBigIndex offset;
    int number;
  } scatterStruct;
#else
  typedef struct {
    CoinBigIndex offset;
    int number;
  } scatterStruct;
#endif
  inline scatterStruct *scatterUColumn() const
  {
    return scatterPointersUColumnAddress_;
  }
#endif


  inline CoinSimplexInt *firstCount() const
  {
    return firstCount_.array();
  }

  inline CoinSimplexInt *nextCount() const
  {
    return firstCount_.array() + numberRows_ + 2;
  }

  inline CoinSimplexInt *lastCount() const
  {
    return firstCount_.array() + 3 * numberRows_ + 2;
  }

  inline CoinSimplexInt numberRowsExtra() const
  {
    return numberRowsExtra_;
  }
  inline CoinBigIndex numberL() const
  {
    return numberL_;
  }

  inline CoinBigIndex baseL() const
  {
    return baseL_;
  }
  inline CoinSimplexInt maximumRowsExtra() const
  {
    return maximumRowsExtra_;
  }
  virtual inline CoinBigIndex numberElements() const
  {
    return totalElements_;
  }
  inline CoinSimplexInt numberForrestTomlin() const
  {
    return numberInColumn_.array()[numberRowsExtra_];
  }
  CoinSimplexDouble adjustedAreaFactor() const;
  inline CoinSimplexInt messageLevel() const
  {
    return messageLevel_;
  }
  void messageLevel(CoinSimplexInt value);
  virtual void maximumPivots(CoinSimplexInt value);

#if ABC_SMALL < 4
  inline CoinSimplexInt denseThreshold() const
  {
    return denseThreshold_;
  }
  inline void setDenseThreshold(CoinSimplexInt value)
  {
    denseThreshold_ = value;
  }
#endif
  CoinSimplexDouble maximumCoefficient() const;
#if 0
  inline bool forrestTomlin() const
  { return doForrestTomlin_;}
  inline void setForrestTomlin(bool value)
  { doForrestTomlin_=value;}
#endif
  inline bool spaceForForrestTomlin() const
  {
    CoinBigIndex start = lastEntryByColumnU_;
    CoinBigIndex space = lengthAreaU_ - (start + numberRowsExtra_);
    return (space >= 0); //&&doForrestTomlin_;
  }


  inline CoinBigIndex numberElementsU() const
  {
    return lengthU_;
  }
  inline void setNumberElementsU(CoinBigIndex value)
  {
    lengthU_ = value;
  }
  inline CoinBigIndex lengthAreaU() const
  {
    return lengthAreaU_;
  }
  inline CoinBigIndex numberElementsL() const
  {
    return lengthL_;
  }
  inline CoinBigIndex lengthAreaL() const
  {
    return lengthAreaL_;
  }
  inline CoinBigIndex numberElementsR() const
  {
    return lengthR_;
  }
  inline CoinBigIndex numberCompressions() const
  {
    return numberCompressions_;
  }
  //virtual CoinSimplexInt * pivotRow() const;
  //virtual CoinFactorizationDouble * workArea() const;
  //virtual CoinSimplexInt * intWorkArea() const;
  virtual inline CoinBigIndex *starts() const
  {
    return startColumnU_.array();
  }
  virtual inline CoinSimplexInt *numberInRow() const
  {
    return numberInRow_.array();
  }
  virtual inline CoinSimplexInt *numberInColumn() const
  {
    return numberInColumn_.array();
  }
  virtual inline CoinFactorizationDouble *elements() const
  {
    return elementU_.array();
  }
  inline CoinBigIndex *startColumnR() const
  {
    return reinterpret_cast< CoinBigIndex * >(firstCount_.array() + 3 * numberRows_ + 4);
  }
  inline CoinFactorizationDouble *elementU() const
  {
    return elementU_.array();
  }
  inline CoinSimplexInt *indexRowU() const
  {
    return indexRowU_.array();
  }
  inline CoinBigIndex *startColumnU() const
  {
    return startColumnU_.array();
  }
#if COIN_BIG_DOUBLE == 1
  void toLongArray(CoinIndexedVector *vector, int which) const;
  void fromLongArray(CoinIndexedVector *vector) const;
  void fromLongArray(int which) const;
  long double *denseVector(CoinIndexedVector *vector) const;
  long double *denseVector(CoinIndexedVector &vector) const;
  const long double *denseVector(const CoinIndexedVector *vector) const;
  const long double *denseVector(const CoinIndexedVector &vector) const;
  void scan(CoinIndexedVector *vector) const;
  void clearHiddenArrays();
#else
  inline double *denseVector(CoinIndexedVector *vector) const
  {
    return vector->denseVector();
  }
  inline double *denseVector(CoinIndexedVector &vector) const
  {
    return vector.denseVector();
  }
  inline const double *denseVector(const CoinIndexedVector *vector) const
  {
    return vector->denseVector();
  }
  inline const double *denseVector(const CoinIndexedVector &vector) const
  {
    return vector.denseVector();
  }
  inline void toLongArray(CoinIndexedVector *vector, int which) const {}
  inline void fromLongArray(CoinIndexedVector *vector) const {}
  inline void fromLongArray(int which) const {}
  inline void scan(CoinIndexedVector *vector) const
  {
    vector->scan(0, numberRows_, zeroTolerance_);
  }
#endif
#ifdef ABC_ORDERED_FACTORIZATION
  void permuteInForFtran(CoinIndexedVector &regionSparse, bool full = false) const;
  void permuteInForBtranAndMultiply(CoinIndexedVector &regionSparse, bool full = false) const;
  void permuteOutForBtran(CoinIndexedVector &regionSparse) const;
#endif

  //inline CoinSimplexInt persistenceFlag() const
  //{ return persistenceFlag_;}

#if 0

  virtual int checkReplace ( const AbcSimplex * model,
                      CoinIndexedVector * regionSparse,
                      int pivotRow,
                      CoinSimplexDouble & pivotCheck,
                             double acceptablePivot = 1.0e-8);
  virtual CoinSimplexInt replaceColumn ( CoinIndexedVector * regionSparse,
                      CoinSimplexInt pivotRow,
                      CoinSimplexDouble pivotCheck ,
                      bool skipBtranU=false,
                      CoinSimplexDouble acceptablePivot=1.0e-8);
#endif

  virtual
#ifdef ABC_LONG_FACTORIZATION
    long
#endif
    double
    checkReplacePart1(CoinIndexedVector *regionSparse,
      int pivotRow);
  virtual
#ifdef ABC_LONG_FACTORIZATION
    long
#endif
    double
    checkReplacePart1(CoinIndexedVector *regionSparse,
      CoinIndexedVector *partialUpdate,
      int pivotRow);
#ifdef MOVE_REPLACE_PART1A

  virtual void checkReplacePart1a(CoinIndexedVector *regionSparse,
    int pivotRow);
  virtual
#ifdef ABC_LONG_FACTORIZATION
    long
#endif
    double
    checkReplacePart1b(CoinIndexedVector *regionSparse,
      int pivotRow);
#endif

  virtual int checkReplacePart2(int pivotRow,
    CoinSimplexDouble 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);
#ifdef EARLY_FACTORIZE
  virtual int replaceColumns(const AbcSimplex *model,
    CoinIndexedVector &stuff,
    int firstPivot, int lastPivot, bool cleanUp);
#endif
  void updatePartialUpdate(CoinIndexedVector &partialUpdate);
  inline virtual bool wantsTableauColumn() const
  {
    return false;
  }
  int replaceColumnU(CoinIndexedVector *regionSparse,
    CoinBigIndex *deletedPosition,
    CoinSimplexInt *deletedColumns,
    CoinSimplexInt pivotRow);



  virtual CoinSimplexInt updateColumnFT(CoinIndexedVector &regionSparse);
  virtual int updateColumnFTPart1(CoinIndexedVector &regionSparse);
  virtual void updateColumnFTPart2(CoinIndexedVector &regionSparse);
  virtual void updateColumnFT(CoinIndexedVector &regionSparseFT,
    CoinIndexedVector &partialUpdate,
    int which);
  virtual CoinSimplexInt updateColumn(CoinIndexedVector &regionSparse) const;
  virtual CoinSimplexInt updateTwoColumnsFT(CoinIndexedVector &regionFT,
    CoinIndexedVector &regionOther);
  virtual CoinSimplexInt updateColumnTranspose(CoinIndexedVector &regionSparse) const;
  virtual void updateFullColumn(CoinIndexedVector &regionSparse) const;
  virtual void updateFullColumnTranspose(CoinIndexedVector &regionSparse) const;
  virtual void updateWeights(CoinIndexedVector &regionSparse) const;
  virtual void updateColumnCpu(CoinIndexedVector &regionSparse, int whichCpu) const;
  virtual void updateColumnTransposeCpu(CoinIndexedVector &regionSparse, int whichCpu) const;
  void unpack(CoinIndexedVector *regionFrom,
    CoinIndexedVector *regionTo) const;
  void pack(CoinIndexedVector *regionFrom,
    CoinIndexedVector *regionTo) const;
  inline void goSparse() {}
  void goSparse2();
#ifndef NDEBUG
  virtual void checkMarkArrays() const;
#endif
#if ABC_SMALL < 2

  inline CoinSimplexInt sparseThreshold() const
  {
    return sparseThreshold_;
  }
#endif

  void sparseThreshold(CoinSimplexInt value);

  inline void clearArrays()
  {
    gutsOfDestructor();
  }

  void checkSparse();
  void gutsOfDestructor(CoinSimplexInt type = 1);
  void gutsOfInitialize(CoinSimplexInt type);
  void gutsOfCopy(const CoinAbcTypeFactorization &other);

  void resetStatistics();
  void printRegion(const CoinIndexedVector &vector, const char *where) const;


  virtual void getAreas(CoinSimplexInt numberRows,
    CoinSimplexInt numberColumns,
    CoinBigIndex maximumL,
    CoinBigIndex maximumU);

  virtual void preProcess();
  void preProcess(CoinSimplexInt);
  double preProcess3();
  void preProcess4();
  virtual CoinSimplexInt factor(AbcSimplex *model);
#ifdef EARLY_FACTORIZE
  virtual int factorize(AbcSimplex *model, CoinIndexedVector &stuff);
#endif
  virtual void postProcess(const CoinSimplexInt *sequence, CoinSimplexInt *pivotVariable);
  virtual void makeNonSingular(CoinSimplexInt *sequence);

protected:
  CoinSimplexInt factorSparse();
  CoinSimplexInt factorDense();

  bool pivotOneOtherRow(CoinSimplexInt pivotRow,
    CoinSimplexInt pivotColumn);
  bool pivotRowSingleton(CoinSimplexInt pivotRow,
    CoinSimplexInt pivotColumn);
  void pivotColumnSingleton(CoinSimplexInt pivotRow,
    CoinSimplexInt pivotColumn);
  void afterPivot(CoinSimplexInt pivotRow,
    CoinSimplexInt pivotColumn);
  int wantToGoDense();

  bool getColumnSpace(CoinSimplexInt iColumn,
    CoinSimplexInt extraNeeded);

  bool reorderU();
  bool getColumnSpaceIterateR(CoinSimplexInt iColumn, CoinFactorizationDouble value,
    CoinSimplexInt iRow);
  CoinBigIndex getColumnSpaceIterate(CoinSimplexInt iColumn, CoinFactorizationDouble value,
    CoinSimplexInt iRow);
  bool getRowSpace(CoinSimplexInt iRow, CoinSimplexInt extraNeeded);

  bool getRowSpaceIterate(CoinSimplexInt iRow,
    CoinSimplexInt extraNeeded);
  void checkConsistency();
//#define CHECK_LINKS
#ifdef CHECK_LINKS
  void checkLinks(int x = 0);
#else
#define checkLinks(x)
#endif
  inline void addLink(CoinSimplexInt index, CoinSimplexInt count)
  {
    CoinSimplexInt *COIN_RESTRICT nextCount = nextCountAddress_;
    CoinSimplexInt *COIN_RESTRICT firstCount = this->firstCount();
    CoinSimplexInt *COIN_RESTRICT lastCount = lastCountAddress_;
    CoinSimplexInt next = firstCount[count];
    firstCount[count] = index;
    nextCount[index] = next;
    lastCount[index] = count - numberRows_ - 2; // points to firstCount[count]
    if (next >= 0)
      lastCount[next] = index;
  }
  inline void deleteLink(CoinSimplexInt index)
  {
    CoinSimplexInt *COIN_RESTRICT nextCount = nextCountAddress_;
    CoinSimplexInt *COIN_RESTRICT lastCount = lastCountAddress_;
    CoinSimplexInt next = nextCount[index];
    CoinSimplexInt last = lastCount[index];
    assert(next != index);
    assert(last != index);
    if (next >= 0)
      lastCount[next] = last;
    if (last >= 0) {
      nextCount[last] = next;
    } else {
      int count = last + numberRows_ + 2;
      CoinSimplexInt *COIN_RESTRICT firstCount = this->firstCount();
      firstCount[count] = next;
    }
  }
  inline void modifyLink(CoinSimplexInt index, CoinSimplexInt count)
  {
    CoinSimplexInt *COIN_RESTRICT nextCount = nextCountAddress_;
    CoinSimplexInt *COIN_RESTRICT lastCount = lastCountAddress_;
    CoinSimplexInt *COIN_RESTRICT firstCount = this->firstCount();
    CoinSimplexInt next2 = firstCount[count];
    if (next2 == index)
      return;
    firstCount[count] = index;
    CoinSimplexInt next = nextCount[index];
    CoinSimplexInt last = lastCount[index];
    assert(next != index);
    assert(last != index);
    nextCount[index] = next2;
    lastCount[index] = count - numberRows_ - 2; // points to firstCount[count]
    if (next >= 0)
      lastCount[next] = last;
    if (next2 >= 0)
      lastCount[next2] = index;
    if (last >= 0) {
      nextCount[last] = next;
    } else {
      int count = last + numberRows_ + 2;
      firstCount[count] = next;
    }
  }
  void separateLinks();
  void separateLinks(CoinSimplexInt, CoinSimplexInt);
  void cleanup();
  void doAddresses();

  void updateColumnL(CoinIndexedVector *region
#if ABC_SMALL < 2
    ,
    CoinAbcStatistics &statistics
#endif
#if ABC_PARALLEL
    ,
    int whichSparse = 0
#endif
    ) const;
  void updateColumnLDensish(CoinIndexedVector *region) const;
  void updateColumnLDense(CoinIndexedVector *region) const;
  void updateColumnLSparse(CoinIndexedVector *region
#if ABC_PARALLEL
    ,
    int whichSparse
#endif
    ) const;

  void updateColumnR(CoinIndexedVector *region
#if ABC_SMALL < 2
    ,
    CoinAbcStatistics &statistics
#endif
#if ABC_PARALLEL
    ,
    int whichSparse = 0
#endif
    ) const;
  bool storeFT(
#if ABC_SMALL < 3
    const
#endif
    CoinIndexedVector *regionFT);
  void updateColumnU(CoinIndexedVector *region
#if ABC_SMALL < 2
    ,
    CoinAbcStatistics &statistics
#endif
#if ABC_PARALLEL
    ,
    int whichSparse = 0
#endif
    ) const;

  void updateColumnUSparse(CoinIndexedVector *regionSparse
#if ABC_PARALLEL
    ,
    int whichSparse
#endif
    ) const;
  void updateColumnUDensish(CoinIndexedVector *regionSparse) const;
  void updateColumnUDense(CoinIndexedVector *regionSparse) const;
  void updateTwoColumnsUDensish(
    CoinSimplexInt &numberNonZero1,
    CoinFactorizationDouble *COIN_RESTRICT region1,
    CoinSimplexInt *COIN_RESTRICT index1,
    CoinSimplexInt &numberNonZero2,
    CoinFactorizationDouble *COIN_RESTRICT region2,
    CoinSimplexInt *COIN_RESTRICT index2) const;
  void updateColumnPFI(CoinIndexedVector *regionSparse) const;
  void updateColumnTransposePFI(CoinIndexedVector *region) const;
  void updateColumnTransposeU(CoinIndexedVector *region,
    CoinSimplexInt smallestIndex
#if ABC_SMALL < 2
    ,
    CoinAbcStatistics &statistics
#endif
#if ABC_PARALLEL
    ,
    int whichCpu
#endif
    ) const;
  void updateColumnTransposeUDensish(CoinIndexedVector *region,
    CoinSimplexInt smallestIndex) const;
  void updateColumnTransposeUSparse(CoinIndexedVector *region
#if ABC_PARALLEL
    ,
    int whichSparse
#endif
    ) const;
  void updateColumnTransposeUByColumn(CoinIndexedVector *region,
    CoinSimplexInt smallestIndex) const;

  void updateColumnTransposeR(CoinIndexedVector *region
#if ABC_SMALL < 2
    ,
    CoinAbcStatistics &statistics
#endif
    ) const;
  void updateColumnTransposeRDensish(CoinIndexedVector *region) const;
  void updateColumnTransposeRSparse(CoinIndexedVector *region) const;

  void updateColumnTransposeL(CoinIndexedVector *region
#if ABC_SMALL < 2
    ,
    CoinAbcStatistics &statistics
#endif
#if ABC_PARALLEL
    ,
    int whichSparse
#endif
    ) const;
  void updateColumnTransposeLDensish(CoinIndexedVector *region) const;
  void updateColumnTransposeLByRow(CoinIndexedVector *region) const;
  void updateColumnTransposeLSparse(CoinIndexedVector *region
#if ABC_PARALLEL
    ,
    int whichSparse
#endif
    ) const;
public:
  CoinSimplexInt replaceColumnPFI(CoinIndexedVector *regionSparse,
    CoinSimplexInt pivotRow, CoinSimplexDouble alpha);

protected:
  CoinSimplexInt checkPivot(CoinSimplexDouble saveFromU, CoinSimplexDouble oldPivot) const;
  int pivot(CoinSimplexInt pivotRow,
    CoinSimplexInt pivotColumn,
    CoinBigIndex pivotRowPosition,
    CoinBigIndex pivotColumnPosition,
    CoinFactorizationDouble *COIN_RESTRICT work,
    CoinSimplexUnsignedInt *COIN_RESTRICT workArea2,
    CoinSimplexInt increment2,
    int *COIN_RESTRICT markRow);
  int pivot(CoinSimplexInt &pivotRow,
    CoinSimplexInt &pivotColumn,
    CoinBigIndex pivotRowPosition,
    CoinBigIndex pivotColumnPosition,
    int *COIN_RESTRICT markRow);
#if ABC_SMALL < 2
#define CONVERTROW 2
#elif ABC_SMALL < 4
#else
#undef ABC_DENSE_CODE
#define ABC_DENSE_CODE 0
#endif

protected:
  CoinSimplexInt *pivotColumnAddress_;
  CoinSimplexInt *permuteAddress_;
  CoinFactorizationDouble *pivotRegionAddress_;
  CoinFactorizationDouble *elementUAddress_;
  CoinSimplexInt *indexRowUAddress_;
  CoinSimplexInt *numberInColumnAddress_;
  CoinSimplexInt *numberInColumnPlusAddress_;
#ifdef ABC_USE_FUNCTION_POINTERS
  scatterStruct *scatterPointersUColumnAddress_;
  CoinFactorizationDouble *elementUColumnPlusAddress_;
#endif
  CoinBigIndex *startColumnUAddress_;
#if CONVERTROW
  CoinBigIndex *convertRowToColumnUAddress_;
#if CONVERTROW > 1
  CoinBigIndex *convertColumnToRowUAddress_;
#endif
#endif
#if ABC_SMALL < 2
  CoinFactorizationDouble *elementRowUAddress_;
#endif
  CoinBigIndex *startRowUAddress_;
  CoinSimplexInt *numberInRowAddress_;
  CoinSimplexInt *indexColumnUAddress_;
  CoinSimplexInt *firstCountAddress_;
  CoinSimplexInt *nextCountAddress_;
  CoinSimplexInt *lastCountAddress_;
  CoinSimplexInt *nextColumnAddress_;
  CoinSimplexInt *lastColumnAddress_;
  CoinSimplexInt *nextRowAddress_;
  CoinSimplexInt *lastRowAddress_;
  CoinSimplexInt *saveColumnAddress_;
  //CoinSimplexInt * saveColumnAddress2_;
  CoinCheckZero *markRowAddress_;
  CoinSimplexInt *listAddress_;
  CoinFactorizationDouble *elementLAddress_;
  CoinSimplexInt *indexRowLAddress_;
  CoinBigIndex *startColumnLAddress_;
#if ABC_SMALL < 2
  CoinBigIndex *startRowLAddress_;
#endif
  CoinSimplexInt *pivotLinkedBackwardsAddress_;
  CoinSimplexInt *pivotLinkedForwardsAddress_;
  CoinSimplexInt *pivotLOrderAddress_;
  CoinBigIndex *startColumnRAddress_;
  CoinFactorizationDouble *elementRAddress_;
  CoinSimplexInt *indexRowRAddress_;
  CoinSimplexInt *indexColumnLAddress_;
  CoinFactorizationDouble *elementByRowLAddress_;
#if ABC_SMALL < 4
  CoinFactorizationDouble *denseAreaAddress_;
#endif
  CoinFactorizationDouble *workAreaAddress_;
  CoinSimplexUnsignedInt *workArea2Address_;
  mutable CoinSimplexInt *sparseAddress_;
#ifdef SMALL_PERMUTE
  CoinSimplexInt *fromSmallToBigRow_;
  CoinSimplexInt *fromSmallToBigColumn_;
#endif
  CoinSimplexInt numberRowsExtra_;
  CoinSimplexInt maximumRowsExtra_;
  CoinSimplexInt numberRowsSmall_;
  CoinSimplexInt numberGoodL_;
  CoinSimplexInt numberRowsLeft_;
  CoinBigIndex totalElements_;
  CoinBigIndex firstZeroed_;
#if ABC_SMALL < 2
  CoinSimplexInt sparseThreshold_;
#endif
  CoinSimplexInt numberR_;
  CoinBigIndex lengthR_;
  CoinBigIndex lengthAreaR_;
  CoinBigIndex numberL_;
  CoinBigIndex baseL_;
  CoinBigIndex lengthL_;
  CoinBigIndex lengthAreaL_;
  CoinSimplexInt numberU_;
  CoinBigIndex maximumU_;
  CoinBigIndex lengthU_;
  CoinBigIndex lengthAreaU_;
  CoinBigIndex lastEntryByColumnU_;
#ifdef ABC_USE_FUNCTION_POINTERS
  CoinBigIndex lastEntryByColumnUPlus_;
  CoinBigIndex lengthAreaUPlus_;
#endif
  CoinBigIndex lastEntryByRowU_;
  CoinSimplexInt numberTrials_;
#if ABC_SMALL < 4
  CoinSimplexInt leadingDimension_;
#endif
#if COIN_BIG_DOUBLE == 1
  mutable CoinFactorizationLongDoubleArrayWithLength longArray_[FACTOR_CPU];
  mutable CoinIndexedVector *associatedVector_[FACTOR_CPU];
#endif
  CoinIntArrayWithLength pivotColumn_;
  CoinIntArrayWithLength permute_;
  CoinBigIndexArrayWithLength startRowU_;
  CoinIntArrayWithLength numberInRow_;
  CoinIntArrayWithLength numberInColumn_;
  CoinIntArrayWithLength numberInColumnPlus_;
  CoinIntArrayWithLength firstCount_;
  CoinIntArrayWithLength nextColumn_;
  CoinIntArrayWithLength lastColumn_;
  CoinIntArrayWithLength nextRow_;
  CoinIntArrayWithLength lastRow_;
  CoinIntArrayWithLength saveColumn_;
  CoinIntArrayWithLength markRow_;
  CoinIntArrayWithLength indexColumnU_;
  CoinFactorizationDoubleArrayWithLength pivotRegion_;
  CoinFactorizationDoubleArrayWithLength elementU_;
  CoinIntArrayWithLength indexRowU_;
  CoinBigIndexArrayWithLength startColumnU_;
#ifdef ABC_USE_FUNCTION_POINTERS
  CoinArbitraryArrayWithLength scatterUColumn_;
#endif
#if CONVERTROW
  CoinBigIndexArrayWithLength convertRowToColumnU_;
#if CONVERTROW > 1
  CoinBigIndexArrayWithLength convertColumnToRowU_;
#endif
#endif
#if ABC_SMALL < 2
  CoinFactorizationDoubleArrayWithLength elementRowU_;
#endif
  CoinFactorizationDoubleArrayWithLength elementL_;
  CoinIntArrayWithLength indexRowL_;
  CoinBigIndexArrayWithLength startColumnL_;
#if ABC_SMALL < 4
  CoinFactorizationDoubleArrayWithLength denseArea_;
#endif
  CoinFactorizationDoubleArrayWithLength workArea_;
  CoinUnsignedIntArrayWithLength workArea2_;
#if ABC_SMALL < 2
  CoinBigIndexArrayWithLength startRowL_;
  CoinIntArrayWithLength indexColumnL_;
  CoinFactorizationDoubleArrayWithLength elementByRowL_;
  mutable CoinIntArrayWithLength sparse_;
#endif
  CoinSimplexInt messageLevel_;
  CoinBigIndex numberCompressions_;
  // last slack pivot row
  CoinSimplexInt lastSlack_;
#if ABC_SMALL < 2
  mutable double ftranCountInput_;
  mutable double ftranCountAfterL_;
  mutable double ftranCountAfterR_;
  mutable double ftranCountAfterU_;
  double ftranAverageAfterL_;
  double ftranAverageAfterR_;
  double ftranAverageAfterU_;
#if FACTORIZATION_STATISTICS
  double ftranTwiddleFactor1_;
  double ftranTwiddleFactor2_;
#endif
  mutable CoinSimplexInt numberFtranCounts_;
#endif
  CoinSimplexInt maximumRows_;
#if ABC_SMALL < 2
  mutable double ftranFTCountInput_;
  mutable double ftranFTCountAfterL_;
  mutable double ftranFTCountAfterR_;
  mutable double ftranFTCountAfterU_;
  double ftranFTAverageAfterL_;
  double ftranFTAverageAfterR_;
  double ftranFTAverageAfterU_;
#if FACTORIZATION_STATISTICS
  double ftranFTTwiddleFactor1_;
  double ftranFTTwiddleFactor2_;
#endif
  mutable CoinSimplexInt numberFtranFTCounts_;
#endif
#if ABC_SMALL < 4
  CoinSimplexInt denseThreshold_;
#endif
#if ABC_SMALL < 2
  mutable double btranCountInput_;
  mutable double btranCountAfterU_;
  mutable double btranCountAfterR_;
  mutable double btranCountAfterL_;
  double btranAverageAfterU_;
  double btranAverageAfterR_;
  double btranAverageAfterL_;
#if FACTORIZATION_STATISTICS
  double btranTwiddleFactor1_;
  double btranTwiddleFactor2_;
#endif
  mutable CoinSimplexInt numberBtranCounts_;
#endif
  CoinSimplexInt maximumMaximumPivots_;
#if ABC_SMALL < 2
  mutable double ftranFullCountInput_;
  mutable double ftranFullCountAfterL_;
  mutable double ftranFullCountAfterR_;
  mutable double ftranFullCountAfterU_;
  double ftranFullAverageAfterL_;
  double ftranFullAverageAfterR_;
  double ftranFullAverageAfterU_;
#if FACTORIZATION_STATISTICS
  double ftranFullTwiddleFactor1_;
  double ftranFullTwiddleFactor2_;
#endif
  mutable CoinSimplexInt numberFtranFullCounts_;
#endif
  CoinSimplexInt initialNumberRows_;
#if ABC_SMALL < 2
  mutable double btranFullCountInput_;
  mutable double btranFullCountAfterL_;
  mutable double btranFullCountAfterR_;
  mutable double btranFullCountAfterU_;
  double btranFullAverageAfterL_;
  double btranFullAverageAfterR_;
  double btranFullAverageAfterU_;
#if FACTORIZATION_STATISTICS
  double btranFullTwiddleFactor1_;
  double btranFullTwiddleFactor2_;
#endif
  mutable CoinSimplexInt numberBtranFullCounts_;
#endif

  CoinSimplexInt state_;
  CoinBigIndex sizeSparseArray_;

public:
#if ABC_SMALL < 2
#if ABC_SMALL >= 0
  inline bool gotLCopy() const
  {
    return ((state_ & ABC_FAC_GOT_LCOPY) != 0);
  }
  inline void setNoGotLCopy() { state_ &= ~ABC_FAC_GOT_LCOPY; }
  inline void setYesGotLCopy() { state_ |= ABC_FAC_GOT_LCOPY; }
  inline bool gotRCopy() const { return ((state_ & ABC_FAC_GOT_RCOPY) != 0); }
  inline void setNoGotRCopy() { state_ &= ~ABC_FAC_GOT_RCOPY; }
  inline void setYesGotRCopy() { state_ |= ABC_FAC_GOT_RCOPY; }
  inline bool gotUCopy() const { return ((state_ & ABC_FAC_GOT_UCOPY) != 0); }
  inline void setNoGotUCopy() { state_ &= ~ABC_FAC_GOT_UCOPY; }
  inline void setYesGotUCopy() { state_ |= ABC_FAC_GOT_UCOPY; }
  inline bool gotSparse() const { return ((state_ & ABC_FAC_GOT_SPARSE) != 0); }
  inline void setNoGotSparse() { state_ &= ~ABC_FAC_GOT_SPARSE; }
  inline void setYesGotSparse() { state_ |= ABC_FAC_GOT_SPARSE; }
#else
  // force use of copies
  inline bool gotLCopy() const { return true; }
  inline void setNoGotLCopy() {}
  inline void setYesGotLCopy() {}
  inline bool gotRCopy() const { return true; }
  inline void setNoGotRCopy() {}
  inline void setYesGotRCopy() {}
  inline bool gotUCopy() const { return true; }
  inline void setNoGotUCopy() {}
  inline void setYesGotUCopy() {}
  inline bool gotSparse() const { return true; }
  inline void setNoGotSparse() {}
  inline void setYesGotSparse() {}
#endif
#else
  // force no use of copies
  inline bool gotLCopy() const { return false; }
  inline void setNoGotLCopy() {}
  inline void setYesGotLCopy() {}
  inline bool gotRCopy() const { return false; }
  inline void setNoGotRCopy() {}
  inline void setYesGotRCopy() {}
  inline bool gotUCopy() const { return false; }
  inline void setNoGotUCopy() {}
  inline void setYesGotUCopy() {}
  inline bool gotSparse() const { return false; }
  inline void setNoGotSparse() {}
  inline void setYesGotSparse() {}
#endif

  //CoinSimplexInt persistenceFlag_;
};

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