CoinFactorization.hpp

// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.

/* 
   Authors
   
   John Forrest

 */
#ifndef CoinFactorization_H
#define CoinFactorization_H

#include <iostream>
#include <string>

class CoinPackedMatrix;
class CoinIndexedVector;
#ifndef COIN_BIG_INDEX
typedef int CoinBigIndex;
#else
typedef long CoinBigIndex;
#endif


class CoinFactorization {
   friend void CoinFactorizationUnitTest( const std::string & mpsDir );

public:


    CoinFactorization (  );
  CoinFactorization ( const CoinFactorization &other);

   ~CoinFactorization (  );
  void show_self (  ) const;
  void sort (  ) const;
    CoinFactorization & operator = ( const CoinFactorization & other );

  int factorize ( const CoinPackedMatrix & matrix, 
                  int rowIsBasic[], int columnIsBasic[] , 
                  double areaFactor = 0.0 );
  int factorize ( int numberRows,
                  int numberColumns,
                  CoinBigIndex numberElements,
                  CoinBigIndex maximumL,
                  CoinBigIndex maximumU,
                  const int indicesRow[],
                  const int indicesColumn[], const double elements[] ,
                  int permutation[],
                  double areaFactor = 0.0);
  int factorizePart1 ( int numberRows,
                       int numberColumns,
                       CoinBigIndex estimateNumberElements,
                       int * indicesRow[],
                       int * indicesColumn[],
                       double * elements[],
                  double areaFactor = 0.0);
  int factorizePart2 (int permutation[],int exactNumberElements);


  inline int status (  ) const {
    return status_;
  };
  inline int pivots (  ) const {
    return numberPivots_;
  };
  inline int *permute (  ) const {
    return permute_;
  };
  inline int *pivotColumn (  ) const {
    return pivotColumn_;
  };
  inline int *permuteBack (  ) const {
    return permuteBack_;
  };
  inline int *pivotColumnBack (  ) const {
    return pivotColumnBack_;
  };
  inline int numberRowsExtra (  ) const {
    return numberRowsExtra_;
  };
  inline int numberRows (  ) const {
    return numberRows_;
  };
  inline int maximumRowsExtra (  ) const {
    return maximumRowsExtra_;
  };
  inline int numberColumns (  ) const {
    return numberColumns_;
  };
  inline int numberElements (  ) const {
    return totalElements_;
  };
  inline int numberForrestTomlin (  ) const {
    return numberInColumn_[numberColumnsExtra_];
  };
  inline int numberGoodColumns (  ) const {
    return numberGoodU_;
  };
  inline double areaFactor (  ) const {
    return areaFactor_;
  };
  inline void areaFactor ( double value ) {
    areaFactor_=value;
  };
  inline void relaxAccuracyCheck(double value)
  { relaxCheck_ = value;};
  inline double getAccuracyCheck() const
  { return relaxCheck_;};
  inline bool increasingRows (  ) const 
  { return true; };
  inline void increasingRows ( int value  ) {};
  inline int messageLevel (  ) const {
    return messageLevel_ ;
  };
  void messageLevel (  int value );
  inline int maximumPivots (  ) const {
    return maximumPivots_ ;
  };
  void maximumPivots (  int value );

  inline int denseThreshold() const 
    { return denseThreshold_;};
  inline void setDenseThreshold(int value)
    { denseThreshold_ = value;};
  inline double pivotTolerance (  ) const {
    return pivotTolerance_ ;
  };
  void pivotTolerance (  double value );
  inline double zeroTolerance (  ) const {
    return zeroTolerance_ ;
  };
  void zeroTolerance (  double value );
  inline double slackValue (  ) const {
    return slackValue_ ;
  };
  void slackValue (  double value );
  double maximumCoefficient() const;


  inline CoinBigIndex numberElementsU (  ) const {
    return lengthU_;
  };
  inline CoinBigIndex lengthAreaU (  ) const {
    return lengthAreaU_;
  };
  inline CoinBigIndex numberElementsL (  ) const {
    return lengthL_;
  };
  inline CoinBigIndex lengthAreaL (  ) const {
    return lengthAreaL_;
  };
  inline CoinBigIndex numberCompressions() const
  { return numberCompressions_;};
  inline int biasLU() const
  { return biasLU_;};
  inline void setBiasLU(int value)
  { biasLU_=value;};


  int replaceColumn ( CoinIndexedVector * regionSparse,
                      int pivotRow,
                      double pivotCheck ,
                      bool checkBeforeModifying=false);

  int updateColumnFT ( CoinIndexedVector * regionSparse,
                       CoinIndexedVector * regionSparse2);
  int updateColumn ( CoinIndexedVector * regionSparse,
                     CoinIndexedVector * regionSparse2,
                     bool noPermute=false) const;
  int updateColumnTranspose ( CoinIndexedVector * regionSparse,
                              CoinIndexedVector * regionSparse2) const;
  void goSparse();
  int sparseThreshold ( ) const;
  void sparseThreshold ( int value );
  void getWeights(int * weights) const;



  inline void clearArrays()
  { gutsOfDestructor();};


  int add ( CoinBigIndex numberElements,
               int indicesRow[],
               int indicesColumn[], double elements[] );

  int addColumn ( CoinBigIndex numberElements,
                     int indicesRow[], double elements[] );

  int addRow ( CoinBigIndex numberElements,
                  int indicesColumn[], double elements[] );

  int deleteColumn ( int Row );
  int deleteRow ( int Row );

  int replaceRow ( int whichRow, int numberElements,
                      const int indicesColumn[], const double elements[] );
  void emptyRows(int numberToEmpty, const int which[]);
protected:


  void getAreas ( int numberRows,
                  int numberColumns,
                  CoinBigIndex maximumL,
                  CoinBigIndex maximumU );

  void preProcess ( int state,
                    int possibleDuplicates = -1 );
  int factor (  );
  int factorSparse (  );
  int factorDense (  );

  bool pivotOneOtherRow ( int pivotRow,
                          int pivotColumn );
  bool pivotRowSingleton ( int pivotRow,
                           int pivotColumn );
  bool pivotColumnSingleton ( int pivotRow,
                              int pivotColumn );

  bool getColumnSpace ( int iColumn,
                        int extraNeeded );

  bool getColumnSpaceIterateR ( int iColumn, double value,
                               int iRow);
  CoinBigIndex getColumnSpaceIterate ( int iColumn, double value,
                               int iRow);
  bool getRowSpace ( int iRow, int extraNeeded );

  bool getRowSpaceIterate ( int iRow,
                            int extraNeeded );
  void checkConsistency (  );
  inline void addLink ( int index, int count ) {
    int next = firstCount_[count];
      lastCount_[index] = -2 - count;
    if ( next < 0 ) {
      //first with that count
      firstCount_[count] = index;
      nextCount_[index] = -1;
    } else {
      firstCount_[count] = index;
      nextCount_[index] = next;
      lastCount_[next] = index;
  }};
  inline void deleteLink ( int index ) {
    int next = nextCount_[index];
    int last = lastCount_[index];
    if ( last >= 0 ) {
      nextCount_[last] = next;
    } else {
      int count = -last - 2;

      firstCount_[count] = next;
    }
    if ( next >= 0 ) {
      lastCount_[next] = last;
    }
    nextCount_[index] = -2;
    lastCount_[index] = -2;
    return;
  };
  void separateLinks(int count,bool rowsFirst);
  void cleanup (  );

  void updateColumnL ( CoinIndexedVector * region, int * indexIn ) const;
  void updateColumnLDensish ( CoinIndexedVector * region, int * indexIn ) const;
  void updateColumnLSparse ( CoinIndexedVector * region, int * indexIn ) const;
  void updateColumnLSparsish ( CoinIndexedVector * region, int * indexIn ) const;

  void updateColumnR ( CoinIndexedVector * region ) const;
  void updateColumnRFT ( CoinIndexedVector * region, int * indexIn );

  void updateColumnU ( CoinIndexedVector * region, int * indexIn) const;

  void updateColumnUSparse ( CoinIndexedVector * regionSparse, 
                             int * indexIn) const;
  void updateColumnUSparsish ( CoinIndexedVector * regionSparse, 
                               int * indexIn) const;
  void updateColumnUDensish ( CoinIndexedVector * regionSparse, 
                              int * indexIn) const;
  void permuteBack ( CoinIndexedVector * regionSparse, 
                     CoinIndexedVector * outVector) const;

  void updateColumnTransposeU ( CoinIndexedVector * region,
                                int smallestIndex) const;
  void updateColumnTransposeUSparsish ( CoinIndexedVector * region,
                                        int smallestIndex) const;
  void updateColumnTransposeUDensish ( CoinIndexedVector * region,
                                       int smallestIndex) const;
  void updateColumnTransposeUSparse ( CoinIndexedVector * region) const;

  void updateColumnTransposeR ( CoinIndexedVector * region ) const;
  void updateColumnTransposeRDensish ( CoinIndexedVector * region ) const;
  void updateColumnTransposeRSparse ( CoinIndexedVector * region ) const;

  void updateColumnTransposeL ( CoinIndexedVector * region ) const;
  void updateColumnTransposeLDensish ( CoinIndexedVector * region ) const;
  void updateColumnTransposeLByRow ( CoinIndexedVector * region ) const;
  void updateColumnTransposeLSparsish ( CoinIndexedVector * region ) const;
  void updateColumnTransposeLSparse ( CoinIndexedVector * region ) const;

  int checkPivot(double saveFromU, double oldPivot) const;
  void gutsOfDestructor();
  void gutsOfInitialize(int type);
  void gutsOfCopy(const CoinFactorization &other);

  void resetStatistics();

  /********************************* START LARGE TEMPLATE ********/
#ifdef INT_IS_8
#define COINFACTORIZATION_BITS_PER_INT 64
#define COINFACTORIZATION_SHIFT_PER_INT 6
#define COINFACTORIZATION_MASK_PER_INT 0x3f
#else
#define COINFACTORIZATION_BITS_PER_INT 32
#define COINFACTORIZATION_SHIFT_PER_INT 5
#define COINFACTORIZATION_MASK_PER_INT 0x1f
#endif
  template <class T>  bool
  pivot ( int pivotRow,
          int pivotColumn,
          int pivotRowPosition,
          int pivotColumnPosition,
          double work[],
          unsigned int workArea2[],
          int increment,
          int increment2,
          T markRow[] ,
          int largeInteger)
{
  int *indexColumnU = indexColumnU_;
  CoinBigIndex *startColumnU = startColumnU_;
  int *numberInColumn = numberInColumn_;
  double *elementU = elementU_;
  int *indexRowU = indexRowU_;
  CoinBigIndex *startRowU = startRowU_;
  int *numberInRow = numberInRow_;
  double *elementL = elementL_;
  int *indexRowL = indexRowL_;
  int *saveColumn = saveColumn_;
  int *nextRow = nextRow_;
  int *lastRow = lastRow_;

  //store pivot columns (so can easily compress)
  int numberInPivotRow = numberInRow[pivotRow] - 1;
  CoinBigIndex startColumn = startColumnU[pivotColumn];
  int numberInPivotColumn = numberInColumn[pivotColumn] - 1;
  CoinBigIndex endColumn = startColumn + numberInPivotColumn + 1;
  int put = 0;
  CoinBigIndex startRow = startRowU[pivotRow];
  CoinBigIndex endRow = startRow + numberInPivotRow + 1;

  if ( pivotColumnPosition < 0 ) {
    CoinBigIndex i;
    for ( i = startRow; i < endRow; i++ ) {
      int iColumn = indexColumnU[i];

      if ( iColumn != pivotColumn ) {
        saveColumn[put] = iColumn;
        put++;
      } else {
        pivotColumnPosition = i;
      }
    }
  } else {
    CoinBigIndex i;

    for ( i = startRow; i < pivotColumnPosition; i++ ) {
      int iColumn = indexColumnU[i];

      saveColumn[put] = iColumn;
      put++;
    }
    for ( i = pivotColumnPosition + 1; i < endRow; i++ ) {
      int iColumn = indexColumnU[i];

      saveColumn[put] = iColumn;
      put++;
    }
  }
  //take out this bit of indexColumnU
  int next = nextRow[pivotRow];
  int last = lastRow[pivotRow];

  nextRow[last] = next;
  lastRow[next] = last;
  nextRow[pivotRow] = numberGoodU_;     //use for permute
  lastRow[pivotRow] = -2;
  numberInRow[pivotRow] = 0;
  //store column in L, compress in U and take column out
  CoinBigIndex l = lengthL_;

  if ( l + numberInPivotColumn > lengthAreaL_ ) {
    //need more memory
    std::cout << "more memory needed in middle of invert" << std::endl;
    return false;
  }
  //l+=currentAreaL_->elementByColumn-elementL;
  CoinBigIndex lSave = l;

  pivotRowL_[numberGoodL_] = pivotRow;
  startColumnL_[numberGoodL_] = l;      //for luck and first time
  numberGoodL_++;
  startColumnL_[numberGoodL_] = l + numberInPivotColumn;
  lengthL_ += numberInPivotColumn;
  if ( pivotRowPosition < 0 ) {
    CoinBigIndex i;
    for ( i = startColumn; i < endColumn; i++ ) {
      int iRow = indexRowU[i];
      if ( iRow != pivotRow ) {
        indexRowL[l] = iRow;
        elementL[l] = elementU[i];
        markRow[iRow] = l - lSave;
        l++;
        //take out of row list
        CoinBigIndex start = startRowU[iRow];
        CoinBigIndex end = start + numberInRow[iRow];
        CoinBigIndex where = start;

        while ( indexColumnU[where] != pivotColumn ) {
          where++;
        }                       /* endwhile */
#if DEBUG_COIN
        if ( where >= end ) {
          abort (  );
        }
#endif
        indexColumnU[where] = indexColumnU[end - 1];
        numberInRow[iRow]--;
      } else {
        pivotRowPosition = i;
      }
    }
  } else {
    CoinBigIndex i;

    for ( i = startColumn; i < pivotRowPosition; i++ ) {
      int iRow = indexRowU[i];

      markRow[iRow] = l - lSave;
      indexRowL[l] = iRow;
      elementL[l] = elementU[i];
      l++;
      //take out of row list
      CoinBigIndex start = startRowU[iRow];
      CoinBigIndex end = start + numberInRow[iRow];
      CoinBigIndex where = start;

      while ( indexColumnU[where] != pivotColumn ) {
        where++;
      }                         /* endwhile */
#if DEBUG_COIN
      if ( where >= end ) {
        abort (  );
      }
#endif
      indexColumnU[where] = indexColumnU[end - 1];
      numberInRow[iRow]--;
      assert (numberInRow[iRow]>=0);
    }
    for ( i = pivotRowPosition + 1; i < endColumn; i++ ) {
      int iRow = indexRowU[i];

      markRow[iRow] = l - lSave;
      indexRowL[l] = iRow;
      elementL[l] = elementU[i];
      l++;
      //take out of row list
      CoinBigIndex start = startRowU[iRow];
      CoinBigIndex end = start + numberInRow[iRow];
      CoinBigIndex where = start;

      while ( indexColumnU[where] != pivotColumn ) {
        where++;
      }                         /* endwhile */
#if DEBUG_COIN
      if ( where >= end ) {
        abort (  );
      }
#endif
      indexColumnU[where] = indexColumnU[end - 1];
      numberInRow[iRow]--;
      assert (numberInRow[iRow]>=0);
    }
  }
  markRow[pivotRow] = largeInteger;
  //compress pivot column (move pivot to front including saved)
  double pivotElement = elementU[pivotRowPosition];
  double pivotMultiplier = 1.0 / pivotElement;

  pivotRegion_[numberGoodU_] = pivotMultiplier;
  numberInColumn[pivotColumn] = 0;
  //use end of L for temporary space
  int *indexL = &indexRowL[lSave];
  double *multipliersL = &elementL[lSave];

  //adjust
  int j;

  for ( j = 0; j < numberInPivotColumn; j++ ) {
    multipliersL[j] = pivotMultiplier * multipliersL[j];
  }
  //zero out fill
  CoinBigIndex iErase;
  for ( iErase = 0; iErase < increment2 * numberInPivotRow;
        iErase++ ) {
    workArea2[iErase] = 0;
  }
  CoinBigIndex added = numberInPivotRow * numberInPivotColumn;
  unsigned int *temp2 = workArea2;

  //pack down and move to work
  int jColumn;
  for ( jColumn = 0; jColumn < numberInPivotRow; jColumn++ ) {
    int iColumn = saveColumn[jColumn];
    CoinBigIndex startColumn = startColumnU[iColumn];
    CoinBigIndex endColumn = startColumn + numberInColumn[iColumn];
    int iRow = indexRowU[startColumn];
    double value = elementU[startColumn];
    double largest;
    CoinBigIndex put = startColumn;
    CoinBigIndex positionLargest = -1;
    double thisPivotValue = 0.0;

    //compress column and find largest not updated
    bool checkLargest;
    int mark = markRow[iRow];

    if ( mark < 0 ) {
      largest = fabs ( value );
      positionLargest = put;
      put++;
      checkLargest = false;
    } else {
      //need to find largest
      largest = 0.0;
      checkLargest = true;
      if ( mark != largeInteger ) {
        //will be updated
        work[mark] = value;
        int word = mark >> COINFACTORIZATION_SHIFT_PER_INT;
        int bit = mark & COINFACTORIZATION_MASK_PER_INT;

        temp2[word] = temp2[word] | ( 1 << bit );       //say already in counts
        added--;
      } else {
        thisPivotValue = value;
      }
    }
    CoinBigIndex i;
    for ( i = startColumn + 1; i < endColumn; i++ ) {
      iRow = indexRowU[i];
      value = elementU[i];
      int mark = markRow[iRow];

      if ( mark < 0 ) {
        //keep
        indexRowU[put] = iRow;
        elementU[put] = value;;
        if ( checkLargest ) {
          double absValue = fabs ( value );

          if ( absValue > largest ) {
            largest = absValue;
            positionLargest = put;
          }
        }
        put++;
      } else if ( mark != largeInteger ) {
        //will be updated
        work[mark] = value;;
        int word = mark >> COINFACTORIZATION_SHIFT_PER_INT;
        int bit = mark & COINFACTORIZATION_MASK_PER_INT;

        temp2[word] = temp2[word] | ( 1 << bit );       //say already in counts
        added--;
      } else {
        thisPivotValue = value;
      }
    }
    //slot in pivot
    elementU[put] = elementU[startColumn];
    indexRowU[put] = indexRowU[startColumn];
    if ( positionLargest == startColumn ) {
      positionLargest = put;    //follow if was largest
    }
    put++;
    elementU[startColumn] = thisPivotValue;
    indexRowU[startColumn] = pivotRow;
    //clean up counts
    startColumn++;
    numberInColumn[iColumn] = put - startColumn;
    numberInColumnPlus_[iColumn]++;
    startColumnU[iColumn]++;
    //how much space have we got
    int next = nextColumn_[iColumn];
    CoinBigIndex space;

    space = startColumnU[next] - put - numberInColumnPlus_[next];
    //assume no zero elements
    if ( numberInPivotColumn > space ) {
      //getColumnSpace also moves fixed part
      if ( !getColumnSpace ( iColumn, numberInPivotColumn ) ) {
        return false;
      }
      //redo starts
      positionLargest = positionLargest + startColumnU[iColumn] - startColumn;
      startColumn = startColumnU[iColumn];
      put = startColumn + numberInColumn[iColumn];
    }
    double tolerance = zeroTolerance_;

    for ( j = 0; j < numberInPivotColumn; j++ ) {
      value = work[j] - thisPivotValue * multipliersL[j];
      double absValue = fabs ( value );

      if ( absValue > tolerance ) {
        work[j] = 0.0;
        elementU[put] = value;
        indexRowU[put] = indexL[j];
        if ( absValue > largest ) {
          largest = absValue;
          positionLargest = put;
        }
        put++;
      } else {
        work[j] = 0.0;
        added--;
        int word = j >> COINFACTORIZATION_SHIFT_PER_INT;
        int bit = j & COINFACTORIZATION_MASK_PER_INT;

        if ( temp2[word] & ( 1 << bit ) ) {
          //take out of row list
          iRow = indexL[j];
          CoinBigIndex start = startRowU[iRow];
          CoinBigIndex end = start + numberInRow[iRow];
          CoinBigIndex where = start;

          while ( indexColumnU[where] != iColumn ) {
            where++;
          }                     /* endwhile */
#if DEBUG_COIN
          if ( where >= end ) {
            abort (  );
          }
#endif
          indexColumnU[where] = indexColumnU[end - 1];
          numberInRow[iRow]--;
        } else {
          //make sure won't be added
          int word = j >> COINFACTORIZATION_SHIFT_PER_INT;
          int bit = j & COINFACTORIZATION_MASK_PER_INT;

          temp2[word] = temp2[word] | ( 1 << bit );     //say already in counts
        }
      }
    }
    numberInColumn[iColumn] = put - startColumn;
    //move largest
    if ( positionLargest >= 0 ) {
      value = elementU[positionLargest];
      iRow = indexRowU[positionLargest];
      elementU[positionLargest] = elementU[startColumn];
      indexRowU[positionLargest] = indexRowU[startColumn];
      elementU[startColumn] = value;
      indexRowU[startColumn] = iRow;
    }
    //linked list for column
    if ( nextCount_[iColumn + numberRows_] != -2 ) {
      //modify linked list
      deleteLink ( iColumn + numberRows_ );
      addLink ( iColumn + numberRows_, numberInColumn[iColumn] );
    }
    temp2 += increment2;
  }
  //get space for row list
  unsigned int *putBase = workArea2;
  int bigLoops = numberInPivotColumn >> COINFACTORIZATION_SHIFT_PER_INT;
  int i = 0;

  // do linked lists and update counts
  while ( bigLoops ) {
    bigLoops--;
    int bit;
    for ( bit = 0; bit < COINFACTORIZATION_BITS_PER_INT; i++, bit++ ) {
      unsigned int *putThis = putBase;
      int iRow = indexL[i];

      //get space
      int number = 0;
      int jColumn;

      for ( jColumn = 0; jColumn < numberInPivotRow; jColumn++ ) {
        unsigned int test = *putThis;

        putThis += increment2;
        test = 1 - ( ( test >> bit ) & 1 );
        number += test;
      }
      int next = nextRow[iRow];
      CoinBigIndex space;

      space = startRowU[next] - startRowU[iRow];
      number += numberInRow[iRow];
      if ( space < number ) {
        if ( !getRowSpace ( iRow, number ) ) {
          return false;
        }
      }
      // now do
      putThis = putBase;
      next = nextRow[iRow];
      number = numberInRow[iRow];
      CoinBigIndex end = startRowU[iRow] + number;
      int saveIndex = indexColumnU[startRowU[next]];

      //add in
      for ( jColumn = 0; jColumn < numberInPivotRow; jColumn++ ) {
        unsigned int test = *putThis;

        putThis += increment2;
        test = 1 - ( ( test >> bit ) & 1 );
        indexColumnU[end] = saveColumn[jColumn];
        end += test;
      }
      //put back next one in case zapped
      indexColumnU[startRowU[next]] = saveIndex;
      markRow[iRow] = -1;
      number = end - startRowU[iRow];
      numberInRow[iRow] = number;
      deleteLink ( iRow );
      addLink ( iRow, number );
    }
    putBase++;
  }                             /* endwhile */
  int bit;

  for ( bit = 0; i < numberInPivotColumn; i++, bit++ ) {
    unsigned int *putThis = putBase;
    int iRow = indexL[i];

    //get space
    int number = 0;
    int jColumn;

    for ( jColumn = 0; jColumn < numberInPivotRow; jColumn++ ) {
      unsigned int test = *putThis;

      putThis += increment2;
      test = 1 - ( ( test >> bit ) & 1 );
      number += test;
    }
    int next = nextRow[iRow];
    CoinBigIndex space;

    space = startRowU[next] - startRowU[iRow];
    number += numberInRow[iRow];
    if ( space < number ) {
      if ( !getRowSpace ( iRow, number ) ) {
        return false;
      }
    }
    // now do
    putThis = putBase;
    next = nextRow[iRow];
    number = numberInRow[iRow];
    CoinBigIndex end = startRowU[iRow] + number;
    int saveIndex;

    saveIndex = indexColumnU[startRowU[next]];

    //add in
    for ( jColumn = 0; jColumn < numberInPivotRow; jColumn++ ) {
      unsigned int test = *putThis;

      putThis += increment2;
      test = 1 - ( ( test >> bit ) & 1 );

      indexColumnU[end] = saveColumn[jColumn];
      end += test;
    }
    indexColumnU[startRowU[next]] = saveIndex;
    markRow[iRow] = -1;
    number = end - startRowU[iRow];
    numberInRow[iRow] = number;
    deleteLink ( iRow );
    addLink ( iRow, number );
  }
  markRow[pivotRow] = -1;
  //modify linked list for pivots
  deleteLink ( pivotRow );
  deleteLink ( pivotColumn + numberRows_ );
  totalElements_ += added;
  return true;
}

  /********************************* END LARGE TEMPLATE ********/

protected:


  double pivotTolerance_;
  double zeroTolerance_;
  double slackValue_;
  double areaFactor_;
  double relaxCheck_;
  int numberRows_;
  int numberRowsExtra_;
  int maximumRowsExtra_;
  int numberColumns_;
  int numberColumnsExtra_;
  int maximumColumnsExtra_;
  int numberGoodU_;
  int numberGoodL_;
  int maximumPivots_;
  int numberPivots_;
  CoinBigIndex totalElements_;
  CoinBigIndex factorElements_;
  int *pivotColumn_;
  int *permute_;
  int *permuteBack_;
  int *pivotColumnBack_;
  int status_;

  //int increasingRows_;

  int messageLevel_;

  int numberTrials_;
  CoinBigIndex *startRowU_;

  int *numberInRow_;

  int *numberInColumn_;

  int *numberInColumnPlus_;

  int *firstCount_;

  int *nextCount_;

  int *lastCount_;

  int *nextColumn_;

  int *lastColumn_;

  int *nextRow_;

  int *lastRow_;

  int *saveColumn_;

  int *markRow_;

  int biggerDimension_;

  int *indexColumnU_;

  int *pivotRowL_;

  double *pivotRegion_;

  int numberSlacks_;

  int numberU_;

  //int baseU_;

  CoinBigIndex lengthU_;

  CoinBigIndex lengthAreaU_;

  double *elementU_;

  int *indexRowU_;

  CoinBigIndex *startColumnU_;

  CoinBigIndex *convertRowToColumnU_;

  int numberL_;

  int baseL_;

  CoinBigIndex lengthL_;

  CoinBigIndex lengthAreaL_;

  double *elementL_;

  int *indexRowL_;

  CoinBigIndex *startColumnL_;

  int numberR_;

  CoinBigIndex lengthR_;

  CoinBigIndex lengthAreaR_;

  double *elementR_;

  int *indexRowR_;

  CoinBigIndex *startColumnR_;

  double  * denseArea_;

  int * densePermute_;

  int numberDense_;

  int denseThreshold_;

  CoinBigIndex numberCompressions_;

  bool doForrestTomlin_;

  mutable bool collectStatistics_;

  mutable double ftranCountInput_;
  mutable double ftranCountAfterL_;
  mutable double ftranCountAfterR_;
  mutable double ftranCountAfterU_;
  mutable double btranCountInput_;
  mutable double btranCountAfterU_;
  mutable double btranCountAfterR_;
  mutable double btranCountAfterL_;

  mutable int numberFtranCounts_;
  mutable int numberBtranCounts_;

  double ftranAverageAfterL_;
  double ftranAverageAfterR_;
  double ftranAverageAfterU_;
  double btranAverageAfterU_;
  double btranAverageAfterR_;
  double btranAverageAfterL_;

  int sparseThreshold_;

  int sparseThreshold2_;

  CoinBigIndex * startRowL_;

  int * indexColumnL_;

  double * elementByRowL_;

  mutable int * sparse_;
  int biasLU_;
};
// Dense coding
#ifdef COIN_USE_DENSE
#define DENSE_CODE 1
#endif
#endif

---