casadi 3.7.2__cp314-none-win_amd64.whl

casadi/include/coin/CoinFactorization.hpp

@@ -0,0 +1,2178 @@
+/* $Id$ */
+// Copyright (C) 2002, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+/* 
+   Authors
+   
+   John Forrest
+
+ */
+#ifndef CoinFactorization_H
+#define CoinFactorization_H
+#define EXTRA_U_SPACE 4
+//#define COIN_ONE_ETA_COPY 100
+
+#include <iostream>
+#include <string>
+#include <cassert>
+#include <cstdio>
+#include <cmath>
+#include "CoinTypes.hpp"
+#include "CoinIndexedVector.hpp"
+
+class CoinPackedMatrix;
+/** This deals with Factorization and Updates
+
+    This class started with a parallel simplex code I was writing in the
+    mid 90's.  The need for parallelism led to many complications and
+    I have simplified as much as I could to get back to this.
+
+    I was aiming at problems where I might get speed-up so I was looking at dense
+    problems or ones with structure.  This led to permuting input and output
+    vectors and to increasing the number of rows each rank-one update.  This is 
+    still in as a minor overhead.
+
+    I have also put in handling for hyper-sparsity.  I have taken out
+    all outer loop unrolling, dense matrix handling and most of the
+    book-keeping for slacks.  Also I always use FTRAN approach to updating
+    even if factorization fairly dense.  All these could improve performance.
+
+    I blame some of the coding peculiarities on the history of the code
+    but mostly it is just because I can't do elegant code (or useful
+    comments).
+
+    I am assuming that 32 bits is enough for number of rows or columns, but CoinBigIndex
+    may be redefined to get 64 bits.
+ */
+
+class CoinFactorization {
+  friend void CoinFactorizationUnitTest(const std::string &mpsDir);
+
+public:
+  /**@name Constructors and destructor and copy */
+  //@{
+  /// Default constructor
+  CoinFactorization();
+  /// Copy constructor
+  CoinFactorization(const CoinFactorization &other);
+
+  /// Destructor
+  ~CoinFactorization();
+  /// Delete all stuff (leaves as after CoinFactorization())
+  void almostDestructor();
+  /// Debug show object (shows one representation)
+  void show_self() const;
+  /// Debug - save on file - 0 if no error
+  int saveFactorization(const char *file) const;
+  /** Debug - restore from file - 0 if no error on file.
+      If factor true then factorizes as if called from ClpFactorization
+  */
+  int restoreFactorization(const char *file, bool factor = false);
+  /// Debug - sort so can compare
+  void sort() const;
+  /// = copy
+  CoinFactorization &operator=(const CoinFactorization &other);
+  //@}
+
+  /**@name Do factorization */
+  //@{
+  /** When part of LP - given by basic variables.
+  Actually does factorization.
+  Arrays passed in have non negative value to say basic.
+  If status is okay, basic variables have pivot row - this is only needed
+  If status is singular, then basic variables have pivot row
+  and ones thrown out have -1
+  returns 0 -okay, -1 singular, -2 too many in basis, -99 memory */
+  int factorize(const CoinPackedMatrix &matrix,
+    int rowIsBasic[], int columnIsBasic[],
+    double areaFactor = 0.0);
+  /** When given as triplets.
+  Actually does factorization.  maximumL is guessed maximum size of L part of
+  final factorization, maximumU of U part.  These are multiplied by
+  areaFactor which can be computed by user or internally.  
+  Arrays are copied in.  I could add flag to delete arrays to save a 
+  bit of memory.
+  If status okay, permutation has pivot rows - this is only needed
+  If status is singular, then basic variables have pivot row
+  and ones thrown out have -1
+  returns 0 -okay, -1 singular, -99 memory */
+  int factorize(int numberRows,
+    int numberColumns,
+    int numberElements,
+    int maximumL,
+    int maximumU,
+    const int indicesRow[],
+    const int indicesColumn[], const double elements[],
+    int permutation[],
+    double areaFactor = 0.0);
+  /** Two part version for maximum flexibility
+      This part creates arrays for user to fill.
+      estimateNumberElements is safe estimate of number
+      returns 0 -okay, -99 memory */
+  int factorizePart1(int numberRows,
+    int numberColumns,
+    int estimateNumberElements,
+    int *indicesRow[],
+    int *indicesColumn[],
+    CoinFactorizationDouble *elements[],
+    double areaFactor = 0.0);
+  /** This is part two of factorization
+      Arrays belong to factorization and were returned by part 1
+      If status okay, permutation has pivot rows - this is only needed
+      If status is singular, then basic variables have pivot row
+      and ones thrown out have -1
+      returns 0 -okay, -1 singular, -99 memory */
+  int factorizePart2(int permutation[], int exactNumberElements);
+  /// Condition number - product of pivots after factorization
+  double conditionNumber() const;
+
+  //@}
+
+  /**@name general stuff such as permutation or status */
+  //@{
+  /// Returns status
+  inline int status() const
+  {
+    return status_;
+  }
+  /// Sets status
+  inline void setStatus(int value)
+  {
+    status_ = value;
+  }
+  /// Returns number of pivots since factorization
+  inline int pivots() const
+  {
+    return numberPivots_;
+  }
+  /// Sets number of pivots since factorization
+  inline void setPivots(int value)
+  {
+    numberPivots_ = value;
+  }
+  /// Returns address of permute region
+  inline int *permute() const
+  {
+    return permute_.array();
+  }
+  /// Returns address of pivotColumn region (also used for permuting)
+  inline int *pivotColumn() const
+  {
+    return pivotColumn_.array();
+  }
+  /// Returns address of pivot region
+  inline CoinFactorizationDouble *pivotRegion() const
+  {
+    return pivotRegion_.array();
+  }
+  /// Returns address of permuteBack region
+  inline int *permuteBack() const
+  {
+    return permuteBack_.array();
+  }
+  /// Returns address of lastRow region
+  inline int *lastRow() const
+  {
+    return lastRow_.array();
+  }
+  /** Returns address of pivotColumnBack region (also used for permuting)
+      Now uses firstCount to save memory allocation */
+  inline int *pivotColumnBack() const
+  {
+    //return firstCount_.array();
+    return pivotColumnBack_.array();
+  }
+  /// Start of each row in L
+  inline int *startRowL() const
+  {
+    return startRowL_.array();
+  }
+
+  /// Start of each column in L
+  inline int *startColumnL() const
+  {
+    return startColumnL_.array();
+  }
+
+  /// Index of column in row for L
+  inline int *indexColumnL() const
+  {
+    return indexColumnL_.array();
+  }
+
+  /// Row indices of L
+  inline int *indexRowL() const
+  {
+    return indexRowL_.array();
+  }
+
+  /// Elements in L (row copy)
+  inline CoinFactorizationDouble *elementByRowL() const
+  {
+    return elementByRowL_.array();
+  }
+
+  /// Number of Rows after iterating
+  inline int numberRowsExtra() const
+  {
+    return numberRowsExtra_;
+  }
+  /// Set number of Rows after factorization
+  inline void setNumberRows(int value)
+  {
+    numberRows_ = value;
+  }
+  /// Number of Rows after factorization
+  inline int numberRows() const
+  {
+    return numberRows_;
+  }
+  /// Number in L
+  inline int numberL() const
+  {
+    return numberL_;
+  }
+
+  /// Base of L
+  inline int baseL() const
+  {
+    return baseL_;
+  }
+  /// Maximum of Rows after iterating
+  inline int maximumRowsExtra() const
+  {
+    return maximumRowsExtra_;
+  }
+  /// Total number of columns in factorization
+  inline int numberColumns() const
+  {
+    return numberColumns_;
+  }
+  /// Total number of elements in factorization
+  inline int numberElements() const
+  {
+    return totalElements_;
+  }
+  /// Length of FT vector
+  inline int numberForrestTomlin() const
+  {
+    return numberInColumn_.array()[numberColumnsExtra_];
+  }
+  /// Number of good columns in factorization
+  inline int numberGoodColumns() const
+  {
+    return numberGoodU_;
+  }
+  /// Whether larger areas needed
+  inline double areaFactor() const
+  {
+    return areaFactor_;
+  }
+  inline void areaFactor(double value)
+  {
+    areaFactor_ = value;
+  }
+  /// Returns areaFactor but adjusted for dense
+  double adjustedAreaFactor() const;
+  /// Allows change of pivot accuracy check 1.0 == none >1.0 relaxed
+  inline void relaxAccuracyCheck(double value)
+  {
+    relaxCheck_ = value;
+  }
+  inline double getAccuracyCheck() const
+  {
+    return relaxCheck_;
+  }
+  /// Level of detail of messages
+  inline int messageLevel() const
+  {
+    return messageLevel_;
+  }
+  void messageLevel(int value);
+  /// Maximum number of pivots between factorizations
+  inline int maximumPivots() const
+  {
+    return maximumPivots_;
+  }
+  void maximumPivots(int value);
+
+  /// Gets dense threshold
+  inline int denseThreshold() const
+  {
+    return denseThreshold_;
+  }
+  /// Sets dense threshold
+  inline void setDenseThreshold(int value)
+  {
+    denseThreshold_ = value;
+  }
+  /// Pivot tolerance
+  inline double pivotTolerance() const
+  {
+    return pivotTolerance_;
+  }
+  void pivotTolerance(double value);
+  /// Zero tolerance
+  inline double zeroTolerance() const
+  {
+    return zeroTolerance_;
+  }
+  void zeroTolerance(double value);
+#ifndef COIN_FAST_CODE
+  /// Whether slack value is +1 or -1
+  inline double slackValue() const
+  {
+    return slackValue_;
+  }
+  void slackValue(double value);
+#endif
+  /// Returns maximum absolute value in factorization
+  double maximumCoefficient() const;
+  /// true if Forrest Tomlin update, false if PFI
+  inline bool forrestTomlin() const
+  {
+    return doForrestTomlin_;
+  }
+  inline void setForrestTomlin(bool value)
+  {
+    doForrestTomlin_ = value;
+  }
+  /// True if FT update and space
+  inline bool spaceForForrestTomlin() const
+  {
+    int start = startColumnU_.array()[maximumColumnsExtra_];
+    int space = lengthAreaU_ - (start + numberRowsExtra_);
+    return (space >= 0) && doForrestTomlin_;
+  }
+  //@}
+
+  /**@name some simple stuff */
+  //@{
+
+  /// Returns number of dense rows
+  inline int numberDense() const
+  {
+    return numberDense_;
+  }
+
+  /// Returns number in U area
+  inline int numberElementsU() const
+  {
+    return lengthU_;
+  }
+  /// Setss number in U area
+  inline void setNumberElementsU(int value)
+  {
+    lengthU_ = value;
+  }
+  /// Returns length of U area
+  inline int lengthAreaU() const
+  {
+    return lengthAreaU_;
+  }
+  /// Returns number in L area
+  inline int numberElementsL() const
+  {
+    return lengthL_;
+  }
+  /// Returns length of L area
+  inline int lengthAreaL() const
+  {
+    return lengthAreaL_;
+  }
+  /// Returns number in R area
+  inline int numberElementsR() const
+  {
+    return lengthR_;
+  }
+  /// Number of compressions done
+  inline int numberCompressions() const
+  {
+    return numberCompressions_;
+  }
+  /// Number of entries in each row
+  inline int *numberInRow() const
+  {
+    return numberInRow_.array();
+  }
+  /// Number of entries in each column
+  inline int *numberInColumn() const
+  {
+    return numberInColumn_.array();
+  }
+  /// Elements of U
+  inline CoinFactorizationDouble *elementU() const
+  {
+    return elementU_.array();
+  }
+  /// Row indices of U
+  inline int *indexRowU() const
+  {
+    return indexRowU_.array();
+  }
+  /// Start of each column in U
+  inline int *startColumnU() const
+  {
+    return startColumnU_.array();
+  }
+  /// Maximum number of Columns after iterating
+  inline int maximumColumnsExtra()
+  {
+    return maximumColumnsExtra_;
+  }
+  /** L to U bias
+      0 - U bias, 1 - some U bias, 2 some L bias, 3 L bias
+  */
+  inline int biasLU() const
+  {
+    return biasLU_;
+  }
+  inline void setBiasLU(int value)
+  {
+    biasLU_ = value;
+  }
+  /** Array persistence flag
+      If 0 then as now (delete/new)
+      1 then only do arrays if bigger needed
+      2 as 1 but give a bit extra if bigger needed
+  */
+  inline int persistenceFlag() const
+  {
+    return persistenceFlag_;
+  }
+  void setPersistenceFlag(int value);
+  //@}
+
+  /**@name rank one updates which do exist */
+  //@{
+
+  /** Replaces one Column to basis,
+   returns 0=OK, 1=Probably OK, 2=singular, 3=no room
+      If checkBeforeModifying is true will do all accuracy checks
+      before modifying factorization.  Whether to set this depends on
+      speed considerations.  You could just do this on first iteration
+      after factorization and thereafter re-factorize
+   partial update already in U */
+  int replaceColumn(CoinIndexedVector *regionSparse,
+    int pivotRow,
+    double pivotCheck,
+    bool checkBeforeModifying = false,
+    double acceptablePivot = 1.0e-8);
+  /** Combines BtranU and delete elements
+      If deleted is NULL then delete elements
+      otherwise store where elements are
+  */
+  void replaceColumnU(CoinIndexedVector *regionSparse,
+    int *deleted,
+    int internalPivotRow);
+#ifdef ABC_USE_COIN_FACTORIZATION
+  /** returns empty fake vector carved out of existing
+      later - maybe use associated arrays */
+  CoinIndexedVector *fakeVector(CoinIndexedVector *vector,
+    int already = 0) const;
+  void deleteFakeVector(CoinIndexedVector *vector,
+    CoinIndexedVector *fakeVector) const;
+  /** Checks if can replace one Column to basis,
+      returns update alpha
+      Fills in region for use later
+      partial update already in U */
+  double checkReplacePart1(CoinIndexedVector *regionSparse,
+    int pivotRow);
+  /** Checks if can replace one Column to basis,
+      returns update alpha
+      Fills in region for use later
+      partial update in vector */
+  double checkReplacePart1(CoinIndexedVector *regionSparse,
+    CoinIndexedVector *partialUpdate,
+    int pivotRow);
+  /** Checks if can replace one Column in basis,
+      returns 0=OK, 1=Probably OK, 2=singular, 3=no room, 5 max pivots */
+  int checkReplacePart2(int pivotRow,
+    double btranAlpha,
+    double ftranAlpha,
+    double ftAlpha,
+    double acceptablePivot = 1.0e-8);
+  /** Replaces one Column to basis,
+      partial update already in U */
+  void replaceColumnPart3(CoinIndexedVector *regionSparse,
+    int pivotRow,
+    double alpha);
+  /** Replaces one Column to basis,
+      partial update in vector */
+  void replaceColumnPart3(CoinIndexedVector *regionSparse,
+    CoinIndexedVector *partialUpdate,
+    int pivotRow,
+    double alpha);
+  /** Updates one column (FTRAN) from regionSparse2
+      Tries to do FT update
+      number returned is negative if no room
+      regionSparse starts as zero and is zero at end.
+      Note - if regionSparse2 packed on input - will be packed on output
+      long regions
+  */
+  int updateColumnFT(CoinIndexedVector &regionSparse);
+  int updateColumnFTPart1(CoinIndexedVector &regionSparse);
+  void updateColumnFTPart2(CoinIndexedVector &regionSparse);
+  /** Updates one column (FTRAN) - long region
+      Tries to do FT update
+      puts partial update in vector */
+  void updateColumnFT(CoinIndexedVector &regionSparseFT,
+    CoinIndexedVector &partialUpdate,
+    int which);
+  /** Updates one column (FTRAN) long region */
+  int updateColumn(CoinIndexedVector &regionSparse) const;
+  /** Updates one column (FTRAN) from regionFT
+      Tries to do FT update
+      number returned is negative if no room.
+      Also updates regionOther - long region*/
+  int updateTwoColumnsFT(CoinIndexedVector &regionSparseFT,
+    CoinIndexedVector &regionSparseOther);
+  /** Updates one column (BTRAN) - long region*/
+  int updateColumnTranspose(CoinIndexedVector &regionSparse) const;
+  /** Updates one column (FTRAN) - long region */
+  void updateColumnCpu(CoinIndexedVector &regionSparse, int whichCpu) const;
+  /** Updates one column (BTRAN) - long region */
+  void updateColumnTransposeCpu(CoinIndexedVector &regionSparse, int whichCpu) const;
+  /** Updates one full column (FTRAN) - long region */
+  void updateFullColumn(CoinIndexedVector &regionSparse) const;
+  /** Updates one full column (BTRAN) - long region */
+  void updateFullColumnTranspose(CoinIndexedVector &regionSparse) const;
+  /** Updates one column for dual steepest edge weights (FTRAN) - long region */
+  void updateWeights(CoinIndexedVector &regionSparse) const;
+  /// Returns true if wants tableauColumn in replaceColumn
+  inline bool wantsTableauColumn() const
+  {
+    return false;
+  }
+  /// Pivot tolerance
+  inline double minimumPivotTolerance() const
+  {
+    return pivotTolerance_;
+  }
+  inline void minimumPivotTolerance(double value)
+  {
+    pivotTolerance(value);
+  }
+  /// Says parallel
+  inline void setParallelMode(int value)
+  {
+    parallelMode_ = value;
+  }
+  /// Sets solve mode
+  inline void setSolveMode(int value)
+  {
+    parallelMode_ &= 3;
+    parallelMode_ |= (value << 2);
+  }
+  /// Sets solve mode
+  inline int solveMode() const
+  {
+    return parallelMode_ >> 2;
+  }
+  /// Update partial Ftran by R update
+  void updatePartialUpdate(CoinIndexedVector &partialUpdate);
+  /// Makes a non-singular basis by replacing variables
+  void makeNonSingular(int *COIN_RESTRICT sequence);
+#endif
+#if ABOCA_LITE_FACTORIZATION
+  /// Does btranU part of replaceColumn (skipping entries)
+  void replaceColumn1(CoinIndexedVector *regionSparse, int pivotRow);
+  /// Does replaceColumn - having already done btranU
+  int replaceColumn2(CoinIndexedVector *regionSparse,
+    int pivotRow,
+    double pivotCheck);
+#endif
+  //@}
+
+  /**@name various uses of factorization (return code number elements) 
+   which user may want to know about */
+  //@{
+  /** Updates one column (FTRAN) from regionSparse2
+      Tries to do FT update
+      number returned is negative if no room
+      regionSparse starts as zero and is zero at end.
+      Note - if regionSparse2 packed on input - will be packed on output
+  */
+  int updateColumnFT(CoinIndexedVector *regionSparse,
+    CoinIndexedVector *regionSparse2);
+  /** This version has same effect as above with FTUpdate==false
+      so number returned is always >=0 */
+  int updateColumn(CoinIndexedVector *regionSparse,
+    CoinIndexedVector *regionSparse2,
+    bool noPermute = false) const;
+  /** Updates one column (FTRAN) from region2
+      Tries to do FT update
+      number returned is negative if no room.
+      Also updates region3
+      region1 starts as zero and is zero at end */
+  int updateTwoColumnsFT(CoinIndexedVector *regionSparse1,
+    CoinIndexedVector *regionSparse2,
+    CoinIndexedVector *regionSparse3,
+    bool noPermuteRegion3 = false);
+  /** Updates one column (BTRAN) from regionSparse2
+      regionSparse starts as zero and is zero at end 
+      Note - if regionSparse2 packed on input - will be packed on output
+  */
+  int updateColumnTranspose(CoinIndexedVector *regionSparse,
+    CoinIndexedVector *regionSparse2) const;
+  /// Part of twocolumnsTranspose
+  void updateOneColumnTranspose(CoinIndexedVector *regionWork, int &statistics) const;
+  /** Updates two columns (BTRAN) from regionSparse2 and 3
+      regionSparse starts as zero and is zero at end 
+      Note - if regionSparse2 packed on input - will be packed on output - same for 3
+  */
+  void updateTwoColumnsTranspose(CoinIndexedVector *regionSparse,
+    CoinIndexedVector *regionSparse2,
+    CoinIndexedVector *regionSparse3,
+    int type) const;
+  /** makes a row copy of L for speed and to allow very sparse problems */
+  void goSparse();
+  /**  get sparse threshold */
+  inline int sparseThreshold() const
+  {
+    return sparseThreshold_;
+  }
+  /**  set sparse threshold */
+  void sparseThreshold(int value);
+  //@}
+  /// *** Below this user may not want to know about
+
+  /**@name various uses of factorization (return code number elements) 
+   which user may not want to know about (left over from my LP code) */
+  //@{
+  /// Get rid of all memory
+  inline void clearArrays()
+  {
+    gutsOfDestructor();
+  }
+  //@}
+
+  /**@name various updates - none of which have been written! */
+  //@{
+
+  /** Adds given elements to Basis and updates factorization,
+      can increase size of basis. Returns rank */
+  int add(int numberElements,
+    int indicesRow[],
+    int indicesColumn[], double elements[]);
+
+  /** Adds one Column to basis,
+      can increase size of basis. Returns rank */
+  int addColumn(int numberElements,
+    int indicesRow[], double elements[]);
+
+  /** Adds one Row to basis,
+      can increase size of basis. Returns rank */
+  int addRow(int numberElements,
+    int indicesColumn[], double elements[]);
+
+  /// Deletes one Column from basis, returns rank
+  int deleteColumn(int Row);
+  /// Deletes one Row from basis, returns rank
+  int deleteRow(int Row);
+
+  /** Replaces one Row in basis,
+      At present assumes just a singleton on row is in basis
+      returns 0=OK, 1=Probably OK, 2=singular, 3 no space */
+  int replaceRow(int whichRow, int numberElements,
+    const int indicesColumn[], const double elements[]);
+  /// Takes out all entries for given rows
+  void emptyRows(int numberToEmpty, const int which[]);
+  //@}
+  /**@name used by ClpFactorization */
+  /// See if worth going sparse
+  void checkSparse();
+  /// For statistics
+#if 0 //def CLP_FACTORIZATION_INSTRUMENT
+  inline bool collectStatistics() const
+  { return collectStatistics_;}
+  /// For statistics 
+  inline void setCollectStatistics(bool onOff) const
+  { collectStatistics_ = onOff;}
+#else
+  inline bool collectStatistics() const
+  {
+    return true;
+  }
+  /// For statistics
+  inline void setCollectStatistics(bool onOff) const
+  {
+  }
+#endif
+  /// The real work of constructors etc 0 just scalars, 1 bit normal
+  void gutsOfDestructor(int type = 1);
+  /// 1 bit - tolerances etc, 2 more, 4 dummy arrays
+  void gutsOfInitialize(int type);
+  void gutsOfCopy(const CoinFactorization &other);
+
+  /// Reset all sparsity etc statistics
+  void resetStatistics();
+
+  //@}
+
+  /**@name used by factorization */
+  /// Gets space for a factorization, called by constructors
+  void getAreas(int numberRows,
+    int numberColumns,
+    int maximumL,
+    int maximumU);
+
+  /** PreProcesses raw triplet data.
+      state is 0 - triplets, 1 - some counts etc , 2 - .. */
+  void preProcess(int state,
+    int possibleDuplicates = -1);
+  /// Does most of factorization
+  int factor();
+
+protected:
+  /** Does sparse phase of factorization
+      return code is <0 error, 0= finished */
+  int factorSparse();
+  /** Does sparse phase of factorization (for smaller problems)
+      return code is <0 error, 0= finished */
+  int factorSparseSmall();
+  /** Does sparse phase of factorization (for larger problems)
+      return code is <0 error, 0= finished */
+  int factorSparseLarge();
+  /** Does dense phase of factorization
+      return code is <0 error, 0= finished */
+  int factorDense();
+
+  /// Pivots when just one other row so faster?
+  bool pivotOneOtherRow(int pivotRow,
+    int pivotColumn);
+  /// Does one pivot on Row Singleton in factorization
+  bool pivotRowSingleton(int pivotRow,
+    int pivotColumn);
+  /// Does one pivot on Column Singleton in factorization
+  bool pivotColumnSingleton(int pivotRow,
+    int pivotColumn);
+
+  /** Gets space for one Column with given length,
+   may have to do compression  (returns True if successful),
+   also moves existing vector,
+   extraNeeded is over and above present */
+  bool getColumnSpace(int iColumn,
+    int extraNeeded);
+
+  /** Reorders U so contiguous and in order (if there is space)
+      Returns true if it could */
+  bool reorderU();
+  /**  getColumnSpaceIterateR.  Gets space for one extra R element in Column
+       may have to do compression  (returns true)
+       also moves existing vector */
+  bool getColumnSpaceIterateR(int iColumn, double value,
+    int iRow);
+  /**  getColumnSpaceIterate.  Gets space for one extra U element in Column
+       may have to do compression  (returns true)
+       also moves existing vector.
+       Returns -1 if no memory or where element was put
+       Used by replaceRow (turns off R version) */
+  int getColumnSpaceIterate(int iColumn, double value,
+    int iRow);
+  /** Gets space for one Row with given length,
+  may have to do compression  (returns True if successful),
+  also moves existing vector */
+  bool getRowSpace(int iRow, int extraNeeded);
+
+  /** Gets space for one Row with given length while iterating,
+  may have to do compression  (returns True if successful),
+  also moves existing vector */
+  bool getRowSpaceIterate(int iRow,
+    int extraNeeded);
+  /// Checks that row and column copies look OK
+  void checkConsistency();
+  /// Adds a link in chain of equal counts
+  inline void addLink(int index, int count)
+  {
+    int *nextCount = nextCount_.array();
+    int *firstCount = firstCount_.array();
+    int *lastCount = lastCount_.array();
+    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;
+    }
+  }
+  /// Deletes a link in chain of equal counts
+  inline void deleteLink(int index)
+  {
+    int *nextCount = nextCount_.array();
+    int *firstCount = firstCount_.array();
+    int *lastCount = lastCount_.array();
+    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;
+  }
+  /// Separate out links with same row/column count
+  void separateLinks(int count, bool rowsFirst);
+  /// Cleans up at end of factorization
+  void cleanup();
+
+  /// Updates part of column (FTRANL)
+  void updateColumnL(CoinIndexedVector *region, int *indexIn) const;
+  /// Updates part of column (FTRANL) when densish
+  void updateColumnLDensish(CoinIndexedVector *region, int *indexIn) const;
+  /// Updates part of column (FTRANL) when sparse
+  void updateColumnLSparse(CoinIndexedVector *region, int *indexIn) const;
+  /// Updates part of column (FTRANL) when sparsish
+  void updateColumnLSparsish(CoinIndexedVector *region, int *indexIn) const;
+
+  /// Updates part of column (FTRANR) without FT update
+  void updateColumnR(CoinIndexedVector *region) const;
+  /** Updates part of column (FTRANR) with FT update.
+      Also stores update after L and R */
+  void updateColumnRFT(CoinIndexedVector *region, int *indexIn);
+
+  /// Updates part of column (FTRANU)
+  void updateColumnU(CoinIndexedVector *region, int *indexIn) const;
+
+  /// Updates part of column (FTRANU) when sparse
+  void updateColumnUSparse(CoinIndexedVector *regionSparse,
+    int *indexIn) const;
+  /// Updates part of column (FTRANU) when sparsish
+  void updateColumnUSparsish(CoinIndexedVector *regionSparse,
+    int *indexIn) const;
+  /// Updates part of column (FTRANU)
+  int updateColumnUDensish(double *COIN_RESTRICT region,
+    int *COIN_RESTRICT regionIndex) const;
+  /// Updates part of 2 columns (FTRANU) real work
+  void updateTwoColumnsUDensish(
+    int &numberNonZero1,
+    double *COIN_RESTRICT region1,
+    int *COIN_RESTRICT index1,
+    int &numberNonZero2,
+    double *COIN_RESTRICT region2,
+    int *COIN_RESTRICT index2) const;
+  /// Updates part of column PFI (FTRAN) (after rest)
+  void updateColumnPFI(CoinIndexedVector *regionSparse) const;
+  /// Permutes back at end of updateColumn
+  void permuteBack(CoinIndexedVector *regionSparse,
+    CoinIndexedVector *outVector) const;
+
+  /// Updates part of column transpose PFI (BTRAN) (before rest)
+  void updateColumnTransposePFI(CoinIndexedVector *region) const;
+  /** Updates part of column transpose (BTRANU),
+      assumes index is sorted i.e. region is correct */
+  void updateColumnTransposeU(CoinIndexedVector *region,
+    int smallestIndex) const;
+  /** Updates part of column transpose (BTRANU) when sparsish,
+      assumes index is sorted i.e. region is correct */
+  void updateColumnTransposeUSparsish(CoinIndexedVector *region,
+    int smallestIndex) const;
+  /** Updates part of column transpose (BTRANU) when densish,
+      assumes index is sorted i.e. region is correct */
+  void updateColumnTransposeUDensish(CoinIndexedVector *region,
+    int smallestIndex) const;
+  /** Updates part of column transpose (BTRANU) when sparse,
+      assumes index is sorted i.e. region is correct */
+  void updateColumnTransposeUSparse(CoinIndexedVector *region) const;
+  /** Updates part of column transpose (BTRANU) by column
+      assumes index is sorted i.e. region is correct */
+  void updateColumnTransposeUByColumn(CoinIndexedVector *region,
+    int smallestIndex) const;
+
+  /// Updates part of column transpose (BTRANR)
+  void updateColumnTransposeR(CoinIndexedVector *region) const;
+  /// Updates part of column transpose (BTRANR) when dense
+  void updateColumnTransposeRDensish(CoinIndexedVector *region) const;
+  /// Updates part of column transpose (BTRANR) when sparse
+  void updateColumnTransposeRSparse(CoinIndexedVector *region) const;
+
+  /// Updates part of column transpose (BTRANL)
+  void updateColumnTransposeL(CoinIndexedVector *region) const;
+  /// Updates part of column transpose (BTRANL) when densish by column
+  void updateColumnTransposeLDensish(CoinIndexedVector *region) const;
+  /// Updates part of column transpose (BTRANL) when densish by row
+  void updateColumnTransposeLByRow(CoinIndexedVector *region) const;
+  /// Updates part of column transpose (BTRANL) when sparsish by row
+  void updateColumnTransposeLSparsish(CoinIndexedVector *region) const;
+  /// Updates part of column transpose (BTRANL) when sparse (by Row)
+  void updateColumnTransposeLSparse(CoinIndexedVector *region) const;
+
+public:
+  /** Replaces one Column to basis for PFI
+   returns 0=OK, 1=Probably OK, 2=singular, 3=no room.
+   In this case region is not empty - it is incoming variable (updated)
+  */
+  int replaceColumnPFI(CoinIndexedVector *regionSparse,
+    int pivotRow, double alpha);
+
+protected:
+  /** Returns accuracy status of replaceColumn
+      returns 0=OK, 1=Probably OK, 2=singular */
+  int checkPivot(double saveFromU, double oldPivot) const;
+  /********************************* 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 >
+  inline bool
+  pivot(int pivotRow,
+    int pivotColumn,
+    int pivotRowPosition,
+    int pivotColumnPosition,
+    CoinFactorizationDouble work[],
+    unsigned int workArea2[],
+    int increment2,
+    T markRow[],
+    int largeInteger)
+  {
+    int *indexColumnU = indexColumnU_.array();
+    int *startColumnU = startColumnU_.array();
+    int *numberInColumn = numberInColumn_.array();
+    CoinFactorizationDouble *elementU = elementU_.array();
+    int *indexRowU = indexRowU_.array();
+    int *startRowU = startRowU_.array();
+    int *numberInRow = numberInRow_.array();
+    CoinFactorizationDouble *elementL = elementL_.array();
+    int *indexRowL = indexRowL_.array();
+    int *saveColumn = saveColumn_.array();
+    int *nextRow = nextRow_.array();
+    int *lastRow = lastRow_.array();
+
+    //store pivot columns (so can easily compress)
+    int numberInPivotRow = numberInRow[pivotRow] - 1;
+    int startColumn = startColumnU[pivotColumn];
+    int numberInPivotColumn = numberInColumn[pivotColumn] - 1;
+    int endColumn = startColumn + numberInPivotColumn + 1;
+    int put = 0;
+    int startRow = startRowU[pivotRow];
+    int endRow = startRow + numberInPivotRow + 1;
+
+    if (pivotColumnPosition < 0) {
+      for (pivotColumnPosition = startRow; pivotColumnPosition < endRow; pivotColumnPosition++) {
+        int iColumn = indexColumnU[pivotColumnPosition];
+        if (iColumn != pivotColumn) {
+          saveColumn[put++] = iColumn;
+        } else {
+          break;
+        }
+      }
+    } else {
+      for (int i = startRow; i < pivotColumnPosition; i++) {
+        saveColumn[put++] = indexColumnU[i];
+      }
+    }
+    assert(pivotColumnPosition < endRow);
+    assert(indexColumnU[pivotColumnPosition] == pivotColumn);
+    pivotColumnPosition++;
+    for (; pivotColumnPosition < endRow; pivotColumnPosition++) {
+      saveColumn[put++] = indexColumnU[pivotColumnPosition];
+    }
+    //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
+    int l = lengthL_;
+
+    if (l + numberInPivotColumn > lengthAreaL_) {
+      //need more memory
+      if ((messageLevel_ & 4) != 0)
+        printf("more memory needed in middle of invert\n");
+      return false;
+    }
+    //l+=currentAreaL_->elementByColumn-elementL;
+    int lSave = l;
+
+    int *startColumnL = startColumnL_.array();
+    startColumnL[numberGoodL_] = l; //for luck and first time
+    numberGoodL_++;
+    startColumnL[numberGoodL_] = l + numberInPivotColumn;
+    lengthL_ += numberInPivotColumn;
+    if (pivotRowPosition < 0) {
+      for (pivotRowPosition = startColumn; pivotRowPosition < endColumn; pivotRowPosition++) {
+        int iRow = indexRowU[pivotRowPosition];
+        if (iRow != pivotRow) {
+          indexRowL[l] = iRow;
+          elementL[l] = elementU[pivotRowPosition];
+          markRow[iRow] = static_cast< T >(l - lSave);
+          l++;
+          //take out of row list
+          int start = startRowU[iRow];
+          int end = start + numberInRow[iRow];
+          int where = start;
+
+          while (indexColumnU[where] != pivotColumn) {
+            where++;
+          } /* endwhile */
+#if DEBUG_COIN
+          if (where >= end) {
+            abort();
+          }
+#endif
+          indexColumnU[where] = indexColumnU[end - 1];
+          numberInRow[iRow]--;
+        } else {
+          break;
+        }
+      }
+    } else {
+      int i;
+
+      for (i = startColumn; i < pivotRowPosition; i++) {
+        int iRow = indexRowU[i];
+
+        markRow[iRow] = static_cast< T >(l - lSave);
+        indexRowL[l] = iRow;
+        elementL[l] = elementU[i];
+        l++;
+        //take out of row list
+        int start = startRowU[iRow];
+        int end = start + numberInRow[iRow];
+        int 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);
+      }
+    }
+    assert(pivotRowPosition < endColumn);
+    assert(indexRowU[pivotRowPosition] == pivotRow);
+    CoinFactorizationDouble pivotElement = elementU[pivotRowPosition];
+    CoinFactorizationDouble pivotMultiplier = 1.0 / pivotElement;
+
+    pivotRegion_.array()[numberGoodU_] = pivotMultiplier;
+    pivotRowPosition++;
+    for (; pivotRowPosition < endColumn; pivotRowPosition++) {
+      int iRow = indexRowU[pivotRowPosition];
+
+      markRow[iRow] = static_cast< T >(l - lSave);
+      indexRowL[l] = iRow;
+      elementL[l] = elementU[pivotRowPosition];
+      l++;
+      //take out of row list
+      int start = startRowU[iRow];
+      int end = start + numberInRow[iRow];
+      int 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] = static_cast< T >(largeInteger);
+    //compress pivot column (move pivot to front including saved)
+    numberInColumn[pivotColumn] = 0;
+    //use end of L for temporary space
+    int *indexL = &indexRowL[lSave];
+    CoinFactorizationDouble *multipliersL = &elementL[lSave];
+
+    //adjust
+    int j;
+
+    for (j = 0; j < numberInPivotColumn; j++) {
+      multipliersL[j] *= pivotMultiplier;
+    }
+    //zero out fill
+    int iErase;
+    for (iErase = 0; iErase < increment2 * numberInPivotRow;
+         iErase++) {
+      workArea2[iErase] = 0;
+    }
+    int added = numberInPivotRow * numberInPivotColumn;
+    unsigned int *temp2 = workArea2;
+    int *nextColumn = nextColumn_.array();
+
+    //pack down and move to work
+    int jColumn;
+    for (jColumn = 0; jColumn < numberInPivotRow; jColumn++) {
+      int iColumn = saveColumn[jColumn];
+      int startColumn = startColumnU[iColumn];
+      int endColumn = startColumn + numberInColumn[iColumn];
+      int iRow = indexRowU[startColumn];
+      CoinFactorizationDouble value = elementU[startColumn];
+      double largest;
+      int put = startColumn;
+      int positionLargest = -1;
+      CoinFactorizationDouble thisPivotValue = 0.0;
+
+      //compress column and find largest not updated
+      bool checkLargest;
+      int mark = markRow[iRow];
+
+      if (mark == largeInteger + 1) {
+        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;
+        }
+      }
+      int i;
+      for (i = startColumn + 1; i < endColumn; i++) {
+        iRow = indexRowU[i];
+        value = elementU[i];
+        int mark = markRow[iRow];
+
+        if (mark == largeInteger + 1) {
+          //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;
+      int *numberInColumnPlus = numberInColumnPlus_.array();
+      numberInColumnPlus[iColumn]++;
+      startColumnU[iColumn]++;
+      //how much space have we got
+      int next = nextColumn[iColumn];
+      int 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
+        if (positionLargest >= 0)
+          positionLargest = positionLargest + startColumnU[iColumn] - startColumn;
+        startColumn = startColumnU[iColumn];
+        put = startColumn + numberInColumn[iColumn];
+      }
+      double tolerance = zeroTolerance_;
+
+      int *nextCount = nextCount_.array();
+      for (j = 0; j < numberInPivotColumn; j++) {
+        value = work[j] - thisPivotValue * multipliersL[j];
+        double absValue = fabs(value);
+
+        if (absValue > tolerance) {
+          work[j] = 0.0;
+          assert(put < lengthAreaU_);
+          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];
+            int start = startRowU[iRow];
+            int end = start + numberInRow[iRow];
+            int 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];
+        int 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];
+        int 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] = static_cast< T >(largeInteger + 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];
+      int 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];
+      int 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] = static_cast< T >(largeInteger + 1);
+      number = end - startRowU[iRow];
+      numberInRow[iRow] = number;
+      deleteLink(iRow);
+      addLink(iRow, number);
+    }
+    markRow[pivotRow] = static_cast< T >(largeInteger + 1);
+    //modify linked list for pivots
+    deleteLink(pivotRow);
+    deleteLink(pivotColumn + numberRows_);
+    totalElements_ += added;
+    return true;
+  }
+
+  /********************************* END LARGE TEMPLATE ********/
+  //@}
+  ////////////////// data //////////////////
+protected:
+  /**@name data */
+  //@{
+  /// Pivot tolerance
+  double pivotTolerance_;
+  /// Zero tolerance
+  double zeroTolerance_;
+#ifndef COIN_FAST_CODE
+  /// Whether slack value is  +1 or -1
+  double slackValue_;
+#else
+#ifndef slackValue_
+#define slackValue_ -1.0
+#endif
+#endif
+  /// How much to multiply areas by
+  double areaFactor_;
+  /// Relax check on accuracy in replaceColumn
+  double relaxCheck_;
+  /// Number of Rows in factorization
+  int numberRows_;
+  /// Number of Rows after iterating
+  int numberRowsExtra_;
+  /// Maximum number of Rows after iterating
+  int maximumRowsExtra_;
+  /// Number of Columns in factorization
+  int numberColumns_;
+  /// Number of Columns after iterating
+  int numberColumnsExtra_;
+  /// Maximum number of Columns after iterating
+  int maximumColumnsExtra_;
+  /// Number factorized in U (not row singletons)
+  int numberGoodU_;
+  /// Number factorized in L
+  int numberGoodL_;
+  /// Maximum number of pivots before factorization
+  int maximumPivots_;
+  /// Number pivots since last factorization
+  int numberPivots_;
+  /// Number of elements in U (to go)
+  ///       or while iterating total overall
+  int totalElements_;
+  /// Number of elements after factorization
+  int factorElements_;
+  /// Pivot order for each Column
+  CoinIntArrayWithLength pivotColumn_;
+  /// Permutation vector for pivot row order
+  CoinIntArrayWithLength permute_;
+  /// DePermutation vector for pivot row order
+  CoinIntArrayWithLength permuteBack_;
+  /// Inverse Pivot order for each Column
+  CoinIntArrayWithLength pivotColumnBack_;
+  /// Status of factorization
+  int status_;
+
+  /** 0 - no increasing rows - no permutations,
+   1 - no increasing rows but permutations 
+   2 - increasing rows 
+     - taken out as always 2 */
+  //int increasingRows_;
+
+  /// Number of trials before rejection
+  int numberTrials_;
+  /// Start of each Row as pointer
+  CoinIntArrayWithLength startRowU_;
+
+  /// Number in each Row
+  CoinIntArrayWithLength numberInRow_;
+
+  /// Number in each Column
+  CoinIntArrayWithLength numberInColumn_;
+
+  /// Number in each Column including pivoted
+  CoinIntArrayWithLength numberInColumnPlus_;
+
+  /** First Row/Column with count of k,
+      can tell which by offset - Rows then Columns */
+  CoinIntArrayWithLength firstCount_;
+
+  /// Next Row/Column with count
+  CoinIntArrayWithLength nextCount_;
+
+  /// Previous Row/Column with count
+  CoinIntArrayWithLength lastCount_;
+
+  /// Next Column in memory order
+  CoinIntArrayWithLength nextColumn_;
+
+  /// Previous Column in memory order
+  CoinIntArrayWithLength lastColumn_;
+
+  /// Next Row in memory order
+  CoinIntArrayWithLength nextRow_;
+
+  /// Previous Row in memory order
+  CoinIntArrayWithLength lastRow_;
+
+  /// Columns left to do in a single pivot
+  CoinIntArrayWithLength saveColumn_;
+
+  /// Marks rows to be updated
+  CoinIntArrayWithLength markRow_;
+
+  /// Detail in messages
+  int messageLevel_;
+
+  /// Larger of row and column size
+  int biggerDimension_;
+
+  /// Base address for U (may change)
+  CoinIntArrayWithLength indexColumnU_;
+
+  /// Pivots for L
+  CoinIntArrayWithLength pivotRowL_;
+
+  /// Inverses of pivot values
+  CoinFactorizationDoubleArrayWithLength pivotRegion_;
+
+  /// Number of slacks at beginning of U
+  int numberSlacks_;
+
+  /// Number in U
+  int numberU_;
+
+  /// Maximum space used in U
+  int maximumU_;
+
+  /// Base of U is always 0
+  //int baseU_;
+
+  /// Length of U
+  int lengthU_;
+
+  /// Length of area reserved for U
+  int lengthAreaU_;
+
+  /// Elements of U
+  CoinFactorizationDoubleArrayWithLength elementU_;
+
+  /// Row indices of U
+  CoinIntArrayWithLength indexRowU_;
+
+  /// Start of each column in U
+  CoinIntArrayWithLength startColumnU_;
+
+  /// Converts rows to columns in U
+  CoinIntArrayWithLength convertRowToColumnU_;
+
+  /// Number in L
+  int numberL_;
+
+  /// Base of L
+  int baseL_;
+
+  /// Length of L
+  int lengthL_;
+
+  /// Length of area reserved for L
+  int lengthAreaL_;
+
+  /// Elements of L
+  CoinFactorizationDoubleArrayWithLength elementL_;
+
+  /// Row indices of L
+  CoinIntArrayWithLength indexRowL_;
+
+  /// Start of each column in L
+  CoinIntArrayWithLength startColumnL_;
+
+  /// true if Forrest Tomlin update, false if PFI
+  bool doForrestTomlin_;
+
+  /// Number in R
+  int numberR_;
+
+  /// Length of R stuff
+  int lengthR_;
+
+  /// length of area reserved for R
+  int lengthAreaR_;
+
+  /// Elements of R
+  CoinFactorizationDouble *elementR_;
+
+  /// Row indices for R
+  int *indexRowR_;
+
+  /// Start of columns for R
+  CoinIntArrayWithLength startColumnR_;
+
+  /// Dense area
+  double *denseArea_;
+
+  /// Dense area - actually used (for alignment etc)
+  double *denseAreaAddress_;
+
+  /// Dense permutation
+  int *densePermute_;
+
+  /// Number of dense rows
+  int numberDense_;
+
+  /// Dense threshold
+  int denseThreshold_;
+
+  /// First work area
+  CoinFactorizationDoubleArrayWithLength workArea_;
+
+  /// Second work area
+  CoinUnsignedIntArrayWithLength workArea2_;
+
+  /// Number of compressions done
+  int numberCompressions_;
+
+public:
+  /// Below are all to collect
+  mutable double ftranCountInput_;
+  mutable double ftranCountAfterL_;
+  mutable double ftranCountAfterR_;
+  mutable double ftranCountAfterU_;
+  mutable double btranCountInput_;
+  mutable double btranCountAfterU_;
+  mutable double btranCountAfterR_;
+  mutable double btranCountAfterL_;
+
+  /// We can roll over factorizations
+  mutable int numberFtranCounts_;
+  mutable int numberBtranCounts_;
+
+  /// While these are average ratios collected over last period
+  double ftranAverageAfterL_;
+  double ftranAverageAfterR_;
+  double ftranAverageAfterU_;
+  double btranAverageAfterU_;
+  double btranAverageAfterR_;
+  double btranAverageAfterL_;
+
+protected:
+  /// For statistics
+#if 0
+  mutable bool collectStatistics_;
+#else
+#define collectStatistics_ 1
+#endif
+
+  /// Below this use sparse technology - if 0 then no L row copy
+  int sparseThreshold_;
+
+  /// And one for "sparsish"
+  int sparseThreshold2_;
+
+  /// Start of each row in L
+  CoinIntArrayWithLength startRowL_;
+
+  /// Index of column in row for L
+  CoinIntArrayWithLength indexColumnL_;
+
+  /// Elements in L (row copy)
+  CoinFactorizationDoubleArrayWithLength elementByRowL_;
+
+  /// Sparse regions
+  mutable CoinIntArrayWithLength sparse_;
+#if ABOCA_LITE_FACTORIZATION
+  /// Offset to second version of sparse
+  int sparseOffset_;
+#endif
+  /** L to U bias
+      0 - U bias, 1 - some U bias, 2 some L bias, 3 L bias
+  */
+  int biasLU_;
+  /** Array persistence flag
+      If 0 then as now (delete/new)
+      1 then only do arrays if bigger needed
+      2 as 1 but give a bit extra if bigger needed
+  */
+  int persistenceFlag_;
+#ifdef ABC_USE_COIN_FACTORIZATION
+  /// Says if parallel
+  int parallelMode_;
+#endif
+  //@}
+};
+// Dense coding
+#ifdef INTEL_COMPILER
+#define COIN_FACTORIZATION_DENSE_CODE 3
+#endif
+#ifdef COIN_HAS_LAPACK
+#ifndef COIN_FACTORIZATION_DENSE_CODE
+#define COIN_FACTORIZATION_DENSE_CODE 1
+#endif
+#endif
+#ifdef COIN_FACTORIZATION_DENSE_CODE
+/* Type of Fortran integer translated into C */
+#ifndef ipfint
+//typedef ipfint FORTRAN_INTEGER_TYPE ;
+typedef int ipfint;
+typedef const int cipfint;
+#endif
+#endif
+#endif
+// Extra for ugly include
+#ifdef UGLY_COIN_FACTOR_CODING
+#define FAC_UNSET (FAC_SET + 1)
+{
+  goodPivot = false;
+  //store pivot columns (so can easily compress)
+  int startColumnThis = startColumn[iPivotColumn];
+  int endColumn = startColumnThis + numberDoColumn + 1;
+  int put = 0;
+  int startRowThis = startRow[iPivotRow];
+  int endRow = startRowThis + numberDoRow + 1;
+  if (pivotColumnPosition < 0) {
+    for (pivotColumnPosition = startRowThis; pivotColumnPosition < endRow; pivotColumnPosition++) {
+      int iColumn = indexColumn[pivotColumnPosition];
+      if (iColumn != iPivotColumn) {
+        saveColumn[put++] = iColumn;
+      } else {
+        break;
+      }
+    }
+  } else {
+    for (int i = startRowThis; i < pivotColumnPosition; i++) {
+      saveColumn[put++] = indexColumn[i];
+    }
+  }
+  assert(pivotColumnPosition < endRow);
+  assert(indexColumn[pivotColumnPosition] == iPivotColumn);
+  pivotColumnPosition++;
+  for (; pivotColumnPosition < endRow; pivotColumnPosition++) {
+    saveColumn[put++] = indexColumn[pivotColumnPosition];
+  }
+  //take out this bit of indexColumn
+  int next = nextRow[iPivotRow];
+  int last = lastRow[iPivotRow];
+
+  nextRow[last] = next;
+  lastRow[next] = last;
+  nextRow[iPivotRow] = numberGoodU_; //use for permute
+  lastRow[iPivotRow] = -2;
+  numberInRow[iPivotRow] = 0;
+  //store column in L, compress in U and take column out
+  int l = lengthL_;
+  // **** HORRID coding coming up but a goto seems best!
+  {
+    if (l + numberDoColumn > lengthAreaL_) {
+      //need more memory
+      if ((messageLevel_ & 4) != 0)
+        printf("more memory needed in middle of invert\n");
+      goto BAD_PIVOT;
+    }
+    //l+=currentAreaL_->elementByColumn-elementL;
+    int lSave = l;
+
+    int *startColumnL = startColumnL_.array();
+    startColumnL[numberGoodL_] = l; //for luck and first time
+    numberGoodL_++;
+    startColumnL[numberGoodL_] = l + numberDoColumn;
+    lengthL_ += numberDoColumn;
+    if (pivotRowPosition < 0) {
+      for (pivotRowPosition = startColumnThis; pivotRowPosition < endColumn; pivotRowPosition++) {
+        int iRow = indexRow[pivotRowPosition];
+        if (iRow != iPivotRow) {
+          indexRowL[l] = iRow;
+          elementL[l] = element[pivotRowPosition];
+          markRow[iRow] = l - lSave;
+          l++;
+          //take out of row list
+          int start = startRow[iRow];
+          int end = start + numberInRow[iRow];
+          int where = start;
+
+          while (indexColumn[where] != iPivotColumn) {
+            where++;
+          } /* endwhile */
+#if DEBUG_COIN
+          if (where >= end) {
+            abort();
+          }
+#endif
+          indexColumn[where] = indexColumn[end - 1];
+          numberInRow[iRow]--;
+        } else {
+          break;
+        }
+      }
+    } else {
+      int i;
+
+      for (i = startColumnThis; i < pivotRowPosition; i++) {
+        int iRow = indexRow[i];
+
+        markRow[iRow] = l - lSave;
+        indexRowL[l] = iRow;
+        elementL[l] = element[i];
+        l++;
+        //take out of row list
+        int start = startRow[iRow];
+        int end = start + numberInRow[iRow];
+        int where = start;
+
+        while (indexColumn[where] != iPivotColumn) {
+          where++;
+        } /* endwhile */
+#if DEBUG_COIN
+        if (where >= end) {
+          abort();
+        }
+#endif
+        indexColumn[where] = indexColumn[end - 1];
+        numberInRow[iRow]--;
+        assert(numberInRow[iRow] >= 0);
+      }
+    }
+    assert(pivotRowPosition < endColumn);
+    assert(indexRow[pivotRowPosition] == iPivotRow);
+    CoinFactorizationDouble pivotElement = element[pivotRowPosition];
+    CoinFactorizationDouble pivotMultiplier = 1.0 / pivotElement;
+
+    pivotRegion_.array()[numberGoodU_] = pivotMultiplier;
+    pivotRowPosition++;
+    for (; pivotRowPosition < endColumn; pivotRowPosition++) {
+      int iRow = indexRow[pivotRowPosition];
+
+      markRow[iRow] = l - lSave;
+      indexRowL[l] = iRow;
+      elementL[l] = element[pivotRowPosition];
+      l++;
+      //take out of row list
+      int start = startRow[iRow];
+      int end = start + numberInRow[iRow];
+      int where = start;
+
+      while (indexColumn[where] != iPivotColumn) {
+        where++;
+      } /* endwhile */
+#if DEBUG_COIN
+      if (where >= end) {
+        abort();
+      }
+#endif
+      indexColumn[where] = indexColumn[end - 1];
+      numberInRow[iRow]--;
+      assert(numberInRow[iRow] >= 0);
+    }
+    markRow[iPivotRow] = FAC_SET;
+    //compress pivot column (move pivot to front including saved)
+    numberInColumn[iPivotColumn] = 0;
+    //use end of L for temporary space
+    int *indexL = &indexRowL[lSave];
+    CoinFactorizationDouble *multipliersL = &elementL[lSave];
+
+    //adjust
+    int j;
+
+    for (j = 0; j < numberDoColumn; j++) {
+      multipliersL[j] *= pivotMultiplier;
+    }
+    //zero out fill
+    int iErase;
+    for (iErase = 0; iErase < increment2 * numberDoRow;
+         iErase++) {
+      workArea2[iErase] = 0;
+    }
+    int added = numberDoRow * numberDoColumn;
+    unsigned int *temp2 = workArea2;
+    int *nextColumn = nextColumn_.array();
+
+    //pack down and move to work
+    int jColumn;
+    for (jColumn = 0; jColumn < numberDoRow; jColumn++) {
+      int iColumn = saveColumn[jColumn];
+      int startColumnThis = startColumn[iColumn];
+      int endColumn = startColumnThis + numberInColumn[iColumn];
+      int iRow = indexRow[startColumnThis];
+      CoinFactorizationDouble value = element[startColumnThis];
+      double largest;
+      int put = startColumnThis;
+      int positionLargest = -1;
+      CoinFactorizationDouble thisPivotValue = 0.0;
+
+      //compress column and find largest not updated
+      bool checkLargest;
+      int mark = markRow[iRow];
+
+      if (mark == FAC_UNSET) {
+        largest = fabs(value);
+        positionLargest = put;
+        put++;
+        checkLargest = false;
+      } else {
+        //need to find largest
+        largest = 0.0;
+        checkLargest = true;
+        if (mark != FAC_SET) {
+          //will be updated
+          workArea[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;
+        }
+      }
+      int i;
+      for (i = startColumnThis + 1; i < endColumn; i++) {
+        iRow = indexRow[i];
+        value = element[i];
+        int mark = markRow[iRow];
+
+        if (mark == FAC_UNSET) {
+          //keep
+          indexRow[put] = iRow;
+          element[put] = value;
+          if (checkLargest) {
+            double absValue = fabs(value);
+
+            if (absValue > largest) {
+              largest = absValue;
+              positionLargest = put;
+            }
+          }
+          put++;
+        } else if (mark != FAC_SET) {
+          //will be updated
+          workArea[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
+      element[put] = element[startColumnThis];
+      indexRow[put] = indexRow[startColumnThis];
+      if (positionLargest == startColumnThis) {
+        positionLargest = put; //follow if was largest
+      }
+      put++;
+      element[startColumnThis] = thisPivotValue;
+      indexRow[startColumnThis] = iPivotRow;
+      //clean up counts
+      startColumnThis++;
+      numberInColumn[iColumn] = put - startColumnThis;
+      int *numberInColumnPlus = numberInColumnPlus_.array();
+      numberInColumnPlus[iColumn]++;
+      startColumn[iColumn]++;
+      //how much space have we got
+      int next = nextColumn[iColumn];
+      int space;
+
+      space = startColumn[next] - put - numberInColumnPlus[next];
+      //assume no zero elements
+      if (numberDoColumn > space) {
+        //getColumnSpace also moves fixed part
+        if (!getColumnSpace(iColumn, numberDoColumn)) {
+          goto BAD_PIVOT;
+        }
+        //redo starts
+        positionLargest = positionLargest + startColumn[iColumn] - startColumnThis;
+        startColumnThis = startColumn[iColumn];
+        put = startColumnThis + numberInColumn[iColumn];
+      }
+      double tolerance = zeroTolerance_;
+
+      int *nextCount = nextCount_.array();
+      for (j = 0; j < numberDoColumn; j++) {
+        value = workArea[j] - thisPivotValue * multipliersL[j];
+        double absValue = fabs(value);
+
+        if (absValue > tolerance) {
+          workArea[j] = 0.0;
+          element[put] = value;
+          indexRow[put] = indexL[j];
+          if (absValue > largest) {
+            largest = absValue;
+            positionLargest = put;
+          }
+          put++;
+        } else {
+          workArea[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];
+            int start = startRow[iRow];
+            int end = start + numberInRow[iRow];
+            int where = start;
+
+            while (indexColumn[where] != iColumn) {
+              where++;
+            } /* endwhile */
+#if DEBUG_COIN
+            if (where >= end) {
+              abort();
+            }
+#endif
+            indexColumn[where] = indexColumn[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 - startColumnThis;
+      //move largest
+      if (positionLargest >= 0) {
+        value = element[positionLargest];
+        iRow = indexRow[positionLargest];
+        element[positionLargest] = element[startColumnThis];
+        indexRow[positionLargest] = indexRow[startColumnThis];
+        element[startColumnThis] = value;
+        indexRow[startColumnThis] = 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 = numberDoColumn >> 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 < numberDoRow; jColumn++) {
+          unsigned int test = *putThis;
+
+          putThis += increment2;
+          test = 1 - ((test >> bit) & 1);
+          number += test;
+        }
+        int next = nextRow[iRow];
+        int space;
+
+        space = startRow[next] - startRow[iRow];
+        number += numberInRow[iRow];
+        if (space < number) {
+          if (!getRowSpace(iRow, number)) {
+            goto BAD_PIVOT;
+          }
+        }
+        // now do
+        putThis = putBase;
+        next = nextRow[iRow];
+        number = numberInRow[iRow];
+        int end = startRow[iRow] + number;
+        int saveIndex = indexColumn[startRow[next]];
+
+        //add in
+        for (jColumn = 0; jColumn < numberDoRow; jColumn++) {
+          unsigned int test = *putThis;
+
+          putThis += increment2;
+          test = 1 - ((test >> bit) & 1);
+          indexColumn[end] = saveColumn[jColumn];
+          end += test;
+        }
+        //put back next one in case zapped
+        indexColumn[startRow[next]] = saveIndex;
+        markRow[iRow] = FAC_UNSET;
+        number = end - startRow[iRow];
+        numberInRow[iRow] = number;
+        deleteLink(iRow);
+        addLink(iRow, number);
+      }
+      putBase++;
+    } /* endwhile */
+    int bit;
+
+    for (bit = 0; i < numberDoColumn; i++, bit++) {
+      unsigned int *putThis = putBase;
+      int iRow = indexL[i];
+
+      //get space
+      int number = 0;
+      int jColumn;
+
+      for (jColumn = 0; jColumn < numberDoRow; jColumn++) {
+        unsigned int test = *putThis;
+
+        putThis += increment2;
+        test = 1 - ((test >> bit) & 1);
+        number += test;
+      }
+      int next = nextRow[iRow];
+      int space;
+
+      space = startRow[next] - startRow[iRow];
+      number += numberInRow[iRow];
+      if (space < number) {
+        if (!getRowSpace(iRow, number)) {
+          goto BAD_PIVOT;
+        }
+      }
+      // now do
+      putThis = putBase;
+      next = nextRow[iRow];
+      number = numberInRow[iRow];
+      int end = startRow[iRow] + number;
+      int saveIndex;
+
+      saveIndex = indexColumn[startRow[next]];
+
+      //add in
+      for (jColumn = 0; jColumn < numberDoRow; jColumn++) {
+        unsigned int test = *putThis;
+
+        putThis += increment2;
+        test = 1 - ((test >> bit) & 1);
+
+        indexColumn[end] = saveColumn[jColumn];
+        end += test;
+      }
+      indexColumn[startRow[next]] = saveIndex;
+      markRow[iRow] = FAC_UNSET;
+      number = end - startRow[iRow];
+      numberInRow[iRow] = number;
+      deleteLink(iRow);
+      addLink(iRow, number);
+    }
+    markRow[iPivotRow] = FAC_UNSET;
+    //modify linked list for pivots
+    deleteLink(iPivotRow);
+    deleteLink(iPivotColumn + numberRows_);
+    totalElements_ += added;
+    goodPivot = true;
+    // **** UGLY UGLY UGLY
+  }
+BAD_PIVOT:
+
+  ;
+}
+#undef FAC_UNSET
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/