CoinAbcBaseFactorization.hpp

Go to the documentation of this file.

/* $Id: CoinAbcBaseFactorization.hpp 1910 2013-01-27 02:00:13Z stefan $ */
// 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_;
};