ruby-cbc 0.1.9 → 0.2.1

data/ext/ruby-cbc/install/include/coin/CoinAlloc.hpp

@@ -1,176 +0,0 @@
-/* $Id: CoinAlloc.hpp 1438 2011-06-09 18:14:12Z stefan $ */
-// Copyright (C) 2007, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef CoinAlloc_hpp
-#define CoinAlloc_hpp
-
-#include "CoinUtilsConfig.h"
-#include <cstdlib>
-
-#if !defined(COINUTILS_MEMPOOL_MAXPOOLED)
-#  define COINUTILS_MEMPOOL_MAXPOOLED -1
-#endif
-
-#if (COINUTILS_MEMPOOL_MAXPOOLED >= 0)
-
-#ifndef COINUTILS_MEMPOOL_ALIGNMENT
-#define COINUTILS_MEMPOOL_ALIGNMENT 16
-#endif
-
-/* Note:
-   This memory pool implementation assumes that sizeof(size_t) and
-   sizeof(void*) are both <= COINUTILS_MEMPOOL_ALIGNMENT.
-   Choosing an alignment of 4 will cause segfault on 64-bit platforms and may
-   lead to bad performance on 32-bit platforms. So 8 is a mnimum recommended
-   alignment. Probably 16 does not waste too much space either and may be even
-   better for performance. One must play with it.
-*/
-
-//#############################################################################
-
-#if (COINUTILS_MEMPOOL_ALIGNMENT == 16)
-static const std::size_t CoinAllocPtrShift = 4;
-static const std::size_t CoinAllocRoundMask = ~((std::size_t)15);
-#elif (COINUTILS_MEMPOOL_ALIGNMENT == 8)
-static const std::size_t CoinAllocPtrShift = 3;
-static const std::size_t CoinAllocRoundMask = ~((std::size_t)7);
-#else
-#error "COINUTILS_MEMPOOL_ALIGNMENT must be defined as 8 or 16 (or this code needs to be changed :-)"
-#endif
-
-//#############################################################################
-
-#ifndef COIN_MEMPOOL_SAVE_BLOCKHEADS
-#  define COIN_MEMPOOL_SAVE_BLOCKHEADS 0
-#endif
-
-//#############################################################################
-
-class CoinMempool 
-{
-private:
-#if (COIN_MEMPOOL_SAVE_BLOCKHEADS == 1)
-   char** block_heads;
-   std::size_t block_num;
-   std::size_t max_block_num;
-#endif
-#if defined(COINUTILS_PTHREADS) && (COINUTILS_PTHREAD == 1)
-  pthread_mutex_t mutex_;
-#endif
-  int last_block_size_;
-  char* first_free_;
-  const std::size_t entry_size_;
-
-private:
-  CoinMempool(const CoinMempool&);
-  CoinMempool& operator=(const CoinMempool&);
-
-private:
-  char* allocate_new_block();
-  inline void lock_mutex() {
-#if defined(COINUTILS_PTHREADS) && (COINUTILS_PTHREAD == 1)
-    pthread_mutex_lock(&mutex_);
-#endif
-  }
-  inline void unlock_mutex() {
-#if defined(COINUTILS_PTHREADS) && (COINUTILS_PTHREAD == 1)
-    pthread_mutex_unlock(&mutex_);
-#endif
-  }
-
-public:
-  CoinMempool(std::size_t size = 0);
-  ~CoinMempool();
-
-  char* alloc();
-  inline void dealloc(char *p) 
-  {
-    char** pp = (char**)p;
-    lock_mutex();
-    *pp = first_free_;
-    first_free_ = p;
-    unlock_mutex();
-  }
-};
-
-//#############################################################################
-
-/** A memory pool allocator.
-
-    If a request arrives for allocating \c n bytes then it is first
-    rounded up to the nearest multiple of \c sizeof(void*) (this is \c
-    n_roundup), then one more \c sizeof(void*) is added to this
-    number. If the result is no more than maxpooled_ then
-    the appropriate pool is used to get a chunk of memory, if not,
-    then malloc is used. In either case, the size of the allocated
-    chunk is written into the first \c sizeof(void*) bytes and a
-    pointer pointing afterwards is returned.
-*/
-
-class CoinAlloc
-{
-private:
-  CoinMempool* pool_;
-  int maxpooled_;
-public:
-  CoinAlloc();
-  ~CoinAlloc() {}
-
-  inline void* alloc(const std::size_t n)
-  {
-    if (maxpooled_ <= 0) {
-      return std::malloc(n);
-    }
-    char *p = NULL;
-    const std::size_t to_alloc =
-      ((n+COINUTILS_MEMPOOL_ALIGNMENT-1) & CoinAllocRoundMask) +
-      COINUTILS_MEMPOOL_ALIGNMENT;
-    CoinMempool* pool = NULL;
-    if (maxpooled_ > 0 && to_alloc >= (size_t)maxpooled_) {
-      p = static_cast<char*>(std::malloc(to_alloc));
-      if (p == NULL) throw std::bad_alloc();
-    } else {
-      pool = pool_ + (to_alloc >> CoinAllocPtrShift);
-      p = pool->alloc();
-    }
-    *((CoinMempool**)p) = pool;
-    return static_cast<void*>(p+COINUTILS_MEMPOOL_ALIGNMENT);
-  }
-
-  inline void dealloc(void* p)
-  {
-    if (maxpooled_ <= 0) {
-      std::free(p);
-      return;
-    }
-    if (p) {
-      char* base = static_cast<char*>(p)-COINUTILS_MEMPOOL_ALIGNMENT;
-      CoinMempool* pool = *((CoinMempool**)base);
-      if (!pool) {
-	std::free(base);
-      } else {
-	pool->dealloc(base);
-      }
-    }
-  }
-};
-
-extern CoinAlloc CoinAllocator;
-
-//#############################################################################
-
-#if defined(COINUTILS_MEMPOOL_OVERRIDE_NEW) && (COINUTILS_MEMPOOL_OVERRIDE_NEW == 1)
-void* operator new(std::size_t size) throw (std::bad_alloc);
-void* operator new[](std::size_t) throw (std::bad_alloc);
-void operator delete(void*) throw();
-void operator delete[](void*) throw();
-void* operator new(std::size_t, const std::nothrow_t&) throw();
-void* operator new[](std::size_t, const std::nothrow_t&) throw();
-void operator delete(void*, const std::nothrow_t&) throw();
-void operator delete[](void*, const std::nothrow_t&) throw();
-#endif
-
-#endif /*(COINUTILS_MEMPOOL_MAXPOOLED >= 0)*/
-#endif

data/ext/ruby-cbc/install/include/coin/CoinBuild.hpp

@@ -1,149 +0,0 @@
-/* $Id: CoinBuild.hpp 1416 2011-04-17 09:57:29Z stefan $ */
-// Copyright (C) 2005, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef CoinBuild_H
-#define CoinBuild_H
-
-
-#include "CoinPragma.hpp"
-#include "CoinTypes.hpp"
-#include "CoinFinite.hpp"
-
-
-/** 
-    In many cases it is natural to build a model by adding one row at a time.  In Coin this
-    is inefficient so this class gives some help.  An instance of CoinBuild can be built up
-    more efficiently and then added to the Clp/OsiModel in one go.
-
-    It may be more efficient to have fewer arrays and re-allocate them but this should
-    give a large gain over addRow.
-
-    I have now extended it to columns.
-
-*/
-
-class CoinBuild {
-  
-public:
-  /**@name Useful methods */
-   //@{
-   /// add a row
-   void addRow(int numberInRow, const int * columns,
-	       const double * elements, double rowLower=-COIN_DBL_MAX, 
-              double rowUpper=COIN_DBL_MAX);
-   /// add a column
-   void addColumn(int numberInColumn, const int * rows,
-                  const double * elements, 
-                  double columnLower=0.0, 
-                  double columnUpper=COIN_DBL_MAX, double objectiveValue=0.0);
-   /// add a column
-   inline void addCol(int numberInColumn, const int * rows,
-                  const double * elements, 
-                  double columnLower=0.0, 
-                  double columnUpper=COIN_DBL_MAX, double objectiveValue=0.0)
-  { addColumn(numberInColumn, rows, elements, columnLower, columnUpper, objectiveValue);}
-   /// Return number of rows or maximum found so far
-  inline int numberRows() const
-  { return (type_==0) ? numberItems_ : numberOther_;}
-   /// Return number of columns or maximum found so far
-  inline int numberColumns() const
-  { return (type_==1) ? numberItems_ : numberOther_;}
-   /// Return number of elements
-  inline CoinBigIndex numberElements() const
-  { return numberElements_;}
-  /**  Returns number of elements in a row and information in row
-   */
-  int row(int whichRow, double & rowLower, double & rowUpper,
-          const int * & indices, const double * & elements) const;
-  /**  Returns number of elements in current row and information in row
-       Used as rows may be stored in a chain
-   */
-  int currentRow(double & rowLower, double & rowUpper,
-          const int * & indices, const double * & elements) const;
-  /// Set current row
-  void setCurrentRow(int whichRow);
-  /// Returns current row number
-  int currentRow() const;
-  /**  Returns number of elements in a column and information in column
-   */
-  int column(int whichColumn, 
-             double & columnLower, double & columnUpper,double & objectiveValue,
-             const int * & indices, const double * & elements) const;
-  /**  Returns number of elements in current column and information in column
-       Used as columns may be stored in a chain
-   */
-  int currentColumn( double & columnLower, double & columnUpper,double & objectiveValue,
-          const int * & indices, const double * & elements) const;
-  /// Set current column
-  void setCurrentColumn(int whichColumn);
-  /// Returns current column number
-  int currentColumn() const;
-  /// Returns type
-  inline int type() const
-  { return type_;}
-   //@}
-
-
-  /**@name Constructors, destructor */
-   //@{
-   /** Default constructor. */
-   CoinBuild();
-   /** Constructor with type 0==for addRow, 1== for addColumn. */
-   CoinBuild(int type);
-   /** Destructor */
-   ~CoinBuild();
-   //@}
-
-   /**@name Copy method */
-   //@{
-   /** The copy constructor. */
-   CoinBuild(const CoinBuild&);
-  /// =
-   CoinBuild& operator=(const CoinBuild&);
-   //@}
-private:
-  /// Set current 
-  void setMutableCurrent(int which) const;
-   /// add a item
-   void addItem(int numberInItem, const int * indices,
-                  const double * elements, 
-                  double itemLower, 
-                  double itemUpper, double objectiveValue);
-  /**  Returns number of elements in a item and information in item
-   */
-  int item(int whichItem, 
-             double & itemLower, double & itemUpper,double & objectiveValue,
-             const int * & indices, const double * & elements) const;
-  /**  Returns number of elements in current item and information in item
-       Used as items may be stored in a chain
-   */
-  int currentItem( double & itemLower, double & itemUpper,double & objectiveValue,
-          const int * & indices, const double * & elements) const;
-  /// Set current item
-  void setCurrentItem(int whichItem);
-  /// Returns current item number
-  int currentItem() const;
-   
-private:
-  /**@name Data members */
-   //@{
-  /// Current number of items
-  int numberItems_;
-  /// Current number of other dimension i.e. Columns if addRow (i.e. max)
-  int numberOther_;
-  /// Current number of elements
-  CoinBigIndex numberElements_;
-  /// Current item pointer
-  mutable double * currentItem_;
-  /// First item pointer
-  double * firstItem_;
-  /// Last item pointer
-  double * lastItem_;
-  /// Type of build - 0 for row, 1 for column, -1 unset
-  int type_;
-   //@}
-};
-
-#endif

data/ext/ruby-cbc/install/include/coin/CoinDenseFactorization.hpp

@@ -1,419 +0,0 @@
-/* $Id: CoinDenseFactorization.hpp 1759 2014-11-18 11:07:23Z forrest $ */
-// Copyright (C) 2008, 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 CoinDenseFactorization_H
-#define CoinDenseFactorization_H
-
-#include <iostream>
-#include <string>
-#include <cassert>
-#include "CoinTypes.hpp"
-#include "CoinIndexedVector.hpp"
-#include "CoinFactorization.hpp"
-#if COIN_FACTORIZATION_DENSE_CODE == 2
-#undef COIN_FACTORIZATION_DENSE_CODE
-#endif
-class CoinPackedMatrix;
-/// Abstract base class which also has some scalars so can be used from Dense or Simp
-class CoinOtherFactorization {
-
-public:
-
-  /**@name Constructors and destructor and copy */
-  //@{
-  /// Default constructor
-  CoinOtherFactorization (  );
-  /// Copy constructor 
-  CoinOtherFactorization ( const CoinOtherFactorization &other);
-  
-  /// Destructor
-  virtual ~CoinOtherFactorization (  );
-  /// = copy
-  CoinOtherFactorization & operator = ( const CoinOtherFactorization & other );
- 
-  /// Clone
-  virtual CoinOtherFactorization * clone() const = 0;
-  //@}
-
-  /**@name general stuff such as 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; }
-  /// Set number of Rows after factorization
-  inline void setNumberRows(int value)
-  { numberRows_ = value; }
-  /// Number of Rows after factorization
-  inline int numberRows (  ) const {
-    return numberRows_;
-  }
-  /// Total number of columns in factorization
-  inline int numberColumns (  ) const {
-    return numberColumns_;
-  }
-  /// Number of good columns in factorization
-  inline int numberGoodColumns (  ) const {
-    return numberGoodU_;
-  }
-  /// 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_;}
-  /// Maximum number of pivots between factorizations
-  inline int maximumPivots (  ) const {
-    return maximumPivots_ ;
-  }
-  /// Set maximum pivots
-  virtual void maximumPivots (  int 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 array to put basis elements in
-  virtual CoinFactorizationDouble * elements() const;
-  /// Returns pivot row 
-  virtual int * pivotRow() const;
-  /// Returns work area
-  virtual CoinFactorizationDouble * workArea() const;
-  /// Returns int work area
-  virtual int * intWorkArea() const;
-  /// Number of entries in each row
-  virtual int * numberInRow() const;
-  /// Number of entries in each column
-  virtual int * numberInColumn() const;
-  /// Returns array to put basis starts in
-  virtual CoinBigIndex * starts() const;
-  /// Returns permute back
-  virtual int * permuteBack() const;
-  /** Get solve mode e.g. 0 C++ code, 1 Lapack, 2 choose
-      If 4 set then values pass
-      if 8 set then has iterated
-  */
-  inline int solveMode() const
-  { return solveMode_ ;}
-  /** Set solve mode e.g. 0 C++ code, 1 Lapack, 2 choose
-      If 4 set then values pass
-      if 8 set then has iterated
-  */
-  inline void setSolveMode(int value)
-  { solveMode_ = value;}
-  /// Returns true if wants tableauColumn in replaceColumn
-  virtual bool wantsTableauColumn() const;
-  /** Useful information for factorization
-      0 - iteration number
-      whereFrom is 0 for factorize and 1 for replaceColumn
-  */
-  virtual void setUsefulInformation(const int * info,int whereFrom);
-  /// Get rid of all memory
-  virtual void clearArrays() {}
-  //@}
-  /**@name virtual general stuff such as permutation */
-  //@{ 
-  /// Returns array to put basis indices in
-  virtual int * indices() const  = 0;
-  /// Returns permute in
-  virtual int * permute() const = 0;
-  /// Total number of elements in factorization
-  virtual int numberElements (  ) const = 0;
-  //@}
-  /**@name Do factorization - public */
-  //@{
-  /// Gets space for a factorization
-  virtual void getAreas ( int numberRows,
-		  int numberColumns,
-		  CoinBigIndex maximumL,
-		  CoinBigIndex maximumU ) = 0;
-  
-  /// PreProcesses column ordered copy of basis
-  virtual void preProcess ( ) = 0;
-  /** Does most of factorization returning status
-      0 - OK
-      -99 - needs more memory
-      -1 - singular - use numberGoodColumns and redo
-  */
-  virtual int factor ( ) = 0;
-  /// Does post processing on valid factorization - putting variables on correct rows
-  virtual void postProcess(const int * sequence, int * pivotVariable) = 0;
-  /// Makes a non-singular basis by replacing variables
-  virtual void makeNonSingular(int * sequence, int numberColumns) = 0;
-  //@}
-
-  /**@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 */
-  virtual int replaceColumn ( CoinIndexedVector * regionSparse,
-		      int pivotRow,
-		      double pivotCheck ,
-			      bool checkBeforeModifying=false,
-			      double acceptablePivot=1.0e-8)=0;
-  //@}
-
-  /**@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
-  */
-  virtual int updateColumnFT ( CoinIndexedVector * regionSparse,
-			       CoinIndexedVector * regionSparse2,
-			       bool noPermute=false) = 0;
-  /** This version has same effect as above with FTUpdate==false
-      so number returned is always >=0 */
-  virtual int updateColumn ( CoinIndexedVector * regionSparse,
-		     CoinIndexedVector * regionSparse2,
-		     bool noPermute=false) const = 0;
-    /// does FTRAN on two columns
-    virtual int updateTwoColumnsFT(CoinIndexedVector * regionSparse1,
-			   CoinIndexedVector * regionSparse2,
-			   CoinIndexedVector * regionSparse3,
-			   bool noPermute=false) = 0;
-  /** 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
-  */
-  virtual int updateColumnTranspose ( CoinIndexedVector * regionSparse,
-			      CoinIndexedVector * regionSparse2) const = 0;
-  //@}
-
-////////////////// 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
-  /// Relax check on accuracy in replaceColumn
-  double relaxCheck_;
-  /// Number of elements after factorization
-  CoinBigIndex factorElements_;
-  /// Number of Rows in factorization
-  int numberRows_;
-  /// Number of Columns in factorization
-  int numberColumns_;
-  /// Number factorized in U (not row singletons)
-  int numberGoodU_;
-  /// Maximum number of pivots before factorization
-  int maximumPivots_;
-  /// Number pivots since last factorization
-  int numberPivots_;
-  /// Status of factorization
-  int status_;
-  /// Maximum rows ever (i.e. use to copy arrays etc)
-  int maximumRows_;
-  /// Maximum length of iterating area
-  CoinBigIndex maximumSpace_;
-  /// Pivot row 
-  int * pivotRow_;
-  /** Elements of factorization and updates
-      length is maxR*maxR+maxSpace
-      will always be long enough so can have nR*nR ints in maxSpace 
-  */
-  CoinFactorizationDouble * elements_;
-  /// Work area of numberRows_ 
-  CoinFactorizationDouble * workArea_;
-  /** Solve mode e.g. 0 C++ code, 1 Lapack, 2 choose
-      If 4 set then values pass
-      if 8 set then has iterated
-  */
-  int solveMode_;
-  //@}
-};
-/** This deals with Factorization and Updates
-    This is a simple dense version so other people can write a better one
-
-    I am assuming that 32 bits is enough for number of rows or columns, but CoinBigIndex
-    may be redefined to get 64 bits.
- */
-
-
-
-class CoinDenseFactorization : public CoinOtherFactorization {
-   friend void CoinDenseFactorizationUnitTest( const std::string & mpsDir );
-
-public:
-
-  /**@name Constructors and destructor and copy */
-  //@{
-  /// Default constructor
-  CoinDenseFactorization (  );
-  /// Copy constructor 
-  CoinDenseFactorization ( const CoinDenseFactorization &other);
-  
-  /// Destructor
-  virtual ~CoinDenseFactorization (  );
-  /// = copy
-  CoinDenseFactorization & operator = ( const CoinDenseFactorization & other );
-  /// Clone
-  virtual CoinOtherFactorization * clone() const ;
-  //@}
-
-  /**@name Do factorization - public */
-  //@{
-  /// Gets space for a factorization
-  virtual void getAreas ( int numberRows,
-		  int numberColumns,
-		  CoinBigIndex maximumL,
-		  CoinBigIndex maximumU );
-  
-  /// PreProcesses column ordered copy of basis
-  virtual void preProcess ( );
-  /** Does most of factorization returning status
-      0 - OK
-      -99 - needs more memory
-      -1 - singular - use numberGoodColumns and redo
-  */
-  virtual int factor ( );
-  /// Does post processing on valid factorization - putting variables on correct rows
-  virtual void postProcess(const int * sequence, int * pivotVariable);
-  /// Makes a non-singular basis by replacing variables
-  virtual void makeNonSingular(int * sequence, int numberColumns);
-  //@}
-
-  /**@name general stuff such as number of elements */
-  //@{ 
-  /// Total number of elements in factorization
-  virtual inline int numberElements (  ) const {
-    return numberRows_*(numberColumns_+numberPivots_);
-  }
-  /// Returns maximum absolute value in factorization
-  double maximumCoefficient() const;
-  //@}
-
-  /**@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 */
-  virtual int replaceColumn ( CoinIndexedVector * regionSparse,
-		      int pivotRow,
-		      double pivotCheck ,
-			      bool checkBeforeModifying=false,
-			      double acceptablePivot=1.0e-8);
-  //@}
-
-  /**@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
-  */
-  virtual inline int updateColumnFT ( CoinIndexedVector * regionSparse,
-				      CoinIndexedVector * regionSparse2,
-				      bool = false)
-  { return updateColumn(regionSparse,regionSparse2);}
-  /** This version has same effect as above with FTUpdate==false
-      so number returned is always >=0 */
-  virtual int updateColumn ( CoinIndexedVector * regionSparse,
-		     CoinIndexedVector * regionSparse2,
-		     bool noPermute=false) const;
-    /// does FTRAN on two columns
-    virtual int updateTwoColumnsFT(CoinIndexedVector * regionSparse1,
-			   CoinIndexedVector * regionSparse2,
-			   CoinIndexedVector * regionSparse3,
-			   bool noPermute=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
-  */
-  virtual int updateColumnTranspose ( CoinIndexedVector * regionSparse,
-			      CoinIndexedVector * regionSparse2) const;
-  //@}
-  /// *** Below this user may not want to know about
-
-  /**@name various uses of factorization
-   which user may not want to know about (left over from my LP code) */
-  //@{
-  /// Get rid of all memory
-  inline void clearArrays()
-  { gutsOfDestructor();}
-  /// Returns array to put basis indices in
-  virtual inline int * indices() const
-  { return reinterpret_cast<int *> (elements_+numberRows_*numberRows_);}
-  /// Returns permute in
-  virtual inline int * permute() const
-  { return NULL;/*pivotRow_*/;}
-  //@}
-
-  /// The real work of desstructor 
-  void gutsOfDestructor();
-  /// The real work of constructor
-  void gutsOfInitialize();
-  /// The real work of copy
-  void gutsOfCopy(const CoinDenseFactorization &other);
-
-  //@}
-protected:
-  /** Returns accuracy status of replaceColumn
-      returns 0=OK, 1=Probably OK, 2=singular */
-  int checkPivot(double saveFromU, double oldPivot) const;
-////////////////// data //////////////////
-protected:
-
-  /**@name data */
-  //@{
-  //@}
-};
-#endif